Informações gerais

Neste laboratório, você vai usar a linha de comando para criar clusters do GKE. Você vai inspecionar o arquivo kubeconfig e usar kubectl para manipular o cluster.

Objetivos

Neste laboratório, você vai aprender a fazer o seguinte:

• Usar kubectl para criar e manipular clusters do GKE
• Usar kubectl e os arquivos de configuração para implantar pods
• Usar o Container Registry para armazenar e implantar contêineres

Configuração do laboratório

Acesse o Qwiklabs

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.

Após concluir as etapas iniciais de login, o painel do projeto será exibido.

Abra o Cloud Shell

A maioria das tarefas será realizada no Cloud Shell, um ambiente de linha de comando em execução no Google Cloud. O Cloud Shell é uma máquina virtual com base em Debian que contém todas as ferramentas de gestão necessárias (como docker, gcloud, gsutil e kubectl) e conta com um diretório principal permanente de 5 GB.

1. Na barra de título do console do Google Cloud, clique em Ativar o Cloud Shell ().
2. Clique em Continuar.

Após o provisionamento, o prompt do Cloud Shell será exibido:

Tarefa 1: implantar clusters do GKE

Nesta tarefa, você vai usar o Cloud Shell para implantar clusters do GKE.

1. No Cloud Shell, digite o comando a seguir para definir a variável de ambiente da zona e o nome do cluster:

export my_region={{{project_0.default_region|Region}}} export my_cluster=autopilot-cluster-1

2. No Cloud Shell, digite o seguinte comando para criar um cluster do Kubernetes:

gcloud container clusters create-auto $my_cluster --region $my_region

Esse comando define a maioria das opções como padrão. Para acessar o conjunto completo de opções possíveis, consulte a referência do gcloud container clusters create.

Serão exibidos vários avisos sobre as mudanças nas configurações padrão do cluster do GKE, que foram introduzidas com a nova versão do Kubernetes adotada pelo GKE.

Observação: espere alguns minutos até que a implantação do cluster seja concluída.

Quando ela terminar, a página Kubernetes Engine > Clusters do console do Google Cloud terá a aparência da seguinte captura de tela:

Selecione Conferir meu progresso para consultar o objetivo. Implante clusters do GKE

Tarefa 2: conectar-se a um cluster do GKE

Nesta tarefa, você vai usar o Cloud Shell para autenticar um cluster do GKE e depois vai inspecionar os arquivos de configuração do kubectl.

A autenticação no Kubernetes se aplica não só à comunicação entre o cluster e um cliente externo por meio do kube-APIserver em execução no mestre, mas também às interações internas e externas dos contêineres de cluster.

No Kubernetes, a autenticação pode assumir várias formas. No GKE, a autenticação geralmente é processada com tokens OAuth2 e pode ser gerenciada no projeto como um todo por meio do Cloud Identity and Access Management. Outra opção é usar o controle de acesso com base em papéis, que pode ser definido e configurado em cada cluster.

Os contêineres de cluster podem usar contas de serviço para autenticar e acessar recursos externos no GKE.

Observação: nas versões do Kubernetes anteriores à 1.12, os certificados de cliente e a autenticação básica não estão desativados por padrão. Como são métodos de autenticação menos seguros, eles precisam ser desativados para aumentar a segurança do cluster. Nas versões 1.12 e mais recentes, isso já é feito por padrão.

1. Execute o comando a seguir para criar um arquivo kubeconfig com as credenciais do usuário atual e permitir a autenticação. Ele também fornece os detalhes do endpoint de um cluster específico para permitir a comunicação com esse cluster na ferramenta de linha de comando kubectl.

gcloud container clusters get-credentials $my_cluster --region $my_region

Esse comando cria um diretório .kube no diretório principal, se ele ainda não existir. No diretório .kube, o comando cria um arquivo chamado config (caso ainda não exista). Ele vai ser usado para armazenar as informações de autenticação e configuração. O arquivo de configuração é normalmente chamado kubeconfig.

