Introdução
Um Pod é o menor objeto de carga de trabalho que você normalmente cria no Kubernetes. Ele encapsula um ou mais containers, fornece a eles uma identidade de rede compartilhada e permite que o Kubernetes os agende em um nó.
Neste laboratório, você criará um único Pod com uma pequena imagem de container pré-carregada, aguardará o Kubernetes deixá-lo pronto e inspecionará o objeto sob vários ângulos. Você usará kubectl get, kubectl describe e kubectl get -o yaml para que os laboratórios futuros de escrita de manifestos sejam baseados no estado real do objeto, em vez de apenas memorizar YAML.
Preparar um Espaço de Trabalho para o Pod
Nesta etapa, você preparará um namespace dedicado para o seu primeiro Pod e tornará esse namespace o destino padrão para seus comandos.
Comece em /home/labex/project, o espaço de trabalho compartilhado usado durante toda a preparação para o CKAD.
mkdir -p /home/labex/project
cd /home/labex/project
O servidor da API do Kubernetes pode precisar de um breve momento para ficar acessível após a inicialização da VM. Execute este comando primeiro. Se ele informar que o servidor ainda não está pronto, aguarde alguns segundos e execute-o novamente até que o nó esteja Ready.
kubectl get nodes --request-timeout=5s
A saída esperada inclui um nó de plano de controle (control-plane) pronto:
NAME STATUS ROLES AGE VERSION
labex-v135 Ready control-plane ... v1.35...
Crie um namespace chamado ckad-prep-pod. Um namespace dá a este laboratório seu próprio escopo de objeto, para que o Pod que você criar não se misture com objetos de outros laboratórios.
kubectl create namespace ckad-prep-pod
O comando deve confirmar a criação do namespace:
namespace/ckad-prep-pod created
Defina o namespace do contexto atual como ckad-prep-pod. Após isso, comandos que dependem de namespace, como kubectl get pods, lerão deste namespace por padrão.
kubectl config set-context --current --namespace=ckad-prep-pod
A saída deve confirmar que o contexto atual foi modificado:
Context "labex-v135" modified.
Verifique se o namespace atual foi alterado:
kubectl config view --minify --output 'jsonpath={..namespace}'; echo
Saída esperada:
ckad-prep-pod
Criar o Pod
Nesta etapa, você criará um único Pod com kubectl run e aguardará até que ele esteja pronto.
O kubectl run pode criar um Pod básico diretamente da linha de comando. A opção --image escolhe a imagem do container, e --restart=Never mantém este Pod como um objeto independente, em vez de criar um controlador de nível superior.
Este laboratório usa registry.k8s.io/pause:3.10.1, uma imagem minúscula que já está presente no ambiente Kubernetes preparado. Ela permanece em execução sem precisar de configuração de aplicação, o que permite que você se concentre no ciclo de vida do Pod em vez de pulls de imagem ou comportamento da aplicação.
kubectl run sample-pod --image=registry.k8s.io/pause:3.10.1 --restart=Never
O comando deve informar que o Kubernetes aceitou o objeto Pod:
pod/sample-pod created
Criação não é o mesmo que prontidão (readiness). O Kubernetes ainda precisa agendar o Pod, iniciar o container e marcar o Pod como pronto. Use kubectl wait para aguardar a condição Ready do Pod.
kubectl wait --for=condition=Ready pod/sample-pod --timeout=60s
Saída esperada:
pod/sample-pod condition met
Agora, liste os Pods no namespace atual:
kubectl get pods
Você deve ver o sample-pod com 1/1 containers prontos e status Running:
NAME READY STATUS RESTARTS AGE
sample-pod 1/1 Running 0 ...
Inspecionar o Posicionamento e Eventos do Pod
Nesta etapa, você inspecionará onde o Pod está sendo executado e lerá o histórico de eventos que o Kubernetes registrou durante a inicialização.
A visualização comum kubectl get pods é compacta. Adicione -o wide para ver detalhes de agendamento, como o nome do nó e o endereço IP do Pod.
kubectl get pod sample-pod -o wide
A saída esperada inclui o nó e um IP interno do Pod:
NAME READY STATUS RESTARTS AGE IP NODE
sample-pod 1/1 Running 0 ... ... labex-v135
O kubectl describe fornece uma visualização legível do objeto. Ele inclui metadados, detalhes do container, condições e eventos recentes. Para iniciantes, a seção Events é especialmente útil porque mostra o que o Kubernetes fez após você criar o Pod.
kubectl describe pod sample-pod
Procure por linhas como estas na saída:
Name: sample-pod
Namespace: ckad-prep-pod
Status: Running
Containers:
sample-pod:
Image: registry.k8s.io/pause:3.10.1
Conditions:
Type Status
Ready True
Events:
Type Reason Age From Message
Normal Scheduled ... default-scheduler Successfully assigned ...
Normal Pulled ... kubelet Container image "registry.k8s.io/pause:3.10.1" already present ...
Normal Created ... kubelet Created container ...
Normal Started ... kubelet Started container ...
As idades exatas dos eventos e as mensagens podem variar, mas a ideia central é estável: o Kubernetes agenda o Pod, prepara a imagem, cria o container e o inicia.
Ler os Campos do Objeto Pod
Nesta etapa, você inspecionará campos selecionados do Pod em formato YAML e os conectará aos conceitos de objetos que você viu no laboratório anterior.
O kubectl get pode imprimir um objeto como YAML usando -o yaml. Esta é a representação real do objeto retornada pelo servidor da API, incluindo campos que o Kubernetes adicionou após a criação. O comando abaixo usa sed -n '1,80p' para mostrar apenas as primeiras 80 linhas, mantendo a saída legível.
kubectl get pod sample-pod -o yaml | sed -n '1,80p'
Na saída, procure pelos campos de nível superior e pela imagem do container:
apiVersion: v1
kind: Pod
metadata:
name: sample-pod
namespace: ckad-prep-pod
spec:
containers:
- image: registry.k8s.io/pause:3.10.1
name: sample-pod
...
status:
...
Você não precisa memorizar todos os campos gerados. Por enquanto, concentre-se na estrutura básica: apiVersion, kind, metadata, spec e status. Você escreverá as partes importantes por conta própria no próximo laboratório.
Use uma consulta JSONPath direcionada para imprimir apenas o campo da imagem. Expressões JSONPath são úteis quando você precisa de um valor preciso de um objeto grande.
kubectl get pod sample-pod -o jsonpath='{.spec.containers[0].image}'; echo
Saída esperada:
registry.k8s.io/pause:3.10.1
Resumo
Você criou um Pod independente, aguardou o Kubernetes marcá-lo como pronto, inspecionou detalhes de agendamento e eventos, e leu campos-chave do objeto a partir da saída YAML e JSONPath. Isso lhe dá um Pod concreto para conectar com o próximo laboratório, onde você escreverá um manifesto de Pod em vez de criar o objeto diretamente com kubectl run.
