Implantar um site com o Cloud Run

Administrar sites pode ser trabalhoso. É preciso criar e gerenciar instâncias de máquina virtual (VM), clusters, pods, serviços etc. Esse processo faz sentido para aplicativos grandes e com vários níveis, mas não é necessário se você quiser apenas implantar um site e torná-lo visível.

Com o Cloud Run, a implementação do Google Cloud do Knative, é possível gerenciar e implantar seu site sem o overhead necessário para implantações baseadas em VM ou no Kubernetes. Além de simplificar o gerenciamento, essa abordagem também permite a redução da escala a zero quando o site não está recebendo solicitações.

O Cloud Run não apenas leva o desenvolvimento sem servidor para os contêineres, mas também pode ser executado em clusters do Google Kubernetes Engine (GKE) ou em uma solução de plataforma como serviço (PaaS) totalmente gerenciada fornecida pelo Cloud Run. Neste codelab, você vai testar o segundo cenário.

O diagrama a seguir ilustra o fluxo da implantação e hospedagem do Cloud Run. Você vai começar com uma imagem do Docker criada pelo Cloud Build, que é acionada no Cloud Shell. Em seguida, você vai implantar essa imagem no Cloud Run com um comando no Cloud Shell.

Pré-requisitos

• Familiaridade geral com o Docker. Consulte a seção Começar do site do Docker.

O que você vai aprender

• Como criar uma imagem do Docker com o Cloud Build e fazer upload dela para gcr.io
• Implantar imagens do Docker no Cloud Run
• Gerenciar implantações do Cloud Run
• Como configurar um endpoint para um app no Cloud Run

O que você vai criar

• Um site estático executado em um contêiner do Docker
• Uma versão desse contêiner que fica no Container Registry
• Uma implantação do Cloud Run para seu site estático

O que é necessário

• Uma Conta do Google com acesso administrativo para criar projetos ou um projeto com o papel de proprietário

Configuração de ambiente personalizada

Se você ainda não tem uma Conta do Google, crie uma. Em seguida, faça login no console do Google Cloud e clique em Projeto > Criar projeto.

Guarde o ID do projeto, que é preenchido automaticamente abaixo do nome dele. O ID do projeto é um nome exclusivo em todos os projetos do Google Cloud. Portanto, o nome na captura de tela já foi usado e não vai funcionar para você. Ele será chamado de PROJECT_ID.

Em seguida, ative o faturamento no console do Cloud para usar os recursos do Google Cloud e ativar a API Cloud Run.

ativar a API Cloud Run

Clique em Menu de navegação ☰ > APIs e serviços > Painel > Ativar APIs e serviços. .

Pesquise "API Cloud Run" e clique em API Cloud Run > Ativar.

A execução deste codelab não deve custar mais do que alguns dólares, mas pode ser mais se você decidir usar mais recursos ou deixá-los em execução. Consulte Limpeza no final. Para saber mais informações, consulte Preços.

Novos usuários do Google Cloud estão qualificados para um teste sem custo financeiro de US$300.

Cloud Shell

Embora o Google Cloud e o Cloud Run possam ser operados remotamente do seu laptop, você vai usar o Cloud Shell, um ambiente de linha de comando executado no Google Cloud. O ambiente é pré-configurado com todas as bibliotecas de cliente e frameworks necessários.

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 permanente de 5 GB, além de ser executada no Google Cloud, o que 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 Google Cloud Shell, clique no botão no canto superior direito do console do desenvolvedor. Leva apenas alguns instantes para provisionar e se conectar ao ambiente:

Clique no botão "Iniciar Cloud Shell":

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 : gcloud é a ferramenta de linha de comando poderosa e unificada do Google Cloud Platform. A documentação completa está disponível em https://cloud.google.com/sdk/gcloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.

gcloud config list project

Resposta ao comando

[core]
project = <PROJECT_ID>

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>

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:

IMPORTANTE: por fim, 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. Saiba mais na documentação sobre Zonas e Regiões.

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

Como você vai implantar um site que já existe, basta clonar o código-fonte do repositório e depois criar as imagens do Docker e fazer a implantação no Cloud Run.

Execute os comandos a seguir para clonar o repositório na sua instância do Cloud Shell e acessar o diretório correto. Você também vai instalar as dependências do Node.js para testar o app antes da implantação.

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

Isso clona seu repositório, muda para o diretório e instala as dependências necessárias para executar o app localmente. A execução do script pode levar alguns minutos.

Faça sua diligência e teste o app. Execute o seguinte comando para iniciar o servidor da Web:

cd ~/monolith-to-microservices/monolith
npm start

Saída:

Monolith listening on port 8080!

