Informações gerais

O Google Kubernetes Engine oferece um ambiente gerenciado para implantação, gerenciamento e escalonamento dos aplicativos em contêineres usando a infraestrutura do Google. O ambiente do Kubernetes Engine é composto por várias máquinas (instâncias do Google Compute Engine) agrupadas para formar um cluster.

O Kubernetes contém os mecanismos necessários para interagir com o cluster. Use 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.

Durante o laboratório, você vai implantar o aplicativo de teste no Kubernetes Engine usando os recursos do Google Cloud Platform, como o Cloud Build e o Container Registry, além dos recursos do Kubernetes, como implantações, pods e serviços.

Objetivos

Neste laboratório, você aprenderá a realizar as seguintes tarefas:

• Criar Dockerfiles para empacotar o código de front-end e back-end do aplicativo de teste para implantação
• Usar o Cloud Build para produzir imagens 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 e requisitos

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.

Ative o Google Cloud Shell

O Google Cloud Shell é uma máquina virtual com 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.

1. No console do Cloud, clique no botão "Abrir o Cloud Shell" na barra de ferramentas superior direita.

   

2. Clique em Continuar.

O provisionamento e a conexão do ambiente podem demorar um pouco. Quando você estiver conectado, já estará autenticado, e o projeto estará definido com seu PROJECT_ID. Exemplo:

A gcloud é a ferramenta de linha de comando do Google Cloud. Ela vem pré-instalada no Cloud Shell e aceita preenchimento com tabulação.

• Para listar o nome da conta ativa, use este comando:

gcloud auth list

Saída:

Credentialed accounts: - @.com (active)

Exemplo de saída:

Credentialed accounts: - google1623327_student@qwiklabs.net

• Para listar o ID do projeto, use este comando:

gcloud config list project

Saída:

[core] project =

Exemplo de saída:

[core] project = qwiklabs-gcp-44776a13dea667a6 Observação: a documentação completa da gcloud está disponível no guia com informações gerais sobre a gcloud CLI .

Tarefa 1: preparar o aplicativo de teste

Nesta seção, você irá clonar o repositório Git que contém o aplicativo de teste, configurar as variáveis de ambiente e executar o aplicativo.

Clonar o código-fonte no Cloud Shell

1. Digite o comando abaixo no Cloud Shell para clonar o repositório do laboratório:

git clone --depth=1 https://github.com/GoogleCloudPlatform/training-data-analyst

2. Crie um link flexível para seu diretório de trabalho:

ln -s ~/training-data-analyst/courses/developingapps/v1.3/java/kubernetesengine ~/kubernetesengine

Configurar o aplicativo de teste

1. Altere para o diretório que contém os arquivos de trabalho:

cd ~/kubernetesengine/start

2. Configure o aplicativo de front-end do teste:

. prepare_environment.sh Observação: este arquivo de script faz o seguinte:

• Cria um aplicativo do Google App Engine.
• Exporta as variáveis de ambiente GCLOUD_PROJECT e GCLOUD_BUCKET;
• Executa o mvn clean install
• 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

Revisar o código

Agora revise e atualize o código do aplicativo de teste em um editor de código. Use o editor de código do Cloud Shell ou os editores de shell instalados no Cloud Shell, como nano ou vim. O laboratório usa o editor de código do Cloud Shell.

1. Inicie o editor de código do Cloud Shell. No Cloud Shell, clique em Abrir editor (um ícone de lápis) para iniciar o editor de código.

Observação: o editor de código substitui o terminal. Para voltar ao terminal depois, selecione a opção Abrir terminal.

2. Verifique o código e a estrutura de pastas. No editor de código do Cloud Shell, navegue até training-data-analyst/courses/developingapps/v1.3/java/kubernetesengine/start.

Observação: na pasta `kubernetesengine`, confira a pasta `end`. A pasta `end` tem os mesmos arquivos que a pasta `start`, mas os que estão na pasta `end` incluem o código completo necessário para executar o laboratório.

A estrutura de pastas do aplicativo de teste agora reflete como ele é implantado no Kubernetes Engine.

• A pasta frontend: contém a saída empacotada para o aplicativo da Web.
• A pasta backend: contém a saída empacotada para o aplicativo do console.
• Dockerfile nas pastas frontend e backend: arquivos de configuração do Docker. Por enquanto, vazio.
• *.yaml: arquivo de configuração do Kubernetes Engine.

3. No Cloud Shell, volte para o terminal e use o seguinte comando para copiar a saída jar do aplicativo de frontend para a pasta frontend:

   cp ./target/quiz-frontend-0.0.1.jar ./frontend/

