Carregando...
Nenhum resultado encontrado.

Aplique suas habilidades no console do Google Cloud

Seu progresso de aprendizado pode ser perdido. Faça login ou participe para salvar seu progresso.
close

Reliable Google Cloud Infrastructure: Design and Process - Português Brasileiro

Curso · 16 horas
< 1%
concluído
Acesse mais de 700 laboratórios e cursos

Como implantar aplicativos no Google Cloud

Laboratório 1 hora 30 minutos universal_currency_alt 5 créditos show_chart Introdutório
info Este laboratório pode incorporar ferramentas de IA para ajudar no seu aprendizado.
Acesse mais de 700 laboratórios e cursos

Visão geral

Neste laboratório, você vai implantar aplicativos nos serviços do Google Cloud App Engine, Kubernetes Engine e Cloud Run.

Arquitetura do serviços do Google Cloud App Engine, Kubernetes Engine e Cloud Run

Objetivos

Neste laboratório, você vai aprender a:

  • fazer o download de um app de exemplo no GitHub;
  • fazer a implantação no App Engine;
  • Fazem a implantação no Kubernetes Engine
  • fazer a implantação no Cloud Run.

Configure o ambiente do laboratório

Para cada laboratório, você recebe um novo projeto do Google Cloud e um conjunto de recursos por um determinado período e sem custos financeiros.

  1. Faça login no Qwiklabs em uma janela anônima.

  2. Confira o tempo de acesso do laboratório (por exemplo, 1:15:00) e finalize todas as atividades nesse prazo.
    Não é possível pausar o laboratório. Você pode reiniciar o desafio, mas vai precisar refazer todas as etapas.

  3. Quando tudo estiver pronto, clique em Começar o laboratório.

  4. Anote as credenciais (Nome de usuário e Senha). É com elas que você vai fazer login no Console do Google Cloud.

  5. Clique em Abrir Console do Google.

  6. Clique em Usar outra conta, depois copie e cole as credenciais deste laboratório nos locais indicados.
    Se você usar outras credenciais, vai receber mensagens de erro ou cobranças.

  7. Aceite os termos e pule a página de recursos de recuperação.

Tarefa 1: criar um aplicativo Python simples

É necessário ter um código-fonte para gerenciar. Por isso, você vai criar um aplicativo da Web simples com o Python Flask. O app será um pouco melhor do que o "Hello World", mas isso é suficiente para testar o pipeline que você vai criar.

  1. No console do Cloud, clique em Ativar o Cloud Shell (Ícone &quot;Ativar o Cloud Shell&quot;).
  2. Se for solicitado, clique em Continuar.

3.9. Digite o comando a seguir no Cloud Shell para criar uma pasta chamada gcp-course:

mkdir gcp-course
  1. Acesse a pasta que você criou:
cd gcp-course
  1. Crie uma pasta chamada deploying-apps-to-gcp:
mkdir deploying-apps-to-gcp
  1. Acesse a pasta que você criou:
cd deploying-apps-to-gcp
  1. No Cloud Shell, clique em Abrir editor (Ícone do editor) para abrir o editor de código. Se solicitado, clique em Abrir em uma nova janela.
  2. Selecione a pasta gcp-course > deploying-apps-to-gcp na árvore do explorador à esquerda.
  3. Clique em deploying-apps-to-gcp.
  4. Clique em Novo arquivo.
  5. Dê ao item o nome main.py e pressione Enter.
  6. Cole o código a seguir no arquivo criado:
from flask import Flask, render_template, request app = Flask(__name__) @app.route("/") def main(): model = {"title": "Hello GCP."} return render_template('index.html', model=model) if __name__ == "__main__": app.run(host='0.0.0.0', port=8080, debug=True, threaded=True)
  1. Para salvar as mudanças, pressione CTRL + S.
  2. Clique na pasta deploying-apps-to-gcp.
  3. Clique em Nova pasta.
  4. Dê ao item o nome templates e pressione Enter.
  5. Clique com o botão direito na pasta templates e crie um novo arquivo chamadolayout.html.
  6. Adicione o código abaixo e salve o arquivo novamente:
<!doctype html> <html lang="en"> <head> <title>{{model.title}}</title> <!-- Bootstrap CSS --> <link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.4.1/css/bootstrap.min.css"> </head> <body> <div class="container"> {% block content %}{% endblock %} <footer></footer> </div> </body> </html>

  1. Ainda na pasta "templates", adicione outro arquivo novo chamado index.html.

  2. Adicione o código abaixo e salve o arquivo novamente:

{% extends "layout.html" %} {% block content %} <div class="jumbotron"> <div class="container"> <h1>{{model.title}}</h1> </div> </div> {% endblock %}

  1. No Python, os pré-requisitos do aplicativo são gerenciados com o pip. Adicione agora um arquivo que indique os requisitos para esse app.

  2. Na pasta deploying-apps-to-gcp (não na pasta "templates"), crie um Novo arquivo, adicione o código a seguir a ele e salve-o como requirements.txt:

Flask==2.0.3 itsdangerous==2.0.1 Jinja2==3.0.3 werkzeug==2.2.2

Tarefa 2: definir um build do Docker

Para usar o Docker, você precisa criar um arquivo chamado Dockerfile. Esse arquivo define como um contêiner do Docker é construído. Você vai fazer isso agora.

  1. Na pasta deploying-apps-to-gcp, clique em Novo arquivo e dê a ele o nome de Dockerfile.

O arquivo Dockerfile é usado para definir como o contêiner é criado.

  1. Adicione o seguinte:
FROM python:3.9 WORKDIR /app COPY . . RUN pip install gunicorn RUN pip install -r requirements.txt ENV PORT=8080 CMD exec gunicorn --bind :$PORT --workers 1 --threads 8 main:app
  1. Para testar o programa, digite o seguinte comando para criar um contêiner do Docker da imagem:
docker build -t test-python .
  1. Para executar a imagem Docker, digite o seguinte comando:
docker run --rm -p 8080:8080 test-python
  1. Para ver a execução do programa, clique em Visualização na Web (Ícone de visualização na Web) na barra de ferramentas do Google Cloud Shell. Depois selecione Visualizar na porta 8080.

O programa será exibido em uma nova guia do navegador.

  1. No Cloud Shell, pressione Ctrl+C para interromper o programa.

Tarefa 3: implantar no App Engine

O App Engine é uma plataforma de implantação completamente automatizada. Ele é compatível com muitas linguagens, como Python, Java, JavaScript e Go. Para usá-lo, é necessário criar um arquivo de configuração e implantar os aplicativos com alguns comandos simples. Nesta tarefa, você vai criar um arquivo chamado app.yaml e fazer a implantação dele no App Engine.

  1. No Cloud Shell, clique em Abrir editor (Ícone do editor do Cloud Shell) e, em seguida, em Abrir em uma nova janela, se necessário.
  2. Selecione a pasta gcp-course/deploying-apps-to-gcp na árvore do explorador à esquerda.
  3. Clique em Novo arquivo, dê ao item o nome app.yaml e pressione Enter.
  4. Cole este comando no arquivo recém-criado:
runtime: python39
  1. Salve as alterações.
Observação: há outras configurações que podem ser adicionadas ao arquivo app.yaml, mas apenas o ambiente de execução da linguagem é obrigatório nesse caso.
  1. É preciso criar um aplicativo do App Engine em um projeto. Isso é feito apenas uma vez com o comando gcloud app create e especificando a região em que o app será criado. Clique em Abrir terminal e digite o seguinte comando. Se for solicitado, clique em Autorizar.
gcloud app create --region={{{project_0.startup_script.app_region| Region}}}
  1. Agora implante o aplicativo usando o seguinte comando:
gcloud app deploy --version=one --quiet Observação: a conclusão deste comando leva alguns minutos.

  1. Na barra de título do console do Google Cloud, digite App Engine no campo de pesquisa e clique em App Engine na seção "Resultados da pesquisa".

  2. No canto superior direito do painel, há um link para seu aplicativo, semelhante a este:

Exemplo de link de aplicativo

