Configurar um balanceador de carga de rede de passagem interna com NEGs zonais

Neste guia, mostramos como implantar um balanceador de carga de rede de passagem interna com back-ends de grupo de endpoints de rede (NEG, na sigla em inglês) zonal. Os NEGs zonais são recursos zonais que representam conjuntos de endereços IP ou combinações de endereço IP/porta para recursos do Google Cloud em uma sub-rede. Os NEGs permitem criar agrupamentos lógicos de endereços IP ou combinações de endereço IP/porta que representam serviços de software em vez de VMs inteiras.

Antes de seguir as instruções deste guia, familiarize-se com os itens abaixo:

Os balanceadores de carga de rede de passagem interna são compatíveis apenas com NEGs zonais com endpoints GCE_VM_IP.

Permissões

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

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

Para mais informações, consulte estes guias:

Visão geral da configuração

Neste guia, mostramos como configurar e testar um balanceador de carga de rede de passagem interna com back-ends de NEG zonal GCE_VM_IP. Nas etapas desta seção, veja como configurar o seguinte:

  1. Uma rede VPC de amostra chamada lb-network com uma sub-rede personalizada
  2. Regras de firewall que permitem conexões de entrada com VMs de back-end
  3. Quatro VMs:
    • VMs vm-a1 e vm-a2 na zona us-west1-a
    • VMs vm-c1 e vm-c2 na zona us-west1-c
  4. Dois NEGs zonais de back-end, neg-a na zona us-west1-a e neg-c na zona us-west1-c. Cada NEG terá os seguintes endpoints:
    • neg-a contém estes dois endpoints:
      • Endereço IP interno da VM vm-a1
      • Endereço IP interno da VM vm-a2
    • neg-c contém estes dois endpoints:
      • Endereço IP interno da VM vm-c1
      • Endereço IP interno da VM vm-c2
  5. Uma VM cliente (vm-client) em us-west1-a para testar conexões
  6. Os componentes do balanceador de carga de rede de passagem interna a seguir:
    • Um serviço de back-end interno na região us-west1 para gerenciar a distribuição de conexões para os dois NEGs zonais
    • Uma regra de encaminhamento interna e um endereço IP interno para o front-end do balanceador de carga

A arquitetura deste exemplo é a seguinte:

Configuração do balanceador de carga de rede de passagem interna com NEGs zonais
Configuração do balanceador de carga de rede de passagem interna com NEGs zonais

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

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

As VMs de back-end, NEGs zonal e os componentes do balanceador de carga deste exemplo estão localizados nesta região e sub-rede:

  • Região: us-west1
  • Sub-rede: lb-subnet, com intervalo de endereços IP principal 10.1.2.0/24

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

Console

  1. Acesse a página "Redes VPC" no Console do Google Cloud.
    Acessar a página "Redes VPC"
  2. Clique em Criar rede VPC.
  3. Informe um Nome de 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
      • Intervalo de endereços IP: 10.1.2.0/24
      • Clique em Concluído.
  5. Clique em Criar.