2. Abra o arquivo kubeconfig com o editor de texto nano:

nano ~/.kube/config

Agora é possível examinar todos os dados de configuração de autenticação e endpoint armazenados no arquivo. Serão exibidas as informações para o cluster que foram preenchidas durante a criação dele.

3. Pressione CTRL+X para sair do editor nano.

Observação: o arquivo kubeconfig pode conter informações de vários clusters. O contexto ativo atualmente (o cluster que os comandos kubectl manipulam) é indicado pela propriedade current-context.

Não é necessário executar o comando gcloud container clusters get-credentials para preencher o arquivo kubeconfig de clusters criados no mesmo contexto (mesmo usuário e ambiente), porque os detalhes desses clusters já foram preenchidos no momento da criação.

No entanto, você precisa executar o comando para se conectar aos clusters criados por outros usuários ou fora do ambiente. Ele também é uma forma fácil de mudar o contexto ativo para outro cluster.

Tarefa 3: usar o kubectl para inspecionar um cluster do GKE

Nesta tarefa, você vai usar o Cloud Shell e kubectl para inspecionar um cluster do GKE.

Depois de preencher o arquivo kubeconfig e definir o contexto ativo como um cluster específico, use a ferramenta de linha de comando kubectl para executar comandos no cluster. A maioria desses comandos aciona uma chamada da API REST diretamente no servidor da API mestre, que leva à ação associada.

1. No Cloud Shell, execute o seguinte comando para imprimir o conteúdo do arquivo kubeconfig:

kubectl config view

Os dados confidenciais do certificado são substituídos por DATA+OMITTED.

2. No Cloud Shell, execute o comando a seguir para imprimir as informações do cluster de contexto ativo:

kubectl cluster-info

A saída descreve o cluster de contexto ativo.

Saída:

Kubernetes control plane is running at https://34.133.211.75 GLBCDefaultBackend is running at https://34.133.211.75/api/v1/namespaces/kube-system/services/default-http-backend:http/proxy KubeDNS is running at https://34.133.211.75/api/v1/namespaces/kube-system/services/kube-dns:dns/proxy KubeDNSUpstream is running at https://34.133.211.75/api/v1/namespaces/kube-system/services/kube-dns-upstream:dns/proxy Metrics-server is running at https://34.133.211.75/api/v1/namespaces/kube-system/services/https:metrics-server:/proxy To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.

3. No Cloud Shell, execute o seguinte comando para imprimir o contexto ativo:

kubectl config current-context

Uma linha de saída indica o cluster de contexto ativo.

Saída:

gke_{{{project_0.project_id|Project_ID}}}_{{{project_0.default_region|Region}}}_autopilot-cluster-1

O PROJECT_ID é o ID do projeto. Essa informação é a mesma da propriedade current-context do arquivo kubeconfig.

4. No Cloud Shell, execute o seguinte comando para imprimir alguns detalhes de todos os contextos de cluster no arquivo kubeconfig:

kubectl config get-contexts

A saída tem várias linhas que dão detalhes do cluster criado e indicam qual é o cluster de contexto ativo. Em geral, esse comando lista algumas informações dos clusters presentes no arquivo kubeconfig do usuário, incluindo os clusters que já foram criados por ele e os que foram adicionados manualmente ao arquivo kubeconfig.

5. No Cloud Shell, execute o seguinte comando para alterar o contexto ativo:

kubectl config use-context gke_${DEVSHELL_PROJECT_ID}_{{{project_0.default_region|Region}}}_autopilot-cluster-1

Nesse caso, havia somente um cluster, então o comando não alterou nada.

Mas pode ser que você tenha no futuro mais de um cluster em um projeto. Use essa abordagem para mudar o contexto ativo quando seu arquivo kubeconfig tiver as credenciais e a configuração de vários clusters já preenchidas. É preciso ter o nome completo do cluster, O que inclui o prefixo gke, o ID do projeto, o local e o nome de exibição, todos concatenados com sublinhados.

