GSP662

Visão geral

Há muitas maneiras de implantar sites no Google Cloud. Cada solução oferece recursos, capacidades e níveis de controle diferentes. O Compute Engine permite um controle abrangente da infraestrutura usada para executar um site, mas também precisa de um pouco mais de gerenciamento operacional comparado a soluções como o Google Kubernetes Engine (GKE), o App Engine ou outras. Com o Compute Engine, você controla todos os detalhes da infraestrutura, inclusive as máquinas virtuais, os balanceadores de carga e muito mais.

Neste laboratório, você vai implantar um aplicativo de amostra, o site de e-commerce da "Fancy Store", para mostrar como esse procedimento e o escalonamento podem ser feitos com facilidade usando o Compute Engine.

O que você vai aprender

Neste laboratório, você aprenderá a fazer o seguinte:

• Criar instâncias do Compute Engine.
• Criar modelos de instância de instâncias de origem.
• Criar grupos gerenciados de instâncias.
• Criar e testar as verificações de integridade dos grupos gerenciados de instâncias.
• Criar balanceadores de carga HTTP(S).
• Criar verificações de integridade do balanceador de carga.
• Usar uma rede de fornecimento de conteúdo (CDN) para armazenamento em cache.

Ao final do laboratório, você terá instâncias dentro de grupos gerenciados de instâncias para recuperação automática, balanceamento de carga, escalonamento automático e atualizações graduais do site.

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 laboratório. Se for preciso pagar por ele, uma caixa de diálogo vai aparecer para você selecionar a forma de pagamento. À direita, você encontra o painel Configuração e acesso ao laboratório com as seguintes informações:

   • O botão Abrir console do Google Cloud
   • As credenciais temporárias (nome de usuário e senha) que você vai usar no laboratório
   • Outros dados, se necessários

   O timer do laboratório fica na parte de cima da página e mostra o tempo restante.

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 "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 Login.

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

   Você também encontra o nome de usuário no painel Configuração e acesso ao laboratório.

4. Clique em Avançar.

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

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

   Você também encontra a senha no painel Configuração e acesso ao laboratório.

6. Clique em Avançar.

   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, talvez 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 sem custo financeiro.

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.

Configure sua região e zona

Alguns recursos do Compute Engine estão em regiões e zonas. As regiões são localizações geográficas específicas onde você executa seus recursos. Todas elas têm uma ou mais zonas.

Execute estes comandos da gcloud no Cloud Shell para definir a região e a zona padrão do laboratório:

gcloud config set compute/zone "{{{project_0.default_zone|ZONE}}}" export ZONE=$(gcloud config get compute/zone) gcloud config set compute/region "{{{project_0.default_region|REGION}}}" export REGION=$(gcloud config get compute/region)

Tarefa 1> ativar a API Compute Engine

• Execute o comando a seguir para ativar a API Compute Engine:

gcloud services enable compute.googleapis.com

Tarefa 2: criar um bucket do Cloud Storage

Você vai usar um bucket do Cloud Storage para armazenar o código criado e seus scripts de inicialização.

• No Cloud Shell, execute o seguinte comando para criar um novo bucket do Cloud Storage:

gcloud storage buckets create gs://fancy-store-{{{project_0.project_id | Project ID}}}

Clique em Verificar meu progresso para conferir o objetivo. Criar um bucket do Cloud Storage

Tarefa 3: clonar um repositório de origem

Neste laboratório, você vai usar o site de e-commerce da Fancy Store no repositório monolith-to-microservices como base do seu site.

Nesta tarefa, você vai clonar o código-fonte para priorizar os aspectos da implantação no Compute Engine. Mais adiante no laboratório, você fará uma pequena atualização no código para demonstrar como é simples fazer isso no Compute Engine.

1. Execute os comandos a seguir para clonar o código-fonte e navegar até o diretório monolith-to-microservices:

git clone https://github.com/googlecodelabs/monolith-to-microservices.git cd ~/monolith-to-microservices

2. Realize o build inicial do código para executar o aplicativo localmente com o seguinte:

./setup.sh

Pode levar alguns minutos para esse script ser concluído.

3. Depois disso, use o comando abaixo para verificar se o Cloud Shell está executando uma versão compatível do nodeJS:

nvm install --lts

4. Depois execute o comando a seguir para testar o aplicativo, mudar para o diretório microservices e iniciar o servidor da web:

cd microservices npm start

Você receberá esta saída:

Saída:

Products microservice listening on port 8082! Frontend microservice listening on port 8080! Orders microservice listening on port 8081!

5. Para ver o aplicativo, clique no ícone de visualização na web e selecione Visualizar na porta 8080.

Isso abre uma nova janela onde é possível ver o front-end da Fancy Store.

Observação: na opção "Visualizar", você vai encontrar o front-end. No entanto, as funções "Produtos" e "Pedidos" não vão funcionar porque esses serviços ainda não foram expostos.

6. Feche a janela depois de visualizar o site e pressione CTRL+C na janela do terminal para interromper o processo do servidor da web.

