Configure um balanceador de carga de rede de proxy interno entre regiões com conetividade híbrida

Esta página mostra como implementar um Network Load Balancer de proxy interno entre regiões para equilibrar a carga do tráfego para pontos finais de rede nas instalações ou noutras nuvens públicas e que são acessíveis através da conetividade híbrida.

Se ainda não o fez, reveja a vista geral dos NEGs de conetividade híbrida para compreender os requisitos de rede para configurar o equilíbrio de carga híbrido.

Vista geral da configuração

O exemplo configura um Network Load Balancer de proxy interno entre regiões para back-ends de NEG híbridos e zonais mistos, conforme mostrado na figura seguinte:

Exemplo de balanceador de carga de rede de proxy interno entre regiões para back-ends de NEG híbridos e zonais mistos.
Exemplo de equilibrador de carga de rede de proxy interno entre regiões para back-ends de NEG híbridos e zonais mistos (clique para aumentar).

Tem de configurar a conetividade híbrida antes de configurar uma implementação de equilíbrio de carga híbrida. Consoante o produto de conetividade híbrida que escolher, use o Cloud VPN ou o Cloud Interconnect (dedicado ou de parceiros).

Autorizações

Para configurar o equilíbrio de carga híbrido, tem de ter as seguintes autorizações:

  • Ativar Google Cloud

  • No seu ambiente local ou noutro ambiente que não seja deGoogle Cloud nuvem

    • Autorizações para configurar pontos finais de rede que permitem que os serviços no seu ambiente no local ou noutros ambientes de nuvem sejam acessíveis a partir deGoogle Cloud através de uma combinação IP:Port. Para mais informações, contacte o administrador de rede do seu ambiente.
    • Autorizações para criar regras de firewall no seu ambiente nas instalações ou noutros ambientes na nuvem para permitir que as sondas de verificação de estado da Google alcancem os pontos finais.

Além disso, para concluir as instruções nesta página, tem de criar um NEG de conetividade híbrida, um equilibrador de carga e NEGs zonais (e os respetivos pontos finais) para funcionarem como back-ends baseados em Google Cloudpara o equilibrador de carga.

Deve ser proprietário ou editor do projeto, ou ter as seguintes funções do IAM do Compute Engine.

Tarefa Função necessária
Crie redes, sub-redes e componentes do balanceador de carga Administrador de rede de Calcular (roles/compute.networkAdmin)
Adicione e remova regras de firewall Administrador de segurança da computação (roles/compute.securityAdmin)
Crie instâncias Administrador de instância de computação (roles/compute.instanceAdmin)

Estabeleça conetividade híbrida

O seu Google Cloud ambiente nas instalações ou outros ambientes na nuvem têm de estar ligados através de conetividade híbrida com anexos de VLAN do Cloud Interconnect ou túneis do Cloud VPN com VMs do Cloud Router ou do dispositivo de router. Recomendamos que use uma ligação de alta disponibilidade.

Um Cloud Router ativado com encaminhamento dinâmico global sabe mais sobre o ponto final específico através do protocolo de gateway de fronteira (BGP) e programa-o na sua Google Cloud rede VPC. O encaminhamento dinâmico regional não é suportado. As rotas estáticas também não são suportadas.

Pode usar a mesma rede ou uma rede VPC diferente no mesmo projeto para configurar a rede híbrida (Cloud Interconnect, Cloud VPN ou uma VM de dispositivo de encaminhamento) e o equilibrador de carga. Tenha em atenção o seguinte:

  • Se usar redes VPC diferentes, as duas redes têm de estar ligadas através do peering de redes VPC ou têm de ser raios VPC no mesmo hub do Network Connectivity Center.

  • Se usar a mesma rede VPC, certifique-se de que os intervalos 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, os caminhos de sub-rede têm prioridade sobre a conetividade remota.

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

Configure o seu ambiente externo ao domínio Google Cloud

Execute os passos seguintes para configurar o seu ambiente no local ou outro ambiente de nuvem para o equilíbrio de carga híbrido:

  • Configure pontos finais de rede para expor serviços no local a Google Cloud (IP:Port).
  • Configure regras de firewall no seu ambiente nas instalações ou noutro ambiente na nuvem.
  • Configure o Cloud Router para anunciar determinadas rotas necessárias ao seu ambiente privado.

Configure pontos finais de rede