gcloud

  1. Crie a rede VPC personalizada:

    gcloud compute networks create lb-network --subnet-mode=custom
    1. Na rede lb-network, crie uma sub-rede para VMs de back-end na região us-west1:
    gcloud compute networks subnets create lb-subnet \
    --network=lb-network \
    --range=10.1.2.0/24 \
    --region=us-west1

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 no intervalo 10.1.2.0/24. Essa regra permite o tráfego de entrada de qualquer cliente localizado em lb-subnet.

  • 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. É possível escolher um intervalo de IP de origem mais restritivo para essa regra, por exemplo, especificando apenas os intervalos de IP do sistema que iniciará as sessões SSH. Neste exemplo, usamos a tag allow-ssh de destino para identificar as VMs a que isso se aplicará.

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. Clique em Criar regra de firewall e insira as seguintes informações para criar a regra que permite o tráfego de sub-rede:
    • Nome: fw-allow-lb-access
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver 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: permitir todos
  3. Clique em Criar.
  4. Clique em Criar regra de firewall novamente para criar a regra que permite conexões SSH de entrada:
    • Nome: fw-allow-ssh
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver correspondência: permitir
    • Destinos: tags de destino especificadas
    • Tags de meta: allow-ssh
    • Filtro de origem: intervalos IPv4
    • Intervalos IPv4 de origem: 0.0.0.0/0
    • Protocolos e portas: escolha Protocolos e portas especificados e digite: tcp:22
  5. Clique em Criar.
  6. Clique em Criar regra de firewall pela terceira vez para criar uma regra que permita as verificações de integridade do Google Cloud:
    • Name: fw-allow-health-check
    • Rede: lb-network
    • Prioridade: 1000
    • Direção do tráfego: entrada
    • Ação se houver correspondência: permitir
    • Destinos: tags de destino especificadas
    • Tags de meta: allow-health-check
    • Filtro de origem: intervalos IPv4
    • Intervalos IPv4 de origem: 130.211.0.0/22 e 35.191.0.0/16
    • Protocolos e portas: permitir todos
  7. Clique em Criar.

gcloud

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

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

  2. Crie a regra de firewall fw-allow-ssh que permita a conectividade SSH para VMs com a tag de rede allow-ssh. Se você omitir source-ranges, o Google Cloud interpretará que a regra autoriza a conexão proveniente de qualquer origem.

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

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

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

Criar back-ends de NEG

Para demonstrar a natureza regional dos balanceadores de carga de rede de passagem interna, este exemplo usa dois back-ends de NEG zonal, neg-a e neg-c, nas zonas us-west1-a e us- west1-c. O tráfego é balanceado por carga nos NEGs e nos endpoints de cada NEG.

Criar VMs

Para ser compatível com este exemplo, cada uma das quatro VMs executa um servidor da Web Apache que detecta as seguintes portas TCP: 80, 8008, 8080, 8088, 443 e 8443.

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

Endereços IP externos não são necessários para VMs de back-end. No entanto, eles são úteis para este exemplo porque permitem que as VMs façam o download do Apache pela Internet e permitem que você se conecte usando SSH. Por padrão, o Apache é configurado para ser vinculado a qualquer endereço IP. Os balanceadores de carga de rede de passagem interna entregam pacotes preservando o IP de destino.

Verifique se o software servidor executado nas suas VMs está escutando no endereço IP da regra de firewall interna do balanceador de carga.

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

Console

Criar VMs

  1. Acesse a página Instâncias de VM no Console do Google Cloud.
    Acessar a página "Instâncias de VM"
  2. Repita as etapas a seguir para criar quatro VMs. Use estas combinações de nome e zona.
    • Nome: vm-a1, zona: us-west1-a
    • Nome: vm-a2, zona: us-west1-a
    • Nome: vm-c1, zona: us-west1-c
    • Nome: vm-c2, zona: us-west1-c
  3. Clique em Criar instância.
  4. Defina o Nome como indicado na etapa 2.
  5. Em Região, escolha us-west1 e escolha uma Zona, como indicado na etapa 2.
  6. Na seção Disco de inicialização, verifique se o sistema operacional Debian e a versão 10 (buster) estão selecionados para as opções de disco de inicialização. Clique em Escolher para alterar a imagem se necessário.

  7. Clique em Opções avançadas e faça as seguintes alterações:

    • Clique em Rede e adicione as seguintes tags de rede: allow-ssh e allow-health-check.
    • Clique em Editar em Interfaces de rede, faça as seguintes alterações e clique em Concluído:
      • Rede: lb-network
      • Sub-rede: lb-subnet
      • IP interno primário: temporário (automático)
      • IP externo: temporário

    • Clique em Gerenciamento. No campo Script de inicialização, copie e cole o conteúdo do script a seguir, que é o mesmo para as quatro VMs:

      #! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed

  8. Clique em Criar.

gcloud

