Configurar um balanceador de carga de rede de passagem interna com back-ends de grupos de instâncias de VM para vários protocolos

Nesta página, fornecemos instruções para criar balanceadores de carga de rede de passagem interna para o balanceamento de carga do tráfego de vários protocolos.

Para configurar um balanceador de carga para vários protocolos, incluindo TCP e UDP, crie uma regra de encaminhamento com o protocolo definido como L3_DEFAULT. Essa regra de encaminhamento aponta para um serviço de back-end com o protocolo definido como UNSPECIFIED.

Neste exemplo, usamos um balanceador de carga de rede de passagem interna para distribuir o tráfego por uma VM de back-end na região us-west1. O balanceador de carga tem uma regra de encaminhamento com o protocolo L3_DEFAULT para lidar com TCP, UDP, ICMP, ICMPv6, SCTP, ESP, AH e GRE

Balanceamento de carga de tráfego IPv4 e IPv6 com base em protocolos, com serviços de back-end para gerenciar a distribuição de conexões para um único grupo de instâncias zonais.
Balanceador de carga de rede de passagem interna para vários protocolos (clique para ampliar).

Antes de começar

Permissões

Para ter as permissões necessárias para concluir este guia, peça ao administrador para conceder a você os papéis do IAM a seguir no projeto:

Para mais informações sobre como conceder papéis, consulte Gerenciar acesso.

Também é possível conseguir as permissões necessárias com papéis personalizados ou outros papéis predefinidos.

Configurar o balanceador de carga para o tráfego L3_DEFAULT

As etapas nesta seção descrevem as seguintes configurações:

  • Um exemplo que usa uma rede VPC personalizada chamada lb-network. Você pode usar uma rede no modo automático se quiser processar apenas o tráfego IPv4. No entanto, o tráfego IPv6 requer uma sub-rede de modo personalizado.
  • 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. No tráfego IPv6, é necessário ter uma sub-rede de pilha dupla (stack-type definido como IPv4_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.
  • Regras de firewall que permitem conexões de entrada com VMs de back-end.
  • O grupo de instâncias de back-end e os componentes do balanceador de carga usados neste exemplo estão localizados nesta região e sub-rede:
    • Região: us-west1
    • Sub-rede: lb-subnet, com intervalo de endereços IPv4 principal 10.1.2.0/24. Embora você escolha qual intervalo de endereços IPv4 será configurado na sub-rede, o intervalo de endereços IPv6 é atribuído automaticamente. O Google fornece um bloco CIDR IPv6 de tamanho fixo (/64).
  • Uma VM de back-end em um grupo gerenciado de instâncias na zona us-west1-a.
  • Uma VM cliente para testar conexões com os back-ends.
  • Um balanceador de carga de rede de passagem interna com os seguintes componentes:
    • Uma verificação de integridade do serviço de back-end.
    • Um serviço de back-end na região us-west1 com o protocolo definido como UNSPECIFIED para gerenciar a distribuição de conexão para o grupo de instâncias zonais.
    • Uma regra de encaminhamento com o protocolo definido como L3_DEFAULT e a porta definida como ALL.

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

Para configurar sub-redes com intervalos IPv6 internos, ative um intervalo IPv6 interno da rede da nuvem privada virtual (VPC, na sigla em inglês). Os intervalos de sub-redes IPv6 internos são alocados desse intervalo. Para criar a rede e sub-rede do exemplo, siga estas etapas:

Console

Para oferecer suporte a tráfego IPv4 e IPv6, siga estas etapas:

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

    1. Em Nome, insira lb-subnet.
    2. Em Região, selecione us-west1.
    3. Para criar uma sub-rede de pilha dupla, selecione IPv4 e IPv6 (pilha dupla) em Tipo de pilha de IP.
    4. Em Intervalo IPv4, insira 10.1.2.0/24.
    5. Em Tipo de acesso IPv6, selecione Interno.

  7. Clique em Concluído.

  8. Clique em Criar.

Para oferecer suporte ao tráfego IPv4, siga estas etapas:

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

    • Defina o Modo de criação de sub-rede como Personalizado.
    • 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
    • Clique em Concluído.

  5. Clique em Criar.

gcloud

Para tráfego IPv4 e IPv6, use os seguintes comandos:

  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.

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

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

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

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

Para somente tráfego IPv4, use os seguintes comandos:

  1. Para criar a rede VPC personalizada, use o comando gcloud compute networks create:

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

  2. Para criar a sub-rede para back-ends na região us-west1 da rede lb-network, use o comando gcloud compute networks subnets create.

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

API

Para tráfego IPv4 e IPv6, use os seguintes comandos:

  1. Crie uma nova rede VPC de modo personalizado: Faça uma solicitação POST ao método networks.insert.

    Para configurar intervalos IPv6 internos em qualquer sub-rede nessa rede, defina enableUlaInternalIpv6 como true. Esta opção atribui um intervalo /48 dentro do intervalo fd20::/20 usado pelo Google para intervalos de sub-rede IPv6 internos.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
{
  "autoCreateSubnetworks": false,
  "name": "lb-network",
  "mtu": MTU,
  "enableUlaInternalIpv6": true,
}

    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.

  2. Faça uma solicitação POST ao 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",
"name": "lb-subnet"
"stackType": IPV4_IPV6,
"ipv6AccessType": Internal
}