Depois de configurar a conetividade híbrida, configura um ou mais pontos finais de rede no seu ambiente nas instalações ou noutros ambientes na nuvem que são acessíveis através do Cloud Interconnect ou do Cloud VPN ou do dispositivo Router usando uma combinação IP:port. Esta IP:port combinação é configurada como um ou mais pontos finais para o NEG de conetividade híbrida que é criado Google Cloud mais tarde neste processo.

Se existirem vários caminhos para o ponto final IP, o encaminhamento segue o comportamento descrito na vista geral do Cloud Router.

Configure regras de firewall

As seguintes regras de firewall têm de ser criadas no seu ambiente nas instalações ou noutro ambiente na nuvem:

  • Crie uma regra de firewall de permissão de entrada em ambientes no local ou noutras nuvens para permitir que o tráfego da sub-rede só de proxy da região alcance os pontos finais.

  • Não é necessário permitir tráfego dos intervalos de sondas de verificação de estado da Google para NEGs híbridos. No entanto, se estiver a usar uma combinação de NEGs híbridos e zonais num único serviço de back-end, tem de permitir o tráfego dos intervalos de sondas de verificação de estado da Google para os NEGs zonais.

Configure o Cloud Router para anunciar os seguintes intervalos de IP personalizados ao seu ambiente nas instalações ou outro ambiente na nuvem:

  • O intervalo da sub-rede só de proxy da região.

Configure o Google Cloud ambiente

Para os passos seguintes, certifique-se de que usa a mesma rede VPC (denominada NETWORK neste procedimento) que foi usada para configurar a conetividade híbrida entre os ambientes.

Além disso, certifique-se de que as regiões usadas (denominadas REGION_A e REGION_B neste procedimento) são as mesmas que as usadas para criar o túnel da Cloud VPN ou as associações de VLAN do Cloud Interconnect.

Configure as sub-redes de back-end

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

Consola

  1. Na Google Cloud consola, aceda à página Redes VPC.

    Aceda a redes de VPC

  2. Aceda à rede que foi usada para configurar a conetividade híbrida entre os ambientes.

  3. Na secção Subnets (Sub-redes):

    • Defina o Subnet creation mode (Modo de criação de sub-rede) como Custom (Personalizado).
    • Na secção Nova sub-rede, introduza as seguintes informações:
      • Indique um Nome para a sub-rede.
      • Selecione uma região: REGION_A
      • Introduza um intervalo de endereços IP.
    • Clique em Concluído.

  4. Clique em Criar.

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

gcloud

  1. Crie sub-redes na rede que foi usada para configurar a conetividade 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 um pedido POST ao método subnetworks.insert. Substitua PROJECT_ID pelo ID do seu 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 um pedido POST ao método subnetworks.insert. Substitua PROJECT_ID pelo ID do seu 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 o seguinte:

  • SUBNET_A e SUBNET_B: o nome das sub-redes
  • LB_SUBNET_RANGE1 e LB_SUBNET_RANGE2: o intervalo de endereços IP para as sub-redes
  • REGION_A e REGION_B: as regiões onde configurou o balanceador de carga

Configure a sub-rede só de proxy

Uma sub-rede apenas de proxy fornece um conjunto de endereços IP que a Google usa para executar proxies do Envoy em seu nome. Os proxies terminam as ligações do cliente e criam novas ligações aos backends.

Esta sub-rede apenas de proxy é usada por todos os equilibradores de carga regionais baseados no Envoy na mesma região da rede VPC. Só pode existir uma sub-rede só de proxy ativa para uma determinada finalidade, por região e por rede.

Consola

Se estiver a usar a Google Cloud consola, pode esperar e criar a sub-rede apenas de proxy mais tarde na página Equilíbrio de carga.

Se quiser criar a sub-rede apenas de proxy agora, siga estes passos:

  1. Na Google Cloud consola, aceda à página Redes VPC.

    Aceda a redes de VPC

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

Crie a sub-rede só de proxy em REGION_B

  1. Clique em Adicionar sub-rede.
  2. Indique um nome para a sub-rede só de proxy.
  3. Na lista Região, selecione REGION_B.
  4. Na lista Finalidade, selecione Proxy gerido entre regiões.
  5. No campo Intervalo de endereços IP, introduza 10.130.0.0/23.
  6. Clique em Adicionar.

gcloud

