Configure um balanceador de carga de rede de passagem interno com back-ends de grupo de instâncias de VM para vários protocolos

Esta página fornece instruções para criar balanceadores de carga de rede de encaminhamento interno para equilibrar a carga do tráfego para 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. Esta regra de encaminhamento aponta para um serviço de back-end com o protocolo definido como UNSPECIFIED.

Neste exemplo, usamos um Network Load Balancer de passagem interno 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 processar TCP, UDP, ICMP, ICMPv6, SCTP, ESP, AH e GRE .

Equilibrar a carga do tráfego IPv4 e IPv6 com base nos protocolos, com serviços de back-end para gerir a distribuição de ligações a um único grupo de instâncias zonais.
Balanceador de carga de passagem interno para vários protocolos (clique para aumentar).

Antes de começar

Autorizações

Para receber as autorizações de que precisa para concluir este guia, peça ao seu administrador para lhe conceder as seguintes funções da IAM no projeto:

Para mais informações sobre a atribuição de funções, consulte o artigo Faça a gestão do acesso a projetos, pastas e organizações.

Também pode conseguir as autorizações necessárias através de funções personalizadas ou outras funções predefinidas.

Configure o balanceador de carga para o tráfego L3_DEFAULT

Os passos nesta secção descrevem as seguintes configurações:

  • Um exemplo que usa uma rede VPC no modo personalizado denominada lb-network. Pode usar uma rede no modo automático se quiser processar apenas tráfego IPv4. No entanto, o tráfego IPv6 requer uma sub-rede no modo personalizado.
  • Uma sub-rede de pilha única (stack-type definida como IPv4), que é necessária para o tráfego IPv4. Quando cria uma sub-rede de pilha única numa rede VPC de modo personalizado, escolhe um intervalo de sub-rede IPv4 para a sub-rede. Para o tráfego IPv6, precisamos de uma sub-rede de pilha dupla (stack-type definida como IPV4_IPV6). Quando cria uma sub-rede de pilha dupla numa rede VPC de modo personalizado, escolhe um tipo de acesso IPv6 para a sub-rede. Para este exemplo, definimos o parâmetro ipv6-access-type da sub-rede como INTERNAL. Isto significa que às novas VMs nesta sub-rede podem ser atribuídos endereços IPv4 internos e endereços IPv6 internos.
  • Regras de firewall que permitem ligações recebidas a VMs de back-end.
  • O grupo de instâncias de back-end e os componentes do equilibrador de carga usados neste exemplo estão localizados nesta região e sub-rede:
    • Região: us-west1
    • Sub-rede: lb-subnet, com o intervalo de endereços IPv4 principal 10.1.2.0/24. Embora escolha o intervalo de endereços IPv4 configurado na sub-rede, o intervalo de endereços IPv6 é atribuído automaticamente. A Google fornece um bloco CIDR IPv6 de tamanho fixo (/64).
  • Uma VM de back-end num grupo de instâncias geridas na zona us-west1-a.
  • Uma VM cliente para testar as ligações aos back-ends.
  • Um balanceador de carga de rede de passagem interno com os seguintes componentes:
    • Uma verificação de funcionamento do serviço de back-end.
    • Um serviço de back-end na região us-west1 com o protocolo definido como UNSPECIFIED para gerir a distribuição de ligações ao grupo de instâncias zonais.
    • Uma regra de encaminhamento com o protocolo definido como L3_DEFAULT e a porta definida como ALL.

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

Para configurar sub-redes com intervalos de IPv6 internos, ative um intervalo de IPv6 interno ULA da rede da nuvem virtual privada (VPC). Os intervalos de sub-redes IPv6 internas são atribuídos a partir deste intervalo. Para criar a rede e a sub-rede de exemplo, siga estes passos:

Consola

Para suportar o tráfego IPv4 e IPv6, siga estes passos:

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

    Aceda a redes de VPC

  2. Clique em Criar rede de VPC.

  3. Em Nome, introduza lb-network.

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

    1. Para o intervalo IPv6 interno ULA da rede VPC, selecione Ativado.
    2. Para Atribuir intervalo IPv6 interno, selecione Automaticamente ou Manualmente.

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

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

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

  7. Clique em Concluído.

  8. Clique em Criar.

