Entendendo Pods

Introdução

Neste laboratório, você explorará a menor unidade implantável do Kubernetes: o Pod.

Um Pod é o objeto que o Kubernetes agenda em um nó. Normalmente, você não executa um contêiner diretamente no Kubernetes; em vez disso, os contêineres são colocados dentro de Pods.

Um Pod pode conter um ou mais contêineres que compartilham o contexto de rede e armazenamento. A maioria dos exemplos para iniciantes usa um único contêiner, mas o conceito importante é o design baseado em um ambiente compartilhado.

Você aprenderá a:

• Definir um Pod usando um arquivo de configuração YAML (o modelo).
• Criar o Pod no cluster usando kubectl.
• Verificar o status do Pod para confirmar que ele está em execução.
• Inspecionar a configuração detalhada e o histórico do Pod.

Ao final deste laboratório, você terá um servidor web real em execução dentro de um Pod no seu cluster.

Defina o Pod

Nesta etapa, você definirá seu primeiro Pod. O Kubernetes usa YAML. Um arquivo YAML funciona como um modelo ou uma receita que descreve exatamente como você quer que sua aplicação seja configurada.

Um Pod é o menor objeto agendado pelo Kubernetes, mas não é a mesma coisa que um contêiner. Um contêiner é o processo da aplicação em execução e a imagem do sistema de arquivos usada por ele. Um Pod é o invólucro do Kubernetes em torno de um ou mais contêineres. Esse invólucro fornece a eles uma identidade de rede compartilhada, um ciclo de vida compartilhado e, opcionalmente, armazenamento compartilhado.

A definição de um Pod exige quatro elementos principais:

• apiVersion: A versão da linguagem do Kubernetes que estamos usando.
• kind: O tipo de objeto que estamos criando (neste caso, um Pod).
• metadata: Informações que identificam o objeto, como nome e labels.
• spec: A “especificação” — o conteúdo principal da receita. Ela descreve os contêineres que serão executados.

Você criará um arquivo chamado nginx-pod.yaml. Esse arquivo definirá um Pod chamado nginx-pod que executa um único contêiner usando a imagem nginx (um servidor web popular).

Crie o arquivo usando o editor de texto nano:

nano nginx-pod.yaml

Copie e cole o conteúdo a seguir no arquivo. Leia com atenção para identificar as quatro seções que discutimos:

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

Para salvar e sair do nano padrão, pressione Ctrl+X, depois digite Y para confirmar o salvamento e pressione Enter para gravar o arquivo com esse nome.

Agora você escreveu seu primeiro modelo do Kubernetes! Ele informa ao Kubernetes: “Quero um Pod chamado nginx-pod. Dentro dele, execute um contêiner usando a imagem nginx.”

Crie o Pod

Agora que você tem seu modelo (nginx-pod.yaml), é hora de entregá-lo à equipe de construção: o Kubernetes.

Usamos o comando kubectl apply para fazer isso. Esse comando informa ao Kubernetes: “Este é o estado desejado. Faça com que ele aconteça.”

A expressão estado desejado é uma das ideias centrais do Kubernetes. Você não informa ao sistema cada etapa de baixo nível que deve ser executada. Em vez disso, declara o resultado final que deseja, e os controladores do Kubernetes continuam trabalhando até que a realidade corresponda a essa declaração.

Execute o comando a seguir para criar seu Pod:

kubectl apply -f nginx-pod.yaml

Você deverá ver uma mensagem de confirmação:

pod/nginx-pod created

Ao executar esse comando, você enviou o modelo ao servidor da API do Kubernetes (o Control Plane). Em seguida, o Scheduler encontrou um Node adequado para o seu Pod, e o Kubelet nesse Node começou a baixar a imagem do Nginx para executá-la.

Verifique o status

Nesta etapa, você verificará o andamento do seu novo Pod. A criação de um Pod não é instantânea; leva algum tempo para baixar a imagem do contêiner e iniciar a aplicação.

Este é um ponto importante: kubectl apply geralmente retorna rapidamente porque apenas envia a solicitação. O trabalho real acontece de forma assíncrona dentro do cluster. Por isso, verificar o status é uma etapa normal depois da criação, e não um sinal de que algo está errado.

Para ver o status dos seus Pods, use o comando get:

kubectl get pods

Você verá uma tabela listando seus Pods. Observe a coluna STATUS:

NAME        READY   STATUS    RESTARTS   AGE
nginx-pod   1/1     Running   0          15s

• STATUS: Este é o campo mais importante.

  • ContainerCreating: O sistema ainda está baixando a imagem ou iniciando o contêiner.
  • Running: Sucesso! O Pod está ativo e saudável.
  • Pending: O cluster está tentando determinar onde colocar o Pod.
  • Error ou CrashLoopBackOff: Algo deu errado (por exemplo, a aplicação falhou).

• READY: Exibe 1/1, o que significa que 1 dos 1 contêineres definidos no Pod está pronto para receber tráfego.

Se você vir ContainerCreating, aguarde alguns segundos e execute kubectl get pods novamente. Quando o status for Running, seu servidor web Nginx estará ativo.

Inspecione os detalhes

Nesta etapa, você aprenderá a “olhar por dentro”. O comando get forneceu um resumo, mas às vezes é necessário saber exatamente o que está acontecendo, especialmente quando algo dá errado.

O comando describe fornece um relatório detalhado sobre o recurso do Kubernetes.

Para iniciantes, é útil pensar em kubectl get e kubectl describe como dois níveis diferentes de observação. get responde “Qual é o status geral atual?”, enquanto describe responde “O que aconteceu para chegarmos a esse estado?”. Esse histórico de eventos costuma ser o caminho mais rápido para encontrar a causa raiz.

Execute o comando a seguir para inspecionar nginx-pod:

kubectl describe pod nginx-pod

Esse comando exibe muitas informações. Role até o final e procure a seção Events. Ela apresenta, em ordem cronológica, o que aconteceu durante a inicialização do seu Pod:

Events:
  Type    Reason     Age   From               Message
  ----    ------     ----  ----               -------
  Normal  Scheduled  ...   default-scheduler  Successfully assigned default/nginx-pod...
  Normal  Pulling    ...   kubelet            Pulling image "nginx:latest"
  Normal  Pulled     ...   kubelet            Successfully pulled image "nginx:latest"...
  Normal  Created    ...   kubelet            Created container nginx
  Normal  Started    ...   kubelet            Started container nginx

Esse registro de eventos é o primeiro lugar que você deve consultar ao depurar um problema. Se um Pod ficar preso em Pending ou Error, a seção Events normalmente explicará o motivo (por exemplo, “Insuficient CPU” ou “ImagePullBackOff”).

Agora você criou, verificou e inspecionou seu primeiro Pod do Kubernetes!

Resumo

Neste laboratório, você dominou o conceito de Pod, o bloco de construção fundamental do Kubernetes.

Você conseguiu:

1. Escrever um modelo YAML para um Pod do Nginx.
2. Implantá-lo no cluster usando kubectl apply.
3. Confirmar que ele estava Running usando kubectl get.
4. Consultar em detalhes seu histórico de inicialização usando kubectl describe.

Entender Pods é essencial porque todos os outros conceitos do Kubernetes — Deployments, Services e StatefulSets — estão, em última análise, relacionados ao gerenciamento desses Pods. Agora você está pronto para estudar tópicos mais avançados!