Crie as sub-redes só de 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 o seguinte:

  • PROXY_SN_A e PROXY_SN_B: o nome das sub-redes só de proxy
  • PROXY_ONLY_SUBNET_RANGE1 e PROXY_ONLY_SUBNET_RANGE2: o intervalo de endereços IP para as sub-redes só de proxy
  • REGION_A e REGION_B: as regiões onde configurou o balanceador de carga

API

Crie as sub-redes só de proxy com o método subnetworks.insert, substituindo PROJECT_ID pelo ID do seu 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, cria as seguintes regras de firewall para os back-ends do NEG zonal em Google Cloud:

  • fw-allow-health-check: uma regra de entrada, aplicável às instâncias com balanceamento de carga, que permite o tráfego dos sistemas de verificação de funcionamento (130.211.0.0/22 e 35.191.0.0/16). Este exemplo usa a etiqueta de destino allow-health-check para identificar os NEGs zonais aos quais deve ser aplicada.Google Cloud
  • fw-allow-ssh: Uma regra de entrada que permite a conetividade SSH de entrada na porta TCP 22 a partir de qualquer endereço. Pode escolher um intervalo de IPs de origem mais restritivo para esta regra. Por exemplo, pode especificar apenas os intervalos de IPs dos sistemas a partir dos quais vai iniciar sessões SSH. Este exemplo usa a etiqueta de destino allow-ssh para identificar as VMs às quais deve ser aplicada.

  • fw-allow-proxy-only-subnet: uma regra de entrada que permite que as ligações da sub-rede só de proxy alcancem os back-ends do NEG zonal.

Consola

  1. Na Google Cloud consola, aceda à página Políticas de firewall.

    Aceder a Políticas de firewall

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

    1. Introduza um Nome de fw-allow-health-check.
    2. Para Rede, selecione NETWORK.
    3. Em Segmentações, selecione Etiquetas de segmentação especificadas.
    4. Preencha o campo Etiquetas alvo com allow-health-check.
    5. Defina o Filtro de origem como Intervalos IPv4.
    6. Defina os Intervalos IPv4 de origem como 130.211.0.0/22 e 35.191.0.0/16.
    7. Para Protocolos e portas, selecione Protocolos e portas especificados.
    8. Selecione TCP e, em seguida, introduza 80 para o número da porta.
    9. Clique em Criar.

  3. Clique novamente em Criar regra de firewall para criar a regra que permite ligações SSH de entrada:

    1. Nome: fw-allow-ssh
    2. Rede: NETWORK
    3. Prioridade: 1000
    4. Direção do tráfego: entrada
    5. Ação na correspondência: permitir
    6. Objetivos: etiquetas de objetivo especificadas
    7. Etiquetas de segmentação: 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, em seguida, introduza 22 para o número da porta.
    12. Clique em Criar.

  4. Clique novamente em Criar regra de firewall para criar a regra que permite ligações recebidas da sub-rede só de proxy:

    1. Nome: fw-allow-proxy-only-subnet
    2. Rede: NETWORK
    3. Prioridade: 1000
    4. Direção do tráfego: entrada
    5. Ação na correspondência: permitir
    6. Objetivos: etiquetas de objetivo especificadas
    7. Etiquetas de segmentação: allow-proxy-only-subnet
    8. Filtro de origem: intervalos IPv4
    9. Intervalos de 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, em seguida, introduza 80 para 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 funcionamento alcancem as instâncias de back-end na porta TCP 80: Google Cloud 

    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 para permitir a conetividade SSH a VMs com a etiqueta de rede allow-ssh. Quando omite source-ranges, Google Cloud interpreta a regra como 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 firewall de permissão de entrada para a sub-rede só de proxy para permitir que o balanceador de carga 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

Configure o NEG zonal

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

Para este exemplo, configurámos um NEG zonal (com pontos finais do tipo GCE_VM_IP_PORT) no REGION1. Primeiro, crie as VMs na zona NEG_ZONE1. Em seguida, crie um NEG zonal no NEG_ZONE2 e adicione os pontos finais de rede das VMs ao NEG. Para suportar a alta disponibilidade, configuramos um NEG zonal semelhante na região REGION2. Se os back-ends numa região estiverem inativos, o tráfego é transferido para a outra região.

Crie VMs