Para suportar o tráfego IPv4, siga estes passos:

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

    Aceda a redes de VPC

  2. Clique em Criar rede de VPC.

  3. Em Nome, introduza lb-network.

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

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

  5. Clique em Criar.

gcloud

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

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

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

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

  2. Na 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 tráfego apenas 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 na 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 o tráfego IPv4 e IPv6, use os seguintes comandos:

  1. Crie uma nova rede VPC de modo personalizado. Faça um pedido POST ao método networks.insert.

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

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

    Substitua o seguinte:

    • PROJECT_ID: o ID do projeto onde a rede VPC é criada.
    • MTU: a unidade de transmissão máxima da rede. A MTU pode ser 1460 (predefinição) ou 1500. Reveja a vista geral da unidade de transmissão máxima antes de definir a MTU como 1500.

  2. Faça um pedido 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 tráfego apenas IPv4, siga estes passos:

  1. Faça um pedido POST ao método networks.insert. Substitua PROJECT_ID pelo ID do seu projetoGoogle Cloud .

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

  2. Faça dois pedidos POST ao 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
}

Configure regras de firewall

Este exemplo usa as seguintes regras de firewall:

  • fw-allow-lb-access: uma regra de entrada, aplicável a todos os destinos na rede VPC, que permite o tráfego de origens nos intervalos 10.1.2.0/24. Esta regra permite o tráfego de entrada de qualquer cliente localizado 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. Esta regra permite o tráfego IPv6 de entrada de qualquer cliente localizado na sub-rede.

  • fw-allow-ssh: Uma regra de entrada, aplicável às instâncias com balanceamento de carga, que permite a conetividade SSH de entrada na porta TCP 22 a partir de qualquer endereço. Pode escolher um intervalo de IPs de origem mais restritivo para esta regra. Por exemplo, pode especificar apenas os intervalos de IPs do sistema a partir do qual está a iniciar sessões SSH. Este exemplo usa a etiqueta de destino allow-ssh para identificar as VMs às quais deve ser aplicada.

  • fw-allow-health-check: uma regra de entrada, aplicável às instâncias com balanceamento de carga, que permite o tráfego dos sistemas de verificação de estado (130.211.0.0/22 e 35.191.0.0/16). Este exemplo usa a etiqueta de destino allow-health-check para identificar as instâncias às quais deve aplicar-se. Google Cloud

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

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

Consola

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

    Aceder a Políticas de firewall

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

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

  3. Clique em Criar.

  4. Para permitir ligações SSH recebidas:

    • Clique em Criar regra de firewall.
    • Nome: fw-allow-ssh
    • Rede: lb-network
    • Prioridade: 1000
    • Sentido do tráfego: entrada
    • Ação na correspondência: permitir
    • Objetivos: etiquetas de objetivo especificadas
    • Etiquetas de segmentação: allow-ssh
    • Filtro de origem: intervalos de IPv4
    • Intervalos IPv4 de origem: 0.0.0.0/0
    • Protocolos e portas: escolha Protocolos e portas especificados e, de seguida, escreva tcp:22.

  5. Clique em Criar.

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

    • Clique em Criar regra de firewall.
    • Nome: fw-allow-lb-access-ipv6
    • Rede: lb-network
    • Prioridade: 1000
    • Sentido do tráfego: entrada
    • Ação na correspondência: permitir
    • Alvos: 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 Protocolos e portas especificados.
      • Selecione TCP e introduza 0-65535.
      • Selecione UDP.
      • Selecione Outro e, para o protocolo ICMPv6, introduza 58.

  7. Clique em Criar.

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

    • Clique em Criar regra de firewall.
    • Nome: fw-allow-health-check-ipv6
    • Rede: lb-network
    • Prioridade: 1000
    • Sentido do tráfego: entrada
    • Ação na correspondência: permitir
    • Objetivos: etiquetas de objetivo especificadas
    • Etiquetas de segmentação: allow-health-check-ipv6
    • Filtro de origem: intervalos IPv6
    • Intervalos IPv6 de origem: 2600:2d00:1:b029::/64
    • Protocolos e portas: permitir tudo

  9. Clique em Criar.

  10. Para permitir Google Cloud verificações de funcionamento de IPv4:

    • Clique em Criar regra de firewall
    • Nome: fw-allow-health-check
    • Rede: lb-network
    • Prioridade: 1000
    • Sentido do tráfego: entrada
    • Ação na correspondência: permitir
    • Objetivos: etiquetas de objetivo especificadas
    • Etiquetas de segmentação: allow-health-check
    • Filtro de origem: intervalos de IPv4
    • Intervalos de IPv4 de origem: 130.211.0.0/22 e 35.191.0.0/16
    • Protocolos e portas: permitir tudo

  11. Clique em Criar.

