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

Nesta página, mostramos como implantar um balanceador de carga de rede de proxy 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 rede de proxy 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 rede de proxy interno entre regiões para back-ends de NEG de conectividade híbrida e zonal (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).

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:

• Cloud VPN
• Cloud Interconnect

Importante: não prossiga com as instruções nesta página antes de configurar a conectividade híbrida entre seus ambientes.

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.

Configurar as sub-redes de back-end

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

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.

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.

Importante: não tente atribuir endereços da sub-rede somente proxy à regra de encaminhamento ou aos back-ends do seu balanceador de carga. Atribua o endereço IP da regra de encaminhamento e os endereços IP da instância de back-end de um intervalo (ou intervalos) de sub-redes diferente, não este aqui. O Google Cloud reserva esse intervalo de sub-redes para proxies gerenciados pelo Google Cloud.

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:

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

   Acessar redes VPC

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

Crie a sub-rede somente proxy em REGION_B

1. Clique em Add subnet.
2. Forneça um Nome para a sub-rede somente proxy.
3. Na lista Região, selecione REGION_B.
4. Na lista Finalidade, selecione Proxy gerenciado entre regiões.
5. No campo Intervalo de endereços IP, insira 10.130.0.0/23.
6. 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 allow-ssh de destino para identificar as VMs a que isso 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

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
   

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 REGION1. Primeiro, crie as VMs na zona NEG_ZONE1. Em seguida, crie um NEG zonal no mesmo NEG_ZONE2 e adicione os endpoints de rede das VMs ao NEG. Para oferecer suporte à alta disponibilidade, configuramos um NEG zonal semelhante na região REGION2. Se os back-ends de uma região ficarem inativos, o tráfego fará o failover para a outra região.

Criar VMs

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: NEG_ZONE1 na região REGION_A
     • Sub-rede SUBNET_A
   • Nome de vm-b1
     • Zona: NEG_ZONE2 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 o sistema operacional Debian e a versão 10 (buster) estão selecionados 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.

• VM_NAME de vm-a1
  • A zona GCP_NEG_ZONE como NEG_ZONE1 na região REGION_A
  • A sub-rede LB_SUBNET_NAME como SUBNET_A

• VM_NAME de vm-b1

  • Zona GCP_NEG_ZONE como NEG_ZONE2 na região REGION_B
  • Sub-rede LB_SUBNET_NAME como SUBNET_B

  gcloud compute instances create VM_NAME \
      --zone=GCP_NEG_ZONE \
      --image-family=debian-10 \
      --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'
  

Criar o NEG zonal

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: NEG_ZONE1 na região REGION_A
     • Sub-rede SUBNET_A
   • Nome: neg-2
     • Zona: NEG_ZONE2 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.

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

   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
   

   É 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=NEG_ZONE1 \
       --add-endpoint='instance=vm-a1,port=80'
   

   gcloud compute network-endpoint-groups update neg2 \
       --zone=NEG_ZONE2 \
       --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.

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:

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.

   • 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

   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
   

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.

Configurar o balanceador de carga

Console

Observação: não é possível usar o console do Google Cloud para criar um balanceador de carga que tenha back-ends de NEG de conectividade híbrida e zonal mistos em um único serviço de back-end. Use o gcloud ou a API REST.

gcloud

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

   gcloud compute health-checks create tcp gil4-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=TCP \
     --enable-logging \
     --logging-sample-rate=1.0 \
     --health-checks=gil4-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=CONNECTION \
     --max-connections-per-endpoint=MAX_CONNECTIONS \
     --network-endpoint-group=neg1 \
     --network-endpoint-group-zone=NEG_ZONE1 \
     --network-endpoint-group=neg2 \
     --network-endpoint-group-zone=NEG_ZONE2
   

   Para detalhes sobre como configurar o modo de balanceamento, consulte a documentação da CLI gcloud para a flag --max-connections-per-endpoint. Em MAX_CONNECTIONS, insira o máximo de conexões simultâneas para o back-end processar.

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=CONNECTION \
     --max-connections-per-endpoint=MAX_CONNECTIONS \
     --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-connections-per-endpoint. Em MAX_CONNECTIONS, insira o máximo de conexões simultâneas para o back-end processar.

5. Crie o proxy de destino.

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

   gcloud compute target-tcp-proxies create gil4-tcp-proxy \
     --url-map=gil4-map \
     --global
   

6. Crie duas regras de encaminhamento, uma com um IP_ADDRESS1 VIP em REGION_A e outra com um VIP IP_ADDRESS2 em 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.

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

   gcloud compute forwarding-rules create gil4-forwarding-rule-a \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_A \
     --subnet-region=REGION_A \
     --address=IP_ADDRESS1 \
     --ports=80 \
     --target-tcp-proxy=gil4-tcp-proxy \
     --global
   

   gcloud compute forwarding-rules create gil4-forwarding-rule-b \
     --load-balancing-scheme=INTERNAL_MANAGED \
     --network=NETWORK \
     --subnet=SUBNET_B \
     --subnet-region=REGION_B \
     --address=IP_ADDRESS2 \
     --ports=80 \
     --target-tcp-proxy=gil4-tcp-proxy \
     --global
   

Testar o balanceador de carga

Criar uma instância de VM para testar a conectividade

1. Crie VMs cliente em REGION_A e REGION_B e regiões:

   gcloud compute instances create l4-ilb-client-a \
       --image-family=debian-10 \
       --image-project=debian-cloud \
       --network=NETWORK \
       --subnet=SUBNET_A \
       --zone=NEG_ZONE1 \
       --tags=allow-ssh
   

   gcloud compute instances create l4-ilb-client-b \
       --image-family=debian-10 \
       --image-project=debian-cloud \
       --network=NETWORK \
       --subnet=SUBNET_B \
       --zone=NEG_ZONE2 \
       --tags=allow-ssh
   

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

   gcloud compute ssh l4-ilb-client-a \
      --zone=NEG_ZONE1
   

   gcloud compute ssh l4-ilb-client-b \
      --zone=NEG_ZONE2
   

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

Executar 100 solicitações

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

• 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
  }
  

Testar o failover

1. 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=CONNECTION \
      --network-endpoint-group=neg2 \
      --network-endpoint-group-zone=NEG_ZONE2
   

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

   gcloud compute ssh l4-ilb-client-b \
      --zone=NEG_ZONE2
   

3. Envie solicitações para o endereço IP com carga balanceada na região REGION_B. A resposta ao comando precisa exibir respostas das VMs de back-end em REGION_A:

   {
   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
   }
   

A seguir

• Visão geral do balanceador de carga de rede de proxy interno
• Sub-redes somente proxy para balanceadores de carga baseados em Envoy
• Limpar uma configuração de balanceamento de carga