GSP005

Visão geral

O objetivo deste laboratório prático é transformar o código que você desenvolveu em um aplicativo replicado para o Kubernetes, executado no Kubernetes Engine. Para este laboratório, o código será um simples aplicativo Hello World em Node.js.

Veja um diagrama das várias partes deste laboratório, para ajudar você a entender como as peças se encaixam umas nas outras. Use-o como referência à medida que avança pelo laboratório, tudo fará sentido quando você chegar ao fim. Você pode ignorá-lo por enquanto.

O Kubernetes é um projeto de código aberto (disponível em kubernetes.io) que pode ser executado em muitos ambientes diferentes, desde laptops a clusters de vários nodes com alta disponibilidade, de nuvens públicas a implantações locais, de máquinas virtuais a bare metal.

Para os fins deste laboratório, usar um ambiente gerenciado como o Kubernetes Engine (uma versão do Kubernetes hospedada pelo Google em execução no Compute Engine) permitirá que você se concentre mais em testar o Kubernetes, em vez de configurar a infraestrutura subjacente.

Atividades deste laboratório

• criar um servidor do Node.js

• criar uma imagem de contêiner do Docker

• criar um cluster de contêiner

• criar um pod do Kubernetes

• escalonar seus serviços

Pré-requisitos

• É recomendado ter familiaridade com os editores de texto padrão do Linux, como vim, emacs ou nano.

Recomendamos que os alunos digitem os comandos por conta própria para ajudar no aprendizado dos conceitos principais. Muitos laboratórios incluirão um bloco de códigos que contém os comandos necessários. Você pode copiá-los desse bloco e colar nos locais apropriados durante o laboratório.

Configuração

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

Observação: 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.

• Tempo para concluir o laboratório---não se esqueça: depois de começar, não será possível pausar o laboratório.

Observação: não use seu projeto ou conta do Google Cloud neste laboratório para evitar cobranças extras na sua conta.

Como iniciar seu laboratório e fazer login no console do Google Cloud

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

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

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

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

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

Observação: para ver uma lista dos produtos e serviços do Google Cloud, clique no Menu de navegação no canto superior esquerdo.

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.

1. 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:

Your Cloud Platform project in this session is set to YOUR_PROJECT_ID

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

2. (Opcional) É possível listar o nome da conta ativa usando este comando:

gcloud auth list

3. Clique em Autorizar.

4. A saída será parecida com esta:

Saída:

ACTIVE: * ACCOUNT: student-01-xxxxxxxxxxxx@qwiklabs.net To set the active account, run: $ gcloud config set account `ACCOUNT`

5. (Opcional) É possível listar o ID do projeto usando este comando:

gcloud config list project

Saída:

[core] project = <project_ID>

Exemplo de saída:

[core] project = qwiklabs-gcp-44776a13dea667a6 Observação: para conferir a documentação completa da gcloud, acesse o guia com informações gerais sobre a gcloud CLI no Google Cloud.

Crie seu aplicativo Node.js

Com o Cloud Shell, crie um servidor Node.js simples para implantar no Kubernetes Engine:

vi server.js

Inicie o editor:

i

Adicione este conteúdo ao arquivo:

var http = require('http');
var handleRequest = function(request, response) {
  response.writeHead(200);
  response.end("Hello World!");
}
var www = http.createServer(handleRequest);
www.listen(8080);

Salve o arquivo server.js: Esc e:

:wq

Como o Cloud Shell tem o executável node instalado, execute este comando para iniciar o servidor do nó (o comando não gera uma saída):

node server.js

Use o recurso de visualização da Web integrado do Cloud Shell para abrir uma nova guia do navegador e fazer proxy de uma solicitação para a instância que você iniciou na porta 8080.

Uma nova guia do navegador será aberta para mostrar seus resultados:

Antes de continuar, retorne ao Cloud Shell e digite Ctrl+c para parar o servidor do nó em execução.

Agora, você empacotará esse aplicativo em um contêiner do Docker.

Crie uma imagem de contêiner do Docker

Em seguida, crie um Dockerfile que descreve a imagem que você quer criar. As imagens de contêiner do Docker podem ser extensões de outras imagens existentes. Por isso, para esta imagem, usaremos uma imagem de node existente.