Para somente tráfego IPv4, use o seguinte comando:

  1. Faça uma solicitação POST ao método networks.insert. Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks
{
"name": "lb-network",
"autoCreateSubnetworks": false
}

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

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. Essas regras autorizam o tráfego de entrada de qualquer cliente na sub-rede.

  • 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. Essas regras autorizam o tráfego IPv6 de entrada de qualquer cliente na sub-rede.

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

    Acesse as políticas de firewall

  2. Para permitir que o tráfego TCP, UDP e ICMP de IPv4 alcance o grupo de instâncias de back-end ig-a:

    • Clique em Criar regra de firewall.
    • Name: fw-allow-lb-access
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação na correspondência: permitir
    • Destinos: todas as instâncias na rede
    • Filtro de origem: intervalos IPv4
    • Intervalos IPv4 de origem: 10.1.2.0/24
    • Protocolos e portas: selecione Portas e protocolos especificados.
      • Selecione TCP e insira ALL.
      • Selecione UDP.
      • Selecione Outro e insira ICMP.

  3. Clique em Criar.

  4. Para permitir conexões SSH de entrada:

    • Clique em Criar regra de firewall.
    • Name: fw-allow-ssh
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação na 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
    • Portas e protocolos: escolha Portas e protocolos especificados e insira tcp:22.

  5. Clique em Criar.

  6. Para permitir que o tráfego TCP, UDP e ICMP do IPv6 alcance o grupo de instâncias de back-end ig-a:

    • Clique em Criar regra de firewall.
    • Name: fw-allow-lb-access-ipv6
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação na correspondência: permitir
    • Destinos: todas as instâncias na rede
    • Filtro de origem: intervalos IPv6
    • Intervalos IPv6 de origem: IPV6_ADDRESS atribuídos no lb-subnet
    • Protocolos e portas: selecione Portas e protocolos especificados.
      • Selecione TCP e insira 0-65535.
      • Selecione UDP.
      • Selecione Outro e, no protocolo ICMPv6, insira 58.

  7. Clique em Criar.

  8. Para permitir verificações de integridade do Google Cloud IPv6:

    • Clique em Criar regra de firewall.
    • Name: fw-allow-health-check-ipv6
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação na 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 verificações de integridade do Google Cloud IPv4:

    • Clique em Criar regra de firewall.
    • Name: fw-allow-health-check
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação na 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. Para permitir que o tráfego TCP do IPv4 alcance o grupo de instâncias de back-end ig-a, crie a seguinte regra:

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

  2. Crie a regra de firewall fw-allow-ssh para permitir a conectividade SSH com as VMs usando 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. Para permitir que o tráfego IPv6 alcance o grupo de instâncias de back-end ig-a, crie a seguinte regra:

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

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

  4. Crie a regra de firewall 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

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

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

