GSP041

Visão geral

O balanceador de carga de aplicativo interno é essencial para criar aplicativos internos robustos, seguros e fáceis de gerenciar que impulsionam suas operações comerciais. Neste laboratório, você vai aprender a distribuir o tráfego na sua rede de nuvem privada sem expor as máquinas virtuais (VMs) diretamente à Internet pública, o que mantém seus serviços seguros e eficientes.

Você vai criar um padrão arquitetônico simplificado, mas muito comum:

• Uma "camada da Web" (site voltado ao público) que precisa pedir ajuda a outro serviço interno.
• Um "nível de serviço interno" (uma calculadora de números primos) que realiza tarefas específicas e é distribuído em várias máquinas.

Essa configuração garante que, mesmo que uma parte do seu serviço interno fique ocupada ou inativa, o sistema geral continue funcionando sem problemas, porque o balanceador de carga direciona automaticamente as solicitações para máquinas em boas condições.

Atividades deste laboratório

• Conhecer melhor os componentes de um balanceador de carga interno
• Criar um grupo de máquinas de back-end (calculadora de números primos)
• Configurar um balanceador de carga interno para direcionar o tráfego interno às máquinas de back-end
• Testar o balanceador de carga interno de outra máquina interna
• Configurar um servidor da Web voltado ao público que usa o balanceador de carga interno para receber resultados do serviço interno "calculadora de números primos"

Pré-requisitos

• Conhecimento básico do Google Cloud Compute Engine: entender o que é uma instância de máquina virtual (VM).
• Conceitos básicos de rede: o que é um endereço IP.
• Linha de comando básica do Unix/Linux: como digitar comandos em um terminal.
• Conhecimento sobre VPCs (nuvens privadas virtuais): entender que os recursos do Google Cloud ficam em uma rede privada.

Configuração e requisitos

Antes de clicar no botão Começar o Laboratório

Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é ativado quando você clica em Iniciar laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.

Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, e não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.

Confira os requisitos para concluir o laboratório:

• Acesso a um navegador de Internet padrão (recomendamos o Chrome).

Observação: para executar este laboratório, use o modo de navegação anônima (recomendado) ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e de estudante, o que poderia causar cobranças extras na sua conta pessoal.

• Tempo para concluir o laboratório: não se esqueça que, depois de começar, não será possível pausar o laboratório.

Observação: use apenas a conta de estudante neste laboratório. Se usar outra conta do Google Cloud, você poderá receber cobranças nela.

Como iniciar seu laboratório e fazer login no console do Google Cloud

1. Clique no botão Começar o laboratório. Se for preciso pagar por ele, uma caixa de diálogo vai aparecer para você selecionar a forma de pagamento. No painel Detalhes do Laboratório, à esquerda, você vai encontrar o seguinte:

   • O botão Abrir Console do Google Cloud
   • O tempo restante
   • As credenciais temporárias que você vai usar neste laboratório
   • Outras informações, se forem necessárias

2. Se você estiver usando o navegador Chrome, clique em Abrir console do Google Cloud ou clique com o botão direito do mouse e selecione Abrir link em uma janela anônima.

   O laboratório ativa os recursos e depois abre a página Fazer Login em outra guia.

   Dica: coloque as guias em janelas separadas lado a lado.

   Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta.

3. Se necessário, copie o Nome de usuário abaixo e cole na caixa de diálogo Fazer login.

   {{{user_0.username | "Username"}}}

   Você também encontra o nome de usuário no painel Detalhes do Laboratório.

4. Clique em Próxima.

5. Copie a Senha abaixo e cole na caixa de diálogo de Olá.

   {{{user_0.password | "Password"}}}

   Você também encontra a senha no painel Detalhes do Laboratório.

6. Clique em Próxima.

   Importante: você precisa usar as credenciais fornecidas no laboratório, e não as da sua conta do Google Cloud. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais.

