Configurar um balanceador de carga de rede de passagem interna com back-ends de grupos de instâncias de VM

Neste guia, usamos um exemplo para ensinar os conceitos básicos dos balanceadores de carga de rede de passagem interna do Google Cloud. Antes de seguir as instruções deste guia, familiarize-se com os itens abaixo:

Para seguir as instruções detalhadas desta tarefa diretamente no console do Google Cloud, clique em Orientação:

Orientações

Permissões

Para seguir este guia, você precisa criar instâncias e modificar uma rede em um projeto. É necessário ser proprietário ou editor de um projeto ou ter todos os seguintes papéis de IAM do Compute Engine:

Tarefa Papel necessário
Criar componentes do balanceador de carga, sub-redes e redes Administrador de rede
Adicionar e remover regras de firewall Administrador de segurança
Criar instâncias Administrador da instância da computação

Para mais informações, consulte estes guias:

Configurar o balanceador de carga com sub-redes de pilha única

Este guia mostra como configurar e testar um balanceador de carga de rede de passagem interna. Nas etapas desta seção, veja como configurar o seguinte:

  1. Um exemplo que usa uma rede VPC personalizada chamada lb-network.
  2. Uma sub-rede de pilha única (stack-type definido como IPv4), que é necessária para o tráfego IPv4. Ao criar uma sub-rede de pilha única em uma rede VPC de modo personalizado, você escolhe um intervalo de sub-rede IPv4 para a sub-rede.
  3. Regras de firewall que permitem conexões de entrada com VMs de back-end.
  4. O grupo de instâncias de back-end, localizado na seguinte região e sub-rede para este exemplo:
    • Região: us-west1
    • Sub-rede: lb-subnet, com intervalo de endereços IPv4 principal 10.1.2.0/24.
  5. Quatro VMs de back-end: duas VMs em um grupo de instâncias não gerenciadas na zona us-west1-a e duas VMs em um grupo de instâncias não gerenciadas na zona us-west1-c. Para demonstrar o acesso global, este exemplo cria uma segunda VM de cliente de teste em uma região e uma sub-rede diferentes:
    • Região: europe-west1
    • Sub-rede: europe-subnet, com intervalo de endereços IP principal 10.3.4.0/24
  6. Uma VM cliente para testar conexões.
  7. Os componentes do balanceador de carga de rede de passagem interna a seguir:
    • Uma verificação de integridade do serviço de back-end.
    • Um serviço de back-end interno na região us-west1 para gerenciar a distribuição de conexões para os dois grupos de instâncias zonais.
    • Uma regra de encaminhamento interna e um endereço IP interno para o front-end do balanceador de carga.

A arquitetura deste exemplo é a seguinte:

Configuração de exemplo do balanceador de carga de rede de passagem interno.
Configuração de exemplo do balanceador de carga de rede de passagem interno (clique para ampliar).

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

Para criar o exemplo de rede e sub-rede, siga estas etapas.

Console

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

    Acessar redes VPC

  2. Clique em Criar rede VPC.

  3. Em Nome, insira lb-network.

  4. Na seção Sub-rede, faça o seguinte:

    1. Defina o Modo de criação de sub-rede como Personalizado.
    2. Na seção Nova sub-rede, insira as informações a seguir:
      • Name: 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 insira as seguintes informações:
      • Name: 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 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 uma solicitação 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 duas solicitações POST para o método subnetworks.insert.

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
}

Configurar 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, permitindo tráfego de origens nos intervalos 10.1.2.0/24 e 10.3.4.0/24. Essa regra permite o tráfego de entrada de qualquer cliente localizado em uma das duas sub-redes. Posteriormente, é possível configurar e testar o acesso global.

  • fw-allow-ssh: uma regra de entrada, aplicável às instâncias submetidas a balanceamento de carga, que permite a conectividade SSH de entrada na porta TCP 22 proveniente de qualquer endereço. Escolha um intervalo de IP de origem mais restritivo para essa regra. Por exemplo, é possível especificar apenas os intervalos de IP do sistema do qual você iniciará sessões SSH. Neste exemplo, usamos a tag allow-ssh de destino para identificar as VMs a que isso se aplicará.

  • fw-allow-health-check: uma regra de entrada, aplicável às instâncias cuja carga está sendo balanceada, que permite o tráfego dos sistemas de verificação de integridade do Google Cloud (130.211.0.0/22 e 35.191.0.0/16). Este exemplo usa a tag de destino allow-health-check para identificar as instâncias às quais ela será aplicada.

Sem essas regras de firewall, a regra padrão de negação de entrada bloqueará o tráfego que chega para as instâncias de back-end.

Console

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

    Acessar as políticas de firewall

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

    • Name: fw-allow-lb-access
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver correspondência: permitir
    • Destinos: All instances in the network
    • Filtro de origem: intervalos IPv4
    • Intervalos IPv4 de origem: 10.1.2.0/24
    • Protocolos e portas: permitir todos

  3. Clique em Criar.

  4. Para permitir conexões SSH de entrada, clique novamente em Criar regra de firewall e insira as seguintes informações:

    • Name: fw-allow-ssh
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver correspondência: permitir
    • Destinos: tags de destino especificadas
    • Tags de meta: allow-ssh
    • Filtro de origem: intervalos IPv4
    • Intervalos IPv4 de origem: 0.0.0.0/0
    • Protocolos e portas: selecione Protocolos e portas especificados, marque a caixa de seleção TCP e insira 22 em Ports (Portas).

  5. Clique em Criar.

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

    • Name: fw-allow-health-check
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver correspondência: permitir
    • Destinos: tags de destino especificadas
    • Tags de meta: allow-health-check
    • Filtro de origem: intervalos IPv4
    • Intervalos IPv4 de origem: 130.211.0.0/22 e 35.191.0.0/16
    • Protocolos e portas: permitir todos

  7. Clique em Criar.

gcloud

  1. Crie a regra de firewall fw-allow-lb-access para permitir a comunicação pela 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 que permita a conectividade SSH para VMs com a tag de rede allow-ssh. Se você omitir source-ranges, o Google Cloud interpretará que a regra autoriza a conexão proveniente de qualquer origem.

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

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

    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 uma solicitação 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 uma solicitação 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 uma solicitação 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
}

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

Neste exemplo, usamos dois grupos de instâncias não gerenciadas, cada um com duas VMs de back-end (servidor). Para demonstrar a natureza regional de balanceadores de carga de rede de passagem 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 as quatro VMs de back-end é submetido a balanceamento de carga.

Para ser compatível com este exemplo e as outras opções de configuração, cada uma das quatro VMs executa um servidor da Web Apache que detecta as portas TCP a seguir: 80, 8008, 8080, 8088, 443 e 8443.

Cada VM recebe um endereço IP interno no lb-subnet e um endereço IP externo (público) temporário. É possível remover os endereços IP externos posteriormente.

O endereço IP externo das VMs de back-end não é obrigatório. No entanto, elas são úteis neste exemplo porque permitem que as VMs de back-end façam o download do Apache via Internet e possam se conectar por SSH.