API

  1. Para criar a regra de firewall fw-allow-lb-access, faça uma solicitação POST ao método firewalls.insert. Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

    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"
],
"allPorts": true,
"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",
 "priority": 1000,
 "sourceRanges": [
   "IPV6_ADDRESS"
 ],
 "allPorts": true,
 "allowed": [
   {
      "IPProtocol": "tcp"
    },
    {
      "IPProtocol": "udp"
    },
    {
      "IPProtocol": "58"
    }
 ],
 "direction": "INGRESS",
 "logConfig": {
    "enable": false
 },
 "disabled": false
}

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

  3. Para criar a regra de firewall fw-allow-ssh, faça 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
}

  4. Para criar a regra de firewall fw-allow-health-check, faça 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
}

  5. 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",
"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
}

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

Neste cenário de balanceamento de carga, você cria um grupo de instâncias gerenciadas por zona do Compute Engine e instala um servidor da Web Apache.

Para lidar com tráfego IPv4 e IPv6, configure as VMs de back-end para serem de pilha dupla. Defina o stack-type da VM como IPv4_IPv6. As VMs também herdam a configuração ipv6-access-type (neste exemplo, INTERNAL) da sub-rede. Para mais detalhes sobre os requisitos do IPv6, consulte a Visão geral do balanceador de carga de rede de passagem interna: regras de encaminhamento.

Se você quiser usar VMs atuais como back-ends, atualize-as para pilha dupla usando o comando gcloud compute instances network-interfaces update.

As instâncias que participam como VMs de back-end para balanceadores de carga de rede de passagem interna precisam executar o ambiente convidado Linux, o ambiente convidado Windows ou outros processos com funcionalidade equivalente.

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

Criar o grupo de instâncias

Console

Para oferecer suporte a tráfego IPv4 e IPv6, siga estas etapas:

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

    Acesse "Modelos de instância"

    1. Clique em Criar modelo de instância.
    2. Em Nome, insira vm-a1.
    3. Certifique-se de que o disco de inicialização esteja definido como uma imagem Debian, como Debian GNU/Linux 12 (bookworm) Estas instruções usam comandos que estão disponíveis apenas no Debian, como apt-get.
    4. Expanda a seção Opções avançadas.

    5. Abra a seção Gerenciamento e copie o script a seguir no campo Script de inicialização. O script de inicialização também configura o servidor Apache para detectar na porta 8080 em vez da porta 80.

      #! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
sed -ire 's/^Listen 80$/Listen 8080/g' /etc/apache2/ports.conf
systemctl restart apache2

    6. Abra a seção Rede e especifique o seguinte:

      1. Em Tags de rede, adicione allow-ssh e allow-health-check-ipv6.
      2. Em Interfaces de rede, clique na interface padrão e configure os seguintes campos:
        • Rede: lb-network
        • Sub-rede: lb-subnet
        • Tipo de pilha de IP: IPv4 e IPv6 (pilha dupla)

    7. Clique em Criar.