7. Acesse as próximas páginas:

   • Aceite os Termos e Condições.
   • Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
   • Não se inscreva em testes gratuitos.

Depois de alguns instantes, o console do Google Cloud será aberto nesta guia.

Observação: para acessar os produtos e serviços do Google Cloud, clique no Menu de navegação ou digite o nome do serviço ou produto no campo Pesquisar.

Ativar o Cloud Shell

O Cloud Shell é uma máquina virtual com várias ferramentas de desenvolvimento. Ele tem um diretório principal permanente de 5 GB e é executado no Google Cloud. O Cloud Shell oferece acesso de linha de comando aos recursos do Google Cloud.

1. Clique em Ativar o Cloud Shell na parte de cima do console do Google Cloud.

2. Clique nas seguintes janelas:

   • Continue na janela de informações do Cloud Shell.
   • Autorize o Cloud Shell a usar suas credenciais para fazer chamadas de APIs do Google Cloud.

Depois de se conectar, você verá que sua conta já está autenticada e que o projeto está configurado com seu Project_ID, . A saída contém uma linha que declara o projeto PROJECT_ID para esta sessão:

Your Cloud Platform project in this session is set to {{{project_0.project_id | "PROJECT_ID"}}}

A gcloud é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.

3. (Opcional) É possível listar o nome da conta ativa usando este comando:

gcloud auth list

4. Clique em Autorizar.

Saída:

ACTIVE: * ACCOUNT: {{{user_0.username | "ACCOUNT"}}} To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Opcional) É possível listar o ID do projeto usando este comando:

gcloud config list project

Saída:

[core] project = {{{project_0.project_id | "PROJECT_ID"}}} Observação: consulte a documentação completa da gcloud no Google Cloud no guia de visão geral da gcloud CLI.

Configurar região e zona

1. Defina a região e a zona do projeto para este laboratório:

gcloud config set compute/region {{{project_0.default_region | Region}}} gcloud config set compute/zone {{{project_0.default_zone | Zone}}}

2. Crie uma variável para a região:

export REGION={{{project_0.default_region | Region}}}

3. Crie uma variável para a zona:

export ZONE={{{project_0.default_zone | Zone}}}

Saiba mais na documentação Regiões e zonas.

Observação: quando você executa a gcloud na sua máquina, as configurações continuam as mesmas em todas as sessões. Porém, no Cloud Shell, elas precisam ser definidas a cada nova sessão ou reconexão.

Tarefa 1: criar um ambiente virtual

Um ambiente virtual mantém o software do projeto organizado e garante que o código sempre seja executado com as versões específicas das ferramentas necessárias.

Os ambientes virtuais Python são usados para isolar do sistema a instalação de pacotes.

1. Instale o ambiente virtualenv:

sudo apt-get install -y virtualenv

2. Crie o ambiente virtual:

python3 -m venv venv

3. Ative o ambiente virtual:

source venv/bin/activate

Tarefa 2: criar um grupo gerenciado de instâncias de back-end

Ao usar um "grupo gerenciado de instâncias", o Google Cloud pode criar e manter automaticamente cópias idênticas do seu serviço. Se uma cópia falhar, o Google Cloud a substituirá, tornando seu serviço mais confiável.

Criar o script de inicialização

Pense nesse script como um conjunto de instruções que cada nova VM no grupo seguirá ao ser iniciada. Nosso script vai incluir um pequeno servidor da Web escrito em Python que pode apontar se um número é primo (True) ou não (False).

1. Para começar, crie o script backend.sh no diretório principal:

touch ~/backend.sh

2. Clique no ícone na parte de cima do Cloud Shell para Abrir o editor. Se for solicitado, clique em Abrir em uma nova janela.

Observação: se o ícone "Editor de código" não aparecer, clique no ícone "Menu de navegação" para fechar o painel esquerdo.

Ao iniciar o editor de código, o Cloud Shell é movido para uma nova janela e o editor de código é aberto. Depois de alguns segundos, o espaço de trabalho vai aparecer.