Por padrão, o Apache é configurado para ser vinculado a qualquer endereço IP. Os balanceadores de carga de rede de passagem interna entregam pacotes preservando o IP de destino. Verifique se o software servidor executado nas suas VMs de back-end está escutando no endereço IP da regra de firewall interna do balanceador de carga. Se você configurar várias regras de encaminhamento internas, verifique se o software escuta o endereço IP interno associado a cada uma delas. O endereço IP interno da regra de encaminhamento é o endereço IP de destino de um pacote entregue a uma VM de back-end por um balanceador de carga de rede de passagem interno.

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

Console

Criar VMs de back-end

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

    Acessar instâncias de VM

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

    • Nome: 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 como indicado na etapa 2.

  5. Em Região, selecione us-west1 e escolha uma Zona, como indicado na etapa 2.

  6. Na seção Disco de inicialização, verifique se Debian GNU/Linux 12 (bookworm) está selecionado para as opções de disco de inicialização. 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. Em Tags de rede, insira allow-ssh e allow-health-check.
    2. Em Interfaces de rede, selecione o seguinte:
      • Rede: lb-network
      • Sub-rede: lb-subnet
      • Tipo de pilha de IP: IPv4 (pilha única)
      • Endereço IPv4 interno principal: temporário (automático)
      • Endereço IPv4 externo: temporário

  9. Clique em Gerenciamento e, no campo Script de inicialização, insira o script a seguir. O conteúdo do script é o mesmo para 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.

Criar grupos de instâncias

  1. No Console do Google Cloud, acesse a página Grupos de instâncias.

    Acesse grupo de instâncias

  2. Repita as etapas a seguir para criar dois grupos de instâncias não gerenciadas com duas VMs cada. Use 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 gerenciadas.

  5. Defina o Nome como indicado na etapa 2.

  6. Na seção Local, selecione us-west1 para Região e escolha uma Zona como indicado na etapa 2.

  7. Em Rede, selecione lb-network.

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

  9. Na seção Instâncias de VMs, adicione as VMs como indicado na etapa 2.

  10. Clique em Criar.

gcloud

  1. Execute o seguinte comando quatro vezes para criar as quatro VMs, usando estas quatro combinações para [VM-NAME] e [ZONE]. O conteúdo do script é o mesmo para 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 gerenciadas 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 apropriados:

    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 VM:

  • 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

Para ver o DEBIAN_IMAGE_NAME atual, execute o comando gcloud a seguir:

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

Crie quatro VMs de back-end fazendo quatro solicitações 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 uma solicitação 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 uma solicitação POST para o 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"
   }
 ]
}

Configurar componentes do balanceador de carga

Estas etapas configuram todos os componentes do balanceador de carga de rede de passagem interno, começando com verificação de integridade e serviço de back-end e, em seguida, componentes de front-end:

  • Verificação de integridade: neste exemplo, você usa uma verificação de integridade HTTP que apenas verifica se há uma resposta HTTP 200 (OK). Para mais informações, consulte a seção sobre verificações de integridade da visão geral do balanceador de carga de rede interno de passagem.

  • Serviço de back-end: devido à necessidade de passar tráfego HTTP através do balanceador de carga interno, você precisa usar TCP em vez de UDP.

  • Regra de encaminhamento: neste exemplo, criamos uma regra de encaminhamento interna.

  • Endereço IP interno: neste exemplo, você especifica um endereço IP interno, 10.1.2.99, ao criar a regra de encaminhamento.

Console

Iniciar a configuração

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

    Acessar o "Balanceamento de carga"

  2. Clique em Criar balanceador de carga.
  3. Em Tipo de balanceador de carga, selecione Balanceador de carga de rede (TCP/UDP/SSL) e clique em Próxima.
  4. Em Proxy ou passagem, selecione Balanceador de carga de passagem e clique em Próxima.
  5. Em Voltado ao público ou interno, selecione Interno e clique em Próxima.
  6. Clique em Configurar.

Configuração básica

Na página Criar balanceador de carga de rede de passagem interna, digite as seguintes informações:

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

Configurar os back-ends

  1. Clique em Configuração de back-end.
  2. Para processar apenas o tráfego IPv4, na seção Novo back-end de Back-ends, selecione o Tipo de pilha de IP como IPv4 (pilha única). .
  3. Em Grupo de instâncias, selecione o grupo de instâncias ig-c e clique em Concluído.
  4. Clique em Adicionar um back-end e repita esta etapa para adicionar ig-a.

  5. Na lista Verificação de integridade, selecione Criar verificação de integridade, insira as informações a seguir e clique em Salvar.

    • Nome: hc-http-80
    • Protocolo: HTTP
    • Porta: 80
    • Protocolo de proxy: NONE
    • Caminho da solicitação; /

    Quando você usa o console do Google Cloud para criar o balanceador de carga, a verificação de integridade é global. Se você quiser criar uma verificação de integridade regional, use gcloud ou a API.

  6. Verifique se há uma marca de seleção azul ao lado de Configuração do back-end antes de continuar.

Configurar o front-end

  1. Clique em Configuração de front-end.
  2. Na seção Novo IP e nova porta de front-end, faça o seguinte:
    1. Em Nome, insira fr-ilb.
    2. Em Sub-rede, selecione lb-subnet.
    3. Na seção Finalidade do IP interno, na lista Endereço IP, selecione Criar endereço IP, insira as informações a seguir e clique em Reservado.
      • Nome: ip-ilb
      • Versão do IP: IPv4
      • Endereço IP estático: Quero escolher
      • Endereço IP personalizado: 10.1.2.99
    4. Em Portas, selecione Várias e, em Números de portas, digite 80, 8008, 8080 e 8088.
    5. Verifique se há uma marca de seleção azul ao lado de Configuração do front-end antes de continuar.

Analise a configuração

  1. Clique em Analisar e finalizar.
  2. Revise suas configurações do balanceador de carga.
  3. Opcional: clique em Código equivalente para conferir a solicitação de API REST que será usada para criar o balanceador de carga.
  4. Clique em Criar.

gcloud

  1. Crie uma nova verificação de integridade HTTP regional para testar a conectividade HTTP com as 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 do 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 do serviço de back-end. Ao 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 integridade fazendo uma solicitação 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 um serviço de back-end regional fazendo uma solicitação POST ao método regionBackendServices.insert.

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 firewall fazendo uma solicitação 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"
}

Testar o balanceador de carga

Nos testes a seguir, veja como validar a configuração do balanceador de carga e conheça o comportamento esperado dele.

Criar uma VM cliente

Neste exemplo, criamos uma VM cliente (vm-client) na mesma região das VMs de back-end (servidor). O cliente é usado para validar a configuração do balanceador de carga e demonstrar o comportamento esperado, conforme descrito na seção de teste.

Console

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

    Acessar instâncias de VM

  2. Clique em Criar instância.

  3. Em Nome, insira vm-client.

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

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

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

  7. Clique em Rede e configure os seguintes campos:

    1. Em Tags de rede, insira allow-ssh.
    2. Em Interfaces de rede, selecione o seguinte:
      • Rede: lb-network
      • Sub-rede: lb-subnet

  8. Clique em Criar.

gcloud

