Checkpoints
Configure the Quiz application
/ 30
Create Kubernetes engine cluster
/ 20
Build Docker Images using Container Builder
/ 20
Create Kubernetes Deployment and Service Resources
/ 30
Desenvolvimento de aplicativos: como implantar aplicativos no Kubernetes Engine – Python
GSP188
Visão geral
O Google Kubernetes Engine oferece um ambiente gerenciado para implantação, gerenciamento e escalonamento dos aplicativos em contêiner usando a infraestrutura do Google. O ambiente do Kubernetes Engine consiste em várias máquinas (especificamente, instâncias do Google Compute Engine) agrupadas para formar um cluster.
O Kubernetes fornece os mecanismos para interagir com o cluster. Você usa os comandos e recursos do Kubernetes para implantar e gerenciar os aplicativos, executar tarefas administrativas e definir políticas, além de monitorar a integridade das cargas de trabalho implantadas.
Neste laboratório, você implantará o aplicativo de teste no Kubernetes Engine usando os recursos do Google Cloud Platform, como o Container Builder e o Container Registry, além dos recursos do Kubernetes, como implantações, pods e serviços.
Objetivos
Neste laboratório, você aprenderá a fazer o seguinte:
- Criar Dockerfiles para empacotar o front-end do aplicativo de teste e o código de back-end da implantação
- Usar o Container Builder para produzir imagens do Docker
- Provisionar um cluster do Kubernetes Engine para hospedar o aplicativo de teste
- Usar implantações do Kubernetes para provisionar pods replicados no Kubernetes Engine
- Usar um serviço do Kubernetes para provisionar um balanceador de carga para o front-end do teste
Configuração do Qwiklabs
Antes de clicar no botão Start Lab
Leia estas instruções. Os laboratórios são cronometrados e não podem ser pausados. O timer é iniciado quando você clica em Começar o laboratório e mostra por quanto tempo os recursos do Google Cloud vão ficar disponíveis.
Este laboratório prático permite que você realize as atividades em um ambiente real de nuvem, não em uma simulação ou demonstração. Você vai receber novas credenciais temporárias para fazer login e acessar o Google Cloud durante o laboratório.
Confira os requisitos para concluir o laboratório:
- Acesso a um navegador de Internet padrão (recomendamos o Chrome).
- Tempo para concluir o laboratório---não se esqueça: depois de começar, não será possível pausar o laboratório.
Como iniciar seu laboratório e fazer login no console do Google Cloud
-
Clique no botão Começar o laboratório. Se for preciso pagar, você verá um pop-up para selecionar a forma de pagamento. No painel Detalhes do laboratório à esquerda, você verá o seguinte:
- O botão Abrir Console do Cloud
- Tempo restante
- As credenciais temporárias que você vai usar neste laboratório
- Outras informações se forem necessárias
-
Clique em Abrir Console do Google. O laboratório ativa recursos e depois abre outra guia com a página Fazer login.
Dica: coloque as guias em janelas separadas lado a lado.
Observação: se aparecer a caixa de diálogo Escolher uma conta, clique em Usar outra conta. -
Caso seja preciso, copie o Nome de usuário no painel Detalhes do laboratório e cole esse nome na caixa de diálogo Fazer login. Clique em Avançar.
-
Copie a Senha no painel Detalhes do laboratório e a cole na caixa de diálogo Olá. Clique em Avançar.
Importante: você precisa usar as credenciais do painel à esquerda. Não use suas credenciais do Google Cloud Ensina. Observação: se você usar sua própria conta do Google Cloud neste laboratório, é possível que receba cobranças adicionais. -
Acesse as próximas páginas:
- Aceite os Termos e Condições.
- Não adicione opções de recuperação nem autenticação de dois fatores (porque essa é uma conta temporária).
- Não se inscreva em testes gratuitos.
Depois de alguns instantes, o console do GCP vai ser aberto nesta guia.
Ativar o Cloud Shell
O Cloud Shell é uma máquina virtual com várias ferramentas de desenvolvimento. Ele tem um diretório principal permanente de 5 GB e é executado no Google Cloud. O Cloud Shell oferece acesso de linha de comando aos recursos do Google Cloud.
- Clique em Ativar o Cloud Shell na parte de cima do console do Google Cloud.
Depois de se conectar, vai notar que sua conta já está autenticada, e que o projeto está configurado com seu PROJECT_ID. A saída contém uma linha que declara o projeto PROJECT_ID para esta sessão:
gcloud
é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.
- (Opcional) É possível listar o nome da conta ativa usando este comando:
-
Clique em Autorizar.
-
A saída será parecida com esta:
Saída:
- (Opcional) É possível listar o ID do projeto usando este comando:
Saída:
Exemplo de saída:
gcloud
, acesse o guia com informações gerais sobre a gcloud CLI no Google Cloud.
Inicie o editor de código do Cloud Shell
No Cloud Shell, clique no ícone Abrir Editor (parece um lápis) para iniciar o editor de código.
Prepare o aplicativo de teste
Nesta seção, você acessará o Cloud Shell, clonará o repositório git que contém o aplicativo de teste, definirá as variáveis de ambiente e executará o aplicativo.
Clone o código-fonte no Cloud Shell
Clique em Abrir Terminal e clone o repositório para o laboratório.
git clone https://github.com/GoogleCloudPlatform/training-data-analyst
Crie um link virtual como um atalho para o diretório de trabalho.
ln -s ~/training-data-analyst/courses/developingapps/v1.2/python/kubernetesengine ~/kubernetesengine
Configure o aplicativo de teste
Altere o diretório de trabalho.
cd ~/kubernetesengine/start
Configure o aplicativo de teste.
. prepare_environment.sh
Este arquivo de script faz o seguinte:
- cria um aplicativo do Google App Engine;
- exporta as variáveis de ambiente
GCLOUD_PROJECT
eGCLOUD_BUCKET
; - atualiza o pip e depois executa
pip install -r requirements.txt
; - cria entidades no Google Cloud Datastore;
- cria um tópico do Google Cloud Pub/Sub;
- cria uma instância, um banco de dados e uma tabela do Cloud Spanner;
- imprime o código do projeto do Google Cloud Platform.
O aplicativo de teste estará configurado quando a seguinte mensagem aparecer:
Exemplo de mensagem de saída
Creating Cloud Pub/Sub topic
Created topic [projects/qwiklabs-gcp-92b7e5716e0cbf7e/topics/feedback].
Created subscription [projects/qwiklabs-gcp-92b7e5716e0cbf7e/subscriptions/worker-subscription].
Creating Cloud Spanner Instance, Database, and Table
Creating instance...done.
Creating database...done.
Project ID: qwiklabs-gcp-92b7e5716e0cbf7e
Clique em verificar meu progresso para verificar o objetivo.
Revise o código
In this section you examine the application files.
Para ver e editar arquivos, você pode usar os editores de shell instalados no Cloud Shell, como o nano
ou o vim
ou o editor de código do Cloud Shell. Este laboratório usa o editor de código do Cloud Shell.
Este laboratório usará o editor de código do Cloud Shell para revisar o código do aplicativo de teste.
Examine o código
Navegue até training-data-analyst/courses/developingapps/v1.2/python/kubernetesengine/start
.
A estrutura de pastas do aplicativo de teste representa como ele será implantado no Kubernetes Engine.
O aplicativo da Web está em uma pasta chamada frontend
.
O código do aplicativo do worker que se registra no Cloud Pub/Sub e processa mensagens está na pasta backend
.
Você encontrará arquivos de configuração para o Docker (um Dockerfile
nas pastas frontend
e backend
) e arquivos no formato .yaml
do Kubernetes Engine chamados backend-deployment
e frontend-deployment
.
Crie um cluster do Kubernetes Engine e conecte-se a ele
Crie um cluster do Kubernetes Engine
-
No Console do Cloud Platform, clique em Menu de navegação > Kubernetes Engine > Clusters.
-
Clique em Criar cluster.
-
Configurar o cluster. Defina os seguintes campos para os valores fornecidos, deixe todas as outras opções nos valores padrão:
Propriedade |
Valor |
Nome |
|
Zone |
|
default Pool > Segurança > Escopos de acesso |
Selecione Permitir acesso completo a todas as APIs do Cloud, e depois clique em Salvar. |
-
Clique em Criar. O cluster leva alguns minutos para ser provisionado.
Clique em verificar meu progresso para verificar o objetivo.
Conecte-se ao cluster
Nesta seção, você conectará o aplicativo de teste ao cluster do Kubernetes.
- Quando o cluster estiver pronto, clique em Conectar.
-
Em Conectar ao cluster, clique em Executar no Cloud Shell para preencher o Cloud Shell com o comando semelhante a
gcloud container clusters get-credentials quiz-cluster --zone us-central1-b --project [Project-ID]
. Pressione Enter para executar o comando no Cloud Shell. -
Execute o seguinte comando para listar os pods no cluster:
kubectl get pods
Você verá a resposta No resources found
, já que não há pods no cluster. Isso confirma que você configurou a ferramenta de linha de comando kubectl
para executar operações no cluster.
Crie imagens do Docker usando o Container Builder
Nesta seção, você criará um Dockerfile para o front-end e o back-end do aplicativo e usará o Container Builder para criar imagens e armazená-las no Container Registry.
Crie o Dockerfile para o front-end e o back-end
No editor de código do Cloud Shell, abra frontend/Dockerfile
. Agora você adicionará um bloco de código que:
- insere o comando do Dockerfile para inicializar a criação de uma imagem do Docker personalizada usando a imagem do App Engine para Python do Google como ponto de partida;
- escreve os comandos do Dockerfile para ativar um ambiente virtual;
- escreve o comando do Dockerfile para executar
pip install
como parte do processo de criação; - escreve o comando do Dockerfile para adicionar conteúdo da pasta atual ao caminho
/app
no contêiner; - finaliza o
Dockerfile
ao inserir a declaraçãogunicorn ...
, executada quando o contêiner é iniciado. O Gunicorn (Green Unicorn) é um servidor HTTP compatível com a especificação para Python da interface de gateway do servidor da Web (WSGI, na sigla em inglês).
Agora, copie e cole o seguinte código no Dockerfile
:
FROM gcr.io/google_appengine/python
RUN virtualenv -p python3.7 /env
ENV VIRTUAL_ENV /env
ENV PATH /env/bin:$PATH
ADD requirements.txt /app/requirements.txt
RUN pip install -r /app/requirements.txt
ADD . /app
CMD gunicorn -b 0.0.0.0:$PORT quiz:app
Agora, abra o arquivo backend/Dockerfile
e copie e cole o seguinte código:
FROM gcr.io/google_appengine/python
RUN virtualenv -p python3.7 /env
ENV VIRTUAL_ENV /env
ENV PATH /env/bin:$PATH
ADD requirements.txt /app/requirements.txt
RUN pip install -r /app/requirements.txt
ADD . /app
CMD python -m quiz.console.worker
Crie imagens do Docker com o Container Builder
-
No Cloud Shell, certifique-se que você está na pasta
start
: -
Execute o seguinte comando para construir a imagem do frontend Docker:
cd ~/kubernetesengine/start
gcloud builds submit -t gcr.io/$DEVSHELL_PROJECT_ID/quiz-frontend ./frontend/
Os arquivos são armazenados no Cloud Storage, e uma imagem do Docker é criada e armazenada no Container Registry. Isso pode demorar alguns minutos.
Ignore as mensagens de incompatibilidade que aparecerão com os resultados.
-
Agora, execute o seguinte comando para criar a imagem de back-end do Docker:
gcloud builds submit -t gcr.io/$DEVSHELL_PROJECT_ID/quiz-backend ./backend/
Quando a imagem de back-end do Docker estiver pronta, você verá estas últimas mensagens:
DONE
-----------------------------------------------------------------------------------------------------------------------
ID CREATE_TIME DURATION SOURCE
IMAGES
STATUS
be0326f4-3f6f-42d6-850f-547e260dd4d7 2018-06-13T22:20:16+00:00 50S gs://qwiklabs-gcp-3f89d0745056ee31_cloudbuil
d/source/1528928414.79-4914d2a972f74e188f40ced135662b7d.tgz gcr.io/qwiklabs-gcp-3f89d0745056ee31/quiz-backend (+1 more
) SUCCESS
- No Console do Cloud Platform, clique em Menu de navegação e selecione Container Registry.
Você verá dois pods:
quiz-frontend
equiz-backend
.
- Clique em quiz-frontend.
Clique em verificar meu progresso para verificar o objetivo.
Crie recursos de implantação e serviço do Kubernetes
Nesta seção, você modificará os arquivos yaml
de modelo que contêm a especificação dos recursos de implantação e serviço do Kubernetes e depois criará os recursos no cluster do Kubernetes Engine.
Crie um arquivo de implantação do Kubernetes
- No editor de código do Cloud Shell, abra o arquivo
frontend-deployment.yaml
.
- Substitua os marcadores de posição no arquivo
frontend-deployment.yaml
pelos seguintes valores:
Nome do marcador |
Valor |
|
Código do projeto do GCP |
|
Nome do intervalo do Cloud Storage para o intervalo de mídia do projeto |
|
A imagem de front-end identificada no formulário |
- Salve o arquivo.
- Substitua os marcadores de posição no arquivo
backend-deployment.yaml
pelos seguintes valores:
Nome do marcador |
Valor |
|
Código do projeto do GCP |
|
Código do intervalo do Cloud Storage para o intervalo de mídia do projeto |
|
A imagem de back-end identificada no formulário |
- Salve o arquivo.
- Revise o conteúdo do arquivo
frontend-service.yaml
.
Execute os arquivos da implantação e do serviço
-
No Cloud Shell, provisione a implantação do front-end do teste.
kubectl create -f ./frontend-deployment.yaml
-
Provisione a implantação do back-end do teste.
kubectl create -f ./backend-deployment.yaml
-
Provisione o serviço do front-end do teste.
kubectl create -f ./frontend-service.yaml
Clique em verificar meu progresso para verificar o objetivo.
Verifique o aplicativo de teste
Nesta seção, você revisará os pods e os serviços implantados e navegará até o aplicativo de teste.
Revise os recursos implantados
- No Console do Google Cloud Platform, clique em Menu de navegação e selecione Kubernetes Engine.
- Clique em Cargas de trabalho.
-
Clique em quiz-frontend. Na seção Pods gerenciados, há três pods quiz-frontend.
-
Na seção Serviços na parte inferior, procure a seção Pontos de extremidade e copie o endereço do IP e cole no campo URL de uma nova guia ou janela do navegador:
-
Essa ação abrirá o aplicativo de teste em uma nova guia. Isso indica que você implantou o aplicativo corretamente. Você pode encerrar o laboratório aqui ou usar o restante do tempo para criar alguns testes.
Parabéns!
Isso conclui o laboratório self-paced: Desenvolvimento de aplicativos: como implantar aplicativos no Kubernetes Engine – Python. Você aproveitou os recursos do GCP e recursos do Kubenetes para implantar um aplicativo de teste
Termine a Quest
Este self-paced laboratório faz parte do Desenvolvimento de Aplicações - Python. e Missões de Cloud Development. Uma Quest é um conjunto de laboratórios relacionados que formam um programa de aprendizado. Concluir esta Quest dá a você o selo acima como reconhecimento pela sua conquista. Você pode publicar os selos e incluir um link para eles no seu currículo on-line ou nas redes sociais. Inscreva-se nesta Quest e ganhe créditos de conclusão agora se você já tiver feito este laboratório. Veja outras Quests do Qwiklabs.
Próximas etapas / Saiba mais
Saiba mais sobre o Kubernetes Engine.
Manual atualizado em 16 de outubro de 2020
Laboratório testado em 16 de outubro de 2020
Copyright 2024 Google LLC. Todos os direitos reservados. Google e o logotipo do Google são marcas registradas da Google LLC. Todos os outros nomes de produtos e empresas podem ser marcas registradas das respectivas empresas a que estão associados.