Observação: o URL do aplicativo do App Engine fica no formato https://project-id.appspot.com por padrão.

  1. Clique no link para testar o programa.

  2. Faça uma alteração no programa para ver como o App Engine facilita o gerenciamento das versões.

  3. No editor de código, expanda a pasta /deploying-apps-to-gcp no painel de navegação à esquerda. Depois, clique em main.py para abri-lo.

  4. Na função main(), altere o título para Hello App Engine, conforme mostrado abaixo:

@app.route("/") def main(): model = {"title" "Hello App Engine"} return render_template('index.html', model=model)

  1. Clique em Arquivo > Salvar na barra de ferramentas do editor de código para salvar a alteração.

  2. Agora implante a versão dois com o seguinte comando:

gcloud app deploy --version=two --no-promote --quiet Observação: o parâmetro --no-promote instrui o App Engine a continuar exibindo as solicitações com a versão antiga. Com isso, você pode testar a nova versão antes de colocar em produção.

  1. Quando o comando for concluído, volte ao painel do App Engine. Clique no link novamente, e a versão um ainda será retornada. Ela retornará Hello GCP. Isso ocorre por causa do parâmetro --no-promote no comando anterior.

  2. À esquerda, clique na guia Versões. Observe que duas versões aparecem.

Observação: talvez seja necessário clicar em Atualizar para ver a versão dois.

  1. Clique no link da versão dois para fazer um teste. A mensagem Hello App Engine será retornada.

  2. Para migrar o tráfego de produção para a versão dois, clique em Dividir tráfego na parte superior. Altere a versão para dois e clique em Salvar.

  3. Aguarde um minuto. Atualize a guia do navegador que retornou anteriormente Hello GCP. Ela deverá retornar a nova versão.

Clique em Verificar meu progresso para ver o objetivo. Implantar no App Engine

Tarefa 4: implantar no Kubernetes Engine com o Cloud Build e o Artifact Registry

O Kubernetes Engine permite criar um cluster de máquinas e implantar qualquer número de aplicativos nele. O Kubernetes abstrai os detalhes do gerenciamento de máquinas e permite automatizar a implantação de seus aplicativos com comandos simples de CLI.

Para implantar um aplicativo no Kubernetes, é preciso primeiro criar o cluster. Depois adicione um arquivo de configuração para cada aplicativo que você implantará no cluster.

  1. No Menu de navegação (Ícone do menu de navegação), clique em Kubernetes Engine. Se aparecer uma mensagem dizendo que a API Kubernetes está sendo inicializada, aguarde até que o processo seja concluído.

  2. Clique em Criar cluster e, em seguida, em Mudar para o cluster padrão. Confirme a mudança.

  3. Clique em Por zona em Tipo de local e selecione a zona . Aceite todas as outras variáveis como padrão e clique em Criar. Levará alguns minutos para que o cluster do Kubernetes Engine seja criado. Quando o cluster estiver pronto, uma marca de seleção verde aparecerá.

  4. Clique nos três pontos à direita do cluster e, em seguida, clique em Conectar.

  5. Na tela Conectar ao cluster, clique em Executar no Cloud Shell. Isso abre o Cloud Shell com o comando "conectar" inserido automaticamente.

  6. Pressione Enter para se conectar ao cluster.

  7. Para testar a conexão, digite o seguinte comando:

kubectl get nodes

Esse comando apenas mostra as máquinas no cluster. Se funcionar, a conexão estará pronta.

  1. No Cloud Shell, clique em Abrir editor (Ícone do editor do Cloud Shell).
  2. Expanda a pasta gcp-course/deploying-apps-to-gcp no painel de navegação à esquerda. Depois, clique em main.py para abri-lo.
  3. Na função main(), altere o título para Hello Kubernetes Engine, conforme mostrado abaixo:
@app.route("/") def main(): model = {"title" "Hello Kubernetes Engine"} return render_template('index.html', model=model)
  1. Salve a mudança.
  2. Adicione um arquivo chamado kubernetes-config.yaml à pasta gcp-course/deploying-apps-to-gcp.
  3. Cole o seguinte código nesse arquivo para configurar o aplicativo:
--- apiVersion: apps/v1 kind: Deployment metadata: name: devops-deployment labels: app: devops tier: frontend spec: replicas: 3 selector: matchLabels: app: devops tier: frontend template: metadata: labels: app: devops tier: frontend spec: containers: - name: devops-demo image: <YOUR IMAGE PATH HERE> ports: - containerPort: 8080 --- apiVersion: v1 kind: Service metadata: name: devops-deployment-lb labels: app: devops tier: frontend-lb spec: type: LoadBalancer ports: - port: 80 targetPort: 8080 selector: app: devops tier: frontend

Observação: na primeira seção do arquivo YAML acima, você está configurando uma implantação. Neste caso, você está implantando três instâncias do seu app da Web em Python. Confira o atributo de imagem. Você atualizará esse valor com sua imagem logo após a criação. Na segunda seção, você configura um serviço do tipo "balanceador de carga". O balanceador de carga terá um endereço IP público. Os usuários acessarão seu aplicativo pelo balanceador de carga.

Para mais informações sobre as implantações e serviços do Kubernetes, consulte os links abaixo:
  1. No Cloud Shell, digite o seguinte comando para criar um repositório do Artifact Registry chamado devops-demo:
gcloud artifacts repositories create devops-demo \ --repository-format=docker \ --location={{{ project_0.default_region | "REGION" }}}
  1. Configure o Docker para autenticação no repositório correspondente do Artifact Registry usando este comando:
gcloud auth configure-docker {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev
  1. Para usar o Kubernetes Engine, você precisa criar uma imagem Docker. Digite os seguintes comandos no Cloud Build para criar a imagem e armazená-la no Artifact Registry:
cd ~/gcp-course/deploying-apps-to-gcp gcloud builds submit --tag {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/$DEVSHELL_PROJECT_ID/devops-demo/devops-image:v0.2 .

  1. Quando o comando anterior for concluído, o nome da imagem será listado na saída. O nome da imagem tem o formato docker.pkg.dev/PROJECT_ID/devops-demo/devops-image:v0.2.

  2. Destaque o nome da imagem e copie para a área de transferência. Cole esse valor no arquivo kubernetes-config.yaml, substituindo a string <YOUR IMAGE PATH HERE>.

Algo semelhante a isso vai aparecer:

spec: containers: - name: devops-demo image: {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/PROJECT_ID/devops-demo/devops-image:v0.2 ports:
  1. Digite o seguinte comando do Kubernetes para implantar o aplicativo:
kubectl apply -f kubernetes-config.yaml
  1. No arquivo de configuração, três réplicas do aplicativo foram especificadas. Digite o seguinte comando para ver se três instâncias foram criadas:
kubectl get pods

Verifique se todos os pods estão prontos. Se não estiverem, aguarde alguns segundos e tente novamente.

  1. Um balanceador de carga também foi adicionado ao arquivo de configuração. Digite o seguinte comando para ver se ele foi criado:
kubectl get services

Algo semelhante a isso vai aparecer:

Saída

Se o endereço IP externo do balanceador de carga estiver "pendente", aguarde alguns segundos e tente de novo.

  1. Quando você tiver um IP externo, abra uma guia do navegador e faça uma solicitação para ele. Ele retornará Hello Kubernetes Engine. O processo talvez leve alguns segundos.

Clique em Verificar meu progresso para ver o objetivo. Implantar no Kubernetes Engine

Tarefa 5: implantar no Cloud Run

O Cloud Run simplifica e automatiza implantações no Kubernetes. Quando você usa o Cloud Run, não precisa de um arquivo de configuração. Basta escolher um cluster para o aplicativo. Com o Cloud Run, é possível usar um cluster gerenciado pelo Google ou usar seu próprio cluster do Kubernetes.

Para usar o Cloud Run, seu aplicativo precisa ser implantado com uma imagem Docker, e ele precisa estar sem estado.

  1. Abra o editor de código do Cloud Shell e expanda a pasta gcp-course/deploying-apps-to-gcp no painel de navegação à esquerda. Depois, clique em main.py para abri-lo.
  2. Na função main(), mude o título para Hello Cloud Run, conforme mostrado abaixo:
@app.route("/") def main(): model = {"title" "Hello Cloud Run"} return render_template('index.html', model=model)

  1. Salve a alteração.

  2. Para usar o Cloud Run, você precisa criar uma imagem Docker. No Cloud Shell, digite os comandos abaixo para usar o Cloud Build na criação da imagem e armazená-la no Artifact Registry:

cd ~/gcp-course/deploying-apps-to-gcp gcloud builds submit --tag {{{ project_0.default_region | "REGION" }}}-docker.pkg.dev/$DEVSHELL_PROJECT_ID/devops-demo/cloud-run-image:v0.1 .

  1. Quando o build for concluído, digite Cloud Run no campo de pesquisa da barra de título do console do Google Cloud, e clique em Cloud Run na seção "Produtos e páginas".

  2. Clique em Criar serviço. Isso ativa a API Cloud Run.

  3. Clique no link Selecionar na caixa de texto Container image URL e, depois, em Artifact Registry. Na caixa de diálogo, abra Region-docker.pkg.dev/$DEVSHELL_PROJECT_ID/devops-demo > cloud-run-image e selecione a imagem listada. Em seguida, clique em Selecionar.

  4. Em Nome do serviço, insira hello-cloud-run e selecione a região .

  5. Para a Autenticação, selecione Permitir invocações não autenticadas.

  6. Na seção Ambiente de execução, em Contêineres, volumes, rede, segurança, selecione Padrão.

  7. Em Escalonamento de revisão, defina o Número máximo de instâncias como 6. Não altere os outros padrões.

  8. Por fim, clique em Criar.

  9. A implantação do serviço não demora muito. Quando aparecer uma marca de seleção verde, clique no URL que é gerado automaticamente para o aplicativo. Ele retornará Hello Cloud Run.

Clique em Verificar meu progresso para ver o objetivo. Fazer a implantação no Cloud Run

Parabéns!

Neste laboratório, você implantou aplicativos nos serviços do Google Cloud App Engine, Kubernetes Engine e Cloud Run.

Finalize o laboratório

Clique em Terminar o laboratório após a conclusão. O Google Cloud Ensina remove os recursos usados e limpa a conta por você.

Você vai poder avaliar sua experiência no laboratório. Basta selecionar o número de estrelas, digitar um comentário e clicar em Enviar.

O número de estrelas indica o seguinte:

  • 1 estrela = muito insatisfeito
  • 2 estrelas = insatisfeito
  • 3 estrelas = neutro
  • 4 estrelas = satisfeito
  • 5 estrelas = muito satisfeito

Feche a caixa de diálogo se não quiser enviar feedback.

Para enviar seu feedback, fazer sugestões ou correções, use a guia Suporte.

Copyright 2025 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de empresas e produtos podem ser marcas registradas das empresas a que estão associados.
Anterior Seguinte

Antes de começar

  1. Os laboratórios criam um projeto e recursos do Google Cloud por um período fixo
  2. Os laboratórios têm um limite de tempo e não têm o recurso de pausa. Se você encerrar o laboratório, vai precisar recomeçar do início.
  3. No canto superior esquerdo da tela, clique em Começar o laboratório

Usar a navegação anônima

  1. Copie o nome de usuário e a senha fornecidos para o laboratório
  2. Clique em Abrir console no modo anônimo

Fazer login no console

  1. Faça login usando suas credenciais do laboratório. Usar outras credenciais pode causar erros ou gerar cobranças.
  2. Aceite os termos e pule a página de recursos de recuperação
  3. Não clique em Terminar o laboratório a menos que você tenha concluído ou queira recomeçar, porque isso vai apagar seu trabalho e remover o projeto

Este conteúdo não está disponível no momento

Você vai receber uma notificação por e-mail quando ele estiver disponível

Ótimo!

Vamos entrar em contato por e-mail se ele ficar disponível

Um laboratório por vez

Confirme para encerrar todos os laboratórios atuais e iniciar este

Use a navegação anônima para executar o laboratório

Para executar este laboratório, use o modo de navegação anônima ou uma janela anônima do navegador. Isso evita conflitos entre sua conta pessoal e a conta de estudante, o que poderia causar cobranças extras na sua conta pessoal.
Visualizar