A VM cliente pode estar em qualquer zona na mesma região que o balanceador de carga, podendo usar qualquer sub-rede nessa região. Neste exemplo, o cliente está na zona us-west1-a e usa a mesma sub-rede das 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 uma solicitação 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
}

Testar a conexão da VM cliente

Neste teste, o balanceador de carga é contatado por uma VM cliente separada, e não por 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 nenhuma afinidade de sessão foi configurada.

  1. Conecte-se à instância da VM cliente.

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

  2. Faça uma solicitação da Web para o balanceador de carga usando curl para contatar o endereço IP dele. Repita a solicitação para ver que as respostas provêm de diferentes VMs de back-end. O nome da VM que gera a resposta é exibido 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 são assim: Page served from: vm-a1 e Page served from: vm-a2.

    curl http://10.1.2.99

    A regra de encaminhamento está configurada para exibir 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, desta maneira:

    curl http://10.1.2.99:8008

    Se você adicionar um rótulo de serviço à regra de encaminhamento interno, poderá usar DNS interno para contatar o balanceador de carga usando o nome de serviço.

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

Dê um ping no endereço IP do balanceador de carga

Neste teste, demonstramos um comportamento esperado: não é possível dar um ping no endereço IP do balanceador de carga. Isso ocorre porque os balanceadores de carga de rede de passagem interna são implementados na programação de rede virtual, eles não são dispositivos separados.

  1. Conecte-se à instância da VM cliente.

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

  2. Tente fazer o ping do endereço IP do balanceador de carga. Você não receberá uma resposta e que o comando ping expira após 10 segundos neste exemplo.

    timeout 10 ping 10.1.2.99

Enviar solicitações de VMs com balanceamento de carga

Esse teste demonstra que, quando uma VM de back-end envia pacotes para o endereço IP da regra de encaminhamento do balanceador de carga, essas solicitações são roteadas de volta para ela. Esse é o caso independente do estado de verificação de integridade da VM de back-end.

Os balanceadores de carga de rede de passagem interna são implementados usando programação de rede virtual e configuração de VM no SO convidado. Nas VMs do Linux, o Ambiente do convidado cria uma rota para o endereço IP do balanceador de carga na tabela de roteamento local do sistema operacional.

Como essa rota local está dentro da própria VM (não uma rota na rede VPC), os pacotes enviados ao endereço IP do balanceador de carga não são processados pela rede VPC. Em vez disso, os pacotes enviados ao endereço IP do balanceador de carga permanecem no sistema operacional da VM.

  1. Conecte-se a uma VM de back-end, como vm-a1:

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

  2. Faça uma solicitação da Web para o balanceador de carga (por endereço IP ou nome de serviço) usando curl. A resposta vem da mesma VM de back-end que faz a solicitação. Solicitações repetidas são respondidas da mesma forma. A resposta esperada quando se faz o teste a partir de vm-a1 é sempre Page served from: vm-a1.

    curl http://10.1.2.99

  3. Inspecione a tabela de roteamento local, procurando um destino que corresponda ao endereço IP do próprio balanceador de carga, 10.1.2.99. Essa rota é uma parte necessária do balanceador de carga de rede de passagem interno, mas também demonstra porque uma solicitação de uma VM por trás do balanceador de carga sempre é respondida pela mesma VM.

    ip route show table local | grep 10.1.2.99

Quando uma VM de back-end de um balanceador de carga de rede de passagem interno envia pacotes para o endereço IP da regra de encaminhamento do balanceador, os pacotes são sempre encaminhados de volta para a VM que faz a solicitação. Isso acontece porque um balanceador de carga de rede e passagem interno é um balanceador de carga de passagem e é implementado criando uma rota local para o endereço IP do balanceador de carga no SO convidado da VM, conforme indicado nesta seção. Se você tiver um caso de uso em que os back-ends com balanceamento de carga precisem enviar tráfego TCP ao endereço IP do balanceador de carga e você precisar que o tráfego seja distribuído como se tivesse origem em um back-end equilibrado, considere usar um balanceador de carga de proxy de rede regional interno.

Para mais informações, consulte Passbacks de carga de rede de passagem interna como próximos saltos.

Configurar o balanceador de carga com sub-redes de pilha dupla

Este guia mostra como configurar e testar um balanceador de carga de rede de passagem interna. Nas etapas desta seção, veja como configurar o seguinte:

  1. O exemplo nesta página usa uma rede VPC de modo personalizado chamada lb-network-dual-stack. No entanto, o tráfego IPv6 requer uma sub-rede de modo personalizado.
  2. Uma sub-rede de pilha dupla (stack-type definida como IPv4_IPv6), que é necessária para o tráfego IPv6. Ao criar uma sub-rede de pilha dupla em uma rede VPC de modo personalizado, você escolhe um tipo de acesso IPv6 para a sub-rede. Neste exemplo, definimos o parâmetro ipv6-access-type da sub-rede como INTERNAL. Isso significa que novas VMs nessa sub-rede poderão receber endereços IPv4 internos e endereços IPv6 internos. Para instruções, consulte a documentação da VPC sobre Como adicionar uma sub-rede de pilha dupla.
  3. Regras de firewall que permitem conexões de entrada com VMs de back-end.
  4. O grupo de instâncias de back-end, localizado na seguinte região e sub-rede para este exemplo:
    • Região: us-west1
    • Sub-rede: lb-subnet, com intervalo de endereços IPv4 principal 10.1.2.0/24. Embora você possa escolher qual intervalo de endereços IPv4 configurar na sub-rede, o intervalo de endereços IPv6 é atribuído automaticamente. O Google fornece um bloco CIDR IPv6 de tamanho fixo (/64).
  5. Quatro VMs de pilha dupla de back-end: duas VMs em um grupo de instâncias não gerenciadas na zona us-west1-a e duas VMs em um grupo de instâncias não gerenciadas na zona us-west1-c (em inglês). Para demonstrar o acesso global, este exemplo cria uma segunda VM de cliente de teste em uma região e uma sub-rede diferentes:
    • Região: europe-west1
    • Sub-rede: europe-subnet, com intervalo de endereços IP principal 10.3.4.0/24
  6. Uma VM cliente para testar conexões.
  7. Os componentes do balanceador de carga de rede de passagem interna a seguir:
    • Uma verificação de integridade do serviço de back-end.
    • Um serviço de back-end interno na região us-west1 para gerenciar a distribuição de conexões para os dois grupos de instâncias zonais.
    • Duas regras de encaminhamento interno para o front-end do balanceador de carga.

O diagrama a seguir mostra a arquitetura deste exemplo:

Uma rede VPC de pilha dupla com um serviço de back-end para gerenciar a distribuição de conexões para dois grupos de instâncias zonais.
Configuração de exemplo do balanceador de carga de rede de passagem interno (clique para ampliar).

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

O exemplo de balanceador de carga de rede de passagem interna descrito nesta página é criado em uma rede VPC de modo personalizado chamada lb-network-dual-stack.

Para configurar sub-redes com intervalos de IPv6 internos, ative um intervalo de IPv6 interno de ULA da rede VPC. Os intervalos de sub-redes IPv6 internos são alocados desse intervalo.