Tarefa 4: criar as instâncias do Compute Engine

Agora é hora de começar a implantar algumas instâncias do Compute Engine.

Nas seções a seguir, você vai:

1. Criar um script de inicialização para configurar as instâncias.
2. Clonar o código-fonte e fazer upload no Cloud Storage.
3. Implantar uma instância do Compute Engine para hospedar os microsserviços de back-end.
4. Reconfigurar o código do front-end para usar a instância dos microsserviços de back-end.
5. Implantar uma instância do Compute Engine para hospedar o microsserviço de front-end.
6. Configurar a rede para permitir a comunicação.

Criar o script de inicialização

A instância usa um script de inicialização para instruir o que fazer sempre que ela for iniciada. Dessa forma, as instâncias são configuradas automaticamente.

1. No terminal do Cloud Shell, execute o comando a seguir para criar um arquivo chamado startup-script.sh:

touch ~/monolith-to-microservices/startup-script.sh

2. Clique em Abrir editor na barra de ferramentas do Cloud Shell para abrir o editor de código.

3. Acesse a pasta monolith-to-microservices.

4. Adicione o seguinte código ao arquivo startup-script.sh. Em seguida, você vai editar parte do código depois de adicioná-lo:

#!/bin/bash # Instala o monitor de registros. O monitor vai detectar automaticamente os registros enviados para # syslog. curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash service google-fluentd restart & # Instala dependências do apt apt-get update apt-get install -yq ca-certificates git build-essential supervisor psmisc # Instala o nodejs apt-get install -y nodejs npm # Carrega o código-fonte do aplicativo do bucket do Google Cloud Storage. mkdir /fancy-store gcloud storage cp -r gs://fancy-store-[DEVSHELL_PROJECT_ID]/monolith-to-microservices/microservices/* /fancy-store/ # Instala as dependências do app. cd /fancy-store/ npm install # Cria um usuário do nodeapp. O aplicativo será executado como sendo esse usuário. useradd -m -d /home/nodeapp nodeapp chown -R nodeapp:nodeapp /fancy-store # Configura o supervisor para executar o app node. cat >/etc/supervisor/conf.d/node-app.conf << EOF [program:nodeapp] directory=/fancy-store command=npm start autostart=true autorestart=true user=nodeapp environment=HOME="/home/nodeapp",USER="nodeapp",NODE_ENV="production" stdout_logfile=syslog stderr_logfile=syslog EOF supervisorctl reread supervisorctl update

5. Substitua [DEVSHELL_PROJECT_ID] pelo ID do seu projeto ({{{project_0.project_id | Project ID}}}).
6. Clique em Arquivo > Salvar ou pressione CTRL+S para salvar o arquivo startup-script.sh, mas não o feche ainda.

7. Clique em Salvar ou pressione CTRL+S para salvar o arquivo startup-script.sh, mas não feche ainda.

8. Consulte o canto inferior direito do editor de código do Cloud Shell e verifique se a opção "End of Line Sequence" está definida como "LF", e não como "CRLF".



• Se ela estiver definida como "CRLF", clique em CRLF e selecione LF no menu suspenso.
• Se já estiver definida como LF, deixe como está.

Volte ao terminal do Cloud Shell e execute o seguinte comando para copiar o arquivo startup-script.sh no bucket:

gcloud storage cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-{{{project_0.project_id | Project ID}}}

O arquivo estará acessível em: https://storage.googleapis.com/[BUCKET_NAME]/startup-script.sh.

[BUCKET_NAME] representa o nome do bucket do Cloud Storage. Por padrão, isso só estará visível a contas de serviço e usuários autorizados e ficará inacessível pelo navegador da web. As instâncias do Compute Engine podem ter acesso automático a isso pelas contas de serviço.

O script de inicialização executa estas tarefas:

• Instala o agente do Logging, que coleta registros automaticamente do syslog.
• Instala o Node.js e o Supervisor. O Supervisor executa o app como um daemon.
• Clona o código-fonte do app no bucket do Cloud Storage e instala dependências.
• Configura o Supervisor para executar o app. Isso garante que o app seja reiniciado em caso de saídas inesperadas ou interrupção por um administrador ou processo. Ele também envia stdout e stderr do app ao syslog para serem coletados pelo agente do Logging.

Copiar o código no bucket do Cloud Storage

Quando as instâncias são lançadas, elas extraem o código do bucket do Cloud Storage. Assim, você pode armazenar algumas variáveis de configuração no arquivo .env do código.