Para oferecer suporte ao tráfego IPv4, siga estas etapas:

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

    Acesse "Modelos de instância"

  2. Clique em Criar modelo de instância.

    1. Em Nome, insira vm-a1.
    2. Certifique-se de que o disco de inicialização esteja definido como uma imagem Debian, como Debian GNU/Linux 12 (bookworm) Estas instruções usam comandos que estão disponíveis apenas no Debian, como apt-get.
    3. Expanda a seção Opções avançadas.

    4. Abra a seção Gerenciamento e copie o script a seguir no campo Script de inicialização. O script de inicialização também configura o servidor Apache para detectar na porta 8080 em vez da porta 80.

      #! /bin/bash
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
sed -ire 's/^Listen 80$/Listen 8080/g' /etc/apache2/ports.conf
systemctl restart apache2

    5. Abra a seção Rede e especifique o seguinte:

      1. Em Tags de rede, adicione allow-ssh e allow-health-check.
      2. Em Interfaces de rede, clique na interface padrão e configure os seguintes campos:
        • Rede: lb-network
        • Sub-rede: lb-subnet
        • Tipo de pilha de IP: IPv4 (pilha única)

    6. Clique em Criar.

  3. Crie um grupo de instâncias gerenciadas. Acesse a página Grupos de instâncias no console do Google Cloud.

    Acesse grupo de instâncias

    1. Clique em Criar grupo de instâncias.
    2. Escolha Novo grupo gerenciado de instâncias (sem estado). Para mais informações, consulte MIGs sem estado ou com estado.
    3. Em Nome, insira ig-a.
    4. Em Local, selecione Zona única.
    5. Em Região, selecione us-west1.
    6. Em Zona, selecione us-west1-a.
    7. Em Modelo de instância, selecione vm-a1.

    8. Especifique o número de instâncias que você quer criar no grupo.

      Neste exemplo, especifique as seguintes opções em Escalonamento automático:

      • Em Modo de escalonamento automático, selecione Off:do not autoscale.
      • Em Número máximo de instâncias, insira 2.

    9. Clique em Criar.

gcloud

As instruções gcloud deste guia pressupõem que você está usando o Cloud Shell ou outro ambiente com o bash instalado.

  1. Crie um modelo de instância de VM com o servidor HTTP usando o comando gcloud compute instance-templates create.

    O script de inicialização também configura o servidor Apache para detectar na porta 8080 em vez da porta 80.

    Para processar tanto tráfego IPv4 quanto IPv6, use o comando a seguir.

    gcloud compute instance-templates create vm-a1 \
    --region=us-west1 \
    --network=lb-network \
    --subnet=lb-subnet \
    --ipv6-network-tier=PREMIUM \
    --stack-type=IPv4_IPv6 \
    --tags=allow-ssh \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
      systemctl restart apache2'

    Ou, se quiser processar apenas tráfego IPv4, use o seguinte comando.

    gcloud compute instance-templates create vm-a1 \
    --region=us-west1 \
    --network=lb-network \
    --subnet=lb-subnet \
    --tags=allow-ssh \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --metadata=startup-script='#! /bin/bash
      apt-get update
      apt-get install apache2 -y
      a2ensite default-ssl
      a2enmod ssl
      vm_hostname="$(curl -H "Metadata-Flavor:Google" \
      http://metadata.google.internal/computeMetadata/v1/instance/name)"
      echo "Page served from: $vm_hostname" | \
      tee /var/www/html/index.html
      sed -ire "s/^Listen 80$/Listen 8080/g" /etc/apache2/ports.conf
      systemctl restart apache2'

  2. Crie um grupo gerenciado de instâncias na zona com o comando gcloud compute instance-groups managed create.

    gcloud compute instance-groups managed create ig-a \
    --zone us-west1-a \
    --size 2 \
    --template vm-a1

api

Para processar tanto tráfego IPv4 quanto IPv6, siga estas etapas:

  1. Crie uma VM fazendo solicitações POST para o método instances.insert:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
"name": "vm-a1",
"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",
   "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-a1",
   "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\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\nsed -ire "s/^Listen 80$/Listen 8080/g" /etc/\\napache2/ports.conf\nsystemctl restart apache2"
   }
 ]
},
"scheduling": {
 "preemptible": false
},
"deletionProtection": false
}

