Configurar um balanceador de carga de aplicativo interno entre regiões com conectividade híbrida

Console

1. No Console do Google Cloud, acesse a página Redes VPC.

   Acessar redes VPC

2. Acesse a rede usada para configurar a conectividade híbrida entre os ambientes.

3. Na seção Sub-redes:

   • Defina o Modo de criação de sub-rede como Personalizado.
   • Na seção Nova sub-rede, insira as informações a seguir:
     • Forneça um Nome para a sub-rede.
     • Selecione uma Região: REGION_A
     • Digite um Intervalo de endereço IP.
   • Clique em Concluído.

4. Clique em Criar.

5. Para adicionar mais sub-redes em regiões diferentes, clique em Adicionar sub-rede e repita as etapas anteriores para REGION_B

gcloud

1. Crie sub-redes na rede que foram usadas para configurar a conectividade híbrida entre os ambientes.

   gcloud compute networks subnets create SUBNET_A \
       --network=NETWORK \
       --range=LB_SUBNET_RANGE1 \
       --region=REGION_A
   

   gcloud compute networks subnets create SUBNET_B \
       --network=NETWORK \
       --range=LB_SUBNET_RANGE2 \
       --region=REGION_B
   

API

Faça uma solicitação POST ao método subnetworks.insert. Substitua PROJECT_ID pelo ID do projeto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/subnetworks

{
 "name": "SUBNET_A",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "ipCidrRange": "LB_SUBNET_RANGE1",
 "region": "projects/PROJECT_ID/regions/REGION_A",
}

Faça uma solicitação POST ao método subnetworks.insert. Substitua PROJECT_ID pelo ID do projeto.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/subnetworks

{
 "name": "SUBNET_B",
 "network": "projects/PROJECT_ID/global/networks/NETWORK",
 "ipCidrRange": "LB_SUBNET_RANGE2",
 "region": "projects/PROJECT_ID/regions/REGION_B",
}

Substitua:

• SUBNET_A e SUBNET_B: o nome das sub-redes
• LB_SUBNET_RANGE1 e LB_SUBNET_RANGE2: o intervalo de endereços IP das sub-redes
• REGION_A e REGION_B: as regiões em que o balanceador de carga foi configurado.

Console

1. No Console do Google Cloud, acesse a página políticas de Firewall.

   Acessar as políticas de firewall

2. Clique em Criar regra de firewall para criar a regra que permite o tráfego de sondagens de verificação de integridade:

   1. Informe um Nome de fw-allow-health-check.
   2. Em Rede, selecione NETWORK.
   3. Em Destinos, selecione Specified target tags.
   4. Preencha o campo Tags de destino com allow-health-check.
   5. Defina Filtro de origem como Intervalos IPv4.
   6. Defina Intervalos IPv4 de origem como 130.211.0.0/22 e 35.191.0.0/16.
   7. Em Protocolos e portas, selecione Protocolos e portas especificados.
   8. Selecione TCP e insira 80 como o número da porta.
   9. Clique em Criar.

3. Clique em Criar regra de firewall novamente para criar a regra e permitir conexões SSH de entrada:

   1. Name: fw-allow-ssh
   2. Rede: NETWORK
   3. Prioridade: 1000
   4. Direção do tráfego: entrada
   5. Ação se houver correspondência: permitir
   6. Destinos: tags de destino especificadas
   7. Tags de meta: allow-ssh
   8. Filtro de origem: intervalos IPv4
   9. Intervalos IPv4 de origem: 0.0.0.0/0
   10. Protocolos e portas: escolha Protocolos e portas especificados.
   11. Selecione TCP e insira 22 como o número da porta.
   12. Clique em Criar.

4. Clique em Criar regra de firewall novamente para criar a regra que permite conexões de entrada da sub-rede somente proxy:

   1. Name: fw-allow-proxy-only-subnet
   2. Rede: NETWORK
   3. Prioridade: 1000
   4. Direção do tráfego: entrada
   5. Ação se houver correspondência: permitir
   6. Destinos: tags de destino especificadas
   7. Tags de meta: allow-proxy-only-subnet
   8. Filtro de origem: intervalos IPv4
   9. Intervalos IPv4 de origem: PROXY_ONLY_SUBNET_RANGE1 e PROXY_ONLY_SUBNET_RANGE2
   10. Protocolos e portas: escolha Protocolos e portas especificados.
   11. Selecione TCP e insira 80 como o número da porta.
   12. Clique em Criar.

gcloud

