Crie um serviço com balanceamento de carga

Este tutorial mostra como, enquanto produtor de serviços, pode criar um serviço simples que usa um Network Load Balancer de encaminhamento interno. Por predefinição, um Network Load Balancer de encaminhamento interno está disponível apenas a partir da rede de VPC que o aloja.

Este tutorial destina-se a arquitetos de nuvem, arquitetos de rede, administradores de rede e administradores de TI.

Objetivos

• Configure a rede para os recursos do produtor de serviços
• Crie recursos de VM para o back-end do balanceador de carga
• Configure os componentes do balanceador de carga
• Teste o acesso ao balanceador de carga

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

• Cloud Load Balancing
• Compute Engine

Para gerar uma estimativa de custos com base na sua utilização prevista, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação sem custo financeiro.

Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.

Antes de começar

1. Crie ou selecione um projeto para usar nos recursos do produtor de serviços. Este projeto é referido nos tutoriais posteriores como PRODUCER_PROJECT

1. In the Google Cloud console, go to the project selector page.

   Go to project selector

2. Select or create a Google Cloud project.

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator role (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

2. Enable the Compute Engine API.

   Roles required to enable APIs

   To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

   Enable the API

3. Make sure that you have the following role or roles on the project: Compute Engine > Compute Network Admin, Compute Engine > Compute Security Admin, Compute Engine > Compute Instance Admin

   Check for the roles

   1. In the Google Cloud console, go to the IAM page.

      Go to IAM
   2. Select the project.

   3. In the Principal column, find all rows that identify you or a group that you're included in. To learn which groups you're included in, contact your administrator.

   4. For all rows that specify or include you, check the Role column to see whether the list of roles includes the required roles.

   Grant the roles

   1. In the Google Cloud console, go to the IAM page.

      Aceder ao IAM
   2. Selecione o projeto.
   3. Clique em Conceder acesso.

   4. No campo Novos responsáveis, introduza o identificador do utilizador. Normalmente, este é o endereço de email de uma Conta Google.

   5. Clique em Selecionar uma função e, de seguida, pesquise a função.
   6. Para conceder funções adicionais, clique em Adicionar outra função e adicione cada função adicional.
   7. Clique em Guardar.

Configure a rede

As secções seguintes explicam como criar uma rede, uma sub-rede e regras de firewall para o serviço.

Configure uma rede e uma sub-rede

Para criar a rede de serviços e a sub-rede para o equilibrador de carga, conclua os passos nas secções seguintes.

Consola

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

   Aceda a redes de VPC

2. Clique em Criar rede de VPC.

3. Em Nome, introduza service-network.

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

5. Na secção Nova sub-rede, introduza as seguintes informações.

   1. Em Nome, introduza service-subnet.
   2. Para Região, selecione a região que quer usar.
   3. Para o Tipo de pilha de IP, selecione IPv4 (pilha única).
   4. Para o intervalo de IPv4, introduza 10.10.10.0/24.
   5. Clique em Concluído.

6. Clique em Criar.

gcloud

1. Crie uma rede VPC de modo personalizado:

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

2. Na rede service-network, crie uma sub-rede.

   gcloud compute networks subnets create service-subnet \
       --network=service-network \
       --range=10.10.10.0/24 \
       --region=REGION
   

   Substitua REGION pela região que quer usar.

Configure regras de firewall

Crie regras de firewall para permitir o seguinte tráfego:

• fw-allow-subnet: permite que o tráfego de 10.10.10.0/24 alcance outros recursos em 10.10.10.0/24.
• fw-allow-ssh: permite que o tráfego SSH de 0.0.0.0/0 alcance VMs que tenham a etiqueta de rede allow-ssh.

• fw-allow-healthcheck: permite que o tráfego dos sistemas de verificação de estado atinja as VMs que têm a etiqueta de rede allow-healthcheck. Google Cloud

Consola

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

   Aceder às políticas de firewall

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

   • Em Nome, introduza fw-allow-subnet.
   • Para Rede, selecione service-network.
   • Para Prioridade, introduza 1000.
   • Para Direção do tráfego, selecione Entrada.
   • Para Ação em caso de correspondência, selecione Permitir.
   • Para Segmentações, selecione Todas as instâncias na rede.
   • Para Filtro de origem, selecione Intervalos IPv4.
   • Para Intervalos de IPv4 de origem, introduza 10.10.10.0/24.
   • Para Protocolos e portas, selecione Permitir tudo.

3. Clique em Criar.

4. Para permitir ligações SSH de entrada, clique em Criar regra de firewall e use as seguintes definições:

   • Em Nome, introduza fw-allow-ssh.
   • Para Rede, selecione service-network.
   • Para Prioridade, introduza 1000.
   • Para Direção do tráfego, selecione Entrada.
   • Para Ação em caso de correspondência, selecione Permitir.
   • Em Segmentações, selecione Etiquetas de segmentação especificadas.
   • Para Etiquetas de segmentação, introduza allow-ssh.
   • Para Filtro de origem, selecione Intervalos IPv4.
   • Para Intervalos de IPv4 de origem, introduza 0.0.0.0/0.
   • Para Protocolos e portas, selecione Protocolos e portas especificados, selecione a caixa de verificação TCP. Em Portas, introduza 22.

5. Clique em Criar.

6. Para permitir Google Cloud verificações de funcionamento, clique em Criar regra da firewall e use as seguintes definições:

   • Em Nome, introduza fw-allow-healthcheck.
   • Para Rede, selecione service-network.
   • Para Prioridade, introduza 1000.
   • Para Direção do tráfego, selecione Entrada.
   • Para Ação em caso de correspondência, selecione Permitir.
   • Em Segmentações, selecione Etiquetas de segmentação especificadas.
   • Para Etiquetas de segmentação, introduza allow-healthcheck.
   • Para Filtro de origem, selecione Intervalos IPv4.
   • Para Intervalos IPv4 de origem, introduza 130.211.0.0/22 e 35.191.0.0/16.
   • Para Protocolos e portas, selecione Permitir tudo.

7. Clique em Criar.

gcloud

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

   gcloud compute firewall-rules create fw-allow-subnet \
       --network=service-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=10.10.10.0/24 \
       --rules=tcp,udp,icmp
   

1. Crie a regra de firewall fw-allow-ssh para permitir a conetividade SSH a VMs com a etiqueta de rede allow-ssh.

   gcloud compute firewall-rules create fw-allow-ssh \
       --network=service-network \
       --action=allow \
       --direction=ingress \
       --source-ranges=0.0.0.0/0 \
       --target-tags=allow-ssh \
       --rules=tcp:22
   

1. Crie a regra fw-allow-healthcheck para permitir Google Cloud verificações de funcionamento.

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

Crie recursos de VM para o back-end do balanceador de carga

Crie as VMs e o grupo de instâncias a usar com o balanceador de carga.

Crie VMs de back-end

O serviço que está a criar é executado em duas VMs para maior disponibilidade: vm-1 e vm-2. As VMs estão na mesma zona, mas, num ambiente de produção, recomendamos a utilização de várias zonas.

Além de criar as VMs, seguir estes passos permite fazer o seguinte:

• Configura as VMs para usar as etiquetas de rede que configurou como destinos nas regras de firewall e uma etiqueta de rede adicional (allow-nat) que é usada mais tarde.

• Instala, configura e inicia o serviço Apache.

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

4. Para Região e Zona, selecione uma região e uma zona nessa região.

5. No menu de navegação, aceda a SO e armazenamento.

6. No painel Sistema operativo e armazenamento, certifique-se de que Debian GNU/Linux 12 (bookworm) está selecionado para o disco de arranque. Se precisar de selecionar uma imagem diferente, clique em Alterar.

7. No menu de navegação, aceda a Rede.

8. Para etiquetas de rede, introduza allow-ssh, allow-healthcheck e allow-nat.

9. Para Interfaces de rede, selecione o seguinte:

   • Para Rede, selecione service-network.
   • Para Sub-rede, selecione service-subnet.
   • Para o Tipo de pilha de IP, selecione IPv4 (pilha única).
   • Para o Endereço IPv4 interno principal, selecione Efémero (automático).
   • Para Endereço IPv4 externo, selecione Efémero.

10. No menu de navegação, aceda a Avançadas.

11. Na secção Automatização, no campo Script de arranque, introduza o seguinte script.

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

12. Clique em Criar.

13. Repita estes passos para criar outra VM denominada vm-2 na mesma região e zona que vm-1.

gcloud

1. Crie duas VMs executando os seguintes comandos:

   gcloud compute instances create vm-1 \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-healthcheck,allow-nat \
       --subnet=service-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'
   

   gcloud compute instances create vm-2 \
       --zone=ZONE \
       --image-family=debian-12 \
       --image-project=debian-cloud \
       --tags=allow-ssh,allow-healthcheck,allow-nati \
       --subnet=service-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'
   

   Substitua ZONE pela zona que quer usar.

Crie um grupo de instâncias

Para usar as VMs num back-end do balanceador de carga, tem de adicionar as VMs a um grupo de instâncias.

Consola

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

   Aceda a Grupos de instâncias

2. Clique em Criar grupo de instâncias.

3. No painel de navegação, clique em Novo grupo de instâncias não gerido.

4. Em Nome, introduza ig-1.

5. Na secção Localização, selecione a mesma região e zona que as suas VMs.

6. Para Rede, selecione service-network.

7. Para Sub-rede, selecione service-subnet.

8. Na secção Instâncias de VM, adicione vm-1 e vm-2 ao grupo de instâncias.

9. Clique em Criar.

gcloud

1. Crie um grupo de instâncias não gerido:

   gcloud compute instance-groups unmanaged create ig-1 \
       --zone=ZONE
   

   Substitua ZONE pela zona que contém as VMs.

2. Adicione as VMs ao grupo de instâncias:

   gcloud compute instance-groups unmanaged add-instances ig-1 \
       --zone=ZONE \
       --instances=vm-1,vm-2
   

Configure os componentes do balanceador de carga

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

• Verificação de saúde. Usa uma verificação de funcionamento de HTTP que procura um código de estado HTTP 200 OK.

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

• Regra de encaminhamento. Cria uma única regra de encaminhamento interno, service-rule.

• Endereço IP interno. Especifica um endereço IP interno, 10.10.10.99, quando cria a regra de encaminhamento.

Consola

Inicie a configuração

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

   Aceda ao balanceamento de carga

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

Configuração básica

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

• Em Nome do balanceador de carga, introduza service-lb.
• Para Região, selecione a mesma região que as suas VMs.
• Para Rede, selecione service-network.

Configure os back-ends

1. Clique em Configuração de back-end.
2. Na lista Verificação de funcionamento, clique em Criar uma verificação de funcionamento e introduza as seguintes informações:
   • Em Nome:, introduza hc-http-80.
   • Para Protocolo:, selecione HTTP.
   • Em Porta:, introduza 80.
   • Para Protocolo de proxy:, selecione NONE.
   • Em Caminho do pedido:, introduza /.
3. Clique em Criar.
4. Na secção Novo back-end de Back-ends, selecione IPv4 (único).
5. Em Grupo de instâncias, selecione o grupo de instâncias ig-1 e clique em Concluído.
6. Verifique se existe uma marca de verificação azul junto a Configuração de back-end antes de continuar.

Configure o frontend

1. Clique em Configuração do front-end.
2. Na secção Novo endereço IP e porta de front-end, faça o seguinte:
   1. Em Nome, introduza service-rule.
   2. Para Sub-rede, selecione service-subnet.
   3. Na secção Finalidade do IP interno, na lista Endereço IP, selecione Criar endereço IP e introduza as seguintes informações:
      • Em Nome, introduza service-rule-ip.
      • Para Versão de IP, selecione IPv4.
      • Para Endereço IP estático, selecione Permitir-me escolher.
      • Para Endereço IP personalizado, introduza 10.10.10.99.
   4. Clique em Reservar.
   5. Para Portas, selecione Única e, em seguida, em Números de portas, introduza 80.
   6. Clique em Concluído.
   7. Verifique se existe uma marca de verificação azul junto a Configuração do frontend antes de continuar.

Reveja a configuração

1. Clique em Rever e finalizar.
2. Reveja as definições de configuração do equilibrador de carga.
3. Clique em Criar.

gcloud

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

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

   Substitua REGION pela mesma região que as VMs de back-end.

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

   gcloud compute backend-services create service-lb \
       --load-balancing-scheme=internal \
       --protocol=tcp \
       --region=REGION \
       --health-checks=hc-http-80 \
       --health-checks-region=REGION
   

   Substitua REGION pela mesma região que as VMs de back-end.

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

   gcloud compute backend-services add-backend service-lb \
       --region=REGION \
       --instance-group=ig-1 \
       --instance-group-zone=ZONE
   

   Substitua o seguinte:

   • REGION: a mesma região que as VMs de back-end.
   • ZONE: a mesma zona que as VMs de back-end.

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

   gcloud compute forwarding-rules create service-rule \
       --region=REGION \
       --load-balancing-scheme=internal \
       --network=service-network \
       --subnet=service-subnet \
       --address=10.10.10.99 \
       --ip-protocol=TCP \
       --ports=80 \
       --backend-service=service-lb \
       --backend-service-region=REGION
   

   Substitua REGION pela mesma região que as VMs de back-end.

Teste o acesso ao balanceador de carga

Para testar se o balanceador de carga está a funcionar, crie uma VM de teste e envie um pedido a partir desta para o balanceador de carga.

Crie uma VM de cliente para testes

Crie uma VM cliente na mesma região que as VMs de back-end (servidor).

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 producer-test.

4. Para Região, selecione a mesma região que as VMs de back-end.

5. Em Zona, selecione uma zona nessa região.

6. Clique em Rede e configure os seguintes campos:

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

7. Clique em Criar.

gcloud

gcloud compute instances create producer-test \
    --zone=ZONE \
    --image-family=debian-12 \
    --image-project=debian-cloud \
    --tags=allow-ssh \
    --subnet=service-subnet

Substitua ZONE por uma zona que esteja na mesma região que as VMs de back-end.

Teste a conetividade

Este teste contacta o balanceador de carga a partir de uma VM do cliente. O comportamento esperado é que o tráfego seja distribuído pelas VMs de back-end do balanceador de carga.

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

   gcloud compute ssh producer-test --zone=ZONE
   

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

   curl -s http://10.10.10.99
   

O que se segue?

• Torne o serviço acessível a partir de outras redes VPC