4. Configure o aplicativo de back-end do teste:

   mvn package -f pom-backend.xml

5. Copie o jar de saída do aplicativo de back-end na pasta backend:

   cp ./target/quiz-backend-0.0.1.jar ./backend/

Tarefa 2: como criar um cluster do Kubernetes Engine

Nesta seção, você vai criar um cluster do Google Kubernetes Engine para hospedar o aplicativo de teste.

1. No Console, clique em Menu de navegação > Kubernetes Engine > Clusters.

2. Em seguida, clique em Criar.

3. Selecione Configurar para o GKE Standard.

4. Para configurar o cluster, use os valores especificados para as propriedades listadas na tabela a seguir. Mantenha os valores padrão para as propriedades não listadas:

   Em Noções básicas sobre clusters:

   Propriedade	Valor
   Name	quiz-cluster
   Zone	us-central1-b

5. Expanda default-pool.

6. Em Segurança selecione Permitir acesso completo a todas as APIs do Cloud.

7. Clique em Criar. O provisionamento do cluster levará alguns minutos.

Conectar ao cluster

1. Quando o cluster estiver pronto, clique nos três pontos verticais e selecione Connect.

   

2. Em Connect to the cluster, copie o primeiro comando para a área de transferência.

3. Clique em OK para fechar a janela "Conectar ao cluster".

O comando está no seguinte formato: gcloud container clusters get-credentials quiz-cluster --zone us-central1-b --project <Project-ID>.

4. Copie o comando no Cloud Shell e pressione Enter.

   Ou clique em Executar no Cloud Shell e, em seguida, pressione Enter.

5. Liste os pods no cluster.

   kubectl get pods

A resposta deve indicar que não há pods no cluster.

Ela confirma que você configurou a segurança para que a ferramenta de linha de comando kubectl execute operações no cluster.

Tarefa 3: criar imagens Docker usando o Cloud Build

Nesta seção, você vai criar um Dockerfile para o front-end e back-end do aplicativo e usar o Cloud Build para criar imagens e armazená-las no Container Registry.

Criar o Dockerfile para o front-end

1. No editor de código do Cloud Shell, em Abrir editor, abra frontend/Dockerfile.

2. Copie e cole o seguinte conteúdo em frontend/Dockerfile:

FROM gcr.io/google_appengine/jetty9 VOLUME /tmp ADD ./quiz-frontend-0.0.1.jar /app.jar CMD java -jar /app.jar

3. Salve o arquivo.

O que o script faz:

Ele é composto por uma série de comandos do Dockerfile.

• O primeiro comando, FROM gcr.io/google_appengine/jetty9, inicializa a criação de uma imagem do Docker personalizada usando a imagem do Google App Engine Jetty 9, gcr.io/google_appengine/jetty9, como ponto de partida.

• O segundo comando, VOLUME /tmp, cria um volume no sistema de arquivos do contêiner com o caminho /tmp.

• O terceiro comando, ADD ./quiz-frontend-0.0.1.jar /app.jar, adiciona o arquivo Jar, uiz-frontend-0.0.1.jar para o front-end gerado pelo processo de empacotamento do Maven como parte do processo de build.

• O quarto e último comando, CMD java -jar /app.jar, é executado quando o contêiner é iniciado.

Crie o Dockerfile para o back-end

O dockerfile para o back-end é criado da mesma maneira que o front-end, porém o arquivo jar é adicionado ao back-end.

1. No editor de código do Cloud Shell, abra o backend/Dockerfile.

2. Copie e cole o seguinte conteúdo em backend/Dockerfile:

FROM gcr.io/google_appengine/jetty9 VOLUME /tmp ADD ./quiz-backend-0.0.1.jar /app.jar CMD java -jar /app.jar

3. Salve o arquivo.

Tarefa 4: criar imagens Docker com o Cloud Build

1. No Cloud Shell, em Abrir terminal, insira o seguinte comando para criar a imagem Docker de front-end:

   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 levará alguns segundos.

2. Crie a imagem de back-end do Docker:

   gcloud builds submit -t gcr.io/$DEVSHELL_PROJECT_ID/quiz-backend ./backend/

3. No Console, clique em Menu de navegação > Container Registry. Duas pastas aparecerão: quiz-frontend e quiz-backend.

4. Clique em quiz-frontend. Serão exibidos o nome (um hash), as tags (mais recentes) e outros detalhes da imagem.

Tarefa 5: criar recursos de implantação e serviço do Kubernetes

