Esta página foi traduzida pela API Cloud Translation.

Hospede e escalone um app da Web no Google Cloud com o Compute Engine

1. Introdução

Há muitas maneiras de implantar sites no Google Cloud, e cada solução oferece diferentes recursos, capacidades e níveis de controle. O Compute Engine oferece um controle profundo sobre a infraestrutura usada para executar um site, mas também exige um pouco mais de gerenciamento operacional em comparação com soluções como Google Kubernetes Engine, App Engine ou outras. Com o Compute Engine, você tem um controle refinado de aspectos da infraestrutura, incluindo máquinas virtuais, balanceador de carga e muito mais. Hoje, você vai implantar um app de exemplo, o site de e-commerce da Fancy Store, para mostrar como implantar e escalonar um site facilmente com o Compute Engine.

O que você vai aprender

Como criar instâncias do Compute Engine
Como criar modelos de instância das instâncias de origem
Como criar grupos de instâncias gerenciadas
Como configurar verificações de integridade e recuperação automática
Como criar balanceamento de carga HTTP(S)
Como criar verificações de integridade para balanceadores de carga
Como usar uma rede de fornecimento de conteúdo para armazenamento em cache

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

Pré-requisitos

Para acessar visões gerais introdutórias dos conceitos que vamos usar neste laboratório, confira o material abaixo:
Este é o Google Cloud Platform: os fundamentos do GCP
Introdução ao Google Cloud Compute Engine
Primeiros passos com o Google Cloud Storage
Como começar: Cloud Shell

2. Configuração do ambiente

Configuração de ambiente personalizada

Faça login no console do Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.

Lembre-se do código do projeto, um nome exclusivo em todos os projetos do Google Cloud. O nome acima já foi escolhido e não servirá para você. Faremos referência a ele mais adiante neste codelab como PROJECT_ID.

Em seguida, será necessário ativar o faturamento no Console do Cloud para usar os recursos do Google Cloud.

A execução deste codelab não será muito cara, se for o caso. Siga todas as instruções na seção "Limpeza", que orienta você sobre como encerrar recursos para não incorrer em cobranças além deste tutorial. Novos usuários do Google Cloud estão qualificados para o programa de US$300 de avaliação sem custo financeiro.

Ative a API Compute Engine

Em seguida, você precisa ativar a API Compute Engine. Para ativar uma API, você precisa aceitar os Termos de Serviço e a responsabilidade de faturamento dela.

No Cloud Shell, execute o seguinte comando para ativar a API Compute Engine:

gcloud services enable compute.googleapis.com

Cloud Shell

Embora o Google Cloud possa ser operado remotamente em um laptop, neste codelab você vai usar o Cloud Shell, um ambiente de linha de comando executado no Cloud.

O Cloud Shell é uma máquina virtual com base em Debian que contém todas as ferramentas de desenvolvimento necessárias. Ela oferece um diretório principal persistente de 5 GB, além de ser executada no Google Cloud. Isso aprimora o desempenho e a autenticação da rede. Isso significa que tudo que você precisa para este codelab é um navegador (sim, funciona em um Chromebook).

Para ativar o Cloud Shell no Console do Cloud, basta clicar em Ativar o Cloud Shell . Leva apenas alguns instantes para provisionar e se conectar ao ambiente.

Screen Shot 2017-06-14 às 10.13.43 PM.png

Depois de se conectar ao Cloud Shell, você já estará autenticado e o projeto estará configurado com seu PROJECT_ID.

gcloud auth list

Resposta ao comando

Credentialed accounts:
 - <myaccount>@<mydomain>.com (active)

gcloud config list project

Resposta ao comando

[core]
project = <PROJECT_ID>

Se, por algum motivo, o projeto não estiver definido, basta emitir o seguinte comando:

gcloud config set project <PROJECT_ID>

Quer encontrar seu PROJECT_ID? Veja qual ID você usou nas etapas de configuração ou procure-o no painel do Console do Cloud:

O Cloud Shell também define algumas variáveis de ambiente por padrão, o que pode ser útil ao executar comandos futuros.

echo $GOOGLE_CLOUD_PROJECT

Resposta ao comando

<PROJECT_ID>

Defina a zona padrão e a configuração do projeto:

gcloud config set compute/zone us-central1-f

É possível escolher uma variedade de zonas diferentes. Para mais informações, consulte Regiões e zonas.

crie o bucket do Cloud Storage

