Implantar um site com o Cloud Run

1. Antes de começar

Administrar sites pode ser trabalhoso. É preciso criar e gerenciar instâncias de máquinas virtuais (VMs), 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.

Neste codelab, você vai começar com uma imagem 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 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

2. configuração do ambiente

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

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

3. clonar o repositório de origem

Como você vai implantar um site que já existe, basta clonar a origem do repositório e depois criar as imagens 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 apropriado. 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 auditoria e teste o app. Execute o comando a seguir para iniciar o servidor da Web:

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

Saída:

Monolith listening on port 8080!

Para ver 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.

4. criar o contêiner do Docker com o Cloud Build

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

Normalmente, você teria que 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 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 seguinte comando 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 seus builds anteriores. Por enquanto, haverá apenas um (o que você criou).

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

5. Implantar contêiner no Cloud Run

Agora que você já colocou o site em um contêiner e enviou o contêiner para o Container Registry, é hora de implantar o site 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 extra 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 o app. 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.

Verificar 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**: você também pode 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.

6. criar uma revisão com simultaneidade menor

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

7. Faça mudanças no site

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 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. 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 aplicativo React e copiar ele 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.

8. atualizar o site 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 de entrada de um 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

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

9. Limpar

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

10. Parabéns

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