gcloud

  1. Para permitir que o tráfego TCP 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 conetividade SSH às VMs através da etiqueta de rede allow-ssh. Quando omite source-ranges, Google Cloud interpreta a regra como qualquer origem.

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

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

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

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

    gcloud compute firewall-rules create fw-allow-health-check-ipv6 \
   --network=lb-network \
   --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 um pedido POST ao método firewalls.insert. Substitua PROJECT_ID pelo ID do seu projetoGoogle 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 um pedido POST ao método firewalls.insert.

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
 "name": "fw-allow-lb-access-ipv6",
 "network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
 "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 um pedido POST ao método firewalls.insert:

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

  4. Para criar a regra de firewall fw-allow-health-check, faça um pedido POST ao método firewalls.insert:

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

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

    POST https://compute.googleapis.com/compute/v1/projects/PROJECT_ID/global/firewalls
{
"name": "fw-allow-health-check-ipv6",
"network": "https://www.googleapis.com/compute/v1/projects/PROJECT_ID/global/networks/lb-network",
"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
}

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

Para este cenário de equilíbrio de carga, cria um grupo de instâncias geridas zonais do Compute Engine e instala um servidor Web Apache.

Para processar o 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 definição ipv6-access-type (neste exemplo, INTERNAL) da sub-rede. Para mais detalhes sobre os requisitos do IPv6, consulte o artigo Vista geral do balanceador de carga de rede de encaminhamento interno: regras de encaminhamento.

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

As instâncias que participam como VMs de back-end para equilibradores de carga de rede de passagem interna têm de estar a executar o ambiente convidado do Linux, ambiente convidado do Windows> ou outros processos adequados que ofereçam uma funcionalidade equivalente.

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

Crie o grupo de instâncias

Consola

Para suportar o tráfego IPv4 e IPv6, siga estes passos:

  1. Crie um modelo de instância. Na Google Cloud consola, aceda à página Modelos de instâncias.

    Aceda a Modelos de instâncias

    1. Clique em Criar modelo de instância.
    2. No campo Nome, introduza vm-a1.
    3. Certifique-se de que o disco de arranque está definido para uma imagem Debian, como o Debian GNU/Linux 12 (bookworm). Estas instruções usam comandos que só estão disponíveis no Debian, como apt-get.
    4. Expanda a secção Opções avançadas.

    5. Expanda a secção Gestão e, de seguida, copie o seguinte script para o campo Script de arranque. O script de arranque também configura o servidor Apache para escutar 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. Expanda a secção Redes e, de seguida, especifique o seguinte:

      1. Para etiquetas de rede, adicione allow-ssh e allow-health-check-ipv6.
      2. Para Interfaces de rede, clique na interface predefinida e configure os seguintes campos:
        • Rede: lb-network
        • Subnetwork: lb-subnet
        • Tipo de pilha de IP: IPv4 e IPv6 (dupla pilha)

    7. Clique em Criar.