vi Dockerfile

Inicie o editor.

i

Adicione este conteúdo:

FROM node:6.9.2
EXPOSE 8080
COPY server.js .
CMD node server.js

Esta "receita" para a imagem do Docker:

• iniciará a partir da imagem node encontrada no hub do Docker.
• exporá a porta 8080
• copiará nosso arquivo server.js para a imagem.
• iniciará o servidor do nó como fizemos manualmente antes.

Salve este Dockerfile pressionando Esc e digite:

:wq

Crie a imagem com as seguintes informações, substituindo PROJECT_ID pelo seu código do projeto do GCP, encontrado no Console e na seção Connection Details do laboratório:

docker build -t gcr.io/PROJECT_ID/hello-node:v1 .

O download e a extração levarão algum tempo, mas você pode ver as barras de progresso à medida que a imagem é criada.

Uma vez concluído, teste a imagem localmente com o seguinte comando, que executará um contêiner do Docker como um daemon na porta 8080, com base na sua imagem de contêiner recém-criada.

Execute o seguinte comando substituindo PROJECT_ID pelo seu ID de projeto do GCP, encontrado no Console e na seção Connection Details do laboratório:

docker run -d -p 8080:8080 gcr.io/PROJECT_ID/hello-node:v1

A saída deverá ser parecida com esta:

325301e6b2bffd1d0049c621866831316d653c0b25a496d04ce0ec6854cb7998

Para ver os resultados, você pode usar o recurso de visualização da Web do Cloud Shell:

Ou use curl no prompt do Cloud Shell:

curl http://localhost:8080

Você verá esta saída:

Hello World!

Depois, pare o contêiner em execução.

Para encontrar o código do contêiner do Docker, execute:

docker ps

A saída será como assim:

CONTAINER ID        IMAGE                              COMMAND
2c66d0efcbd4        gcr.io/PROJECT_ID/hello-node:v1    "/bin/sh -c 'node

Pare o contêiner executando o seguinte comando, substituindo CONTAINER ID pelo código do contêiner informado na etapa anterior:

docker stop [CONTAINER ID]

A saída do console será o código do seu contêiner, como:

2c66d0efcbd4

Agora que a imagem está funcionando conforme o esperado, envie-a para o Google Container Registry, um repositório particular para suas imagens do Docker, acessível a partir dos seus projetos do Google Cloud.

Execute este comando, substituindo PROJECT_ID pelo seu código do projeto do GCP, encontrado no Console ou na seção Connection Details do laboratório.

gcloud auth configure-docker

docker push gcr.io/PROJECT_ID/hello-node:v1

O push inicial pode levar alguns minutos para ser concluído. Você verá as barras de progresso durante a criação.

The push refers to a repository [gcr.io/qwiklabs-gcp-6h281a111f098/hello-node]
ba6ca48af64e: Pushed
381c97ba7dc3: Pushed
604c78617f34: Pushed
fa18e5ffd316: Pushed
0a5e2b2ddeaa: Pushed
53c779688d06: Pushed
60a0858edcd5: Pushed
b6ca02dfe5e6: Pushed
v1: digest: sha256:8a9349a355c8e06a48a1e8906652b9259bba6d594097f115060acca8e3e941a2 size: 2002

A imagem do contêiner estará listada no seu Console. Selecione Menu de navegação > Container Registry.

Agora você tem uma imagem do Docker em todo o projeto, que pode ser acessada e orquestrada.

Crie o cluster

Agora, você está pronto para criar seu cluster do Container Engine. Um cluster consiste em um servidor de API mestre do Kubernetes hospedado pelo Google e um conjunto de worker nodes. Os nós de trabalhos são máquinas virtuais do Compute Engine.

Certifique-se de ter definido seu projeto usando o gcloud (substitua PROJECT_ID pelo seu código do projeto do GCP, encontrado no Console e na seção Connection Details do laboratório):

gcloud config set project PROJECT_ID

Crie um cluster com dois nós n1-standard-1. Esse processo levará alguns minutos:

gcloud container clusters create hello-world \
                --num-nodes 2 \
                --machine-type n1-standard-1 \
                --zone us-central1-a

