Configure um balanceador de carga de rede de passagem interno com back-ends de grupos de instâncias de VM

Este guia usa um exemplo para ensinar os fundamentos dos Google Cloud balanceadores de carga de rede de encaminhamento interno. Antes de seguir este guia, familiarize-se com o seguinte:

• Conceitos do balanceador de carga de rede de encaminhamento interno
• Como funcionam os equilibradores de carga de passagem internos da rede
• Vista geral das regras de firewall
• Conceitos de verificação de saúde

---

Para seguir orientações passo a passo para esta tarefa diretamente na Google Cloud consola, clique em Orientar-me:

Visita guiada

---

Autorizações

Para seguir este guia, tem de criar instâncias e modificar uma rede num projeto. Tem de ser proprietário ou editor do projeto, ou ter todas 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 do Compute (roles/compute.securityAdmin)
Crie instâncias	Administrador de instância de computação (roles/compute.instanceAdmin)

Para mais informações, consulte os seguintes guias:

• Controlo de acesso
• Condições do IAM

Configure o balanceador de carga com sub-redes e back-ends apenas IPv4

Este guia mostra como configurar e testar um Network Load Balancer de encaminhamento interno. Os passos nesta secção descrevem como configurar o seguinte:

1. Um exemplo que usa uma rede VPC no modo personalizado denominada lb-network.
2. Uma sub-rede de pilha única (stack-type definida como IPv4), que é necessária para o tráfego IPv4. Quando cria uma sub-rede de pilha única numa rede de VPC de modo personalizado, escolhe um intervalo de sub-redes IPv4 para a sub-rede.
3. Regras de firewall que permitem ligações de entrada a instâncias de máquinas virtuais (VMs) de back-end.
4. O grupo de instâncias de back-end, que está localizado na seguinte região e sub-rede para este exemplo:
   • Região: us-west1
   • Sub-rede: lb-subnet, com o intervalo de endereços IPv4 principal 10.1.2.0/24.
5. Quatro VMs de back-end: duas VMs num grupo de instâncias não gerido na zona us-west1-a e duas VMs num grupo de instâncias não gerido na zona us-west1-c. Para demonstrar o acesso global, este exemplo cria uma segunda VM de cliente de teste numa região e sub-rede diferentes:
   • Região: europe-west1
   • Sub-rede: europe-subnet, com o intervalo de endereços IP principal 10.3.4.0/24
6. Uma VM cliente para testar as ligações.
7. Os seguintes componentes do balanceador de carga de rede de encaminhamento interno:
   • Uma verificação de funcionamento do serviço de back-end.
   • Um serviço de back-end interno na região us-west1 para gerir a distribuição de ligações aos dois grupos de instâncias zonais.
   • Uma regra de encaminhamento interno e um endereço IP interno para o front-end do balanceador de carga.

Nota: pode alterar o nome da rede, da região e dos parâmetros da sub-rede. No entanto, os passos seguintes neste guia usam os parâmetros de rede, região e sub-rede, conforme descrito nos passos anteriores.

A arquitetura para este exemplo tem o seguinte aspeto:

Exemplo de configuração do balanceador de carga de rede de encaminhamento interno (clique para aumentar).

Nota: para simplificar, este exemplo usa grupos de instâncias não geridos. Na produção, considere usar um grupo de instâncias geridas, conforme ilustrado em Grupos de instâncias geridas.

Configure uma rede, uma região e uma sub-rede

Para criar a rede e a sub-rede de exemplo, siga estes passos.

Consola

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

   Aceda a redes de VPC

2. Clique em Criar rede de VPC.

3. Em Nome, introduza lb-network.

4. Na secção Sub-redes, faça o seguinte:

   1. Defina o Subnet creation mode (Modo de criação de sub-rede) como Custom (Personalizado).
   2. Na secção Nova sub-rede, introduza as seguintes informações:
      • Nome: lb-subnet
      • Região: us-west1
      • Tipo de pilha de IP: IPv4 (pilha única)
      • Intervalo de endereços IP: 10.1.2.0/24
   3. Clique em Concluído.
   4. Clique em Adicionar sub-rede e introduza as seguintes informações:
      • Nome: europe-subnet
      • Região: europe-west1
      • Tipo de pilha de IP: IPv4 (pilha única)
      • Intervalo de endereços IP: 10.3.4.0/24
   5. Clique em Concluído.

5. Clique em Criar.

gcloud

1. Crie a rede VPC personalizada:

   gcloud compute networks create lb-network --subnet-mode=custom
   

2. Na rede lb-network, crie uma sub-rede para os back-ends na região us-west1:

   gcloud compute networks subnets create lb-subnet \
       --network=lb-network \
       --range=10.1.2.0/24 \
       --region=us-west1
   

3. Na rede lb-network, crie outra sub-rede para testar o acesso global na região europe-west1:

   gcloud compute networks subnets create europe-subnet \
       --network=lb-network \
       --range=10.3.4.0/24 \
       --region=europe-west1
   

API

Faça um pedido POST ao método networks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks

{
 "routingConfig": {
   "routingMode": "REGIONAL"
 },
 "name": "lb-network",
 "autoCreateSubnetworks": false
}

Faça dois pedidos POST ao subnetworks.insert método.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks

{
 "name": "lb-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "ipCidrRange": "10.1.2.0/24",
 "privateIpGoogleAccess": false
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/europe-west1/subnetworks

{
 "name": "europe-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
  "ipCidrRange": "10.3.4.0/24",
  "privateIpGoogleAccess": false
}

Configure regras de firewall

Este exemplo usa as seguintes regras de firewall:

• fw-allow-lb-access: uma regra de entrada, aplicável a todos os destinos na rede VPC, que permite o tráfego de origens nos intervalos 10.1.2.0/24 e 10.3.4.0/24. Esta regra permite o tráfego de entrada de qualquer cliente localizado numa das duas sub-redes. Posteriormente, permite-lhe configurar e testar o acesso global.

• fw-allow-ssh: Uma regra de entrada, aplicável às instâncias com balanceamento de carga, 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 do sistema a partir do qual 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-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 estado (130.211.0.0/22 e 35.191.0.0/16). Este exemplo usa a etiqueta de destino allow-health-check para identificar as instâncias às quais deve aplicar-se. Google Cloud

Sem estas regras de firewall, a regra de negação predefinida de entrada bloqueia o tráfego de entrada para as instâncias de back-end.

Nota: tem de criar uma regra de firewall para permitir verificações de funcionamento a partir dos intervalos de IP dos sistemas de sondagem. Google Cloud Para mais informações, consulte os intervalos de IPs de sondagem.

Consola

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

   Aceder a Políticas de firewall

2. Para permitir o tráfego de sub-rede, clique em Criar regra de firewall e introduza as seguintes informações:

   • Nome: fw-allow-lb-access
   • Rede: lb-network
   • Prioridade: 1000
   • Direção do trânsito: entrada
   • Ação na correspondência: permitir
   • Segmenta: todas as instâncias na rede
   • Filtro de origem: intervalos IPv4
   • Intervalos IPv4 de origem: 10.1.2.0/24
   • Protocolos e portas: Permitir tudo

3. Clique em Criar.

4. Para permitir ligações SSH recebidas, clique novamente em Criar regra de firewall e introduza as seguintes informações:

   • Nome: fw-allow-ssh
   • Rede: lb-network
   • Prioridade: 1000
   • Direção do trânsito: entrada
   • Ação na correspondência: permitir
   • Objetivos: etiquetas de destino especificadas
   • Etiquetas de segmentação: allow-ssh
   • Filtro de origem: intervalos IPv4
   • Intervalos IPv4 de origem: 0.0.0.0/0
   • Protocolos e portas: selecione Protocolos e portas especificados, selecione a caixa de verificação TCP e, de seguida, introduza 22 em Portas.

5. Clique em Criar.

6. Para permitir Google Cloud verificações de funcionamento, clique em Criar regra de firewall pela terceira vez e introduza as seguintes informações:

   • Nome: fw-allow-health-check
   • Rede: lb-network
   • Prioridade: 1000
   • Direção do trânsito: entrada
   • Ação na correspondência: permitir
   • Objetivos: etiquetas de destino especificadas
   • Etiquetas de segmentação: allow-health-check
   • Filtro de origem: intervalos IPv4
   • Intervalos de IPv4 de origem: 130.211.0.0/22 e 35.191.0.0/16
   • Protocolos e portas: Permitir tudo

7. Clique em Criar.

gcloud

1. Crie a regra de firewall fw-allow-lb-access para permitir a comunicação a partir de dentro da sub-rede:

   gcloud compute firewall-rules create fw-allow-lb-access \
       --network=lb-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=10.1.2.0/24,10.3.4.0/24 \
       --rules=tcp,udp,icmp
   

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=lb-network \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-ssh \
       --rules=tcp:22
   

3. Crie a regra fw-allow-health-check para permitir Google Cloud verificações de funcionamento.

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

API

Crie a regra de firewall fw-allow-lb-access fazendo um pedido POST ao método firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-allow-lb-access",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [
   "10.1.2.0/24", "10.3.4.0/24"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   },
   {
     "IPProtocol": "udp"
   },
   {
     "IPProtocol": "icmp"
   }
 ],
 "direction": "INGRESS",
 "logConfig": {
   "enable": false
 },
 "disabled": false
}

Crie a regra de firewall fw-allow-ssh fazendo um pedido POST ao método firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-allow-ssh",
      "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [
   "0.0.0.0/0"
 ],
 "targetTags": [
   "allow-ssh"
 ],
 "allowed": [
  {
    "IPProtocol": "tcp",
    "ports": [
      "22"
    ]
  }
 ],
"direction": "INGRESS",
"logConfig": {
  "enable": false
},
"disabled": false
}

Crie a regra de firewall fw-allow-health-check fazendo um pedido POST ao método firewalls.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls

{
 "name": "fw-allow-health-check",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "priority": 1000,
 "sourceRanges": [
   "130.211.0.0/22",
   "35.191.0.0/16"
 ],
 "targetTags": [
   "allow-health-check"
 ],
 "allowed": [
   {
     "IPProtocol": "tcp"
   },
   {
     "IPProtocol": "udp"
   },
   {
     "IPProtocol": "icmp"
   }
 ],
 "direction": "INGRESS",
 "logConfig": {
   "enable": false
 },
 "disabled": false
}

Crie VMs de back-end e grupos de instâncias

Este exemplo usa dois grupos de instâncias não geridos, cada um com duas VMs de back-end (servidor). Para demonstrar a natureza regional dos equilibradores de carga de rede de encaminhamento interno, os dois grupos de instâncias são colocados em zonas separadas, us-west1-a e us-west1-c.

• O grupo de instâncias ig-a contém estas duas VMs:
  • vm-a1
  • vm-a2
• O grupo de instâncias ig-c contém estas duas VMs:
  • vm-c1
  • vm-c2

O tráfego para todas as quatro VMs de back-end é equilibrado por carga.

Para suportar este exemplo e as opções de configuração adicionais, cada uma das quatro VMs executa um servidor Web Apache que escuta nas seguintes portas TCP: 80, 8008, 8080, 8088, 443 e 8443.

A cada VM é atribuído um endereço IP interno no intervalo lb-subnet e um endereço IP externo (público) efémero. Pode remover os endereços IP externos mais tarde.

Não são necessários endereços IP externos para as VMs de back-end. No entanto, são úteis para este exemplo, porque permitem que as VMs de back-end transfiram o Apache da Internet e podem estabelecer ligação através de SSH.

Por predefinição, o Apache está configurado para ser associado a qualquer endereço IP. Os balanceadores de carga de rede de encaminhamento interno fornecem pacotes preservando o IP de destino. Certifique-se de que o software do servidor executado nas VMs de back-end está a ouvir o endereço IP da regra de encaminhamento interno do balanceador de carga. Se configurar várias regras de encaminhamento interno, certifique-se de que o seu software escuta o endereço IP interno associado a cada uma delas. O endereço IP de destino de um pacote enviado para uma VM de back-end por um balanceador de carga de rede de encaminhamento direto interno é o endereço IP interno da regra de encaminhamento.

Para simplificar as instruções, estas VMs de back-end executam o Debian GNU/Linux 12.

Consola

Crie VMs de back-end

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: vm-a1, zona: us-west1-a
   • Nome: vm-a2, zona: us-west1-a
   • Nome: vm-c1, zona: us-west1-c
   • Nome: vm-c2, zona: us-west1-c

3. Clique em Criar instância.

4. Defina o Nome conforme indicado no passo 2.

5. Para Região, selecione us-west1 e escolha uma Zona, conforme indicado no passo 2.

6. 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. Se necessário, clique em Alterar para alterar a imagem.

7. Clique em Opções avançadas.

8. Clique em Rede e configure os seguintes campos:

   1. Para Etiquetas de rede, introduza allow-ssh e allow-health-check.
   2. Para Interfaces de rede, selecione o seguinte:
      • Rede: lb-network
      • Subnet: lb-subnet
      • Tipo de pilha de IP: IPv4 (pilha única)
      • Endereço IPv4 interno principal: efémero (automático)
      • Endereço IPv4 externo: efémero

9. Clique em Gestão e, de seguida, no campo Script de arranque, introduza o seguinte script. O conteúdo do script é idêntico para todas as quatro VMs.

   
   #! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   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
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed
   

10. Clique em Criar.

Crie grupos de instâncias

1. Na Google Cloud consola, aceda à página Grupos de instâncias.

   Aceda a Grupos de instâncias

2. Repita os passos seguintes para criar dois grupos de instâncias não geridos, cada um com duas VMs, usando estas combinações.

   • Nome do grupo de instâncias: ig-a, zona: us-west1-a, VMs: vm-a1 e vm-a2
   • Nome do grupo de instâncias: ig-c, zona: us-west1-c, VMs: vm-c1 e vm-c2

3. Clique em Criar grupo de instâncias.

4. Clique em Novo grupo de instâncias não gerido.

5. Defina o Nome conforme indicado no passo 2.

6. Na secção Localização, selecione us-west1 para Região e, de seguida, escolha uma Zona, conforme indicado no passo 2.

7. Para Rede, selecione lb-network.

8. Para Sub-rede, selecione lb-subnet.

9. Na secção Instâncias de VM, adicione as VMs conforme indicado no passo 2.

10. Clique em Criar.

gcloud

1. Crie as quatro VMs executando o seguinte comando quatro vezes, usando estas quatro combinações para [VM-NAME] e [ZONE]. O conteúdo do script é idêntico para todas as quatro VMs.

   • VM-NAME: vm-a1, ZONE: us-west1-a
   • VM-NAME: vm-a2, ZONE: us-west1-a
   • VM-NAME: vm-c1, ZONE: us-west1-c
   • VM-NAME: vm-c2, ZONE: us-west1-c

     gcloud compute instances create VM-NAME \
         --zone=ZONE \
         --image-family=debian-12 \
         --image-project=debian-cloud \
         --tags=allow-ssh,allow-health-check \
         --subnet=lb-subnet \
         --metadata=startup-script='#! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   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
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed'
   

2. Crie os dois grupos de instâncias não geridos em cada zona:

   gcloud compute instance-groups unmanaged create ig-a \
       --zone=us-west1-a
   gcloud compute instance-groups unmanaged create ig-c \
       --zone=us-west1-c
   

3. Adicione as VMs aos grupos de instâncias adequados:

   gcloud compute instance-groups unmanaged add-instances ig-a \
       --zone=us-west1-a \
       --instances=vm-a1,vm-a2
   gcloud compute instance-groups unmanaged add-instances ig-c \
       --zone=us-west1-c \
       --instances=vm-c1,vm-c2
   

API

Para as quatro VMs, use os seguintes nomes e zonas de VMs:

• VM-NAME: vm-a1, ZONE: us-west1-a
• VM-NAME: vm-a2, ZONE: us-west1-a
• VM-NAME: vm-c1, ZONE: us-west1-c
• VM-NAME: vm-c2, ZONE: us-west1-c

Pode obter o DEBIAN_IMAGE_NAME atual executando o seguinte comando gcloud:

gcloud compute images list \
 --filter="family=debian-12"