Vamos usar um bucket do Cloud Storage para armazenar o código criado e os scripts de inicialização. No Cloud Shell, execute o seguinte comando para criar um novo bucket do Cloud Storage:

gsutil mb gs://fancy-store-$DEVSHELL_PROJECT_ID

3. clone o repositório de origem

Você vai usar o site de e-commerce da Fancy Store no repositório monolith-to-microservices como base para o seu site. Você clonará o código-fonte do seu repositório para se concentrar na implantação no Compute Engine. Mais tarde, você vai fazer uma pequena atualização no código para demonstrar a simplicidade das atualizações no Compute Engine.

Você pode clonar automaticamente o repositório de código no projeto, bem como abrir o Cloud Shell e o editor de código integrado, usando o seguinte link: Abrir no Cloud Shell.

Outra opção é clonar manualmente o repositório com os comandos abaixo no Cloud Shell:

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

No prompt de comando do Cloud Shell, execute o build inicial do código para permitir que o app seja executado localmente. Pode levar alguns minutos para o script ser executado.

./setup.sh

Faça a auditoria e teste o app. Execute o seguinte comando para iniciar o servidor da Web:

cd microservices
npm start

Saída:

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

Visualize seu aplicativo clicando no ícone de visualização da Web e selecionando "Visualizar na porta 8080".

Isso abrirá uma nova janela onde é possível ver o front-end da Fancy Store em ação.

Você pode fechar esta janela depois de acessar o site. Para interromper o processo do servidor da Web, pressione Control+C (Command+C no Macintosh) na janela do terminal.

4. crie instâncias do Compute Engine

Agora que seu ambiente de desenvolvedor está funcionando, você pode implantar algumas instâncias do Compute Engine. Nas etapas a seguir, você vai:

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

Criar script de inicialização

Um script de inicialização será usado para instruir a instância sobre o que fazer sempre que ela for iniciada. Dessa forma, as instâncias são configuradas automaticamente.

Clique no ícone de lápis na barra lateral do Cloud Shell para abrir o editor de código.

Navegue até a pasta monolith-to-microservices. Clique em Arquivo > Novo arquivo e crie um arquivo chamado startup-script.sh.

No novo arquivo, cole o seguinte código, que você poderá editar depois de colá-lo:

#!/bin/bash

# Install logging monitor. The monitor will automatically pick up logs sent to
# syslog.
curl -s "https://storage.googleapis.com/signals-agents/logging/google-fluentd-install.sh" | bash
service google-fluentd restart &

# Install dependencies from apt
apt-get update
apt-get install -yq ca-certificates git build-essential supervisor psmisc

# Install nodejs
mkdir /opt/nodejs
curl https://nodejs.org/dist/v8.12.0/node-v8.12.0-linux-x64.tar.gz | tar xvzf - -C /opt/nodejs --strip-components=1
ln -s /opt/nodejs/bin/node /usr/bin/node
ln -s /opt/nodejs/bin/npm /usr/bin/npm

# Get the application source code from the Google Cloud Storage bucket.
mkdir /fancy-store
gsutil -m cp -r gs://fancy-store-[DEVSHELL_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.
useradd -m -d /home/nodeapp nodeapp
chown -R nodeapp:nodeapp /opt/app

# 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

Agora, no editor de código, encontre o texto [DEVSHELL_PROJECT_ID] e substitua-o pela saída deste comando:

echo $DEVSHELL_PROJECT_ID

Exemplo de saída:

my-gce-codelab-253520

A linha de código em startup-script.sh será parecida com esta:

gs://fancy-store-my-gce-codelab-253520/monolith-to-microservices/microservices/* /fancy-store/

O script de inicialização executa estas tarefas:

Instalação do agente do Logging, que coleta automaticamente registros do syslog
Instalação do Node.js e do Supervisor, que executa o aplicativo como um daemon
Clonar o código-fonte do app do bucket do Cloud Storage e instalar as dependências
A configuração do Supervisor, que executa o app, garante que o app seja reiniciado em caso de saídas inesperadas ou interrupção por um administrador ou processamento. Em seguida, envia o stdout e o stderr do app ao syslog para que o agente do Logging colete

Copie o arquivo startup-script.sh para o bucket do Cloud Storage criado anteriormente:

gsutil cp ~/monolith-to-microservices/startup-script.sh gs://fancy-store-$DEVSHELL_PROJECT_ID

Ele pode ser acessado 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ó ficará visível para contas de serviço e usuários autorizados e não poderá ser acessado em um navegador da Web. As instâncias do Compute Engine poderão acessá-lo automaticamente pelas contas de serviço.