3. Selecione o arquivo backend.sh no painel esquerdo.

4. Agora, adicione o seguinte script no editor à direita:

sudo chmod -R 777 /usr/local/sbin/ sudo cat << EOF > /usr/local/sbin/serveprimes.py import http.server def is_prime(a): return a!=1 and all(a % i for i in range(2,int(a**0.5)+1)) class myHandler(http.server.BaseHTTPRequestHandler): def do_GET(s): s.send_response(200) s.send_header("Content-type", "text/plain") s.end_headers() s.wfile.write(bytes(str(is_prime(int(s.path[1:]))).encode('utf-8'))) http.server.HTTPServer(("",80),myHandler).serve_forever() EOF nohup python3 /usr/local/sbin/serveprimes.py >/dev/null 2>&1 &

5. Clique em Arquivo > Salvar.

Criar o modelo da instância

6. Na barra de ferramentas do Cloud Shell, clique em Abrir Terminal. Para criar o modelo de instância primecalc, insira o seguinte comando:

gcloud compute instance-templates create primecalc \ --metadata-from-file startup-script=backend.sh \ --no-address --tags backend --machine-type=e2-medium

Esse é o "blueprint" das VMs de back-end. Observe que ele tem --no-address, o que significa que essas VMs de back-end não terão acesso público à Internet por segurança.

Abrir o firewall

Crie uma regra de firewall para permitir que o tráfego na porta 80 (tráfego HTTP padrão) alcance as VMs de back-end. Isso é crucial para que o balanceador de carga de aplicativo interno e as verificações de integridade se comuniquem com elas.

7. Abra o firewall para a porta 80:

gcloud compute firewall-rules create http --network default --allow=tcp:80 \ --source-ranges {{{project_0.startup_script.selected_cidr | IP}}} --target-tags backend

Clique em Verificar meu progresso para saber se você está no caminho certo neste laboratório.

Criar modelo de instância e abrir firewall na porta 80

Criar o grupo de instâncias

8. Em seguida, crie o grupo gerenciado de instâncias chamado backend. Comece com três instâncias:

gcloud compute instance-groups managed create backend \ --size 3 \ --template primecalc \ --zone $ZONE

9. Quando a execução terminar, volte para a guia "Console". Acesse Compute Engine > Instâncias de VM. Agora você vai ver três VMs de back-end sendo criadas pelo grupo de instâncias.

Os back-ends estão prontos para veicular o tráfego.

Clique em Verificar meu progresso para saber se você está no caminho certo neste laboratório.

Criar o grupo de instâncias

Tarefa 3: configurar o balanceador de carga interno

Você está criando uma única entrada VIP privada para seu serviço interno. Ela permite que outros aplicativos internos alcancem sua "calculadora de números primos" de maneira confiável, sem precisar saber qual VM de back-end específica está ativa ou disponível. Agora vamos configurar o balanceador de carga interno e conectá-lo ao grupo de instâncias que você acabou de criar.

Um balanceador de carga interno consiste em três partes principais:

• Regra de encaminhamento: é o endereço IP particular real para onde outros serviços internos vão enviar solicitações. Ela "encaminha" o tráfego para o serviço de back-end.
• Serviço de back-end: define como o balanceador de carga distribui o tráfego para as instâncias de VM. Também inclui a verificação de integridade.
• Verificação de integridade: é uma verificação contínua que monitora a "integridade" das VMs de back-end. O balanceador de carga só envia tráfego para máquinas que são aprovadas nas verificações de integridade, garantindo que seu serviço esteja sempre disponível.

O diagrama a seguir mostra como as instâncias passam pelo balanceador de carga usando várias instâncias em diversos grupos de back-end em zonas diferentes.

Criar uma verificação de integridade