Observação: também é possível escrever o código para extrair as variáveis de ambiente de outro local. No entanto, para fins de demonstração, esse é um método simples de lidar com a configuração. Na produção, as variáveis de ambiente geralmente seriam armazenadas fora do código.
• Execute o seguinte comando para copiar o código clonado no seu bucket:
cd ~ rm -rf monolith-to-microservices/*/node_modules gcloud storage cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/ Observação: os diretórios de dependências de node_modules são excluídos para garantir que a cópia seja feita da forma mais rápida e eficiente possível. Eles são recriados nas instâncias quando elas são iniciadas.

Clique em Verificar meu progresso para conferir o objetivo. Copiar o código e o script de inicialização no bucket do Cloud Storage

Implantar a instância de back-end

A primeira instância a ser implantada é a de back-end, que hospeda os microsserviços "Orders" e "Products".

Observação: em um ambiente de produção, é recomendável separar cada microsserviço na própria instância e grupo de instâncias para ser escalonado de forma independente. Para fins de demonstração, os microsserviços de back-end "Orders" e "Products" vão residir na mesma instância e grupo de instâncias.
• Execute o comando a seguir para criar uma instância e2-standard-2 configurada para usar o script de inicialização. Ela está marcada como uma instância de backend, portanto, você poderá aplicar regras específicas de firewall a ela depois:
gcloud compute instances create backend \ --zone={{{project_0.default_zone | zone}}} \ --machine-type=e2-standard-2 \ --tags=backend \ --image-family={{{project_0.startup_script.debian_image_id_short | Debian image name}}} \ --image-project=debian-cloud \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | Project ID}}}/startup-script.sh

Configurar uma conexão com o back-end

Antes de implantar o front-end do aplicativo, você precisa atualizar a configuração para apontar para o back-end recém-implantado.

1. Recupere o endereço IP externo do back-end com o seguinte comando e procure a instância de back-end na guia EXTERNAL_IP:
gcloud compute instances list

Exemplo de saída:

NAME: backend ZONE: {{{project_0.default_zone | zone}}} MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.142.0.2 EXTERNAL_IP: 35.237.245.193 STATUS: RUNNING

2. Copie o IP externo para o back-end.

3. No explorador do Cloud Shell, acesse monolith-to-microservices > react-app.

4. No editor de código, selecione View > Toggle Hidden Files para ver o arquivo .env.

Na próxima etapa, você vai editar o arquivo .env para apontar para o IP externo do back-end. [BACKEND_ADDRESS] representa o endereço IP externo da instância de back-end determinada no comando gcloud executado recentemente.

5. No arquivo .env, substitua localhost pelo seu [BACKEND_ADDRESS]:
REACT_APP_ORDERS_URL=http://[BACKEND_ADDRESS]:8081/api/orders REACT_APP_PRODUCTS_URL=http://[BACKEND_ADDRESS]:8082/api/products

6. Salve o arquivo.

7. No Cloud Shell, execute o seguinte comando para recriar o react-app, que atualiza o código de front-end:

cd ~/monolith-to-microservices/react-app npm install && npm run-script build
8. Em seguida, execute o comando abaixo para copiar o código do aplicativo no bucket do Cloud Storage:
cd ~ rm -rf monolith-to-microservices/*/node_modules gcloud storage cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

Implantar a instância de front-end

Agora que o código está configurado, você já pode implantar a instância de front-end.

• Execute o seguinte comando para implantar a instância de frontend com um comando semelhante ao anterior. Essa instância está marcada como frontend devido ao firewall:
gcloud compute instances create frontend \ --zone={{{project_0.default_zone | zone}}} \ --machine-type=e2-standard-2 \ --tags=frontend \ --image-family={{{project_0.startup_script.debian_image_id_short | Debian image name}}} \ --image-project=debian-cloud \ --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | Project ID}}}/startup-script.sh Observação: o comando de implantação e o script de inicialização são usados com as instâncias de front-end e back-end por simplicidade e porque o código está configurado para iniciar todos os microsserviços por padrão. Portanto, todos os microsserviços são executados no front-end e no back-end nesta amostra. Em um ambiente de produção, você só executaria os microsserviços necessários em cada componente.

Configurar a rede

1. Execute o comando a seguir para criar regras de firewall para permitir o acesso à porta 8080 para o front-end e às portas 8081-8082 para o back-end. Estes comandos de firewall usam as tags atribuídas durante a criação da instância para o aplicativo:
gcloud compute firewall-rules create fw-fe \ --allow tcp:8080 \ --target-tags=frontend gcloud compute firewall-rules create fw-be \ --allow tcp:8081-8082 \ --target-tags=backend

O site agora deve estar totalmente funcional.

2. Para acessar o IP externo do frontend, você precisa saber o endereço. Execute o seguinte comando e procure o EXTERNAL_IP da instância de frontend:
gcloud compute instances list

Exemplo de saída:

NAME: backend ZONE: us-central1-f MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.128.0.2 EXTERNAL_IP: 34.27.178.79 STATUS: RUNNING NAME: frontend ZONE: us-central1-f MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: INTERNAL_IP: 10.128.0.3 EXTERNAL_IP: 34.172.241.242 STATUS: RUNNING

Pode levar alguns minutos para a instância ser iniciada e configurada.

3. Aguarde três minutos, abra uma nova guia do navegador e acesse http://[FRONTEND_ADDRESS]:8080 para acessar o site, em que [FRONTEND_ADDRESS] é o EXTERNAL_IP do front-end determinado a priori.

