Esta página foi traduzida pela API Cloud Translation.

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

Nesta página, mostramos como implantar um balanceador de carga de aplicativo interno entre regiões para balancear a carga do tráfego para endpoints de rede que estão no local ou em outras nuvens públicas e que podem ser acessados usando conectividade híbrida

Se você ainda não tiver feito isso, leia a Visão geral dos NEGs de conectividade híbridos para entender os requisitos de rede para configurar o balanceamento de carga híbrido.

Visão geral da configuração

O exemplo configura um balanceador de carga de aplicativo interno entre regiões para back-ends de NEG de conectividade híbrida e por zona, conforme mostrado na figura a seguir:

Exemplo de balanceador de carga de aplicativo interno entre regiões para back-ends de NEG de conectividade híbrida e zonal. — Exemplo de balanceador de carga interno de aplicativo entre regiões para back-ends de NEG de conectividade híbrida e por zona (clique para ampliar).

É preciso configurar a conectividade híbrida antes de configurar uma implantação de balanceamento de carga híbrida. Dependendo da escolha do produto de conectividade híbrida, use o Cloud VPN ou o Cloud Interconnect (dedicado ou por parceiro).

Configurar um recurso de certificado SSL

Crie um recurso de certificado SSL do Gerenciador de certificados conforme descrito a seguir:

Recomendamos o uso de um certificado gerenciado pelo Google.

Permissões

Para configurar o balanceamento de carga híbrido, você precisa ter as seguintes permissões:

No Google Cloud
- Permissões para estabelecer conectividade híbrida entre o Google Cloud e seu ambiente local ou outros ambientes de nuvem. Confira a lista de permissões necessárias na documentação relevante do produto Conectividade de rede.
- Permissões para criar um NEG de conectividade híbrida e o balanceador de carga. O papel Administrador do balanceador de carga do Compute (roles/compute.loadBalancerAdmin) contém a permissão necessária para executar as tarefas descritas neste guia.
No local ou em outro ambiente de nuvem que não seja o Google Cloud
- Permissões para configurar endpoints de rede que autorizam os serviços no local ou em outros ambientes de nuvem a serem acessados pelo Google Cloud com uma combinação de IP:Port. Para mais informações, entre em contato com o administrador de rede do ambiente.
- Permissões para criar regras de firewall no seu ambiente local ou em outros ambientes de nuvem para que as sondagens de verificação de integridade do Google alcancem os endpoints.

Além disso, para concluir as instruções nesta página, você precisa criar um NEG híbrido de conectividade, um balanceador de carga e NEGs zonais (e os respectivos endpoints) para servir como back-ends baseados no Google Cloud para o balanceador de carga.

É necessário ser proprietário ou editor de um projeto ou ter os seguintes papéis de IAM do Compute Engine.

Tarefa	Papel necessário
Criar redes, sub-redes e componentes do balanceador de carga	Administrador de rede do Compute (`roles/compute.networkAdmin`)
Adicionar e remover regras de firewall	Administrador de segurança do Compute (`roles/compute.securityAdmin`)
Criar instâncias	Administrador da instância do Compute (`roles/compute.instanceAdmin`)

Estabelecer conectividade híbrida

O Google Cloud e os ambientes locais ou em nuvem precisam ser conectados por uma conectividade híbrida usando anexos da VLAN do Cloud Interconnect ou túneis do Cloud VPN com o Cloud Router. Recomendamos que você use uma conexão de alta disponibilidade.

Um Cloud Router ativado com roteamento dinâmico global aprende sobre o endpoint específico usando o Border Gateway Protocol (BGP) e o programa na sua rede VPC do Google Cloud. O roteamento dinâmico regional não é compatível. Rotas estáticas também não são compatíveis.

A rede VPC que você usa para configurar o Cloud Interconnect ou o Cloud VPN é a mesma rede usada para configurar a implantação do balanceamento de carga híbrido. Verifique se os intervalos de CIDR da sub-rede da rede VPC não entram em conflito com os intervalos CIDR remotos. Quando os endereços IP se sobrepõem, as rotas de sub-rede são priorizadas em relação à conectividade remota.

