Simuler des défauts HTTP

Traduction Bêta Non Officielle

Cette page a été traduite par PageTurner AI (bêta). Non approuvée officiellement par le projet. Vous avez trouvé une erreur ? Signaler un problème →

Ce document explique comment simuler des défauts HTTP en créant des expériences HTTPChaos dans Chaos Mesh.

Présentation d'HTTPChaos

HTTPChaos est un type de défaut fourni par Chaos Mesh. En créant des expériences HTTPChaos, vous pouvez simuler des scénarios de défaillance lors du traitement des requêtes et réponses HTTP. Actuellement, HTTPChaos prend en charge les types de défauts suivants :

• abort : interrompt la connexion

• delay : injecte une latence dans la requête ou la réponse

• replace : remplace une partie du contenu dans les messages HTTP

• patch : ajoute du contenu supplémentaire aux messages HTTP

HTTPChaos permet de combiner différents types de défauts. Si vous configurez plusieurs types simultanément lors de la création d'expériences, l'ordre d'injection au démarrage sera : abort -> delay -> replace -> patch. Si le défaut abort provoque un court-circuit, la connexion sera interrompue immédiatement.

Pour une description détaillée de la configuration HTTPChaos, consultez la section Description des champs ci-dessous.

Notes importantes

Avant d'injecter des défauts avec HTTPChaos, prenez en compte les points suivants :

• Aucun gestionnaire de contrôle Chaos Mesh ne doit s'exécuter sur le Pod cible.

• Les règles affectent simultanément clients et serveurs dans le Pod. Pour cibler un seul côté, référez-vous à la section spécifier un côté.

• Désactivez les accès HTTPS car l'injection sur ces connexions n'est actuellement pas supportée.

• Pour que l'injection HTTPChaos soit effective, le client doit éviter de réutiliser les sockets TCP. Les requêtes HTTP envoyées avant l'injection via un socket existant ne seront pas affectées.

• Utilisez les requêtes non-idempotentes (comme la plupart des POST) avec prudence en production. Si elles sont employées, le service cible pourrait ne pas revenir à un état normal après l'injection malgré des tentatives répétées.

Créer des expériences avec Chaos Dashboard

1. Ouvrez Chaos Dashboard et cliquez sur NEW EXPERIMENT pour créer une nouvelle expérience :

   

   Créer une expérience

2. Dans la zone Choose a Target, sélectionnez HTTP FAULT et choisissez un comportement spécifique (par exemple RESPONSE ABORT). Complétez ensuite les configurations :

   

   Créer un défaut HTTP

3. Soumettez l'expérience.

   Dans cet exemple, vous avez configuré l'injection du défaut "Response abort" sur toutes les requêtes du port 80.

Créer des expériences via des fichiers YAML

Chaos Mesh permet également de créer des expériences HTTPChaos via des fichiers de configuration YAML. Vous pouvez y simuler un seul type de défaut HTTP ou une combinaison de plusieurs types.

Exemple avec abort

1. Écrivez la configuration expérimentale dans un fichier http-abort-failure.yaml comme dans cet exemple :

   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

   Avec cette configuration, Chaos Mesh injectera le défaut abort dans le Pod spécifié pendant 5 minutes. Les requêtes GET envoyées via le port 80 sur le chemin /api seront interrompues.

2. Après avoir préparé le fichier, utilisez kubectl pour lancer l'expérience :

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

Exemple de combinaisons de fautes

1. Écrivez la configuration expérimentale dans le fichier http-failure.yaml comme dans l'exemple ci-dessous :

   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

   D'après cet exemple de configuration, Chaos Mesh injectera successivement les fautes delay, replace et patch.

2. Une fois le fichier de configuration préparé, utilisez kubectl pour créer l'expérience :

   kubectl apply -f ./http-failure.yaml

Description des champs

Description des champs communs

Les champs communs sont significatifs lorsque la target de l'injection de faute est Request ou Response.

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"

note

• Lors de la création d'expériences avec des fichiers YAML, replace.body doit être l'encodage base64 du contenu de remplacement.

• Lors de la création d'expériences via l'API Kubernetes, il n'est pas nécessaire d'encoder le contenu de remplacement. Convertissez-le simplement en []byte et placez-le dans le champ httpchaos.Spec.Replace.Body. Voici un exemple :

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

Description des champs liés à target

Champs liés à Request

Le champ Request est significatif lorsque la target est définie sur Request pendant l'injection de faute.

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]

Champs liés à Respond

Le champ Response est significatif lorsque la target est définie sur Response pendant l'injection de faute.

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

Spécifier le côté affecté

Par défaut, les règles affectent à la fois les clients et les serveurs dans le Pod, mais vous pouvez cibler un seul côté en sélectionnant les en-têtes de requête.

Cette section fournit des exemples pour spécifier le côté affecté. Vous pouvez adapter le sélecteur d'en-tête en fonction de vos cas particuliers.

Côté client

Pour injecter des fautes dans les clients du Pod sans affecter les serveurs, sélectionnez la requête/réponse via l'en-tête Host de la requête.

Par exemple, pour interrompre toutes les requêtes vers http://example.com/, appliquez la configuration YAML suivante :

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

Côté serveur

Pour injecter des fautes dans les serveurs du Pod sans affecter les clients, sélectionnez également la requête/réponse via l'en-tête Host de la requête.

Par exemple, pour interrompre toutes les requêtes vers votre serveur derrière le service nginx.nginx.svc, appliquez la configuration YAML suivante :

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

Dans d'autres cas, notamment lors de l'injection de requêtes entrantes externes, vous pouvez sélectionner la requête/réponse via l'en-tête X-Forwarded-Host.

Par exemple, pour interrompre toutes les requêtes vers votre serveur derrière la passerelle publique nginx.host.org, appliquez la configuration YAML suivante :

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

Pour injecter des fautes dans des connexions basées sur TLS, utilisez le mode TLS. Notre proxy joue alors un rôle d'intermédiaire : il doit agir comme un serveur distant avec une autorité de certification (CA) de confiance, tout en étant un client qui fait confiance au serveur avec une CA spécifique.

Dans les données secrètes ci-dessous, l'utilisateur doit créer ses propres clés TLS, CA et CRT.

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

Si un utilisateur doit créer un nouveau serveur TLS et injecter la connexion, il doit :

1. Créer sa clé privée d'autorité de certification (CA) racine et son certificat CA :

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

2. Créer sa demande de signature de certificat (CSR) pour le serveur :

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

3. Écrire un fichier d'extension server.ext pour le serveur, par exemple :

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

4. Générer le certificat du serveur :

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

5. Ajouter le certificat CA ca.crt au client.

6. Placer server.key, server.crt et ca.crt dans un secret Kubernetes et le fournir au mode TLS.

Si vous devez injecter un client, vous devez agir comme proxy du chaos HTTP à la manière du serveur distant. Modifiez simplement le fichier server.ext ci-dessus pour spécifier le domaine concerné.

Exemple :

subjectAltName = @alt_names

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

Débogage local

Si vous n'êtes pas sûr des effets d'une injection de faute, vous pouvez également tester les fonctionnalités localement avec rs-tproxy. Chaos Mesh fournit également HTTPChaos via chaos-tproxy.