1. Crie a regra fw-allow-health-check-and-proxy para permitir que as verificações de integridade do Google Cloud alcancem as instâncias de back-end na porta TCP 80:

   gcloud compute firewall-rules create fw-allow-health-check \
       --network=NETWORK \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-health-check \
       --source-ranges=130.211.0.0/22,35.191.0.0/16 \
       --rules=tcp:80
   

2. Crie a regra de firewall fw-allow-ssh que permita a conectividade SSH para VMs com a tag de rede allow-ssh. Se você omitir source-ranges, o Google Cloud interpretará que a regra autoriza a conexão proveniente de qualquer origem.

   gcloud compute firewall-rules create fw-allow-ssh \
       --network=NETWORK \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-ssh \
       --rules=tcp:22
   

3. Crie uma regra de permissão de entrada de firewall para a sub-rede somente proxy para permitir que o balanceador de carga se comunique com instâncias de back-end na porta TCP 80:

   gcloud compute firewall-rules create fw-allow-proxy-only-subnet \
       --network=NETWORK \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-proxy-only-subnet \
       --source-ranges=PROXY_ONLY_SUBNET_RANGE1,PROXY_ONLY_SUBNET_RANGE2 \
       --rules=tcp:80
   

Console

1. No console do Google Cloud, acesse a página Instâncias de VMs.

   Acessar instâncias de VM

2. Repita as etapas de 3 a 8 para cada VM, usando as seguintes combinações de nome e zona.

   • Nome de vm-a1
     • Zona: ZONE_A na região REGION_A
     • Sub-rede SUBNET_A
   • Nome de vm-b1
     • Zona: ZONE_B na região REGION_B
     • Sub-rede SUBNET_B

3. Clique em Criar instância.

4. Defina o nome conforme indicado na etapa anterior.

5. Em Região, escolha o indicado na etapa anterior.

6. Em Zona, escolha conforme indicado na etapa anterior.

7. Na seção Disco de inicialização, verifique se Debian GNU/Linux 12 (bookworm) está selecionado para as opções de disco de inicialização. Clique em Escolher para alterar a imagem se necessário.

8. Na seção Opções avançadas, expanda Rede e faça o seguinte:

   • Adicione as seguintes tags de rede: allow-ssh allow-health-check e allow-proxy-only-subnet.
   • Na seção Interfaces de rede, clique em Adicionar uma interface de rede faça as seguintes alterações e clique em Concluído:
     .
     • Rede: NETWORK
     • Sub-rede: conforme indicado na etapa anterior.
     • IP interno primário: temporário (automático)
     • IP externo: temporário

   • Expanda Gerenciamento. No campo Automação, copie e cole o conteúdo de script a seguir. O conteúdo do script é o mesmo para as quatro VMs.

     #! /bin/bash
     apt-get update
     apt-get install apache2 -y
     a2ensite default-ssl
     a2enmod ssl
     vm_hostname="$(curl -H "Metadata-Flavor:Google" \
     http://metadata.google.internal/computeMetadata/v1/instance/name)"
     echo "Page served from: $vm_hostname" | \
     tee /var/www/html/index.html
     systemctl restart apache2
     

9. Clique em Criar.

gcloud

Crie as VMs executando o comando a seguir duas vezes, usando essas combinações para o nome da VM e a zona dela. O conteúdo do script é idêntico para as duas VMs.

gcloud compute instances create VM_NAME \
    --zone=GCP_NEG_ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-health-check,allow-proxy-only-subnet \
    --subnet=LB_SUBNET_NAME \
    --metadata=startup-script='#! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      systemctl restart apache2'

• VM_NAME de vm-a1
  • A zona GCP_NEG_ZONE como ZONE_A na região REGION_A
  • A sub-rede LB_SUBNET_NAME como SUBNET_A
• VM_NAME de vm-b1
  • Zona GCP_NEG_ZONE como ZONE_B na região REGION_B
  • Sub-rede LB_SUBNET_NAME como SUBNET_B

Console

Para criar um grupo de endpoints de rede zonal:

1. No console do Google Cloud, acesse a página Grupos de endpoints da rede.

   Acessar grupos de endpoints da rede

2. Repita as etapas de 3 a 8 para cada NEG zonal, usando as seguintes combinações de nome e zona:

   • Nome: neg-1
     • Zona: ZONE_A na região REGION_A
     • Sub-rede SUBNET_A
   • Nome: neg-2
     • Zona: ZONE_B na região REGION_B
     • Sub-rede SUBNET_B

