Criar um serviço com balanceamento de carga

Neste tutorial, mostramos como você, como um produtor de serviços, pode criar um serviço simples que usa um balanceador de carga de rede de passagem interna. Por padrão, um balanceador de carga de rede de passagem interna só está disponível na rede VPC que o hospeda.

Este tutorial é destinado a arquitetos de nuvem e de rede, administradores de rede e de TI.

Objetivos

• Configurar a rede para os recursos do produtor de serviços
• Criar recursos de VM para o back-end do balanceador de carga
• Configurar os componentes do balanceador de carga
• Testar o acesso ao balanceador de carga

Custos

Neste documento, você vai usar os seguintes componentes faturáveis do Google Cloud:

• Cloud Load Balancing
• Compute Engine

Para gerar uma estimativa de custo baseada na sua projeção de uso, utilize a calculadora de preços.

Novos usuários do Google Cloud podem estar qualificados para um teste sem custo financeiro.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Para mais informações, consulte Limpeza.

Antes de começar

1. Crie ou selecione um projeto para usar nos recursos do produtor de serviços. Nos tutoriais posteriores, esse projeto será chamado de 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.

      Acessar o IAM
   2. Selecione o projeto.
   3. Clique em Conceder acesso.

   4. No campo Novos principais, digite seu identificador de usuário. Normalmente, é o endereço de e-mail de uma Conta do Google.

   5. Clique em Selecionar um papel e pesquise o papel.
   6. Para conceder outros papéis, adicione-os clicando em Adicionar outro papel.
   7. Clique em Salvar.

Configurar rede

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

Configurar uma rede e uma sub-rede

Para criar a rede e a sub-rede de serviço para o balanceador de carga, siga as etapas nas seções a seguir.

Console

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

   Acessar redes VPC

2. Clique em Criar rede VPC.

3. Em Nome, insira service-network.

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

5. Na seção Nova sub-rede, insira as seguintes informações:

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

6. Clique em Criar.

gcloud

1. Crie uma rede VPC personalizada:

   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 você quer usar.

Configurar regras de firewall

Crie regras de firewall para permitir o tráfego a seguir:

• 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 tag de rede allow-ssh.

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

Console

1. No console do Google Cloud , acesse a página Políticas de firewall.

   Acesse as políticas de firewall

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

   • Em Nome, insira fw-allow-subnet.
   • Em Rede, selecione service-network.
   • Em Prioridade, digite 1000.
   • Em Direção de tráfego, selecione Entrada.
   • Em Ação se houver correspondência, selecione Permitir.
   • Em Destinos, selecione Todas as instâncias na rede.
   • Em Filtro de origem, selecione Intervalos IPv4.
   • Em Intervalos IPv4 de origem, insira 10.10.10.0/24.
   • Em Protocolos e portas, selecione Permitir todos.

3. Clique em Criar.

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

   • Em Nome, insira fw-allow-ssh.
   • Em Rede, selecione service-network.
   • Em Prioridade, digite 1000.
   • Em Direção de tráfego, selecione Entrada.
   • Em Ação se houver correspondência, selecione Permitir.
   • Em Destinos, selecione Specified target tags.
   • Em Tags de destino, insira allow-ssh.
   • Em Filtro de origem, selecione Intervalos IPv4.
   • Em Intervalos IPv4 de origem, insira 0.0.0.0/0.
   • Em Protocolos e portas, selecione Protocolos e portas especificados e marque a caixa de seleção TCP. Em Portas, insira 22.

5. Clique em Criar.

6. Para permitir as verificações de integridade do Google Cloud , clique em Criar regra de firewall e use as seguintes configurações:

   • Em Nome, insira fw-allow-healthcheck.
   • Em Rede, selecione service-network.
   • Em Prioridade, digite 1000.
   • Em Direção de tráfego, selecione Entrada.
   • Em Ação se houver correspondência, selecione Permitir.
   • Em Destinos, selecione Specified target tags.
   • Em Tags de destino, insira allow-healthcheck.
   • Em Filtro de origem, selecione Intervalos IPv4.
   • Em Intervalos IPv4 de origem, insira 130.211.0.0/22 e 35.191.0.0/16.
   • Em Protocolos e portas, selecione Permitir todos.

7. Clique em Criar.

gcloud

1. Crie a regra de firewall fw-allow-subnet para permitir a comunicação pela 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 que permita a conectividade SSH para VMs com a tag 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 verificações de integridade do Google Cloud.

   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
   

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

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

Criar VMs de back-end

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

Além de criar as VMs, seguir estas etapas realiza o seguinte:

