Utiliser l'équilibrage de charge Maglev dans GKE Dataplane V2

Ce document explique comment configurer et vérifier l'équilibrage de charge Maglev pour les services dans GKE Dataplane V2.

Maglev est un algorithme de hachage cohérent qui fournit un équilibrage de charge à haut débit et à faible latence. Maglev minimise les pertes de paquets et les perturbations de connexion lorsque les pods de backend sont mis à l'échelle, mis à jour ou reprogrammés. Il permet en effet de s'assurer que le même flux est toujours mappé au même backend.

Pour en savoir plus, consultez le document de recherche sur l'algorithme de hachage cohérent Maglev.

Nous recommandons cette fonctionnalité pour les charges de travail avec des connexions à longue durée de vie ou des applications avec état où les modifications du backend ne doivent pas perturber les flux existants.

Pour en savoir plus sur la surcharge de ressources et les considérations relatives à l'évolutivité, consultez Concepts de GKE Dataplane V2.

Avant de commencer

Avant de commencer, effectuez les tâches suivantes :

• Activez l'API Google Kubernetes Engine.
Activer l'API Google Kubernetes Engine
• Pour utiliser Google Cloud CLI pour cette tâche, installez puis initialisez la gcloud CLI. Si vous avez déjà installé la gcloud CLI, obtenez la dernière version en exécutant la commande gcloud components update. Il est possible que les versions antérieures de la gcloud CLI ne permettent pas d'exécuter les commandes de ce document.

Conditions requises et limites

• Version de GKE : 1.36.0-gke.2882000 et versions ultérieures
• GKE Dataplane V2 : activé
• Modes de cluster : Autopilot et Standard

Créer un cluster GKE avec GKE Dataplane V2

Pour utiliser Maglev, vous devez disposer d'un cluster GKE avec GKE Dataplane V2 activé.

gcloud container clusters create-auto CLUSTER_NAME \
    --region=COMPUTE_REGION \
    --release-channel=rapid
gcloud container clusters get-credentials CLUSTER_NAME \
    --region=COMPUTE_REGION

gcloud container clusters create CLUSTER_NAME \
    --zone=COMPUTE_ZONE \
    --enable-dataplane-v2 \
    --cluster-version=1.36.0-gke.2882000
gcloud container clusters get-credentials CLUSTER_NAME \
    --zone=COMPUTE_ZONE

Déployer une application de backend

Avant de configurer vos services d'équilibrage de charge, déployez une application de backend pour gérer le trafic. Ce déploiement exécute cinq instances répliquées de l'application exemple hello-app.

1. Enregistrez le manifeste suivant sous le nom echo-backend.yaml :

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: echo-backend
   spec:
     replicas: 5
     selector:
       matchLabels:
         app: echo-backend
     template:
       metadata:
         labels:
           app: echo-backend
       spec:
         containers:
         - name: hello
           image: "us-docker.pkg.dev/google-samples/containers/gke/hello-app:2.0"
           ports:
           - containerPort: 8080
   

2. Appliquez le fichier manifeste :

   kubectl apply -f echo-backend.yaml
   

Configurer les services d'équilibrage de charge

Vous pouvez configurer les services pour qu'ils utilisent l'algorithme d'équilibrage de charge Maglev ou l'algorithme d'équilibrage de charge aléatoire par défaut. Les deux services ciblent le déploiement echo-backend créé à l'étape précédente.

Configurer un service Maglev

Pour activer l'équilibrage de charge Maglev, ajoutez l'annotation gke.networking.io/lb-algorithm: "maglev" aux métadonnées du service lors de la création.

1. Enregistrez le manifeste suivant sous le nom maglev-service.yaml :

   apiVersion: v1
   kind: Service
   metadata:
     name: maglev-service
     annotations:
       gke.networking.io/lb-algorithm: "maglev"
   spec:
     selector:
       app: echo-backend
     ports:
       - protocol: TCP
         port: 80
         targetPort: 8080
   