3. Clique em Criar grupo de endpoints de rede.

4. Defina o nome conforme indicado na etapa anterior.

5. Selecione o Tipo de grupo de endpoints da rede: Grupo de endpoints da rede (Zonal).

6. Selecione a Rede: NETWORK

7. Selecione a Sub-rede conforme indicado na etapa anterior.

8. Selecione a Zona como indicado na etapa anterior.

9. Insira a Porta padrão: 80.

10. Clique em Criar.

Adicione endpoints ao NEG zonal:

1. No console do Google Cloud, acesse a página Grupos de endpoints da rede.

   Acessar os grupos de endpoints de rede

2. Clique no Nome do grupo de endpoints da rede criado na etapa anterior. Você verá a página Detalhes do grupo de endpoints da rede.

3. Na seção Endpoints da rede neste grupo, clique em Adicionar endpoint da rede. Você verá a página Adicionar endpoint de rede.

4. Selecione uma instância de VM para adicionar endereços IP internos como endpoints da rede. Na seção Interface de rede, são exibidos o nome, a zona e a sub-rede da VM.

5. Insira o endereço IP do novo endpoint da rede.

6. Selecione o Tipo de porta.

   1. Se você selecionar Padrão, o endpoint usará a porta padrão 80 para todos os endpoints no grupo de endpoints da rede. Isso é suficiente para nosso exemplo, porque o servidor Apache está atendendo solicitações na porta 80.
   2. Se você selecionar Personalizado, insira o Número da porta do endpoint que será usado.

7. Para adicionar mais endpoints, clique em Adicionar endpoint da rede e repita as etapas anteriores.

8. Depois de adicionar todos os endpoints, clique em Criar.

gcloud

1. Crie NEGs zonais (com endpoints GCE_VM_IP_PORT) usando as combinações de nome, zona e sub-rede. Use o comando gcloud compute network-endpoint-groups create.

   gcloud compute network-endpoint-groups create GCP_NEG_NAME \
       --network-endpoint-type=GCE_VM_IP_PORT \
       --zone=GCP_NEG_ZONE \
       --network=NETWORK \
       --subnet=LB_SUBNET_NAME
   

   • Nome: neg-1
     • Zona GCP_NEG_ZONE: ZONE_A na região REGION_A
     • Sub-rede LB_SUBNET_NAME: SUBNET_A
   • Nome: neg-2
     • Zona GCP_NEG_ZONE: ZONE_B na região REGION_B
     • Sub-rede LB_SUBNET_NAME: SUBNET_B

   É possível especificar uma porta usando a opção --default-port ao criar o NEG ou especificar um número de porta para cada endpoint, conforme mostrado na próxima etapa.

2. Adicione endpoints a neg1 e neg2.

   gcloud compute network-endpoint-groups update neg1 \
       --zone=ZONE_A \
       --add-endpoint='instance=vm-a1,port=80'
   

   gcloud compute network-endpoint-groups update neg2 \
       --zone=ZONE_B \
       --add-endpoint='instance=vm-b1,port=80'
   

Console

Para criar um grupo de endpoints de rede de conectividade híbrida:

1. No console do Google Cloud, acesse a página Grupos de endpoints da rede.

   Acessar grupos de endpoints da rede

2. Clique em Criar grupo de endpoints de rede.

3. Repita as etapas 4 a 9 para cada NEG híbrido, usando as seguintes combinações de nome e zona.

   • Nome ON_PREM_NEG_NAME: hybrid-1
     • Zona: ON_PREM_NEG_ZONE1
     • Sub-rede SUBNET_A
   • Nome ON_PREM_NEG_NAME: hybrid-2
     • Zona: ON_PREM_NEG_ZONE2
     • Sub-rede SUBNET_B

4. Defina o nome conforme indicado na etapa anterior.

5. Selecione o Tipo de grupo de endpoints da rede: grupo de endpoints da rede de conectividade híbrida (zonal).

6. Selecione a Rede: NETWORK

7. Em Sub-rede, escolha conforme indicado na etapa anterior.

8. Em Zona, escolha conforme indicado na etapa anterior.

9. Insira a Porta padrão.

10. Clique em Criar.

Adicione endpoints ao NEG de conectividade híbrida:

1. No console do Google Cloud, acesse a página Grupos de endpoints da rede.

   Acessar grupos de endpoints da rede

2. Clique no Nome do grupo de endpoints da rede criado na etapa anterior. Você verá a página Detalhes do grupo de endpoints da rede.

