GSP1123
Visão geral
Gerenciar a criação, implantação e as atualizações contínuas de aplicativos é
fundamental em operações na nuvem. As principais questões estão relacionadas a
otimizações de recursos para cumprir SLAs, implantação de alterações de
código, atualizações otimizadas de VM e configuração de balanceamento de
carga/rede. O Azure usa pipelines de DevOps, conjuntos de dimensionamento
automático de máquinas virtuais e o IAM do Azure para controle de acesso. Os
principais de serviço são essenciais para a execução e a comunicação dos
aplicativos. Além deles, a configuração da infraestrutura consiste em redes
virtuais, balanceadores de carga, sondagens de integridade e conjuntos de
disponibilidade. A atualização de VMs pode envolver novas versões e
implantações de imagens ou ajustes de instâncias gerenciadas com manutenção
programada.
O Google Cloud oferece uma flexibilidade semelhante. Os scripts de
inicialização podem buscar atualizações de código, facilitando as atualizações
graduais sem tempo de inatividade. Embora existam soluções como o GKE e o App
Engine, o Compute Engine oferece controle granular sobre VMs e balanceadores
de carga. Este laboratório vai demonstrar a implantação e o escalonamento do
aplicativo de e-commerce da Fancy Store no Compute Engine, destacando essa
abordagem avançada no gerenciamento de web apps.
Objetivos
Neste laboratório, você aprenderá a fazer o seguinte:
Quando o laboratório terminar, você terá instâncias dentro de grupos
gerenciados para recuperação automática, balanceamento de carga, escalonamento
automático e atualizações graduais do seu 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
-
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.
-
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.
-
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.
-
Clique em Avançar.
-
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.
-
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.
-
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.
-
Clique em Ativar o Cloud Shell
na parte de cima do console do Google Cloud.
-
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.
- (Opcional) É possível listar o nome da conta ativa usando este comando:
gcloud auth list
- Clique em Autorizar.
Saída:
ACTIVE: *
ACCOUNT: {{{user_0.username | "ACCOUNT"}}}
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- (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.
Definir a zona padrão
- Defina a zona padrão e a configuração do projeto:
gcloud config set compute/zone {{{project_0.default_zone|ZONE}}}
Saiba mais na documentação
Regiões e zonas.
Observação: quando você executa o 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: ativar a API Compute Engine e o editor
Depois 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
Nesta tarefa, você vai configurar 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 | BUCKET}}}
Clique em Verificar meu progresso para conferir o objetivo.
Criar um bucket do Cloud Storage
Tarefa 3: clonar o repositório de origem
Você está usando o site de e-commerce atual 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 a simplicidade do processo no
Compute Engine.
-
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
-
Execute o build inicial do código para executar o aplicativo localmente:
./setup.sh
Pode levar alguns minutos para esse script ser concluído.
-
Depois disso, use o comando abaixo para verificar se o Cloud Shell está
executando uma versão compatível do nodeJS:
{{{project_0.startup_script.node_nvm_command | nvm install --lts}}}
-
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
O resultado será parecido com o exemplo a seguir.
Saída:
Products microservice listening on port 8082!
Frontend microservice listening on port 8080!
Orders microservice listening on port 8081!
-
Para encontrar o aplicativo, clique no
ícone de visualização na Web e selecione
Visualizar na porta 8080.
Isso abre uma nova janela onde é possível conferir o front-end da Fancy Store.
Observação: na opção "Visualizar", você encontra o front-end. No entanto, as funções "Products" e "Orders" não vão funcionar porque esses serviços ainda não foram expostos.
-
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 etapas a seguir, você vai realizar várias ações:
- Criar um script de inicialização para configurar as instâncias.
- Clonar o código-fonte e fazer upload no Cloud Storage.
-
Implantar uma instância do Compute Engine para hospedar os microsserviços de
back-end.
-
Reconfigurar o código do front-end para usar a instância dos microsserviços
de back-end.
-
Implantar uma instância do Compute Engine para hospedar o microsserviço de
front-end.
- 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.
-
Clique em Abrir editor na barra de ferramentas do Cloud
Shell para abrir o editor de código.
-
Navegue até a pasta monolith-to-microservices.
-
Clique em File > New File e crie um
arquivo chamado startup-script.sh.
-
Cole o código a seguir no arquivo:
#!/bin/bash
# Install dependencies from apt
apt-get update
apt-get install -yq ca-certificates git build-essential supervisor psmisc
# Install nodejs
mkdir -p /opt/nodejs
curl https://nodejs.org/dist/v16.14.0/node-v16.14.0-linux-x64.tar.gz | tar xvzf - -C /opt/nodejs --strip-components=1
ln -sf /opt/nodejs/bin/node /usr/bin/node
ln -sf /opt/nodejs/bin/npm /usr/bin/npm
# Get the application source code from the Google Cloud Storage bucket.
mkdir -p /fancy-store
gcloud storage cp -r gs://fancy-store-[PROJECT_ID]/monolith-to-microservices/microservices/* /fancy-store/
# Install app dependencies.
cd /fancy-store/
npm install
# Create a nodeapp user. The application will run as this user.
id -u nodeapp >/dev/null 2>&1 || useradd -m -d /home/nodeapp nodeapp
chown -R nodeapp:nodeapp /fancy-store
# Configure supervisor to run the node app.
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
-
Clique em File > Save para salvar o
arquivo.
-
No editor de código do Cloud Shell, verifique se a opção
"End of Line Sequence" está definida como "LF", e não
como "CRLF". Verifique no canto inferior direito do editor de
código para confirmar.