Crie quatro VMs de back-end fazendo quatro pedidos POST ao método instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
 "name": "VM-NAME",
 "tags": {
   "items": [
     "allow-health-check",
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/[ZONE]/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "VM-NAME",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/zone/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "metadata": {
   "items": [
     {
       "key": "startup-script",
       "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://metadata.google.internal/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Crie dois grupos de instâncias fazendo um pedido POST ao método instanceGroups.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups

{
 "name": "ig-a",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups

{
 "name": "ig-c",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

Adicione instâncias a cada grupo de instâncias fazendo um pedido POST ao método instanceGroups.addInstances.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a2"
   }
 ]
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c2"
   }
 ]
}

Configure os componentes do balanceador de carga

Estes passos configuram todos os componentes do balanceador de carga de rede de encaminhamento interno, começando pela verificação de estado e pelo serviço de back-end e, em seguida, pelos componentes de front-end:

• Verificação de saúde. Neste exemplo, usa uma verificação de funcionamento de HTTP que procura um código de estado 200 OK HTTP. Para mais informações, consulte a secção Verificação de estado.

• Serviço de back-end. Uma vez que tem de transmitir tráfego HTTP através do balanceador de carga interno, tem de usar o protocolo TCP e não o UDP.

• Regra de encaminhamento. Este exemplo cria uma única regra de encaminhamento interno.

• Endereço IP interno. Neste exemplo, especifica um endereço IP interno, 10.1.2.99, quando cria a regra de encaminhamento.

Consola

Inicie a configuração

1. Na Google Cloud consola, aceda à página Equilíbrio de carga.

   Aceda ao balanceamento de carga

2. Clique em Criar equilibrador de carga.
3. Para Tipo de balanceador de carga, selecione Balanceador de carga de rede (TCP/UDP/SSL) e clique em Seguinte.
4. Para Proxy ou passagem, selecione Passagem do balanceador de carga e clique em Seguinte.
5. Para Público ou interno, selecione Interno e clique em Seguinte.
6. Clique em Configurar.

Configuração básica

Na página Criar balanceador de carga de rede de encaminhamento interno, introduza as seguintes informações:

• Nome do balanceador de carga: be-ilb
• Região: us-west1
• Rede: lb-network

Configure os back-ends

1. Clique em Configuração de back-end.

2. Na lista Verificação de funcionamento, clique em Criar uma verificação de funcionamento e introduza as seguintes informações.

   • Nome: hc-http-80
   • Protocolo: HTTP
   • Porta: 80
   • Protocolo de proxy: Nenhum
   • Pedido: /

   Tenha em atenção que, quando usa a consola para criar o balanceador de carga, a verificação de funcionamento é global. Google Cloud Se quiser criar uma verificação de funcionamento regional, use gcloud ou a API.

3. Clique em Criar.

4. Para processar apenas tráfego IPv4, na secção Novo back-end, para Tipo de pilha de IP, selecione a opção IPv4 (pilha única).

5. Na lista Grupo de instâncias, selecione o grupo de instâncias ig-c e clique em Concluído.

6. Clique em Adicionar um back-end e repita o passo para adicionar o grupo de instâncias ig-a.

7. Verifique se existe uma marca de verificação azul junto a Configuração de back-end antes de continuar.

Configure a interface

1. Clique em Configuração do front-end.
2. Na secção Novo endereço IP e porta de front-end, faça o seguinte:
   1. Em Nome, introduza fr-ilb.
   2. Para Sub-rede, selecione lb-subnet.
   3. Na secção Finalidade do IP interno, na lista Endereço IP, selecione Criar endereço IP, introduza as seguintes informações e clique em Reservar.
      • Nome: ip-ilb
      • Versão do IP: IPv4
      • Endereço IP estático: Permitir-me escolher
      • Endereço IP personalizado: 10.1.2.99
   4. Em Portas, selecione Múltiplas e, em seguida, em Números de portas, introduza 80,8008,8080 e 8088.
   5. Antes de continuar, verifique se existe uma marca de verificação azul junto a Configuração do frontend.

Reveja a configuração

1. Clique em Rever e finalizar.
2. Reveja as definições de configuração do equilibrador de carga.
3. Opcional: clique em Código equivalente para ver o pedido da API REST que vai ser usado para criar o equilibrador de carga.
4. Clique em Criar.

gcloud

1. Crie uma nova verificação de funcionamento de HTTP regional para testar a conetividade HTTP às VMs na porta 80.

   gcloud compute health-checks create http hc-http-80 \
       --region=us-west1 \
       --port=80
   

2. Crie o serviço de back-end para o tráfego HTTP:

   gcloud compute backend-services create be-ilb \
       --load-balancing-scheme=internal \
       --protocol=tcp \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

3. Adicione os dois grupos de instâncias ao serviço de back-end:

   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

4. Crie uma regra de encaminhamento para o serviço de back-end. Quando criar a regra de encaminhamento, especifique 10.1.2.99 para o endereço IP interno na sub-rede.

   gcloud compute forwarding-rules create fr-ilb \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=lb-subnet \
       --address=10.1.2.99 \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
   

API

Crie a verificação de funcionamento fazendo um pedido POST ao método regionHealthChecks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionHealthChecks

{
"name": "hc-http-80",
"type": "HTTP",
"httpHealthCheck": {
  "port": 80
}
}

Crie o serviço de back-end regional fazendo um pedido POST ao regionBackendServices.insert método.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices

{
"name": "be-ilb",
"backends": [
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"connectionDraining": {
  "drainingTimeoutSec": 0
 }
}

Crie a regra de encaminhamento fazendo um pedido POST ao método forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

Teste o balanceador de carga

Estes testes mostram como validar a configuração do equilibrador de carga e saber mais sobre o respetivo comportamento esperado.

Crie uma VM de cliente

Este exemplo cria uma VM de cliente (vm-client) na mesma região que as VMs de back-end (servidor). O cliente é usado para validar a configuração do equilibrador de carga e demonstrar o comportamento esperado, conforme descrito na secção de testes.

Consola

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

   Aceder às instâncias de VM

2. Clique em Criar instância.

3. Em Nome, introduza vm-client.

4. Para Região, selecione us-west1.

5. Para Zona, selecione us-west1-a.

6. Clique em Opções avançadas.

7. Clique em Rede e configure os seguintes campos:

   1. Para etiquetas de rede, introduza allow-ssh.
   2. Para Interfaces de rede, selecione o seguinte:
      • Rede: lb-network
      • Subnet: lb-subnet

8. Clique em Criar.

gcloud

A VM do cliente pode estar em qualquer zona na mesma região que o balanceador de carga e pode usar qualquer sub-rede nessa região. Neste exemplo, o cliente está na zona us-west1-a e usa a mesma sub-rede que as VMs de back-end.

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=lb-subnet

API

Faça um pedido POST ao método instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances

{
 "name": "vm-client",
 "tags": {
   "items": [
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "vm-client",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Teste a ligação a partir da VM do cliente

Este teste contacta o balanceador de carga a partir de uma VM cliente separada, ou seja, não a partir de uma VM de back-end do balanceador de carga. O comportamento esperado é que o tráfego seja distribuído entre as quatro VMs de back-end porque não foi configurada nenhuma afinidade de sessão.

1. Ligue-se à instância de VM do cliente.

   gcloud compute ssh vm-client --zone=us-west1-a
   

2. Faça um pedido Web ao equilibrador de carga através de curl para contactar o respetivo endereço IP. Repita o pedido para poder ver que as respostas provêm de VMs de back-end diferentes. O nome da VM que gera a resposta é apresentado no texto na resposta HTML, em virtude do conteúdo de /var/www/html/index.html em cada VM de back-end. Por exemplo, as respostas esperadas têm o seguinte aspeto: Page served from: vm-a1 e Page served from: vm-a2.

   curl http://10.1.2.99
   

   A regra de encaminhamento está configurada para servir as portas 80, 8008, 8080 e 8088. Para enviar tráfego para essas outras portas, anexe dois pontos (:) e o número da porta após o endereço IP, da seguinte forma:

   curl http://10.1.2.99:8008
   

   Se adicionar uma etiqueta de serviço à regra de encaminhamento interno, pode usar o DNS interno para contactar o equilibrador de carga através do respetivo nome de serviço.

   curl http://web-test.fr-ilb.il4.us-west1.lb.PROJECT_ID.internal
   

Enviar um ping para o endereço IP do balanceador de carga

Este teste demonstra um comportamento esperado: não pode enviar um ping para o endereço IP do balanceador de carga. Isto deve-se ao facto de os equilibradores de carga de rede de encaminhamento interno serem implementados na programação de rede virtual, e não serem dispositivos separados.

1. Ligue-se à instância de VM do cliente.

   gcloud compute ssh vm-client --zone=us-west1-a
   

2. Tente enviar um ping para o endereço IP do equilibrador de carga. Repare que não recebe uma resposta e que o comando ping expira após 10 segundos neste exemplo.

   timeout 10 ping 10.1.2.99
   

Envie pedidos de VMs com balanceamento de carga

Este teste demonstra que, quando uma VM de back-end envia pacotes para o endereço IP da regra de encaminhamento do respetivo equilibrador de carga, esses pedidos são encaminhados de volta para si próprios. Isto aplica-se independentemente do estado da verificação de funcionamento da VM de back-end.

Os equilibradores de carga de rede de passagem interna são implementados através da programação de rede virtual e da configuração da VM no SO convidado. Nas VMs Linux, o ambiente convidado cria uma rota para o endereço IP do balanceador de carga na tabela de encaminhamento local do sistema operativo.

Uma vez que esta rota local está na própria VM (e não numa rota na rede da VPC), os pacotes enviados para o endereço IP do balanceador de carga não são processados pela rede da VPC. Em alternativa, os pacotes enviados para o endereço IP do balanceador de carga permanecem no sistema operativo da VM.

1. Estabeleça ligação a uma VM de back-end, como vm-a1:

   gcloud compute ssh vm-a1 --zone=us-west1-a
   

   Importante: não vai poder estabelecer ligação a uma VM de back-end desta forma se tiver removido o respetivo endereço IP externo. Para opções de ligação, se as VMs de back-end não tiverem endereços IP externos, consulte o artigo Escolha uma opção de ligação para VMs apenas internas.

2. Faça um pedido Web ao balanceador de carga (por endereço IP ou nome do serviço) através de curl. A resposta é proveniente da mesma VM de back-end que faz o pedido. As solicitações repetidas são respondidas da mesma forma. A resposta esperada quando testa a partir de vm-a1 é sempre Page served from: vm-a1.

   curl http://10.1.2.99
   

3. Inspecione a tabela de encaminhamento local à procura de um destino que corresponda ao endereço IP do próprio balanceador de carga, 10.1.2.99. Esta rota é uma parte necessária de um balanceador de carga de rede de encaminhamento interno, mas também demonstra por que motivo um pedido de uma VM atrás do balanceador de carga é sempre respondido pela mesma VM.

   ip route show table local | grep 10.1.2.99
   

Quando uma VM de back-end para um balanceador de carga de rede de passagem interna envia pacotes para o endereço IP da regra de encaminhamento do balanceador de carga, os pacotes são sempre encaminhados de volta para a VM que faz o pedido. Isto deve-se ao facto de um Network Load Balancer de passagem interno ser um balanceador de carga de passagem e ser implementado através da criação de uma rota local para o endereço IP do balanceador de carga no SO convidado da VM, conforme indicado nesta secção. Se tiver um caso de utilização em que os back-ends com equilíbrio de carga tenham de enviar tráfego TCP para o endereço IP do equilibrador de carga e precisar que o tráfego seja distribuído como se tivesse origem num back-end sem equilíbrio de carga, considere usar um Network Load Balancer de proxy interno regional.

Para mais informações, consulte o artigo Balanceadores de carga de rede de encaminhamento interno como saltos seguintes.

Configure o balanceador de carga com sub-redes e back-ends de pilha dupla

Este documento mostra como configurar e testar um balanceador de carga de rede de encaminhamento interno que suporta tráfego IPv4 e IPv6. Os passos nesta secção descrevem como configurar o seguinte:

1. O exemplo nesta página usa uma rede VPC no modo personalizado denominada lb-network-dual-stack. O tráfego IPv6 requer uma sub-rede no modo personalizado.
2. Uma sub-rede de pilha dupla (stack-type definida como IPV4_IPV6), que é necessária para o tráfego IPv6. Quando cria uma sub-rede de pilha dupla numa rede de VPC de modo personalizado, escolhe um tipo de acesso IPv6 para a sub-rede. Para este exemplo, definimos o parâmetro ipv6-access-type da sub-rede como INTERNAL. Isto significa que às novas VMs nesta sub-rede podem ser atribuídos endereços IPv4 internos e endereços IPv6 internos. Para ver instruções, consulte a documentação da VPC sobre como adicionar uma sub-rede de pilha dupla.
3. Regras de firewall que permitem ligações recebidas a VMs de back-end.
4. O grupo de instâncias de back-end, que está localizado na seguinte região e sub-rede para este exemplo:
   • Região: us-west1
   • Sub-rede: lb-subnet, com o intervalo de endereços IPv4 principal 10.1.2.0/24. Embora escolha o intervalo de endereços IPv4 a configurar na sub-rede, o intervalo de endereços IPv6 é atribuído automaticamente. A Google fornece um bloco CIDR IPv6 de tamanho fixo (/64).
5. Quatro VMs de duplo stack: duas VMs num grupo de instâncias não gerido na zona us-west1-a e duas VMs num grupo de instâncias não gerido na zona us-west1-c. Para demonstrar o acesso global, este exemplo cria uma segunda VM de cliente de teste numa região e sub-rede diferentes:
   • Região: europe-west1
   • Sub-rede: europe-subnet, com o intervalo de endereços IP principal 10.3.4.0/24
6. Uma VM cliente para testar as ligações.
7. Os seguintes componentes do balanceador de carga de rede de encaminhamento interno:
   • Uma verificação de funcionamento do serviço de back-end.
   • Um serviço de back-end interno na região us-west1 para gerir a distribuição de ligações aos dois grupos de instâncias zonais.
   • Duas regras de encaminhamento interno para o front-end do balanceador de carga.

O diagrama seguinte mostra a arquitetura deste exemplo:

Exemplo de configuração do balanceador de carga de rede de encaminhamento interno (clique para aumentar).

Nota: para simplificar, este exemplo usa grupos de instâncias não geridos. Na produção, considere usar um grupo de instâncias geridas, conforme ilustrado em Grupos de instâncias geridas.

Configure uma rede, uma região e uma sub-rede

O exemplo de balanceador de carga de rede de encaminhamento interno descrito nesta página é criado numa rede VPC de modo personalizado denominada lb-network-dual-stack.

Para configurar sub-redes com intervalos IPv6 internos, ative um intervalo IPv6 interno ULA de rede VPC. Os intervalos de sub-redes IPv6 internas são atribuídos a partir deste intervalo.

Consola

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

   Aceda a redes de VPC

2. Clique em Criar rede de VPC.

3. Em Nome, introduza lb-network-dual-stack.

4. Se quiser configurar intervalos de endereços IPv6 internos em sub-redes nesta rede, conclua estes passos:

   1. Para as Definições de endereço IPv6 privado, selecione Configurar um intervalo IPv6 interno para esta rede VPC.
   2. Para Atribuir intervalo IPv6 interno, selecione Automaticamente ou Manualmente. Se selecionar Manualmente, introduza um intervalo de /48 no intervalo de fd20::/20. Se o intervalo estiver em uso, é-lhe pedido que faculte um intervalo diferente.

5. Para o Modo de criação de sub-rede, selecione Personalizado.

6. Na secção Nova sub-rede, especifique os seguintes parâmetros de configuração de uma sub-rede:

   • Nome: lb-subnet
   • Região: us-west1
   • Tipo de pilha de IP: IPv4 e IPv6 (dupla pilha)
   • Intervalo IPv4: 10.1.2.0/24.
   • Tipo de acesso IPv6: interno

7. Clique em Concluído.

8. Clique em Adicionar sub-rede e introduza as seguintes informações:

   • Nome: europe-subnet
   • Região: europe-west1
   • Tipo de pilha de IP: IPv4 (pilha única)
   • Intervalo de endereços IP: 10.3.4.0/24

9. Clique em Concluído.

10. Clique em Criar.

gcloud

1. Para criar uma nova rede VPC no modo personalizado, execute o comando gcloud compute networks create.

   Para configurar intervalos IPv6 internos em quaisquer sub-redes nesta rede, use a flag --enable-ula-internal-ipv6. Esta opção atribui um /48prefixo ULA a partir do intervalo fd20::/20usado pelo Google Cloud para intervalos de sub-redes IPv6 internos. Se quiser selecionar o /48intervalo IPv6 atribuído, use a flag --internal-ipv6-range para especificar um intervalo.

   gcloud compute networks create lb-network-dual-stack \
      --subnet-mode=custom \
      --enable-ula-internal-ipv6 \
      --internal-ipv6-range=ULA_IPV6_RANGE \
      --bgp-routing-mode=regional
   

   Substitua ULA_IPV6_RANGE por um prefixo /48 do intervalo fd20::/20 usado pela Google para intervalos de sub-redes IPv6 internos. Se não usar a flag --internal-ipv6-range, a Google seleciona um prefixo /48 para a rede, como fd20:bc7:9a1c::/48.

2. Na rede NETWORK, crie uma sub-rede para back-ends na região us-west1 e outra sub-rede para testar o acesso global na região europe-west1.

   Para criar as sub-redes, execute o comando gcloud compute networks subnets create.

   gcloud compute networks subnets create lb-subnet \
      --network=lb-network-dual-stack \
      --range=10.1.2.0/24 \
      --region=us-west1 \
      --stack-type=IPV4_IPV6 \
      --ipv6-access-type=INTERNAL
   

   gcloud compute networks subnets create europe-subnet \
      --network=lb-network-dual-stack \
      --range=10.3.4.0/24 \
      --region=europe-west1 \
      --stack-type=IPV4_IPV6 \
      --ipv6-access-type=INTERNAL
   

API

Crie uma nova rede VPC de modo personalizado.

Para configurar intervalos IPv6 internos em quaisquer sub-redes nesta rede, defina enableUlaInternalIpv6 como verdadeiro. Esta opção atribui um /48 intervalo do intervalo fd20::/20 usado pela Google para intervalos de sub-redes IPv6 internos. Se quiser selecionar o intervalo de /48 IPv6 atribuído, use também o campo internalIpv6Range para especificar um intervalo.

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
 {
   "autoCreateSubnetworks": false,
   "name": "lb-network-dual-stack",
   "mtu": MTU,
   "enableUlaInternalIpv6": true,
   "internalIpv6Range": "ULA_IPV6_RANGE",
   "routingConfig": {
   "routingMode": "DYNAMIC_ROUTING_MODE"
  }
 }
 

Substitua o seguinte:

• PROJECT_ID: o ID do projeto onde a rede VPC é criada.
• MTU: a unidade de transmissão máxima da rede. A MTU pode ser 1460 (predefinição) ou 1500. Reveja a vista geral da unidade de transmissão máxima antes de definir a MTU como 1500.
• ULA_IPV6_RANGE: um prefixo /48 do intervalo fd20::/20 usado pela Google para intervalos de sub-redes IPv6 internos. Se não fornecer um valor para internalIpv6Range, a Google seleciona um prefixo /48 para a rede.

• DYNAMIC_ROUTING_MODE: global ou regional para controlar o comportamento de publicidade de rotas dos Cloud Routers na rede. Para mais informações, consulte o modo de planeamento de rotas dinâmico.

  Para mais informações, consulte o método networks.insert.

Faça dois pedidos POST ao subnetworks.insert método.

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks
 {
   "ipCidrRange": "10.1.2.0/24",
   "network": "lb-network-dual-stack",
   "name": "lb-subnet"
   "stackType": IPV4_IPV6,
   "ipv6AccessType": Internal
 }
 

 POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/REGION/subnetworks
 {
   "ipCidrRange": "10.3.4.0/24",
   "network": "lb-network-dual-stack",
   "name": "europe-subnet"
   "stackType": IPV4_IPV6,
   "ipv6AccessType": Internal
 }
 

Configure regras de firewall

Este exemplo usa as seguintes regras de firewall:

• fw-allow-lb-access: uma regra de entrada, aplicável a todos os destinos na rede VPC, que permite o tráfego de origens nos intervalos 10.1.2.0/24 e 10.3.4.0/24. Esta regra permite o tráfego de entrada de qualquer cliente localizado numa das duas sub-redes. Mais tarde, pode configurar e testar o acesso global.

• fw-allow-lb-access-ipv6: Uma regra de entrada, aplicável a todos os destinos na rede VPC, que permite o tráfego de origens no intervalo IPv6 configurado na sub-rede. Esta regra permite o tráfego IPv6 de entrada de qualquer cliente localizado numa das duas sub-redes. Mais tarde, pode configurar e testar o acesso global.

• fw-allow-ssh: Uma regra de entrada, aplicável às instâncias com balanceamento de carga, 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 do sistema a partir do qual inicia sessões SSH. Este exemplo usa a etiqueta de destino allow-ssh para identificar as VMs às quais deve ser aplicada.

• 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 estado (130.211.0.0/22 e 35.191.0.0/16). Este exemplo usa a etiqueta de destino allow-health-check para identificar as instâncias às quais deve aplicar-se. Google Cloud

• fw-allow-health-check-ipv6: uma regra de entrada, aplicável às instâncias com balanceamento de carga, que permite o tráfego dos sistemas de verificação de estado (2600:2d00:1:b029::/64). Este exemplo usa a etiqueta de destino allow-health-check-ipv6 para identificar as instâncias às quais deve ser aplicada. Google Cloud

Sem estas regras de firewall, a regra de negação predefinida de entrada bloqueia o tráfego de entrada para as instâncias de back-end.

Nota: tem de criar uma regra de firewall para permitir verificações de funcionamento a partir dos intervalos de IP dos sistemas de sondagem. Google Cloud Consulte os intervalos de IPs de sondagem para mais informações.

Consola

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

   Aceder a Políticas de firewall

2. Para criar a regra que permite o tráfego da sub-rede, clique em Criar regra de firewall e introduza as seguintes informações:

   • Nome: fw-allow-lb-access
   • Rede: lb-network-dual-stack
   • Prioridade: 1000
   • Direção do trânsito: entrada
   • Ação na correspondência: permitir
   • Segmenta: todas as instâncias na rede
   • Filtro de origem: intervalos IPv4
   • Intervalos de IPv4 de origem: 10.1.2.0/24 e 10.3.4.0/24
   • Protocolos e portas: Permitir tudo

3. Clique em Criar.

4. Para permitir o tráfego de sub-rede IPv6, clique novamente em Criar regra de firewall e introduza as seguintes informações:

   • Nome: fw-allow-lb-access-ipv6
   • Rede: lb-network-dual-stack
   • Prioridade: 1000
   • Direção do trânsito: entrada
   • Ação na correspondência: permitir
   • Segmenta: todas as instâncias na rede
   • Filtro de origem: intervalos IPv6
   • Intervalos IPv6 de origem: IPV6_ADDRESS atribuídos no lb-subnet
   • Protocolos e portas: Permitir tudo

5. Clique em Criar.

6. Para permitir ligações SSH recebidas, clique novamente em Criar regra de firewall e introduza as seguintes informações:

   • Nome: fw-allow-ssh
   • Rede: lb-network-dual-stack
   • Prioridade: 1000
   • Direção do trânsito: entrada
   • Ação na correspondência: permitir
   • Objetivos: etiquetas de destino especificadas
   • Etiquetas de segmentação: allow-ssh
   • Filtro de origem: intervalos IPv4
   • Intervalos IPv4 de origem: 0.0.0.0/0
   • Protocolos e portas: selecione Protocolos e portas especificados, selecione a caixa de verificação TCP e, de seguida, introduza 22 em Portas.

7. Clique em Criar.

8. Para permitir as verificações de funcionamento de Google Cloud IPv6, clique novamente em Criar regra de firewall e introduza as seguintes informações:

   • Nome: fw-allow-health-check-ipv6
   • Rede: lb-network-dual-stack
   • Prioridade: 1000
   • Direção do trânsito: entrada
   • Ação na correspondência: permitir
   • Objetivos: etiquetas de destino especificadas
   • Etiquetas de segmentação: allow-health-check-ipv6
   • Filtro de origem: intervalos IPv6
   • Intervalos IPv6 de origem: 2600:2d00:1:b029::/64
   • Protocolos e portas: Permitir tudo

9. Clique em Criar.

10. Para permitir Google Cloud verificações de funcionamento, clique novamente em Criar regra de firewall e introduza as seguintes informações:

    • Nome: fw-allow-health-check
    • Rede: lb-network-dual-stack
    • Prioridade: 1000
    • Direção do trânsito: entrada
    • Ação na correspondência: permitir
    • Objetivos: etiquetas de destino especificadas
    • Etiquetas de segmentação: allow-health-check
    • Filtro de origem: intervalos IPv4
    • Intervalos de IPv4 de origem: 130.211.0.0/22 e 35.191.0.0/16
    • Protocolos e portas: Permitir tudo

11. Clique em Criar.

gcloud

1. Crie a regra de firewall fw-allow-lb-access para permitir a comunicação com a sub-rede:

   gcloud compute firewall-rules create fw-allow-lb-access \
       --network=lb-network-dual-stack \
       --action=allow \
       --direction=ingress \
       --source-ranges=10.1.2.0/24,10.3.4.0/24 \
       --rules=all
   

2. Crie a regra de firewall fw-allow-lb-access-ipv6 para permitir a comunicação com a sub-rede:

   gcloud compute firewall-rules create fw-allow-lb-access-ipv6 \
       --network=lb-network-dual-stack \
       --action=allow \
       --direction=ingress \
       --source-ranges=IPV6_ADDRESS \
       --rules=all
   

   Substitua IPV6_ADDRESS pelo endereço IPv6 atribuído no lb-subnet.

3. 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=lb-network-dual-stack \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-ssh \
       --rules=tcp:22
   

4. Crie a regra fw-allow-health-check-ipv6 para permitir Google Cloud verificações de funcionamento de IPv6.

   gcloud compute firewall-rules create fw-allow-health-check-ipv6 \
       --network=lb-network-dual-stack \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-health-check-ipv6 \
       --source-ranges=2600:2d00:1:b029::/64 \
       --rules=tcp,udp
   

5. Crie a regra fw-allow-health-check para permitir Google Cloud verificações de funcionamento.

   gcloud compute firewall-rules create fw-allow-health-check \
       --network=lb-network-dual-stack \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-health-check \
       --source-ranges=130.211.0.0/22,35.191.0.0/16 \
       --rules=tcp,udp,icmp
   

API

1. Crie a regra de firewall fw-allow-lb-access fazendo um pedido POST ao método firewalls.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   
   {
   "name": "fw-allow-lb-access",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
   "priority": 1000,
   "sourceRanges": [
     "10.1.2.0/24", "10.3.4.0/24"
   ],
   "allowed": [
     {
       "IPProtocol": "tcp"
     },
     {
       "IPProtocol": "udp"
     },
     {
       "IPProtocol": "icmp"
     }
   ],
   "direction": "INGRESS",
   "logConfig": {
     "enable": false
   },
   "disabled": false
   }
   

2. Crie a regra de firewall fw-allow-lb-access-ipv6 fazendo um pedido POST ao método firewalls.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   
   {
    "name": "fw-allow-lb-access-ipv6",
    "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
    "priority": 1000,
    "sourceRanges": [
      "IPV6_ADDRESS"
    ],
    "allowed": [
      {
         "IPProtocol": "tcp"
       },
       {
         "IPProtocol": "udp"
       },
       {
         "IPProtocol": "icmp"
       }
    ],
    "direction": "INGRESS",
    "logConfig": {
       "enable": false
    },
    "disabled": false
   }
   

   Substitua IPV6_ADDRESS pelo endereço IPv6 atribuído no lb-subnet.

3. Crie a regra de firewall fw-allow-ssh fazendo um pedido POST ao método firewalls.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   
   {
   "name": "fw-allow-ssh",
        "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
   "priority": 1000,
   "sourceRanges": [
     "0.0.0.0/0"
   ],
   "targetTags": [
     "allow-ssh"
   ],
   "allowed": [
    {
      "IPProtocol": "tcp",
      "ports": [
        "22"
      ]
    }
   ],
   "direction": "INGRESS",
   "logConfig": {
    "enable": false
   },
   "disabled": false
   }
   

4. Crie a regra de firewall fw-allow-health-check-ipv6 fazendo um pedido POST ao método firewalls.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   
   {
   "name": "fw-allow-health-check-ipv6",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
   "priority": 1000,
   "sourceRanges": [
     "2600:2d00:1:b029::/64"
   ],
   "targetTags": [
     "allow-health-check-ipv6"
   ],
   "allowed": [
     {
       "IPProtocol": "tcp"
     },
     {
       "IPProtocol": "udp"
     }
   ],
   "direction": "INGRESS",
   "logConfig": {
     "enable": false
   },
   "disabled": false
   }
   

5. Crie a regra de firewall fw-allow-health-check fazendo um pedido POST ao método firewalls.insert.

   POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
   
   {
   "name": "fw-allow-health-check",
   "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
   "priority": 1000,
   "sourceRanges": [
     "130.211.0.0/22",
     "35.191.0.0/16"
   ],
   "targetTags": [
     "allow-health-check"
   ],
   "allowed": [
     {
       "IPProtocol": "tcp"
     },
     {
       "IPProtocol": "udp"
     },
     {
       "IPProtocol": "icmp"
     }
   ],
   "direction": "INGRESS",
   "logConfig": {
     "enable": false
   },
   "disabled": false
   }
   

Crie VMs de back-end e grupos de instâncias

Este exemplo usa dois grupos de instâncias não geridos, cada um com duas VMs de back-end (servidor). Para demonstrar a natureza regional dos equilibradores de carga de rede de encaminhamento interno, os dois grupos de instâncias são colocados em zonas separadas, us-west1-a e us-west1-c.

• O grupo de instâncias ig-a contém estas duas VMs:
  • vm-a1
  • vm-a2
• O grupo de instâncias ig-c contém estas duas VMs:
  • vm-c1
  • vm-c2

O tráfego para todas as quatro VMs de back-end é equilibrado por carga.

Para suportar este exemplo e as opções de configuração adicionais, cada uma das quatro VMs executa um servidor Web Apache que escuta nas seguintes portas TCP: 80,8008, 8080, 8088, 443 e 8443.

A cada VM é atribuído um endereço IP interno no intervalo lb-subnet e um endereço IP externo (público) efémero. Pode remover os endereços IP externos mais tarde.

Não são necessários endereços IP externos para as VMs de back-end. No entanto, são úteis para este exemplo, porque permitem que as VMs de back-end transfiram o Apache da Internet e podem estabelecer ligação através de SSH.

Por predefinição, o Apache está configurado para ser associado a qualquer endereço IP. Os balanceadores de carga de rede de encaminhamento interno fornecem pacotes preservando o IP de destino.

Certifique-se de que o software do servidor executado nas VMs de back-end está a ouvir o endereço IP da regra de encaminhamento interno do balanceador de carga. Se configurar várias regras de encaminhamento interno, certifique-se de que o seu software escuta o endereço IP interno associado a cada uma delas. O endereço IP de destino de um pacote enviado para uma VM de back-end por um balanceador de carga de rede de encaminhamento direto interno é o endereço IP interno da regra de encaminhamento.

Se estiver a usar grupos de instâncias geridos, certifique-se de que o tipo de pilha da sub-rede corresponde ao tipo de pilha dos modelos de instâncias usados pelos grupos de instâncias geridos. A sub-rede tem de ser de pilha dupla se o grupo de instâncias geridas estiver a usar um modelo de instância de pilha dupla.

Para simplificar as instruções, estas VMs de back-end executam o Debian GNU/Linux 12.

Consola

Crie VMs de back-end

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: vm-a1, zona: us-west1-a
   • Nome: vm-a2, zona: us-west1-a
   • Nome: vm-c1, zona: us-west1-c
   • Nome: vm-c2, zona: us-west1-c

3. Clique em Criar instância.

4. Defina o Nome conforme indicado no passo 2.

5. Para Região, selecione us-west1 e escolha uma Zona, conforme indicado no passo 2.

6. 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. Se necessário, clique em Alterar para alterar a imagem.

7. Clique em Opções avançadas.

8. Clique em Rede e configure os seguintes campos:

   1. Para Etiquetas de rede, introduza allow-ssh e allow-health-check-ipv6.
   2. Para Interfaces de rede, selecione o seguinte:
      • Rede: lb-network-dual-stack
      • Subnet: lb-subnet
      • Tipo de pilha de IP: IPv4 e IPv6 (dupla pilha)
      • Endereço IPv4 interno principal: efémero (automático)
      • Endereço IPv4 externo: efémero

   3. Clique em Gestão e, de seguida, no campo Script de arranque, introduza o seguinte script. O conteúdo do script é idêntico para todas as quatro VMs.

      #! /bin/bash
      if [ -f /etc/startup_script_completed ]; then
      exit 0
      fi
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      file_ports="/etc/apache2/ports.conf"
      file_http_site="/etc/apache2/sites-available/000-default.conf"
      file_https_site="/etc/apache2/sites-available/default-ssl.conf"
      http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
      http_vh_prts="*:80 *:8008 *:8080 *:8088"
      https_listen_prts="Listen 443\nListen 8443"
      https_vh_prts="*:443 *:8443"
      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
      prt_conf="$(cat "$file_ports")"
      prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
      prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
      echo "$prt_conf" | tee "$file_ports"
      http_site_conf="$(cat "$file_http_site")"
      http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
      echo "$http_site_conf_2" | tee "$file_http_site"
      https_site_conf="$(cat "$file_https_site")"
      https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
      echo "$https_site_conf_2" | tee "$file_https_site"
      systemctl restart apache2
      touch /etc/startup_script_completed
      

9. Clique em Criar.

Crie grupos de instâncias

1. Na Google Cloud consola, aceda à página Grupos de instâncias.

   Aceda a Grupos de instâncias

2. Repita os passos seguintes para criar dois grupos de instâncias não geridos, cada um com duas VMs, usando estas combinações.

   • Nome do grupo de instâncias: ig-a, zona: us-west1-a, VMs: vm-a1 e vm-a2
   • Nome do grupo de instâncias: ig-c, zona: us-west1-c, VMs: vm-c1 e vm-c2

3. Clique em Criar grupo de instâncias.

4. Clique em Novo grupo de instâncias não gerido.

5. Defina o Nome conforme indicado no passo 2.

6. Na secção Localização, selecione us-west1 para a Região e, em seguida, escolha uma Zona, conforme indicado no passo 2.

7. Para Rede, selecione lb-network-dual-stack.

8. Para Sub-rede, selecione lb-subnet.

9. Na secção Instâncias de VM, adicione as VMs conforme indicado no passo 2.

10. Clique em Criar.

gcloud

1. Para criar as quatro VMs, execute o comando gcloud compute instances create quatro vezes, usando estas quatro combinações para [VM-NAME] e [ZONE]. O conteúdo do script é idêntico para todas as quatro VMs.

   • VM-NAME: vm-a1, ZONE: us-west1-a
   • VM-NAME: vm-a2, ZONE: us-west1-a
   • VM-NAME: vm-c1, ZONE: us-west1-c

   • VM-NAME: vm-c2, ZONE: us-west1-c

     gcloud compute instances create VM-NAME \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check-ipv6 \
       --subnet=lb-subnet \
       --stack-type=IPV4_IPV6 \
       --metadata=startup-script='#! /bin/bash
     if [ -f /etc/startup_script_completed ]; then
     exit 0
     fi
     apt-get update
     apt-get install apache2 -y
     a2ensite default-ssl
     a2enmod ssl
     file_ports="/etc/apache2/ports.conf"
     file_http_site="/etc/apache2/sites-available/000-default.conf"
     file_https_site="/etc/apache2/sites-available/default-ssl.conf"
     http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
     http_vh_prts="*:80 *:8008 *:8080 *:8088"
     https_listen_prts="Listen 443\nListen 8443"
     https_vh_prts="*:443 *:8443"
     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
     prt_conf="$(cat "$file_ports")"
     prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
     prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
     echo "$prt_conf" | tee "$file_ports"
     http_site_conf="$(cat "$file_http_site")"
     http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
     echo "$http_site_conf_2" | tee "$file_http_site"
     https_site_conf="$(cat "$file_https_site")"
     https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
     echo "$https_site_conf_2" | tee "$file_https_site"
     systemctl restart apache2
     touch /etc/startup_script_completed'
     

2. Crie os dois grupos de instâncias não geridos em cada zona:

   gcloud compute instance-groups unmanaged create ig-a \
       --zone=us-west1-a
   gcloud compute instance-groups unmanaged create ig-c \
       --zone=us-west1-c
   

3. Adicione as VMs aos grupos de instâncias adequados:

   gcloud compute instance-groups unmanaged add-instances ig-a \
       --zone=us-west1-a \
       --instances=vm-a1,vm-a2
   gcloud compute instance-groups unmanaged add-instances ig-c \
       --zone=us-west1-c \
       --instances=vm-c1,vm-c2
   

api

Para as quatro VMs, use os seguintes nomes e zonas de VMs:

• VM-NAME: vm-a1, ZONE: us-west1-a
• VM-NAME: vm-a2, ZONE: us-west1-a
• VM-NAME: vm-c1, ZONE: us-west1-c
• VM-NAME: vm-c2, ZONE: us-west1-c

Pode obter o DEBIAN_IMAGE_NAME atual executando o seguinte comando gcloud:

gcloud compute images list \
 --filter="family=debian-12"

Crie quatro VMs de back-end fazendo quatro pedidos POST ao método instances.insert:

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances

{
 "name": "VM-NAME",
 "tags": {
   "items": [
     "allow-health-check-ipv6",
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/[ZONE]/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "stackType": "IPV4_IPV6",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "VM-NAME",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/zone/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "metadata": {
   "items": [
     {
       "key": "startup-script",
       "value": "#! /bin/bash\napt-get update\napt-get install apache2 -y\na2ensite default-ssl\na2enmod ssl\nfile_ports=\"/etc/apache2/ports.conf\"\nfile_http_site=\"/etc/apache2/sites-available/000-default.conf\"\nfile_https_site=\"/etc/apache2/sites-available/default-ssl.conf\"\nhttp_listen_prts=\"Listen 80\\nListen 8008\\nListen 8080\\nListen 8088\"\nhttp_vh_prts=\"*:80 *:8008 *:8080 *:8088\"\nhttps_listen_prts=\"Listen 443\\nListen 8443\"\nhttps_vh_prts=\"*:443 *:8443\"\nvm_hostname=\"$(curl -H \"Metadata-Flavor:Google\" \\\nhttp://169.254.169.254/computeMetadata/v1/instance/name)\"\necho \"Page served from: $vm_hostname\" | \\\ntee /var/www/html/index.html\nprt_conf=\"$(cat \"$file_ports\")\"\nprt_conf_2=\"$(echo \"$prt_conf\" | sed \"s|Listen 80|${http_listen_prts}|\")\"\nprt_conf=\"$(echo \"$prt_conf_2\" | sed \"s|Listen 443|${https_listen_prts}|\")\"\necho \"$prt_conf\" | tee \"$file_ports\"\nhttp_site_conf=\"$(cat \"$file_http_site\")\"\nhttp_site_conf_2=\"$(echo \"$http_site_conf\" | sed \"s|*:80|${http_vh_prts}|\")\"\necho \"$http_site_conf_2\" | tee \"$file_http_site\"\nhttps_site_conf=\"$(cat \"$file_https_site\")\"\nhttps_site_conf_2=\"$(echo \"$https_site_conf\" | sed \"s|_default_:443|${https_vh_prts}|\")\"\necho \"$https_site_conf_2\" | tee \"$file_https_site\"\nsystemctl restart apache2"
     }
   ]
 },
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Crie dois grupos de instâncias fazendo um pedido POST ao método instanceGroups.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups

{
 "name": "ig-a",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups

{
 "name": "ig-c",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
 "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

Adicione instâncias a cada grupo de instâncias fazendo um pedido POST ao método instanceGroups.addInstances.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a2"
   }
 ]
}

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c/addInstances

{
 "instances": [
   {
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c1",
     "instance": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instances/vm-c2"
   }
 ]
}

Configure os componentes do balanceador de carga

Estes passos configuram todos os componentes do balanceador de carga de rede de encaminhamento interno, começando pela verificação de estado e pelo serviço de back-end e, em seguida, pelos componentes de front-end:

• Verificação de funcionamento. Neste exemplo, usa uma verificação de funcionamento de HTTP que verifica um 200 OKcódigo de estado HTTP. Para mais informações, consulte a secção de verificações de funcionamento da vista geral do balanceador de carga de rede de encaminhamento interno.

• Serviço de back-end. Uma vez que tem de transmitir tráfego HTTP através do balanceador de carga interno, tem de usar o protocolo TCP e não o UDP.

• Regra de encaminhamento. Este exemplo cria duas regras de encaminhamento interno para tráfego IPv4 e IPv6.

• Endereço IP interno. Neste exemplo, especifica um endereço IP interno, 10.1.2.99, quando cria a regra de encaminhamento IPv4. Para mais informações, consulte Endereço IP interno. Embora escolha o endereço IPv4 configurado, o endereço IPv6 é atribuído automaticamente.

Consola

Inicie a configuração

1. Na Google Cloud consola, aceda à página Equilíbrio de carga.

   Aceda ao balanceamento de carga

2. Clique em Criar equilibrador de carga.
3. Para Tipo de balanceador de carga, selecione Balanceador de carga de rede (TCP/UDP/SSL) e clique em Seguinte.
4. Para Proxy ou passagem, selecione Passagem do balanceador de carga e clique em Seguinte.
5. Para Público ou interno, selecione Interno e clique em Seguinte.
6. Clique em Configurar.

Configuração básica

Na página Criar balanceador de carga de rede de encaminhamento interno, introduza as seguintes informações:

• Nome do balanceador de carga: be-ilb
• Região: us-west1
• Rede: lb-network-dual-stack

Configuração do back-end

1. Clique em Configuração de back-end.
2. Na lista Verificação de funcionamento, clique em Criar uma verificação de funcionamento e introduza as seguintes informações:
   • Nome: hc-http-80
   • Âmbito: regional
   • Protocolo: HTTP
   • Porta: 80
   • Protocolo proxy: NONE
   • Pedido: /
3. Clique em Criar.
4. Na secção Novo back-end, para Tipo de pilha de IP, selecione a opção IPv4 e IPv6 (pilha dupla).
5. Em Grupo de instâncias, selecione o grupo de instâncias ig-a e clique em Concluído.
6. Clique em Adicionar um back-end e repita o passo para adicionar o grupo de instâncias ig-c.
7. Verifique se aparece uma marca de verificação azul junto a Configuração de back-end.

Configuração da interface

1. Clique em Configuração do front-end. Na secção Novo endereço IP e porta de front-end, faça o seguinte:
   1. Em Nome, introduza fr-ilb-ipv6.
   2. Para processar o tráfego IPv6, faça o seguinte:
      1. Para a versão do IP, selecione IPv6.
      2. Para Sub-rede, selecionelb-subnet. O intervalo de endereços IPv6 na regra de encaminhamento é sempre efémero.
      3. Em Portas, selecione Múltiplas e, de seguida, no campo Número da porta, introduza 80,8008,8080,8088.
      4. Clique em Concluído.
   3. Para processar o tráfego IPv4, faça o seguinte:
      1. Clique em Adicionar IP e porta do front-end.
      2. Em Nome, introduza fr-ilb.
      3. Para Sub-rede, selecione lb-subnet.
      4. Na secção Finalidade do IP interno, na lista Endereço IP, selecione Criar endereço IP, introduza as seguintes informações e, de seguida, clique em Reservar.
         • Nome: ip-ilb
         • Versão do IP: IPv4
         • Endereço IP estático: Permitir-me escolher
         • Endereço IP personalizado: 10.1.2.99
      5. Para Portas, selecione Múltiplas e, em seguida, em Números de portas,introduza 80,8008, 8080 e 8088.
      6. Clique em Concluído.
      7. Antes de continuar, verifique se existe uma marca de verificação azul junto a Configuração do frontend.

Reveja a configuração

1. Clique em Rever e finalizar. Verifique todas as suas definições.
2. Se as definições estiverem corretas, clique em Criar. A criação do balanceador de carga de encaminhamento interno demora alguns minutos.

gcloud

1. Crie uma nova verificação de funcionamento de HTTP regional para testar a conetividade HTTP às VMs na porta 80.

   gcloud compute health-checks create http hc-http-80 \
       --region=us-west1 \
       --port=80
   

2. Crie o serviço de back-end para o tráfego HTTP:

   gcloud compute backend-services create be-ilb \
       --load-balancing-scheme=internal \
       --protocol=tcp \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

3. Adicione os dois grupos de instâncias ao serviço de back-end:

   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

4. Crie duas regras de encaminhamento para o serviço de back-end. Quando criar a regra de encaminhamento IPv4, especifique 10.1.2.99 para o endereço IP interno na sub-rede para endereços IPv4.

   gcloud compute forwarding-rules create fr-ilb \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --subnet=lb-subnet \
       --address=10.1.2.99 \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
   

   gcloud compute forwarding-rules create fr-ilb-ipv6 \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --subnet=lb-subnet \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1 \
       --ip-version=IPV6
   

api

Crie a verificação de funcionamento fazendo um pedido POST ao método regionHealthChecks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/regionHealthChecks

{
"name": "hc-http-80",
"type": "HTTP",
"httpHealthCheck": {
  "port": 80
}
}

Crie o serviço de back-end regional fazendo um pedido POST ao regionBackendServices.insert método.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices

{
"name": "be-ilb",
"backends": [
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
    "balancingMode": "CONNECTION"
  },
  {
    "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-c/instanceGroups/ig-c",
    "balancingMode": "CONNECTION"
  }
],
"healthChecks": [
  "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"connectionDraining": {
  "drainingTimeoutSec": 0
 }
}

Crie a regra de encaminhamento fazendo um pedido POST ao método forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-ipv6",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"ipVersion": "IPV6",
"networkTier": "PREMIUM"
}

Crie a regra de encaminhamento fazendo um pedido POST ao método forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080", "8088"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

Teste o balanceador de carga

Para testar o balanceador de carga, crie uma VM cliente na mesma região que o balanceador de carga e, em seguida, envie tráfego do cliente para o balanceador de carga.

Crie uma VM de cliente

Este exemplo cria uma VM de cliente (vm-client) na mesma região que as VMs de back-end (servidor). O cliente é usado para validar a configuração do equilibrador de carga e demonstrar o comportamento esperado, conforme descrito na secção de testes.

Consola

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

   Aceder às instâncias de VM

2. Clique em Criar instância.

3. Em Nome, introduza vm-client.

4. Para Região, selecione us-west1.

5. Para Zona, selecione us-west1-a.

6. Clique em Opções avançadas.

7. Clique em Rede e configure os seguintes campos:

   1. Para etiquetas de rede, introduza allow-ssh.
   2. Para Interfaces de rede, selecione o seguinte:
      • Rede: lb-network-dual-stack
      • Subnet: lb-subnet
      • Tipo de pilha de IP: IPv4 e IPv6 (dupla pilha)
      • IP interno principal: efémero (automático)
      • IP externo: efémero
   3. Clique em Concluído.

8. Clique em Criar.

gcloud

A VM do cliente pode estar em qualquer zona na mesma região que o balanceador de carga e pode usar qualquer sub-rede nessa região. Neste exemplo, o cliente está na zona us-west1-a e usa a mesma sub-rede que as VMs de back-end.

gcloud compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --stack-type=IPV4_IPV6 \
    --tags=allow-ssh \
    --subnet=lb-subnet

api

Faça um pedido POST ao método instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances

{
 "name": "vm-client",
 "tags": {
   "items": [
     "allow-ssh"
   ]
 },
 "machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/machineTypes/e2-standard-2",
 "canIpForward": false,
 "networkInterfaces": [
   {
     "stackType": "IPV4_IPV6",
     "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network-dual-stack",
     "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
     "accessConfigs": [
       {
         "type": "ONE_TO_ONE_NAT",
         "name": "external-nat",
         "networkTier": "PREMIUM"
       }
     ]
   }
 ],
 "disks": [
   {
     "type": "PERSISTENT",
     "boot": true,
     "mode": "READ_WRITE",
     "autoDelete": true,
     "deviceName": "vm-client",
     "initializeParams": {
       "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
       "diskType": "projects/PROJECT_ID/zones/us-west1-a/diskTypes/pd-standard",
       "diskSizeGb": "10"
     }
   }
 ],
 "scheduling": {
   "preemptible": false
 },
 "deletionProtection": false
}

Teste a ligação

Este teste contacta o balanceador de carga a partir de uma VM cliente separada, ou seja, não a partir de uma VM de back-end do balanceador de carga. O comportamento esperado é que o tráfego seja distribuído entre as quatro VMs de back-end.

1. Ligue-se à instância de VM do cliente.

   gcloud compute ssh vm-client --zone=us-west1-a
   

2. Descreva a regra de encaminhamento IPv6 fr-ilb-ipv6. Tenha em atenção o IPV6_ADDRESS na descrição.

   gcloud compute forwarding-rules describe fr-ilb-ipv6 --region=us-west1
   

3. Descreva a regra de encaminhamento IPv4 fr-ilb.

   gcloud compute forwarding-rules describe fr-ilb --region=us-west1
   

4. Em clientes com conetividade IPv6, execute o seguinte comando:

   curl -m 10 -s http://IPV6_ADDRESS:80
   

   Por exemplo, se o endereço IPv6 atribuído for [fd20:1db0:b882:802:0:46:0:0/96]:80, o comando deve ter o seguinte aspeto:

   curl -m 10 -s http://[fd20:1db0:b882:802:0:46:0:0]:80
   

5. Em clientes com conetividade IPv4, execute o seguinte comando:

   curl -m 10 -s http://10.1.2.99:80
   

   Substitua os marcadores de posição por valores válidos:

   • IPV6_ADDRESS é o endereço IPv6 efémero na regra de encaminhamento fr-ilb-ipv6.

Configure o balanceador de carga com sub-redes e back-ends apenas IPv6

Este documento mostra como configurar e testar um balanceador de carga de rede de encaminhamento interno que suporta apenas tráfego IPv6. Os passos nesta secção descrevem como configurar o seguinte:

1. Uma rede VPC no modo personalizado denominada lb-network-ipv6-only. O tráfego IPv6 requer uma sub-rede de modo personalizado.
2. Uma sub-rede apenas IPv6 interna denominada lb-subnet-ipv6-only (stack-type definida como IPV6_ONLY), que é necessária para o tráfego apenas IPv6.
3. Regras de firewall que permitem ligações recebidas a VMs de back-end.
4. O grupo de instâncias de back-end, que está localizado na seguinte região e sub-rede para este exemplo:
   • Região: us-west1
   • Sub-rede: lb-subnet-ipv6-only o intervalo de endereços IPv6 para a sub-rede é atribuído automaticamente. A Google fornece um bloco CIDR IPv6 de tamanho fixo (/64).
5. Quatro VMs de back-end apenas IPv6: duas VMs num grupo de instâncias não gerido na zona us-west1-a e duas VMs num grupo de instâncias não gerido na zona us-west1-c.
6. Um servidor TCP IPv6 nas VMs de back-end. O servidor ouve as ligações recebidas no VIP especificado da regra de encaminhamento do balanceador de carga e na interface de rede especificada. O servidor aceita ligações de clientes recebidas, envia uma resposta e, em seguida, fecha a ligação.
7. Uma VM cliente para testar as ligações.
8. Os seguintes componentes do balanceador de carga de rede de encaminhamento interno:
   • Uma verificação de funcionamento para o serviço de back-end
   • Um serviço de back-end interno na região us-west1 para gerir a distribuição de ligações aos dois grupos de instâncias zonais
   • Uma regra de encaminhamento IPv6

Também pode configurar um balanceador de carga de rede de encaminhamento interno com back-ends apenas IPv6 internos através de uma instância de VM que funcione como gateway NAT. Para saber mais acerca desta configuração, consulte o artigo Configure um Network Load Balancer de encaminhamento interno com back-ends apenas IPv6 internos.

Configure uma rede, uma região e uma sub-rede

O exemplo de balanceador de carga de rede de encaminhamento interno descrito nesta página é criado numa rede VPC de modo personalizado denominada lb-network-ipv6-only.

Para configurar sub-redes com intervalos IPv6 internos, ative um intervalo IPv6 interno ULA de rede VPC. Os intervalos de sub-redes IPv6 internas são atribuídos a partir deste intervalo.

Mais tarde, na secção Instale um servidor TCP IPv6 nas VMs de back-end através de um script Bash de arranque deste documento, o intervalo da sub-rede IPv6 interna é usado para criar uma regra de encaminhamento para encaminhar o tráfego da sub-rede da VPC através do gateway e da interface de rede especificados.

Consola

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

   Aceda a redes de VPC

2. Clique em Criar rede de VPC.

3. Em Nome, introduza lb-network-ipv6-only.

4. Se quiser configurar intervalos de endereços IPv6 internos em sub-redes nesta rede, conclua estes passos:

   1. Para as Definições de endereço IPv6 privado, selecione Configurar um intervalo IPv6 interno para esta rede VPC.
   2. Para Atribuir intervalo IPv6 interno, selecione Automaticamente ou Manualmente. Se selecionar Manualmente, introduza um intervalo de /48 no intervalo de fd20::/20. Se o intervalo já estiver a ser usado, é-lhe pedido que forneça um intervalo diferente.

5. Para o Modo de criação de sub-rede, selecione Personalizado.

6. Na secção Nova sub-rede, especifique os seguintes parâmetros de configuração de uma sub-rede:

   • Nome: lb-subnet-ipv6-only
   • Região: us-west1
   • Tipo de pilha de IP: IPv6 (pilha única)
   • Tipo de acesso IPv6: interno

7. Clique em Concluído.

8. Clique em Criar.

gcloud

1. Para criar uma nova rede VPC no modo personalizado, execute o comando gcloud compute networks create.

   Para configurar intervalos IPv6 internos em quaisquer sub-redes nesta rede, use a flag --enable-ula-internal-ipv6.

   gcloud compute networks create lb-network-ipv6-only \
     --subnet-mode=custom \
     --enable-ula-internal-ipv6 \
     --bgp-routing-mode=regional
   

2. Configure uma sub-rede com o ipv6-access-type definido como INTERNAL. Isto indica que as VMs nesta sub-rede só podem ter endereços IPv6 internos.Para criar a sub-rede, execute o comando gcloud compute networks subnets create.

   gcloud compute networks subnets create lb-subnet-ipv6-only \
     --network=lb-network-ipv6-only \
     --region=us-west1 \
     --stack-type=IPV6_ONLY \
     --ipv6-access-type=INTERNAL
   

Configure regras de firewall

Este exemplo usa as seguintes regras de firewall:

• fw-allow-lb-access-ipv6-only: uma regra de entrada, aplicável a todos os destinos na rede VPC, que permite o tráfego de todas as origens IPv6.

• fw-allow-ssh: uma regra de entrada, aplicável às instâncias com balanceamento de carga, 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 do sistema a partir do qual inicia sessões SSH. Este exemplo usa a etiqueta de destino allow-ssh para identificar as VMs às quais se deve aplicar.

• fw-allow-health-check-ipv6-only: uma regra de entrada, aplicável às instâncias com balanceamento de carga, que permite o tráfego dos sistemas de verificação de estado (2600:2d00:1:b029::/64). Este exemplo usa a etiqueta de destino allow-health-check-ipv6 para identificar as instâncias às quais tem de se aplicar. Google Cloud

Sem estas regras de firewall, a regra de negação predefinida de entrada bloqueia o tráfego de entrada para as instâncias de back-end.

Nota: tem de criar uma regra de firewall para permitir verificações de funcionamento a partir dos intervalos de IP dos sistemas de sondagem. Google Cloud Para mais informações, consulte o artigo Intervalos de IPs de sondagem e regras da firewall.

Consola

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

   Aceder a Políticas de firewall

2. Para permitir o tráfego de sub-rede IPv6, clique novamente em Criar regra de firewall e introduza as seguintes informações:

   • Nome: fw-allow-lb-access-ipv6-only
   • Rede: lb-network-ipv6-only
   • Prioridade: 1000
   • Direção do tráfego: entrada
   • Ação na correspondência: Permitir
   • Segmenta: todas as instâncias na rede
   • Filtro de origem: intervalos IPv6
   • Intervalos IPv6 de origem: ::/0
   • Protocolos e portas: Permitir tudo

3. Clique em Criar.

4. Para permitir ligações SSH recebidas, clique novamente em Criar regra de firewall e introduza as seguintes informações:

   • Nome: fw-allow-ssh
   • Rede: lb-network-ipv6-only
   • Prioridade: 1000
   • Direção do tráfego: entrada
   • Ação na correspondência: Permitir
   • Objetivos: etiquetas de destino especificadas
   • Etiquetas de segmentação: allow-ssh
   • Filtro de origem: intervalos IPv4
   • Intervalos IPv4 de origem: 0.0.0.0/0
   • Protocolos e portas: selecione Protocolos e portas especificados, selecione a caixa de verificação TCP e, de seguida, introduza 22 em Portas.

5. Clique em Criar.

6. Para permitir as verificações de funcionamento de Google Cloud IPv6, clique novamente em Criar regra de firewall e introduza as seguintes informações:

   • Nome: fw-allow-health-check-ipv6-only
   • Rede: lb-network-ipv6-only
   • Prioridade: 1000
   • Direção do tráfego: entrada
   • Ação na correspondência: Permitir
   • Objetivos: etiquetas de destino especificadas
   • Etiquetas de segmentação: allow-health-check-ipv6
   • Filtro de origem: intervalos IPv6
   • Intervalos IPv6 de origem: 2600:2d00:1:b029::/64
   • Protocolos e portas: Permitir tudo

7. Clique em Criar.

gcloud

1. Crie a regra de firewall fw-allow-lb-access-ipv6-only para permitir o tráfego IPv6 para todas as instâncias de VM na rede VPC.

   gcloud compute firewall-rules create fw-allow-lb-access-ipv6-only \
       --network=lb-network-ipv6-only \
       --action=allow \
       --direction=ingress \
       --source-ranges=::/0 \
       --rules=all
   

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=lb-network-ipv6-only \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-ssh \
       --rules=tcp:22
   

3. Crie a regra fw-allow-health-check-ipv6 para permitir Google Cloud verificações de funcionamento de IPv6.

   gcloud compute firewall-rules create fw-allow-health-check-ipv6-only \
       --network=lb-network-ipv6-only \
       --action=allow \
       --direction=ingress \
       --target-tags=allow-health-check-ipv6 \
       --source-ranges=2600:2d00:1:b029::/64 \
       --rules=tcp,udp
   

Crie VMs de back-end e grupos de instâncias

Este exemplo usa dois grupos de instâncias não geridos, cada um com duas VMs de back-end. Para demonstrar a natureza regional dos equilibradores de carga de rede de encaminhamento interno, os dois grupos de instâncias são colocados em zonas separadas, us-west1-a e us-west1-c.

• O grupo de instâncias ig-a contém estas duas VMs:
  • vm-a1
  • vm-a2
• O grupo de instâncias ig-c contém estas duas VMs:
  • vm-c1
  • vm-c2

O tráfego para todas as quatro VMs de back-end é equilibrado por carga.

Consola

Crie VMs de back-end

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

   Aceder às instâncias de VM

2. Repita estes passos para cada VM, usando as seguintes combinações de nome e zona.

   • Nome: vm-a1, zona: us-west1-a
   • Nome: vm-a2, zona: us-west1-a
   • Nome: vm-c1, zona: us-west1-c
   • Nome: vm-c2, zona: us-west1-c

3. Clique em Criar instância.

4. Defina o Nome conforme indicado no passo 2.

5. Para Região, selecione us-west1 e escolha uma Zona, conforme indicado no passo 2.

6. 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. Se necessário, clique em Alterar para alterar a imagem.

7. Clique em Opções avançadas.

8. Clique em Rede e configure os seguintes campos:

   1. Para Etiquetas de rede, introduza allow-ssh e allow-health-check-ipv6.
   2. Para Interfaces de rede, selecione o seguinte:
      • Rede: lb-network-ipv6-only
      • Subnet: lb-subnet-ipv6-only
      • Tipo de pilha de IP: IPv6 (pilha única)
      • Endereço IPv6 interno principal: efémero (automático)

9. Clique em Criar.

A VM de back-end tem de executar um servidor TCP IPv6 que ouve as ligações recebidas. Instale este servidor nas VMs de back-end depois de configurar o balanceador de carga. Isto deve-se ao facto de o script do servidor criar um socket que se associa à regra de encaminhamento do balanceador de carga.

Crie grupos de instâncias

1. Na Google Cloud consola, aceda à página Grupos de instâncias.

   Aceda a Grupos de instâncias

2. Repita os passos seguintes para criar dois grupos de instâncias não geridos, cada um com duas VMs, usando estas combinações.

   • Nome do grupo de instâncias: ig-a, zona: us-west1-a, VMs: vm-a1 e vm-a2
   • Nome do grupo de instâncias: ig-c, zona: us-west1-c, VMs: vm-c1 e vm-c2

3. Clique em Criar grupo de instâncias.

4. Clique em Novo grupo de instâncias não gerido.

5. Defina o Nome conforme indicado no passo 2.

6. Na secção Localização, selecione us-west1 para a Região e, em seguida, escolha uma Zona, conforme indicado no passo 2.

7. Para Rede, selecione lb-network-ipv6-only.

8. Para Sub-rede, selecione lb-subnet-ipv6-only.

9. Na secção Instâncias de VM, adicione as VMs conforme indicado no passo 2.

10. Clique em Criar.

gcloud

1. Para criar as quatro VMs, execute o comando gcloud compute instances create quatro vezes, usando estas quatro combinações para [VM-NAME] e [ZONE].

   • VM-NAME: vm-a1, ZONE: us-west1-a
   • VM-NAME: vm-a2, ZONE: us-west1-a
   • VM-NAME: vm-c1, ZONE: us-west1-c
   • VM-NAME: vm-c2, ZONE: us-west1-c

   gcloud beta compute instances create VM-NAME \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check-ipv6 \
       --subnet=lb-subnet-ipv6-only \
       --stack-type=IPV6_ONLY
   

   A VM de back-end tem de executar um servidor TCP IPv6 que ouve as ligações recebidas. Instale este servidor nas VMs de back-end depois de configurar o balanceador de carga. Isto deve-se ao facto de o script do servidor criar um socket que se associa à regra de encaminhamento do balanceador de carga.

2. Crie os dois grupos de instâncias não geridos em cada zona:

   gcloud beta compute instance-groups unmanaged create ig-a \
       --zone=us-west1-a
   gcloud beta compute instance-groups unmanaged create ig-c \
       --zone=us-west1-c
   

3. Adicione as VMs aos grupos de instâncias adequados:

   gcloud beta compute instance-groups unmanaged add-instances ig-a \
     --zone=us-west1-a \
     --instances=vm-a1,vm-a2
   gcloud beta compute instance-groups unmanaged add-instances ig-c \
     --zone=us-west1-c \
     --instances=vm-c1,vm-c2
   

Configure os componentes do balanceador de carga

Estes passos configuram todos os componentes do balanceador de carga de rede de encaminhamento interno, começando pela verificação de estado e pelo serviço de back-end e, em seguida, pelos componentes de front-end:

Consola

Inicie a configuração

1. Na Google Cloud consola, aceda à página Equilíbrio de carga.

   Aceda ao balanceamento de carga

2. Clique em Criar equilibrador de carga.
3. Para Tipo de balanceador de carga, selecione Balanceador de carga de rede (TCP/UDP/SSL) e clique em Seguinte.
4. Para Proxy ou passagem, selecione Passagem do balanceador de carga e clique em Seguinte.
5. Para Público ou interno, selecione Interno e clique em Seguinte.
6. Clique em Configurar.

Configuração básica

Na página Criar balanceador de carga de rede de encaminhamento interno, introduza as seguintes informações:

• Nome do balanceador de carga: ilb-ipv6-only
• Região: us-west1
• Rede: lb-network-ipv6-only

Configuração do back-end

1. Clique em Configuração de back-end.
2. Na lista Verificação de funcionamento, clique em Criar uma verificação de funcionamento e, de seguida, introduza as seguintes informações:
   • Nome: hc-http-80
   • Âmbito: regional
   • Protocolo: HTTP
   • Porta: 80
   • Protocolo proxy: Nenhum
   • Pedido: /
3. Clique em Criar.
4. Na secção Novo back-end, para Tipo de pilha de IP, selecione a opção IPv6 (pilha única).
5. Em Grupo de instâncias, selecione o grupo de instâncias ig-a e clique em Concluído.
6. Clique em Adicionar um back-end e repita o passo para adicionar o grupo de instâncias ig-c.
7. Verifique se aparece uma marca de verificação azul junto a Configuração de back-end.

Configuração da interface

1. Clique em Configuração do front-end. Na secção Novo IP e porta de front-end, faça o seguinte:
   1. Em Nome, introduza fr-ilb-ipv6-only.
   2. Para processar o tráfego IPv6, faça o seguinte:
      1. Para a versão do IP, selecione IPv6. O servidor TCP IPv6 que vai criar na secção seguinte associa-se ao VIP da regra de encaminhamento.
      2. Para Sub-rede, selecionelb-subnet-ipv6-only. O intervalo de endereços IPv6 na regra de encaminhamento é sempre efémero.
      3. Para Portas, selecione Múltiplas e, de seguida, no campo Número da porta, introduza 80,8008,8080,8088.
      4. Clique em Concluído.
   3. Antes de continuar, verifique se existe uma marca de verificação azul junto a Configuração do frontend.

Reveja a configuração

1. Clique em Rever e finalizar. Verifique todas as suas definições.
2. Se as definições estiverem corretas, clique em Criar. A criação do balanceador de carga de encaminhamento interno demora alguns minutos.

gcloud

1. Crie uma nova verificação de funcionamento de HTTP regional para testar a conetividade HTTP às VMs na porta 80.

   gcloud beta compute health-checks create http hc-http-80 \
       --region=us-west1 \
       --port=80
   

2. Crie o serviço de back-end:

   gcloud beta compute backend-services create ilb-ipv6-only \
       --load-balancing-scheme=INTERNAL \
       --protocol=tcp \
       --region=us-west1 \
       --health-checks=hc-http-80 \
       --health-checks-region=us-west1
   

3. Adicione os dois grupos de instâncias ao serviço de back-end:

   gcloud beta compute backend-services add-backend ilb-ipv6-only \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   

   gcloud beta compute backend-services add-backend ilb-ipv6-only \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

4. Crie a regra de encaminhamento IPv6 com um endereço IPv6 temporário.

   gcloud beta compute forwarding-rules create fr-ilb-ipv6-only \
       --region=us-west1 \
       --load-balancing-scheme=INTERNAL \
       --subnet=lb-subnet-ipv6-only \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=ilb-ipv6-only \
       --backend-service-region=us-west1 \
       --ip-version=IPV6
   

   O servidor TCP IPv6 que vai criar na secção seguinte associa-se ao VIP da regra de encaminhamento.

Instale um servidor TCP IPv6 nas VMs de back-end através de um script Bash de arranque

Neste exemplo, o script de arranque do Bash para VMs de back-end contém o seguinte:

• Comandos de rede para encaminhar todos os pacotes de saída originários de uma sub-rede através de um gateway e uma interface de rede especificados.
• Script do servidor Python (server.py), que é um servidor TCP IPv6, que ouve as ligações recebidas no VIP e na interface de rede especificados. Aceita ligações de clientes recebidas, envia uma resposta e, em seguida, fecha a ligação.

Tem de adicionar os seguintes detalhes no script Bash:

• Endereço do gateway
• Intervalo de sub-rede
• VIP da regra de encaminhamento
• Interface de rede

Pode identificar o endereço de gateway e o intervalo de sub-rede executando o comando ip -6 route show table all na VM de back-end. Para saber mais acerca dos comandos usados no script Bash de arranque, consulte a secção Apêndice.

Para adicionar um script de arranque à instância de VM, faça o seguinte:

Nota: tem de executar estes passos para cada VM de back-end que criou anteriormente.

Consola

1. Na lista de instâncias de VM que criou anteriormente, clique na instância de VM que tem de atualizar.

2. Clique em Edit.

3. Na secção Metadados, introduza o seguinte guião no campo Guião de arranque.

   Nota: o script do servidor server.py referenciado no script Bash está armazenado na pasta raiz da VM de back-end.

   #!/bin/bash
   
   # Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
   GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
   SUBNET_RANGE=fd20:307:120c:2000::/64
   
   # Add a custom default route to routing table 1.
   # The following command sends packets to the gateway using the network interface named 'ens4'.
   sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1
   
   # Add a source-based policy routing rule.
   # The following command adds a rule to route all outgoing packets originating
   # from a specified subnet. If the source address matches the subnet,
   # the system uses the default route defined in table 1 to forward the traffic.
   sudo ip -6 rule add from $SUBNET_RANGE table 1
   
   # Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
   sudo sysctl -w net.ipv6.ip_nonlocal_bind=1
   
   # Overview:
   # This script sets up a simple IPv6 TCP server using Python's socket library.
   # The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
   # It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
   # Key features:
   # - Uses IPv6 (AF_INET6) for networking.
   # - Binds to a specific network interface using SO_BINDTODEVICE.
   # - Handles multiple client connections in a loop.
   # - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
   # Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.
   
   # Write the Python file locally.
   cat << 'EOF' > server.py
   
   # Import the socket library to work with network connections
   import socket
   import urllib.request
   
   # Fetch the VM hostname from Google Cloud metadata server
   def get_vm_hostname():
       url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
       req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
       with urllib.request.urlopen(req) as response:
           return response.read().decode()
   
   vm_hostname = get_vm_hostname()
   
   # Create a socket object for IPv6 and TCP connections
   # AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
   server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
   
   # Set the SO_REUSEADDR option to allow reusing the address
   # This is useful to avoid "address already in use" errors when restarting the server
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
   
   # Specify the network interface to bind the server to
   # Replace "ens4" with the name of your network interface
   interface_name = "ens4"
   # Get the index of the network interface
   interface_index = socket.if_nametoindex(interface_name)
   # Bind the socket to the specified network interface
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())
   
   # Bind the socket to an address and port
   # Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
   server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
   server_socket.bind(server_address)
   
   # Start listening for incoming connections
   # The argument '5' specifies the maximum number of queued connections
   server_socket.listen(5)
   
   # Print a message indicating that the server is ready to accept connections
   print(f"Server listening on {server_address}, bound to {interface_name}")
   
   # Serve incoming connections
   while True:
       client_socket, client_address = server_socket.accept()
       print(f"Accepted connection from {client_address}")
   
       # Generate response body
       body = f"Thank you for connecting to {vm_hostname}\n"
   
       # Construct a proper HTTP/1.1 response
       response = (
           "HTTP/1.1 200 OK\r\n"
           f"Content-Length: {len(body)}\r\n"
           "Content-Type: text/plain\r\n"
           "Connection: close\r\n"
           "\r\n"
           f"{body}"
       )
   
       # Send the response and close the connection
       client_socket.sendall(response.encode())
       client_socket.close()
   EOF
   
   # Make the Python script executable
   chmod +x server.py
   
   # Run the server
   sudo python3 server.py
   
   

4. Clique em Guardar.

5. Reinicie a instância.

gcloud

1. Crie um script de arranque.

   nano startup.sh
   

2. Adicione o seguinte script e guarde o ficheiro.

   Nota: o script do servidor server.py referenciado no script Bash está armazenado na pasta raiz da VM de back-end.

   #!/bin/bash
   
   # Replace these with your actual values. Run the 'ip -6 route show table all' command to find the correct values.
   GATEWAY_ADDRESS=fe80::57:2ff:fe36:ffbe
   SUBNET_RANGE=fd20:307:120c:2000::/64
   
   # Add a custom default route to routing table 1.
   # The following command sends packets to the gateway using the network interface named 'ens4'.
   sudo ip route add default via $GATEWAY_ADDRESS dev ens4 table 1
   
   # Add a source-based policy routing rule.
   # The following command adds a rule to route all outgoing packets originating
   # from a specified subnet. If the source address matches the subnet,
   # the system uses the default route defined in table 1 to forward the traffic.
   sudo ip -6 rule add from $SUBNET_RANGE table 1
   
   # Allow the server to bind to a non-local IPv6 address--the VIP of the load balancer.
   sudo sysctl -w net.ipv6.ip_nonlocal_bind=1
   
   # Overview:
   # This script sets up a simple IPv6 TCP server using Python's socket library.
   # The server binds to a specific network interface and listens on a specified Virtual IP (VIP) address and port (default: 80).
   # It accepts incoming client connections, sends a simple response ("Thank you for connecting"), and then closes the connection.
   # Key features:
   # - Uses IPv6 (AF_INET6) for networking.
   # - Binds to a specific network interface using SO_BINDTODEVICE.
   # - Handles multiple client connections in a loop.
   # - Demonstrates basic socket programming concepts like binding, listening, accepting, and sending data.
   # Note: Replace placeholders like 'FORWARDING_RULE_VIP' and 'ens4' with actual values for your setup.
   
   # Write the Python file locally.
   cat << 'EOF' > server.py
   
   # Import the socket library to work with network connections
   import socket
   import urllib.request
   
   # Fetch the VM hostname from Google Cloud metadata server
   def get_vm_hostname():
       url = "http://metadata.google.internal/computeMetadata/v1/instance/name"
       req = urllib.request.Request(url, headers={"Metadata-Flavor": "Google"})
       with urllib.request.urlopen(req) as response:
           return response.read().decode()
   
   vm_hostname = get_vm_hostname()
   
   # Create a socket object for IPv6 and TCP connections
   # AF_INET6 specifies IPv6, SOCK_STREAM specifies TCP
   server_socket = socket.socket(socket.AF_INET6, socket.SOCK_STREAM)
   
   # Set the SO_REUSEADDR option to allow reusing the address
   # This is useful to avoid "address already in use" errors when restarting the server
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
   
   # Specify the network interface to bind the server to
   # Replace "ens4" with the name of your network interface
   interface_name = "ens4"
   # Get the index of the network interface
   interface_index = socket.if_nametoindex(interface_name)
   # Bind the socket to the specified network interface
   server_socket.setsockopt(socket.SOL_SOCKET, socket.SO_BINDTODEVICE, interface_name.encode())
   
   # Bind the socket to an address and port
   # Replace 'FORWARDING_RULE_VIP' with the actual VIP (Virtual IP) address
   server_address = ('FORWARDING_RULE_VIP', 80, 0, 0)
   server_socket.bind(server_address)
   
   # Start listening for incoming connections
   # The argument '5' specifies the maximum number of queued connections
   server_socket.listen(5)
   
   # Print a message indicating that the server is ready to accept connections
   print(f"Server listening on {server_address}, bound to {interface_name}")
   
   # Serve incoming connections
   while True:
       client_socket, client_address = server_socket.accept()
       print(f"Accepted connection from {client_address}")
   
       # Generate response body
       body = f"Thank you for connecting to {vm_hostname}\n"
   
       # Construct a proper HTTP/1.1 response
       response = (
           "HTTP/1.1 200 OK\r\n"
           f"Content-Length: {len(body)}\r\n"
           "Content-Type: text/plain\r\n"
           "Connection: close\r\n"
           "\r\n"
           f"{body}"
       )
   
       # Send the response and close the connection
       client_socket.sendall(response.encode())
       client_socket.close()
   EOF
   
   # Make the Python script executable
   chmod +x server.py
   
   # Run the server
   sudo python3 server.py
   
   

3. Adicione o ficheiro de metadados à instância de VM.

   gcloud compute instances add-metadata VM-NAME \
     --metadata-from-file=startup-script=startup.sh
   

4. Reinicie a instância.

Teste o balanceador de carga

Para testar o balanceador de carga, crie uma VM cliente na mesma região que o balanceador de carga e, em seguida, envie tráfego do cliente para o balanceador de carga.

Crie uma VM de cliente

Este exemplo cria uma VM de cliente (vm-client) na mesma região que as VMs de back-end (servidor). O cliente é usado para validar a configuração do equilibrador de carga e demonstrar o comportamento esperado, conforme descrito na secção de testes.

Consola

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

   Aceder às instâncias de VM

2. Clique em Criar instância.

3. Em Nome, introduza vm-client.

4. Para Região, selecione us-west1.

5. Para Zona, selecione us-west1-a.

6. Clique em Opções avançadas.

7. Clique em Rede e configure os seguintes campos:

   1. Para etiquetas de rede, introduza allow-ssh.
   2. Para Interfaces de rede, selecione o seguinte:
      • Rede: lb-network-ipv6-only
      • Subnet: lb-subnet-ipv6-only
      • Tipo de pilha de IP: IPv6 (pilha única)
   3. Clique em Concluído.

8. Clique em Criar.

gcloud

A VM do cliente pode estar em qualquer zona na mesma região que o balanceador de carga e pode usar qualquer sub-rede nessa região. Neste exemplo, o cliente está na zona us-west1-a e usa a mesma sub-rede que as VMs de back-end.

gcloud beta compute instances create vm-client \
    --zone=us-west1-a \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --stack-type=IPV6_ONLY \
    --tags=allow-ssh \
    --subnet=lb-subnet-ipv6-only

Teste a ligação

Este teste contacta o balanceador de carga a partir de uma VM cliente separada, ou seja, não a partir de uma VM de back-end do balanceador de carga. O comportamento esperado é que o tráfego seja distribuído entre as quatro VMs de back-end.

1. Estabeleça ligação à instância de VM do cliente através do SSH.

   gcloud compute ssh vm-client --zone=us-west1-a
   

2. Descreva a regra de encaminhamento IPv6 fr-ilb-ipv6-only. Tenha em atenção o IPV6_ADDRESS na descrição.

   gcloud beta compute forwarding-rules describe fr-ilb-ipv6-only \
       --region=us-west1
   

3. Em clientes com conetividade IPv6, execute o seguinte comando:

   curl http://IPV6_ADDRESS:80
   

   Por exemplo, se o endereço IPv6 atribuído for [fd20:307:120c:2000:0:1:0:0/96]:80, o comando deve ter o seguinte aspeto:

   curl http://[fd20:307:120c:2000:0:1:0:0]:80
   

Opções de configuração adicionais

Esta secção expande o exemplo de configuração para oferecer opções de configuração alternativas e adicionais. Todas as tarefas são opcionais. Pode realizá-las por qualquer ordem.

Ative o acesso global

Pode ativar o acesso global para o Network Load Balancer de encaminhamento interno de exemplo para o tornar acessível a clientes em todas as regiões. Os back-ends do balanceador de carga de exemplo têm de estar localizados numa região (us-west1).

Balanceador de carga de passagem interno com acesso global (clique para aumentar).

Para configurar o acesso global, faça as seguintes alterações de configuração.

Consola

Edite a regra de encaminhamento do balanceador de carga

1. Na Google Cloud consola, aceda à página Equilíbrio de carga.

   Aceda a Balanceamento de carga

2. Na coluna Nome, clique no seu Network Load Balancer de encaminhamento interno. O equilibrador de carga de exemplo tem o nome be-ilb.

3. Clique em Configuração do front-end.

4. Clique em Editar .

5. Em Acesso global, selecione Ativar.

6. Clique em Concluído.

7. Clique em Atualizar.

Na página Detalhes do balanceador de carga, verifique se a configuração de front-end indica Regional (REGION) com acesso global.

gcloud

1. Atualize a regra de encaminhamento do balanceador de carga de exemplo, fr-ilb, para incluir a flag --allow-global-access.

    gcloud compute forwarding-rules update fr-ilb \
        --region=us-west1 \
        --allow-global-access
   

2. Pode usar o comando forwarding-rules describe para determinar se uma regra de encaminhamento tem o acesso global ativado. Por exemplo:

    gcloud compute forwarding-rules describe fr-ilb \
        --region=us-west1 \
        --format="get(name,region,allowGlobalAccess)"
   

   A palavra True aparece no resultado, após o nome e a região da regra de encaminhamento, quando o acesso global está ativado.

API

Faça um pedido PATCH ao método forwardingRules/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

{
"allowGlobalAccess": true
}

Crie um cliente de VM para testar o acesso global

Consola

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

   Aceder às instâncias de VM

2. Clique em Criar instância.

3. Defina o Nome como vm-client2.

4. Defina a Região como europe-west1.

5. Defina a Zona como europe-west1-b.

6. Clique em Opções avançadas.

7. Clique em Rede e configure os seguintes campos:

   1. Para etiquetas de rede, introduza allow-ssh.
   2. Para Interfaces de rede, selecione o seguinte:
      • Rede: lb-network
      • Subnet: europe-subnet

8. Clique em Criar.

gcloud

A VM do cliente pode estar em qualquer zona na mesma região que o balanceador de carga e pode usar qualquer sub-rede nessa região. Neste exemplo, o cliente está na zona europe-west1-b e usa a mesma sub-rede que as VMs de back-end.

gcloud compute instances create vm-client2 \
    --zone=europe-west1-b \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=europe-subnet

API

Faça um pedido POST ao método instances.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/instances

{
"name": "vm-client2",
"tags": {
  "items": [
    "allow-ssh"
  ]
},
"machineType": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/europe-west1-b/machineTypes/e2-standard-2",
"canIpForward": false,
"networkInterfaces": [
  {
    "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
    "subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/europe-west1/subnetworks/europe-subnet",
    "accessConfigs": [
      {
        "type": "ONE_TO_ONE_NAT",
        "name": "external-nat",
        "networkTier": "PREMIUM"
      }
    ]
  }
],
"disks": [
  {
    "type": "PERSISTENT",
    "boot": true,
    "mode": "READ_WRITE",
    "autoDelete": true,
    "deviceName": "vm-client2",
    "initializeParams": {
      "sourceImage": "projects/debian-cloud/global/images/debian-image-name",
      "diskType": "projects/PROJECT_ID/zones/europe-west1-b/diskTypes/pd-standard",
      "diskSizeGb": "10"
    }
  }
],
"scheduling": {
  "preemptible": false
},
"deletionProtection": false
}

Ligue-se ao cliente de VM e teste a conetividade

Para testar a conetividade, execute o seguinte comando:

  gcloud compute ssh vm-client2 --zone=europe-west1-b
  

Teste a ligação ao balanceador de carga em todas as portas configuradas, tal como fez a partir do vm-client na região us-west1. Teste a conetividade HTTP nas quatro portas configuradas na regra de encaminhamento:

  curl http://10.1.2.99
  curl http://10.1.2.99:8008
  curl http://10.1.2.99:8080
  curl http://10.1.2.99:8088
  

Configure grupos de instâncias geridas

Importante: os grupos de instâncias geridos não são suportados como back-ends para equilibradores de carga que usam sub-redes e back-ends apenas IPv6.

A configuração de exemplo criou dois grupos de instâncias não geridos. Em alternativa, pode usar grupos de instâncias geridos, incluindo grupos de instâncias geridos zonais e regionais, como back-ends para equilibradores de carga de rede de encaminhamento interno.

Os grupos de instâncias geridas requerem que crie um modelo de instância. Este procedimento demonstra como substituir os dois grupos de instâncias não geridos zonais do exemplo por um único grupo de instâncias gerido regional. Um grupo de instâncias gerido regional cria automaticamente VMs em várias zonas da região, o que simplifica a distribuição do tráfego de produção entre zonas.

Os grupos de instâncias geridos também suportam o dimensionamento automático e a recuperação automática. Se usar o dimensionamento automático com equilibradores de carga de passagem interna de rede, não pode fazer o dimensionamento com base no equilíbrio de carga.

Este procedimento mostra como modificar o serviço de back-end para o exemplo de Network Load Balancer de encaminhamento interno, de modo que use um grupo de instâncias geridas regional.

Consola

Modelo de instância

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

   Aceda aos modelos de instâncias de VM

2. Clique em Criar modelo de instância.

3. Defina o Nome como template-vm-ilb.

4. Escolha um tipo de máquina.

5. 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. Se necessário, clique em Alterar para alterar a imagem.

6. Clique em Opções avançadas.

7. Clique em Rede e configure os seguintes campos:

   1. Para Etiquetas de rede, introduza allow-ssh e allow-health-check.
   2. Para Interfaces de rede, selecione o seguinte:
      • Rede: lb-network
      • Subnet: lb-subnet

8. Clique em Gestão e, de seguida, no campo Script de arranque, introduza o seguinte script:

   #! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   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
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed
   

9. Clique em Criar.

Grupo de instâncias geridas

1. Na Google Cloud consola, aceda à página Grupos de instâncias.

   Aceda a Grupos de instâncias

2. Clique em Criar grupo de instâncias.

3. Defina o Nome como ig-ilb.

4. Para Localização, escolha Várias zonas e defina a Região como us-west1.

5. Defina o modelo de instância como template-vm-ilb.

6. Opcional: configure o ajuste automático de escala. Não pode ajustar automaticamente a escala do grupo de instâncias com base na utilização do balanceamento de carga HTTP, porque o grupo de instâncias é um back-end para o balanceador de carga de rede de passagem interno.

7. Defina o Número mínimo de instâncias como 1 e o Número máximo de instâncias como 6.

8. Opcional: configure a autorreparação. Se configurar a autorreparação, use a mesma verificação de estado usada pelo serviço de back-end para o Network Load Balancer de encaminhamento interno. Neste exemplo, use hc-http-80.

9. Clique em Criar.

gcloud

1. Crie o modelo de instância. Opcionalmente, pode definir outros parâmetros, como o tipo de máquina, para o modelo de imagem usar.

   gcloud compute instance-templates create template-vm-ilb \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-health-check \
       --subnet=lb-subnet \
       --region=us-west1 \
       --network=lb-network \
       --metadata=startup-script='#! /bin/bash
   if [ -f /etc/startup_script_completed ]; then
   exit 0
   fi
   apt-get update
   apt-get install apache2 -y
   a2ensite default-ssl
   a2enmod ssl
   file_ports="/etc/apache2/ports.conf"
   file_http_site="/etc/apache2/sites-available/000-default.conf"
   file_https_site="/etc/apache2/sites-available/default-ssl.conf"
   http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
   http_vh_prts="*:80 *:8008 *:8080 *:8088"
   https_listen_prts="Listen 443\nListen 8443"
   https_vh_prts="*:443 *:8443"
   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
   prt_conf="$(cat "$file_ports")"
   prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
   prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
   echo "$prt_conf" | tee "$file_ports"
   http_site_conf="$(cat "$file_http_site")"
   http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
   echo "$http_site_conf_2" | tee "$file_http_site"
   https_site_conf="$(cat "$file_https_site")"
   https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
   echo "$https_site_conf_2" | tee "$file_https_site"
   systemctl restart apache2
   touch /etc/startup_script_completed'
   

2. Crie um grupo de instâncias geridas regional com o modelo:

   gcloud compute instance-groups managed create ig-ilb \
       --template=template-vm-ilb \
       --region=us-west1 \
       --size=6
   

3. Adicione o grupo de instâncias gerido regional como back-end ao serviço de back-end que já criou:

   gcloud compute backend-services add-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-ilb \
       --instance-group-region=us-west1
   

4. Desligue os dois grupos de instâncias não geridos (zonais) do serviço de back-end:

   gcloud compute backend-services remove-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-a \
       --instance-group-zone=us-west1-a
   gcloud compute backend-services remove-backend be-ilb \
       --region=us-west1 \
       --instance-group=ig-c \
       --instance-group-zone=us-west1-c
   

Remova endereços IP externos de VMs de back-end

Quando criou as VMs de back-end, foi atribuído a cada uma um endereço IP externo efémero para poder transferir o Apache através de um script de arranque. Uma vez que as VMs de back-end só são usadas por um Network Load Balancer de encaminhamento direto interno, pode remover os respetivos endereços IP externos. A remoção de endereços IP externos impede que as VMs de back-end acedam diretamente à Internet.

Importante: a remoção do endereço IP externo de uma VM limita a forma como pode estabelecer ligação à mesma. Para obter detalhes, consulte o artigo Escolha uma opção de ligação para VMs apenas internas. É útil deixar os endereços IP externos nas VMs de back-end se precisar de demonstrar como os pedidos de uma VM de back-end para o endereço IP do balanceador de carga são processados.

Consola

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

   Aceder às instâncias de VM

2. Repita os passos seguintes para cada VM de back-end.

3. Clique no nome da VM de back-end, por exemplo, vm-a1.

4. Clique em Editar.

5. Na secção Interfaces de rede, clique na rede.

6. Na lista IP externo, selecione Nenhum e clique em Concluído.

7. Clique em Guardar.

gcloud

1. Para procurar a zona de uma instância, por exemplo, se estiver a usar um grupo de instâncias gerido regional, execute o seguinte comando para cada instância para determinar a respetiva zona. Substitua [SERVER-VM] pelo nome da VM a procurar.

   gcloud compute instances list --filter="name=[SERVER-VM]"
   

2. Repita o passo seguinte para cada VM de back-end. Substitua [SERVER-VM] pelo nome da VM e substitua [ZONE] pela zona da VM.

   gcloud compute instances delete-access-config [SERVER-VM] \
       --zone=[ZONE] \
       --access-config-name=external-nat
   

API

Faça um pedido POST ao método instances.deleteAccessConfig para cada VM de back-end, substituindo vm-a1 pelo nome da VM e substituindo us-west1-a pela zona da VM.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instances/vm-a1/deleteAccessConfig?accessConfig=external-nat&networkInterface=None

Use um endereço IP interno reservado

Quando cria VMs de back-end e grupos de instâncias, a instância da VM usa um endereço IPv4 ou IPv6 interno efémero.

Os passos seguintes mostram como promover um endereço IPv4 ou IPv6 interno para um endereço IPv4 ou IPv6 interno estático e, em seguida, atualizar a instância de VM para usar o endereço IP interno estático:

1. Promova um endereço IPv4 ou IPv6 interno efémero em utilização para um endereço estático.
2. Alterar ou atribuir um endereço IPv6 interno a uma instância existente.

Em alternativa, os passos seguintes mostram como reservar um novo endereço IPv4 ou IPv6 interno estático e, em seguida, atualizar a instância de VM para usar o endereço IP interno estático:

1. Reserve um novo endereço IPv4 ou IPv6 interno estático.

   Ao contrário da reserva de IPv4 interna, a reserva de IPv6 interna não suporta a reserva de um endereço IP específico da sub-rede. Em alternativa, é automaticamente atribuído um intervalo de endereços IPv6 /96internos a partir do intervalo de endereços IPv6 /64internos da sub-rede.

2. Alterar ou atribuir um endereço IPv6 interno a uma instância existente.

Para mais informações, consulte o artigo Como reservar um endereço IP interno estático.

Aceitar tráfego em todas as portas

A regra de encaminhamento do balanceador de carga, e não o respetivo serviço de back-end, determina a porta ou as portas nas quais o balanceador de carga aceita tráfego. Para informações sobre a finalidade de cada componente, consulte Componentes.

Quando criou a regra de encaminhamento deste exemplo de balanceador de carga, configurou as portas 80, 8008, 8080 e 8088. O script de arranque que instala o Apache também o configura para aceitar ligações HTTPS nas portas 443 e 8443.

Para suportar estas seis portas, pode configurar a regra de encaminhamento para aceitar tráfego em todas as portas. Com esta estratégia, também pode configurar a regra ou as regras de firewall que permitem ligações recebidas a VMs de back-end para que só permitam determinadas portas.

Este procedimento mostra como eliminar a regra de encaminhamento atual do equilibrador de carga e criar uma nova que aceite tráfego em todas as portas.

Nota: se tentar editar a regra de encaminhamento existente adicionando uma nova porta, pode encontrar o seguinte erro: Forwarding rule's port range is conflicting with forwarding rule: resource_type: FORWARDING_RULE resource_name: "<EXISTING_FORWARDING_RULE_NAME>"

Para mais informações sobre quando usar esta configuração, consulte o artigo Balanceadores de carga de rede de passagem interna e regras de encaminhamento com um endereço IP comum.

Consola

Elimine a regra de encaminhamento e crie uma nova

1. Na Google Cloud consola, aceda à página Equilíbrio de carga.

   Aceda a Balanceamento de carga

2. Clique no balanceador de carga be-ilb e clique em Editar.

3. Clique em Configuração do front-end.

4. Mantenha o ponteiro sobre a regra de encaminhamento 10.1.2.9 e clique em Eliminar.

5. Clique em Adicionar IP e porta do front-end.

6. Na secção Novo IP e porta do front-end, introduza as seguintes informações e clique em Concluído:

   • Nome: fr-ilb
   • Subnetwork: lb-subnet
   • IP interno: ip-ilb
   • Portas: todas.

7. Antes de continuar, verifique se existe uma marca de verificação azul junto a Configuração do frontend.

8. Clique em Rever e finalizar e reveja as definições de configuração do equilibrador de carga.

9. Clique em Criar.

gcloud

1. Elimine a regra de encaminhamento existente, fr-ilb.

   gcloud compute forwarding-rules delete fr-ilb \
       --region=us-west1
   

2. Crie uma regra de encaminhamento de substituição com o mesmo nome, cuja configuração de porta use a palavra-chave ALL. Os outros parâmetros da regra de encaminhamento permanecem inalterados.

   gcloud compute forwarding-rules create fr-ilb \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=lb-subnet \
       --address=10.1.2.99 \
       --ip-protocol=TCP \
       --ports=ALL \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
   

API

Elimine a regra de encaminhamento fazendo um pedido DELETE ao método forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

Crie a regra de encaminhamento fazendo um pedido POST ao método forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"allPorts": true,
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

Teste o tráfego em todas as portas configuradas

Ligue-se à instância de VM do cliente e teste as ligações HTTP e HTTPS.

• Estabeleça ligação à VM do cliente:

  gcloud compute ssh vm-client --zone=us-west1-a
  

• Teste a conetividade HTTP em todas as quatro portas:

  curl http://10.1.2.99
  curl http://10.1.2.99:8008
  curl http://10.1.2.99:8080
  curl http://10.1.2.99:8088
  

• Teste a conetividade HTTPS nas portas 443 e 8443. A flag --insecure é necessária porque cada servidor Apache na configuração de exemplo usa um certificado autoassinado.

  curl https://10.1.2.99 --insecure
  curl https://10.1.2.99:8443 --insecure
  

• Observe que os pedidos HTTP (em todas as quatro portas) e os pedidos HTTPS (em ambas as portas) são distribuídos por todas as VMs de back-end.

Aceite tráfego em várias portas através de duas regras de encaminhamento

Quando criou a regra de encaminhamento deste exemplo de balanceador de carga, configurou as portas 80, 8008, 8080 e 8088. O script de arranque que instala o Apache também o configura para aceitar ligações HTTPS nas portas 443 e 8443.

Uma estratégia alternativa à configuração de uma única regra de encaminhamento para aceitar tráfego em todas as portas é criar várias regras de encaminhamento, cada uma a suportar cinco ou menos portas.

Este procedimento mostra como substituir a regra de encaminhamento do exemplo de equilibrador de carga por duas regras de encaminhamento, uma que processa o tráfego nas portas 80, 8008, 8080 e 8088, e a outra que processa o tráfego nas portas 443 e 8443.

Para mais informações sobre quando usar esta configuração, consulte o artigo Balanceadores de carga de rede de passagem interna e regras de encaminhamento com um endereço IP comum.

Consola

1. Na Google Cloud consola, aceda à página Regras de encaminhamento.

   Aceda a Regras de encaminhamento

2. Na coluna Nome, clique em fr-ilb e, de seguida, em Eliminar.

3. Na Google Cloud consola, aceda à página Equilíbrio de carga.

   Aceda a Balanceamento de carga

4. Na coluna Nome, clique em be-ilb.

5. Clique em Edit.

6. Clique em Configuração do front-end.

7. Clique em Adicionar IP e porta do front-end.

8. Na secção Novo endereço IP e porta do front-end, faça o seguinte:

   1. Em Nome, introduza fr-ilb-http.
   2. Para Sub-rede, selecione lb-subnet.
   3. Para Finalidade do IP interno, selecione Partilhado.
   4. Na lista Endereço IP, selecione Criar endereço IP, introduza as seguintes informações e clique em Reservar:
      • Nome: internal-10-1-2-99
      • Endereço IP estático: Deixar-me escolher
      • Endereço IP personalizado: 10.1.2.99
   5. Para Portas, selecione Múltiplas e, em seguida, em Números de portas,introduza 80,8008, 8080 e 8088.
   6. Clique em Concluído.

9. Clique em Adicionar IP e porta do front-end.

10. Na secção Novo endereço IP e porta do front-end, faça o seguinte:

    1. Em Nome, introduza fr-ilb-https.
    2. Para Sub-rede, selecione lb-subnet.
    3. Para Finalidade do IP interno, selecione Partilhado.
    4. Na lista Endereço IP, selecione internal-10-1-2-99.
    5. Para Portas, selecione Várias e, em seguida, em Números de portas, introduza 443 e 8443.
    6. Clique em Concluído.

11. Clique em Rever e finalizar e reveja as definições de configuração do equilibrador de carga.

12. Clique em Atualizar.

gcloud

1. Elimine a regra de encaminhamento existente, fr-ilb.

   gcloud compute forwarding-rules delete fr-ilb \
       --region=us-west1
   

2. Crie um endereço IP interno estático (reservado) para 10.1.2.99 e defina a respetiva flag --purpose como SHARED_LOADBALANCER_VIP. A flag --purpose é necessária para que duas regras de encaminhamento interno possam usar o mesmo endereço IP interno.

   gcloud compute addresses create internal-10-1-2-99 \
       --region=us-west1 \
       --subnet=lb-subnet \
       --addresses=10.1.2.99 \
       --purpose=SHARED_LOADBALANCER_VIP
   

   1. Crie duas regras de encaminhamento de substituição com os seguintes parâmetros:

   gcloud compute forwarding-rules create fr-ilb-http \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=lb-subnet \
       --address=10.1.2.99 \
       --ip-protocol=TCP \
       --ports=80,8008,8080,8088 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
   

   gcloud compute forwarding-rules create fr-ilb-https \
       --region=us-west1 \
       --load-balancing-scheme=internal \
       --network=lb-network \
       --subnet=lb-subnet \
       --address=10.1.2.99 \
       --ip-protocol=TCP \
       --ports=443,8443 \
       --backend-service=be-ilb \
       --backend-service-region=us-west1
   

API

Elimine a regra de encaminhamento fazendo um pedido DELETE ao método forwardingRules.delete.

DELETE https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules/fr-ilb

Crie um endereço IP interno estático (reservado) para 10.1.2.99 e defina a respetiva finalidade como SHARED_LOADBALANCER_VIP fazendo um pedido POST ao método addresses.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/addresses

{
"name": "internal-10-1-2-99",
"address": "10.1.2.99",
"prefixLength": 32,
"addressType": INTERNAL,
"purpose": SHARED_LOADBALANCER_VIP,
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet"
}

Crie duas regras de encaminhamento fazendo dois pedidos POST ao método forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-http",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "80", "8008", "8080",  "8088"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

{
"name": "fr-ilb-https",
"IPAddress": "10.1.2.99",
"IPProtocol": "TCP",
"ports": [
  "443", "8443"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

Teste o tráfego em várias portas configuradas

Ligue-se à instância de VM do cliente e teste as ligações HTTP e HTTPS.

• Estabeleça ligação à VM do cliente:

  gcloud compute ssh vm-client --zone=us-west1-a
  

• Teste a conetividade HTTP em todas as quatro portas:

  curl http://10.1.2.99
  curl http://10.1.2.99:8008
  curl http://10.1.2.99:8080
  curl http://10.1.2.99:8088
  

• Teste a conetividade HTTPS nas portas 443 e 8443. A flag --insecure é necessária porque cada servidor Apache na configuração de exemplo usa um certificado autoassinado.

  curl https://10.1.2.99 --insecure
  curl https://10.1.2.99:8443 --insecure
  

• Observe que os pedidos HTTP (em todas as quatro portas) e os pedidos HTTPS (em ambas as portas) são distribuídos por todas as VMs de back-end.

Use a afinidade de sessão

A configuração de exemplo cria um serviço de back-end sem afinidade de sessão.

Este procedimento mostra como atualizar o serviço de back-end para o exemplo de Network Load Balancer de passagem interna, de modo que use a afinidade de sessão com base num hash criado a partir dos endereços IP do cliente e do endereço IP da regra de encaminhamento interno do balanceador de carga.

Para ver os tipos de afinidade de sessão suportados, consulte as opções de afinidade de sessão.

Nota: para balanceadores de carga UDP) internos, a definição da afinidade de sessão é suportada na CLI gcloud e na API. Não pode definir a afinidade de sessão para tráfego UDP através da Google Cloud consola.

Consola

1. Na Google Cloud consola, aceda à página Equilíbrio de carga.

   Aceda a Balanceamento de carga

2. Clique em be-ilb (o nome do serviço de back-end que criou para este exemplo) e clique em Editar.

3. Na página Editar Network Load Balancer de encaminhamento interno, clique em Configuração do back-end.

4. Na lista Afinidade de sessão, selecione IP do cliente.

5. Clique em Atualizar.

gcloud

Use o seguinte comando gcloud para atualizar o serviço de back-end be-ilb, especificando a afinidade da sessão do IP do cliente:

gcloud compute backend-services update be-ilb \
    --region=us-west1 \
    --session-affinity CLIENT_IP

API

Faça um pedido PATCH ao método regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
"sessionAffinity": "CLIENT_IP"
}

Configure uma política de acompanhamento de ligações

Esta secção mostra-lhe como atualizar o serviço de back-end para alterar a política de acompanhamento de ligações predefinida do equilibrador de carga.

Uma política de acompanhamento de ligações inclui as seguintes definições:

• Modo de acompanhamento
• Persistência da ligação em back-ends não saudáveis
• Limite de tempo de inatividade

Nota: não pode usar a Google Cloud consola para configurar uma política de acompanhamento de ligações. Em alternativa, use a Google Cloud CLI ou a [API REST](/compute/docs/reference/rest/v1/regionBackendServices).

gcloud

Use o seguinte gcloud compute backend-services comando para atualizar a política de acompanhamento de ligações para o serviço de back-end:

gcloud compute backend-services update BACKEND_SERVICE \
    --region=REGION \
    --tracking-mode=TRACKING_MODE \
    --connection-persistence-on-unhealthy-backends=CONNECTION_PERSISTENCE_BEHAVIOR \
    --idle-timeout-sec=IDLE_TIMEOUT_VALUE

Substitua os marcadores de posição por valores válidos:

• BACKEND_SERVICE: o serviço de back-end que está a atualizar
• REGION: a região do serviço de back-end que está a atualizar
• TRACKING_MODE: o modo de acompanhamento de ligações a usar para pacotes recebidos; para ver a lista de valores suportados, consulte Modo de acompanhamento
• CONNECTION_PERSISTENCE_BEHAVIOR: o comportamento de persistência da ligação quando os back-ends não estão em bom estado; para ver a lista de valores suportados, consulte Persistência da ligação em back-ends não em bom estado
• IDLE_TIMEOUT_VALUE: o número de segundos durante os quais uma entrada da tabela de acompanhamento de ligações tem de ser mantida depois de o equilibrador de carga processar o último pacote que correspondeu à entrada

Use a afinidade zonal

Pré-visualização

Este produto ou funcionalidade está sujeito aos "Termos das Ofertas de Pré-DG" na secção Termos Gerais de Serviço dos Termos Específicos do Serviço. Os produtos e as funcionalidades pré-GA estão disponíveis "tal como estão" e podem ter apoio técnico limitado. Para mais informações, consulte as descrições das fases de lançamento.

Esta secção mostra como configurar um balanceador de carga de encaminhamento interno para ativar a afinidade zonal no serviço de back-end do balanceador de carga. Por predefinição, a afinidade zonal está desativada. Para mais informações, consulte o artigo Afinidade zonal para balanceadores de carga de rede de encaminhamento interno.

• Use o seguinte comando para configurar a opção de afinidade zonal.ZONAL_AFFINITY_STAY_WITHIN_ZONE Para mais informações sobre o funcionamento desta opção, consulte Como funciona o ZONAL_AFFINITY_STAY_WITHIN_ZONE.

  gcloud beta compute backend-services update be-ilb \
      --zonal-affinity-spillover=ZONAL_AFFINITY_STAY_WITHIN_ZONE \
      --region=us-west1
  

• Use o seguinte comando para configurar a afinidade zonal com a taxa de transbordo 0.0 predefinida.ZONAL_AFFINITY_SPILL_CROSS_ZONE Para mais informações sobre o funcionamento desta opção, consulte as secções Como funcionam ZONAL_AFFINITY_SPILL_CROSS_ZONE a taxa de transbordo e o rácio de transbordo e Rácio de transbordo zero.

  gcloud beta compute backend-services update be-ilb \
      --zonal-affinity-spillover=ZONAL_AFFINITY_SPILL_CROSS_ZONE \
      --region=us-west1
  

• Use o seguinte comando para configurar a ZONAL_AFFINITY_SPILL_CROSS_ZONEafinidade zonal com uma taxa de transbordo de 30%. Para mais informações sobre como esta opção funciona, consulte as secções Como funcionam os ZONAL_AFFINITY_SPILL_CROSS_ZONE e a taxa de transbordo e Taxa de transbordo diferente de zero.

  gcloud beta compute backend-services update be-ilb \
      --zonal-affinity-spillover=ZONAL_AFFINITY_SPILL_CROSS_ZONE \
      --zonal-affinity-spillover-ratio=0.3 \
      --region=us-west1
  

Crie uma regra de encaminhamento noutra sub-rede

Este procedimento cria um segundo endereço IP e uma regra de encaminhamento numa sub-rede diferente para demonstrar que pode criar várias regras de encaminhamento para um balanceador de carga de rede de passagem interno. A região da regra de encaminhamento tem de corresponder à região do serviço de back-end.

Sujeitos às regras de firewall, os clientes em qualquer sub-rede na região podem contactar qualquer endereço IP do Network Load Balancer de encaminhamento interno.

Consola

Adicione a segunda sub-rede

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

   Aceda a redes de VPC

2. Clique em Criar rede de VPC.

3. Clique em lb-network.

4. Na secção Sub-redes, faça o seguinte:

   1. Clique em Adicionar sub-rede.
   2. Na secção Nova sub-rede, introduza as seguintes informações:
      • Nome: second-subnet
      • Região: us-west1
      • Intervalo de endereços IP: 10.5.6.0/24
   3. Clique em Adicionar.

Adicione a segunda regra de encaminhamento

1. Na Google Cloud consola, aceda à página Equilíbrio de carga.

   Aceda a Balanceamento de carga

2. Clique no balanceador de carga be-ilb e clique em Editar.

3. Clique em Configuração do front-end.

4. Clique em Adicionar IP e porta do front-end.

5. Na secção Novo IP e porta de front-end, defina os seguintes campos e clique em Concluído:

   • Nome: fr-ilb-2
   • Versão do IP: IPv4
   • Subnetwork: second-subnet
   • IP interno: ip-ilb
   • Portas: 80 e 443

6. Antes de continuar, verifique se existe uma marca de verificação azul junto a Configuração do frontend.

7. Clique em Rever e finalizar e reveja as definições de configuração do equilibrador de carga.

8. Clique em Criar.

gcloud

1. Crie uma segunda sub-rede na rede lb-network na região us-west1:

    gcloud compute networks subnets create second-subnet \
        --network=lb-network \
        --range=10.5.6.0/24 \
        --region=us-west1
   

2. Crie uma segunda regra de encaminhamento para as portas 80 e 443. Os outros parâmetros desta regra, incluindo o endereço IP e o serviço de back-end, são iguais aos da regra de encaminhamento principal, fr-ilb.

    gcloud compute forwarding-rules create fr-ilb-2 \
        --region=us-west1 \
        --load-balancing-scheme=internal \
        --network=lb-network \
        --subnet=second-subnet \
        --address=10.5.6.99 \
        --ip-protocol=TCP \
        --ports=80,443 \
        --backend-service=be-ilb \
        --backend-service-region=us-west1
   

API

Faça POST pedidos ao método subnetworks.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks

{
 "name": "second-subnet",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "ipCidrRange": "10.5.6.0/24",
 "privateIpGoogleAccess": false
}

Crie a regra de encaminhamento fazendo um pedido POST ao método forwardingRules.insert.

POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/forwardingRules

{
"name": "fr-ilb-2",
"IPAddress": "10.5.6.99",
"IPProtocol": "TCP",
"ports": [
  "80", "443"
],
"loadBalancingScheme": "INTERNAL",
"subnetwork": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/subnetworks/lb-subnet",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"backendService": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb",
"networkTier": "PREMIUM"
}

Teste a nova regra de encaminhamento

Estabeleça ligação à instância de VM do cliente e teste as ligações HTTP e HTTPS aos endereços IP.

1. Estabeleça ligação à VM do cliente:

   gcloud compute ssh vm-client --zone=us-west1-a
   

2. Teste a conetividade HTTP aos endereços IP:

   curl http://10.1.2.99
   curl http://10.5.6.99
   

3. Teste a conetividade HTTPS. A utilização de --insecure é necessária porque a configuração do servidor Apache na configuração de exemplo usa certificados autossinados.

   curl https://10.1.2.99 --insecure
   curl https://10.5.6.99 --insecure
   

4. Tenha em atenção que os pedidos são processados por todas as VMs de back-end, independentemente do protocolo (HTTP ou HTTPS) ou do endereço IP usado.

Use a subdivisão de back-end

A configuração de exemplo cria um serviço de back-end sem subconjuntos.

Este procedimento mostra como ativar a criação de subconjuntos no serviço de back-end para o exemplo de Network Load Balancer de passagem interna, de modo que a implementação possa ser dimensionada para um número maior de instâncias de back-end.

Atenção: a ativação da restrição de subconjuntos de back-end pode ser temporariamente disruptiva e pode interromper as ligações TCP existentes.

Só deve ativar a subdivisão se precisar de suportar mais de 250 VMs de back-end num único balanceador de carga.

Nota: esta funcionalidade não suporta endereços IPv6.

Para mais informações sobre este exemplo de utilização, consulte o subconjunto de back-end.

gcloud

Use o seguinte comando gcloud para atualizar o serviço de back-end be-ilb, especificando a política de subconjuntos:

gcloud compute backend-services update be-ilb \
    --subsetting-policy=CONSISTENT_HASH_SUBSETTING

API

Faça um pedido PATCH ao método regionBackendServices/patch.

PATCH https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/backendServices/be-ilb

{
"subsetting":
  {
    "policy": CONSISTENT_HASH_SUBSETTING
  }
}

Crie um balanceador de carga para o espelhamento de pacotes

O espelhamento de pacotes permite-lhe copiar e recolher dados de pacotes de instâncias específicas numa VPC. Os dados recolhidos podem ajudar a detetar ameaças de segurança e a monitorizar o desempenho das aplicações.

A replicação de pacotes requer um Network Load Balancer de passagem interno para equilibrar o tráfego para um grupo de instâncias de destinos de coletores. Para criar um Network Load Balancer de encaminhamento interno para a replicação de pacotes, siga estes passos.

Consola

Inicie a configuração

1. Na Google Cloud consola, aceda à página Equilíbrio de carga.

   Aceda ao balanceamento de carga

2. Clique em Criar equilibrador de carga.
3. Para Tipo de balanceador de carga, selecione Balanceador de carga de rede (TCP/UDP/SSL) e clique em Seguinte.
4. Para Proxy ou passagem, selecione Passagem do balanceador de carga e clique em Seguinte.
5. Para Público ou interno, selecione Interno e clique em Seguinte.
6. Clique em Configurar.

Configuração básica

1. Em Nome do balanceador de carga, introduza um nome.
2. Para Região, selecione a região das instâncias de VM onde quer espelhar pacotes.
3. Para Rede, selecione a rede onde quer duplicar pacotes.
4. Clique em Configuração de back-end.
5. Na secção Novo back-end, para Grupo de instâncias, selecione o grupo de instâncias para o qual encaminhar pacotes.
6. Na lista Verificação de funcionamento, clique em Criar uma verificação de funcionamento e, de seguida, introduza as seguintes informações:
   • No campo Nome, introduza um nome para a verificação de estado.
   • Na lista Protocolo, selecione HTTP.
   • No campo Porta, introduza 80.
7. Clique em Criar.
8. Clique em Configuração do front-end.
9. Na secção Novo endereço IP e porta de front-end, faça o seguinte:
   1. Em Nome, introduza um nome.
   2. Para Subnetwork, selecione uma sub-rede na mesma região que as instâncias a duplicar.
   3. Para Portas, selecione Todas.
   4. Clique em Configurações avançadas e selecione a caixa de verificação Ativar este equilibrador de carga para a replicação de pacotes.
   5. Clique em Concluído.
10. Clique em Criar.

gcloud

1. Crie uma nova verificação de funcionamento de HTTP regional para testar a conetividade HTTP a um grupo de instâncias na porta 80:

   gcloud compute health-checks create http HEALTH_CHECK_NAME \
       --region=REGION \
       --port=80
   

   Substitua o seguinte:

   • HEALTH_CHECK_NAME: o nome da verificação de funcionamento.
   • REGION: a região das instâncias de VM para as quais quer duplicar pacotes.

2. Crie um serviço de back-end para o tráfego HTTP:

   gcloud compute backend-services create COLLECTOR_BACKEND_SERVICE \
       --region=REGION \
       --health-checks-region=REGION \
       --health-checks=HEALTH_CHECK_NAME \
       --load-balancing-scheme=internal \
       --protocol=tcp
   

   Substitua o seguinte:

   • COLLECTOR_BACKEND_SERVICE: o nome do serviço de back-end.
   • REGION: a região das instâncias de VM onde quer duplicar pacotes.
   • HEALTH_CHECK_NAME: o nome da verificação de funcionamento.

3. Adicione um grupo de instâncias ao serviço de back-end:

   gcloud compute backend-services add-backend COLLECTOR_BACKEND_SERVICE \
       --region=REGION \
       --instance-group=INSTANCE_GROUP \
       --instance-group-zone=ZONE
   

   Substitua o seguinte:

   • COLLECTOR_BACKEND_SERVICE: o nome do serviço de back-end.
   • REGION: a região do grupo de instâncias.
   • INSTANCE_GROUP: o nome do grupo de instâncias.
   • ZONE: a zona do grupo de instâncias.

4. Crie uma regra de encaminhamento para o serviço de back-end:

   gcloud compute forwarding-rules create FORWARDING_RULE_NAME \
       --region=REGION \
       --network=NETWORK \
       --subnet=SUBNET \
       --backend-service=COLLECTOR_BACKEND_SERVICE \
       --load-balancing-scheme=internal \
       --ip-protocol=TCP \
       --ports=all \
       --is-mirroring-collector
   

   Substitua o seguinte:

   • FORWARDING_RULE_NAME: o nome da regra de encaminhamento.
   • REGION: a região da regra de encaminhamento.
   • NETWORK: a rede para a regra de encaminhamento.
   • SUBNET: uma sub-rede na região das VMs onde quer duplicar pacotes.
   • COLLECTOR_BACKEND_SERVICE: o serviço de back-end para este balanceador de carga.

Nota: não pode usar o protocolo L3_DEFAULT na regra de encaminhamento para configurar a replicação de pacotes.

O que se segue?

• Consulte a Vista geral do balanceador de carga de rede de encaminhamento interno para ver os princípios importantes.
• Consulte Conceitos de comutação por falha para equilibradores de carga de rede de passagem interna para ver informações importantes sobre a comutação por falha.
• Consulte o artigo Equilíbrio de carga interno e nomes DNS para ver as opções de nomes DNS disponíveis que o equilibrador de carga pode usar.
• Consulte o artigo Configurar a ativação pós-falha para balanceadores de carga de rede de encaminhamento direto internos para ver os passos de configuração e um exemplo de configuração de ativação pós-falha de um balanceador de carga de rede de encaminhamento direto interno.
• Consulte o artigo Registo e monitorização do balanceador de carga de rede de encaminhamento interno para ver informações sobre a configuração do registo e da monitorização de balanceadores de carga de rede de encaminhamento interno.
• Consulte o artigo Balanceadores de carga de rede de encaminhamento interno e redes ligadas para ver informações sobre o acesso a balanceadores de carga de rede de encaminhamento interno a partir de redes de pares ligadas à sua rede VPC.
• Consulte o artigo Resolva problemas com balanceadores de carga de rede de encaminhamento interno para ver informações sobre como resolver problemas com o seu balanceador de carga de rede de encaminhamento interno.
• Limpe a configuração do balanceador de carga.

Apêndice: introdução ao script Bash IPv6

Esta secção fornece uma breve descrição dos diferentes comandos de rede relacionados com o script de arranque do Bash usado para instalar um servidor TCP IPv6 nas VMs de back-end. Não tem de executar estes passos novamente. Estão apenas descritas aqui para fornecer contexto e ajudar na compreensão.

1. Mostrar todas as rotas IPv6.

   ip -6 route show table all
   

   O resultado é o seguinte:

   fd20:307:120c:2000::/64 via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 62sec pref medium
   fe80::/64 dev ens4 proto kernel metric 256 pref medium
   default via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 62sec mtu 1460 pref medium
   local ::1 dev lo table local proto kernel metric 0 pref medium
   local fd20:307:120c:2000:0:b:: dev ens4 table local proto kernel metric 0 pref medium
   local fe80::56:24ff:feb1:59b3 dev ens4 table local proto kernel metric 0 pref medium
   multicast ff00::/8 dev ens4 table local proto kernel metric 256 pref medium
   

   A partir do resultado do passo anterior, identifique o seguinte:

   • Endereço IPv6 link-local (a começar por fe80::/10): no exemplo de saída, o endereço link-local é fe80::57:2ff:fe36:ffbe. Este endereço local de link é usado na rota predefinida definida na tabela de encaminhamento 1. Este trajeto predefinido é criado no passo 2.
   • Sub-rede /64: esta sub-rede é referenciada na regra de encaminhamento baseada na origem no passo 3

2. Adicione uma rota predefinida personalizada na tabela de encaminhamento 1.

   O comando seguinte envia pacotes para o gateway através da interface de rede denominada ens4.

   sudo ip route add default via GATEWAY_ADDRESS dev ens4 table 1
   

   Depois de executar este comando, é adicionada uma rota predefinida a uma tabela de encaminhamento personalizada (tabela 1), que aponta para o gateway fe80::57:2ff:fe36:ffbe através da interface ens4.

   Se executar novamente o comando ip -6 route show table all, o resultado é o seguinte:

   default via fe80::57:2ff:fe36:ffbe dev ens4 table 1 metric 1024 pref medium
   fd20:307:120c:2000::/64 via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 89sec pref medium
   fe80::/64 dev ens4 proto kernel metric 256 pref medium
   default via fe80::57:2ff:fe36:ffbe dev ens4 proto ra metric 100 expires 89sec mtu 1460 pref medium
   local ::1 dev lo table local proto kernel metric 0 pref medium
   local fd20:307:120c:2000:0:1::/96 dev ens4 table local proto 66 metric 1024 pref medium
   local fd20:307:120c:2000:0:b:: dev ens4 table local proto kernel metric 0 pref medium
   local fe80::56:24ff:feb1:59b3 dev ens4 table local proto kernel metric 0 pref medium
   multicast ff00::/8 dev ens4 table local proto kernel metric 256 pref medium
   

3. Adicione uma regra de encaminhamento de políticas baseada na origem.

   O comando seguinte adiciona uma regra para encaminhar todos os pacotes de saída originários de uma sub-rede especificada. Se o endereço de origem corresponder à sub-rede, o sistema usa o trajeto predefinido definido na tabela 1 para encaminhar o tráfego.

   sudo ip -6 rule add from SUBNET_RANGE table 1
   

4. Para ver a lista de regras de encaminhamento de políticas, execute o seguinte comando.

   ip -6 rule show
   

   O resultado é o seguinte:

   0:      from all lookup local
   32765:  from fd20:307:120c:2000::/64 lookup 1
   32766:  from all lookup main
   

   A linha com from fd20:... lookup 1 é a regra que adicionou, que indica ao kernel para usar a tabela de encaminhamento 1 para o tráfego originário dessa sub-rede.

5. Permita que o servidor se associe a um endereço IPv6 não local, ou seja, o VIP do equilibrador de carga.

   sudo sysctl -w net.ipv6.ip_nonlocal_bind=1