Para receber instruções, consulte a seguinte documentação:

Configurar o ambiente fora do Google Cloud

Execute as etapas a seguir para configurar seu ambiente local ou outro ambiente de nuvem para balanceamento de carga híbrido:

Configure endpoints da rede para expor serviços locais ao Google Cloud (IP:Port).
Configure regras de firewall no seu ambiente local ou em outro ambiente de nuvem
Configurar o Cloud Router para divulgar determinadas rotas necessárias para seu ambiente particular.

Configurar endpoints da rede

Depois de configurar a conectividade híbrida, você configura um ou mais endpoints de rede no seu ambiente local ou em outros ambientes de nuvem acessíveis pelo Cloud Interconnect ou pelo Cloud VPN usando uma combinação de IP:port. Essa combinação de IP:port é configurada como um ou mais endpoints para o NEG de conectividade híbrida criado no Google Cloud posteriormente neste processo.

Se houver vários caminhos para o endpoint do IP, o roteamento seguirá o comportamento descrito na Visão geral do Cloud Router.

Configurar regras de firewall

As regras de firewall a seguir precisam ser criadas no ambiente local ou em outro ambiente de nuvem:

Crie uma regra de firewall de permissão de entrada no ambiente local ou em outros ambientes de nuvem para permitir que o tráfego da sub-rede somente proxy da região chegue aos endpoints.
Não é necessário adicionar intervalos de sondagem de verificação de integridade do Google à lista de permissões para NEGs híbridos. No entanto, se você estiver usando uma combinação de NEGs híbridos e zonais em um único serviço de back-end, será necessário usar lista de permissões dos intervalos de sondagem de verificação de integridade do Google para NEGs zonais.

Divulgar rotas

Configure o Cloud Router para divulgar os seguintes intervalos de IP personalizados no local ou outro ambiente de nuvem:

O intervalo da sub-rede somente proxy da região.

Configurar o ambiente do Google Cloud

Para as etapas a seguir, certifique-se de usar a mesma rede VPC (chamada NETWORK neste procedimento) usada para configurar a conectividade híbrida entre os ambientes.

Além disso, verifique se as regiões usadas (chamadas REGION_A e REGION_B neste procedimento) são as mesmas usadas para criar o túnel do Cloud VPN ou a VLAN do Cloud Interconnect. anexos.

Se preferir, configure políticas de roteamento de DNS do tipo GEO para rotear o tráfego do cliente para o VIP do balanceador de carga na região mais próxima do cliente durante interrupções regionais.

Configurar as sub-redes de back-end

Use esta sub-rede para criar os back-ends de NEG zonais do balanceador de carga:

Console

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

Acessar redes VPC
Acesse a rede usada para configurar a conectividade híbrida entre os ambientes.
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.
Clique em Criar.
Para adicionar mais sub-redes em regiões diferentes, clique em Adicionar sub-rede e repita as etapas anteriores para REGION_B

gcloud

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.

Configurar a sub-rede somente proxy

Uma sub-rede somente proxy fornece um conjunto de endereços IP que o Google usa para executar proxies Envoy em seu nome. Os proxies encerram as conexões do cliente e criam novas conexões com os back-ends.

Essa sub-rede somente proxy é usada por todos os balanceadores de carga regionais baseados no Envoy na mesma região que a rede VPC . Só pode haver uma sub-rede somente proxy ativa para uma determinada finalidade, por região e por rede.

Console

Se você estiver usando o Console do Google Cloud, poderá esperar e criar a sub-rede somente proxy depois na página Balanceamento de carga.

Se você quiser criar a sub-rede somente proxy agora, siga estas etapas:

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

Acessar redes VPC
Clique no nome da rede VPC.
Na guia Sub-redes, clique em Adicionar sub-rede.
Forneça um Nome para a sub-rede somente proxy.
Na lista Região, selecione REGION_A.
Na lista Finalidade, selecione Proxy gerenciado entre regiões.
No campo Intervalo de endereços IP, insira 10.129.0.0/23.
Clique em Adicionar.