3. Na seção Endpoints da rede neste grupo, clique em Adicionar endpoint da rede. Você verá a página Adicionar endpoint de rede.

4. Insira o endereço IP do novo endpoint da rede.

5. Selecione o Tipo de porta.

   1. Se você selecionar Padrão, o endpoint usará a porta padrão para todos os endpoints no grupo de endpoints da rede.
   2. Se você selecionar Personalizado, insira um Número de porta diferente para ser usado pelo endpoint.

6. Para adicionar mais endpoints, clique em Adicionar endpoint da rede e repita as etapas anteriores.

7. Depois de adicionar todos os endpoints que não são do Google Cloud, clique em Criar.

gcloud

1. Crie um NEG de conectividade híbrida que use as combinações de nome a seguir. Use o comando gcloud compute network-endpoint-groups create.

   gcloud compute network-endpoint-groups create ON_PREM_NEG_NAME \
       --network-endpoint-type=NON_GCP_PRIVATE_IP_PORT \
       --zone=ON_PREM_NEG_ZONE \
       --network=NETWORK
   

   • Nome ON_PREM_NEG_NAME: hybrid-1
     • Zona ON_PREM_NEG_ZONE: ON_PREM_NEG_ZONE1
   • Nome ON_PREM_NEG_NAME: hybrid-2
     • Zona GCP_NEG_ZONE: ON_PREM_NEG_ZONE2

2. Adicione o endpoint da VM de back-end local a ON_PREM_NEG_NAME:

   gcloud compute network-endpoint-groups update ON_PREM_NEG_NAME \
       --zone=ON_PREM_NEG_ZONE \
       --add-endpoint="ip=ON_PREM_IP_ADDRESS_1,port=PORT_1" \
       --add-endpoint="ip=ON_PREM_IP_ADDRESS_2,port=PORT_2"
   

Use esse comando para adicionar os endpoints de rede que você configurou anteriormente no local ou no seu ambiente de nuvem. Repita --add-endpoint quantas vezes forem necessárias.

Console

gcloud

1. Defina a verificação de integridade HTTP com o comando gcloud compute health-checks create http.

   gcloud compute health-checks create http gil7-basic-check \
      --use-serving-port \
      --global
   

2. Crie o serviço de back-end para ativar a geração de registros com o comando gcloud compute backend-services create.

   gcloud compute backend-services create BACKEND_SERVICE \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --protocol=HTTP \
     --enable-logging \
     --logging-sample-rate=1.0 \
     --health-checks=gil7-basic-check \
     --global-health-checks \
     --global
   

3. Adicione back-ends ao serviço de back-end com o comando gcloud compute backend-services add-backend.

   gcloud compute backend-services add-backend BACKEND_SERVICE \
     --global \
     --balancing-mode=RATE \
     --max-rate-per-endpoint=MAX_REQUEST_RATE_PER_ENDPOINT \
     --network-endpoint-group=neg1 \
     --network-endpoint-group-zone=ZONE_A \
     --network-endpoint-group=neg2 \
     --network-endpoint-group-zone=ZONE_B
   

   Para detalhes sobre como configurar o modo de balanceamento, consulte a documentação da CLI gcloud para a sinalização --max-rate-per-endpoint.

4. Adicione o NEG híbrido como um back-end ao serviço de back-end.

   gcloud compute backend-services add-backend BACKEND_SERVICE \
     --global \
     --balancing-mode=RATE \
     --max-rate-per-endpoint=MAX_REQUEST_RATE_PER_ENDPOINT \
     --network-endpoint-group=hybrid1 \
     --network-endpoint-group-zone=ON_PREM_NEG_ZONE1 \
     --network-endpoint-group=hybrid2 \
     --network-endpoint-group-zone=ON_PREM_NEG_ZONE2 \
   

   Para detalhes sobre como configurar o modo de balanceamento, consulte a documentação da CLI gcloud para o parâmetro --max-rate-per-endpoint.

5. Crie o mapa de URL com o comando gcloud compute url-maps create.

   gcloud compute url-maps create gil7-map \
     --default-service=BACKEND_SERVICE \
     --global
   