Para visualizar o app, clique em Visualização na Web e selecione Visualizar na porta 8080.

Isso abre uma nova janela onde é possível conferir sua 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.

Agora que os arquivos de origem estão prontos, é hora de colocar o app no Docker.

Normalmente, você precisaria seguir uma abordagem de duas etapas que envolve a criação de um contêiner do Docker e o envio dele para um registro, onde a imagem é armazenada e pode ser extraída pelo GKE. No entanto, existe um jeito mais fácil: crie o contêiner do Docker no Cloud Build e envie a imagem para o Container Registry com um único comando. Para ver o processo manual de criação e envio de um Dockerfile, consulte o guia de início rápido do Container Registry.

O Cloud Build compacta e envia os arquivos do diretório para um bucket do Cloud Storage. Em seguida, o processo de build usa todos os arquivos do bucket e o Dockerfile, que está presente no mesmo diretório para executar o processo de build do Docker. Como você especificou a flag --tag com o host gcr.io para a imagem do Docker, a imagem resultante será enviada ao Container Registry.

Primeiro, verifique se a API Cloud Build está ativada. Para isso, execute o seguinte comando:

gcloud services enable cloudbuild.googleapis.com

Depois de ativar a API, execute o comando a seguir no Cloud Shell para iniciar o processo de build:

gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 .

Esse processo leva alguns minutos. Quando a compilação estiver pronta, o terminal vai mostrar o seguinte:

-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
ID                                    CREATE_TIME                DURATION  SOURCE                                                                                  IMAGES                              STATUS
1ae295d9-63cb-482c-959b-bc52e9644d53  2019-08-29T01:56:35+00:00  33S       gs://<PROJECT_ID>_cloudbuild/source/1567043793.94-abfd382011724422bf49af1558b894aa.tgz  gcr.io/<PROJECT_ID>/monolith:1.0.0  SUCCESS

Para consultar o histórico de builds ou acompanhar o processo em tempo real, acesse o console do Cloud e clique em Menu de navegação ☰ > Cloud Build > Histórico. Essa tela apresenta uma lista de todos os builds anteriores. Por enquanto, haverá apenas um (o que você acabou de criar).

Se clicar no ID do build, você vai encontrar todos os detalhes da versão, incluindo a saída do registro. Para ver a imagem do contêiner criada, clique no link ao lado de Imagem.

Agora que você já fez a conteinerização do site e enviou o contêiner para o Container Registry, é hora de implantar no Cloud Run.

Há duas abordagens de implantação no Cloud Run:

• O Cloud Run (totalmente gerenciado) é o modelo de PaaS em que todo o ciclo de vida do contêiner é gerenciado. Você vai usar essa abordagem neste codelab.
• O Cloud Run for Anthos é o Cloud Run com uma camada adicional de controle, que permite integrar seus clusters e pods do GKE. Para mais informações, consulte Como configurar o Cloud Run for Anthos no Google Cloud.

Os exemplos de linha de comando estarão no Cloud Shell usando as variáveis de ambiente que você configurou anteriormente.

Linha de comando

Execute o comando a seguir para implantar o app:

gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --platform managed 

Você precisará especificar a região em que quer executar. Selecione a região mais próxima de você e aceite o nome de serviço padrão sugerido (monolith).

Para fins de teste, permita solicitações não autenticadas ao app. Digite y no prompt.

Verifique a implantação

Para verificar se a implantação foi criada corretamente, execute o seguinte comando: Pode levar alguns instantes para que o Pod status fique Running:

gcloud run services list

Selecione [1] Cloud Run (totalmente gerenciado).

Saída:

SERVICE   REGION    URL  LAST DEPLOYED BY          LAST DEPLOYED AT
✔  monolith  us-east1 <your url>  <your email>  2019-09-16T21:07:38.267Z

A saída mostra várias informações: a implantação, o usuário que a executou, ou seja, seu endereço de e-mail e o URL para acessar o aplicativo. Parece que tudo foi criado corretamente.

Abra o URL fornecido na lista de serviços no navegador da Web. Você vai ver o mesmo site que visualizou localmente.

Observação:também é possível conferir suas implantações do Cloud Run no Console do Cloud. Clique em Menu de navegação ☰ > Cloud Run para conferir o painel com o serviço implantado.

Agora, implante o app novamente, mas ajuste um dos parâmetros.

Por padrão, um app do Cloud Run tem um valor de simultaneidade de 80, o que significa que cada instância de contêiner atende até 80 solicitações por vez. É uma diferença considerável em relação ao modelo de funções como serviço (FaaS), em que uma instância processa uma solicitação por vez.

Implante novamente a mesma imagem de contêiner com um valor de simultaneidade "1" (apenas para fins de teste) e veja o que acontece.

gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --platform managed --concurrency 1

Responda às próximas perguntas como fez na primeira vez. Depois que o comando for executado, confira o resultado no console do Cloud.

No painel do Cloud Run, clique no serviço monolith para conferir os detalhes.

Clique na guia Revisões. Agora haverá duas revisões. Clique em monolith-00002 e confira os detalhes. O valor de simultaneidade vai ser reduzido para 1.

]

Essa configuração pode ser usada para testes, mas geralmente os contêineres processam várias solicitações simultâneas nos cenários de produção.

Agora, restaure a simultaneidade original sem fazer outra implantação. Você pode definir o valor de simultaneidade como o padrão 80 ou 0, o que remove as restrições de simultaneidade e define o valor máximo padrão, que é 80 no momento da redação deste artigo.

Execute o comando a seguir no Cloud Shell para atualizar a revisão atual:

gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --platform managed --concurrency 80

Você vai perceber que outra revisão foi criada, que o tráfego foi redirecionado e que a simultaneidade voltou para "80".

Sua equipe de marketing pediu para você mudar a página inicial do site da empresa. Ela acha que o site deve oferecer mais informações sobre a 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. Basta copiar esse arquivo para index.js, e as mudanças vão aparecer. Siga as instruções 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 app React e copiar no diretório público monolith:

cd ~/monolith-to-microservices/react-app
npm run build:monolith

Agora que o código foi atualizado, é necessário recriar o contêiner do Docker e publicá-lo no Container Registry. Use o mesmo comando de antes, mas atualize o indicador de versão desta vez.

Execute este comando para acionar o Cloud Build de novo com a imagem atualizada na versão 2.0.0:

cd ~/monolith-to-microservices/monolith

#Feel free to test your application
npm start

gcloud builds submit --tag gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 .

Na próxima seção, você vai usar essa imagem para atualizar seu app sem inatividade.

As alterações foram feitas, e a equipe de marketing adorou a nova versão. É hora de atualizar o site sem interromper o serviço para os usuários.

O Cloud Run trata cada implantação como uma nova revisão, que será implantada on-line e depois terá o tráfego redirecionado para ela.

Observação:por padrão, 100% do tráfego do serviço será atribuído à revisão mais recente. É possível usar rotas para alocar porcentagens diferentes de tráfego para revisões específicas em um serviço.

Siga as próximas instruções para atualizar seu site.

Linha de comando

Na linha de comando, é possível reimplantar o serviço para atualizar a imagem para uma nova versão com o seguinte comando:

gcloud run deploy --image=gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 --platform managed

Verifique a implantação

Para validar a atualização da implantação, execute o seguinte comando:

gcloud run services describe monolith --platform managed 

A saída será semelhante ao seguinte:

apiVersion: serving.knative.dev/v1alpha1
kind: Service
metadata:
  annotations:
    client.knative.dev/user-image: gcr.io/my-cloudrun-codelab/monolith:2.0.0
...

Observe que o serviço agora está usando a versão mais recente da imagem, que foi implantada como uma nova revisão.

Para verificar as mudanças, acesse novamente o URL externo do serviço do Cloud Run e note que o título do app foi atualizado.

Execute o comando a seguir para listar os serviços e ver o endereço IP, caso tenha esquecido:

gcloud run services list

O site agora mostra o texto que você adicionou ao componente da página inicial.

Excluir imagens do Container Registry

Observação:se você criou outras versões, use a mesma sintaxe para excluir essas imagens também. Este codelab pressupõe que você seguiu as instruções exatamente e só tem duas tags.

# Delete the container image for version 1.0.0 of our monolith
gcloud container images delete gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:1.0.0 --quiet

# Delete the container image for version 2.0.0 of our monolith
gcloud container images delete gcr.io/${GOOGLE_CLOUD_PROJECT}/monolith:2.0.0 --quiet

Excluir artefatos do Cloud Build no Cloud Storage

Observação:se você usou o Cloud Build para artefatos diferentes dos deste codelab, será necessário excluir manualmente a origem de gs://<PROJECT_ID>_cloudbuild/source.

# The following command will take all source archives from all builds and delete them from cloud storage

# Run this command to print all sources:
# gcloud builds list | awk 'NR > 1 {print $4}' 

gcloud builds list | awk 'NR > 1 {print $4}' | while read line; do gsutil rm $line; done

Excluir serviço do Cloud Run

gcloud run services delete monolith --platform managed

Você implantou, escalonou e atualizou seu site com o Cloud Run.

Saiba mais

• Documentação do Docker
• Documentação do Google Kubernetes Engine
• Documentação do Cloud Build
• Documentação do Container Registry