1. Introdução
Por que é tão difícil gerenciar aplicativos?
Um grande motivo é que os desenvolvedores muitas vezes precisam ser administradores de sistema em meio período. Considere esta lista (parcial) de preocupações para desenvolver, implantar e gerenciar um aplicativo da Web moderno de produção :
Não sei você, mas não quero me preocupar com essas coisas! O que eu realmente quero pensar é a lógica do meu aplicativo:
Resumindo, o Cloud Run é isso, permitindo que você se concentre no seu aplicativo e deixe toda a administração e manutenção para outra pessoa, ou seja, o Google, que investiu milhões de horas no refinamento e no aperfeiçoamento de habilidades nessa área.
Além dos desafios administrativos mencionados acima, você também precisa lidar com:
- Dependências: o ambiente em que o app é executado precisa, sempre que possível, corresponder exatamente ao ambiente em que foi testado. Isso pode abranger várias dimensões, incluindo sistema operacional, bibliotecas de suporte, intérprete ou compilador de linguagem, configuração de hardware e muitos outros fatores.
- Distribuição: migrar de uma versão local de um app para uma versão compartilhada na Internet geralmente requer uma mudança no ambiente de execução, um salto quântico na complexidade e uma curva de aprendizado acentuada.
O Cloud Run cuida dessas e muitas outras preocupações para você. Mas, em vez de acreditar na minha palavra, vamos criar um aplicativo juntos e ver como é fácil fazer a transição de um ambiente de desenvolvimento local para um aplicativo na nuvem de nível de produção em apenas algumas etapas simples.
O que você vai fazer…
- Você criará um app da Web simples e verificará se ele é executado conforme o esperado no seu ambiente de desenvolvimento.
- Depois, você vai acessar uma versão conteinerizada do mesmo app. Ao longo do caminho, você vai explorar o que significa conteinerização e por que ela é tão útil.
- Por fim, você vai implantar o app na nuvem e ver como é fácil gerenciar o serviço do Cloud Run usando a linha de comando e o console do Google Cloud.
O que você vai aprender…
- Como criar um app de servidor da Web simples em Python
- Como empacotar o app em um contêiner do Docker que pode ser executado em qualquer lugar
- Como implantar o app na nuvem para que qualquer pessoa possa testar sua nova criação
- Como simplificar ainda mais as etapas acima usando Buildpacks.
- Como usar a ferramenta de linha de comando do Google Cloud e a IU da Web do Console do Cloud
O que é necessário…
- Um navegador da Web
- Uma Conta do Google
Este laboratório é voltado para desenvolvedores com todos os níveis de conhecimento, inclusive iniciantes. Embora você esteja usando Python, não é preciso estar familiarizado com programação em Python para entender o que está acontecendo, porque vamos explicar todo o código que você usar.
2. Começar a configuração
Nesta seção, você vai encontrar tudo o que precisa fazer para começar o laboratório.
Configuração de ambiente autoguiada
- Faça login no console do Cloud e crie um novo projeto ou reutilize um existente. Crie uma conta do Gmail ou do Google Workspace, se ainda não tiver uma.
Lembre-se do código do projeto, um nome exclusivo em todos os projetos do Google Cloud. O nome acima já foi escolhido e não servirá para você. Faremos referência a ele mais adiante neste codelab como PROJECT_ID.
- Em seguida, será necessário ativar o faturamento no Console do Cloud para usar os recursos do Google Cloud.
A execução deste codelab não será muito cara, se for o caso. Siga todas as instruções na seção "Limpeza", que orienta você sobre como encerrar recursos para não incorrer em cobranças além deste tutorial. Novos usuários do Google Cloud estão qualificados para o programa de US$300 de teste sem custo financeiro.
Inicie o Cloud Shell.
Neste laboratório, você vai trabalhar em uma sessão do Cloud Shell, que é um interpretador de comandos hospedado por uma máquina virtual em execução na nuvem do Google. A sessão também pode ser executada localmente no seu computador, mas se você usar o Cloud Shell, todas as pessoas vão ter acesso a uma experiência reproduzível em um ambiente consistente. Após concluir o laboratório, é uma boa ideia testar a sessão no seu computador.
Ativar o Cloud Shell
- No Console do Cloud, clique em Ativar o Cloud Shell
.
Se você nunca iniciou o Cloud Shell antes, uma tela intermediária (abaixo da dobra) será exibida com a descrição dele. Se esse for o caso, clique em Continuar (e você não verá mais esse aviso). Esta é a aparência dessa tela única:
Leva apenas alguns instantes para provisionar e se conectar ao Cloud Shell.
Essa máquina virtual tem 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. Praticamente todo o seu trabalho neste codelab pode ser feito em um navegador ou no seu Chromebook.
Depois de se conectar ao Cloud Shell, você já estará autenticado e o projeto já estará configurado com seu ID do projeto.
- Execute o seguinte comando no Cloud Shell para confirmar que você está autenticado:
gcloud auth list
Resposta ao comando
Credentialed Accounts
ACTIVE ACCOUNT
* <my_account>@<my_domain.com>
To set the active account, run:
$ gcloud config set account `ACCOUNT`
- Execute o seguinte comando no Cloud Shell para confirmar que o comando gcloud sabe sobre seu projeto:
gcloud config list project
Resposta ao comando
[core] project = <PROJECT_ID>
Se o projeto não estiver configurado, configure-o usando este comando:
gcloud config set project <PROJECT_ID>
Resposta ao comando
Updated property [core/project].
Defina algumas variáveis de ambiente no terminal que facilitarão a vida nas próximas etapas:
export PROJ=$GOOGLE_CLOUD_PROJECT export APP=hello export PORT=8080 export REGION="us-central1" export TAG="gcr.io/$PROJ/$APP"
Ative as APIs
Nas próximas etapas, você vai saber onde e por que esses serviços são necessários. Por enquanto, execute este comando para conceder ao seu projeto acesso aos serviços do Cloud Build, Container Registry e Cloud Run:
gcloud services enable cloudbuild.googleapis.com \
containerregistry.googleapis.com \
run.googleapis.com
Uma mensagem semelhante a esta vai aparecer:
Operation "operations/acf.cc11852d-40af-47ad-9d59-477a12847c9e" finished successfully.
3. Criar um app da Web simples
Para começar, clique no botão Open Editor na parte superior do painel do Cloud Shell. Esta é a aparência dela:
Em seguida, você estará em um ambiente de desenvolvimento integrado semelhante ao Visual Studio Code, em que poderá criar projetos, editar o código-fonte, executar programas etc. Se a tela estiver muito apertada, será possível expandir ou reduzir a linha divisória entre o console e a janela de edição/terminal arrastando a barra horizontal entre essas duas regiões destacadas aqui:
Para alternar entre o Editor e o Terminal, clique nos botões Open Editor e Open Terminal, respectivamente. Tente alternar entre esses dois ambientes agora.
Em seguida, crie uma pasta para armazenar o trabalho deste laboratório. Para isso, selecione Arquivo->Nova pasta, digite hello e clique em OK. Todos os arquivos que você criar neste laboratório e todo o trabalho que você realizar no Cloud Shell serão realizados nessa pasta.
Agora, crie um arquivo requirements.txt. Isso informa ao Python de quais bibliotecas seu aplicativo depende. Para esse app da Web simples, você vai usar um módulo Python conhecido para criar servidores da Web chamado Flask e um framework de servidor da Web chamado gunicorn. Na janela do Cloud Editor, clique no menu File->New File para criar um novo arquivo. Quando o nome do novo arquivo for solicitado, digite requirements.txt e pressione o botão OK. Verifique se o novo arquivo está na pasta do projeto hello.
Digite as linhas abaixo no novo arquivo para especificar que o app depende do pacote Flask Python e do servidor da Web gunicorn.
Flask gunicorn
Não é necessário salvar explicitamente este arquivo, porque o Cloud Editor salva as mudanças automaticamente.
Versão 1: Hello World!
Usando a mesma técnica, crie outro arquivo com o nome main.py. Esse será o principal (e único) arquivo de origem Python do seu aplicativo. Novamente, verifique se o novo arquivo está na pasta do projeto hello.
Insira o código a seguir nesse arquivo:
from flask import Flask
import os
import random
app = Flask(__name__) # Create a Flask object.
PORT = os.environ.get("PORT") # Get PORT setting from the environment.
# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
@app.route("/", methods=["GET"])
def say_hello():
html = "<h1>Hello world!</h1>"
return html
# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
app.run(host="0.0.0.0", port=PORT)
Volte ao terminal e acesse a pasta do projeto com este comando:
cd hello
Execute o seguinte comando para instalar as dependências do projeto:
pip3 install -r requirements.txt
Execute este comando no terminal para iniciar o app:
python3 main.py
Neste ponto, seu aplicativo está sendo executado na máquina virtual dedicada à sua sessão do Cloud Shell. O Cloud Shell inclui um mecanismo de proxy que possibilita o acesso a servidores da Web (como o que você acabou de iniciar) em execução na sua máquina virtual de qualquer lugar da Internet global.
Clique no botão web preview e, em seguida, no item de menu Preview on Port 8080, desta forma:
Isso vai abrir uma guia do navegador da Web para o app em execução, que terá esta aparência:
Versão 2: Como repetir o caminho do URL
Volte ao Editor do Cloud (usando o botão Open Editor) e adicione suporte para transmitir um sufixo de URL opcional atualizando o arquivo main.py da seguinte maneira:
from flask import Flask
import os
import random
app = Flask(__name__) # Create a Flask object.
PORT = os.environ.get("PORT") # Get PORT setting from environment.
# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
# If something is specified as the URL path (after the '/'), say_hello()
# responds with "Hello X", where X is the string at the end of the URL.
@app.route("/", methods=["GET"])
@app.route("/<name>", methods=["GET"]) # ← NEW
def say_hello(name="world"): # ← MODIFIED
html = f"<h1>Hello {name}!</h1>" # ← MODIFIED
return html
# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
app.run(host="0.0.0.0", port=PORT)
Volte ao terminal usando o botão Open Terminal e pressione control-C (mantenha a tecla Control pressionada enquanto pressiona "C") para interromper o app em execução e reinicie-o inserindo:
python3 main.py
Novamente, clique no botão web preview e no item de menu Preview on Port 8080 para abrir uma guia do navegador da Web do app em execução. Você verá novamente a mensagem "Hello world!" mas substitua o texto do URL após o caractere de barra por qualquer string de sua escolha (por exemplo, /your-name) e verifique se aparece algo assim:
Versão 3: cores aleatórias
Agora, adicione suporte a cores de plano de fundo aleatórias retornando ao Editor do Cloud (usando o botão Open Editor) e atualizando o arquivo main.py da seguinte maneira:
from flask import Flask
import os
import random
app = Flask(__name__) # Create a Flask object.
PORT = os.environ.get("PORT") # Get PORT setting from the environment.
# This function decides whether foreground text should be
# displayed in black or white, to maximize fg/bg contrast.
def set_text_color(rgb): # ← NEW
sum = round( # ← NEW
(int(rgb[0]) * 0.299) # ← NEW
+ (int(rgb[1]) * 0.587) # ← NEW
+ (int(rgb[2]) * 0.114) # ← NEW
) # ← NEW
return "black" if sum > 186 else "white" # ← NEW
# The app.route decorator routes any GET requests sent to the root path
# to this function, which responds with a "Hello world!" HTML document.
# If something is specified as the URL path (after the '/'), say_hello()
# responds with "Hello X", where X is the string at the end of the URL.
# To verify each new invocation of these requests, the HTML document
# includes CSS styling to produce a randomly colored background.
@app.route("/", methods=["GET"])
@app.route("/<name>", methods=["GET"])
def say_hello(name="world"):
bg = random.sample(range(1, 255), 3) # ← NEW
hex = (int(bg[0]) * 256) + (int(bg[1]) * 16) + int(bg[2]) # ← NEW
fg_color = set_text_color(bg) # ← NEW
bg_color = f"#{hex:06x}" # ← NEW
style = f"color:{fg_color}; background-color:{bg_color}" # ← NEW
html = f'<h1 style="{style}">Hello {name}!</h1>' # ← MODIFIED
return html
# This code ensures that your Flask app is started and listens for
# incoming connections on the local interface and port 8080.
if __name__ == "__main__":
app.run(host="0.0.0.0", port=PORT)
Volte ao terminal usando o botão Open Terminal e pressione control-C (mantenha a tecla Control pressionada enquanto pressiona "C") para interromper o app em execução e reinicie-o inserindo:
python3 main.py
Novamente, clique no botão web preview e no item de menu Preview on Port 8080 para abrir uma guia do navegador da Web do app em execução. O texto gerado, com qualquer sufixo especificado ou a mensagem "Hello world!" padrão, é exibido. exibida em frente a um plano de fundo colorido aleatoriamente, como este:
Atualize a página algumas vezes para ver se a cor aleatória do plano de fundo muda toda vez que você acessa o app.
E com isso, seu app está pronto. Parabéns! Na próxima etapa, você vai aprender a empacotar seu app em um contêiner e por que isso é útil.
4. Conteinerizar o aplicativo
O que é um contêiner?
Os contêineres em geral, e o Docker em particular, nos permitem criar uma caixa modular para executar um aplicativo com todas as dependências agrupadas. Chamamos o resultado de imagem de contêiner. Nesta seção, você vai criar uma imagem de contêiner, que será usada para encapsular seu aplicativo e todas as dependências dele.
Falando em dependências, em uma etapa anterior, ao executar o app em um ambiente de desenvolvedor, era necessário executar pip3 install -r requirements.txt e verificar se o arquivo requirements.txt continha todas as bibliotecas dependentes e versões correspondentes. Com os contêineres, você instala esses requisitos ao gerar a imagem do contêiner. Assim, o consumidor do contêiner não precisa se preocupar em instalar nada.
Essa imagem de contêiner vai ser o elemento básico para implantar seu aplicativo no Cloud Run. Como os contêineres podem ser usados em praticamente qualquer servidor virtual ou real, isso nos dá uma maneira de implantar seu aplicativo onde você quiser e movê-lo de um provedor de serviços para outro, ou do local para a nuvem.
Com os contêineres, seus aplicativos podem:
- reproduzíveis: os contêineres são independentes e completos
- portáteis: contêineres são elementos básicos de vários setores e permitem a portabilidade de aplicativos entre ambientes e provedores de nuvem.
Em resumo, os contêineres oferecem a capacidade de, por fim, "gravar uma vez e executar em qualquer lugar". Uma exceção a essa regra é que o contêiner gerado é limitado a ser executado no tipo de processador em que você o criou, mas também há maneiras de gerar versões de contêiner para outras configurações de hardware.
Chega de conversa, vamos fazer um contêiner! Você vai usar uma tecnologia específica para criar um contêiner chamado Docker.
No Cloud Editor, crie um novo arquivo com o nome Dockerfile. Esse arquivo é um modelo para criar sua imagem. Ele informa ao Docker sobre o ambiente operacional e o código-fonte, como instalar as dependências, criar o app e executar o código.
# Use an official lightweight Python image.
FROM python:3.9-slim
# Copy local code to the container image.
WORKDIR /app
COPY main.py .
COPY requirements.txt .
# Install dependencies into this container so there's no need to
# install anything at container run time.
RUN pip install -r requirements.txt
# Service must listen to $PORT environment variable.
# This default value facilitates local development.
ENV PORT 8080
# Run the web service on container startup. Here you use the gunicorn
# server, with one worker process and 8 threads. For environments
# with multiple CPU cores, increase the number of workers to match
# the number of cores available.
CMD exec gunicorn --bind 0.0.0.0:$PORT --workers 1 --threads 8 --timeout 0 main:app
No Terminal do Cloud, execute o comando a seguir para criar a imagem do contêiner usando o Cloud Build:
gcloud builds submit --tag $TAG
Depois de enviada ao registro, você verá uma mensagem SUCCESS contendo o nome da imagem, que deve ser semelhante a este: gcr.io/<project-id>/hello. A imagem agora está armazenada no Google Container Registry e pode ser reutilizada quando e onde você quiser.
Use este comando para listar todas as imagens do contêiner associadas ao projeto atual:
gcloud container images list
Agora, execute e teste o aplicativo localmente no Cloud Shell usando estes comandos docker:
docker run -p $PORT:$PORT -e PORT=$PORT $TAG
A opção -p $PORT:$PORT instrui o Docker a mapear a porta externa $PORT (definida como 8080 acima) no ambiente do host para o mesmo número de porta dentro do contêiner em execução. Isso facilita a vida porque o código do servidor que você escreve e o número da porta externa a que você se conecta ao testar o aplicativo são os mesmos (8080), mas também é possível usar a opção -p para mapear qualquer porta externa arbitrária no host para qualquer porta interna desejada dentro do contêiner.
A opção -e PORT=$PORT instrui o Docker a disponibilizar a variável de ambiente $PORT (definida como 8080 acima) para o aplicativo em execução no contêiner.
Agora está tudo pronto para testar o app. Basta apontar um navegador da Web para o código Python em execução no contêiner. Na janela do Cloud Shell, clique em "Visualização na Web". e selecione "Preview on port 8080", como você fez na etapa anterior.
O resultado deve parecer familiar. Você verá o texto gerado em frente a um plano de fundo colorido aleatoriamente, assim como fez ao executar o app diretamente no terminal do Cloud Shell. Atualize a página algumas vezes para ver se a cor aleatória do plano de fundo muda toda vez que você acessa o app.
Parabéns! Você acabou de executar uma versão conteinerizada do seu app. Na próxima seção, sem tocar em uma linha de código, você vai transformar sua imagem de contêiner em um app da Web com qualidade de produção.
5. Para a nuvem...
Agora que você já colocou seu app em um contêiner, é hora de compartilhar essa maravilha com o mundo todo, então é hora de implantá-lo na nuvem. Mas você realmente quer fazer mais do que apenas compartilhar. Você quer garantir que:
- é executado de maneira confiável. Você tem tolerância automática a falhas caso um computador que executa seu aplicativo falhe
- escalona automaticamente - seu aplicativo acompanhará os grandes níveis de tráfego e reduzirá automaticamente sua pegada quando não for usado
- minimiza seus custos, não cobrando por recursos que você não usa - você é cobrado apenas pelos recursos consumidos ao responder ao tráfego
- pode ser acessado por meio de um nome de domínio personalizado; você tem acesso a uma solução de um clique para atribuir um nome de domínio personalizado ao seu serviço
- oferece excelente tempo de resposta: inicializações a frio são razoavelmente responsivas, mas você pode ajustar isso especificando uma configuração de instância mínima.
- oferece suporte à criptografia de ponta a ponta usando segurança da Web SSL/TLS padrão. Ao implantar um serviço, você recebe a criptografia padrão da Web e os certificados necessários correspondentes, sem custo financeiro e automática
Ao implantar seu app no Google Cloud Run, você tem acesso a tudo isso e muito mais.
Implante seu app no Cloud Run
Primeiro, vamos modificar seu app para poder distinguir a nova revisão da antiga. Para fazer isso, modifique o arquivo main.py para que a mensagem padrão mude de "Hello world!". para "Hello from Cloud Run!". Em outras palavras, altere essa linha em main.py desta forma:
def say_hello(name="world"):
para isso:
def say_hello(name="from Cloud Run"):
O Cloud Run é regional, ou seja, a infraestrutura que executa os serviços do Cloud Run está localizada em uma região específica e é gerenciada pelo Google para estar disponível de maneira redundante em todas as zonas dessa região. Na caixa de diálogo "Começar a configuração", seção acima, você definiu uma região padrão usando a variável de ambiente REGION.
Recrie a imagem do contêiner e implante o aplicativo conteinerizado no Cloud Run com o seguinte comando:
gcloud builds submit --tag $TAG gcloud run deploy "$APP" \ --image "$TAG" \ --platform "managed" \ --region "$REGION" \ --allow-unauthenticated
- Também é possível definir uma região padrão com
gcloud config set run/region $REGION. - A opção
--allow-unauthenticatedtorna o serviço disponível publicamente. Para evitar solicitações não autenticadas, use--no-allow-unauthenticated.
A imagem especificada aqui é aquela do Docker que você criou na etapa anterior. Graças ao serviço Cloud Build, que armazenou a imagem resultante no Google Container Registry, o serviço do Cloud Run pode encontrá-la e implantá-la para você.
Aguarde alguns instantes até a implantação terminar. Em caso de sucesso, a linha de comando vai exibir o URL de serviço:
Deploying container to Cloud Run service [hello] in project [PROJECT_ID... ✓ Deploying new service... Done. ✓ Creating Revision... Revision deployment finished. Waiting for health check... ✓ Routing traffic... ✓ Setting IAM Policy... Done. Service [hello] revision [hello-...] has been deployed and is serving 100 percent of traffic. Service URL: https://hello-....a.run.app
Também é possível recuperar o URL do serviço com este comando:
gcloud run services describe hello \ --platform managed \ --region $REGION \ --format "value(status.url)"
O resultado será semelhante a este:
https://hello-....a.run.app
Este link é um URL dedicado, com segurança TLS, para seu serviço do Cloud Run. Esse link é permanente (desde que você não desative seu serviço) e pode ser usado em qualquer lugar da Internet. Ele não usa o mecanismo de proxy do Cloud Shell mencionado anteriormente, que dependia de uma máquina virtual temporária.
Clique no Service URL destacado para abrir uma guia do navegador da Web para o app em execução. O resultado exibirá a mensagem "Hello from Cloud Run!" em frente a um fundo colorido aleatoriamente.
Parabéns! Seu app está em execução na nuvem do Google. Sem se preocupar, seu app está disponível publicamente, com criptografia TLS (HTTPS) e escalonamento automático para níveis de tráfego surpreendentes.
Mas acho que esse processo poderia ser ainda mais fácil...
6. Criar o contêiner automaticamente
Tudo isso é muito legal, mas e se eu não quiser pensar em Dockerfiles e contêineres? E se, como a maioria dos desenvolvedores, eu quiser me concentrar em escrever o código do aplicativo e deixar outra pessoa se preocupar com a conteinerização? Você está com sorte, porque o Cloud Run oferece suporte a um padrão de código aberto chamado Buildpacks, que existe por esse mesmo motivo: automatizar o processo de fabricação de um contêiner a partir de uma coleção de arquivos de origem.
Há alguns casos em que um desenvolvedor pode preferir usar um Dockerfile explícito, por exemplo, se quiser um alto grau de personalização na forma como o contêiner é criado. Mas, para casos comuns como esse, os buildpacks funcionam bem e evitam a necessidade de criar um Dockerfile manualmente. Vamos modificar seu código para usar buildpacks.
Primeiro, vamos modificar seu app para poder distinguir a nova revisão da antiga. Faça isso modificando o arquivo main.py para que a mensagem padrão mude de "Hello from Cloud Run!". até "Hello from Cloud Run with Buildpacks!". Em outras palavras, altere essa linha em main.py desta forma:
def say_hello(name="from Cloud Run"):
para isso:
def say_hello(name="from Cloud Run with Buildpacks"):
Agora, vamos criar um novo arquivo chamado Procfile para usar os buildpacks. Crie esse arquivo no Cloud Editor e insira esta linha de texto:
web: python3 main.py
Isso informa ao sistema de buildback como executar seu app no contêiner gerado automaticamente. Com essa instrução, você não precisa mais de um Dockerfile. Para verificar isso, exclua o Dockerfile e execute o comando a seguir no terminal do Cloud Shell:
gcloud beta run deploy "$APP" \
--source . \
--platform "managed" \
--region "$REGION" \
--allow-unauthenticated
Isso é semelhante ao comando executado para implantar o app na última etapa, mas, desta vez, você substituiu a opção --image pela opção --source .. Isso informa ao comando gcloud que você quer que ele use buildpacks para criar sua imagem de contêiner, com base nos arquivos de origem que encontrar no diretório atual. O dot em --source . é uma abreviação do diretório atual. Como o serviço cuida da imagem do contêiner implicitamente, não é necessário especificar uma imagem neste comando gcloud.
Mais uma vez, verifique se essa implantação funcionou clicando no Service URL destacado para abrir uma guia do navegador da Web no app em execução e se o serviço está exibindo "Hello from Cloud Run with Buildpacks!". em frente a um fundo colorido aleatoriamente.
Ao usar buildpacks para fabricar seu Dockerfile, você reduziu estas três etapas fáceis a duas:
- Crie um app no seu ambiente de desenvolvimento.
- Implante exatamente o mesmo código na nuvem com um único comando.
7. Preciso usar a linha de comando?
Não! Como quase todos os serviços do Google Cloud, há três maneiras de interagir com o Cloud Run:
- A ferramenta de linha de comando gcloud que você acabou de ver.
- Uma interface do usuário da Web avançada, por meio do console do Cloud, compatível com um estilo intuitivo de interação de apontar e clicar.
- De forma programática, é possível usar bibliotecas de cliente do Google disponíveis para várias linguagens conhecidas, incluindo Java, C#, Python, Go, JavaScript, Ruby, C/C++, entre outras.
Implante outra instância do app Cloud Run usando a interface do console. Navegue até a página de destino do serviço do Cloud Run no menu superior esquerdo:
Você verá um resumo dos serviços do Cloud Run, como este:
Clique em "Criar serviço". para iniciar o processo de implantação:
Digite "hello-again" como nome do serviço, escolha a plataforma e a região de implantação padrão e clique em "Próxima".
Insira este URL para a imagem do contêiner: gcr.io/cloudrun/hello, que é um contêiner criado pelo Google para fins de teste, e clique em "Configurações avançadas" para ver algumas das diversas definições de configuração disponíveis. Estes são alguns exemplos que podem ser personalizados:
- número da porta e ponto de entrada do contêiner (que substituirão o ponto de entrada especificado ao criar o contêiner)
- Hardware: memória e número de CPUs
- escalonamento: instâncias mínima e máxima
- variáveis de ambiente
- outros: configuração de tempo limite da solicitação, número máximo de solicitações por contêiner, HTTP/2
Clique no botão "Próxima" para avançar a caixa de diálogo. A próxima caixa de diálogo permite especificar como o serviço é acionado. Em "Entrada", selecione "Permitir todo o tráfego" e, em "Autenticação", selecione "Permitir tráfego não autenticado".
Essas são as configurações mais liberais, porque permitem que qualquer pessoa acesse o app Cloud Run de qualquer lugar na Internet pública, sem especificar credenciais de autenticação. Talvez você queira configurações mais restritivas para o app, mas vamos simplificar para este exercício de aprendizado.
Agora clique no botão Create para criar o serviço do Cloud Run. Após alguns segundos, o novo serviço será exibido na lista de resumo dos serviços do Cloud Run. A linha de resumo apresenta a implantação mais recente (data/hora e por quem) além de algumas configurações importantes. Clique no link do nome do serviço para ver mais detalhes sobre o novo serviço.
Para verificar seu serviço, clique no URL mostrado próximo à parte superior da página de resumo, conforme destacado no exemplo abaixo:
Você verá algo como:
Agora que você implantou um novo serviço do Cloud Run, selecione a guia REVISIONS para ver algumas maneiras de gerenciar várias implantações.
Para implantar novas revisões diretamente do console, clique no botão EDIT & DEPLOY NEW REVISION, conforme destacado na captura de tela do exemplo abaixo:
Clique nesse botão para criar uma nova revisão. Próximo ao URL do contêiner, clique no botão SELECT, conforme mostrado abaixo:
Na caixa de diálogo que aparece, encontre o app da Web simples que você já implantou do Cloud Build usando Buildpacks e clique em "Selecionar". Escolha a imagem do contêiner em
gcr.io/<project>/cloud-run-source-deploy
folder , da seguinte forma:
Depois de selecionar, role até a parte de baixo da tela e clique no botão DEPLOY. Você implantou uma nova revisão do app. Para verificar, acesse novamente o URL do serviço e veja se a mensagem "Hello from Cloud Run with Buildpacks!" está aparecendo app da Web.
Como você pode ver, a guia "Revisões" oferece um resumo de cada revisão implantada, e agora serão exibidas duas revisões do serviço. Você pode selecionar uma determinada revisão clicando no botão de opção à esquerda do nome da revisão, que exibirá um resumo dos detalhes da revisão no lado direito da tela. Ao selecionar esses botões, você verá que suas duas revisões são derivadas de duas imagens de contêiner diferentes.
O botão MANAGE TRAFFIC permite modificar a distribuição das solicitações recebidas enviadas para uma determinada revisão. Essa capacidade de ajustar a quantidade de tráfego enviada para uma determinada revisão possibilita vários casos de uso valiosos:
- um teste canário de uma nova versão do app com uma pequena parte do tráfego de entrada
- reverter o tráfego de uma versão problemática para uma revisão anterior
- Teste A/B
Encontre o botão do MANAGE TRAFFIC aqui:
Configure uma divisão de tráfego 50/50 entre suas duas revisões especificando uma divisão de tráfego 50/50 desta maneira:
Agora clique no botão SALVAR e verifique a divisão 50/50 acessando o URL do serviço repetidamente e verifique se, em média, metade das solicitações é atendida pela revisão atual ("Hello from Cloud Run with Buildpacks!") e metade é atendida pela revisão anterior ("Em execução!").
Outras guias na página "Detalhes do serviço" oferecem a capacidade de monitorar o desempenho, o tráfego e os registros, que fornecem insights valiosos sobre a dificuldade e o desempenho do serviço. Você também pode ajustar o acesso ao seu serviço na guia "Permissões" . Reserve alguns minutos para explorar as guias desta página e ter uma noção dos recursos disponíveis aqui.
Interface programática
Conforme observado anteriormente, você também tem a opção de criar, implantar e gerenciar os serviços do Cloud Run de maneira programática. Para tarefas manuais, essa opção é mais avançada do que a linha de comando ou o console da Web, mas é definitivamente a maneira de automatizar os serviços do Cloud Run. Você tem a opção de usar as bibliotecas de cliente do Google em várias linguagens de programação conhecidas.
8. Testar o app
Nesta etapa final, você vai executar um teste de carga artificial para realizar um teste de estresse no app e observar como ele é dimensionado de acordo com a nova demanda. Você usará uma ferramenta chamada hey, que vem pré-instalada no Cloud Shell e permite executar testes de carga e apresentar os resultados.
Executar o teste
No terminal do Cloud Shell, execute este comando para executar um teste de carga:
hey -q 1000 -c 200 -z 30s https://hello-...run.app
Os argumentos do comando são interpretados da seguinte maneira:
-q 1000: tente impulsionar a carga a cerca de 1.000 solicitações por segundo.-c 200: aloca 200 workers paralelos.-z 30s: executa o teste de carga por 30 segundos.- use seu URL de serviço como o último argumento nessa linha de comando
Os resultados do teste vão ficar assim:
Summary:
Total: 30.2767 secs
Slowest: 3.3633 secs
Fastest: 0.1071 secs
Average: 0.1828 secs
Requests/sec: 1087.2387
Total data: 3028456 bytes
Size/request: 92 bytes
Response time histogram:
0.107 [1] |
0.433 [31346] |■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■■
0.758 [1472] |■■
1.084 [82] |
1.410 [4] |
...
Latency distribution:
...
50% in 0.1528 secs
75% in 0.1949 secs
90% in 0.2442 secs
95% in 0.4052 secs
99% in 0.7062 secs
Details (average, fastest, slowest):
...
req write: 0.0000 secs, 0.0000 secs, 0.0232 secs
resp wait: 0.1824 secs, 0.1070 secs, 3.2953 secs
resp read: 0.0000 secs, 0.0000 secs, 0.0010 secs
Status code distribution:
[200] 32918 responses
Este resumo nos diz vários itens de interesse:
- 32.918 solicitações foram enviadas a aproximadamente 1.000/por segundo durante 30 segundos.
- Não houve erros (apenas 200 respostas HTTP).
- A latência média foi de 180 ms.
- A latência mínima foi de 107 ms, o pior caso foi de 3,3 s
- A latência do 90o percentil foi de 244 ms.
Se você verificar a guia METRICS no console do Cloud Run, será possível ver o lado do servidor da história de desempenho:
9. Como fazer a limpeza
O Cloud Run não gera custos quando o serviço não está em uso, mas você ainda vai receber cobranças pelo armazenamento da imagem de contêiner que você criou.
É possível excluir seu projeto do GCP para evitar cobranças, o que interromperá o faturamento de todos os recursos usados nele, ou simplesmente excluir sua imagem de contêiner usando este comando:
gcloud container images delete $TAG
Para excluir os serviços do Cloud Run, use estes comandos:
gcloud run services delete hello --platform managed --region $REGION --quiet gcloud run services delete hello-again --platform managed --region $REGION --quiet
10. Parabéns!
Parabéns! Você criou e implantou corretamente um app de produção do Cloud Run. No caminho, você aprendeu sobre contêineres e como criar seu próprio contêiner. Você viu como é fácil implantar seu app com o Cloud Run usando a ferramenta de linha de comando gcloud e o console do Cloud. Agora você sabe como compartilhar suas criações brilhantes com o mundo inteiro!
Quero deixar uma pergunta importante para você:
Depois de colocar o app para funcionar no seu ambiente de desenvolvedor, quantas linhas de código você precisou modificar para implantá-lo na nuvem, com todos os atributos de nível de produção oferecidos pelo Cloud Run?
A resposta é zero. :)
Codelabs para conferir...
- Criar um bot do Slack com Node.js no Cloud Run
- Acionar o Cloud Run com eventos do Eventarc
- Codelab Hello Cloud Run for Anthos
- Implantar e executar um contêiner com o Cloud Run no Node.js
- Outros codelabs do Cloud Run
Outros recursos interessantes...
- Implantação contínua com o Git usando o Cloud Build
- Como usar secrets do Secret Manager
- Conheça os streams bidirecionais de WebSockets, HTTP/2 e gRPC para o Cloud Run
- Instâncias mínimas do Cloud Run: minimize as inicializações a frio sem servidor
- Veiculação de tráfego de várias regiões
Documentos de referência…
11. Call-to-action
Se você gostou deste codelab e provavelmente vai passar mais tempo praticando com o Google Cloud, participe do Google Cloud Innovators hoje mesmo.
O Google Cloud Innovators é sem custo financeiro e inclui:
- Discussões, AMAs e sessões de roteiro ao vivo para ficar por dentro das novidades diretamente dos Googlers
- Receba as últimas notícias sobre o Google Cloud na sua caixa de entrada
- Selo digital e plano de fundo de videoconferência
- 500 créditos de laboratórios e aprendizado no Google Cloud Ensina
Clique aqui para se inscrever.