Para suportar o tráfego IPv4, siga estes passos:

  1. Crie um modelo de instância. Na Google Cloud consola, aceda à página Modelos de instâncias.

    Aceda a Modelos de instâncias

  2. Clique em Criar modelo de instância.

    1. No campo Nome, introduza vm-a1.
    2. Certifique-se de que o disco de arranque está definido para uma imagem Debian, como o Debian GNU/Linux 12 (bookworm). Estas instruções usam comandos que só estão disponíveis no Debian, como apt-get.
    3. Expanda a secção Opções avançadas.

    4. Expanda a secção Gestão e, de seguida, copie o seguinte script para o campo Script de arranque. O script de arranque também configura o servidor Apache para escutar 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. Expanda a secção Redes e, de seguida, especifique o seguinte:

      1. Para etiquetas de rede, adicione allow-ssh e allow-health-check.
      2. Para Interfaces de rede, clique na interface predefinida e configure os seguintes campos:
        • Rede: lb-network
        • Subnetwork: lb-subnet
        • Tipo de pilha de IP: IPv4 (pilha única)

    6. Clique em Criar.

  3. Crie um grupo de instâncias gerido. Aceda à página Grupos de instâncias na Google Cloud consola.

    Aceda a Grupos de instâncias

    1. Clique em Criar grupo de instâncias.
    2. Escolha Novo grupo de instâncias gerido (sem estado). Para mais informações, consulte o artigo Grupos de instâncias geridos sem estado ou com estado.
    3. No campo Nome, introduza ig-a.
    4. Para Localização, selecione Zona única.
    5. Para a Região, selecione us-west1.
    6. Para a Zona, selecione us-west1-a.
    7. Para Modelo de instância, selecione vm-a1.

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

      Para este exemplo, especifique as seguintes opções em Ajuste automático de escala:

      • Para o Modo de ajuste automático de escala, selecione Off:do not autoscale.
      • Para Número máximo de instâncias, introduza 2.

    9. Clique em Criar.

gcloud

As instruções gcloud neste guia pressupõem que está a usar o Cloud Shell ou outro ambiente com o bash instalado.

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

    O script de arranque também configura o servidor Apache para escutar na porta 8080 em vez da porta 80.

    Para processar o tráfego IPv4 e IPv6, use o seguinte comando.

    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'

    Em alternativa, 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 de instâncias gerido 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 o tráfego IPv4 e IPv6, siga estes passos:

  1. Crie uma VM fazendo POSTpedidos ao métodoinstances.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 os passos abaixo.

  1. Crie uma VM fazendo POSTpedidos ao métodoinstances.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 um pedido POST ao método instanceGroups.insert.

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

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

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

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

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

Crie uma VM de cliente

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

Para tráfego IPv4 e IPv6:

Consola

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

    Aceder às instâncias de VM

  2. Clique em Criar instância.

  3. Defina o Nome como vm-client-ipv6.

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

  5. Expanda a secção Opções avançadas e, de seguida, faça as seguintes alterações:

    • Expanda Redes e, em seguida, adicione o allow-ssh a Etiquetas de rede.
    • Em Interfaces de rede, clique em Editar, faça as seguintes alterações e, de seguida, clique em Concluído:
      • Rede: lb-network
      • Subnet: lb-subnet
      • Tipo de pilha de IP: IPv4 e IPv6 (dupla pilha)
      • IP interno principal: efémero (automático)
      • IP externo: efémero

  6. Clique em Criar.

gcloud

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

gcloud compute instances create vm-client-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 um pedido POST ao método instances.insert.

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

{
 "name": "vm-client-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 tráfego IPv4:

Consola

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

    Aceder às instâncias de VM

  2. Clique em Criar instância.

  3. Em Nome, introduza vm-client.

  4. Para Zone, introduza us-west1-a.

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

  6. Expanda Redes e, em seguida, configure os seguintes campos:

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

  7. Clique em Criar.

gcloud

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

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

API

Faça um pedido POST ao método instances.insert. Substitua PROJECT_ID pelo ID do seu projeto 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
  }

Configure os componentes do balanceador de carga

Crie um balanceador de carga para vários protocolos.

gcloud

  1. Crie uma verificação de funcionamento de HTTP para a porta 80. Esta verificação de funcionamento é usada para validar o estado 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 o 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 processar todo o tráfego de protocolo IPv6 suportado. Todas as portas têm de 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 processar todo o tráfego de protocolo IPv4 suportado. Todas as portas têm de 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 funcionamento fazendo um pedido POST ao método regionHealthChecks.insert. Substitua PROJECT_ID pelo ID do seu projetoGoogle 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 o serviço de back-end regional fazendo um pedido 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 o tráfego IPv6: crie a regra de encaminhamento fazendo um pedido POST ao métodoforwardingRules.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 um pedido POST ao forwardingRules.insert método:

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

Teste o balanceador de carga

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

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

Este teste contacta o balanceador de carga a partir de uma VM cliente separada, ou seja, não a partir de uma VM de back-end do balanceador de carga.