Copie o código para o bucket do Cloud Storage

Quando as instâncias são iniciadas, elas extraem o código do bucket do Cloud Storage para que você possa armazenar algumas variáveis de configuração no arquivo ".env" do código.

Copie o código clonado no bucket do Cloud Storage:

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Implante a instância de back-end

A primeira instância a ser implantada será a de back-end, que abriga os microsserviços de pedidos e produtos.

Execute o seguinte comando no Cloud Shell para criar uma instância f1-micro que esteja configurada para usar o script de inicialização criado anteriormente e marcada como uma instância de back-end para que você possa aplicar regras de firewall específicas a ela mais tarde:

gcloud compute instances create backend \
    --machine-type=f1-micro \
    --image=debian-9-stretch-v20190905 \
    --image-project=debian-cloud \
    --tags=backend \
    --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh

Configure a conexão para back-end

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

Recupere o endereço IP externo do back-end, que pode ser visualizado no comando a seguir na guia EXTERNAL_IP da instância de back-end:

gcloud compute instances list

Exemplo de saída:

NAME     ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP   STATUS
backend  us-central1-a  f1-micro                   10.128.0.2   34.68.223.88  RUNNING

No editor de código do Cloud Shell, navegue até a pasta monolith-to-microservices > react-app. No menu "Editor de código", selecione Exibir > Alterne os arquivos ocultos para exibir o arquivo .env.

Edite o arquivo .env para apontar para o endereço IP externo do back-end. [BACKEND_ADDRESS] abaixo representa o endereço IP externo da instância de back-end determinada no comando anterior na ferramenta gcloud.

REACT_APP_ORDERS_URL=http://[BACKEND_ADDRESS]:8081/api/orders
REACT_APP_PRODUCTS_URL=http://[BACKEND_ADDRESS]:8082/api/products

Salve o arquivo.

Use o comando a seguir para recriar o app, que vai atualizar o código de front-end:

cd ~/monolith-to-microservices/react-app
npm install && npm run-script build

Copie o código do app no bucket do Cloud Storage:

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Implante a instância de front-end

Agora que o código está configurado, implante a instância de front-end. Execute o seguinte comando para implantar a instância de front-end com um comando semelhante ao anterior, mas essa instância está marcada como "frontend" para fins de firewall.

gcloud compute instances create frontend \
    --machine-type=f1-micro \
    --image=debian-9-stretch-v20190905 \
    --image-project=debian-cloud \
    --tags=frontend \
    --metadata=startup-script-url=https://storage.googleapis.com/fancy-store-$DEVSHELL_PROJECT_ID/startup-script.sh

Configurar a rede

Crie regras de firewall para permitir o acesso às portas 8080 para o front-end e às portas 8081 e 8082 para o back-end. Os comandos de firewall usam as tags atribuídas durante a criação da instância para o app.

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 já deve estar funcionando. Determine o endereço IP externo do front-end. Para determinar o endereço, procure o EXTERNAL_IP da instância de front-end:

gcloud compute instances list

Exemplo de saída:

NAME      ZONE           MACHINE_TYPE  PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP      STATUS
backend   us-central1-a  f1-micro                   10.128.0.2   104.198.235.171  RUNNING
frontend  us-central1-a  f1-micro                   10.128.0.3   34.69.141.9      RUNNING

Pode levar alguns minutos para a instância ser iniciada e configurada. Execute o seguinte comando para monitorar a prontidão do app:

watch -n 5 curl http://[EXTERNAL_IP]:8080

Quando aparecer uma resposta semelhante a esta, o site vai estar pronto. Pressione Control+C (Command+C no Macintosh) no prompt de comando para cancelar o comando watch.

Navegue até http://[FRONTEND_ADDRESS]:8080 com uma nova guia do navegador da Web para acessar o site, em que [FRONTEND_ADDRESS] é o EXTERNAL_IP determinado acima.

Tente navegar até as páginas "Produtos" e "Pedidos", que também devem funcionar.

5. crie grupos gerenciados de instâncias

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

Um grupo gerenciado de instâncias 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 com uma disponibilidade proativa das instâncias, ou seja, no estado "RUNNING". Você vai usar grupos gerenciados de instâncias nas 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 baseado na instância de origem

Antes de criar um grupo gerenciado de instâncias, você precisa criar um modelo de instância que servirá de base para o grupo. Com os modelos de instância, é possível definir 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 máquina virtual (VM). Use os modelos para criar instâncias individuais ou em um grupo gerenciado.