Consola

  1. Na Google Cloud consola, aceda à página Instâncias de VM.

    Aceder às instâncias de VM

  2. Repita os passos 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 no passo anterior.

  5. Para a Região, escolha conforme indicado no passo anterior.

  6. Para a Zona, escolha conforme indicado no passo anterior.

  7. Na secção Disco de arranque, certifique-se de que a opção Debian GNU/Linux 12 (bookworm) está selecionada para as opções do disco de arranque. Clique em Escolher para alterar a imagem, se necessário.

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

    • Adicione as seguintes etiquetas de rede: allow-ssh,allow-health-check e allow-proxy-only-subnet.
    • Na secção Interfaces de rede, clique em Adicionar uma interface de rede faça as seguintes alterações e, de seguida, clique em Concluído:
      • Rede: NETWORK
      • Subnetwork: conforme indicado no passo anterior.
      • IP interno principal: efémero (automático)
      • IP externo: efémero

    • Expanda Gestão. No campo Automatização, copie e cole o seguinte conteúdo do script. O conteúdo do script é idêntico para todas as 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 seguinte comando e usando estas combinações para o nome da VM e a respetiva zona. Os conteúdos do script são idênticos para ambas as 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

    • ZonaGCP_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-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'

Crie o NEG zonal

Consola

Para criar um grupo de pontos finais de rede zonal:

  1. Na Google Cloud consola, aceda à página Grupos de pontos finais da rede.

    Aceda a Grupos de pontos finais da rede

  2. Repita os passos 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 pontos finais de rede.

  4. Defina o nome conforme indicado no passo anterior.

  5. Selecione o Tipo de grupo de pontos finais da rede: Grupo de pontos finais da rede (zonal).

  6. Selecione a rede: NETWORK

  7. Selecione a sub-rede, conforme indicado no passo anterior.

  8. Selecione a Zona, conforme indicado no passo anterior.

  9. Introduza a Porta predefinida: 80.

  10. Clique em Criar.

Adicione pontos finais ao NEG zonal:

  1. Na Google Cloud consola, aceda à página Grupos de pontos finais da rede.

    Aceda aos grupos de pontos finais da rede

  2. Clique no Nome do grupo de pontos finais de rede criado no passo anterior. É apresentada a página Detalhes do grupo de pontos finais da rede.

  3. Na secção Pontos finais de rede neste grupo, clique em Adicionar ponto final de rede. É apresentada a página Adicionar ponto final de rede.

  4. Selecione uma instância de VM para adicionar os respetivos endereços IP internos como pontos finais de rede. Na secção Interface de rede, é apresentado o nome, a zona e a sub-rede da VM.

  5. Introduza o endereço IP do novo ponto final de rede.

  6. Selecione o Tipo de porta.

    1. Se selecionar Predefinição, o ponto final usa a porta predefinida 80 para todos os pontos finais no grupo de pontos finais da rede. Isto é suficiente para o nosso exemplo porque o servidor Apache está a processar pedidos na porta 80.
    2. Se selecionar Personalizado, introduza o Número da porta do ponto final a usar.

  7. Para adicionar mais pontos finais, clique em Adicionar ponto final de rede e repita os passos anteriores.

  8. Depois de adicionar todos os pontos finais, clique em Criar.