Console

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

    Acessar redes VPC

  2. Clique em Criar rede VPC.

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

  4. Se você quiser configurar intervalos de endereços de IPv6 internos em sub-redes nesta rede, siga estas etapas:

    1. Em Intervalo de IPv6 interno de ULA da rede VPC, selecione Ativado.
    2. Em Alocar intervalo de IPv6 interno, selecione Automático ou Manualmente.

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

  6. Na seção Nova sub-rede, especifique os parâmetros de configuração a seguir para uma sub-rede:

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

  7. Clique em Concluído.

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

    • Name: 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 personalizada, execute o comando gcloud compute networks create.

    Para configurar intervalos IPv6 internos em qualquer sub-rede nessa rede, use a sinalização --enable-ula-internal-ipv6. Essa opção atribui um prefixo ULA de /48 do intervalo fd20::/20 usado pelo Google Cloud para intervalos de sub-rede IPv6 internos. Se você quiser selecionar o intervalo de IPv6 /48 atribuído, use a sinalização --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 pelo Google para intervalos de sub-rede IPv6 internos. Se você não usar a sinalização --internal-ipv6-range, o Google selecionará 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 qualquer sub-rede nessa rede, defina enableUlaInternalIpv6 como verdadeiro. Esta opção atribui um intervalo /48 dentro do intervalo fd20::/20 usado pelo Google para intervalos de sub-rede IPv6 internos. Se você quiser selecionar qual intervalo de IPv6 /48 será 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:

  • PROJECT_ID: o ID do projeto em que a rede VPC foi criada.
  • MTU: a unidade de transmissão máxima da rede. A MTU pode ser 1460 (padrão) ou 1500. Analise a visão geral da unidade de transmissão máxima antes de definir a MTU como 1500.
  • ULA_IPV6_RANGE: um prefixo /48 de dentro do intervalo fd20::/20 usado pelo Google para intervalos de sub-rede IPv6 interno. Se você não fornecer um valor para internalIpv6Range, o Google selecionará um prefixo /48 para a rede.

  • DYNAMIC_ROUTING_MODE: global ou regional para controlar o comportamento da divulgação de rota dos Cloud Routers na rede. Para mais informações, consulte o modo de roteamento dinâmico.

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

Faça duas solicitações POST para o método subnetworks.insert.

 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
 }

Configurar 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, permitindo tráfego de origens nos intervalos 10.1.2.0/24 e 10.3.4.0/24. Essa regra permite o tráfego de entrada de qualquer cliente localizado em uma das duas sub-redes. Depois, é possível 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. Essa regra permite o tráfego de entrada IPv6 de qualquer cliente localizado em uma das duas sub-redes. Depois, é possível configurar e testar o acesso global.

  • fw-allow-ssh: uma regra de entrada, aplicável às instâncias submetidas a balanceamento de carga, que permite a conectividade SSH de entrada na porta TCP 22 proveniente de qualquer endereço. Escolha um intervalo de IP de origem mais restritivo para esta regra. Por exemplo, é possível especificar apenas os intervalos de IP do sistema do qual você inicia sessões SSH. Neste exemplo, usamos a tag allow-ssh de destino para identificar as VMs a que isso se aplicará.

  • fw-allow-health-check: uma regra de entrada, aplicável às instâncias cuja carga está sendo balanceada, que permite o tráfego dos sistemas de verificação de integridade do Google Cloud (130.211.0.0/22 e 35.191.0.0/16). Este exemplo usa a tag de destino allow-health-check para identificar as instâncias às quais ela será aplicada.

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

Sem essas regras de firewall, a regra padrão de negação de entrada bloqueará o tráfego que chega para as instâncias de back-end.

Console

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

    Acessar as políticas de firewall

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

    • Name: fw-allow-lb-access
    • Rede: lb-network-dual-stack
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver correspondência: permitir
    • Destinos: All instances in the network
    • Filtro de origem: intervalos IPv4
    • Intervalos IPv4 de origem: 10.1.2.0/24 e 10.3.4.0/24
    • Protocolos e portas: permitir todos

  3. Clique em Criar.

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

    • Name: fw-allow-lb-access-ipv6
    • Rede: lb-network-dual-stack
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver correspondência: permitir
    • Destinos: All instances in the network
    • Filtro de origem: intervalos IPv6
    • Intervalos IPv6 de origem: IPV6_ADDRESS atribuídos no lb-subnet
    • Protocolos e portas: permitir todos

  5. Clique em Criar.

  6. Para permitir conexões SSH de entrada, clique novamente em Criar regra de firewall e insira as seguintes informações:

    • Name: fw-allow-ssh
    • Rede: lb-network-dual-stack
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver correspondência: permitir
    • Destinos: tags de destino especificadas
    • Tags de meta: allow-ssh
    • Filtro de origem: intervalos IPv4
    • Intervalos IPv4 de origem: 0.0.0.0/0
    • Protocolos e portas: selecione Protocolos e portas especificados, marque a caixa de seleção TCP e insira 22 em Ports (Portas).

  7. Clique em Criar.

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

    • Name: fw-allow-health-check-ipv6
    • Rede: lb-network-dual-stack
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver correspondência: permitir
    • Destinos: tags de destino especificadas
    • Tags de meta: allow-health-check-ipv6
    • Filtro de origem: intervalos IPv6
    • Intervalos IPv6 de origem: 2600:2d00:1:b029::/64
    • Protocolos e portas: permitir todos

  9. Clique em Criar.

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

    • Name: fw-allow-health-check
    • Rede: lb-network-dual-stack
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver correspondência: permitir
    • Destinos: tags de destino especificadas
    • Tags de meta: allow-health-check
    • Filtro de origem: intervalos IPv4
    • Intervalos IPv4 de origem: 130.211.0.0/22 e 35.191.0.0/16
    • Protocolos e portas: permitir todos

  11. Clique em Criar.

gcloud

  1. Crie a regra de firewall fw-allow-lb-access para permitir a comunicação a partir da 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 a partir da 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 que permita a conectividade SSH para VMs com a tag de rede allow-ssh. Se você omitir source-ranges, o Google Cloud interpretará que a regra autoriza a conexão proveniente de qualquer origem.

    gcloud compute firewall-rules create fw-allow-ssh \
    --network=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 verificações de integridade do Google Cloud.

    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 verificações de integridade do Google Cloud.

    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 uma solicitação 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 uma solicitação 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 uma solicitação 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 uma solicitação 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 uma solicitação 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
}

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

Neste exemplo, usamos dois grupos de instâncias não gerenciadas, cada um com duas VMs de back-end (servidor). Para demonstrar a natureza regional de balanceadores de carga de rede de passagem 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 as quatro VMs de back-end é submetido a balanceamento de carga.

Para ser compatível com este exemplo e as outras opções de configuração, cada uma das quatro VMs executa um servidor da Web Apache que detecta as portas TCP a seguir: 80, 8008, 8080, 8088, 443 e 8443.

Cada VM recebe um endereço IP interno no lb-subnet e um endereço IP externo (público) temporário. É possível remover os endereços IP externos posteriormente.