4. Tente navegar até as páginas Products e Orders, que já devem estar funcionando.



Clique em Verificar meu progresso para conferir o objetivo. Implantar instâncias e configurar a rede

Tarefa 5: criar grupos gerenciados de instâncias

Para o escalonamento do aplicativo, serão criados grupos de instâncias gerenciadas, e as instâncias frontend e backend serão usadas como modelos.

Um grupo gerenciado de instâncias (MIG) contém instâncias idênticas que você pode gerenciar como uma única entidade em uma zona. Os grupos gerenciados de instâncias mantêm a alta disponibilidade dos apps, garantindo que as instâncias estejam sempre ativas, ou seja, no estado "RUNNING". Você vai usar grupos gerenciados para suas instâncias de front-end e back-end para oferecer recuperação automática, balanceamento de carga, escalonamento automático e atualizações graduais.

Criar um modelo de instância com base em uma instância de origem

Antes de criar um grupo gerenciado de instâncias, você precisa criar um modelo de instância para ser a base para o grupo. Com os modelos de instância, você define o tipo de máquina, a imagem do disco de inicialização ou a imagem do contêiner, a rede e outras propriedades que serão usadas na criação de novas instâncias de VM. É possível usar os modelos para criar instâncias individuais ou em um grupo gerenciado.

Para criar o modelo de instância, use as instâncias que você criou antes.

1. Primeiro, execute o seguinte para interromper as duas instâncias:
gcloud compute instances stop frontend --zone={{{project_0.default_zone | zone}}} gcloud compute instances stop backend --zone={{{project_0.default_zone | zone}}}
2. Depois, crie o modelo de instância a partir de cada instância de origem com os seguintes comandos:
gcloud compute instance-templates create fancy-fe \ --source-instance-zone={{{project_0.default_zone | zone}}} \ --source-instance=frontend gcloud compute instance-templates create fancy-be \ --source-instance-zone={{{project_0.default_zone | zone}}} \ --source-instance=backend
3. Execute o seguinte comando para confirmar se os modelos de instância foram criados:
gcloud compute instance-templates list

Exemplo de saída:

NAME: fancy-be MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: CREATION_TIMESTAMP: 2023-07-25T14:52:21.933-07:00 NAME: fancy-fe MACHINE_TYPE: e2-standard-2 PREEMPTIBLE: CREATION_TIMESTAMP: 2023-07-25T14:52:15.442-07:00
4. Com os modelos de instância criados, execute o seguinte para excluir a VM backend e economizar espaço de recursos:
gcloud compute instances delete backend --zone={{{project_0.default_zone | zone}}}
5. Digite y quando solicitado.

Normalmente, é possível excluir a VM frontend, mas você precisará usá-la para atualizar o modelo de instância mais adiante no laboratório.

criar grupos gerenciados de instâncias

1. Execute os comandos a seguir para criar dois grupos gerenciados de instâncias, um para o front-end e outro para o back-end:
gcloud compute instance-groups managed create fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --base-instance-name fancy-fe \ --size 2 \ --template fancy-fe gcloud compute instance-groups managed create fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --base-instance-name fancy-be \ --size 2 \ --template fancy-be

Para iniciar, os grupos gerenciados de instâncias vão usar os modelos e serão configurados para duas instâncias, cada uma em um grupo. As instâncias são nomeadas automaticamente com base no base-instance-name especificado com os caracteres aleatórios anexados.

2. Execute o seguinte para garantir que, no seu aplicativo, o microsserviço frontend rode na porta 8080 e o microsserviço backend na porta 8081 para orders e na porta 8082 para products:
gcloud compute instance-groups set-named-ports fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --named-ports frontend:8080 gcloud compute instance-groups set-named-ports fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --named-ports orders:8081,products:8082

Como essas portas não são padrão, especifique as portas nomeadas para identificá-las. As portas nomeadas são metadados de pares de chave-valor que representam o nome do serviço e a porta em que o serviço é executado. Elas podem ser atribuídas a um grupo, indicando que o serviço está disponível em todas as instâncias contidas nele. Essa informação é usada pelo serviço de balanceamento de carga HTTP que você configura depois.

Configurar a recuperação automática

Para melhorar a disponibilidade do aplicativo e verificar se ele está respondendo, configure uma política de recuperação automática para os grupos gerenciados de instâncias.

Essa política depende de uma verificação de integridade baseada em aplicativo para conferir se um app está respondendo conforme esperado. Essa confirmação é mais precisa do que apenas verificar se o estado de uma instância é "RUNNING", que é o comportamento padrão.