Execute o seguinte comando quatro vezes para criar as quatro VMs, usando estas quatro combinações para [VM-NAME] e [ZONE]. O conteúdo do script é o mesmo para as quatro VMs.

  • [VM-NAME] de vm-a1 e [ZONE] de us-west1-a
  • [VM-NAME] de vm-a2 e [ZONE] de us-west1-a
  • [VM-NAME] de vm-c1 e [ZONE] de us-west1-c

  • [VM-NAME] de vm-c2 e [ZONE] de us-west1-c

    gcloud compute instances create VM-NAME \
    --zone=ZONE \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh,allow-health-check \
    --subnet=lb-subnet \
    --metadata=startup-script='#! /bin/bash
if [ -f /etc/startup_script_completed ]; then
exit 0
fi
apt-get update
apt-get install apache2 -y
a2ensite default-ssl
a2enmod ssl
file_ports="/etc/apache2/ports.conf"
file_http_site="/etc/apache2/sites-available/000-default.conf"
file_https_site="/etc/apache2/sites-available/default-ssl.conf"
http_listen_prts="Listen 80\nListen 8008\nListen 8080\nListen 8088"
http_vh_prts="*:80 *:8008 *:8080 *:8088"
https_listen_prts="Listen 443\nListen 8443"
https_vh_prts="*:443 *:8443"
vm_hostname="$(curl -H "Metadata-Flavor:Google" \
http://metadata.google.internal/computeMetadata/v1/instance/name)"
echo "Page served from: $vm_hostname" | \
tee /var/www/html/index.html
prt_conf="$(cat "$file_ports")"
prt_conf_2="$(echo "$prt_conf" | sed "s|Listen 80|${http_listen_prts}|")"
prt_conf="$(echo "$prt_conf_2" | sed "s|Listen 443|${https_listen_prts}|")"
echo "$prt_conf" | tee "$file_ports"
http_site_conf="$(cat "$file_http_site")"
http_site_conf_2="$(echo "$http_site_conf" | sed "s|*:80|${http_vh_prts}|")"
echo "$http_site_conf_2" | tee "$file_http_site"
https_site_conf="$(cat "$file_https_site")"
https_site_conf_2="$(echo "$https_site_conf" | sed "s|_default_:443|${https_vh_prts}|")"
echo "$https_site_conf_2" | tee "$file_https_site"
systemctl restart apache2
touch /etc/startup_script_completed'

Criar GCE_VM_IP NEGs zonais

Os NEGs (neg-a e neg-c) precisam ser criados nas mesmas zonas que as VMs criadas na etapa anterior.

Console

Para criar um grupo de endpoints de rede zonal:

  1. Acesse a página "Grupos de endpoints da rede" no Google Cloud Console.
    Acessar a página "Grupos de endpoints de rede"
  2. Clique em Criar grupo de endpoints de rede.
  3. Insira um Nome para o NEG zonal: neg-a
  4. Selecione o Tipo de grupo de endpoints da rede: Grupo de endpoints da rede (Zonal).
  5. Selecione Rede: lb-network
  6. Selecione a Sub-rede: lb-subnet
  7. Selecione a Zona: us-west1-a
  8. Clique em Criar.
  9. Repita essas etapas para criar um segundo NEG zonal chamado neg-c, na zona us-west1-c.

Adicione endpoints ao NEG zonal:

  1. Acesse a página "Grupos de endpoints da rede" no Google Cloud Console.
    Acessar os grupos de endpoints de rede
  2. Clique no Nome do primeiro grupo de endpoints de rede criado na etapa anterior (neg-a). Você verá a página Detalhes do grupo de endpoints de rede.

  3. Na seção Endpoints da rede neste grupo, clique em Adicionar endpoint da rede. Você verá a página Adicionar endpoint de rede.

    1. Clique em Instância de VM e selecione vm-a1 para adicionar os endereços IP internos como endpoints da rede.
    2. Clique em Criar.
    3. Clique mais uma vez em Adicionar endpoint da rede e, em Instância de VM, selecione vm-a2.
    4. Clique em Criar.

  4. Clique no Nome do segundo grupo de endpoints de rede criado na etapa anterior (neg-c). Você verá a página Detalhes do grupo de endpoints de rede.

  5. Na seção Endpoints da rede neste grupo, clique em Adicionar endpoint da rede. Você verá a página Adicionar endpoint de rede.

    1. Clique em Instância de VM e selecione vm-c1 para adicionar os endereços IP internos como endpoints da rede.
    2. Clique em Criar.
    3. Clique mais uma vez em Adicionar endpoint da rede e, em Instância de VM, selecione vm-c2.
    4. Clique em Criar.

