Checkpoints
Create your cluster
/ 20
Create your pod
/ 30
Create a Kubernetes Service
/ 30
Scale up your service
/ 20
Hello Node Kubernetes
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
ounano
.
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).
- 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.
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 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.
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.
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.
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:
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.