Observação: verificações de integridade separadas são usadas para balanceamento de carga e recuperação automática. As verificações de integridade para balanceamento de carga são mais agressivas, porque determinam se uma instância recebe tráfego do usuário. É recomendável identificar rapidamente as instâncias que não respondem para redirecionar o tráfego, se necessário. Por outro lado, a verificação de integridade para recuperação automática faz o Compute Engine substituir proativamente as instâncias com falha. Por isso, ela precisa ser mais conservadora que a de balanceamento de carga.
1. Para criar uma verificação de integridade que repare a instância caso ela apareça três vezes consecutivas como "unhealthy" para o frontend e o backend, execute o seguinte:
gcloud compute health-checks create http fancy-fe-hc \ --port 8080 \ --check-interval 30s \ --healthy-threshold 1 \ --timeout 10s \ --unhealthy-threshold 3 gcloud compute health-checks create http fancy-be-hc \ --port 8081 \ --request-path=/api/orders \ --check-interval 30s \ --healthy-threshold 1 \ --timeout 10s \ --unhealthy-threshold 3
2. Para criar uma regra de firewall que permita que as sondagens de verificação de integridade se conectem aos microsserviços nas portas 8080-8081, execute o seguinte:
gcloud compute firewall-rules create allow-health-check \ --allow tcp:8080-8081 \ --source-ranges 130.211.0.0/22,35.191.0.0/16 \ --network default
3. Aplique as verificações de integridade aos respectivos serviços com os seguintes comandos:
gcloud compute instance-groups managed update fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --health-check fancy-fe-hc \ --initial-delay 300 gcloud compute instance-groups managed update fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --health-check fancy-be-hc \ --initial-delay 300 Observação: pode levar 15 minutos para que a recuperação automática comece a monitorar as instâncias no grupo.
4. Continue com o laboratório para que a recuperação automática possa monitorar as instâncias do grupo. Você vai simular uma falha para testar a recuperação automática ao final do laboratório.

Clique em Verificar meu progresso para conferir o objetivo. Criar grupos gerenciados de instâncias

Tarefa 6: criar balanceadores de carga

Para complementar os grupos gerenciados de instâncias, use balanceadores de carga HTTP(S) para veicular tráfego aos microsserviços de front-end e back-end e utilize mapeamentos para enviar o tráfego aos serviços de back-end adequados com base nas regras de caminho. Isso expõe um único IP de balanceamento de carga para todos os serviços.

Saiba mais sobre as opções de balanceamento de carga no Google Cloud: Visão geral do balanceamento de carga.

Criar o balanceador de carga HTTP(S)

O Google Cloud oferece vários tipos de balanceadores de carga. Neste laboratório, você vai usar um balanceador de carga HTTP(S) para seu tráfego. O balanceador de carga HTTP é estruturado da seguinte maneira:

• Uma regra de encaminhamento direciona as solicitações recebidas para um proxy HTTP de destino.
• O proxy HTTP de destino verifica cada solicitação em um mapa de URL para determinar o serviço de back-end apropriado.
• O serviço de back-end direciona cada solicitação a um back-end apropriado com base na capacidade de serviço, zona e integridade das instâncias dos back-ends anexados. Cada instância de back-end passa por uma verificação de integridade HTTP. Se o serviço de back-end estiver configurado para usar uma verificação de integridade HTTPS ou HTTP/2, a solicitação é criptografada a caminho da instância de back-end.
• Sessões entre o balanceador de carga e a instância podem usar o protocolo HTTP, HTTPS ou HTTP/2. Se você usar HTTPS ou HTTP/2, será necessário que cada instância nos serviços de back-end tenha um certificado SSL.
Observação: para fins de demonstração, evite usar os certificados SSL complexos e prefira o protocolo HTTP em vez de HTTPS. Para produção, é recomendável usar HTTPS para a criptografia quando possível.
1. Para criar verificações de integridade que serão usadas para determinar quais instâncias podem veicular o tráfego para cada serviço, execute o comando a seguir:
gcloud compute health-checks create http fancy-fe-frontend-hc \ --request-path=/ \ --port=8080 gcloud compute health-checks create http fancy-be-orders-hc \ --request-path=/api/orders \ --port=8081 gcloud compute health-checks create http fancy-be-products-hc \ --request-path=/api/products \ --port=8082 Observação: essas verificações de integridade são para o balanceador de carga e só lidam com o direcionamento do tráfego do balanceador de carga. Elas não fazem com que os grupos gerenciados recriem instâncias.
2. Execute o comando a seguir para criar serviços de back-end que são os destinos do tráfego com carga balanceada. Os serviços de back-end usam as verificações de integridade e as portas nomeadas que você criou:
gcloud compute backend-services create fancy-fe-frontend \ --health-checks=fancy-fe-frontend-hc \ --port-name=frontend \ --global gcloud compute backend-services create fancy-be-orders \ --health-checks=fancy-be-orders-hc \ --port-name=orders \ --global gcloud compute backend-services create fancy-be-products \ --health-checks=fancy-be-products-hc \ --port-name=products \ --global
3. Para adicionar os serviços de back-end do balanceador de carga, execute o seguinte:
gcloud compute backend-services add-backend fancy-fe-frontend \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-fe-mig \ --global gcloud compute backend-services add-backend fancy-be-orders \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-be-mig \ --global gcloud compute backend-services add-backend fancy-be-products \ --instance-group-zone={{{project_0.default_zone | zone}}} \ --instance-group fancy-be-mig \ --global
4. Para criar um mapa de URL que define quais URLs são direcionados para quais serviços de back-end, execute o comando a seguir:
gcloud compute url-maps create fancy-map \ --default-service fancy-fe-frontend
5. Para criar uma correspondência que permita que os caminhos /api/orders e /api/products sejam roteados para os respectivos serviços, execute o comando a seguir:
gcloud compute url-maps add-path-matcher fancy-map \ --default-service fancy-fe-frontend \ --path-matcher-name orders \ --path-rules "/api/orders=fancy-be-orders,/api/products=fancy-be-products"
6. Execute este comando para criar o proxy vinculado ao mapa de URL:
gcloud compute target-http-proxies create fancy-proxy \ --url-map fancy-map
7. Para criar uma regra de encaminhamento global que vincula um endereço IP público e uma porta ao proxy, execute o comando a seguir:
gcloud compute forwarding-rules create fancy-http-rule \ --global \ --target-http-proxy fancy-proxy \ --ports 80

