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

1. Introdução

Existem várias maneiras de implantar sites no Google Cloud, e cada solução oferece diferentes recursos, capacidades e níveis de controle. 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, o App Engine ou outras. Com o Compute Engine, você controla todos os detalhes da infraestrutura, inclusive as máquinas virtuais, o 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 um site pode ser implantado e escalonado 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 de instâncias para recuperação automática, balanceamento de carga, escalonamento automático e atualizações graduais do site.

Pré-requisitos

• Para conferir visões gerais introdutórias dos conceitos que vamos usar neste laboratório, confira o material abaixo:
• Bem-vindo ao Google Cloud Platform: os fundamentos do GCP
• Introdução ao Google Cloud Compute Engine
• Como começar a usar o Google Cloud Storage
• Como começar: Cloud Shell

2. configuração do ambiente

Configuração de ambiente personalizada

1. 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.

Observação:para acessar facilmente o console do Cloud, basta memorizar o URL, que é console.cloud.google.com.

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.

Observação: se você estiver usando uma conta do Gmail, deixe o local padrão definido como Sem organização. Se você estiver usando uma conta do Google Workspace, escolha um local adequado para a organização.

2. 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 custos.

Observação:é importante criar um projeto e não reutilizar um existente, já que você vai excluir o projeto para limpar todas as atividades realizadas no codelab.

ativar a API Compute Engine

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

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 seu 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).

1. 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.

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)

Observação: a ferramenta de linha de comando gcloud vem pré-instalada no Cloud Shell, e você terá certeza de que a ferramenta aceita a conclusão da guia. Para mais informações, consulte a visão geral da ferramenta de linha de comando gcloud.

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>

2. 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.

Observação: quando você executava o gcloud na sua própria máquina, as definições de configuração permaneceriam entre as sessões. No Cloud Shell, você precisará configurá-lo para cada nova sessão ou reconexão.

criar 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 comando a seguir para criar um bucket do Cloud Storage:

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

Observação:você vai usar a variável de ambiente $DEVSHELL_PROJECT_ID no Cloud Shell para garantir que os nomes dos objetos sejam exclusivos. Como todos os IDs de projeto do Google Cloud precisam ser exclusivos, anexar o ID também torna os outros nomes exclusivos.

3. clonar o repositório de origem

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

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

Como alternativa, clone 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 sua auditoria e teste o app. Execute o comando a seguir 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!

Para ver o app, clique no ícone de visualização na Web e selecione "Visualizar na porta 8080".

Isso vai abrir uma nova janela com 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.

Observação:na opção de visualização, você pode ver o front-end. No entanto, as funções de produtos e pedidos não funcionam, porque esses serviços ainda não foram expostos nesse método.

4. criar instâncias do Compute Engine

Agora que você tem um ambiente de desenvolvimento funcional, é possível implantar algumas instâncias do Compute Engine. Nas etapas 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 dele 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 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 superior do Cloud Shell para abrir o editor de código.

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

No novo arquivo, cole o código a seguir. Parte dele será editada depois que você colar:

#!/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 do seguinte 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/

Observação:se você estiver usando o editor de código no Cloud Shell, verifique se a opção "End of Line Sequence" está definida como "LF", e não como "CRLF". Para isso, verifique a parte inferior direita do editor de código:

Se ela estiver definida como CRLF, clique em CRLF e selecione "LF" no menu suspenso.

O script de inicialização executa estas tarefas:

• Instalação do agente do Logging, que coleta registros automaticamente do syslog
• Instalação do Node.js e do Supervisor, que executa o app como um daemon
• Clonagem do código-fonte do app no bucket do Cloud Storage e instalação de dependências
• A configuração do Supervisor, que executa o app, garante que ele seja reiniciado em caso de saídas inesperadas ou interrupção por um administrador ou processo, e envia o stdout e o stderr do app ao syslog para coleta pelo agente do Logging.

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

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

Ele agora está 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 estará inacessível pelo navegador da Web. As instâncias do Compute Engine podem ter acesso automático a isso 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.

Observação:você também pode codificar isso 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 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/

Observação:exclua os diretórios de dependências "node_modules" para garantir que o código seja o mais rápido e eficiente possível. Eles são recriados nas instâncias quando elas são iniciadas.

Implante a instância de back-end

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

Observação:em um ambiente de produção, é recomendável separar cada microsserviço na própria instância e no próprio grupo de instâncias para permitir o escalonamento independente. Para fins de demonstração, os microsserviços de back-end (pedidos e produtos) vão residir na mesma instância e grupo de instâncias.