Nesta seção, você vai modificar os arquivos de modelo yaml, que contêm a especificação dos recursos de implantação e serviço do Kubernetes, e criar os recursos no cluster do Kubernetes Engine.

Crie um arquivo de implantação do Kubernetes

1. No editor de código, abra o arquivo frontend-deployment.yaml. A estrutura do arquivo já foi criada para você. Agora substitua os marcadores pelos valores do projeto.

2. Substitua os marcadores no arquivo frontend-deployment.yaml usando os seguintes valores:

   Marcador (Nome)	Valor
   [GCLOUD_PROJECT]	ID do projeto do GCP (exiba o ID do projeto digitando echo $GCLOUD_PROJECT no Cloud Shell)
   [GCLOUD_BUCKET]	ID do bucket do Cloud Storage para o bucket de mídia do projeto O ID do bucket é [GCP_Project_ID]-media.
   [FRONTEND_IMAGE_IDENTIFIER]	Imagem do front-end identificada no formulário gcr.io/[GCP_Project_ID]/quiz-frontend

   Substitua apenas os valores que estão entre [].

   O arquivo yaml resultante parece com o seguinte:

   apiVersion: apps/v1beta1 kind: Deployment metadata: name: quiz-frontend labels: app: quiz-app spec: replicas: 3 template: metadata: labels: app: quiz-app tier: frontend spec: containers: - name: quiz-frontend image: gcr.io/qwiklabs-gcp-04-3ad1f39f2114/quiz-frontend imagePullPolicy: Always ports: - name: http-server containerPort: 8080 env: - name: GCLOUD_PROJECT value: qwiklabs-gcp-04-3ad1f39f2114 - name: GCLOUD_BUCKET value: qwiklabs-gcp-04-3ad1f39f2114-media

   A implantação do front-end de teste provisiona três réplicas da imagem de front-end do Docker nos pods do Kubernetes, distribuídas nos três nós do cluster do Kubernetes Engine.

3. Salve o arquivo.

4. Abra o arquivo backend-deployment.yaml e substitua os marcadores no arquivo backend-deployment.yaml usando os seguintes valores:

   Marcador (Nome)	Valor
   [GCLOUD_PROJECT]	ID do projeto do GCP (ou use echo $GCLOUD_PROJECT)
   [GCLOUD_BUCKET]	ID do bucket do Cloud Storage para o bucket de mídia do projeto Este será o mesmo bucket usado em frontend-deployment.yaml (O ID do bucket é [GCP_Project_ID]-media.)
   [BACKEND_IMAGE_IDENTIFIER]	Imagem de back-end identificada no formulário gcr.io/[GCP_Project_ID]/quiz-backend

   A implantação do quiz-backend provisiona uma réplica da imagem de back-end do Docker nos pods do Kubernetes, posicionada em um dos três nós do cluster do Kubernetes Engine.

5. Salve o arquivo.

6. Revise o conteúdo do arquivo frontend-service.yaml.

   Observação: o serviço apresenta a implantação do front-end usando um balanceador de carga, que envia solicitações de clientes para as três réplicas do pod de front-end.

Execute os arquivos de implantação e serviço

1. No Cloud Shell, provisione a implantação do front-end de teste:

   kubectl create -f ./frontend-deployment.yaml

2. Provisione a implantação do back-end de teste:

   kubectl create -f ./backend-deployment.yaml

3. Provisione o serviço do front-end de teste:

   kubectl create -f ./frontend-service.yaml

Cada comando provisiona recursos no Kubernetes Engine. Este processo levará alguns minutos para ser concluído.

Tarefa 6: testar o aplicativo

Nesta seção, revise os pods e os serviços implantados e navegue até o aplicativo de teste.

Revise os recursos implantados

1. No Console, clique em Menu de navegação > Kubernetes Engine > Cargas de trabalho. Você verá dois itens: quiz-frontend e quiz-backend.

   O status do pod poderá aparecer como OK ou em processo de criação.

2. Clique em quiz-frontend para acessar as informações gerais do quiz-frontend.

3. Role para baixo até encontrar Pods gerenciados.

   O status do balanceador de carga quiz-frontend poderá aparecer como OK ou em processo de criação. Aguarde até que o serviço esteja OK antes de continuar. Você verá um endpoint do endereço IP quando o serviço estiver pronto.

4. Em Como expor serviços, em Endpoints, selecione o endereço IP e abra em uma nova guia do navegador.

5. Faça um teste para verificar se o aplicativo funciona conforme o esperado.

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