Para processar o tráfego IPv4, siga estas etapas.

  1. Crie uma VM fazendo solicitações POST para o método instances.insert:

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/zones/ZONE/instances
{
"name": "vm-a1",
"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": [
 {
   "stackType": "IPV4",
   "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-a1",
   "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\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\nsed -ire "s/^Listen 80$/Listen 8080/g" /etc/\\napache2/ports.conf\nsystemctl restart apache2"
   }
 ]
},
"scheduling": {
 "preemptible": false
},
"deletionProtection": false
}

  2. Crie um grupo 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"
}

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

Criar uma VM cliente

Neste exemplo, criamos uma VM cliente () 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.

Para tráfego IPv4 e IPv6:

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

  4. Defina a Zona como us-west1-a.

  5. Abra a seção Opções avançadas e faça as seguintes alterações:

    • Abra Rede e adicione allow-ssh às Tags de rede.
    • Em Interfaces de rede, clique em Editar, faça as alterações a seguir e clique em Concluído:
      • Rede: lb-network
      • 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

  6. 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-ipv6 \
    --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-ipv6",
 "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",
     "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
}

Para o tráfego IPv4:

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 Zona, insira us-west1-a.

  5. Expanda a seção Opções avançadas.

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

  7. 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. Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

 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
  }

Configurar componentes do balanceador de carga

Crie um balanceador de carga para vários protocolos.

gcloud

  1. Crie uma verificação de integridade HTTP para a porta 80. Essa verificação de integridade é usada para verificar a integridade dos back-ends no grupo de instâncias ig-a.

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

  2. Crie um serviço de back-end com o protocolo definido como UNSPECIFIED:

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

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

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

  4. Para tráfego IPv6: crie uma regra de encaminhamento com o protocolo definido como L3_DEFAULT para lidar com todo o tráfego de protocolo IPv6 compatível. Todas as portas precisam ser configuradas com regras de encaminhamento L3_DEFAULT.

    gcloud compute forwarding-rules create fr-ilb-ipv6 \
   --region=us-west1 \
   --load-balancing-scheme=internal \
   --subnet=lb-subnet \
   --ip-protocol=L3_DEFAULT \
   --ports=ALL \
   --backend-service=be-ilb-l3-default \
   --backend-service-region=us-west1 \
   --ip-version=IPV6

  5. Para tráfego IPv4: crie uma regra de encaminhamento com o protocolo definido como L3_DEFAULT para lidar com todo o tráfego de protocolo IPv4 compatível. Todas as portas precisam ser configuradas com regras de encaminhamento L3_DEFAULT. Use 10.1.2.99 como o endereço IP interno.

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

API

  1. Crie a verificação de integridade fazendo uma solicitação POST ao método regionHealthChecks.insert. Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

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

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

  2. 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-l3-default",
"backends": [
 {
   "group": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/zones/us-west1-a/instanceGroups/ig-a",
   "balancingMode": "CONNECTION"
 }
],
"healthChecks": [
 "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"protocol": "UNSPECIFIED",
"connectionDraining": {
 "drainingTimeoutSec": 0
}
}

  3. Para tráfego IPv6: crie a regra de encaminhamento 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": "L3_DEFAULT",
"allPorts": true,
"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-l3-default",
"ipVersion": "IPV6",
"networkTier": "PREMIUM"
}

  4. Para tráfego IPv4: crie a regra de encaminhamento 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-l3-default",
"IPAddress": "10.1.2.99",
"IPProtocol": "L3_DEFAULT",
"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-l3-default",
"networkTier": "PREMIUM"
}

Testar o balanceador de carga

Os testes a seguir mostram como validar a configuração do balanceador de carga e saber mais sobre o comportamento esperado.

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.

gcloud:IPv6

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

    gcloud compute ssh vm-client-ipv6 --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. Em clientes com conectividade IPv6, execute o seguinte comando. Substitua IPV6_ADDRESS pelo endereço IPv6 temporário na regra de encaminhamento fr-ilb-ipv6.

    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