Para criar o modelo, use as instâncias que você já criou.

Primeiro, interrompa as duas instâncias.

gcloud compute instances stop frontend

gcloud compute instances stop backend

Agora, crie o modelo de instância a partir das instâncias 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 de instância foram criados:

gcloud compute instance-templates list

Exemplo de saída:

NAME      MACHINE_TYPE  PREEMPTIBLE  CREATION_TIMESTAMP
fancy-be  f1-micro                   2019-09-12T07:52:57.544-07:00
fancy-fe  f1-micro                   2019-09-12T07:52:48.238-07:00

Criar um grupo gerenciado de instâncias

Você vai criar dois grupos gerenciados de instâncias, um para o front-end e outro para o back-end. Para iniciar, esses grupos gerenciados de instâncias usarão os modelos criados anteriormente e serão configurados para duas instâncias, cada uma em um grupo. As instâncias serão nomeadas automaticamente com base no "base-instance-name" especificado com caracteres aleatórios anexados.

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

No seu aplicativo, o microsserviço de front-end é executado na porta 8080, e os microsserviços de back-end são executados na porta 8081 para pedidos e na porta 8082 para produtos. Como essas portas não são padrão, você vai especificar 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. Essas informações são usadas pelo balanceador de carga, que você vai configurar depois.

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

Configure a recuperação automática

Para melhorar a disponibilidade do app 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 app para conferir se ele está respondendo conforme o esperado. Verificar se um app responde é mais preciso do que apenas verificar se uma instância está no estado RUNNING, que é o comportamento padrão.

Crie uma verificação de integridade que repare a instância como não íntegra três vezes consecutivas para o front-end e o back-end:

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 e 8081:

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

Aplique 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

Continue com o codelab para que a recuperação automática possa monitorar as instâncias no grupo. Mais tarde, você vai simular uma falha para testar a recuperação automática.

6. Criar balanceador de carga

Para complementar nossos grupos gerenciados de instâncias, você vai usar o balanceamento de carga HTTP(S) para veicular o tráfego aos microsserviços de front-end e back-end e usar mapeamentos para enviar tráfego aos serviços de back-end adequados com base nas regras de caminho. Isso vai expor um único endereço IP com carga balanceada para todos os serviços.

Para mais informações sobre as opções de balanceamento de carga disponíveis no Google Cloud, consulte Visão geral do balanceamento de carga.

Criar balanceamento de carga HTTP(S)

O Google Cloud oferece muitos tipos diferentes de balanceamento de carga, mas você vai usar o balanceamento de carga HTTP(S) para o tráfego. O balanceamento de carga HTTP(S) é 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 URLs 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 será 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.

Criar verificações de integridade que serão usadas 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

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.

gcloud compute backend-services add-backend fancy-fe-frontend \
  --instance-group fancy-fe-mig \
  --instance-group-zone us-central1-f \
  --global

gcloud compute backend-services add-backend fancy-be-orders \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-f \
  --global

gcloud compute backend-services add-backend fancy-be-products \
  --instance-group fancy-be-mig \
  --instance-group-zone us-central1-f \
  --global

Crie um mapa de URLs. O mapa define quais URLs são direcionadas para quais 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 os caminhos /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 o proxy vinculado ao mapa de URLs criado.

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

Atualizar a configuração

Agora que você tem um novo endereço IP estático, atualize o código no front-end para apontar para o novo endereço, em vez do endereço temporário usado anteriormente que apontava para a instância de backend.

No Cloud Shell, mude para a pasta React-app, que armazena o arquivo .env que contém 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                    REGION  IP_ADDRESS     IP_PROTOCOL  TARGET
fancy-http-rule          34.102.237.51  TCP          fancy-proxy

Edite o arquivo .env com o editor de texto de sua preferência (como o GNU nano) para apontar para o endereço IP público do balanceador de carga. [LB_IP] representa o endereço IP externo da instância de back-end.

REACT_APP_ORDERS_URL=http://[LB_IP]/api/orders
REACT_APP_PRODUCTS_URL=http://[LB_IP]/api/products

Recrie o app React, que vai atualizar o código de front-end.

cd ~/monolith-to-microservices/react-app
npm install && npm run-script build

Copie o código do aplicativo para o bucket do GCS.

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Atualize as instâncias de front-end

Agora você quer que as instâncias de front-end no grupo gerenciado de instâncias extraiam o novo código. Como as instâncias extraem o código na inicialização, você pode emitir um comando de reinicialização gradual.