-
Se ela estiver definida como CRLF, clique em CRLF e
selecione LF no menu suspenso para mudar.
-
No arquivo
startup-script.sh, substitua o marcador de posição
[PROJECT_ID] pelo ID do projeto:
{{{project_0.project_id | PROJECT_ID}}}.
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 do bucket do Cloud Storage e instala
dependências.
-
Configura o Supervisor para executar o app, garantindo que ele seja
reiniciado caso feche inesperadamente ou seja interrompido por um
administrador ou processo. Ele também envia o stdout e o stderr do app ao
syslog para serem coletados pelo agente do Logging.
-
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 | BUCKET}}}
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, ele fica visível apenas para usuários autorizados e contas de serviço,
sendo inacessível via navegador da web. As instâncias do Compute Engine podem
ter acesso automático a esse arquivo por meio das contas de serviço.
Copiar o código no bucket do Cloud Storage
Quando as instâncias são iniciadas, elas extraem o código do bucket do Cloud
Storage. Portanto, você pode armazenar algumas variáveis de configuração no
arquivo .env do código.
Observação: também é possível programar o código para extrair as variáveis de ambiente de outro local, mas, 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.
- Copie 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 | BUCKET}}}/
Observação: os diretórios de dependências node_modules são excluídos para maximizar a rapidez e a eficiência da cópia. Os diretórios são recriados nas instâncias ao serem iniciadas.
Clique em Verificar meu progresso para conferir o objetivo.
Copiar o código e o script de inicialização para o 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 Pedidos e Produtos.
Observação: no ambiente de produção, é recomendável separar cada microsserviço na própria instância e no próprio grupo de instâncias para um escalonamento 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-medium configurada para usar o script de inicialização. Ela
está marcada como uma instância backend, portanto, você poderá
aplicar regras específicas de firewall a ela depois:
gcloud compute instances create backend \
--machine-type=e2-medium \
--tags=backend \
--metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | BUCKET}}}/startup-script.sh
Observação: se for necessário especificar uma zona, verifique se alguma zona padrão foi definida na seção de configuração deste laboratório.
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.
-
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 ZONE MACHINE_TYPE PREEMPTIBLE INTERNAL_IP EXTERNAL_IP STATUS
backend {{{ project_0.default_zone | "ZONE" }}} e2-medium 10.128.0.2 34.68.223.88 RUNNING
-
Copie o IP externo para o back-end.
-
No explorador do Cloud Shell, acesse
monolith-to-microservices > react-app.
-
No editor de código, selecione View >
Toggle Hidden Files para visualizar o arquivo
.env.
-
Edite o arquivo .env apontando 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 acima.
-
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
-
Salve o arquivo.
-
Execute o seguinte comando para recriar o react-app, que vai
atualizar o código do front-end:
cd ~/monolith-to-microservices/react-app
npm install && npm run-script build
-
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 | BUCKET}}}/
Implantar a instância de front-end
Agora que o código está configurado, implante a instância de front-end.
-
Execute o comando a seguir 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 \
--machine-type=e2-medium \
--tags=frontend \
--metadata=startup-script-url=https://storage.googleapis.com/fancy-store-{{{project_0.project_id | BUCKET}}}/startup-script.sh
Observação: o comando de implantação e o script de inicialização são usados nas instâncias de front-end e back-end pela simplicidade, já que o código está configurado para lançar 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.
Configure a rede
Nesta seção, você criará regras de firewall que liberam o acesso à porta 8080
para o front-end e às portas 8081-8082 para o back-end. Os comandos do
firewall usam as tags atribuídas durante a criação da instância para o
aplicativo.
- Execute os comandos a seguir para configurar as regras de firewall:
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.
-
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: {{{ project_0.default_zone | "ZONE" }}}
MACHINE_TYPE: e2-medium
PREEMPTIBLE:
INTERNAL_IP: 10.150.0.2
EXTERNAL_IP: 34.86.128.228
STATUS: RUNNING
NAME: frontend
ZONE: {{{ project_0.default_zone | "ZONE" }}}
MACHINE_TYPE: e2-medium
PREEMPTIBLE:
INTERNAL_IP: 10.150.0.3
EXTERNAL_IP: 35.199.2.193
STATUS: RUNNING
Pode levar alguns minutos para a instância ser iniciada e configurada.
-
Aguarde 30 segundos e execute o seguinte comando para monitorar a preparação
do aplicativo, substituindo
FRONTEND_ADDRESS pelo IP externo da
instância de front-end:
watch -n 2 curl http://[FRONTEND_ADDRESS]:8080
O site estará pronto assim que uma saída parecida com a seguinte for exibida.