gcloud

  1. Crie NEGs zonais (com pontos finais 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

    Pode especificar uma porta através da opção --default-port enquanto cria o NEG ou especificar um número de porta para cada ponto final, conforme mostrado no passo seguinte.

  2. Adicione pontos finais 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'

Configure o NEG de conetividade híbrida

Ao criar o NEG, use uma zona que minimize a distância geográfica entre o NEG e o seu ambiente nas instalações ou noutra nuvem. Google Cloud

Além disso, se estiver a usar o Cloud Interconnect, a zona usada para criar o NEG está na mesma região onde o anexo do Cloud Interconnect foi configurado.

Os NEGs híbridos só suportam as verificações de estado do Envoy distribuídas.

Consola

Para criar um grupo de pontos finais de rede de conetividade híbrida:

  1. Na Google Cloud consola, aceda à página Grupos de pontos finais da rede.

    Aceda a Grupos de pontos finais da rede

  2. Clique em Criar grupo de pontos finais de rede.

  3. Repita os passos 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 no passo anterior.

  5. Selecione o tipo de grupo de pontos finais da rede: grupo de pontos finais da rede de conetividade híbrida (zonal).

  6. Selecione a rede: NETWORK

  7. Para a Subnet, escolha conforme indicado no passo anterior.

  8. Para a Zona, escolha conforme indicado no passo anterior.

  9. Introduza a porta predefinida.

  10. Clique em Criar

Adicione pontos finais ao NEG de conetividade híbrida:

  1. Na Google Cloud consola, aceda à página Grupos de pontos finais da rede.

    Aceda a Grupos de pontos finais da rede

  2. Clique no Nome do grupo de pontos finais de rede criado no passo anterior. É apresentada a página Detalhes do grupo de pontos finais da rede.

  3. Na secção Pontos finais de rede neste grupo, clique em Adicionar ponto final de rede. É apresentada a página Adicionar ponto final de rede.

  4. Introduza o endereço IP do novo ponto final de rede.

  5. Selecione o Tipo de porta.

    1. Se selecionar Predefinição, o ponto final usa a porta predefinida para todos os pontos finais no grupo de pontos finais de rede.
    2. Se selecionar Personalizado, pode introduzir um Número de porta diferente para o ponto final usar.

  6. Para adicionar mais pontos finais, clique em Adicionar ponto final de rede e repita os passos anteriores.

  7. Depois de adicionar todos osGoogle Cloud pontos finais que não sejam de serviço Web, clique em Criar.

gcloud

  1. Crie um NEG de conetividade híbrida que use as seguintes combinações de nomes. 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 ponto final da VM do back-end no 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"

Pode usar este comando para adicionar os pontos finais de rede que configurou anteriormente no local ou no seu ambiente de nuvem. Repita --add-endpoint quantas vezes forem necessárias.

Configure o balanceador de carga

Consola

gcloud

  1. Defina a verificação de funcionamento 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 e ative o registo 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 ver detalhes sobre a configuração do modo de balanceamento, consulte a documentação da CLI gcloud para a flag --max-connections-per-endpoint. Para MAX_CONNECTIONS, introduza o número máximo de ligações simultâneas que o back-end pode processar.

  4. Adicione os NEGs híbridos como 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 ver detalhes sobre a configuração do modo de equilíbrio, consulte a documentação da CLI gcloud para o parâmetro --max-connections-per-endpoint. Para MAX_CONNECTIONS, introduza o número máximo de ligações simultâneas que o back-end pode 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 \
  --backend-service=BACKEND_SERVICE \
  --global

  6. Crie duas regras de encaminhamento, uma com um VIP IP_ADDRESS1 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_RANGE1LB_SUBNET_RANGE2 ou LB_SUBNET_RANGE1LB_SUBNET_RANGE2. Se tentar usar a sub-rede apenas de proxy, a criação da regra de encaminhamento falha.

    Para redes personalizadas, tem de fazer referência à sub-rede na regra de encaminhamento. Tenha em atenção que esta é a sub-rede da VM e não a sub-rede do proxy.

    Use o comando gcloud compute forwarding-rules create com as flags 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

Teste o balanceador de carga

Crie uma instância de VM para testar a conetividade

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

    gcloud compute instances create l4-ilb-client-a \
    --image-family=debian-12 \
    --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-12 \
    --image-project=debian-cloud \
    --network=NETWORK \
    --subnet=SUBNET_B \
    --zone=NEG_ZONE2 \
    --tags=allow-ssh

  2. Use o SSH para estabelecer ligação 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á a publicar o respetivo nome do anfitrião.

    • Confirme se a VM do cliente consegue alcançar ambos os endereços IP. O comando deve ser bem-sucedido e devolver o nome da VM de back-end que processou o pedido:

      curl IP_ADDRESS1

      curl IP_ADDRESS2

Executar 100 pedidos

Execute 100 pedidos curl e confirme pelas respostas que estão com equilíbrio de carga.

  • Confirme se a VM do cliente consegue alcançar ambos os endereços IP. O comando deve ser bem-sucedido e devolver o nome da VM de back-end que serviu o pedido:

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

Teste de comutação por falha

  1. Validar a comutação por falha para back-ends na região REGION_A quando os back-ends na região REGION_B não estão em bom estado ou estão inacessíveis. Simulamos isto 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 o SSH para estabelecer ligação à VM do cliente em REGION_B.

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

  3. Envie pedidos para o endereço IP com balanceamento de carga na região REGION_B. O resultado do comando deve apresentar respostas das VMs de back-end em REGION_A.

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

O que se segue?