gcloud compute instance-groups managed rolling-action restart fancy-fe-mig \
    --max-unavailable 100%

Teste o site

Aguarde cerca de 30 segundos após emitir o comando rolling-action além para dar tempo ao processamento das instâncias. Depois, verifique o status do grupo gerenciado de instâncias até que as instâncias apareçam na lista.

watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig

Depois que os itens aparecerem na lista, saia do comando watch pressionando Control+C (Command+C em Macintosh).

Confirme se o serviço está listado como íntegro.

watch -n 5 gcloud compute backend-services get-health fancy-fe-frontend --global

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

Quando os itens aparecerem na lista, saia do comando watch pressionando Control+C (Command+C no Macintosh).

O aplicativo poderá ser acessado via 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

7. escalonamento no Compute Engine

Até o momento, você criou dois grupos gerenciados de instâncias, cada um com duas instâncias. A configuração é totalmente funcional, mas a configuração estática não depende da 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 a política de escalonamento automático, execute os comandos a seguir no Cloud Shell. Eles vão criar um escalonador automático nos grupos gerenciados de instâncias que adiciona instâncias automaticamente quando o balanceador de carga está com utilização superior a 60% e remove instâncias quando a utilização do balanceador de carga está abaixo de 60%.

gcloud compute instance-groups managed set-autoscaling \
  fancy-fe-mig \
  --max-num-replicas 5 \
  --target-load-balancing-utilization 0.60

gcloud compute instance-groups managed set-autoscaling \
  fancy-be-mig \
  --max-num-replicas 5 \
  --target-load-balancing-utilization 0.60

Ativar a rede de fornecimento de conteúdo

Outro recurso que ajuda no escalonamento é permitir que o Cloud CDN, um serviço de rede de fornecimento de conteúdo, forneça armazenamento em cache para o serviço de front-end. Para isso, execute o seguinte comando no seu serviço de front-end:

gcloud compute backend-services update fancy-fe-frontend \
    --enable-cdn --global

Agora, quando um usuário solicita conteúdo do balanceador de carga, a solicitação chega ao front-end do Google, que primeiro procura no cache do Cloud CDN uma resposta à solicitação. Se o front-end encontrar uma resposta armazenada em cache, ele a enviará ao usuário. Isso é chamado de ocorrência em cache.

Caso contrário, se o front-end não puder encontrar uma resposta armazenada em cache para a solicitação, ele fará uma solicitação diretamente ao back-end. Se a resposta a essa solicitação puder ser armazenada em cache, o front-end armazenará a resposta no cache do Cloud CDN para que o cache possa ser usado para solicitações subsequentes.

8. Atualizar site

Como atualizar o modelo de instância

Não é possível editar os modelos de instâncias atuais. No entanto, como as instâncias não têm estado e toda a configuração é feita pelo script de inicialização, você só precisa mudar o modelo de instância se quiser mudar a imagem principal das configurações do modelo. Agora, você fará uma mudança simples para usar um tipo de máquina maior e fazer isso.

Atualize a instância de front-end, que funciona como base para o modelo de instância. Durante a atualização, você vai colocar um arquivo na versão atualizada da imagem do modelo de instância, depois vai atualizar o modelo de instância, lançar o novo modelo e confirmar se o arquivo existe nas instâncias do grupo gerenciado de instâncias.

Você modificará o tipo de máquina do modelo de instância trocando o tipo de máquina padrão f1-micro para um tipo de máquina personalizado com 4 vCPUs e 3.840 MiB de RAM.

No Cloud Shell, execute o seguinte comando para modificar o tipo de máquina da instância frontend:

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=us-central1-a

Lance o modelo de instância atualizado no grupo gerenciado de instâncias:

gcloud compute instance-groups managed rolling-action start-update fancy-fe-mig \
    --version template=fancy-fe-new

Monitore o status da atualização:

watch -n 2 gcloud compute instance-groups managed list-instances fancy-fe-mig

Quando houver mais de uma instância com o status RUNNING, ACTION definida como None e com INSTANCE_TEMPLATE definido como o nome do novo modelo (fancy-fe-new), copie o nome de uma das máquinas listadas para uso no próximo comando.

Control+S (Command+S no Macintosh) para sair do processo de exibição.

Execute o seguinte comando para ver 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/us-central1-f/machineTypes/custom-4-3840

Fazer mudanças no site