Execute o comando a seguir no Cloud Shell para criar uma instância f1-micro 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

Observação: se a API Compute Engine não foi ativada nas etapas anteriores, a ferramenta de linha de comando gcloud vai perguntar: "Você quer ativar e tentar de novo? Isso vai levar alguns minutos". Selecione "y" para ativar a API Compute Engine.

Observação:se você precisar especificar uma zona, verifique se uma zona padrão foi configurada anteriormente na seção de configuração do ambiente.

Configure a conexão para back-end

Antes de implantar o front-end do app, 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 visto com o seguinte comando 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 do editor de código, selecione Visualizar > Alternar arquivos ocultos para ver 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 seguinte comando 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

Copie o código do app 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/

Implante a instância de front-end

Agora que o código está configurado, você pode implantar a instância de front-end. Execute o comando a seguir 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 

Observação:você está usando um comando de implantação e um script de inicialização semelhantes para as instâncias de front-end e back-end. Isso é para simplificar 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 na amostra. No entanto, em um ambiente de produção, você só executaria os microsserviços necessários em cada componente.

Configurar a rede

Crie regras de firewall de acesso à porta 8080 para o front-end e às portas 8081 e 8082 para o back-end. Os comandos do 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 agora deve estar funcional. 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 para monitorar a prontidão do app:

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

Quando aparecer uma saída parecida com a seguinte, o site estará pronto. Pressione Control+C (Command+C no Macintosh) no prompt de comando para cancelar o comando "watch".

Acesse http://[FRONTEND_ADDRESS]:8080 em uma nova guia do navegador 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 estar funcionando.

Observação:se você parar neste ponto e não escalonar o ambiente, as instâncias precisarão ser configuradas para usar endereços IP estáticos. Continue criando grupos gerenciados de instâncias e um balanceador de carga, mesmo que não seja necessário um escalonamento alto, para que a redundância e a recuperação automática possam ser implementadas.

5. criar grupos gerenciados de instâncias

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

Um grupo gerenciado de instâncias contém instâncias idênticas que podem ser gerenciadas como uma única entidade em uma única 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 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.

Crie 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, 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 máquina virtual (VM). Você pode 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.

Primeiro, interrompa as duas instâncias.

gcloud compute instances stop frontend

gcloud compute instances stop backend

Agora, crie o modelo de instância com base nas 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, os grupos gerenciados de instâncias vão usar os modelos criados anteriormente 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.

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, 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. Essas informações são usadas pelo balanceador de carga, que você vai configurar mais tarde.

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.

Uma política de recuperação automática depende de uma verificação de integridade baseada em app 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:você vai usar verificações de integridade separadas para o balanceador de carga e a recuperação automática. As verificações de integridade para o balanceador de carga podem e precisam ser mais agressivas, já que elas determinam se uma instância recebe tráfego do usuário. Convém detectar 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 de integridade de um balanceador de carga.

Crie uma verificação de integridade que repare a instância caso ela apareça três vezes consecutivas como "unhealthy" 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

Observação:a recuperação automática pode levar 15 minutos para começar a monitorar as instâncias no grupo.

Continue com o codelab para que a recuperação automática possa monitorar as instâncias do grupo. Depois, 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ê usará o balanceamento de carga HTTP(S) para veicular o tráfego aos microsserviços de front-end e back-end e mapeamentos para enviar o tráfego aos serviços de back-end adequados com base nas regras de caminho. Isso vai expor um único endereço IP com balanceamento de carga 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 vários tipos de balanceamento de carga, mas você vai usar o balanceamento de carga HTTP(S) para seu tráfego. O balanceamento de carga HTTP(S) é estruturado da seguinte maneira:

1. Uma regra de encaminhamento direciona as solicitações recebidas para um proxy HTTP de destino.
2. O proxy HTTP de destino verifica cada solicitação em um mapa de URLs para determinar o serviço de back-end apropriado.
3. 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.
4. 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, cada instância nos serviços de back-end precisará ter um certificado SSL.

Observação:para evitar a complexidade dos certificados SSL, use HTTP em vez de HTTPS. Para produção, é recomendável usar HTTPS para a criptografia quando possível.

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:as verificações de integridade são para o balanceador de carga e apenas direcionam o tráfego dele. Elas não fazem com que os grupos de instâncias gerenciadas recriem 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.

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 um 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 frontend para apontar para o 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 do 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