O endereço IP externo das VMs de back-end não é obrigatório. No entanto, elas são úteis neste exemplo porque permitem que as VMs de back-end façam o download do Apache via Internet e possam se conectar por SSH.

Por padrão, o Apache é configurado para ser vinculado a qualquer endereço IP. Os balanceadores de carga de rede de passagem interna entregam pacotes preservando o IP de destino.

Verifique se o software servidor executado nas suas VMs de back-end está escutando no endereço IP da regra de firewall interna do balanceador de carga. Se você configurar várias regras de encaminhamento internas, verifique se o software escuta o endereço IP interno associado a cada uma delas. O endereço IP interno da regra de encaminhamento é o endereço IP de destino de um pacote entregue a uma VM de back-end por um balanceador de carga de rede de passagem interno.

Verifique se o tipo de pilha de sub-rede corresponde ao tipo de pilha de modelos de instância usados pelos grupos de instâncias gerenciadas. A sub-rede precisará ser de pilha dupla se o grupo de instâncias gerenciadas estiver usando um modelo de instância de pilha dupla.

Para simplificar a instrução, essas VMs de back-end executam o Debian GNU/Linux 10.

Console

Criar VMs de back-end

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

    Acessar instâncias de VM

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

    • Nome: 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 como indicado na etapa 2.

  5. Em Região, selecione us-west1 e escolha uma Zona, como indicado na etapa 2.

  6. Na seção Disco de inicialização, verifique se Debian GNU/Linux 12 (bookworm) está selecionado para as opções de disco de inicialização. 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. Em Tags de rede, insira allow-ssh e allow-health-check-ipv6.
    2. Em Interfaces de rede, selecione o seguinte:
      • Rede: lb-network-dual-stack
      • Sub-rede: lb-subnet
      • Tipo de pilha de IP: IPv4 e IPv6 (pilha dupla)
      • Endereço IPv4 interno principal: temporário (automático)
      • Endereço IPv4 externo: temporário

    3. Clique em Gerenciamento e, no campo Script de inicialização, insira o script a seguir. O conteúdo do script é o mesmo para 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.

Criar grupos de instâncias

  1. No Console do Google Cloud, acesse a página Grupos de instâncias.

    Acesse grupo de instâncias

  2. Repita as etapas a seguir para criar dois grupos de instâncias não gerenciadas com duas VMs cada. Use 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 gerenciadas.

  5. Defina o Nome como indicado na etapa 2.

  6. Na seção Local, escolha us-west1 como Região e escolha uma Zona, conforme indicado na etapa 2.

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

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

  9. Na seção Instâncias de VMs, adicione as VMs como indicado na etapa 2.

  10. Clique em Criar.

gcloud

  1. Para criar as quatro VMs, execute o comando gcloud compute instances create quatro vezes, usando essas quatro combinações para [VM-NAME] e [ZONE]. O conteúdo do script é o mesmo para 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 gerenciadas 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 apropriados:

    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 VM:

  • 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

Para ver o DEBIAN_IMAGE_NAME atual, execute o comando gcloud a seguir:

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

Crie quatro VMs de back-end fazendo quatro solicitações 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 uma solicitação 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 uma solicitação POST para o 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"
   }
 ]
}

Configurar componentes do balanceador de carga

Estas etapas configuram todos os componentes do balanceador de carga de rede de passagem interno, começando com verificação de integridade e serviço de back-end e, em seguida, componentes de front-end:

  • Verificação de integridade: neste exemplo, você usa uma verificação de integridade HTTP que apenas verifica se há uma resposta HTTP 200 (OK). Para mais informações, consulte a seção sobre verificações de integridade da visão geral do balanceador de carga de rede de passagem interna.

  • Serviço de back-end: devido à necessidade de passar tráfego HTTP através do balanceador de carga interno, você precisa usar TCP em vez de UDP.

  • Regra de encaminhamento: neste exemplo, criamos duas regras de encaminhamento interno para o tráfego IPv4 e IPv6.

  • Endereço IP interno: neste exemplo, você especifica um endereço IP interno, 10.1.2.99, ao criar a regra de encaminhamento IPv4. Para mais informações, consulte Endereço IP interno. Embora você escolha qual endereço IPv4 está configurado, o endereço IPv6 é atribuído automaticamente.

Console

Iniciar a configuração

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

    Acessar o "Balanceamento de carga"

  2. Clique em Criar balanceador de carga.
  3. Em Tipo de balanceador de carga, selecione Balanceador de carga de rede (TCP/UDP/SSL) e clique em Próxima.
  4. Em Proxy ou passagem, selecione Balanceador de carga de passagem e clique em Próxima.
  5. Em Voltado ao público ou interno, selecione Interno e clique em Próxima.
  6. Clique em Configurar.

Configuração básica

Na página Criar balanceador de carga de rede de passagem interna, digite as seguintes informações:

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

Configuração de back-end

  1. Clique em Configuração de back-end.
  2. Na seção Novo back-end de Back-ends, selecione o Tipo de pilha de IP como IPv4 e IPv6 (pilha dupla).
  3. Em Grupo de instâncias, selecione o grupo de instâncias ig-a e clique em Concluído.
  4. Clique em Adicionar um back-end e repita esta etapa para adicionar ig-c.
  5. Na lista Verificação de integridade, selecione Criar verificação de integridade, insira as informações a seguir e clique em Salvar:
    • Nome: hc-http-80.
    • Escopo: regional.
    • Protocolo: HTTP.
    • Porta: 80.
    • Protocolo de proxy: NONE.
    • Caminho da solicitação: /.
  6. Verifique se uma marca de seleção azul aparece ao lado de Configuração de back-end.

Configuração de front-end

  1. Clique em Configuração de front-end. Na seção Novo IP e nova porta de front-end, faça o seguinte:
    1. Em Nome, insira fr-ilb-ipv6.
    2. Para gerenciar o tráfego IPv6, faça o seguinte:
      1. Em Versão IP, selecione IPv6.
      2. Em Sub-rede, selecione lb-subnet. O intervalo de endereços IPv6 na regra de encaminhamento é sempre temporário.
      3. Em Portas, selecione Várias e, no campo Número da porta, digite 80, 8008, 8080 e 8088.
      4. Clique em Concluído.
    3. Para gerenciar o tráfego IPv4, faça o seguinte:
      1. Clique em Adicionar IP e porta de front-end.
      2. Em Nome, insira fr-ilb.
      3. Em Sub-rede, selecione lb-subnet.
      4. Na seção Finalidade do IP interno, na lista Endereço IP, selecione Criar endereço IP, insira as informações a seguir e clique em Reservado.
        • Nome: ip-ilb
        • Versão do IP: IPv4
        • Endereço IP estático: Quero escolher
        • Endereço IP personalizado: 10.1.2.99
      5. Em Portas, selecione Várias e, em Números de portas, digite 80, 8008, 8080 e 8088.
      6. Clique em Concluído.
      7. Verifique se há uma marca de seleção azul ao lado de Configuração do front-end antes de continuar.

Analise a configuração

  1. Clique em Analisar e finalizar. Verifique todas as suas configurações.
  2. Se as configurações estiverem corretas, clique em Criar. Leva alguns minutos para que o balanceador de carga de rede de passagem interna seja criado.