gcloud:IPv4

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

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

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

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

  3. 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. As respostas esperadas são semelhantes a Page served from: vm-a1.

    curl http://10.1.2.99

    A regra de encaminhamento está configurada para exibir as portas 80 e 53. Para enviar tráfego para essas portas, anexe dois pontos (:) e o número da porta após o endereço IP, desta maneira:

    curl http://10.1.2.99:80

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.

gcloud:IPv6

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

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

  2. Tente fazer o ping do endereço IPv6 do balanceador de carga. Substitua IPV6_ADDRESS pelo endereço IPv6 temporário na regra de encaminhamento fr-ilb-ipv6.

    Você recebe uma resposta e o comando ping funciona neste exemplo.

    ping6 IPV6_ADDRESS

    Por exemplo, se o endereço IPv6 atribuído for [2001:db8:1:1:1:1:1:1/96], o comando será o seguinte:

    ping6 2001:db8:1:1:1:1:1:1

    O resultado será assim:

    @vm-client: ping IPV6_ADDRESS
PING IPV6_ADDRESS (IPV6_ADDRESS) 56(84) bytes of data.
64 bytes from IPV6_ADDRESS: icmp_seq=1 ttl=64 time=1.58 ms

gcloud:IPv4

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

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

  2. Tente dar um ping no endereço IPv4 do balanceador de carga. Você recebe uma resposta e o comando ping funciona neste exemplo.

    ping 10.1.2.99

    A saída é esta:

    @vm-client: ping 10.1.2.99
PING 10.1.2.99 (10.1.2.99) 56(84) bytes of data.
64 bytes from 10.1.2.99: icmp_seq=1 ttl=64 time=1.58 ms
64 bytes from 10.1.2.99: icmp_seq=2 ttl=64 time=0.242 ms
64 bytes from 10.1.2.99: icmp_seq=3 ttl=64 time=0.295 ms

Outras opções de configuração

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

É possível reservar um endereço IP interno estático para o exemplo. Essa configuração permite que várias regras de encaminhamento interno usem o mesmo endereço IP com protocolos e portas diferentes. Os back-ends do balanceador de carga de exemplo ainda precisam estar localizados na única região us-west1.

O diagrama a seguir mostra a arquitetura deste exemplo.

Tráfego de balanceamento de carga baseado em protocolos, com serviços de back-end para gerenciar a distribuição de conexões para um único grupo de instâncias zonais.
Um balanceador de carga de rede de passagem interna para vários protocolos que usam um endereço IP interno estático (clique para ampliar).

Também é possível usar as seguintes configurações de regra de encaminhamento:

  • Regras de encaminhamento com várias portas:

    • Protocolo TCP com portas 80,8080
    • Protocolo L3_DEFAULT com portas ALL

  • Regras de encaminhamento com todas as portas:

    • Protocolo TCP com portas ALL
    • Protocolo L3_DEFAULT com portas ALL

Reservar endereço IPv4 interno estático

Reserve um endereço IP interno estático para 10.1.2.99 e defina a flag --purpose como SHARED_LOADBALANCER_VIP. A flag --purpose é necessária para que muitas regras de encaminhamento possam usar o mesmo endereço IP interno.

gcloud

Use o comando gcloud compute addresses create:

gcloud compute addresses create internal-lb-ipv4 \
    --region us-west1 \
    --subnet lb-subnet \
    --purpose SHARED_LOADBALANCER_VIP \
    --addresses 10.1.2.99

API

Chame o método addresses.insert. Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

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

O corpo da solicitação precisa incluir addressType, que precisa ser INTERNAL, o name do endereço e o subnetwork do endereço IP. Especifique address como 10.1.2.99.

{
  "addressType": "INTERNAL",
  "name": "internal-lb-ipv4",
  "subnetwork": "regions/us-west1/subnetworks/lb-subnet",
  "purpose": "SHARED_LOADBALANCER_VIP",
  "address": "10.1.2.99"
}