6. Crie o proxy de destino.

   Para HTTP:

   Crie o proxy de destino com o comando gcloud compute target-http-proxies create.

   gcloud compute target-http-proxies create gil7-http-proxy \
     --url-map=gil7-map \
     --global
   

   Para HTTPS:

   Para criar um certificado gerenciado pelo Google, consulte a seguinte documentação:

   • Criar um certificado gerenciado pelo Google emitido pela instância do Certificate Authority Service.
   • Criar um certificado gerenciado pelo Google com autorização de DNS.

   Depois de criar o certificado gerenciado pelo Google, anexe-o ao proxy de destino. Os mapas de certificado não são suportados por balanceadores de carga de aplicativo internos entre regiões.

   Para criar um certificado autogerenciado, consulte a seguinte documentação:

   • Crie uma chave privada e um certificado.

   Atribua os caminhos de arquivo aos nomes de variáveis.

   export LB_CERT=PATH_TO_PEM_FORMATTED_FILE
   

   export LB_PRIVATE_KEY=PATH_TO_PEM_LB_PRIVATE_FILE
   

   Crie um certificado SSL para todas as regiões usando o comando gcloud certificate-manager certificates create.

   gcloud certificate-manager certificates create gilb-certificate \
     --private-key-file=$LB_CERT \
     --certificate-file=$LB_PRIVATE_KEY \
     --scope=all-regions
   

   Use o certificado SSL regional para criar um proxy de destino com o comando gcloud compute target-https-proxies create.

   gcloud compute target-https-proxies create gil7-https-proxy \
     --url-map=gil7-map \
     --certificate-manager-certificates=gilb-certificate \
     --global
   

7. Crie duas regras de encaminhamento, uma com um VIP IP_ADDRESS1 na região REGION_A e outra com um VIP IP_ADDRESS2 na região REGION_B. Para o endereço IP da regra de encaminhamento, use o intervalo de endereços IP LB_SUBNET_RANGE1 ou LB_SUBNET_RANGE2. Se você tentar usar a sub-rede somente proxy, a criação da regra de encaminhamento falhará.

   Para redes personalizadas, referencie a sub-rede na regra de encaminhamento. Observe que esta é a sub-rede da VM, não a do proxy.

   Para HTTP:

   Use o comando gcloud compute forwarding-rules create com as sinalizações corretas.

   gcloud compute forwarding-rules create FWRULE_A \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --subnet-region=REGION_A \
     --address=IP_ADDRESS1 \
     --ports=80 \
     --target-http-proxy=gil7-http-proxy \
     --global
   

   gcloud compute forwarding-rules create FWRULE_B \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_B \
     --subnet-region=REGION_B \
     --address=IP_ADDRESS2 \
     --ports=80 \
     --target-http-proxy=gil7-http-proxy \
     --global
   

   Para HTTPS:

   Crie a regra de encaminhamento usando o comando gcloud compute forwarding-rules create com as sinalizações corretas.

   gcloud compute forwarding-rules create FWRULE_A \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --subnet-region=REGION_A \
     --address=IP_ADDRESS1 \
     --ports=443 \
     --target-https-proxy=gil7-https-proxy \
     --global
   

   gcloud compute forwarding-rules create FWRULE_B \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_B \
     --subnet-region=REGION_B \
     --address=IP_ADDRESS2 \
     --ports=443 \
     --target-https-proxy=gil7-https-proxy \
     --global
   

gcloud

Para criar uma entrada de DNS com um TTL de 30 segundos, use o comando gcloud dns record-sets create.

gcloud dns record-sets create DNS_ENTRY --ttl="30" \
  --type="A" --zone="service-zone" \
  --routing-policy-type="GEO" \
  --routing-policy-data="REGION_A=gil7-forwarding-rule-a@global;REGION_B=gil7-forwarding-rule-b@global" \
  --enable-health-checking

Substitua:

• DNS_ENTRY: nome de domínio ou DNS do conjunto de registros

  Por exemplo, service.example.com.

• REGION_A e REGION_B: as regiões em que o balanceador de carga foi configurado.

API

Crie o registro DNS fazendo uma solicitação POST ao método ResourceRecordSets.create. Substitua PROJECT_ID pelo ID do projeto.

POST https://www.googleapis.com/dns/v1/projects/PROJECT_ID/managedZones/SERVICE_ZONE/rrsets
{
  "name": "DNS_ENTRY",
  "type": "A",
  "ttl": 30,
  "routingPolicy": {
    "geo": {
      "items": [
        {
          "location": "REGION_A",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        },
        {
          "location": "REGION_B",
          "healthCheckedTargets": {
            "internalLoadBalancers": [
              {
                "loadBalancerType": "globalL7ilb",
                "ipAddress": "IP_ADDRESS_B",
                "port": "80",
                "ipProtocol": "tcp",
                "networkUrl": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
                "project": "PROJECT_ID"
              }
            ]
          }
        }
      ]
    }
  }
}