gcloud

  1. Crie um NEG zonal GCE_VM_IP chamado neg-a em us-west1-a usando o comando gcloud compute network-endpoint-groups create:

    gcloud compute network-endpoint-groups create neg-a \
    --network-endpoint-type=gce-vm-ip \
    --zone=us-west1-a \
    --network=lb-network \
    --subnet=lb-subnet

  2. Adicione endpoints a neg-a:

    gcloud compute network-endpoint-groups update neg-a \
    --zone=us-west1-a \
    --add-endpoint='instance=vm-a1' \
    --add-endpoint='instance=vm-a2'

  3. Crie um NEG zonal GCE_VM_IP chamado neg-c em us-west1-c usando o comando gcloud compute network-endpoint-groups create:

    gcloud compute network-endpoint-groups create neg-c \
    --network-endpoint-type=gce-vm-ip \
    --zone=us-west1-c \
    --network=lb-network \
    --subnet=lb-subnet

  4. Adicione endpoints a neg-c:

    gcloud compute network-endpoint-groups update neg-c \
    --zone=us-west1-c \
    --add-endpoint='instance=vm-c1' \
    --add-endpoint='instance=vm-c2'

Configurar componentes do balanceador de carga

Estas etapas configuram todos os componentes do balanceador de carga de rede de passagem interna:

  • Serviço de back-end: para este exemplo, você precisa transmitir o tráfego HTTP por meio do balanceador de carga. Portanto, você precisa usar TCP, não UDP.

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

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

Console

gcloud

  1. Crie uma nova verificação de integridade HTTP regional.

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

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

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

  3. Adicione os dois NEGs zonais, neg-a e neg-c, ao serviço de back-end:

    gcloud compute backend-services add-backend bs-ilb \
    --region=us-west1 \
    --network-endpoint-group=neg-a \
    --network-endpoint-group-zone=us-west1-a

    gcloud compute backend-services add-backend bs-ilb \
    --region=us-west1 \
    --network-endpoint-group=neg-c \
    --network-endpoint-group-zone=us-west1-c

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

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

Testar o balanceador de carga

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

Criar uma VM do cliente de teste

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

Console

  1. Acesse a página Instâncias de VM no Console do Google Cloud.
    Acessar a página "Instâncias de VM"
  2. Clique em Criar instância.
  3. Defina o Nome como vm-client.
  4. Defina a Zona como us-west1-a.
  5. Clique em Opções avançadas e faça as seguintes alterações:
    • Clique em Rede e adicione allow-ssh a Tags de rede.
    • Clique no botão de editar em Interfaces de rede e faça as alterações a seguir. Depois, clique em Concluído:
      • Rede: lb-network
      • Sub-rede: lb-subnet
      • 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 \
    --zone=us-west1-a \
    --image-family=debian-10 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=lb-subnet

Enviar tráfego ao balanceador de carga

Siga as etapas abaixo para se conectar ao balanceador de carga.

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

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

  2. Faça uma solicitação da Web para o balanceador de carga usando curl para contatar o endereço IP dele. Repita a solicitação para ver que as respostas provêm de diferentes VMs de back-end. O nome da VM que gera a resposta é exibido no texto na resposta HTML, em virtude do conteúdo de /var/www/html/index.html em cada VM de back-end. As respostas esperadas são assim: Page served from: vm-a1 e Page served from: vm-a2.

    curl http://10.1.2.99

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

    curl http://10.1.2.99:8008

A seguir