Sua equipe de marketing pediu para você mudar a página inicial do 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 às necessidades da equipe de marketing. Parece que um dos desenvolvedores já criou as alterações com o nome de arquivo index.js.new. Se você copiar o arquivo para index.js, as alterações serão refletidas. Siga as instruções abaixo para fazer as mudanças apropriadas.

Execute os comandos a seguir, copie o arquivo atualizado no arquivo com o nome correto e imprima o conteúdo dele para verificar as alterações:

cd ~/monolith-to-microservices/react-app/src/pages/Home
mv index.js.new index.js
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 { makeStyles } from "@material-ui/core/styles";
import Paper from "@material-ui/core/Paper";
import Typography from "@material-ui/core/Typography";
const useStyles = makeStyles(theme => ({
  root: {
    flexGrow: 1
  },
  paper: {
    width: "800px",
    margin: "0 auto",
    padding: theme.spacing(3, 2)
  }
}));
export default function Home() {
  const classes = useStyles();
  return (
    <div className={classes.root}>
      <Paper className={classes.paper}>
        <Typography variant="h5">
          Fancy Fashion &amp; Style Online
        </Typography>
        <br />
        <Typography variant="body1">
          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!
        </Typography>
      </Paper>
    </div>
  );
}

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 app React e copiar no diretório público monolith:

cd ~/monolith-to-microservices/react-app
npm install && npm run-script build

Em seguida, envie o código novamente para o bucket do Cloud Storage.

cd ~
rm -rf monolith-to-microservices/*/node_modules
gsutil -m cp -r monolith-to-microservices gs://fancy-store-$DEVSHELL_PROJECT_ID/

Enviar alterações por push com atualizações graduais

Agora é possível forçar todas as instâncias a reiniciar para receber a atualização.

gcloud compute instance-groups managed rolling-action restart fancy-fe-mig \
    --max-unavailable=100%

Aguarde cerca de 30 segundos após executar o comando de reinicialização de ação contínua para que as instâncias tenham tempo de processamento. Depois, verifique o status do grupo gerenciado de instâncias até que elas apareçam na lista.

watch -n 5 gcloud compute instance-groups list-instances fancy-fe-mig

Quando os itens aparecerem na lista, saia do comando watch, pressionando Control+S (Command+S no Macintosh).

Execute o seguinte comando para confirmar se o serviço está listado como healthy:

watch -n 5 gcloud compute backend-services get-health fancy-fe-frontend --global

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

Depois que os itens aparecerem na lista, saia do comando watch pressionando Control+S (Command+S em Macintosh).

Para invalidar o conteúdo armazenado em cache na rede de fornecimento de conteúdo e garantir que o conteúdo atualizado seja exibido, execute o seguinte:

gcloud compute url-maps invalidate-cdn-cache fancy-map \
    --path "/*"

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 se a verificação de integridade funciona, faça login em uma instância e interrompa os serviços. Execute o seguinte comando para encontrar um nome de instância:

gcloud compute instance-groups list-instances fancy-fe-mig

Em seguida, proteja o shell em uma das instâncias, em que INSTANCE_NAME é uma das instâncias da lista:

gcloud compute ssh [INSTANCE_NAME]

Na instância, use supervisorctl para interromper o app.

sudo supervisorctl stop nodeapp; sudo killall node

Saia da instância.

exit

Monitorar as operações de reparo.

watch -n 5 gcloud compute operations list \
--filter='operationType~compute.instances.repair.*'

Procure o seguinte exemplo de resposta:

NAME                                                  TYPE                                       TARGET                                 HTTP_STATUS  STATUS  TIMESTAMP
repair-1568314034627-5925f90ee238d-fe645bf0-7becce15  compute.instances.repair.recreateInstance  us-central1-a/instances/fancy-fe-1vqq  200          DONE    2019-09-12T11:47:14.627-07:00

Depois que o reparo for detectado, Control+C (Command+S no Macintosh) para sair do comando de observação. Nesse ponto, o grupo gerenciado de instâncias recria a instância para repará-la.

9. Limpar

Quando tudo estiver pronto, a maneira mais fácil de limpar todas as atividades realizadas é excluir o projeto. A exclusão do projeto exclui o balanceador de carga, as instâncias, os modelos e outros itens criados durante o codelab para garantir que não ocorram cobranças recorrentes inesperadas. Execute o seguinte comando no Cloud Shell, em que PROJECT_ID é o ID completo do projeto, não apenas o nome dele.

gcloud projects delete [PROJECT_ID]

Digite "Y" para confirmar a exclusão quando solicitado.

10. Parabéns!

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