-
Pressione CTRL+C para cancelar o comando watch.
-
Abra uma nova guia de navegação anônima e acesse
http://[FRONTEND_ADDRESS]:8080 para entrar no site, em que
[FRONTEND_ADDRESS] é o EXTERNAL_IP do front-end determinado acima.
-
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 os grupos gerenciados de instâncias
Para permitir o escalonamento do aplicativo, serão criados grupos gerenciados
de instâncias que usam o frontend e o backend como
modelos.
Um grupo gerenciado de instâncias (MIG) reúne VMs idênticas para que você as
gerencie de forma unificada em uma única zona. Os grupos gerenciados de
instâncias mantêm a alta disponibilidade dos apps com uma disponibilidade
proativa das VMs, ou seja, no estado "RUNNING".
Neste laboratório, você vai usar grupos gerenciados das 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 o modelo a partir de uma instância de origem
Antes de criar um grupo gerenciado, você precisa criar um modelo de instância
que servirá de base para ele. Com os modelos de instâncias, você define o tipo
de máquina, a imagem do disco de inicialização ou do contêiner, a rede e
outras propriedades que serão usadas na criação de novas instâncias de VMs. É
possível usar os modelos para criar instâncias individuais ou em um grupo
gerenciado.
Para criar o modelo, use as instâncias que você gerou antes.
-
Primeiro, execute os seguintes comandos para interromper as duas instâncias:
gcloud compute instances stop frontend
gcloud compute instances stop backend
-
Depois use os seguintes comandos para criar o modelo baseado em cada
instância de origem:
gcloud compute instance-templates create fancy-fe \
--source-instance=frontend
gcloud compute instance-templates create fancy-be \
--source-instance=backend
-
Confirme se os modelos das instâncias foram criados com o seguinte comando:
gcloud compute instance-templates list
Exemplo de saída:
NAME MACHINE_TYPE PREEMPTIBLE CREATION_TIMESTAMP
fancy-be e2-medium 2020-02-03T10:34:12.966-08:00
fancy-fe e2-medium 2020-02-03T10:34:01.082-08:00
-
Com os modelos de instância criados, execute o seguinte comando para excluir
a VM de
backend e economizar espaço para recursos:
gcloud compute instances delete backend
- Digite y quando solicitado.
Normalmente, é possível excluir a VM frontend, mas ela será usada
para atualizar o modelo de instância mais adiante no laboratório.
Criar um grupo gerenciado de instâncias
-
Execute os comandos abaixo 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 \
--base-instance-name fancy-fe \
--size 2 \
--template fancy-fe
gcloud compute instance-groups managed create fancy-be-mig \
--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.
-
No seu aplicativo, o microsserviço
frontend é executado na
porta 8080, e o microsserviço backend é executado na porta 8081
para orders e na porta 8082 para products:
gcloud compute instance-groups set-named-ports fancy-fe-mig \
--named-ports frontend:8080
gcloud compute instance-groups set-named-ports fancy-be-mig \
--named-ports orders:8081,products:8082
Como essas portas não são padrão, especifique 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 o 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: serão usadas verificações de integridade diferentes para balanceamento de carga e recuperação automática. As verificações de integridade de 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 verificação do balanceamento de carga.
-
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 os comandos a
seguir:
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
-
Crie uma regra de firewall para as sondagens da verificação de integridade
se conectarem aos microsserviços nas portas 8080-8081 com estes comandos:
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
-
Execute os comandos abaixo para aplicar as verificações de integridade aos
respectivos serviços:
gcloud compute instance-groups managed update fancy-fe-mig \
--health-check fancy-fe-hc \
--initial-delay 300
gcloud compute instance-groups managed update fancy-be-mig \
--health-check fancy-be-hc \
--initial-delay 300
Observação: a recuperação automática pode levar 15 minutos para começar a monitorar as instâncias no grupo.
-
Continue com o laboratório para que a recuperação automática possa monitorar
as instâncias do grupo. Ao final do laboratório, você simulará uma falha
para testar a recuperação automática.
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 o tráfego para os microsserviços de front-end e de
back-end e 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 um 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 adequado.
-
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 será criptografada
a caminho da instância de back-end.
-
Sessões entre o balanceador de carga e a instância podem usar os protocolos
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 a complexidade dos certificados SSL. Use o protocolo HTTP em vez do HTTPS. Nos casos de produção, é recomendável usar HTTPS sempre que possível para a criptografia.
-
Crie verificações de integridade para determinar quais instâncias podem
veicular o tráfego para cada serviço:
gcloud compute http-health-checks create fancy-fe-frontend-hc \
--request-path / \
--port 8080
gcloud compute http-health-checks create fancy-be-orders-hc \
--request-path /api/orders \
--port 8081
gcloud compute http-health-checks create 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 apenas direcionam o tráfego dele. Elas não fazem os grupos de instâncias gerenciadas recriarem instâncias.
-
Crie serviços de back-end que são os destinos do tráfego com carga
balanceada. Os serviços de back-end vão usar as verificações de integridade
e as portas nomeadas que você criou:
gcloud compute backend-services create fancy-fe-frontend \
--http-health-checks fancy-fe-frontend-hc \
--port-name frontend \
--global
gcloud compute backend-services create fancy-be-orders \
--http-health-checks fancy-be-orders-hc \
--port-name orders \
--global
gcloud compute backend-services create fancy-be-products \
--http-health-checks fancy-be-products-hc \
--port-name products \
--global
-
Adicione os
serviços de back-end
do balanceador de carga:
gcloud compute backend-services add-backend fancy-fe-frontend \
--instance-group fancy-fe-mig \
--instance-group-zone {{{ project_0.default_zone | "ZONE" }}} \
--global
gcloud compute backend-services add-backend fancy-be-orders \
--instance-group fancy-be-mig \
--instance-group-zone {{{ project_0.default_zone | "ZONE" }}} \
--global
gcloud compute backend-services add-backend fancy-be-products \
--instance-group fancy-be-mig \
--instance-group-zone {{{ project_0.default_zone | "ZONE" }}} \
--global
-
Crie um mapa de URLs. O mapa define os URLs que são direcionados para
determinados serviços de back-end:
gcloud compute url-maps create fancy-map \
--default-service fancy-fe-frontend
-
Crie uma correspondência de caminhos que permita que
/api/orders e /api/products sejam roteados para os
respectivos serviços:
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"
- Crie um proxy vinculado ao mapa de URLs:
gcloud compute target-http-proxies create fancy-proxy \
--url-map fancy-map
-
Crie uma regra de encaminhamento global que vincule um endereço IP público e
uma porta ao proxy:
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.
-
No Cloud Shell, mude para a pasta
react-app, que armazena o
arquivo .env com a configuração:
cd ~/monolith-to-microservices/react-app/
- Encontre o endereço IP para o balanceador de carga:
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
-
Volte ao 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 das instâncias de
back-end determinadas acima.
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 é responsável por processar esse encaminhamento para você.
-
Salve o arquivo.
-
Recrie o react-app, que atualiza o código do front-end:
cd ~/monolith-to-microservices/react-app
npm install && npm run-script build
- Copie 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 | BUCKET}}}/
Atualize as instâncias de front-end
Agora, com o novo código e a configuração, a ideia é que as instâncias de
front-end dentro do grupo gerenciado de instâncias extraiam o novo código.
-
Já que suas instâncias extraem o código quando iniciam, você pode emitir um
comando de reinicialização contínua:
gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \
--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 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
-
Aguarde cerca de 30 segundos depois de executar o comando
rolling-action replace para o processamento. Depois verifique o
status do grupo até que as instâncias apareçam na lista:
watch -n 2 gcloud compute instance-groups list-instances fancy-fe-mig
-
Quando os itens aparecerem na lista, interrompa o comando
watch pressionando CTRL+C.
-
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
-
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/{{{ project_0.default_region | "REGION" }}}/instanceGroups/fancy-fe-mig status: healthStatus:
- healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_region | "REGION" }}}/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/{{{ project_0.default_region | "REGION" }}}/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth
Observação: se uma instância apresentar um problema e estiver no estado "UNHEALTHY", ela será reparada automaticamente. Espere até a conclusão do reparo. Se você esperou algum tempo e nenhuma das instâncias consta como HEALTHY, algo está errado com a configuração das instâncias de front-end, porque não é possível acessá-las pela porta 8080. Para verificar, procure as instâncias diretamente na porta 8080.
-
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 comando abaixo.
gcloud compute forwarding-rules list --global
Você vai verificar esse aplicativo mais adiante neste laboratório.
Tarefa 7: escalonar os grupos de instâncias do Compute Engine
Até o momento, você criou dois grupos gerenciados com duas instâncias cada.
Essa configuração é completamente funcional, mas as configurações estáticas
não consideram a carga. Agora, você vai criar uma política de escalonamento
automático com base na utilização para escalonar automaticamente cada grupo
gerenciado de instâncias.
Redimensionar automaticamente por uso
-
Para criar uma política de escalonamento automático, execute o comando a
seguir:
gcloud compute instance-groups managed set-autoscaling \
fancy-fe-mig \
--max-num-replicas 2 \
--target-load-balancing-utilization 0.60
gcloud compute instance-groups managed set-autoscaling \
fancy-be-mig \
--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 automaticamente quando a utilização 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
Ativar uma rede de fornecimento de conteúdo também ajuda no escalonamento ao
fornecer 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 achar uma resposta no cache, o GFE
enviará 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âncias 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ó precisará mudar o modelo de instância se quiser mudar as configurações
dele. Agora você fará uma mudança simples para usar um tipo de máquina maior e
fazer isso.
-
Atualize a instância de frontend, que é a base do modelo de
instância. Nessa etapa, você incluirá um arquivo na nova versão da imagem
do modelo de instância, atualizará o modelo, fará o lançamento e
confirmará que o arquivo existe nas instâncias do grupo gerenciado.
-
Agora modifique o tipo de máquina do seu modelo de instância de um
e2-medium para um tipo de máquina personalizado com 4 vCPUs e 3840 MiB de
RAM.
-
Execute o seguinte comando para modificar o tipo de máquina da instância
de front-end:
gcloud compute instances set-machine-type frontend --machine-type custom-4-3840
- Crie o novo modelo de instância:
gcloud compute instance-templates create fancy-fe-new \
--source-instance=frontend \
--source-instance-zone={{{ project_0.default_zone | "ZONE" }}}
- Lance o modelo atualizado no grupo gerenciado de instâncias:
gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \
--version template=fancy-fe-new
-
Aguarde 30 segundos 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
Isso leva alguns instantes.
Quando pelo menos uma instância estiver na seguinte condição:
- STATUS: RUNNING
- ACTION configurado como None
-
INSTANCE_TEMPLATE: o nome do novo modelo (fancy-fe-new)
-
Copie o nome de uma das máquinas listadas e use no
próximo comando.
-
Aperte CTRL+C para interromper o processo watch.
-
Execute o seguinte comando para verificar se a máquina virtual está usando
o novo tipo de máquina (custom-4-3840), em que [VM_NAME] é a
instância recém-criada:
gcloud compute instances describe [VM_NAME] | grep machineType
Exemplo de resposta esperado:
machineType: https://www.googleapis.com/compute/v1/projects/project-name/zones/{{{ project_0.default_zone | "ZONE" }}}/machineTypes/custom-4-3840
Fazer mudanças no site
Cenário: sua equipe de marketing pediu para você alterar a
página inicial do site. Eles acham que ela deve mostrar mais informações sobre
sua empresa e os produtos vendidos.
Tarefa: adicionar texto na página inicial para atender ao
pedido da equipe de marketing. Parece que um dos desenvolvedores já criou as
mudanças em um arquivo chamado 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.
-
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
- 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 será parecido com este:
/*
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 (
theme.spacing(3, 2),
}}
>
Fancy Fashion & Style Online
Tired of mainstream fashion ideas, popular trends and societal norms? This
line of lifestyle products will help you catch up with the Fancy
trend and express your personal style. Start shopping Fancy items
now!
);
}
Os componentes do React foram atualizados, mas você precisa criar o app React
para gerar os arquivos estáticos.
-
Execute o comando a seguir para criar o aplicativo React e copiá-lo no
diretório público monolith:
cd ~/monolith-to-microservices/react-app
npm install && npm run-script build
- Depois reenvie esse código por push ao bucket:
cd ~
rm -rf monolith-to-microservices/*/node_modules
gcloud storage cp -r monolith-to-microservices gs://fancy-store-{{{project_0.project_id | BUCKET}}}/
Enviar mudanças por push com as substituições graduais
-
Agora faça com que todas as instâncias sejam substituídas para executar a
atualização:
gcloud compute instance-groups managed rolling-action replace fancy-fe-mig \
--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 no ar durante a atualização.
Clique em Verificar meu progresso para conferir o objetivo.
Atualizar o site
-
Aguarde cerca de 30 segundos depois de executar o comando
rolling-action replace para o processamento. Depois verifique o
status do grupo até que as instâncias apareçam na lista:
watch -n 2 gcloud compute instance-groups list-instances fancy-fe-mig
-
Quando os itens aparecerem na lista, interrompa o comando
watch pressionando CTRL+C.
-
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
-
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/{{{ project_0.default_zone | "ZONE" }}}/instanceGroups/fancy-fe-mig status: healthStatus:
- healthState: HEALTHY instance: https://www.googleapis.com/compute/v1/projects/my-gce-codelab/zones/{{{ project_0.default_zone | "ZONE" }}}/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/{{{ project_0.default_zone | "ZONE" }}}/instances/fancy-fe-cgrt ipAddress: 10.128.0.11 port: 8080 kind: compute#backendServiceGroupHealth
-
Quando os itens aparecerem na lista, interrompa o comando
watch pressionando CTRL+C.
-
Acesse 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, faça login em uma
instância e interrompa os serviços.
- Execute o comando a seguir para encontrar um nome de instância:
gcloud compute instance-groups list-instances fancy-fe-mig
-
Copie o nome de uma instância e execute o comando a seguir para acessá-la
via SSH, em que
INSTANCE_NAME é um dos itens da lista:
gcloud compute ssh [INSTANCE_NAME]
-
Digite y para confirmar e pressione
Enter duas vezes para não usar uma senha.
-
Dentro da instância, use supervisorctl para interromper o
aplicativo:
sudo supervisorctl stop nodeapp; sudo killall node
- Saia da instância:
exit
- 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:
NAME TYPE TARGET HTTP_STATUS STATUS TIMESTAMP
repair-1568314034627-5925f90ee238d-fe645bf0-7becce15 compute.instances.repair.recreateInstance {{{ project_0.default_zone | "ZONE" }}}/instances/fancy-fe-1vqq 200 DONE 2019-09-12T11:47:14.627-07:00
O grupo gerenciado de instâncias recria a instância para repará-la.
-
Também é possível fazer o monitoramento pelo console. Para isso, acesse
Menu de navegação > Compute Engine >
Instâncias de VM.
Parabéns!
Parabéns! Neste laboratório, você implantou, escalonou e atualizou seu site no
Compute Engine, adquirindo experiência prática com esse serviço, grupos
gerenciados de instâncias, balanceadores de carga e verificações de
integridade. O laboratório destaca como o Google Cloud e o Azure facilitam
implantações de aplicativos baseadas em VMs com balanceadores de carga
voltados para a internet. A abordagem do Google Cloud usa scripts de
inicialização para unificar a implantação de código e a configuração de VMs,
simplifica o gerenciamento de VMs com escalonamento automático, oferece
balanceamento de carga HTTP(S) externo global e permite atualizações contínuas
de imagens e aplicativos no fluxo de trabalho do MIG e do script de
inicialização.
Vamos revisar as semelhanças e diferenças entre as duas plataformas que você
percebeu neste laboratório.
Semelhanças:
-
O Google Cloud, assim como o Azure, permite implantar aplicativos em VMs e
configurar balanceadores de carga para disponibilizar esses apps na
internet.
Diferenças:
-
No Google Cloud, você implantou um serviço de aplicativo usando o Compute
Engine com base em um código hospedado em um bucket do Cloud Storage. No
Azure, você precisa usar um pipeline de DevOps ou um repositório de código
para chegar ao mesmo ponto.
-
No Google Cloud, você gerenciou a implantação do código, a configuração das
VMs e a atualização do aplicativo usando o mesmo script de inicialização. No
Azure, você precisa gerenciar a implantação do código em pipelines de DevOps
ou no repositório de código e controlar as VMs separadamente usando
conjuntos de dimensionamento.
-
No Google Cloud, você atualizou o código do aplicativo e o reimplantou
usando um modelo de implantação gradual sem inatividade. No Azure, uma
janela de manutenção é usada para as atualizações.
-
No Google Cloud, é possível ativar o escalonamento automático para grupos
gerenciados de instâncias (MIGs). O Google Cloud mantém e atualiza as VMs
nos MIGs. No Azure, você usa conjuntos de escalonamento.
Próximas etapas / Saiba mais
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 4 de agosto de 2026
Laboratório testado em 4 de agosto 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.