gcloud

  1. Crie uma nova verificação de integridade HTTP regional para testar a conectividade HTTP com as 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 do 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. Ao criar a regra de encaminhamento IPv4, especifique 10.1.2.99 para o endereço IP interno na sub-rede de 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 integridade fazendo uma solicitação 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 um serviço de back-end regional fazendo uma solicitação POST ao método regionBackendServices.insert.

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 firewall fazendo uma solicitação 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 firewall fazendo uma solicitação 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"
}

Testar o balanceador de carga

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

Criar uma VM cliente

Neste exemplo, criamos uma VM cliente (vm-client) na mesma região das VMs de back-end (servidor). O cliente é usado para validar a configuração do balanceador de carga e demonstrar o comportamento esperado, conforme descrito na seção de teste.

Console

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

    Acessar instâncias de VM

  2. Clique em Criar instância.

  3. Em Nome, insira vm-client.

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

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

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

  7. Clique em Rede e configure os seguintes campos:

    1. Em Tags de rede, insira allow-ssh.
    2. Em Interfaces de rede, selecione o seguinte:
      • Rede: lb-network-dual-stack
      • Sub-rede: lb-subnet
      • Tipo de pilha de IP: IPv4 e IPv6 (pilha dupla)
      • IP interno primário: temporário (automático)
      • IP externo: temporário
    3. Clique em Concluído.

  8. Clique em Criar.

gcloud

A VM cliente pode estar em qualquer zona na mesma região que o balanceador de carga, podendo usar qualquer sub-rede nessa região. Neste exemplo, o cliente está na zona us-west1-a e usa a mesma sub-rede das 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 uma solicitação 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
}

Testar a conexão

Neste teste, o balanceador de carga é contatado por uma VM cliente separada, e não por 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. Conecte-se à instância da VM cliente.

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

  2. Descreva a regra de encaminhamento IPv6 fr-ilb-ipv6. Observe 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 conectividade 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 terá esta aparência:

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

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

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

    Substitua os marcadores por valores válidos:

    • IPV6_ADDRESS é o endereço IPv6 temporário na regra de encaminhamento fr-ilb-ipv6.

Outras opções de configuração

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

Ativar o acesso global

Ative o acesso global do balanceador de carga de rede de passagem interno de exemplo para torná-lo acessível aos clientes de todas as regiões. Os back-ends do balanceador de carga de exemplo ainda precisam estar localizados em uma única região (us-west1).

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

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

Console

Editar a regra de encaminhamento do balanceador de carga

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

    Acessar o "Balanceamento de carga"

  2. Na coluna Nome, clique no seu balanceador de carga de rede de passagem interna. O balanceador de carga de exemplo é chamado de be-ilb.

  3. Clique em Configuração de 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 diz Regional (REGION) com acesso global.

gcloud

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

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

  2. Use o comando forwarding-rules describe para determinar se uma regra de encaminhamento tem acesso global ativado. Exemplo:

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

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

API

Faça uma solicitação PATCH ao método forwardingRules/patch.

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

{
"allowGlobalAccess": true
}

Criar um cliente de VM para testar o acesso global

Console

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

    Acessar 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. Em Tags de rede, insira allow-ssh.
    2. Em Interfaces de rede, selecione o seguinte:
      • Rede: lb-network
      • Sub-rede: europe-subnet

  8. Clique em Criar.

gcloud

A VM cliente pode estar em qualquer zona na mesma região que o balanceador de carga, podendo usar qualquer sub-rede nessa região. Neste exemplo, o cliente está na zona europe-west1-b e usa a mesma sub-rede das 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 uma solicitação 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
}

Conectar-se ao cliente da VM e testar a conectividade

Para testar a conectividade, execute o seguinte comando:

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

Teste a conexão com o balanceador de carga em todas as portas configuradas, como você fez no vm-client na região us-west1. Teste a conectividade 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

Configurar grupos gerenciados de instâncias

Com a configuração de exemplo, foram criados dois grupos de instâncias não gerenciadas. Porém, é possível usar grupos gerenciados de instâncias, incluindo grupos gerenciados de instâncias zonais e regionais, como back-ends para balanceadores de carga de rede de passagem internos.

Os grupos de instâncias gerenciadas exigem que você crie um modelo de instância. Neste procedimento, demonstramos como substituir os dois grupos não gerenciados de instâncias zonais do exemplo por um único grupo gerenciado de instâncias regionais. Um grupo de instâncias gerenciadas regionais cria automaticamente VMs em várias zonas da região, simplificando a distribuição do tráfego de produção entre as zonas.

Os grupos de instâncias gerenciadas também são compatíveis com autoescalonamento e recuperação automática. Se você usar o escalonamento automático com balanceadores de carga de rede de passagem interna, não será possível escalonar com base no balanceamento de carga.

Neste procedimento, mostramos como modificar o serviço de back-end do balanceador de carga de rede de passagem interno de exemplo para que ele use um grupo de instâncias gerenciadas regionais.

Console

Modelo de instância

  1. No Console do Google Cloud, acesse a página Modelos de instância de VM.

    Acessar os modelos de instância 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 seção Disco de inicialização, verifique se Debian GNU/Linux 12 (bookworm) está selecionado para as opções de disco de inicialização. 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. Em Tags de rede, insira allow-ssh e allow-health-check.
    2. Em Interfaces de rede, selecione o seguinte:
      • Rede: lb-network
      • Sub-rede: lb-subnet

  8. Clique em Gerenciamento e, no campo Script de inicialização, insira o script a seguir:

    #! /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 gerenciadas

  1. No Console do Google Cloud, acesse a página Grupos de instâncias.

    Acesse grupo de instâncias

  2. Clique em Criar grupo de instâncias.

  3. Defina o Nome como ig-ilb.

  4. Em Local, 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 escalonamento automático. Não é possível fazer escalonamento automático no grupo de instâncias com base no uso do balanceamento de carga HTTP porque o grupo de instâncias é um back-end do 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 recuperação automática. Se você configurar a recuperação automática, use a mesma verificação de integridade usada pelo serviço de back-end para o balanceador de carga de rede de passagem interno. Neste exemplo, use hc-http-80.

  9. Clique em Criar.