Clique em Verificar meu progresso para conferir o objetivo. Criar balanceadores de carga HTTP(S)

Atualizar a configuração

Agora que você tem um novo endereço IP estático, atualize o código no frontend para apontar para esse novo endereço em vez do endereço temporário anterior, que indicava a instância de backend.

1. No Cloud Shell, para mudar para a pasta react-app que armazena o arquivo .env contendo a configuração, execute o seguinte comando:
cd ~/monolith-to-microservices/react-app/
2. Encontre o endereço IP do balanceador de carga executando o seguinte comando:
gcloud compute forwarding-rules list --global

Exemplo de saída:

NAME: fancy-http-rule REGION: IP_ADDRESS: 34.111.203.235 IP_PROTOCOL: TCP TARGET: fancy-proxy
3. Volte para o editor do Cloud Shell e edite o arquivo .env novamente para apontar para o IP público do balanceador de carga. [LB_IP] representa o endereço IP externo da instância de back-end determinada anteriormente.
REACT_APP_ORDERS_URL=http://[LB_IP]/api/orders REACT_APP_PRODUCTS_URL=http://[LB_IP]/api/products Observação: as portas são removidas no novo endereço, porque o balanceador de carga está configurado para processar esse encaminhamento para você.

4. Salve o arquivo.

5. Execute os seguintes comandos para recriar o react-app, que vai atualizar o código de front-end:

cd ~/monolith-to-microservices/react-app npm install && npm run-script build
6. Execute o seguinte comando para copiar o código do aplicativo no seu bucket:
cd ~ rm -rf monolith-to-microservices/*/node_modules gcloud storage cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

Atualizar as instâncias de front-end

Agora que o novo código e a configuração estão prontos, as instâncias de front-end precisam estar no grupo gerenciado de instâncias para a extração do novo código.

• Como suas instâncias extraem o código quando iniciam, execute o seguinte comando para emitir uma reinicialização contínua:
gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --max-unavailable 100% Observação: nesse exemplo de substituição contínua, você faz uma declaração específica de que todas as máquinas podem ser substituídas imediatamente usando o parâmetro --max-unavailable. Sem esse parâmetro, o comando manteria uma instância ativa durante a reinicialização das outras para garantir a disponibilidade. Por se tratar de um teste, você pode substituir todas as instâncias imediatamente para agilizar o processo.

Clique em Verificar meu progresso para conferir o objetivo. Atualizar as instâncias de front-end

Testar o site

1. Espere três minutos, depois execute o comando rolling-action replace, dando tempo para as instâncias serem processadas, e em seguida verifique o status do grupo gerenciado de instâncias. Execute o seguinte comando para confirmar que o serviço está listado como HEALTHY:
watch -n 2 gcloud compute backend-services get-health fancy-fe-frontend --global
2. Aguarde até que os dois serviços estejam listados como HEALTHY.

Exemplo de saída:

backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instanceGroups/fancy-fe-mig status: healthStatus: - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-x151 ipAddress: 10.128.0.7 port: 8080 - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth Observação: se uma das instâncias tiver um problema e constar como "UNHEALTHY", ela será reparada automaticamente. Espere até a conclusão do reparo.

Se nenhuma das instâncias aparecer no estado "HEALTHY" após algum tempo, significa que algo está errado com a configuração das instâncias de front-end, porque não é possível acessá-las pela porta 8080. Verifique isso procurando as instâncias diretamente na porta 8080.
3. Quando todos os itens aparecerem como "HEALTHY" na lista, saia do comando watch pressionando Ctrl+C.
Observação: o aplicativo está disponível em http://[LB_IP], em que [LB_IP] é o IP_ADDRESS especificado no balanceador de carga, que pode ser acessado pelo seguinte comando:

gcloud compute forwarding-rules list --global

Você vai verificar esse aplicativo mais adiante neste laboratório.

Tarefa 7: escalonar o Compute Engine

Até agora, você criou dois grupos gerenciados de instâncias com duas instâncias cada. Essa configuração é completamente funcional, mas as configurações estáticas não consideram a carga. Em seguida, você vai criar uma política de escalonamento automático com base no uso para escalonar automaticamente cada grupo gerenciado de instâncias.

Redimensionar automaticamente por uso

• Para criar uma política de escalonamento automático, execute o seguinte comando:
gcloud compute instance-groups managed set-autoscaling \ fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60 gcloud compute instance-groups managed set-autoscaling \ fancy-be-mig \ --zone={{{project_0.default_zone | zone}}} \ --max-num-replicas 2 \ --target-load-balancing-utilization 0.60

Esses comandos criam um escalonador automático nos grupos gerenciados de instâncias que adiciona instâncias quando o uso do balanceador de carga está acima de 60% e as remove quando esse índice está abaixo de 60%.

Ativar a rede de fornecimento de conteúdo

Outro recurso que ajuda no escalonamento é a ativação do serviço da rede de fornecimento de conteúdo, para oferecer cache para o front-end.

• Execute o seguinte comando no serviço de front-end:
gcloud compute backend-services update fancy-fe-frontend \ --enable-cdn --global

Quando o usuário solicita um conteúdo do balanceador de carga HTTP(S), a solicitação chega ao Google Front End (GFE), que primeiro procura no cache do Cloud CDN pela resposta à solicitação. Se o GFE achar uma resposta em cache, ele vai enviá-la para o usuário. Isso é chamado de ocorrência em cache.

Se o GFE não achar a resposta para a solicitação no cache, ele fará uma solicitação diretamente ao back-end. Se a resposta a essa solicitação puder ser armazenada em cache, o GFE armazenará a resposta no cache do Cloud CDN para que o cache possa ser usado em solicitações posteriores.

Clique em Verificar meu progresso para conferir o objetivo. Escalonar o Compute Engine

Tarefa 8: atualizar o site

Atualizar o modelo de instância

Os modelos de instância não são editáveis, porém, como suas instâncias não têm estado e todas as configurações são feitas pelo script de inicialização, você só precisa mudar o modelo de instância se quiser mudar as configurações do modelo. Nesta tarefa, você fará uma mudança simples para usar um tipo de máquina maior e implementá-la.

Siga as etapas abaixo para realizar as seguintes ações:

• Atualize a instância frontend, que é a base do modelo de instância. Durante a atualização, coloque um arquivo na versão atualizada da imagem do modelo de instância, depois atualize o modelo, lance o novo modelo e confirme que esse arquivo está nas instâncias do grupo gerenciado.

• Modifique o tipo de máquina do modelo de instância de e2-standard-2 para e2-small.

1. Execute o seguinte comando para modificar o tipo de máquina da instância de front-end:
gcloud compute instances set-machine-type frontend \ --zone={{{project_0.default_zone | zone}}} \ --machine-type e2-small
2. Execute o comando a seguir para criar o novo modelo de instância:
gcloud compute instance-templates create fancy-fe-new \ --region=$REGION \ --source-instance=frontend \ --source-instance-zone={{{project_0.default_zone | zone}}}
3. Implante o modelo de instância atualizado no grupo gerenciado de instâncias com o seguinte comando:
gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --version template=fancy-fe-new
4. Aguarde três minutos e execute o seguinte comando para monitorar o status da atualização:
watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}}

Esse processo leva alguns minutos.

Antes de continuar, verifique se você tem pelo menos uma instância na seguinte condição:

• STATUS: RUNNING
• ACTION configurado como None
• INSTANCE_TEMPLATE: o nome do novo modelo (fancy-fe-new)

5. Copie o nome de uma das máquinas listadas e use no próximo comando.

6. CTRL+C para sair do processo watch.

7. Para ver se a máquina virtual está usando o novo tipo de máquina (e2-small), em que [VM_NAME] é a instância recém-criada, execute o seguinte comando:

gcloud compute instances describe [VM_NAME] --zone={{{project_0.default_zone | zone}}} | grep machineType

Exemplo de resposta esperado:

machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/us-central1-f/machineTypes/e2-small

Fazer mudanças no site

Situação: sua equipe de marketing solicitou que você mude a página inicial do seu site. Ela acha que o site deve oferecer mais informações sobre sua empresa e os produtos vendidos.

Nesta seção, você vai adicionar um texto à página inicial para atender ao pedido da equipe de marketing. Parece que um dos desenvolvedores já criou as mudanças com o nome de arquivo index.js.new. Basta copiar esse arquivo para index.js, e as mudanças serão aplicadas. Siga as instruções abaixo para fazer as mudanças apropriadas.

1. Execute os comandos a seguir para copiar o arquivo atualizado no nome correto:
cd ~/monolith-to-microservices/react-app/src/pages/Home mv index.js.new index.js
2. Imprima o conteúdo do arquivo e verifique as mudanças:
cat ~/monolith-to-microservices/react-app/src/pages/Home/index.js

O código resultante deve ser semelhante à saída a seguir.

Saída:

/* Copyright 2019 Google LLC Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at https://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. */ import React from "react"; import { Box, Paper, Typography } from "@mui/material"; export default function Home() { return ( <Box sx={{ flexGrow: 1 }}> <Paper elevation={3} sx={{ width: "800px", margin: "0 auto", padding: (theme) => theme.spacing(3, 2), }} > <Typography variant="h5">Welcome to the Fancy Store!</Typography> <br /> <Typography variant="body1"> Take a look at our wide variety of products. </Typography> </Paper> </Box> ); }

