Utilizzare il bilanciamento del carico Maglev in GKE Dataplane V2

Questo documento mostra come configurare e verificare il bilanciamento del carico Maglev per i servizi in GKE Dataplane V2.

Maglev è un algoritmo di hashing coerente che fornisce un bilanciamento del carico con throughput elevato e bassa latenza. Maglev riduce al minimo le perdite di pacchetti e le interruzioni della connessione quando i pod di backend vengono scalati, aggiornati o riprogrammati, contribuendo a garantire che lo stesso flusso venga mappato in modo coerente allo stesso backend.

Per saperne di più, consulta il documento di ricerca sull'algoritmo di hashing coerente Maglev.

Consigliamo questa funzionalità per i workload con connessioni di lunga durata o applicazioni stateful in cui le modifiche al backend non devono interrompere i flussi esistenti.

Per informazioni sull'overhead delle risorse e sulle considerazioni sulla scalabilità, consulta Concetti di GKE Dataplane V2.

Prima di iniziare

Prima di iniziare, assicurati di aver eseguito le seguenti attività:

• Abilita l'API Google Kubernetes Engine.
Abilita l'API Google Kubernetes Engine
• Per utilizzare Google Cloud CLI per questa attività, installala e poi inizializza gcloud CLI. Se hai già installato gcloud CLI, scarica l'ultima versione eseguendo il comando gcloud components update. Le versioni precedenti di gcloud CLI potrebbero non supportare l'esecuzione dei comandi in questo documento.

Prerequisiti e limiti

• Versione di GKE:1.36.0-gke.2882000 e successive
• GKE Dataplane V2: abilitato
• Modalità cluster:Autopilot e Standard

Crea un cluster GKE con GKE Dataplane V2

Per utilizzare Maglev, devi disporre di un cluster GKE con GKE Dataplane V2 abilitato.

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

Esegui il deployment di un'applicazione di backend

Prima di configurare i servizi di bilanciamento del carico, esegui il deployment di un'applicazione di backend per gestire il traffico. Questo deployment esegue cinque repliche dell'applicazione di esempio hello-app.

1. Salva il seguente manifest come 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. Applica il manifest:

   kubectl apply -f echo-backend.yaml
   

Configura i servizi di bilanciamento del carico

Puoi configurare i servizi in modo che utilizzino l'algoritmo di bilanciamento del carico Maglev o l'algoritmo di bilanciamento del carico casuale predefinito. Entrambi i servizi hanno come target il deployment echo-backend creato nel passaggio precedente.

Configura un servizio Maglev

Per abilitare il bilanciamento del carico Maglev, aggiungi l'annotazione gke.networking.io/lb-algorithm: "maglev" ai metadati del servizio durante la creazione.

1. Salva il seguente manifest come 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. Applica il manifest:

   kubectl apply -f maglev-service.yaml
   

Configura un servizio casuale

Per impostazione predefinita, i servizi utilizzano un algoritmo di bilanciamento del carico casuale. Non è necessario specificare un'annotazione per utilizzare l'algoritmo predefinito, ma l'esempio seguente lo configura esplicitamente per il confronto.

1. Salva il seguente manifest come 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. Applica il manifest:

   kubectl apply -f random-service.yaml
   

Verifica la coerenza del traffico

Puoi verificare le differenze di coerenza del routing tra Maglev e il bilanciamento del carico casuale eseguendo il deployment di pod client di test che inviano traffico da una porta di origine fissa.

Verifica la coerenza del traffico Maglev

Maglev instrada le richieste dalla stessa porta di origine in modo coerente allo stesso pod di backend.

1. Salva il seguente manifest come 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
   

   Il flag --local-port forza la porta di origine e l'intestazione Connection: close aiuta a garantire che il client possa riutilizzare immediatamente la porta di origine per le richieste successive.

2. Applica il manifest:

   kubectl apply -f client-maglev.yaml
   

3. Mentre il pod è in esecuzione, controlla i log:

   kubectl logs client-maglev
   

   Output previsto:

   L'output mostra lo stesso nome host stampato ripetutamente, a indicare che tutto il traffico proveniente dal client viene instradato in modo coerente allo stesso pod di backend:

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

Verifica la distribuzione del traffico predefinita (casuale)

Il servizio predefinito distribuisce il traffico dalla stessa porta di origine a diversi pod di backend.

1. Salva il seguente manifest come 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. Applica il manifest:

   kubectl apply -f client-random.yaml
   

3. Mentre il pod è in esecuzione, controlla i log:

   kubectl logs client-random
   

   Output previsto:

   L'output mostra più nomi host diversi, il che indica che il traffico è distribuito su più pod:

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

Esegui la pulizia

Per eseguire la pulizia delle risorse utilizzate in questo tutorial, esegui questi comandi:

1. Elimina i pod, i servizi e il deployment client:

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

2. Elimina i cluster GKE:

gcloud container clusters delete CLUSTER_NAME --region=COMPUTE_REGION

gcloud container clusters delete CLUSTER_NAME --zone=COMPUTE_ZONE