Criar um balanceador de carga externo baseado em serviço de back-end

Autopilot Standard

Nesta página, mostramos como implantar um Serviço LoadBalancer externo que cria um balanceador de carga de rede de passagem externo baseado em serviço de back-end. Antes de ler esta página, confira se você conhece os seguintes conceitos:

• Sobre os serviços LoadBalancer
• Parâmetros de serviço LoadBalancer do GKE

Para saber mais sobre balanceadores de carga de rede de passagem externa em geral, consulte Balanceador de carga de rede de passagem externa baseado em serviço de back-end.

Antes de começar

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

• Ativar a API Google Kubernetes Engine.
Ativar a API Google Kubernetes Engine
• Se você quiser usar a CLI do Google Cloud para essa tarefa, instale e inicialize a gcloud CLI. 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.
  Observação: em instalações prévias da gcloud CLI, defina a propriedade compute/region. Se você usa principalmente clusters zonais, defina compute/zone. Ao definir um local padrão, é possível evitar erros na gcloud CLI como: One of [--zone, --region] must be supplied: Please specify location. Talvez seja necessário especificar o local em determinados comandos se o local do cluster for diferente do padrão definido.

Requisitos

• O complemento HttpLoadBalancing precisa estar ativado no cluster. Esse complemento é ativado por padrão. Ele permite que o cluster gerencie balanceadores de carga que usam serviços de back-end.

• Para criar um serviço LoadBalancer externo que use um balanceador de carga de rede de passagem externa baseado em serviço de back-end, seu cluster do GKE precisa usar a versão 1.25.5 ou mais recente.

• Para criar um serviço LoadBalancer externo que use o balanceamento de carga ponderado, seu cluster do GKE precisa usar a versão 1.31.0-gke.1506000 ou mais recente.

• Para criar um serviço LoadBalancer externo que use back-ends de grupo de endpoints de rede (NEG) GCE_VM_IP, seu cluster do GKE precisa usar a versão 1.32.2-gke.1652000 ou mais recente.

Escolher um cluster

É possível criar um cluster ou escolher um que atenda aos requisitos.

Criar um novo cluster

Piloto automático

Para criar um cluster do Autopilot:

gcloud container clusters create-auto CLUSTER_NAME \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=VERSION \
    --location=COMPUTE_LOCATION

Substitua:

• CLUSTER_NAME: o nome do novo cluster;
• RELEASE_CHANNEL: o nome do canal de lançamento do GKE para o cluster.
• VERSION: a versão do GKE do cluster.
• COMPUTE_LOCATION: a região do Compute Engine do cluster.

Para desativar a criação automática de regras de firewall da VPC para serviços de LoadBalancer, inclua a flag --disable-l4-lb-firewall-reconciliation. Para mais informações, consulte Regras de firewall gerenciadas pelo usuário para serviços do LoadBalancer do GKE.

Padrão

Para criar um cluster padrão:

gcloud container clusters create CLUSTER_NAME \
    --release-channel=RELEASE_CHANNEL \
    --cluster-version=VERSION \
    --location=COMPUTE_LOCATION

Substitua:

• CLUSTER_NAME: o nome do novo cluster;
• RELEASE_CHANNEL: o nome do canal de lançamento do GKE para o cluster.
• VERSION: a versão do GKE do cluster.
• COMPUTE_LOCATION: a região do Compute Engine do cluster.

Para desativar a criação automática de regras de firewall da VPC para serviços de LoadBalancer, inclua a flag --disable-l4-lb-firewall-reconciliation. Para mais informações, consulte Regras de firewall gerenciadas pelo usuário para serviços do LoadBalancer do GKE.

Fazer upgrade de um cluster atual

Use a CLI gcloud para atualizar um cluster:

gcloud container clusters upgrade CLUSTER_NAME \
    --cluster-version=VERSION \
    --master \
    --location=COMPUTE_LOCATION

Substitua:

• CLUSTER_NAME: o nome do cluster existente.
• VERSION: a versão específica do GKE para a qual você quer fazer upgrade do cluster. Para mais informações, consulte Como fazer upgrade manual do plano de controle.
• COMPUTE_LOCATION: a região do Compute Engine do cluster.

Para desativar a criação automática de regras de firewall da VPC para serviços de LoadBalancer, inclua a flag --disable-l4-lb-firewall-reconciliation. Para mais informações, consulte Regras de firewall gerenciadas pelo usuário para serviços do LoadBalancer do GKE.

implante uma carga de trabalho de amostra

Implante a seguinte carga de trabalho de exemplo, que fornece os pods de serviço para o serviço LoadBalancer externo.

1. Salve a seguinte implantação de amostra como store-deployment.yaml:

   apiVersion: apps/v1
   kind: Deployment
   metadata:
     name: store
   spec:
     replicas: 20
     selector:
       matchLabels:
         app: store
     template:
       metadata:
         labels:
           app: store
       spec:
         containers:
         - image: gcr.io/google_containers/echoserver:1.10
           imagePullPolicy: Always
           name: echoserver
           ports:
             - name: http
               containerPort: 8080
           readinessProbe:
             httpGet:
               path: /healthz
               port: 8080
               scheme: HTTP
   

2. Aplique o manifesto ao cluster:

   kubectl apply -f store-deployment.yaml
   

3. Verifique se há 20 pods de exibição para a implantação:

   kubectl get pods
   

   O resultado será assim:

   NAME                     READY   STATUS    RESTARTS   AGE
   store-cdb9bb4d6-s25vw      1/1     Running   0          10s
   store-cdb9bb4d6-vck6s      1/1     Running   0          10s
   ....
   

Criar o serviço LoadBalancer externo

1. Exponha a carga de trabalho de exemplo criando um serviço LoadBalancer externo.

   1. Salve o seguinte manifesto de serviço como store-v1-lb-svc.yaml:

      apiVersion: v1
      kind: Service
      metadata:
        name: store-v1-lb-svc
        annotations:
          cloud.google.com/l4-rbs: "enabled"
      spec:
        type: LoadBalancer
        selector:
          app: store
        ports:
        - name: tcp-port
          protocol: TCP
          port: 8080
          targetPort: 8080
      

   2. Aplique o manifesto ao cluster:

      kubectl apply -f store-v1-lb-svc.yaml
      

   Observe os seguintes pontos sobre este exemplo de manifesto:

   • O manifesto do serviço precisa incluir a anotação cloud.google.com/l4-rbs: "enabled" quando o manifesto é aplicado ao cluster pela primeira vez. Isso instrui o GKE a criar um balanceador de carga de rede de passagem externa baseado em serviço de back-end. Os balanceadores de carga de rede de passagem externa baseados em serviço de back-end são necessários para oferecer suporte a recursos como IPv6 e balanceamento de carga ponderado.

   • O GKE usa back-ends NEG GCE_VM_IP ou back-ends de grupos de instâncias não gerenciadas, dependendo da versão do cluster. Em clusters com a versão 1.32.2-gke.1652000, o balanceador de carga de rede de passagem externa baseado em serviço de back-end usa NEGs GCE_VM_IP. Em versões anteriores, o balanceador de carga de rede de passagem externa baseado em serviço de back-end usava grupos de instâncias não gerenciadas.

   • Se você adicionar a anotação cloud.google.com/l4-rbs: "enabled" ao manifesto de um serviço LoadBalancer externo existente (ou seja, depois que o balanceador de carga for criado), o GKE vai ignorar a anotação. Os serviços LoadBalancer externos criados sem essa anotação nos manifestos usam balanceadores de carga de rede de passagem externa baseados em pool de destino. Não é recomendável usar balanceadores de carga de rede de passagem externa baseados em pool de destino.

Ativar o balanceamento de carga ponderado

Para distribuir novas conexões proporcionalmente aos nós com base em quantos pods de exibição, prontos e não encerrados estão presentes em cada nó, ative o balanceamento de carga ponderado adicionando a anotação networking.gke.io/weighted-load-balancing: "pods-per-node" ao manifesto do serviço.