Você pode ignorar com segurança os avisos que surgem quando o cluster é compilado.

A saída do console será algo como:

Creating cluster hello-world...done.
Created [https://container.googleapis.com/v1/projects/PROJECT_ID/zones/us-central1-a/clusters/hello-world].
kubeconfig entry generated for hello-world.
NAME         ZONE           MASTER_VERSION  MASTER_IP       MACHINE_TYPE   STATUS
hello-world  us-central1-a  1.5.7           146.148.46.124  n1-standard-1  RUNNING

Observação: também é possível criar o cluster por meio do Console, como na imagem mostrada acima: Kubernetes Engine > Clusters > Criar cluster.

Se você selecionar Menu de navegação > Kubernetes Engine, verá que agora tem um cluster Kubernetes totalmente funcional com a tecnologia do Kubernetes Engine:

É hora de implantar seu próprio aplicativo em contêiner no cluster do Kubernetes. A partir de agora, usaremos a linha de comando kubectl, já configurada no ambiente do Cloud Shell.

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório.

Crie o cluster.

Crie seu pod

Um pod do Kubernetes é um grupo de contêineres agrupados para fins de administração e comunicação em rede. Ele pode ter um ou vários contêineres. Aqui, você usará um contêiner criado com a imagem do Node.js armazenada no seu Container Registry particular. O pod disponibilizará conteúdo na porta 8080.

Crie um pod com o comando kubectl run (substitua PROJECT_ID pelo seu código do projeto do GCP, encontrado no Console e na seção Connection Details do laboratório):

kubectl create deployment hello-node \
    --image=gcr.io/PROJECT_ID/hello-node:v1

Você verá esta saída:

deployment.apps/hello-node created

Como você pode ver, criamos um objeto de implantação. Implantações são a maneira recomendada de criar e escalonar pods. Aqui, uma nova implantação gerencia uma réplica de pod único que executa a imagem hello-node:v1.

Para ver a implantação, execute:

kubectl get deployments

Você verá esta saída:

NAME         READY   UP-TO-DATE   AVAILABLE   AGE
hello-node   1/1     1            1           1m36s

Para ver o pod criado pela implantação, execute:

kubectl get pods

Você verá esta saída:

NAME                         READY     STATUS    RESTARTS   AGE
hello-node-714049816-ztzrb   1/1       Running   0          6m

Agora é um bom momento para testar alguns comandos kubectl interessantes. Nenhum deles alterará o estado do cluster. A documentação completa está disponível aqui:

kubectl cluster-info

kubectl config view

E para a solução de problemas:

kubectl get events

kubectl logs <pod-name>

Agora, é preciso tornar seu pod acessível por ambientes externos.

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório.

Crie seu pod

Permita o tráfego externo

Por padrão, o pod é acessível somente do seu IP interno dentro do cluster. Para tornar o contêiner hello-node acessível de fora da rede virtual do Kubernetes, é necessário expor o pod como um serviço do Kubernetes.

Com o Cloud Shell, podemos expor o pod à Internet pública com o comando kubectl expose, combinado com o sinalizador --type="LoadBalancer". Esse sinalizador é obrigatório para a criação de um IP acessível externamente:

kubectl expose deployment hello-node --type="LoadBalancer" --port=8080

Você verá esta saída:

service/hello-node exposed

O sinalizador usado neste comando especifica se você usará o balanceador de carga fornecido pela infraestrutura subjacente (nesse caso, o balanceador de carga do Compute Engine). Observe que a implantação será exposta, não o pod diretamente. Isso fará com que o serviço resultante faça o balanceamento de carga do tráfego em todos os pods gerenciados pela implantação (nesse caso, apenas um pod, mas você adicionará mais réplicas posteriormente).

O mestre do Kubernetes cria o balanceador de carga e as regras de encaminhamento do Compute Engine relacionadas, pools de destino e regras de firewall para tornar o serviço totalmente acessível de fora do Google Cloud Platform.

Para encontrar o endereço IP publicamente acessível do serviço, solicite ao kubectl para listar todos os serviços de cluster:

kubectl get services

Você verá esta saída:

NAME         CLUSTER-IP     EXTERNAL-IP      PORT(S)    AGE
hello-node   10.3.250.149   104.154.90.147   8080/TCP   1m
kubernetes   10.3.240.1     <none>           443/TCP    5m

Há dois endereços IP listados para o serviço hello-node, ambos usando a porta 8080. O CLUSTER-IP é o IP interno, que é visível apenas dentro da sua rede virtual na nuvem. O EXTERNAL-IP é o IP com balanceamento de carga externo.

Agora, você deve conseguir acessar o serviço ao apontar seu navegador para este endereço: http://<EXTERNAL_IP>:8080

Nesse ponto, ganhamos vários recursos com a migração para contêineres e o Kubernetes. Não é preciso especificar em qual host executar nossa carga de trabalho, e também nos beneficiamos do monitoramento e da reinicialização de serviços. Vamos ver o que mais nossa nova infraestrutura do Kubernetes pode oferecer.

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório.

Crie um serviço do Kubernetes

Escalone seu serviço

Um dos poderosos recursos oferecidos pelo Kubernetes é a facilidade de escalonar seu aplicativo. Suponha que, de repente, você precisa de uma capacidade maior para seu aplicativo. Você pode dizer ao controlador de replicação para gerenciar um novo número de réplicas para seu pod:

kubectl scale deployment hello-node --replicas=4

Você verá esta saída:

deployment.extensions/hello-node scaled

Você pode solicitar uma descrição da implantação atualizada:

kubectl get deployment

Você verá esta saída:

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-node   4         4         4            4           16m

Você pode precisar executar o comando acima até ver todas as 4 réplicas criadas. Você também pode listar todos os pods:

kubectl get pods

Você verá esta saída:

NAME                         READY     STATUS    RESTARTS   AGE
hello-node-714049816-g4azy   1/1       Running   0          1m
hello-node-714049816-rk0u6   1/1       Running   0          1m
hello-node-714049816-sh812   1/1       Running   0          1m
hello-node-714049816-ztzrb   1/1       Running   0          16m

Uma abordagem declarativa está sendo usada aqui. Em vez de iniciar ou interromper novas instâncias, você declara quantas instâncias precisam estar em execução o tempo todo. Os loops de reconciliação do Kubernetes garantem que a realidade corresponda ao que você solicitou e entram em ação, se necessário.

Este diagrama resume o estado do nosso cluster Kubernetes:

Clique em Verificar meu progresso abaixo para conferir seu andamento no laboratório.

Escalone seu serviço

Implemente uma atualização no seu serviço

Em algum momento, o aplicativo implantado na produção exigirá correções de bugs ou recursos adicionais. O Kubernetes ajuda você a implantar uma nova versão na produção sem afetar seus usuários.

Primeiro, modifique o aplicativo. Edite o server.js:

vi server.js

i

Em seguida, atualize a mensagem de resposta:

response.end("Hello Kubernetes World!");

Salve o arquivo server.js: pressione Esc e:

:wq

Agora, podemos criar e publicar uma nova imagem de contêiner no registro com uma tag incrementada (v2, nesse caso):

Execute o seguinte comando, substituindo o PROJECT_ID pelo seu código do projeto do laboratório:

docker build -t gcr.io/PROJECT_ID/hello-node:v2 .

docker push gcr.io/PROJECT_ID/hello-node:v2

O Kubernetes atualizará o controlador de replicação automaticamente para a nova versão do aplicativo. Para alterar o rótulo da imagem do contêiner em execução, é preciso editar a hello-node deployment existente e alterar a imagem de gcr.io/PROJECT_ID/hello-node:v1 para gcr.io/PROJECT_ID/hello-node:v2.

Para isso, use o comando kubectl edit. Ele abre um editor de texto que mostra a configuração YAML completa da implantação. Não é preciso entender a configuração YAML completa agora. Apenas entenda que, ao atualizar o campo spec.template.spec.containers.image na configuração, você solicita à implantação que atualize os pods com a nova imagem.

kubectl edit deployment hello-node

Procure por Spec > containers > image e altere o número da versão para v2:

# Please edit the object below. Lines beginning with a '#' will be ignored,
# and an empty file will abort the edit. If an error occurs while saving this file will be
# reopened with the relevant failures.
#
apiVersion: extensions/v1beta1
kind: Deployment
metadata:
  annotations:
    deployment.kubernetes.io/revision: "1"
  creationTimestamp: 2016-03-24T17:55:28Z
  generation: 3
  labels:
    run: hello-node
  name: hello-node
  namespace: default
  resourceVersion: "151017"
  selfLink: /apis/extensions/v1beta1/namespaces/default/deployments/hello-node
  uid: 981fe302-f1e9-11e5-9a78-42010af00005
spec:
  replicas: 4
  selector:
    matchLabels:
      run: hello-node
  strategy:
    rollingUpdate:
      maxSurge: 1
      maxUnavailable: 1
    type: RollingUpdate
  template:
    metadata:
      creationTimestamp: null
      labels:
        run: hello-node
    spec:
      containers:
      - image: gcr.io/PROJECT_ID/hello-node:v1 ## Update this line ##
        imagePullPolicy: IfNotPresent
        name: hello-node
        ports:
        - containerPort: 8080
          protocol: TCP
        resources: {}
        terminationMessagePath: /dev/termination-log
      dnsPolicy: ClusterFirst
      restartPolicy: Always
      securityContext: {}
      terminationGracePeriodSeconds: 30

Depois de fazer a alteração, salve e feche o arquivo: pressione Esc e:

:wq

Você verá esta saída:

deployment.extensions/hello-node edited

Execute o seguinte comando para atualizar a implantação com a nova imagem.

kubectl get deployments

Novos pods serão criados com a nova imagem e os pods antigos serão excluídos.

Você verá esta saída (pode ser necessário executar novamente o comando acima para ver o seguinte):

NAME         DESIRED   CURRENT   UP-TO-DATE   AVAILABLE   AGE
hello-node   4         4         4            4           1h

Enquanto isso acontece, os usuários dos seus serviços não sofrerão nenhuma interrupção. Depois de algum tempo, eles começarão a acessar a nova versão do seu aplicativo. Veja mais detalhes sobre atualizações contínuas nesta documentação.

Esperamos que, com esses recursos de implantação, escalonamento e atualização, depois de configurar seu cluster do Kubernetes Engine, você concorde que o Kubernetes ajuda você a se concentrar no aplicativo e não na infraestrutura.

Teste seus conhecimentos

Faça nosso teste para testar seu conhecimento sobre o Google Cloud Platform. Selecione todas as opções corretas.

Parabéns!

Isso conclui este laboratório prático com o Kubernetes. Nós abordamos apenas uma pequena parte dessa tecnologia e incentivamos você a explorar ainda mais com seus próprios pods, controladores de replicação e serviços. Verifique também as sondas de atividade (verificações de integridade) e considere a possibilidade de usar a Kubernetes API diretamente.

Comece seu próximo laboratório

Continue sua Quest com Gerenciar implantações usando o Kubernetes Engine ou confira estas sugestões:

• Orquestração na nuvem com o Kubernetes

• Como configurar um cluster particular do Kubernetes

Próximas etapas/saiba mais

• Depois de fazer este laboratório, confira o Minikube, que oferece uma instalação simples de um cluster do Kubernetes com um único nó para fins de desenvolvimento e teste: http://kubernetes.io/docs/getting-started-guides/minikube/.
• O Kubernetes é um projeto de código aberto (http://kubernetes.io/) hospedado no GitHub. Seu feedback e suas contribuições são sempre bem-vindos.
• Você pode acompanhar as notícias sobre o Kubernetes no Twitter e no blog da comunidade.

Treinamento e certificação do Google Cloud

Esses treinamentos ajudam você a aproveitar as tecnologias do Google Cloud ao máximo. Nossas aulas incluem habilidades técnicas e práticas recomendadas para ajudar você a alcançar rapidamente o nível esperado e continuar sua jornada de aprendizado. Oferecemos treinamentos que vão do nível básico ao avançado, com opções de aulas virtuais, sob demanda e por meio de transmissões ao vivo para que você possa encaixá-las na correria do seu dia a dia. As certificações validam sua experiência e comprovam suas habilidades com as tecnologias do Google Cloud.

Manual atualizado em 4 de dezembro de 2020

Laboratório testado em 4 de dezembro 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.