1. Uma verificação de integridade é necessária para garantir que o balanceador de carga envie o tráfego apenas para instâncias em boas condições. Como o serviço de back-end é um servidor HTTP, verifique se ele responde com "200 OK" em um caminho de URL específico (neste caso, /2 para verificar se 2 é primo):

gcloud compute health-checks create http ilb-health --request-path /2

Como o serviço HTTP é fornecido, verifique se uma resposta "200" em um caminho de URL específico (neste caso, /2 para verificar se 2 é um número primo) é preenchida:

Criar um serviço de back-end

2. Agora crie o serviço de back-end chamado prime-service:

gcloud compute backend-services create prime-service \ --load-balancing-scheme internal --region=$REGION \ --protocol tcp --health-checks ilb-health

Esse serviço vai vincular a verificação de integridade ao grupo de instâncias.

Adicionar o grupo de instâncias ao serviço de back-end

3. Conecte o grupo de instâncias de back-end ao serviço de back-end "prime-service". Isso informa ao balanceador de carga quais máquinas ele precisa gerenciar:

gcloud compute backend-services add-backend prime-service \ --instance-group backend --instance-group-zone=$ZONE \ --region=$REGION

Criar a regra de encaminhamento

4. Por fim, crie a regra de encaminhamento chamada prime-lb com um IP estático de :

gcloud compute forwarding-rules create prime-lb \ --load-balancing-scheme internal \ --ports 80 --network default \ --region=$REGION --address {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}} \ --backend-service prime-service

Seu serviço interno de "cálculo de números primos" agora está totalmente configurado e pronto para ser consultado pelo endereço IP interno.

Clique em Verificar meu progresso para saber se você está no caminho certo neste laboratório.

Configurar o balanceador de carga interno

Tarefa 4: testar o balanceador de carga

Esta etapa é fundamental para confirmar se o balanceador de carga de aplicativo interno está direcionando o tráfego corretamente aos serviços de back-end. Isso prova que outros aplicativos internos agora podem acessar seu serviço de forma confiável por um único endereço IP estável, garantindo a operação contínua.

Para testar o balanceador de carga, crie uma instância de VM na mesma rede do balanceador de carga de aplicativo interno. Ele só pode ser acessado na rede de nuvem privada, e não diretamente do Cloud Shell, que fica fora dessa rede específica.

1. Usando gcloud no Cloud Shell, crie uma instância de teste simples:

gcloud compute instances create testinstance \ --machine-type=e2-standard-2 --zone $ZONE

2. Em seguida, use SSH para acessar:

gcloud compute ssh testinstance --zone $ZONE

Caso solicitado, digite Y e pressione Enter duas vezes para prosseguir.

Consultar o balanceador de carga

3. Na instância de teste, use curl para perguntar ao endereço IP do balanceador de carga de aplicativo interno se alguns números são primos:

curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/2 curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/4 curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/5

A saída vai mostrar "True" ou "False" ao lado da linha de comando, desta forma:

user@testinstance:~$ curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/2 Trueuser@testinstance:~$ curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/4 Falseuser@testinstance:~$ curl {{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/5 Trueuser@testinstance:~$ exit

Perceba que 2 e 5 são identificados corretamente como números primos, mas 4 não é. Isso confirma que o balanceador de carga de aplicativo interno está funcionando corretamente. Ele recebeu as solicitações e as encaminhou para uma das VMs de "cálculo de números primos" de back-end.

O serviço respondeu corretamente: 2 e 5 são números primos, mas 4 não é.

4. Saia da instância de teste:

exit

5. Em seguida, exclua o arquivo, já que ele não é mais necessário:

gcloud compute instances delete testinstance --zone=$ZONE

6. Digite Y para confirmar a exclusão.

Tarefa 5: criar um servidor da Web voltado ao público

Agora você pode ver como um aplicativo voltado ao público, como um site, pode aproveitar seus serviços internos. Você vai criar um servidor da Web voltado ao público que usará o serviço interno "calculadora de números primos" (pelo balanceador de carga de aplicativo interno) para mostrar uma matriz de números primos.

1. Primeiro, crie o script de inicialização para esse "front-end" voltado ao público no diretório inicial:

touch ~/frontend.sh

2. O editor de código ainda vai estar aberto. Se não estiver, selecione o Editor de código no shell para iniciá-lo:

Depois de alguns segundos, o espaço de trabalho vai aparecer.

3. Agora adicione este script ao editor à direita:

sudo chmod -R 777 /usr/local/sbin/ sudo cat << EOF > /usr/local/sbin/getprimes.py import urllib.request from multiprocessing.dummy import Pool as ThreadPool import http.server PREFIX="http://{{{project_0.startup_script.selected_forwarding_rule_cidr | IP}}}/" #HTTP Load Balancer def get_url(number): return urllib.request.urlopen(PREFIX+str(number)).read().decode('utf-8') class myHandler(http.server.BaseHTTPRequestHandler): def do_GET(s): s.send_response(200) s.send_header("Content-type", "text/html") s.end_headers() i = int(s.path[1:]) if (len(s.path)>1) else 1 s.wfile.write("<html><body><table>".encode('utf-8')) pool = ThreadPool(10) results = pool.map(get_url,range(i,i+100)) for x in range(0,100): if not (x % 10): s.wfile.write("<tr>".encode('utf-8')) if results[x]=="True": s.wfile.write("<td bgcolor='#00ff00'>".encode('utf-8')) else: s.wfile.write("<td bgcolor='#ff0000'>".encode('utf-8')) s.wfile.write(str(x+i).encode('utf-8')+"</td> ".encode('utf-8')) if not ((x+1) % 10): s.wfile.write("</tr>".encode('utf-8')) s.wfile.write("</table></body></html>".encode('utf-8')) http.server.HTTPServer(("",80),myHandler).serve_forever() EOF nohup python3 /usr/local/sbin/getprimes.py >/dev/null 2>&1 &

4. Clique em Arquivo > Salvar.

Criar a instância de front-end

5. No Cloud Shell, crie uma instância chamada frontend que vai executar este servidor da Web:

gcloud compute instances create frontend --zone=$ZONE \ --metadata-from-file startup-script=frontend.sh \ --tags frontend --machine-type=e2-standard-2

Abrir o firewall para o front-end

6. Como esse é um servidor público, abra o firewall dele para permitir o tráfego de qualquer lugar na Internet (0.0.0.0/0) na porta 80:

gcloud compute firewall-rules create http2 --network default --allow=tcp:80 \ --source-ranges 0.0.0.0/0 --target-tags frontend

7. No Menu de navegação, clique em Compute Engine > Instâncias de VM. Atualize o navegador se a instância frontend não aparecer.

8. Abra o IP externo do front-end no navegador:

Uma matriz como esta vai aparecer, mostrando todos os números primos até 100 em verde:

9. Tente adicionar um número ao caminho, como http://your-ip/10000, para ver todos os números primos a partir desse número.

Observação: além de não calcular os números primos de forma eficaz, o exemplo de script de inicialização não tem algoritmos de detecção ou correção de erros. Adicionar números grandes ao caminho vai fazer o serviço chegar ao tempo limite.

Clique em Verificar meu progresso para saber se você está no caminho certo neste laboratório.

Criar um servidor da Web voltado ao público

Parabéns!

Você criou um serviço interno confiável usando o balanceador de carga de aplicativo interno do Google Cloud e demonstrou como um aplicativo público pode utilizar esse serviço com segurança.

Próximas etapas / Saiba mais

• Leia mais sobre os balanceadores de carga de aplicativo internos.
• Saiba mais sobre sub-redes
• Publique perguntas e encontre respostas no Stack Overflow com a tag google-compute-engine ou google-cloud-platform.

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 18 de julho de 2025

Laboratório testado em 18 de julho de 2025

Copyright 2025 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.