Usar o balanceamento de carga do Maglev no GKE Dataplane V2

Neste documento, mostramos como configurar e verificar o balanceamento de carga do Maglev para serviços no GKE Dataplane V2.

O Maglev é um algoritmo hashing consistente que oferece balanceamento de carga de alta capacidade e baixa latência. O Maglev minimiza as quedas de pacotes e a interrupção da conexão quando os pods de back-end são escalonados, atualizados ou reagendados, ajudando a garantir que o mesmo fluxo seja mapeado de forma consistente para o mesmo back-end.

Para mais informações, consulte o artigo de pesquisa Maglev hashing consistente algorithm.

Recomendamos esse recurso para cargas de trabalho com conexões de longa duração ou aplicativos com estado em que as mudanças de back-end não devem interromper os fluxos atuais.

Para informações sobre sobrecarga de recursos e considerações de escalonabilidade, consulte Conceitos do GKE Dataplane V2.

Antes de começar

Antes de começar, verifique se você realizou as tarefas a seguir:

• Ative a API Google Kubernetes Engine.
Ativar a API Google Kubernetes Engine
• Para usar a Google Cloud CLI nesta tarefa, instale e inicialize a CLI gcloud. Se você instalou a CLI gcloud anteriormente, instale a versão mais recente executando o comando gcloud components update. Talvez as versões anteriores da CLI gcloud não sejam compatíveis com a execução dos comandos neste documento.

Pré-requisitos e limites

• Versão do GKE:1.36.0-gke.2882000 e mais recentes
• GKE Dataplane V2:ativado
• Modos de cluster:Autopilot e Standard

Criar um cluster do GKE com o GKE Dataplane V2

Para usar o Maglev, você precisa ter um cluster do GKE com o GKE Dataplane V2 ativado.

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

Implantar um aplicativo de back-end

Antes de configurar os serviços de balanceamento de carga, implante um aplicativo de back-end para processar o tráfego. Essa implantação executa cinco réplicas do aplicativo de exemplo hello-app.

1. Salve o seguinte manifesto como 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. Aplique o manifesto:

   kubectl apply -f echo-backend.yaml
   

Configurar serviços de balanceamento de carga

É possível configurar os serviços para usar o algoritmo de balanceamento de carga do Maglev ou o algoritmo de balanceamento de carga aleatório padrão. Os dois serviços têm como destino a implantação echo-backend criada na etapa anterior.

Configurar um serviço do Maglev

Para ativar o balanceamento de carga do Maglev, adicione a anotação gke.networking.io/lb-algorithm: "maglev" aos metadados do serviço durante a criação.

1. Salve o seguinte manifesto como 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. Aplique o manifesto:

   kubectl apply -f maglev-service.yaml
   

Configurar um serviço aleatório

Por padrão, os serviços usam um algoritmo de balanceamento de carga aleatório. Não é necessário especificar uma anotação para usar o algoritmo padrão, mas o exemplo a seguir o configura explicitamente para comparação.

1. Salve o seguinte manifesto como 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. Aplique o manifesto:

   kubectl apply -f random-service.yaml
   

Verificar a consistência do tráfego

É possível verificar as diferenças de consistência de roteamento entre o Maglev e o balanceamento de carga aleatório implantando pods de cliente de teste que enviam tráfego de uma porta de origem fixa.

Verificar a consistência do tráfego do Maglev

O Maglev encaminha solicitações da mesma porta de origem de maneira consistente para o mesmo pod de back-end.

1. Salve o seguinte manifesto como 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
   

   A flag --local-port força a porta de origem, e o cabeçalho Connection: close ajuda a garantir que o cliente possa reutilizar a porta de origem imediatamente para solicitações subsequentes.

2. Aplique o manifesto:

   kubectl apply -f client-maglev.yaml
   

3. Enquanto o pod estiver em execução, verifique os registros:

   kubectl logs client-maglev
   

   Resposta esperada:

   A saída mostra o mesmo nome do host impresso repetidamente, indicando que todo o tráfego do cliente é roteado consistentemente para o mesmo pod de back-end:

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

Verificar a distribuição de tráfego padrão (aleatória)

O serviço padrão distribui o tráfego da mesma porta de origem entre diferentes pods de back-end.

1. Salve o seguinte manifesto como 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. Aplique o manifesto:

   kubectl apply -f client-random.yaml
   

3. Enquanto o pod estiver em execução, verifique os registros:

   kubectl logs client-random
   

   Resposta esperada:

   A saída mostra vários nomes de host diferentes, indicando que o tráfego é distribuído entre vários pods:

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

Limpeza

Para limpar os recursos usados neste tutorial, execute os comandos a seguir:

1. Exclua os pods, serviços e implantações do cliente:

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

2. Exclua os clusters do GKE:

gcloud container clusters delete CLUSTER_NAME --region=COMPUTE_REGION

gcloud container clusters delete CLUSTER_NAME --zone=COMPUTE_ZONE