Observação:as portas são removidas no novo endereço porque o balanceador de carga está configurado para processar o encaminhamento para você.

Recrie o react-app, que vai atualizar o código do 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 quando iniciam, você pode emitir um comando de reinicialização contínua.

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

Observação:nesse exemplo de reinicialização contínua, você especificou que todas as máquinas podem ser reinicializadas imediatamente usando o parâmetro --max-unavailable. Sem isso, o comando manteria uma instância ativa enquanto reiniciava outras. Por se tratar de um teste, especifique para reiniciar todas as instâncias imediatamente para agilizar o processo.

Teste o site

Aguarde cerca de 30 segundos após executar o comando rolling-action restart para que as instâncias sejam processadas. Em seguida, 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

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

Confirme se o serviço está listado como em bom estado.

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 estará 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

7. escalonar o Compute Engine

Até agora, você criou dois grupos gerenciados de instâncias, cada um com duas instâncias. 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.

Redimensione automaticamente por uso

Para criar a política de escalonamento automático, execute os seguintes comandos no Cloud Shell. Eles vão criar 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%.

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 é a ativação do Cloud CDN, um serviço de rede de fornecimento de conteúdo, para oferecer armazenamento em cache para o serviço de front-end. Para isso, execute o seguinte comando no 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 a um front-end do Google, que primeiro procura no cache do Cloud CDN uma resposta à solicitação do usuário. Se o front-end encontrar uma resposta em cache, ele a enviará para o usuário. Isso é chamado de ocorrência em cache.

Caso contrário, se o front-end não 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 vai armazenar a resposta no cache do Cloud CDN para que ele possa ser usado em solicitações subsequentes.

8. Atualizar o site

Como atualizar o modelo de instância

Não é possível editar modelos de instância atuais. No entanto, 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 ou a imagem principal. 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 é 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 de instância, lance o novo modelo e confirme que esse arquivo está nas instâncias do grupo gerenciado de instâncias.

Você vai modificar o tipo de máquina do modelo de instância de um f1-micro padrão para um tipo de máquina personalizado com 4 vCPUs e 3840 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

Implante 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 mais de uma instância estiver com o status EM EXECUÇÃO, a AÇÃO definida como Nenhuma e o INSTANCE_TEMPLATE definido como o novo nome do modelo (fancy-fe-new), copie o nome de uma das máquinas listadas para usar 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

Faça 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 ao pedido da equipe de marketing. Parece que um dos seus desenvolvedores já criou as mudanças com o nome de arquivo index.js.new. Você pode copiar o arquivo para index.js, e as mudanças vão aparecer. 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 para verificar as mudanças:

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

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

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

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

Enviar mudanças com atualizações graduais

Agora é possível forçar a reinicialização de todas as instâncias para efetuar a atualização.

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

Observação:neste exemplo de reinicialização gradual, você faz uma declaração específica de que todas as máquinas podem ser reiniciadas imediatamente usando o parâmetro --max-unavailable. Sem isso, o comando manteria uma instância ativa enquanto reiniciava outras. Por se tratar de um teste, você pode reiniciar 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.

Aguarde cerca de 30 segundos e execute o comando rolling-action restart para que as instâncias sejam processadas. Depois verifique o status do grupo gerenciado de instâncias até as instâncias aparecerem 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 que 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

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

Para invalidar o conteúdo 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.

Observação:se o novo conteúdo não aparecer, atualize a página da Web com Control+F5 (Command+Shift+R no Macintosh) no Google Chrome para garantir que o conteúdo armazenado em cache seja baixado novamente.

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 seguinte comando para encontrar um nome de instância:

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

Em seguida, acesse uma das instâncias via Secure Shell, 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

Monitore as operações de reparo.

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

Procure o seguinte exemplo de saída:

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 notado, pressione Control+C (Command+S no Macintosh) para sair do comando "watch". Nesse ponto, o grupo gerenciado de instâncias recria a instância para repará-la.

9. Limpar

Quando estiver tudo 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 haja cobranças recorrentes inesperadas. Execute o seguinte no Cloud Shell, em que PROJECT_ID é o ID completo do projeto, não apenas o nome dele.

gcloud projects delete [PROJECT_ID]

Confirme a exclusão digitando "Y" quando solicitado.

Se você não tiver certeza do ID do projeto, execute gcloud config list | grep project no Cloud Shell para encontrá-lo.

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.