HTTP-Fehler simulieren

Inoffizielle Beta-Übersetzung

Diese Seite wurde von PageTurner AI übersetzt (Beta). Nicht offiziell vom Projekt unterstützt. Fehler gefunden? Problem melden →

Dieses Dokument erklärt, wie Sie HTTP-Fehler durch das Erstellen von HTTPChaos-Experimenten in Chaos Mesh simulieren können.

Einführung in HTTPChaos

HTTPChaos ist eine Fehlerart, die von Chaos Mesh bereitgestellt wird. Durch das Erstellen von HTTPChaos-Experimenten können Sie Fehlerszenarien während der HTTP-Anfrage- und Antwortverarbeitung simulieren. Aktuell unterstützt HTTPChaos folgende Fehlertypen:

• abort: unterbricht die Verbindung

• delay: fügt Latenz in Anfragen oder Antworten ein

• replace: ersetzt Teile des Inhalts in HTTP-Anfrage- oder Antwortnachrichten

• patch: fügt zusätzliche Inhalte zu HTTP-Anfrage- oder Antwortnachrichten hinzu

HTTPChaos unterstützt Kombinationen verschiedener Fehlertypen. Wenn Sie beim Erstellen von HTTPChaos-Experimenten mehrere HTTP-Fehlertypen gleichzeitig konfigurieren, erfolgt die Fehlerinjektion in dieser Reihenfolge: abort -> delay -> replace -> patch. Wenn der abort-Fehler zu Kurzschlüssen führt, wird die Verbindung sofort unterbrochen.

Eine detaillierte Beschreibung der HTTPChaos-Konfiguration finden Sie im Abschnitt Feldbeschreibung weiter unten.

Hinweise

Beachten Sie folgende Punkte, bevor Sie die von HTTPChaos unterstützten Fehler injizieren:

• Auf dem Ziel-Pod läuft kein Control Manager von Chaos Mesh.

• Die Regeln wirken sich auf Clients und Server im Pod aus. Wenn Sie nur eine Seite beeinflussen möchten, lesen Sie den Abschnitt Seite festlegen.

• HTTPS-Zugriffe sollten deaktiviert werden, da das Injizieren von HTTPS-Verbindungen derzeit nicht unterstützt wird.

• Damit die HTTPChaos-Injektion wirksam wird, sollte der Client die Wiederverwendung von TCP-Sockets vermeiden. HTTPChaos beeinflusst nämlich keine HTTP-Anfragen, die vor der Fehlerinjektion über TCP-Sockets gesendet wurden.

• Verwenden Sie nicht-idempotente Anfragen (wie die meisten POST-Anfragen) in Produktionsumgebungen mit Vorsicht. Bei solchen Anfragen kann der Zielservice nach der Fehlerinjektion durch wiederholte Anfragen möglicherweise nicht zum Normalzustand zurückkehren.

Experimente mit Chaos Dashboard erstellen

1. Öffnen Sie Chaos Dashboard und klicken Sie auf NEW EXPERIMENT, um ein neues Experiment zu erstellen:

   

   Experiment erstellen

2. Wählen Sie im Bereich Choose a Target die Option HTTP FAULT und selektieren Sie ein spezifisches Verhalten wie RESPONSE ABORT. Tragen Sie dann die konkreten Konfigurationen ein.

   

   HTTP-Fehler erstellen

3. Experiment übermitteln.

   Im obigen Beispiel haben Sie konfiguriert, den "Response Abort"-Fehler in alle Anfragen an Port 80 zu injizieren.

Experimenterstellung mit YAML-Dateien

Chaos Mesh unterstützt auch die Erstellung von HTTPChaos-Experimenten über YAML-Konfigurationsdateien. In einer YAML-Datei können Sie entweder einen einzelnen HTTP-Fehlertyp oder Kombinationen verschiedener HTTP-Fehlertypen simulieren.

Beispiel für abort

1. Schreiben Sie die Experimentkonfiguration wie im folgenden Beispiel in die Datei http-abort-failure.yaml:

   apiVersion: chaos-mesh.org/v1alpha1
   kind: HTTPChaos
   metadata:
     name: test-http-chaos
   spec:
     mode: all
     selector:
       labelSelectors:
         app: nginx
     target: Request
     port: 80
     method: GET
     path: /api
     abort: true
     duration: 5m

   Basierend auf diesem Konfigurationsbeispiel injiziert Chaos Mesh den abort-Fehler für 5 Minuten in den angegebenen Pod. Während der Fehlerinjektion werden GET-Anfragen an Port 80 im Pfad /api des Ziel-Pods unterbrochen.

2. Nachdem die Konfigurationsdatei vorbereitet ist, erstellen Sie das Experiment mit kubectl:

   kubectl apply -f ./http-abort-failure.yaml

Beispiel für Fehlerkombinationen

