Container Service for Kubernetes:Utiliser un contrôleur Ingress pour dupliquer le trafic réseau

Prérequis

Avant de commencer, assurez-vous de disposer des éléments suivants :

• Deux clusters ACK : l'un pour la production (K8s Product Cluster) et l'autre pour la préproduction (K8s Stage Cluster). Consultez Créer un cluster ACK géré.

• Le contrôleur NGINX Ingress v1.2.1 ou version ultérieure installé. Consultez Gérer le contrôleur NGINX Ingress.

• kubectl configuré avec le fichier kubeconfig de chaque cluster. Consultez Se connecter aux clusters ACK à l'aide de kubectl.

Cas d'utilisation

• Tests de charge avant mise en production : Dupliquez le trafic de production vers la préproduction pour simuler des charges réelles, y compris un trafic anormal, avant le déploiement d'un nouveau système. Vous obtenez ainsi un profil de charge plus précis qu'avec des benchmarks synthétiques.

• Diagnostic des problèmes en production : Si vous ne parvenez pas à identifier un goulot d'étranglement en production, dupliquez le trafic vers la préproduction pour reproduire et analyser l'incident en toute sécurité.

Fonctionnement

Toutes les requêtes destinées à example.com sur le cluster de production sont répliquées et envoyées à example1.com sur le cluster de préproduction. Ce dernier reçoit le trafic dupliqué sans aucune modification du routage du cluster de production.

Le contrôleur NGINX Ingress utilise l'annotation nginx.ingress.kubernetes.io/mirror-target pour dupliquer les requêtes vers une destination spécifiée. L'annotation mirror-host permet de définir la valeur exacte de l'en-tête Host pour la requête dupliquée.

Annotations de duplication

Étape 1 : Déployer une application dans le cluster de préproduction

Déployez une application réceptrice dans K8s Stage Cluster. Ce déploiement fournit une destination au trafic dupliqué. Ne modifiez aucune configuration du cluster de production lors de cette étape.

1. Créez le fichier my-nginx.yaml avec le contenu suivant :

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: nginx-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: nginx
     template:
       metadata:
         labels:
           app: nginx
       spec:
         containers:
         - image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
           imagePullPolicy: Always
           name: nginx
           ports:
           - containerPort: 80
             protocol: TCP
         restartPolicy: Always
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: nginx-service
   spec:
     ports:
     - port: 80
       protocol: TCP
       targetPort: 80
     selector:
       app: nginx
     type: NodePort
   ---
   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: nginx-ingress
   spec:
     rules:
     - host: example1.com
       http:
         paths:
         - path: /
           backend:
             service:
               name: nginx-service
               port:
                 number: 80
           pathType: ImplementationSpecific

2. Déployez l'application :

   kubectl apply -f my-nginx.yaml

3. Vérifiez qu'une adresse IP externe est bien attribuée à l'Ingress :

   kubectl get ing nginx-ingress

   Résultat attendu :

   NAME            HOSTS         ADDRESS       PORTS   AGE
   nginx-ingress   example1.com  47.**.**.53   80      8m

   Notez la valeur ADDRESS (47.**.**.53). Vous utiliserez cette adresse IP pour configurer la duplication du trafic à l'étape 2.

4. Confirmez que l'application de préproduction est accessible :

   curl http://example1.com

Étape 2 : Configurer la duplication du trafic dans le cluster de production

Déployez l'application et l'Ingress dans K8s Product Cluster, puis ajoutez les annotations de duplication pour rediriger une copie de tout le trafic vers le cluster de préproduction.

1. Créez le fichier my-nginx.yaml avec le contenu suivant :

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: nginx-deployment
   spec:
     replicas: 1
     selector:
       matchLabels:
         app: nginx
     template:
       metadata:
         labels:
           app: nginx
       spec:
         containers:
         - image: anolis-registry.cn-zhangjiakou.cr.aliyuncs.com/openanolis/nginx:1.14.1-8.6
           imagePullPolicy: Always
           name: nginx
           ports:
           - containerPort: 80
             protocol: TCP
         restartPolicy: Always
   ---
   apiVersion: v1
   kind: Service
   metadata:
     name: nginx-service
   spec:
     ports:
     - port: 80
       protocol: TCP
       targetPort: 80
     selector:
       app: nginx
     type: NodePort

2. Déployez l'application :

   kubectl apply -f my-nginx.yaml

3. Créez le fichier my-ingress.yaml avec les annotations de duplication. Remplacez 47.**.**.53 par la valeur ADDRESS obtenue à l'étape 1, et example1.com par la valeur HOSTS du cluster de préproduction :

   apiVersion: networking.k8s.io/v1
   kind: Ingress
   metadata:
     name: nginx-ingress
     annotations:
       nginx.ingress.kubernetes.io/mirror-target: "http://47.**.**.53$request_uri"
       nginx.ingress.kubernetes.io/mirror-request-body: "off"
       nginx.ingress.kubernetes.io/mirror-host: "example1.com"
   spec:
     rules:
     - host: example.com
       http:
         paths:
         - path: /
           backend:
             service:
               name: nginx-service
               port:
                 number: 80
           pathType: ImplementationSpecific

4. Déployez l'Ingress :

   kubectl apply -f my-ingress.yaml

5. Vérifiez que l'Ingress de production est actif :

   kubectl get ing nginx-ingress

   Résultat attendu :

   NAME            HOSTS        ADDRESS       PORTS   AGE
   nginx-ingress   example.com  39.**.**.54   80      1m

6. Confirmez que l'application de production est accessible :

   curl http://example.com

Vérifier la duplication du trafic

Envoyez une requête au domaine de production et consultez les journaux du contrôleur NGINX Ingress pour confirmer que le trafic est bien dupliqué vers le cluster de préproduction.

1. Envoyez une requête à l'application de production :

   curl http://example.com

2. Consultez les journaux du contrôleur NGINX Ingress dans le namespace kube-system de K8s Product Cluster :

   kubectl -n kube-system logs --tail=0 -f nginx-ingress-controller-674c96ffbc-9mc8n

   Les journaux affichent des entrées dupliquées : l'une correspondant à la requête originale vers example.com et l'autre à la requête dupliquée transférée vers le cluster de préproduction.