gcloud

  1. Crie o modelo da instância. Opcionalmente, defina outros parâmetros, como tipo de máquina, para o modelo de imagem a 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ânciasgerenciadas regionais usando 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 gerenciadas regionais como back-end para o serviço de back-end que você já criou:

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

  4. Desconecte os dois grupos de instâncias não gerenciadas (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

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

Quando você criou as VMs de back-end, a cada uma foi atribuído um endereço IP externo temporário para possibilitar o download do Apache por meio de um script de inicialização. Como as VMs de back-end só são usadas por um balanceador de carga interno, é possível remover os endereços IP externos. A remoção de endereços IP externos impede que as VMs de back-end acessem a Internet diretamente.

Console

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

    Acessar instâncias de VM

  2. Repita as etapas a seguir 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 seção Interfaces de rede, clique na rede.

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

  7. Clique em Salvar.

gcloud

  1. Para procurar a zona de uma instância, por exemplo, se estiver usando um grupo de instâncias gerenciadas regionais, execute o seguinte comando para cada instância determinar sua zona. Substitua [SERVER-VM] pelo nome da VM a ser pesquisada.

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

  2. Repita a etapa a seguir para cada VM de back-end. Substitua [SERVER-VM] pelo nome da VM e [ZONE] pela zona da VM.

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

API

Faça uma solicitação POST ao método instances.deleteAccessConfig para cada VM de back-end, substituindo vm-a1 pelo nome da VM e 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

Usar um endereço IP interno reservado

Quando você cria VMs de back-end e grupos de instâncias, a instância de VM usa um endereço IPv4 ou IPv6 temporário.

As etapas a seguir mostram como promover um endereço IPv4 ou IPv6 interno a 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. Promover um endereço IPv4 ou IPv6 interno efêmero em uso a um endereço estático
  2. Alterar ou atribuir um endereço IPv6 interno a uma instância atual

Como alternativa, as etapas a seguir mostram como reservar um novo endereço IPv4 ou IPv6 interno estático e atualizar a instância de VM para usar o endereço IP interno estático:

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

    Ao contrário da reserva IPv4 interna, a reserva IPv6 interna não é compatível com a reserva de um endereço IP específico da sub-rede. Em vez disso, um intervalo de endereços IPv6 interno /96 é alocado automaticamente com base no intervalo de endereços IPv6 interno /64 da sub-rede.

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

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

Aceitar o tráfego em todas as portas

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

Ao criar a regra de encaminhamento do balanceador de carga de exemplo, você configurou as portas 80, 8008, 8080 e 8088. O script de inicialização que instala o Apache também o configura para aceitar conexões HTTPS nas portas 443 e 8443.

Para que essas seis portas tenham suporte, configure a regra de encaminhamento para aceitar o tráfego em todas as portas. Com essa estratégia, também é possível configurar a regra de firewall ou regras que permitem conexões de entrada para VMs de back-end, para que elas permitam apenas determinadas portas.

Neste procedimento, mostramos como excluir a regra de encaminhamento atual do balanceador de carga e criar uma nova que aceite tráfego em todas as portas.

Para mais informações sobre quando usar essa configuração, consulte Balanceadores de carga TCP/UDP internos e regras de encaminhamento com um endereço IP comum.

Console

Excluir sua regra de encaminhamento e criar uma nova

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

    Acessar o "Balanceamento de carga"

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

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

  4. Mantenha o ponteiro do mouse sobre a regra de encaminhamento 10.1.2.9 e clique em Excluir.

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

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

    • Name: fr-ilb
    • Sub-rede: lb-subnet
    • IP interno: ip-ilb
    • Portas: Todas.

  7. Verifique se há uma marca de seleção azul ao lado da Configuração de front-end antes de continuar.

  8. Clique em Analisar e finalizar e revise as configurações do balanceador de carga.

  9. Clique em Criar.

gcloud

  1. Exclua a regra de encaminhamento atual, 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, com uma configuração de porta que use a palavra-chave ALL. Os outros parâmetros da regra de encaminhamento permanecem os mesmos.

    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

Exclua a regra de encaminhamento fazendo uma solicitação 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 firewall fazendo uma solicitação 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"
}

Testar o tráfego em todas as portas

Conecte-se à instância de VM de cliente e teste as conexões HTTP e HTTPS.

  • Conecte-se à VM do cliente:

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

  • Teste a conectividade HTTP nas 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 conectividade HTTPS nas portas 443 e 8443. A sinalização --insecure é obrigató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 as solicitações HTTP (em todas as quatro portas) e HTTPS (em ambas as portas) são distribuídas entre todas as VMs de back-end.

Aceitar tráfego em várias portas usando duas regras de encaminhamento

Ao criar a regra de encaminhamento do balanceador de carga de exemplo, você configurou as portas 80, 8008, 8080 e 8088. O script de inicialização que instala o Apache também o configura para aceitar conexões HTTPS nas portas 443 e 8443.

Uma estratégia alternativa para configurar uma única regra de encaminhamento para aceitar o tráfego em todas as portas é criar várias regras de encaminhamento, cada uma com suporte para cinco ou menos portas.

Neste procedimento, veja como substituir a regra de encaminhamento do balanceador de carga de exemplo por duas regras de encaminhamento, uma para lidar com o tráfego nas portas 80, 8008, 8080 e 8088 e outra, nas portas 443 e 8443.

Para mais informações sobre quando usar essa configuração, consulte Balanceadores de carga TCP/UDP internos e regras de encaminhamento com um endereço IP comum.

Console

  1. No Console do Google Cloud, acesse a página Regras de encaminhamento.

    Acessar as regras de encaminhamento

  2. Na coluna Nome, clique em fr-ilb e em Excluir.

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

    Acessar o "Balanceamento de carga"

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

  5. Clique em Editar.

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

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

  8. Na seção Novo IP e nova porta de front-end, faça o seguinte:

    1. Em Nome, insira fr-ilb-http.
    2. Em Sub-rede, selecione lb-subnet.
    3. Em Finalidade do IP interno, selecione Compartilhado.
    4. Na lista de Endereços IP, selecione Criar endereço IP, insira as informações a seguir e clique em Reservar:
      • Name: internal-10-1-2-99
      • Endereço IP estático: quero escolher
      • Endereço IP personalizado: 10.1.2.99
    5. Em Portas, selecione Várias e, em Números de portas, digite 80, 8008, 8080 e 8088.
    6. Clique em Concluído.

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

  10. Na seção Novo IP e nova porta de front-end, faça o seguinte:

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

  11. Clique em Analisar e finalizar e revise as configurações do balanceador de carga.

  12. Clique em Atualizar.

gcloud

  1. Exclua a regra de encaminhamento atual, 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 sinalização --purpose como SHARED_LOADBALANCER_VIP. A sinalização --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

Exclua a regra de encaminhamento fazendo uma solicitação 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 finalidade como SHARED_LOADBALANCER_VIP, fazendo uma solicitação POST para o 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 duas solicitações POST para o 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"
}

Testar o tráfego em várias portas

Conecte-se à instância de VM de cliente e teste as conexões HTTP e HTTPS.

  • Conecte-se à VM do cliente:

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

  • Teste a conectividade HTTP nas 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 conectividade HTTPS nas portas 443 e 8443. A sinalização --insecure é obrigató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 as solicitações HTTP (em todas as quatro portas) e HTTPS (em ambas as portas) são distribuídas entre todas as VMs de back-end.

Usar afinidade da sessão

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

Neste procedimento, mostramos como atualizar o serviço de back-end do balanceador de carga de rede de passagem interno de exemplo para que ele use a afinidade da sessão com base em um hash criado a partir dos endereços IP do cliente e do endereço IP da regra de encaminhamento interna do balanceador de carga.

Para ver os tipos de afinidade de sessão compatíveis, consulte Opções de afinidade de sessão.

Console

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

    Acessar o "Balanceamento de carga"

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

  3. Na página Editar balanceador de carga de rede de passagem interna, clique em Configuração de back-end.

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

  5. Clique em Atualizar.