gcloud:IPv6

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

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

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

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

  3. Em clientes com conetividade IPv6, execute o seguinte comando. Substitua IPV6_ADDRESS pelo endereço IPv6 efémero 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 deve ter o seguinte aspeto:

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

gcloud:IPv4

  1. Ligue-se à instância de VM do 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 um pedido Web ao equilibrador de carga através de curl para contactar o respetivo endereço IP. Repita o pedido para poder ver que as respostas provêm de VMs de back-end diferentes. O nome da VM que gera a resposta é apresentado no texto na resposta HTML em virtude do conteúdo de /var/www/html/index.html em cada VM de back-end. As respostas esperadas têm o seguinte aspeto: Page served from: vm-a1.

    curl http://10.1.2.99

    A regra de encaminhamento está configurada para publicar 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, da seguinte forma:

    curl http://10.1.2.99:80

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

Este teste demonstra um comportamento esperado: pode enviar um ping para o endereço IP do balanceador de carga.

gcloud:IPv6

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

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

  2. Tente enviar um ping para o endereço IPv6 do balanceador de carga. Substitua IPV6_ADDRESS pelo endereço IPv6 efémero na regra de encaminhamento fr-ilb-ipv6.

    Repare que recebe uma resposta e que 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 é o seguinte:

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

    O resultado é semelhante ao seguinte:

    @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. Ligue-se à instância de VM do cliente.

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

  2. Tente enviar um ping para o endereço IPv4 do equilibrador de carga. Repare que recebe uma resposta e que o comando ping funciona neste exemplo.

    ping 10.1.2.99

    O resultado é o seguinte:

    @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

Opções de configuração adicionais

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

Pode reservar um endereço IP interno estático para o seu exemplo. Esta 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 seu exemplo de equilibrador de carga têm de continuar a estar localizados na região us-west1.

O diagrama seguinte mostra a arquitetura deste exemplo.

Equilibrar o tráfego com base nos protocolos, com serviços de back-end para gerir a distribuição de ligações a um único grupo de instâncias zonais.
Um Network Load Balancer de passagem interno para vários protocolos que usa um endereço IP interno estático (clique para aumentar).

Também pode considerar usar as seguintes configurações de regras 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

Reserve um endereço IPv4 interno estático

Reserve um endereço IP interno estático para 10.1.2.99 e defina a respetiva 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 seu projetoGoogle Cloud .

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

O corpo do pedido tem de incluir o addressType, que deve ser INTERNAL, o name do endereço e o subnetwork ao qual o endereço IP pertence. Tem de especificar o 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"
}

Configure os componentes do balanceador de carga

Configure três equilibradores 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 corresponda às regras de encaminhamento TCP ou UDP é processado pela regra de encaminhamento L3_DEFAULT.
  • Todos os três balanceadores de carga partilham o mesmo endereço IP interno estático (internal-lb-ipv4) nas respetivas regras de encaminhamento.

Crie o primeiro balanceador de carga

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

gcloud

  1. Crie o serviço de back-end para o 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 para o serviço de back-end. Use o endereço IP interno reservado estático (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 o serviço de back-end regional fazendo um pedido POST ao regionBackendServices.insert método. Substitua PROJECT_ID pelo ID do seu projetoGoogle 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"
}

Crie o segundo balanceador de carga

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

gcloud

  1. Crie o 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 para o serviço de back-end. Use o endereço IP interno reservado estático (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 o serviço de back-end regional fazendo um pedido POST ao regionBackendServices.insert método. Substitua PROJECT_ID pelo ID do seu projetoGoogle 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 encaminhamento fazendo um pedido POST ao métodoforwardingRules.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"
}

Crie o terceiro balanceador de carga

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

gcloud

Crie a regra de encaminhamento com o protocolo definido como L3_DEFAULT para processar todo o outro tráfego de protocolo IPv4 suportado. Use o endereço IP interno reservado estático (internal-lb-ipv4) como 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 encaminhamento fazendo um pedido POST ao método forwardingRules.insert. Substitua PROJECT_ID pelo ID do seu projetoGoogle 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"
}

Teste o balanceador de carga

Para testar o equilibrador de carga, siga os passos na secção anterior.

O que se segue?