• Configura as VMs para usar as tags de rede que você configurou como destinos nas regras de firewall e uma tag de rede adicional (allow-nat) que será usada mais tarde.

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

Console

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

   Acessar Instâncias de VM

2. Clique em Criar instância.

3. Em Nome, insira vm-1.

4. Em Região e Zona, selecione uma região e uma zona dentro dela.

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

6. No painel Sistema operacional e armazenamento, verifique se Debian GNU/Linux 12 (bookworm) está selecionado para o disco de inicialização. Se precisar selecionar outra imagem, clique em Mudar.

7. No menu de navegação, acesse Rede.

8. Em Tags de rede, insira allow-ssh, allow-healthcheck e allow-nat.

9. Em Interfaces de rede, selecione o seguinte:

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

10. No menu de navegação, acesse Avançado.

11. Na seção Automação, no campo Script de inicialização, insira o script a seguir.

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

12. Clique em Criar.

13. Repita essas etapas para criar outra VM chamada vm-2 na mesma região e zona de 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 você quer usar.

Criar um grupo de instâncias

Para usar as VMs em um back-end de balanceador de carga, adicione-as a um grupo de instâncias.

Console

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

   Acesse grupo de instâncias

2. Clique em Criar grupo de instâncias.

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

4. Em Nome, insira ig-1.

5. Na seção Local, selecione a mesma região e zona das suas VMs.

6. Em Rede, selecione service-network.

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

8. Na seçã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 gerenciadas:

   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
   

Configurar componentes do balanceador de carga

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

• Verificação de integridade. Você usa uma verificação de integridade HTTP que verifica um código de status HTTP 200 OK.

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

• Regra de encaminhamento. Você cria uma única regra de encaminhamento interno, service-rule.

• Endereço IP interno. Você especifica um endereço IP interno, 10.10.10.99, ao criar a regra de encaminhamento.

Console

Iniciar a configuração

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

   Acessar o "Balanceamento de carga"

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

Configuração básica

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

• Em Nome do balanceador de carga, insira service-lb.
• Em Região, selecione a mesma região das suas VMs.
• Em Rede, selecione service-network.

Configurar os back-ends

1. Clique em Configuração de back-end.
2. Na lista Verificação de integridade, clique em Criar verificação de integridade e insira as seguintes informações:
   • Em Nome, insira hc-http-80.
   • Em Protocolo, selecione HTTP.
   • Em Porta, insira 80.
   • Em Protocolo de proxy, selecione NONE.
   • Em Caminho da solicitação, insira /.
3. Clique em Criar.
4. Na seção Novo back-end de Back-ends, selecione IPv4 (pilha única).
5. Em Grupo de instâncias, selecione o grupo de instâncias ig-1 e clique em Concluído.
6. Verifique se há uma marca de seleção azul ao lado de Configuração do back-end antes de continuar.

Configure o front-end

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

Analise a configuração

1. Clique em Analisar e finalizar.
2. Revise suas configurações do balanceador de carga.
3. Clique em Criar.

gcloud

1. Crie uma nova verificação de integridade HTTP regional para testar a conectividade HTTP com as VMs na porta 80.

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

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

2. Crie o serviço de back-end do 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 das 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:

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

4. Crie uma regra de encaminhamento do 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 das VMs de back-end.

Testar o acesso ao balanceador de carga

Para testar se o balanceador de carga está funcionando, crie uma VM de teste e envie uma solicitação dela para o balanceador de carga.

Criar uma VM cliente para teste

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

Console

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

   Acessar Instâncias de VM

2. Clique em Criar instância.

3. Em Nome, insira producer-test.

4. Em Região, selecione a mesma região das VMs de back-end.

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

6. Clique em Rede e configure os seguintes campos:

   1. Em Tags de rede, insira allow-ssh.
   2. Em Interfaces de rede, selecione o seguinte:
      • Em Rede, selecione service-network.
      • Em 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 na mesma região das VMs de back-end.

testar a conectividade

Neste teste, o balanceador de carga é contatado por uma VM cliente. O comportamento esperado é que o tráfego seja distribuído entre as VMs de back-end do balanceador de carga.

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

   gcloud compute ssh producer-test --zone=ZONE
   

   Substitua ZONE pela zona da VM do cliente.
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, devido ao conteúdo de /var/www/html/index.html em cada VM de back-end. Por exemplo, as respostas esperadas são assim: Page served from: vm-1 e Page served from: vm-2.

   curl -s http://10.10.10.99
   

A seguir

• Tornar o serviço acessível de outras redes VPC