1. Adicione a anotação networking.gke.io/weighted-load-balancing: "pods-per-node" ao manifesto do serviço store-v1-lb-svc.yaml e defina também o externalTrafficPolicy: Local para que ele fique assim:

   apiVersion: v1
   kind: Service
   metadata:
     name: store-v1-lb-svc
     annotations:
       cloud.google.com/l4-rbs: "enabled"
       networking.gke.io/weighted-load-balancing: "pods-per-node"
   spec:
     type: LoadBalancer
     externalTrafficPolicy: Local
     selector:
       app: store
     ports:
     - name: tcp-port
       protocol: TCP
       port: 8080
       targetPort: 8080
   

2. Aplique o manifesto ao cluster:

   kubectl apply -f store-v1-lb-svc.yaml
   

Observe o seguinte sobre este exemplo de balanceamento de carga ponderado:

• O manifesto do serviço usa externalTrafficPolicy: Local. Se você não precisar ativar o balanceamento de carga ponderado, também poderá usar externalTrafficPolicy: Cluster. Para detalhes sobre como o externalTrafficPolicy define o agrupamento de nós, quais nós passam nas verificações de integridade do balanceador de carga e como os pacotes são processados, consulte Conceitos do serviço LoadBalancer.

• Se você ativar o balanceamento de carga ponderado, o GKE não vai impedir o uso de externalTrafficPolicy: Cluster, mas externalTrafficPolicy: Cluster desativa o balanceamento de carga ponderado porque o pacote pode ser encaminhado, após o balanceador de carga, para um nó diferente.

Também é possível ativar o balanceamento de carga ponderado em um serviço LoadBalancer externo usando kubectl edit svc service-name. O comando kubectl edit abre o manifesto do serviço do balanceador de carga atual no editor de texto configurado, em que é possível modificar o manifesto e salvar as mudanças. Ao editar um serviço LoadBalancer externo, observe os seguintes pontos:

• O serviço LoadBalancer externo atual precisa ter resultado na criação de um balanceador de carga de rede de passagem externa baseado em serviço de back-end. Isso significa que o serviço LoadBalancer externo precisa ter incluído a anotação cloud.google.com/l4-rbs: "enabled" quando o manifesto foi aplicado ao cluster pela primeira vez.

  Adicionar a anotação networking.gke.io/weighted-load-balancing: "pods-per-node" a um serviço LoadBalancer externo que usa um balanceador de carga de rede de passagem externa baseado em pool de destino não tem efeito.

• Ao atualizar o manifesto do serviço LoadBalancer externo, defina externalTrafficPolicy: Local. O uso de externalTrafficPolicy: Cluster desativa efetivamente o balanceamento de carga ponderado porque o pacote pode ser encaminhado, após o balanceador de carga, para um nó diferente.

Desativar o balanceamento de carga ponderado

Para distribuir novas conexões aos nós, não importa quantos pods de serviço estejam presentes em cada nó, desative o balanceamento de carga ponderado removendo a anotação networking.gke.io/weighted-load-balancing: "pods-per-node" do manifesto do serviço.

Observação: ativar ou desativar o balanceamento de carga ponderado limpa a tabela de rastreamento de conexão do balanceador de carga. As conexões atuais podem ser encaminhadas para nós diferentes, o que faz com que esses nós enviem pacotes de redefinição TCP. Como prática recomendada, ative ou desative o balanceamento de carga ponderado quando um breve período de interrupções de conexão puder ser tolerado.

Verificar o serviço LoadBalancer externo e os componentes dele

1. Verifique se o serviço está em execução:

   kubectl get svc store-v1-lb-svc
   

   O resultado será assim:

   NAME               TYPE           CLUSTER-IP        EXTERNAL-IP     PORT(S)          AGE
   store-v1-lb-svc   LoadBalancer   10.44.196.160     35.193.28.231   8080:32466/TCP   11m
   

   O GKE atribuiu um EXTERNAL_IP para o balanceador de carga de rede de passagem externa.

   Observação: pode levar alguns minutos para que o GKE aloque um endereço IP externo antes que o balanceador de carga esteja pronto para disponibilizar o aplicativo.

