1. Antes de começar
Executar sites pode ser difícil, já que é necessário criar e gerenciar instâncias de máquina virtual (VM), clusters, pods, serviços e muito mais. Isso não é um problema para apps maiores e com várias camadas, mas se você estiver apenas tentando implantar e tornar o site visível, haverá muita sobrecarga.
Com o Cloud Run, a implementação do Knative no Google Cloud, é possível gerenciar e implantar seu site sem o overhead necessário para implantações baseadas em VM ou 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.
Além de levar o desenvolvimento sem servidor para os contêineres do Cloud Run, ele também pode ser executado nos seus 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ê testará o segundo caso.
O diagrama a seguir ilustra o fluxo de implantação e hospedagem do Cloud Run. Você começa com uma imagem Docker criada pelo Cloud Build, que pode ser acionada no Cloud Shell. Em seguida, implante essa imagem no Cloud Run com um comando no Cloud Shell.
Pré-requisitos
- Familiaridade geral com o Docker (consulte a seção Primeiros passos 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 que é executado dentro de 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 do projeto
2. Configuração do ambiente
Configuração de ambiente personalizada
Se você ainda não tiver uma Conta do Google, crie uma. Em seguida, faça login no Console do Google Cloud e clique em Projeto > Criar projeto.
Lembre-se do ID do projeto, que é preenchido automaticamente no nome do projeto. O ID do projeto é um nome exclusivo em todos os projetos do Google Cloud. Portanto, o nome na captura de tela já foi feito e não vai funcionar para você. Mais adiante, faremos referência e ele como PROJECT_ID.
Em seguida, você precisa ativar 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". Depois 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 se 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ê 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).
- 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)
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.
3. clone o repositório de origem
Como você está implantando um site atual, basta clonar a origem do seu repositório. Assim, é possível se concentrar na criação de imagens do Docker e na 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. Instale 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 o repositório, altera o diretório e instala as dependências necessárias para executar localmente seu aplicativo. Pode levar alguns minutos para o script ser executado.
Faça a auditoria 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 ver sua Fancy Store em ação!
Você pode fechar esta janela depois de acessar o site. Para interromper o processo do web-server, 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, é necessário adotar uma abordagem de duas etapas, que envolve criar um contêiner do Docker e enviá-lo para um registro, onde a imagem é armazenada e pode ser extraída pelo GKE. No entanto, é possível facilitar sua vida usando o Cloud Build para criar o contêiner do Docker e colocar a imagem no 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 move os arquivos do diretório para um bucket do Cloud Storage. Em seguida, todos os arquivos do bucket e o Dockerfile no mesmo diretório são usados para executar o processo de build no Docker. Como você especificou a flag --tag com o host como gcr.io para a imagem do Docker, a imagem Docker resultante será enviada ao Container Registry.
Primeiro, você precisa verificar 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, mas, após a conclusão, o terminal mostra uma saída parecida com esta:
----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- 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 acessar seu histórico de versões ou acompanhar o processo em tempo real, acesse o console do Cloud e clique em Menu de navegação ☰ > Cloud Build > Histórico. Você verá uma lista de todos os builds anteriores, mas apenas o que você criou.
Clique em Build id para ver todos os detalhes da versão, incluindo a saída do registro. Para visualizar a imagem do contêiner que foi criada, clique no link ao lado de Imagem.
5. implantar o contêiner no Cloud Run
Agora que você conteinerizou seu site e o enviou para o Container Registry, é hora de implantá-lo 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ê usará essa abordagem neste codelab.
- O Cloud Run for Anthos é o Cloud Run com uma camada extra de controle, que permite migrar 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ê já configurou.
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 em qual região quer executar. Selecione a região mais próxima de você e aceite o nome de serviço padrão sugerido (monolítico).
Para fins de teste, permita solicitações não autenticadas ao aplicativo. Digite y no prompt.
Verifique a implantação
Para verificar se a implantação foi criada corretamente, execute o comando a seguir. Pode levar alguns instantes para Pod status se tornar 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. Você pode ver a implantação, o usuário que a implantou (seu endereço de e-mail) e o URL que pode ser usado para acessar o aplicativo. Parece que tudo foi criado corretamente.
Abra o URL fornecido na lista de serviços no seu navegador da Web para ver o mesmo site que você visualizou localmente.
6. Criar uma revisão com simultaneidade menor
Agora, implante o app novamente, mas desta vez ajuste um dos parâmetros.
Por padrão, um aplicativo do Cloud Run tem um valor de simultaneidade de 80, o que significa que cada instância de contêiner atenderá até 80 solicitações por vez. Isso é 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 de 1 (apenas para fins de teste) e descubra 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 você fez na primeira vez. Quando o comando for executado, verifique o console do Cloud para conferir o resultado.
No painel do Cloud Run, clique no serviço do monolith para ver os detalhes.
Clique na guia Revisões. Duas revisões serão criadas. Clique em monolith-00002 e revise os detalhes. O valor de simultaneidade será reduzido a 1.
]
Essa configuração é suficiente para testes, mas na maioria dos cenários de produção você terá contêineres que aceitam várias solicitações simultâneas.
Agora, restaure a simultaneidade original sem fazer a implantação outra vez. É possível definir o valor de simultaneidade como o padrão de 80 ou 0, o que vai remover todas as restrições de simultaneidade e defini-lo como o máximo padrão (que também é 80 no momento da gravação).
Execute o seguinte comando 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
Observe que outra revisão foi criada, que o tráfego foi redirecionado e que a simultaneidade voltou para 80.
7. Fazer mudanças no site
Sua equipe de marketing pediu para você mudar a página inicial do site da empresa. Ele acha que deveria ser mais informativo sobre o que a empresa é e vende. 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 mudanças com o nome de arquivo index.js.new. Basta copiar esse arquivo para index.js, e as mudanças serão aplicadas. Siga as instruções para fazer as alterações apropriadas.
Execute os comandos a seguir, copie o arquivo atualizado para o nome de arquivo correto e imprima o conteúdo dele 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 & 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. Você pode usar o mesmo comando usado anteriormente, mas atualizará o identificador 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 o 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á colocada on-line e, em seguida, o tráfego será redirecionado para ela.
Siga as próximas instruções para atualizar seu site.
Linha de comando
Na linha de comando, reimplante 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
Valide a atualização da implantação executando 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
...
Você verá que o serviço agora está usando a versão mais recente da imagem implantada em uma nova revisão.
Para verificar as mudanças, acesse o URL externo do serviço do Cloud Run novamente e observe que o título do app foi atualizado.
Execute o seguinte comando para listar os serviços e ver o endereço IP se você tiver esquecido:
gcloud run services list
O site agora vai exibir o texto que você adicionou ao componente da página inicial.
9. Limpar
Excluir imagens do Container Registry
# 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 do Cloud Storage
# 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.