Configurar componentes do balanceador de carga

Configure três balanceadores de carga com os seguintes componentes:

  • O primeiro balanceador de carga tem uma regra de encaminhamento com o protocolo TCP e a porta 80. O tráfego TCP que chega ao endereço IP interno na porta 80 é processado pela regra de encaminhamento TCP.
  • O segundo balanceador de carga tem uma regra de encaminhamento com o protocolo UDP e a porta 53. O tráfego UDP que chega ao endereço IP interno na porta 53 é processado pela regra de encaminhamento UDP.
  • O terceiro balanceador de carga tem uma regra de encaminhamento com o protocolo L3_DEFAULT e a porta ALL. Todo o outro tráfego que não corresponde às regras de encaminhamento TCP ou UDP é processado pela regra de encaminhamento L3_DEFAULT.
  • Os três balanceadores de carga compartilham o mesmo endereço IP interno estático (internal-lb-ipv4) nas regras de encaminhamento.

Criar o primeiro balanceador de carga

Crie o primeiro balanceador de carga para o tráfego TCP na porta 80.

gcloud

  1. Crie o serviço de back-end do tráfego TCP:

    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

  2. Adicione o grupo 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

  3. Crie uma regra de encaminhamento do serviço de back-end. Use o endereço IP interno estático reservado (internal-lb-ipv4) para o endereço IP interno.

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

API

  1. Crie um serviço de back-end regional fazendo uma solicitação POST ao método regionBackendServices.insert. Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

    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"
 }
],
"healthChecks": [
 "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/regions/us-west1/healthChecks/hc-http-80"
],
"loadBalancingScheme": "INTERNAL",
"protocol": "TCP",
"connectionDraining": {
 "drainingTimeoutSec": 0
}
}

  2. Create the forwarding rule by making a POST request to the forwardingRules.insert method:

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

{
"name": "fr-ilb",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "TCP",
"ports": [
 "80"
],
"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"
}

Criar o segundo balanceador de carga

Crie o segundo balanceador de carga para o tráfego UDP na porta 53.

gcloud

  1. Crie um serviço de back-end com o protocolo definido como UDP:

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

  2. Adicione o grupo de instâncias ao serviço de back-end.

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

  3. Crie uma regra de encaminhamento do serviço de back-end. Use o endereço IP interno estático reservado (internal-lb-ipv4) para o endereço IP interno.

    gcloud compute forwarding-rules create fr-ilb-udp \
    --region=us-west1 \
    --load-balancing-scheme=internal \
    --network=lb-network \
    --subnet=lb-subnet \
    --address=internal-lb-ipv4 \
    --ip-protocol=UDP \
    --ports=53 \
    --backend-service=be-ilb-udp \
    --backend-service-region=us-west1

API

  1. Crie um serviço de back-end regional fazendo uma solicitação POST ao método regionBackendServices.insert. Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

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

  2. 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-udp",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "UDP",
"ports": [
 "53"
],
"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-udp",
"networkTier": "PREMIUM"
}

Criar o terceiro balanceador de carga

Criar a regra de encaminhamento do terceiro balanceador de carga para usar o endereço IP interno estático reservado.

gcloud

Criar a regra de encaminhamento com o protocolo definido como L3_DEFAULT para processar todos os outros tráfegos de protocolo IPv4 compatíveis. Use o endereço IP interno estático reservado (internal-lb-ipv4) como o endereço IP interno.

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

API

Crie a regra de firewall fazendo uma solicitação POST ao método forwardingRules.insert. Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

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

{
"name": "fr-ilb-l3-default",
"IPAddress": "internal-lb-ipv4",
"IPProtocol": "L3_DEFAULT",
"ports": [
  "ALL"
],
"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-l3-default",
"networkTier": "PREMIUM"
}

Testar o balanceador de carga

Para testar o balanceador de carga, siga as etapas da seção anterior.

A seguir