Os componentes do React foram atualizados, mas você precisa criar o app React para gerar os arquivos estáticos.

3. Para criar o app React e copiá-lo para o diretório público monolith, execute o comando a seguir:
cd ~/monolith-to-microservices/react-app npm install && npm run-script build
4. Depois, para reenviar esse código por push ao bucket, execute o seguinte:
cd ~ rm -rf monolith-to-microservices/*/node_modules gcloud storage cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | Project ID}}}/

Enviar mudanças por push com as substituições graduais

1. Agora, para forçar a substituição de todas as instâncias e efetuar a atualização, execute o seguinte:
gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \ --zone={{{project_0.default_zone | zone}}} \ --max-unavailable=100%

Observação: neste exemplo de substituição contínua, você faz uma declaração específica de que todas as máquinas podem ser substituídas imediatamente por meio do parâmetro --max-unavailable. Sem esse parâmetro, o comando mantém a instância ativa enquanto substitui as outras. Por se tratar de um teste, você pode substituir todas as instâncias imediatamente para agilizar o processo. Na produção, deixar um buffer faz com que o site continue sendo exibido enquanto atualiza.

Clique em Verificar meu progresso para conferir o objetivo. Atualizar o site

2. Espere três minutos, depois execute o comando rolling-action replace, dando tempo para as instâncias serem processadas, e em seguida verifique o status do grupo gerenciado de instâncias. Execute o seguinte comando para confirmar que o serviço está listado como HEALTHY:
watch -n 2 gcloud compute backend-services get-health fancy-fe-frontend --global
3. Aguarde alguns instantes para ambos os serviços aparecerem como HEALTHY.

Exemplo de saída:

backend: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instanceGroups/fancy-fe-mig status: healthStatus: - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-x151 ipAddress: 10.128.0.7 port: 8080 - healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/us-central1-a/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth

4. Quando os itens aparecerem na lista com o status HEALTHY, saia do comando watch ao pressionar CTRL+C.

5. Navegue até o site em http://[LB_IP], em que [LB_IP] é o IP_ADDRESS especificado no balanceador de carga, que pode ser acessado pelo seguinte comando:

gcloud compute forwarding-rules list --global

As novas mudanças no site devem estar visíveis agora.

Simular uma falha

Para confirmar que a verificação de integridade funciona, você decide fazer login em uma instância e interromper os serviços.

1. Execute o seguinte comando para encontrar um nome de instância:
gcloud compute instance-groups list-instances fancy-fe-mig --zone={{{project_0.default_zone | zone}}}
2. Copie um nome de instância e execute o seguinte comando para manter o Secure Shell na instância, em que INSTANCE_NAME é uma das instâncias da lista:
gcloud compute ssh [INSTANCE_NAME] --zone={{{project_0.default_zone | zone}}}

3. Digite "y" para confirmar e pressione Enter duas vezes para não usar uma senha.

4. Dentro da instância, execute o seguinte para usar supervisorctl e interromper o aplicativo:

sudo supervisorctl stop nodeapp; sudo killall node
5. Execute o comando a seguir para sair da instância:
exit
6. Monitore as operações de reparo:
watch -n 2 gcloud compute operations list \ --filter='operationType~compute.instances.repair.*'

Esse processo leva alguns minutos para ser concluído.

Procure o seguinte exemplo de saída:

Saída:

NAME: repair-1755080598062-63c3c8b99843b-eed8dabc-f1833ea3 TYPE: compute.instances.repair.recreateInstance TARGET: us-east4-c/instances/fancy-fe-tn40 HTTP_STATUS: 200 STATUS: DONE TIMESTAMP: 2025-08-13T03:23:18.062-07:00

O grupo gerenciado de instâncias recria a instância para repará-la.

7. Também é possível acessar Menu de navegação > Compute Engine > Instâncias de VM para monitorar pelo console.

Parabéns!

Você implantou, escalonou e atualizou seu site no Compute Engine. Agora já tem experiência com o Compute Engine, grupos gerenciados de instâncias, balanceadores de carga e verificações de integridade.

Próximas etapas / Saiba mais

• Recuperação automática e verificações de integridade em grupos gerenciados de instâncias
• Assista ao vídeo com o estudo de caso Hospedagem de aplicativos da web escalonáveis no Google Cloud.

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 19 de junho de 2026

Laboratório testado em 19 de junho de 2026

Copyright 2026 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.