1. Schreiben Sie die Experimentkonfiguration wie im folgenden Beispiel in die Datei http-failure.yaml:

   apiVersion: chaos-mesh.org/v1alpha1
   kind: HTTPChaos
   metadata:
     name: test-http-chaos
   spec:
     mode: all
     selector:
       labelSelectors:
         app: nginx
     target: Request
     port: 80
     method: GET
     path: /api/*
     delay: 10s
     replace:
       path: /api/v2/
       method: DELETE
     patch:
       headers:
         - ['Token', '<one token>']
         - ['Token', '<another token>']
       body:
         type: JSON
         value: '{"foo": "bar"}'
     duration: 5m

   Basierend auf diesem Konfigurationsbeispiel injiziert Chaos Mesh nacheinander die Fehler delay, replace und patch.

2. Nachdem die Konfigurationsdatei vorbereitet ist, verwenden Sie kubectl, um das Experiment zu erstellen:

   kubectl apply -f ./http-failure.yaml

Feldbeschreibung

Beschreibung der allgemeinen Felder

Allgemeine Felder sind relevant, wenn das target der Fehlerinjektion Request oder Response ist.

Parameter	Type	Description	Default value	Required	Example
mode	string	Specifies the mode of the experiment. The mode options include one (selecting a random pod), all (selecting all eligible pods), fixed (selecting a specified number of eligible pods), fixed-percent (selecting a specified percentage of Pods from the eligible pods), and random-max-percent (selecting the maximum percentage of Pods from the eligible pods).		yes	one
value	string	Provides parameters for the mode configuration depending on the value of mode.		no	1
target	string	Specifies whether the target of fault injuection is Request or Response. The target-related fields should be configured at the same time.		yes	Request
port	int32	The TCP port that the target service listens on.		yes	80
path	string	The URI path of the target request. Supports Matching wildcards.	Takes effect on all paths by default.	no	/api/*
method	string	The HTTP method of the target request method.	Takes effect for all methods by default.	no	GET
request_headers	map[string]string	Matches request headers to the target service.	Takes effect for all requests by default.	no	Content-Type: application/json
abort	bool	Indicates whether to inject the fault that interrupts the connection.	false	no	true
delay	string	Specifies the time for a latency fault.	0	no	10s
replace.headers	map[string]string	Specifies the key pair used to replace the request headers or response headers.		no	Content-Type: application/xml
replace.body	[]byte	Specifies request body or response body to replace the fault (Base64 encoded).		no	eyJmb28iOiAiYmFyIn0K
patch.headers	[][]string	Specifies the attached key pair of the request headers or response headers with patch faults.		no	- [Set-Cookie, one cookie]
patch.body.type	string	Specifies the type of patch faults of the request body or response body. Currently, it only supports JSON.		no	JSON
patch.body.value	string	Specifies the fault of the request body or response body with patch faults.		no	{"foo": "bar"}
duration	string	Specifies the duration of a specific experiment.		yes	30s
scheduler	string	Specifies the scheduling rules for the time of a specific experiment.		no	5 * * * *
tls.secretName	string	SecretName represents the name of required secret resource. The secrete must combined with data {"tls.certName":cert, "tls.KeyName":key, "tls.caName":ca}		no	"http-tls-scr"
tls.secretNamespace	string	SecretNamespace represents the namespace of required secret resource,should be the same with deployment/chaos-controller-manager in most cases		no	"chaos-mesh"
tls.certName	string	CertName represents the data name of cert file in secret, tls.crt for example		no	"tls.crt"
tls.KeyName	string	KeyName represents the data name of key file in secret, tls.key for example		no	"tls.key"
tls.caName	string	CAName represents the data name of ca file in secret, ca.crt for example		no	"ca.crt"

Hinweis

• Beim Erstellen von Experimenten mit YAML-Dateien muss replace.body die Base64-Kodierung des Ersetzungsinhalts sein.

• Beim Erstellen von Experimenten mit der Kubernetes-API muss der Ersetzungsinhalt nicht kodiert werden. Konvertieren Sie ihn einfach in []byte und fügen Sie ihn in das Feld httpchaos.Spec.Replace.Body ein. Hier ist ein Beispiel:

httpchaos.Spec.Replace.Body = []byte(`{"foo": "bar"}`)

Beschreibung der target-bezogenen Felder

Request-bezogene Felder

Das Feld Request ist relevant, wenn das target während der Fehlerinjektion auf Request gesetzt ist.

Parameter	Type	Description	Default value	Required	Example
replace.path	string	Specifies the URI path used to replace content.		no	/api/v2/
replace.method	string	Specifies the replaced content of the HTTP request method.		no	DELETE
replace.queries	map[string]string	Specifies the replaced key pair of the URI query.		no	foo: bar
patch.queries	[][]string	Specifies the attached key pair of the URI query with patch faults.		no	- [foo, bar]

Respond-bezogene Felder

Das Feld Response ist relevant, wenn das target während der Fehlerinjektion auf Response gesetzt ist.

Parameter	Type	Description	Default value	Required	Example
code	int32	Specifies the status code responded by target.	Takes effect for all status codes by default.	no	200
response_headers	map[string]string	Matches request headers to target.	Takes effect for all responses by default.	no	Content-Type: application/json
replace.code	int32	Specifies the replaced content of the response status code.		no	404

Betroffene Seite festlegen

Standardmäßig betreffen die Regeln sowohl Clients als auch Server im Pod. Sie können jedoch nur eine Seite beeinflussen, indem Sie die Anfrage-Header auswählen.

Dieser Abschnitt enthält Beispiele zur Festlegung der betroffenen Seite. Sie können den Header-Selektor in den Regeln an Ihre speziellen Anwendungsfälle anpassen.

Client-Seite

Um Fehler nur in Clients innerhalb des Pods zu injizieren (ohne Server zu beeinflussen), können Sie Anfragen/Antworten über den Host-Header in der Anfrage auswählen.

Wenn Sie beispielsweise alle Anfragen an http://example.com/ unterbrechen möchten, können Sie folgende YAML-Konfiguration verwenden:

apiVersion: chaos-mesh.org/v1alpha1
kind: HTTPChaos
metadata:
  name: test-http-client
spec:
  mode: all
  selector:
    labelSelectors:
      app: some-http-client
  target: Request
  port: 80
  path: '*'
  request_headers:
    Host: 'example.com'
  abort: true

Server-Seite

Um Fehler nur in Servern innerhalb des Pods zu injizieren (ohne Clients zu beeinflussen), können Sie ebenfalls Anfragen/Antworten über den Host-Header in der Anfrage auswählen.

Wenn Sie beispielsweise alle Anfragen an Ihren Server hinter dem Service nginx.nginx.svc unterbrechen möchten, können Sie folgende YAML-Konfiguration verwenden:

apiVersion: chaos-mesh.org/v1alpha1
kind: HTTPChaos
metadata:
  name: test-http-server
spec:
  mode: all
  selector:
    labelSelectors:
      app: nginx
  target: Request
  port: 80
  path: '*'
  request_headers:
    Host: 'nginx.nginx.svc'
  abort: true

In anderen Fällen, insbesondere bei der Injektion eingehender Anfragen von extern, können Sie Anfragen/Antworten über den X-Forwarded-Host-Header in der Anfrage auswählen.

Wenn Sie beispielsweise alle Anfragen an Ihren Server hinter einem öffentlichen Gateway nginx.host.org unterbrechen möchten, können Sie folgende YAML-Konfiguration verwenden:

apiVersion: chaos-mesh.org/v1alpha1
kind: HTTPChaos
metadata:
  name: test-http-server
spec:
  mode: all
  selector:
    labelSelectors:
      app: nginx
  target: Request
  port: 80
  path: '*'
  request_headers:
    X-Forwarded-Host: 'nginx.host.org'
  abort: true

TLS

Um Fehler in TLS-basierten Verbindungen zu injizieren, muss der TLS-Modus verwendet werden. Unser Proxy übernimmt hier eine Vermittlerrolle. Im TLS-Modus muss der Proxy sowohl als Server mit vertrauenswürdiger CA als auch als Client agieren, der dem Server mit eigener CA vertraut.

Daher müssen Benutzer in den Secret-Daten ihre eigenen TLS-Schlüssel, CA-Zertifikate und CRTs erstellen.

{
  "tls.certName":cert,
  "tls.KeyName":key,
  "tls.caName":ca
}

Wenn Benutzer einen neuen TLS-Server erstellen und die Verbindung dorthin injizieren möchten, sollten sie folgende Schritte durchführen:

1. Eigenen privaten Root-CA-Schlüssel und Root-CA-Zertifikat erstellen:

   openssl req -newkey rsa:4096  -x509  -sha512  -days 365 -nodes -out ca.crt -keyout ca.key

2. Certificate Signing Request (CSR) für ihren Server erstellen:

   openssl genrsa -out server.key 2048
   openssl req -new -key server.key -out server.csr

3. Erweiterungsdatei server.ext für den Server anlegen, z.B.:

   authorityKeyIdentifier=keyid,issuer
   basicConstraints=CA:FALSE
   keyUsage = digitalSignature, nonRepudiation, keyEncipherment, dataEncipherment
   subjectAltName = @alt_names
   
   [alt_names]
   IP.1 = X.X.X.X

4. Serverzertifikat generieren:

   openssl x509 -req -in server.csr -CA ca.crt -CAkey ca.key -CAcreateserial -out server.crt -days 365 -sha256 -extfile server.ext

5. CA-Zertifikat ca.crt zum Client hinzufügen.

6. server.key, server.crt und ca.crt in ein Secret ablegen und dem TLS-Modus zuweisen.

Falls Benutzer einen Client injizieren möchten, sollten sie den Proxy von HTTP Chaos wie den entfernten Server agieren lassen. Passen Sie dazu einfach die oben genannte server.ext auf die spezifische Domain an.

Beispiel:

subjectAltName = @alt_names

[alt_names]
DNS.1 = *.domain.com
IP.1 = xxx.xxx.xxx.xxx

Lokales Debugging

Wenn Sie sich über die Auswirkungen bestimmter Fehlerinjektionen nicht sicher sind, können Sie die entsprechenden Funktionen auch lokal mit rs-tproxy testen. Chaos Mesh stellt HTTP Chaos auch über chaos-tproxy bereit.