2. Teste a conexão com o balanceador de carga:

   curl EXTERNAL_IP:PORT
   

   Substitua:

   • EXTERNAL_IP: o endereço IP de alocação para o balanceador de carga de rede de passagem externa.
   • PORT: o número da porta alocada para o balanceador de carga de rede de passagem externa.

   O resultado será assim:

   Hostname: store-v1-lb-svc-cdb9bb4d6-hflxd
   
   Pod Information:
     -no pod information available-
   
   Server values:
     server_version=nginx: 1.13.3 - lua: 10008
   
   Request Information:
     client_address=10.128.0.50
     method=GET
     real path=/
     query=
     request_version=1.1
     request_scheme=http
     request_uri=EXTERNAL_IP
   
   Request Headers:
     accept=*/*
     host=EXTERNAL_IP
     user-agent=curl/7.81.0
   
   Request Body:
     -no body in request-
   
   

3. Verifique seu serviço LoadBalancer e o conjunto de anotações que descreve os recursos do Google Cloud :

   kubectl describe svc store-v1-lb-svc
   

   O resultado será assim:

   Name:                     my-service-external
   Namespace:                default
   Labels:                   <none>
   Annotations:              cloud.google.com/l4-rbs: enabled
                             cloud.google.com/neg-status: {"network_endpoint_groups":{"0":"k8s2-qvveq1d8-default-my-service-ext-5s55db85"},"zones":["us-central1-c"]} #This annotation appears in the output only if the service uses NEG backends.
                             networking.gke.io/weighted-load-balancing: pods-per-node #This annotation appears in the output only if weighted load balancing is enabled.
                             service.kubernetes.io/backend-service: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                             service.kubernetes.io/firewall-rule: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                             service.kubernetes.io/firewall-rule-for-hc: k8s2-qvveq1d8-default-my-service-ext-5s55db85-fw
                             service.kubernetes.io/healthcheck: k8s2-qvveq1d8-default-my-service-ext-5s55db85
                             service.kubernetes.io/tcp-forwarding-rule: a808124abf8ce406ca51ab3d4e7d0b7d
   Selector:                 app=my-app
   Type:                     LoadBalancer
   IP Family Policy:         SingleStack
   IP Families:              IPv4
   IP:                       10.18.102.23
   IPs:                      10.18.102.23
   LoadBalancer Ingress:     35.184.160.229
   Port:                     tcp-port  8080/TCP
   TargetPort:               8080/TCP
   NodePort:                 tcp-port  31864/TCP
   Endpoints:                10.20.1.28:8080,10.20.1.29:8080
   Session Affinity:         None
   External Traffic Policy:  Local
   HealthCheck NodePort:     30394
   
   Events:
     Type    Reason                Age                    From                     Message
     ----    ------                ----                   ----                     -------
     Normal  ADD                   4m55s                  loadbalancer-controller  default/my-service-ext
   

   Há vários campos que indicam que um balanceador de carga de rede de passagem externa baseado em serviço de back-end e seus recursos Google Cloud foram criados com sucesso:

   • Campo Events. Este campo fica vazio quando o serviço LoadBalancer e os recursos dele foram criados com sucesso. Se ocorrer um erro, ele será listado aqui.

   • Lista de Annotations ativadas: o GKE adiciona a seguinte lista de anotações somente leitura ao manifesto do serviço. Cada anotação com um nome que começa com service.kubernetes.io/ é usada para indicar o nome de um recursoGoogle Cloud criado como parte ou para oferecer suporte ao balanceador de carga.

     • A anotação networking.gke.io/weighted-load-balancing: pods-per-node indica que o balanceamento de carga ponderado foi aplicado e que o balanceador de carga distribui o tráfego para os pods de back-end com base no número de pods em execução em cada nó.
     • A anotação service.kubernetes.io/backend-service indica o nome do serviço de back-end do balanceador de carga.
     • A anotação service.kubernetes.io/healthcheck indica o nome da verificação de integridade do balanceador de carga usada pelo serviço de back-end.
     • A anotação service.kubernetes.io/tcp-forwarding-rule ou service.kubernetes.io/udp-forwarding-rule indica o nome da regra de encaminhamento do balanceador de carga.
     • A anotação service.kubernetes.io/firewall-rule indica o nome da regra de firewall criada para permitir o tráfego para os nós do cluster. Os intervalos de origem desta regra de firewall são personalizáveis usando spec.loadBalancerSourceRanges[]. Para mais detalhes sobre as regras de firewall para os serviços LoadBalancer, consulte Regras de firewall e lista de permissões de endereços IP de origem.
     • A anotação service.kubernetes.io/firewall-rule-for-hc indica o nome da regra de firewall necessária para as verificações de integridade do balanceador de carga.

     • A anotação cloud.google.com/neg-status indica as NEGs usadas pelo balanceador de carga e as zonas delas. Essa anotação só está presente quando as duas condições a seguir são verdadeiras:

       • O cluster estava executando o GKE versão 1.32.2-gke.1652000 ou posterior quando o manifesto foi aplicado ao cluster, e
       • A anotação cloud.google.com/l4-rbs: "enabled" estava presente no manifesto do serviço quando ele foi aplicado ao cluster.

4. Verifique se os recursos do balanceador de carga e as regras de firewall foram criados para o serviço LoadBalancer externo:

   • Para ver a regra de encaminhamento, execute o seguinte comando:

       gcloud compute forwarding-rules describe FWD_RULE_NAME \
         --region=REGION_NAME
     

     Substitua:

     • FWD_RULE_NAME: o nome da regra de encaminhamento fornecido pelas anotações somente leitura service.kubernetes.io/tcp-forwarding-rule ou service.kubernetes.io/udp-forwarding-rule. Para conferir essas anotações, execute kubectl describe svc SERVICE_NAME.
     • REGION_NAME: a Google Cloud região que contém o cluster. Para clusters zonais, a região contém a zona usada pelo cluster.

   • Para ver o serviço de back-end, execute o seguinte comando:

     gcloud compute backend-services describe BACKEND_SERVICE_NAME \
       --region=REGION_NAME
     

     Substitua:

     • BACKEND_SERVICE_NAME: o nome do serviço de back-end fornecido pela anotação somente leitura service.kubernetes.io/backend-service. Para verificar essa anotação somente leitura, execute kubectl describe svc SERVICE_NAME.
     • REGION_NAME: a Google Cloud região que contém o cluster. Para clusters zonais, a região contém a zona usada pelo cluster.

   • Para ver a verificação de integridade do balanceador de carga, execute o seguinte comando:

     gcloud compute health-checks describe HEALTH_CHECK_NAME \
       --region=REGION_NAME
     

     Substitua:

     • HEALTH_CHECK_NAME: o nome da verificação de integridade do balanceador de carga. O nome da verificação de integridade é fornecido pela anotação somente leitura service.kubernetes.io/healthcheck. Para verificar essa anotação somente leitura, execute kubectl describe svc SERVICE_NAME.
     • REGION_NAME: a Google Cloud região que contém o cluster. Para clusters zonais, a região contém a zona usada pelo cluster.

   • Para ver as regras de firewall, execute os seguintes comandos:

     gcloud compute firewall-rules describe FIREWALL_RULE_NAME \
     gcloud compute firewall-rules describe HEALTH_CHECK_FIREWALL_RULE_NAME
     

     Substitua:

     • FIREWALL_RULE_NAME: o nome da regra de firewall que permite o tráfego para o balanceador de carga. O nome dessa regra de firewall é fornecido pela anotação somente leitura service.kubernetes.io/firewall-rule. Para verificar essa anotação somente leitura, execute kubectl describe svc SERVICE_NAME.
     • HEALTH_CHECK_FIREWALL_RULE_NAME: o nome da regra de firewall que permite verificações de saúde dos back-ends do balanceador de carga (os nós do cluster). O nome da regra de firewall é fornecido pela anotação somente leitura service.kubernetes.io/firewall-rule-for-hc. Para verificar essa anotação somente leitura, execute kubectl describe svc SERVICE_NAME.

   • Para ver as NEGs do balanceador de carga, execute o seguinte comando:

     gcloud compute network-endpoint-groups describe NEG_NAME \
       --zone=ZONE_NAME
     

     Substitua:

     • NEG_NAME: o nome do NEG do balanceador de carga. O nome do NEG é fornecido pela anotação somente leitura cloud.google.com/neg-status. Para verificar essa anotação somente leitura, execute o comando kubectl describe svc SERVICE_NAME. A anotação contém dados estruturados com informações sobre os nomes e as zonas do NEG usados pelo balanceador de carga. Para clusters zonais, essa anotação contém informações sobre um NEG. Para clusters regionais, essa anotação contém informações sobre um NEG em cada zona em que o cluster está localizado.
     • ZONE_NAME: a Google Cloud zona que contém o NEG.

Excluir o serviço LoadBalancer externo

Para excluir o serviço LoadBalancer externo store-v1-lb-svc de exemplo, use o seguinte comando:

kubectl delete service store-v1-lb-svc

O GKE remove automaticamente todos os recursos de balanceador de carga que ele criou para o serviço LoadBalancer externo.

Migrar para back-ends de NEG GCE_VM_IP

Os serviços LoadBalancer externos com a anotação cloud.google.com/l4-rbs: "enabled" criam balanceadores de carga de rede de passagem externa baseados em serviço de back-end que usam back-ends de grupo de endpoints de rede GCE_VM_IP ou de grupo de instâncias, dependendo da versão do GKE do cluster:

• Se o manifesto do serviço foi aplicado a um cluster que executa a versão 1.32.2-gke.1652000 ou mais recente do GKE, o balanceador de carga de rede de passagem externa resultante usa back-ends de grupo de endpoints de rede (NEG) GCE_VM_IP.

• Se o manifesto do serviço foi aplicado a um cluster que executa uma versão anterior do GKE, o balanceador de carga de rede de passagem externa resultante usa back-ends de grupo de instâncias não gerenciadas.

Para mais informações, consulte Agrupamento de nós em "Sobre os serviços LoadBalancer".

Você pode criar um novo serviço LoadBalancer externo com tecnologia de um balanceador de carga de rede de passagem externa baseado em serviço de back-end que usa back-ends de NEG GCE_VM_IP se o serviço atual usar um dos seguintes balanceadores de carga:

• Um balanceador de carga de rede de passagem externa baseado em serviço de back-end com back-ends de grupo de instâncias
• Um balanceador de carga de rede de passagem externa baseado em pool de destino

Observação: a mudança para um balanceador de carga de rede de passagem externa baseado em serviço de back-end usando back-ends de NEG GCE_VM_IP requer alguns minutos de inatividade para substituir o serviço.

Para mudar para um balanceador de carga de rede de passagem externa baseado em serviço de back-end usando back-ends de NEG GCE_VM_IP:

1. Se ainda não fez isso, faça upgrade do cluster para a versão do GKE 1.32.2-gke.1652000 ou mais recente.

2. Identifique o serviço LoadBalancer externo que você quer mudar para um balanceador de carga de rede de passagem externa baseado em serviço de back-end usando back-ends de NEG GCE_VM_IP. Descreva o serviço usando o seguinte comando:

   kubectl describe svc SERVICE_NAME -n SERVICE_NAMESPACE
   

   Substitua:

   • SERVICE_NAME: o nome do serviço de LoadBalancer externo.

   • SERVICE_NAMESPACE: o namespace do serviço LoadBalancer externo atual.

   Na resposta ao comando, anote o endereço IPv4 externo usado pelo balanceador de carga na coluna EXTERNAL-IP.

3. Recupere o manifesto do serviço para o serviço LoadBalancer atual:

   • O ideal é ter o manifesto de serviço original que você aplicou ao cluster no passado. Por exemplo, você pode ter isso em um repositório de controle de origem.

   • Se você não tiver o manifesto do serviço original:

     • Execute o comando a seguir para receber uma cópia YAML do manifesto do serviço que representa a implementação atual do balanceador de carga:

       kubectl get svc SERVICE_NAME -n SERVICE_NAMESPACE -o yaml
       

     • Copie o manifesto YAML para um editor de texto. Remova o atributo status e os seguintes atributos metadata:

       • Todas as seguintes anotações:
         • A anotação kubectl.kubernetes.io/last-applied-configuration
         • Todas as anotações que começam com service.kubernetes.io
       • creationTimestamp
       • finalizers
       • resourceVersion
       • uid

   • Verifique se o manifesto inclui a anotação cloud.google.com/l4-rbs: "enabled". Se você estiver migrando de um balanceador de carga de rede de passagem externa baseado em pool de destino, a anotação precisará ser adicionada.

   Anote o caminho local que contém o arquivo de manifesto do serviço. O restante deste procedimento se refere ao caminho como MANIFEST_FILE_PATH.

4. Configure um recurso de endereço IPv4 externo estático para armazenar o endereço IPv4 externo usado pelo balanceador de carga atual:

   gcloud compute addresses create IP_ADDRESS_NAME --region=CLUSTER_REGION --addresses LB_EXTERNAL_IP
   

   Substitua:

   • IP_ADDRESS_NAME: o nome do endereço IP externo estático. O nome precisa seguir as convenções de nomenclatura para recursos do Compute Engine.

   • CLUSTER_REGION: a região que contém o cluster. Para clusters zonais, essa é a região que contém a zona do cluster.

   • LB_EXTERNAL_IP: o endereço IPv4 externo usado pelo balanceador de carga atual, determinado na segunda etapa deste procedimento.

5. Verifique se o recurso de endereço IPv4 externo estático foi criado:

   gcloud compute addresses describe IP_ADDRESS_NAME --region=CLUSTER_REGION
   

   Substitua as variáveis conforme indicado na etapa anterior.

6. Exclua o serviço atual:

   kubectl delete svc SERVICE_NAME -n SERVICE_NAMESPACE
   

7. Adicione a seguinte anotação ao arquivo de manifesto do serviço MANIFEST_FILE_PATH:

   networking.gke.io/load-balancer-ip-addresses: IP_ADDRESS_NAME
   

   Para mais informações sobre essa anotação, consulte Endereços IP estáticos nos parâmetros do serviço LoadBalancer.

8. Aplique o manifesto de serviço atualizado ao cluster:

   kubectl apply -f MANIFEST_FILE_PATH
   

9. (Opcional) Libere o recurso de endereço IPv4 estático.

   gcloud compute addresses delete IP_ADDRESS_NAME --region=CLUSTER_REGION
   

Resolver problemas

Esta seção descreve um problema que pode ocorrer ao configurar o balanceamento de carga ponderado.

Política de tráfego externo incorreta para balanceamento de carga ponderado

Se você não definir externalTrafficPolicy: Local ao ativar o balanceamento de carga ponderado, poderá receber um evento de aviso ao descrever o serviço usando o seguinte comando:

kubectl describe svc store-v1-lb-svc`

Events:
  Type     Reason                   Age      From                     Message
  ----     ------                   ----     ----                     -------
  Warning  UnsupportedConfiguration 4m55s    loadbalancer-controller  Weighted load balancing by pods-per-node has no effect with External Traffic Policy: Cluster.

Para ativar o balanceamento de carga ponderado, defina externalTrafficPolicy: Local.

A seguir

• Para uma visão geral dos serviços do balanceador de carga, consulte Serviços do LoadBalancer.
• Para uma descrição dos parâmetros dos serviços do balanceador de carga, consulte Parâmetros do serviço LoadBalancer.
• Resolver problemas de balanceamento de carga no GKE.