Console

1. No Console do Google Cloud, acesse a página Balanceamento de carga.

   Acessar o "Balanceamento de carga"

2. Clique no nome do balanceador de carga em que está o serviço de back-end a ser editado.

3. Na página Detalhes do balanceador de carga, clique em editEditar.

4. Na página Editar balanceador de carga de aplicativo interno entre regiões, clique em Configuração de back-end.

5. Na página Configuração de back-end, clique em editEditar no serviço de back-end que você quer modificar.

6. Role para baixo e expanda a seção Advanced Configurations.

7. Na seção Detecção de outliers, marque a caixa de seleção Ativar.

8. Clique em editEditar para configurar a detecção de outliers.

   Verifique se as seguintes opções estão configuradas com estes valores:

   Propriedade	Valor
   Erros consecutivos	5
   Interval	1000
   Tempo base de expulsão	30000
   Percentual máximo de expulsão	50
   Como aplicar erros consecutivos	100

   Neste exemplo, a análise de detecção de outliers é executada a cada segundo. Se o número de código de status HTTP 5xx consecutivos recebidos por um proxy Envoy for cinco ou mais, o endpoint de back-end será removido do pool de balanceamento de carga desse proxy Envoy por 30 segundos. Quando a porcentagem de aplicação é definida em 100%, o serviço de back-end aplica a remoção de endpoints não íntegros dos pools de balanceamento de carga desses proxies Envoy específicos sempre que a análise de detecção de outliers é executada. Se as condições de remoção forem atendidas, até 50% dos endpoints de back-end do pool de balanceamento de carga poderão ser removidos.

9. Clique em Salvar.

10. Para atualizar o serviço de back-end, clique em Atualizar.

11. Para atualizar o balanceador de carga, na página Editar balanceador de carga de aplicativo interno entre regiões, clique em Atualizar.

gcloud

1. Exporte o serviço de back-end para um arquivo YAML.

   gcloud compute backend-services export BACKEND_SERVICE_NAME \
     --destination=BACKEND_SERVICE_NAME.yaml --global
   

   Substitua BACKEND_SERVICE_NAME pelo nome do serviço de back-end.

2. Edite a configuração YAML do serviço de back-end para adicionar os campos de detecção de outliers conforme destacado na seguinte configuração YAML, na seção outlierDetection:

   Neste exemplo, a análise de detecção de outliers é executada a cada segundo. Se o número de código de status HTTP 5xx consecutivos recebidos por um proxy Envoy for cinco ou mais, o endpoint de back-end será removido do pool de balanceamento de carga desse proxy Envoy por 30 segundos. Quando a porcentagem de aplicação é definida em 100%, o serviço de back-end aplica a remoção de endpoints não íntegros dos pools de balanceamento de carga desses proxies Envoy específicos sempre que a análise de detecção de outliers é executada. Se as condições de remoção forem atendidas, até 50% dos endpoints de back-end do pool de balanceamento de carga poderão ser removidos.

   name: BACKEND_SERVICE_NAME
   backends:
   - balancingMode: UTILIZATION
     capacityScaler: 1.0
     group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_A/networkEndpointGroups/SERVERLESS_NEG_NAME
   - balancingMode: UTILIZATION
     capacityScaler: 1.0
     group: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION_B/networkEndpointGroups/SERVERLESS_NEG_NAME_2
   outlierDetection:
     baseEjectionTime:
       nanos: 0
       seconds: 30
     consecutiveErrors: 5
     enforcingConsecutiveErrors: 100
     interval:
       nanos: 0
       seconds: 1
     maxEjectionPercent: 50
   port: 80
   selfLink: https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/backendServices/BACKEND_SERVICE_NAME
   sessionAffinity: NONE
   timeoutSec: 30
   ...
   

   Substitua:

   • BACKEND_SERVICE_NAME: o nome do serviço de back-end
   • PROJECT_ID: ID do projeto
   • REGION_A e REGION_B: as regiões em que o balanceador de carga foi configurado.
   • SERVERLESS_NEG_NAME: o nome do primeiro NEG sem servidor
   • SERVERLESS_NEG_NAME_2: o nome do segundo NEG sem servidor

3. Atualize o serviço de back-end importando a configuração mais recente.

   gcloud compute backend-services import BACKEND_SERVICE_NAME \
     --source=BACKEND_SERVICE_NAME.yaml --global
   

   A detecção de outliers agora está ativada no serviço de back-end.