2. Appliquez le fichier manifeste :

   kubectl apply -f maglev-service.yaml
   

Configurer un service aléatoire

Par défaut, les services utilisent un algorithme d'équilibrage de charge aléatoire. Vous n'avez pas besoin de spécifier d'annotation pour utiliser l'algorithme par défaut, mais l'exemple suivant le configure explicitement à des fins de comparaison.

1. Enregistrez le manifeste suivant sous le nom random-service.yaml :

   apiVersion: v1
   kind: Service
   metadata:
     name: random-service
     annotations:
       gke.networking.io/lb-algorithm: "random"
   spec:
     selector:
       app: echo-backend
     ports:
       - protocol: TCP
         port: 80
         targetPort: 8080
   

2. Appliquez le fichier manifeste :

   kubectl apply -f random-service.yaml
   

Vérifier la cohérence du trafic

Vous pouvez vérifier les différences de cohérence du routage entre l'équilibrage de charge Maglev et aléatoire en déployant des pods clients de test qui envoient du trafic à partir d'un port source fixe.

Vérifier la cohérence du trafic Maglev

Maglev achemine les requêtes provenant du même port source de manière cohérente vers le même pod de backend.

1. Enregistrez le manifeste suivant sous le nom client-maglev.yaml :

   apiVersion: v1
   kind: Pod
   metadata:
     name: client-maglev
   spec:
     restartPolicy: Never
     containers:
     - name: curl
       image: curlimages/curl:8.2.0
       command: ["/bin/sh", "-c"]
       args:
       - |
         while true; do
           curl -s -H "Connection: close" http://maglev-service:80 --local-port 54321 | grep Hostname
           sleep 0.5
         done
   

   L'option --local-port force le port source, et l'en-tête Connection: close permet de s'assurer que le client peut réutiliser immédiatement le port source pour les requêtes ultérieures.

2. Appliquez le fichier manifeste :

   kubectl apply -f client-maglev.yaml
   

3. Pendant l'exécution du pod, vérifiez les journaux :

   kubectl logs client-maglev
   

   Résultat attendu :

   Le résultat affiche le même nom d'hôte de manière répétée, ce qui indique que tout le trafic du client est systématiquement acheminé vers le même pod de backend :

   Hostname: echo-backend-5c78f66dbf-abcde
   Hostname: echo-backend-5c78f66dbf-abcde
   

Vérifier la répartition du trafic par défaut (aléatoire)

Le service par défaut répartit le trafic provenant du même port source entre différents pods backend.

1. Enregistrez le manifeste suivant sous le nom client-random.yaml :

   apiVersion: v1
   kind: Pod
   metadata:
     name: client-random
   spec:
     restartPolicy: Never
     containers:
     - name: curl
       image: curlimages/curl:8.2.0
       command: ["/bin/sh", "-c"]
       args:
       - |
         while true; do
           curl -s -H "Connection: close" http://random-service:80 --local-port 54321 | grep Hostname
           sleep 0.5
         done
   

2. Appliquez le fichier manifeste :

   kubectl apply -f client-random.yaml
   

3. Pendant l'exécution du pod, vérifiez les journaux :

   kubectl logs client-random
   

   Résultat attendu :

   Le résultat affiche plusieurs noms d'hôtes différents, ce qui indique que le trafic est réparti sur différents pods :

   Hostname: echo-backend-5c78f66dbf-abcde
   Hostname: echo-backend-5c78f66dbf-fghij
   Hostname: echo-backend-5c78f66dbf-klmno
   ...
   

Nettoyage

Pour nettoyer les ressources utilisées dans ce tutoriel, exécutez les commandes suivantes :

1. Supprimez les pods, les services et le déploiement du client :

   kubectl delete service maglev-service random-service
   kubectl delete deployment echo-backend
   kubectl delete pod client-maglev client-random
   

2. Supprimez les clusters GKE :

gcloud container clusters delete CLUSTER_NAME --region=COMPUTE_REGION

gcloud container clusters delete CLUSTER_NAME --zone=COMPUTE_ZONE