gcloud

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

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

API

Faça uma solicitação 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"
}

Configurar uma política de rastreamento de conexão

Nesta seção, você verá como atualizar o serviço de back-end para alterar a política de rastreamento de conexão padrão do balanceador de carga.

Uma política de rastreamento de conexão inclui as seguintes configurações:

gcloud

Use o seguinte comando gcloud compute backend-services para atualizar a política de rastreamento de conexão do 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 por valores válidos:

  • BACKEND_SERVICE: o serviço de back-end que você está atualizando.
  • REGION: a região do serviço de back-end que você está atualizando
  • TRACKING_MODE: o modo de rastreamento de conexão a ser usado para pacotes de entrada; para ver a lista de valores compatíveis, consulte Modo de rastreamento
  • CONNECTION_PERSISTENCE_BEHAVIOR: o comportamento de persistência de conexão quando os back-ends não estiverem íntegros. Para ver a lista de valores compatíveis, consulte Persistência de conexão em back-ends não íntegros

  • IDLE_TIMEOUT_VALUE: o número de segundos que uma entrada da tabela de rastreamento de conexão precisa manter depois que o balanceador de carga processar o último pacote que corresponde à entrada

    Só será possível modificar essa propriedade quando o rastreamento de conexão for menor que 5 tuplas, ou seja, quando a afinidade de sessão estiver configurada como CLIENT_IP ou CLIENT_IP_PROTO e o modo de rastreamento for PER_SESSION.

    O valor padrão é de 600 segundos (dez minutos). O valor máximo do tempo limite de inatividade configurável é de 57.600 segundos (16 horas).

Criar uma regra de encaminhamento em outra sub-rede

Neste procedimento, criamos um segundo endereço IP e regra de encaminhamento em outra sub-rede para demonstrar que é possível criar várias regras de encaminhamento para um balanceador de carga de rede de passagem interno. A região da regra de encaminhamento precisa corresponder à região do serviço de back-end.

Sujeito a regras de firewall, os clientes em qualquer sub-rede da região podem contatar o endereço IP do balanceador de carga de rede de passagem interno.

Console

Adicione a segunda sub-rede

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

    Acessar redes VPC

  2. Clique em Criar rede VPC.

  3. Clique em lb-network.

  4. Na seção Sub-rede, faça o seguinte:

    1. Clique em Add subnet.
    2. Na seção Nova sub-rede, insira as informações a seguir:
      • Name: 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. No Console do Google Cloud, acesse a página Balanceamento de carga.

    Acessar o "Balanceamento de carga"

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

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

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

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

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

  6. Verifique se há uma marca de seleção azul ao lado da Configuração de front-end antes de continuar.

  7. Clique em Analisar e finalizar e revise as configurações do balanceador de carga.

  8. Clique em Criar.

gcloud

  1. Crie uma segunda sub-rede na rede lb-network, 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 endereço IP e 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 uma solicitação POST 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 firewall fazendo uma solicitação 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"
}

Testar a nova regra de encaminhamento

Conecte-se à instância de VM de cliente e teste as conexões HTTP e HTTPS com os endereços IP.

  1. Conecte-se à VM do cliente:

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

  2. Teste a conectividade HTTP com os endereços IP:

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

  3. Teste a conectividade HTTPS. O uso de --insecure é obrigatório porque a configuração do servidor Apache na configuração de exemplo usa certificados autoassinados.

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

  4. As solicitações são manipuladas por todas as VMs de back-end, independentemente do protocolo (HTTP ou HTTPS) ou do endereço IP usado.

Usar a subdivisão de back-end

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

Neste procedimento, mostramos como ativar a criação de subconjuntos no serviço de back-end para o balanceador de carga de rede de passagem interno de exemplo de modo que a implantação possa ser escalonada para um número maior de instâncias de back-end.

Ative a subconfiguração se precisar aceitar mais de 250 VMs de back-end em um único balanceador de carga.

Para mais informações sobre esse caso de uso, consulte Subconjuntos de back-ends.

gcloud

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

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

API

Faça uma solicitação 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
  }
}

Criar um balanceador de carga para o espelhamento de pacotes

O espelhamento de pacotes permite copiar e coletar dados de pacotes de instâncias específicas em uma VPC. Os dados coletados podem ajudar você a detectar ameaças à segurança e a monitorar o desempenho do aplicativo.

O espelhamento de pacotes exige um balanceador de carga de rede de passagem interno para balancear o tráfego para um grupo de instâncias de destinos de coletor. Para criar um balanceador de carga de rede de passagem interna para o espelhamento de pacotes, siga estas etapas.

Console

Iniciar a configuração

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

    Acessar o "Balanceamento de carga"

  2. Clique em Criar balanceador de carga.
  3. Em Tipo de balanceador de carga, selecione Balanceador de carga de rede (TCP/UDP/SSL) e clique em Próxima.
  4. Em Proxy ou passagem, selecione Balanceador de carga de passagem e clique em Próxima.
  5. Em Voltado ao público ou interno, selecione Interno e clique em Próxima.
  6. Clique em Configurar.

Configuração básica

  1. Em Nome do balanceador de carga, insira um nome.
  2. Em Região, selecione a região das instâncias de VM em que você quer espelhar pacotes.
  3. Em Rede, selecione a rede em que você quer espelhar pacotes.
  4. Clique em Configuração de back-end.
  5. Na seção Novo back-end, em Grupo de instâncias, selecione o grupo de instâncias para encaminhar pacotes.
  6. Na lista Verificação de integridade, selecione Criar verificação de integridade, insira as informações a seguir e clique em Salvar:
    1. Em Nome, digite um nome para a verificação de integridade.
    2. Em Protocolo, selecione HTTP.
    3. Em Porta, insira 80.
  7. Clique em Configuração de front-end.
  8. Na seção Novo IP e nova porta de front-end, faça o seguinte:
    1. Em Nome, digite um nome.
    2. Em Sub-rede, selecione uma sub-rede na mesma região das instâncias a serem espelhadas.
    3. Em Portas, selecione Todas.
    4. Clique em Configurações avançadas e marque a caixa de seleção Ativar este balanceador de carga para espelhamento de pacotes.
    5. Clique em Concluído.
  9. Clique em Criar.

gcloud

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

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

    Substitua:

    • HEALTH_CHECK_NAME: o nome da verificação de integridade.
    • REGION: a região das instâncias de VM em que você quer espelhar 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:

    • COLLECTOR_BACKEND_SERVICE: o nome do serviço de back-end.
    • REGION: a região das instâncias de VM em que você quer espelhar pacotes.
    • HEALTH_CHECK_NAME: o nome da verificação de integridade.

  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:

    • 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 do 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:

    • FORWARDING_RULE_NAME: o nome da regra de encaminhamento.
    • REGION: a região da regra de encaminhamento.
    • NETWORK: a rede da regra de encaminhamento.
    • SUBNET: uma sub-rede na região das VMs em que você querespelhar pacotes.
    • COLLECTOR_BACKEND_SERVICE: o serviço de back-end do balanceador de carga.

A seguir