6. No Cloud Shell, execute o seguinte comando para ativar o preenchimento automático de bash no kubectl:

source <(kubectl completion bash)

Esse comando não produz saída.

7. No Cloud Shell, digite kubectl seguido por um espaço e pressione a tecla Tab duas vezes.

O shell exibe todos os comandos possíveis:

8. No Cloud Shell, digite kubectl co e pressione a tecla Tab duas vezes.

O shell exibe todos os comandos que começam com "co" (ou qualquer outra sequência de letras que você digitar).

Tarefa 4: implantar pods em clusters do GKE

Nesta tarefa, você vai usar o Cloud Shell para implantar pods em clusters do GKE.

Use kubectl para implantar pods no GKE

O Kubernetes usa a abstração de um pod para agrupar um ou mais contêineres relacionados como uma só entidade a ser programada e implantada como uma unidade no mesmo nó. Você pode implantar um pod que é um único contêiner de uma só imagem de contêiner. Ou um pod que tem muitos contêineres e muitas imagens de contêiner.

1. No Cloud Shell, execute o seguinte comando para implantar o nginx como um pod chamado nginx-1:

kubectl create deployment --image nginx nginx-1

Esse comando cria um pod chamado nginx com um contêiner que executa a imagem do nginx. Quando um repositório não é especificado, o comportamento padrão é tentar encontrar a imagem localmente ou no registro público do Docker. Neste exemplo, a imagem é extraída do registro público do Docker.

2. No Cloud Shell, execute o seguinte comando para visualizar todos os pods implantados no cluster de contexto ativo:

kubectl get pods

A saída será semelhante ao exemplo a seguir, mas com um nome de pod um pouco diferente.

Observação: se aparecer uma mensagem informando que o servidor não pode processar a solicitação no momento, aguarde a implantação terminar e ficar pronta.

Saída:

NAME READY STATUS RESTARTS AGE nginx-1-74c7bbdb84-nvwsc 1/1 Running 0 2m52s

3. No Cloud Shell, execute o seguinte comando para visualizar o uso de recursos nos nós do cluster:

kubectl top nodes

A saída será semelhante ao exemplo a seguir.

Saída:

NAME CPU(cores) CPU% MEMORY(bytes) MEMORY% gk3-autopilot-cluster-1-pool-2-7246ae0e-4q7s 1971m 102% 1803Mi 30%

Outro comando top (kubectl top pods) mostra informações semelhantes em todos os pods implantados no cluster.

4. Agora, digite o nome do pod em uma variável que será usada durante este laboratório. O uso de variáveis como esta pode evitar erros humanos ao escrever nomes longos. Digite o nome exclusivo do seu pod no lugar de [your_pod_name]:

export my_nginx_pod=[your_pod_name]

Exemplo:

export my_nginx_pod=nginx-1-74c7bbdb84-nvwsc

5. Para confirmar se a variável de ambiente foi definida corretamente, faça o shell retornar o valor:

echo $my_nginx_pod

Saída:

nginx-1-74c7bbdb84-nvwsc

6. No Cloud Shell, execute o seguinte comando para conferir todos os detalhes do pod que você acabou de criar:

kubectl describe pod $my_nginx_pod

A saída será semelhante ao exemplo a seguir. Os detalhes do pod, assim como o status, as condições e os eventos do ciclo de vida dele, serão exibidos.

Saída:

Image: nginx Image: nginx Image: nginx Image ID: docker.io/library/nginx@sha256:480868e8c8c797794257e2abd88d0f9a8809b2fe956cbfbc05dcc0bca1f7cd43 Port: Host Port: State: Running Started: Wed, 17 May 2023 10:47:04 +0000 Ready: True Restart Count: 0 Limits: cpu: 500m ephemeral-storage: 1Gi memory: 2Gi Requests: cpu: 500m ephemeral-storage: 1Gi memory: 2Gi Environment: Mounts: /var/run/secrets/kubernetes.io/serviceaccount from kube-api-access-ksxxr (ro) Conditions: Type Status Initialized True Ready True ContainersReady True PodScheduled True Volumes: kube-api-access-ksxxr: Type: Projected (a volume that contains injected data from multiple sources) TokenExpirationSeconds: 3607 ConfigMapName: kube-root-ca.crt ConfigMapOptional: DownwardAPI: true QoS Class: Guaranteed Node-Selectors: Tolerations: kubernetes.io/arch=amd64:NoSchedule node.kubernetes.io/not-ready:NoExecute op=Exists for 300s node.kubernetes.io/unreachable:NoExecute op=Exists for 300s Events: Type Reason Age From Message ---- ------ ---- ---- ------- Warning FailedScheduling 5m42s gke.io/optimize-utilization-scheduler 0/2 nodes are available: 2 Insufficient cpu, 2 Insufficient memory. preemption: 0/2 nodes are available: 2 No preemption victims found for incoming pod. Normal Scheduled 4m15s gke.io/optimize-utilization-scheduler Successfully assigned default/nginx-1-6b7bff9fc7-t7fzk to gk3-autopilot-cluster-1-pool-1-242a3a6a-j9rh Normal TriggeredScaleUp 5m34s cluster-autoscaler pod triggered scale-up: [{https://www.googleapis.com/compute/v1/projects/qwiklabs-gcp-02-92c260add90a/zones/{{{project_0.default_zone|Zone}}}/instanceGroups/gk3-autopilot-cluster-1-pool-1-242a3a6a-grp 0->1 (max: 1000)}] Normal Pulling 3m30s kubelet Pulling image "nginx" Normal Pulled 3m16s kubelet Successfully pulled image "nginx" in 13.843394735s (13.843643782s including waiting) Normal Created 3m16s kubelet Created container nginx Normal Started 3m15s kubelet Started container nginx

Enviar um arquivo para um contêiner

Para exibir conteúdo estático pelo servidor da Web nginx, é preciso criar e colocar um arquivo no contêiner.

1. No Cloud Shell, digite os seguintes comandos para abrir um arquivo chamado test.html no editor de texto nano:

nano ~/test.html

2. Adicione o texto abaixo (script de shell) ao arquivo test.html vazio:

Este é o título Hello World

3. Pressione CTRL+X, depois Y e Enter para salvar o arquivo e sair do editor nano.

4. No Cloud Shell, execute o seguinte comando para colocar o arquivo no local adequado do contêiner nginx no pod nginx que vai ser exibido estaticamente:

kubectl cp ~/test.html $my_nginx_pod:/usr/share/nginx/html/test.html

Esse comando copia o arquivo test.html do diretório principal local para o /usr/share/nginx/html do primeiro contêiner no pod nginx. Quando o pod tem vários contêineres, é possível especificar outros usando a opção -c seguida do nome do contêiner.

Exponha o pod para teste

Um serviço é obrigatório para expor um pod para clientes fora do cluster. Esses serviços são abordados ao longo do curso e usados em outros laboratórios. Use um comando simples e crie um serviço para expor um pod.

1. No Cloud Shell, execute o seguinte comando para criar um serviço e expor o pod nginx externamente:

kubectl expose pod $my_nginx_pod --port 80 --type LoadBalancer

Esse comando cria um serviço LoadBalancer, que permite o acesso ao pod nginx de endereços da Internet fora do cluster.

2. No Cloud Shell, execute o seguinte comando para exibir detalhes sobre os serviços no cluster:

kubectl get services

A saída será semelhante ao exemplo a seguir. Você vai usar o endereço IP externo na próxima etapa.

Observação: talvez você precise repetir o comando algumas vezes até que o IP externo do novo serviço seja preenchido.

Saída:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.11.240.1 443/TCP 1h nginx-1-7...wsc LoadBalancer 10.11.240.87 80:31695/TCP 3s

O serviço Kubernetes é uma das opções padrão criadas ou usadas pelo cluster. O serviço nginx que você criou também aparece na resposta.

Talvez o comando precise ser executado várias vezes até que o endereço IP externo seja exibido.

Saída:

NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE kubernetes ClusterIP 10.11.240.1 443/TCP 1h nginx-1-7...wsc LoadBalancer 10.11.240.87 104.154.177.46 80:31695/TCP 1m

Clique em Verificar meu progresso para conferir o objetivo. Implante pods em clusters do GKE

3. No Cloud Shell, execute o seguinte comando para verificar se o contêiner nginx está exibindo o arquivo HTML estático copiado.

Substitua [EXTERNAL_IP] pelo endereço IP externo do serviço obtido na saída da etapa anterior.

curl http://[EXTERNAL_IP]/test.html

A saída mostra o conteúdo do arquivo. Acesse o mesmo endereço no navegador para acessar o arquivo renderizado como HTML.

Exemplo:

curl http://104.154.177.46/test.html Este é o título Hello World

4. No Cloud Shell, execute o seguinte comando para conferir os recursos que estão sendo usados pelo pod nginx:

kubectl top pods

Saída:

NAME CPU(cores) MEMORY(bytes) nginx-1-74c7bbdb84-nvwsc 0m 2Mi

Tarefa 5: fazer a introspecção de pods do GKE

Nesta tarefa, você vai se conectar a um pod para ajustar configurações, editar arquivos e fazer outras alterações nele em tempo real.

Observação: só use este processo para resolver problemas ou fazer experimentos. Como as alterações não são feitas na imagem de origem do pod, elas não afetam as réplicas.

Prepare o ambiente

A maneira mais comum de implantar pods e outros recursos no Kubernetes é usar os arquivos de configuração, que às vezes são chamados de arquivos de manifesto. Eles costumam usar a sintaxe YAML e especificam os detalhes do recurso. Com esses arquivos, é mais fácil especificar opções complexas, em vez de usar uma longa string de argumentos de linha de comando.

A sintaxe YAML é semelhante, mas mais concisa do que a sintaxe JSON, e permite o mesmo tipo de estruturação hierárquica de objetos e propriedades. O repositório de origem do laboratório tem exemplos de arquivos YAML preparados para você.

1. No Cloud Shell, digite o seguinte comando para clonar o repositório no Cloud Shell do laboratório:

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

2. Crie um link flexível como atalho para o diretório de trabalho:

ln -s ~/training-data-analyst/courses/ak8s/v1.1 ~/ak8s

3. Mude para o diretório que contém os arquivos de exemplo deste laboratório:

cd ~/ak8s/GKE_Shell/

Você vai receber uma amostra de arquivo de manifesto YAML referente a um pod chamado new-nginx-pod.yaml:

apiVersion: v1 kind: Pod metadata: name: new-nginx labels: name: new-nginx spec: containers: - name: new-nginx image: nginx ports: - containerPort: 80

4. Para implantar o manifesto, execute o comando abaixo:

kubectl apply -f ./new-nginx-pod.yaml

Selecione Conferir meu progresso para consultar o objetivo. Implantar um novo pod usando um arquivo Yaml

5. Para acessar uma lista de pods, execute este comando:

kubectl get pods

A saída será semelhante ao exemplo.

Saída:

NAME READY STATUS RESTARTS AGE new-nginx 1/1 Running 0 9s nginx-1-74c7bbdb84-nvwsc 1/1 Running 0 55m

Você verá o novo pod nginx, além daquele criado anteriormente no laboratório.

Use o redirecionamento de shell para se conectar a um pod

Algumas imagens de contêiner incluem um ambiente shell que pode ser iniciado. Talvez ele seja uma opção mais prática do que executar comandos individuais com o kubectl. Por exemplo, a imagem nginx inclui um shell bash. Nesta tarefa, você vai usar o redirecionamento de shell para se conectar ao shell bash no novo pod nginx e realizar uma sequência de ações.

1. No Cloud Shell, execute o seguinte comando para iniciar um shell bash interativo no contêiner nginx:

kubectl exec -it new-nginx -- /bin/bash

Um novo prompt de shell será exibido.

Saída:

root@new-nginx:/#

Você iniciou um shell bash interativo no contêiner do pod new-nginx. Se esse pod tivesse vários contêineres, seria possível especificar um deles pelo nome com a opção -c.

Como a imagem do contêiner nginx não tem ferramentas de edição de texto por padrão, é necessário instalar uma.

2. No Cloud Shell, localize o shell bash do nginx e execute os seguintes comandos para instalar o editor de texto nano:

apt-get update apt-get install nano

Quando a pergunta Do you want to continue (Y/n) aparecer, pressione Y para confirmar.

É preciso criar um arquivo test.html no diretório estático exibido no contêiner nginx.

3. No Cloud Shell, vá até o shell bash do nginx e execute os seguintes comandos para acessar o diretório de arquivos estáticos e criar um arquivo test.html:

cd /usr/share/nginx/html nano test.html

4. No Cloud Shell, encontre a sessão nano do shell bash nginx e digite o seguinte:

Este é o título Hello World

5. Pressione CTRL+X, depois Y e Enter para salvar o arquivo e sair do editor nano.
6. No shell bash do nginx, execute o seguinte comando para sair dele no Cloud Shell:

exit

É possível criar um serviço para estabelecer uma conexão e testar o contêiner nginx modificado com o novo arquivo HTML estático. Uma opção mais fácil é usar o encaminhamento de portas para se conectar ao pod diretamente no Cloud Shell.

7. No Cloud Shell, execute o seguinte comando para configurar o encaminhamento de portas do Cloud Shell ao pod nginx (da porta 10081 da VM do Cloud Shell para a 80 do contêiner nginx):

kubectl port-forward new-nginx 10081:80

A saída será semelhante ao exemplo.

Saída:

Forwarding from 127.0.0.1:10081 -> 80 Forwarding from [::1]:10081 -> 80

Esse é um processo em primeiro plano, então é preciso abrir outra instância do Cloud Shell para fazer testes.

8. Na barra de menus do Cloud Shell, clique no sinal de mais (+) para iniciar uma nova sessão.

Uma segunda sessão do Cloud Shell vai aparecer na janela. Para alternar entre as sessões, clique nos títulos na barra de menu.

9. Na segunda sessão do Cloud Shell, execute o seguinte comando para testar o contêiner nginx modificado pelo encaminhamento de portas:

curl http://127.0.0.1:10081/test.html

Você verá o texto HTML que colocou no arquivo test.html.

Este é o título Hello World

Acessar os registros de um pod

1. Na barra de menu do Cloud Shell, clique no sinal de mais (+) para iniciar outra sessão.

Agora a janela tem três sessões abertas. Como antes, clique nas sessões na barra de menus para alternar entre elas.

2. Na terceira janela do Cloud Shell, execute o comando abaixo para exibir os registros do pod new-nginx e transmitir as novas entradas (incluindo carimbos de data/hora) à medida que elas chegam:

kubectl logs new-nginx -f --timestamps

3. Os registros vão aparecer nessa nova janela.
4. Volte à segunda sessão do Cloud Shell e execute o comando curl de novo para gerar tráfego no pod.
5. Confira as novas mensagens de registro que vão aparecer na terceira sessão do Cloud Shell.

6. Feche essa última sessão para interromper a exibição das mensagens de registro.
7. Feche a sessão original do Cloud Shell para encerrar o processo de encaminhamento de portas.

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.