Crie a sub-rede somente proxy em REGION_B

Clique em Add subnet.
Forneça um Nome para a sub-rede somente proxy.
Na lista Região, selecione REGION_B.
Na lista Finalidade, selecione Proxy gerenciado entre regiões.
No campo Intervalo de endereços IP, insira 10.130.0.0/23.
Clique em Adicionar.

gcloud

Crie a sub-rede somente proxy com o comando gcloud compute networks subnets create.

    gcloud compute networks subnets create PROXY_SN_A \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_A \
        --network=NETWORK \
        --range=PROXY_ONLY_SUBNET_RANGE1

    gcloud compute networks subnets create PROXY_SN_B \
        --purpose=GLOBAL_MANAGED_PROXY \
        --role=ACTIVE \
        --region=REGION_B \
        --network=NETWORK \
        --range=PROXY_ONLY_SUBNET_RANGE2

Substitua:

PROXY_SN_A e PROXY_SN_B: o nome das sub-redes apenas de proxy
PROXY_ONLY_SUBNET_RANGE1 e PROXY_ONLY_SUBNET_RANGE2: o intervalo de endereços IP das sub-redes apenas de proxy
REGION_A e REGION_B: as regiões em que o balanceador de carga foi configurado

API

Crie as sub-redes somente proxy com o método subnetworks.insert, substituindo PROJECT_ID pelo ID do projeto.

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

    {
      "name": "PROXY_SN_A",
      "ipCidrRange": "PROXY_ONLY_SUBNET_RANGE1",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_A",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }

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

    {
      "name": " PROXY_SN_B",
      "ipCidrRange": "PROXY_ONLY_SUBNET_RANGE2",
      "network": "projects/PROJECT_ID/global/networks/NETWORK",
      "region": "projects/PROJECT_ID/regions/REGION_B",
      "purpose": "GLOBAL_MANAGED_PROXY",
      "role": "ACTIVE"
    }

Crie regras de firewall

Neste exemplo, você cria as seguintes regras de firewall para os back-ends de NEG zonais no Google Cloud:

fw-allow-health-check: uma regra de entrada, aplicável às instâncias cuja carga está sendo balanceada, que permite o tráfego dos sistemas de verificação de integridade do Google Cloud (130.211.0.0/22 e 35.191.0.0/16). Este exemplo usa a tag de destino allow-health-check para identificar as NEGs de back-end às quais ela deve ser aplicada.
fw-allow-ssh: uma regra de entrada que permite a conectividade SSH de entrada na porta TCP 22 de qualquer endereço. Escolha um intervalo de IP de origem mais restritivo para esta regra. Por exemplo, é possível especificar apenas os intervalos de IP do sistema do qual você inicia sessões SSH. Neste exemplo, usamos a tag de destino allow-ssh para identificar as instâncias de máquina virtual (VM) a que ele deve se aplicar.
fw-allow-proxy-only-subnet: uma regra de entrada que permite que as conexões da sub-rede somente proxy alcancem os back-ends de NEG zonais.

Console

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

Acessar as políticas de firewall
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.
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.
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

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

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
```

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

Configurar o NEG zonal

Para back-ends baseados no Google Cloud, recomendamos que você configure vários NEGs zonais na mesma região em que configurou a conectividade híbrida.

Neste exemplo, configuramos um NEG zonal (com endpoints do tipo GCE_VM_IP_PORT) na região REGION_A. Primeiro, crie as VMs na zona ZONE_A. Em seguida, crie um NEG zonal na zona ZONE_A e adicione os endpoints de rede das VMs a ele. Para oferecer suporte à alta disponibilidade, configuramos um NEG zonal semelhante na região REGION_B. Se os back-ends de uma região ficarem inativos, o tráfego fará o failover para a outra região.

Criar VMs

Console

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

Acessar instâncias de VM
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
Clique em Criar instância.
Defina o nome conforme indicado na etapa anterior.
Em Região, escolha o indicado na etapa anterior.
Em Zona, escolha conforme indicado na etapa anterior.
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.
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
```
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

Criar o NEG zonal

Console

Para criar um grupo de endpoints de rede zonal:

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

Acessar grupos de endpoints da rede
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
Clique em Criar grupo de endpoints de rede.
Defina o nome conforme indicado na etapa anterior.
Selecione o Tipo de grupo de endpoints da rede: Grupo de endpoints da rede (Zonal).
Selecione a Rede: NETWORK
Selecione a Sub-rede conforme indicado na etapa anterior.
Selecione a Zona como indicado na etapa anterior.
Insira a Porta padrão: 80.
Clique em Criar.

Adicione endpoints ao NEG zonal:

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

Acessar os grupos de endpoints de rede
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.
Na seção Endpoints da rede neste grupo, clique em Adicionar endpoint da rede. Você verá a página Adicionar endpoint de rede.
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.
Insira o endereço IP do novo endpoint da rede.
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.
Para adicionar mais endpoints, clique em Adicionar endpoint da rede e repita as etapas anteriores.
Depois de adicionar todos os endpoints, clique em Criar.

gcloud

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.

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'

Configurar o NEG de conectividade híbrida

Ao criar o NEG, use uma zona que minimize a distância geográfica entre o Google Cloud e o ambiente local ou de outra nuvem. Por exemplo, se você estiver hospedando um serviço em um ambiente local em Frankfurt, na Alemanha, será possível especificar a zona europe-west3-a do Google Cloud ao criar o NEG.

Se você estiver usando o Cloud Interconnect, a zona usada para criar o NEG estará na mesma região em que o anexo do Cloud Interconnect foi configurado.

Os NEGs híbridos são compatíveis apenas com as verificações de integridade do Envoy distribuídas.

Console

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

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

Acessar grupos de endpoints da rede
Clique em Criar grupo de endpoints de rede.
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
Defina o nome conforme indicado na etapa anterior.
Selecione o Tipo de grupo de endpoints da rede: grupo de endpoints da rede de conectividade híbrida (zonal).
Selecione a Rede: NETWORK
Em Sub-rede, escolha conforme indicado na etapa anterior.
Em Zona, escolha conforme indicado na etapa anterior.
Insira a Porta padrão.
Clique em Criar.

Adicione endpoints ao NEG de conectividade híbrida:

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

Acessar grupos de endpoints da rede
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.
Na seção Endpoints da rede neste grupo, clique em Adicionar endpoint da rede. Você verá a página Adicionar endpoint de rede.
Insira o endereço IP do novo endpoint da rede.
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.
Para adicionar mais endpoints, clique em Adicionar endpoint da rede e repita as etapas anteriores.
Depois de adicionar todos os endpoints que não são do Google Cloud, clique em Criar.

gcloud

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

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.

Configurar o balanceador de carga

Console

gcloud

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

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

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.

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.

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

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
```

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

Como conectar seu domínio ao balanceador de carga

Depois de criar o balanceador de carga, anote o endereço IP associado a ele, por exemplo, IP_ADDRESS1 e IP_ADDRESS2. Para apontar seu domínio para o balanceador de carga, crie um registro A usando o Cloud DNS ou o serviço de registro de domínio. Se você adicionou vários domínios ao certificado SSL, adicione um registro A para cada um deles, todos apontando para o endereço IP do balanceador de carga.

Testar o balanceador de carga

Criar uma instância de VM para testar a conectividade

Crie uma VM cliente:

gcloud compute instances create l7-ilb-client-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_A \
    --zone=ZONE_A \
    --tags=allow-ssh

gcloud compute instances create l7-ilb-client-b \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_B \
    --zone=ZONE_B \
    --tags=allow-ssh

Use o SSH para se conectar a cada instância do cliente.

gcloud compute ssh l7-ilb-client-a \
   --zone=ZONE_A

gcloud compute ssh l7-ilb-client-b \
   --zone=ZONE_B

Verifique se o endereço IP está exibindo o nome do host.
- Verifique se a VM cliente pode acessar os dois endereços IP. O comando será bem-sucedido e retornará o nome da VM de back-end que veiculou a solicitação:
```
curl IP_ADDRESS1
```
```
curl IP_ADDRESS2
```
  Para fazer teste em HTTPS, substitua curl por:
```
curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS1:443
```
```
curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS2:443
```
  A sinalização -k faz com que o curl ignore a validação do certificado.
- Opcional: use o registro DNS configurado para resolver o endereço IP mais próximo da VM cliente. Por exemplo, DNS_ENTRY pode ser service.example.com.
```
curl DNS_ENTRY
```

Executar 100 solicitações

Execute 100 solicitações curl e confirme se as respostas têm balanceamento de carga.

Para HTTP:

Verifique se a VM cliente pode acessar os dois endereços IP. O comando será bem-sucedido e retornará o nome da VM de back-end que veiculou a solicitação:

{
  RESULTS=
  for i in {1..100}
  do
    RESULTS="$RESULTS:$(curl --silent IP_ADDRESS1)"
  done
  echo "***"
  echo "*** Results of load-balancing to IP_ADDRESS1: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

{
  RESULTS=
  for i in {1..100}
  do
    RESULTS="$RESULTS:$(curl --silent IP_ADDRESS2)"
  done
  echo "***"
  echo "*** Results of load-balancing to IP_ADDRESS2: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

Para HTTPS:

Verifique se a VM cliente pode acessar os dois endereços IP. O comando será bem-sucedido e retornará o nome da VM de back-end que veiculou a solicitação:

{
  RESULTS=
  for i in {1..100}
  do
    RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS1:443)"
  done
  echo "***"
  echo "*** Results of load-balancing to IP_ADDRESS1: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

{
  RESULTS=
  for i in {1..100}
  do
    RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS2:443)"
  done
  echo "***"
  echo "*** Results of load-balancing to IP_ADDRESS2: "
  echo "***"
  echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
  echo
}

Testar o failover

Verifique o failover para back-ends na região REGION_A quando back-ends em REGION_B não estiverem íntegros ou inacessíveis. Simule isso removendo todos os back-ends de REGION_B:
```
gcloud compute backend-services remove-backend BACKEND_SERVICE \
   --balancing-mode=RATE \
   --network-endpoint-group=neg2 \
   --network-endpoint-group-zone=ZONE_B
```

Use SSH para se conectar à VM do cliente em REGION_B.

gcloud compute ssh l7-ilb-client-b \
   --zone=ZONE_B

Envie solicitações ao endereço IP com carga balanceada na região REGION_B. O resultado será assim:

{
RESULTS=
for i in {1..100}
do
  RESULTS="$RESULTS:$(curl -k -s 'https://test.example.com:443' --connect-to test.example.com:443:IP_ADDRESS2:443)"
done
echo "***"
echo "*** Results of load-balancing to IP_ADDRESS2: "
echo "***"
echo "$RESULTS" | tr ':' '\n' | grep -Ev "^$" | sort | uniq -c
echo
}

Outras opções de configuração

Nesta seção, o exemplo é detalhado para fornecer outras opções de configuração. Todas as tarefas são opcionais. É possível realizá-las em qualquer ordem.

Configurar políticas de roteamento de DNS

Se os clientes estiverem em várias regiões, convém tornar o balanceador de carga de aplicativo interno entre regiões acessível por meio de VIPs nessas regiões. Essa configuração multirregional minimiza os custos de latência e trânsito de rede. Além disso, é possível configurar uma solução de balanceamento de carga global baseada em DNS que oferece resiliência contra interrupções regionais. Para mais informações, consulte Gerenciar políticas de roteamento de DNS e verificações de integridade.

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"
              }
            ]
          }
        }
      ]
    }
  }
}

Atualizar tempo limite do sinal de atividade HTTP do cliente

O balanceador de carga criado nas etapas anteriores foi configurado com um valor padrão para o tempo limite do sinal de atividade HTTP do cliente.

Para atualizar o tempo limite do sinal de atividade HTTP do cliente, use as instruções a seguir.

Console

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

Acessar o "Balanceamento de carga"
Clique no nome do balanceador de carga que você quer modificar.
Clique em Editar.
Clique em Configuração de front-end.
Expanda Recursos avançados. Em Tempo limite de sinal de atividade HTTP, insira um valor de tempo limite.
Clique em Atualizar.
Para revisar as alterações, clique em Analisar e finalizar e depois em Atualizar.

gcloud

Para um balanceador de carga HTTP, atualize o proxy HTTP de destino usando o comando gcloud compute target-http-proxies update:

    gcloud compute target-http-proxies update TARGET_HTTP_PROXY_NAME \
        --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
        --global

Para um balanceador de carga HTTPS, atualize o proxy HTTPS de destino usando o comando gcloud compute target-https-proxies update:

    gcloud compute target-https-proxies update TARGET_HTTPS_PROXY_NAME \
        --http-keep-alive-timeout-sec=HTTP_KEEP_ALIVE_TIMEOUT_SEC \
        --global

Substitua:

TARGET_HTTP_PROXY_NAME: o nome do proxy HTTP de destino.
TARGET_HTTPS_PROXY_NAME: o nome do proxy HTTPS de destino.
HTTP_KEEP_ALIVE_TIMEOUT_SEC: o valor do tempo limite do sinal de atividade HTTP de 5 a 600 segundos.

Ativar detecção de outliers

É possível ativar a detecção de outliers em serviços de back-end globais para identificar NEGs sem servidor não íntegros e reduzir o número de solicitações enviadas aos NEGs sem servidor não íntegros.

A detecção de outliers é ativada no serviço de back-end usando um dos seguintes métodos:

O método consecutiveErrors (outlierDetection.consecutiveErrors), em que um código de status HTTP da série 5xx se qualifica como erro.
O método consecutiveGatewayFailure (outlierDetection.consecutiveGatewayFailure), em que apenas os códigos de status HTTP 502, 503 e 504 se qualificam como erros.

Use as etapas a seguir para ativar a detecção de outliers para um serviço de back-end existente. Observe que, mesmo depois de ativar a detecção de outliers, algumas solicitações podem ser enviadas para o serviço não íntegro e retornar um código de status 5xx aos clientes. Para reduzir ainda mais a taxa de erro, configure valores mais agressivos nos parâmetros de detecção de outliers. Para mais informações, consulte o campo outlierDetection.

Console

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

Acessar o "Balanceamento de carga"
Clique no nome do balanceador de carga em que está o serviço de back-end a ser editado.
Na página Detalhes do balanceador de carga, clique em Editar.
Na página Editar balanceador de carga de aplicativo interno entre regiões, clique em Configuração de back-end.
Na página Configuração de back-end, clique em Editar no serviço de back-end que você quer modificar.
Role para baixo e expanda a seção Advanced Configurations.
Na seção Detecção de outliers, marque a caixa de seleção Ativar.

Clique em Editar 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.

Clique em Salvar.
Para atualizar o serviço de back-end, clique em Atualizar.
Para atualizar o balanceador de carga, na página Editar balanceador de carga de aplicativo interno entre regiões, clique em Atualizar.

gcloud

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.

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
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.

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

Visão geral da configuração

Configurar um recurso de certificado SSL

Permissões

Estabelecer conectividade híbrida

Configurar o ambiente fora do Google Cloud

Configurar endpoints da rede

Configurar regras de firewall

Divulgar rotas

Configurar o ambiente do Google Cloud

Configurar as sub-redes de back-end

Console

gcloud

API

Configurar a sub-rede somente proxy

Console

gcloud

API

Crie regras de firewall

Console

gcloud

Configurar o NEG zonal

Criar VMs

Console

gcloud

Criar o NEG zonal

Console

gcloud

Configurar o NEG de conectividade híbrida

Console

gcloud

Configurar o balanceador de carga

Console

gcloud

Como conectar seu domínio ao balanceador de carga

Testar o balanceador de carga

Criar uma instância de VM para testar a conectividade

Executar 100 solicitações

Testar o failover

Outras opções de configuração

Configurar políticas de roteamento de DNS

gcloud

API

Atualizar tempo limite do sinal de atividade HTTP do cliente

Console

gcloud

Ativar detecção de outliers

Console

gcloud

A seguir