Introdução
O laboratório anterior focou em logs e eventos. Esses são os primeiros sinais, mas às vezes você também precisa inspecionar um container em execução ou acessar temporariamente um Service a partir do seu terminal. O Kubernetes fornece duas ferramentas comuns para isso: kubectl exec e kubectl port-forward.
Neste laboratório, você implantará uma pequena aplicação web, usará o kubectl exec para inspecionar arquivos e processos dentro de um Pod, e usará o kubectl port-forward para abrir uma conexão local temporária com o Service. O fluxo de trabalho é intencionalmente simples para que você possa focar nas técnicas de depuração em vez da complexidade da aplicação.
Preparar um Namespace de Depuração
Nesta etapa, você preparará um namespace limpo para praticar o exec e o port-forward.
Comece em /home/labex/project. Você manterá o manifesto da aplicação neste diretório.
mkdir -p /home/labex/project
cd /home/labex/project
Verifique se o servidor da API do Kubernetes está acessível. Se a VM acabou de iniciar e o nó ainda não está pronto, aguarde alguns segundos e execute o comando novamente.
kubectl get nodes --request-timeout=5s
A saída esperada inclui:
NAME STATUS ROLES AGE VERSION
labex-v135 Ready control-plane ... v1.35...
Aguarde até que o Pod de rede do cluster esteja pronto (Ready). O port-forwarding usa a conexão com o servidor da API, mas a aplicação ainda precisa de um Pod e um Service saudáveis.
kubectl wait --namespace kube-system --for=condition=Ready pod -l k8s-app=calico-node --timeout=120s
Saída esperada:
pod/calico-node-... condition met
Crie um namespace chamado ckad-prep-debug e defina-o como o namespace atual:
kubectl create namespace ckad-prep-debug
kubectl config set-context --current --namespace=ckad-prep-debug
Confirme o namespace atual:
kubectl config view --minify --output 'jsonpath={..namespace}'; echo
Saída esperada:
ckad-prep-debug
Implantar uma Pequena Aplicação Web
Nesta etapa, você implantará uma aplicação simples para inspecionar e acessar.
O Pod escreve um arquivo index.html e executa o httpd do BusyBox na porta 8080. Um Service chamado debug-web expõe os Pods dentro do cluster na porta 80. O Service foi incluído porque o kubectl port-forward pode direcionar tanto um Service quanto um Pod.
Crie o arquivo debug-web.yaml:
cat > debug-web.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: debug-web
spec:
replicas: 2
selector:
matchLabels:
app: debug-web
template:
metadata:
labels:
app: debug-web
spec:
terminationGracePeriodSeconds: 0
containers:
- name: web
image: busybox:1.36
command:
- /bin/sh
- -c
- |
mkdir -p /www
echo "debug-web-ready" > /www/index.html
httpd -f -p 8080 -h /www
ports:
- containerPort: 8080
readinessProbe:
httpGet:
path: /
port: 8080
initialDelaySeconds: 1
periodSeconds: 2
---
apiVersion: v1
kind: Service
metadata:
name: debug-web
spec:
selector:
app: debug-web
ports:
- port: 80
targetPort: 8080
EOF
Aplique o manifesto e aguarde o Deployment:
kubectl apply -f debug-web.yaml
kubectl rollout status deployment/debug-web --timeout=120s
A saída esperada inclui:
deployment.apps/debug-web created
service/debug-web created
deployment "debug-web" successfully rolled out
Inspecione os Pods e o Service:
kubectl get pods -l app=debug-web
kubectl get service debug-web
A saída esperada inclui dois Pods em execução (Running) e um Service do tipo ClusterIP:
debug-web-... 1/1 Running
debug-web ClusterIP
Inspecionar um Container em Execução com exec
Nesta etapa, você usará o kubectl exec para executar comandos dentro de um Pod da aplicação.
O kubectl exec é útil quando o Pod está em execução, mas você precisa inspecionar o que o container enxerga. Ele não substitui os logs e não deve ser usado para fazer correções manuais ocultas durante uma implantação normal. Em um fluxo de trabalho de depuração, ele ajuda a confirmar arquivos, processos, ambiente e comportamento da rede local a partir de dentro do container.
Armazene o nome de um Pod em uma variável de shell:
POD_NAME="$(kubectl get pods -l app=debug-web -o jsonpath='{.items[0].metadata.name}')"
echo "$POD_NAME"
A saída esperada é o nome de um Pod:
debug-web-...
Execute hostname dentro do container. A saída deve corresponder ao nome do Pod, pois o Kubernetes define o hostname do container a partir do nome do Pod.
kubectl exec "$POD_NAME" -- hostname
Saída esperada:
debug-web-...
Liste os processos em execução dentro do container:
kubectl exec "$POD_NAME" -- ps
A saída esperada inclui o processo httpd:
PID USER TIME COMMAND
... root ... httpd -f -p 8080 -h /www
Leia o arquivo servido pelo servidor web:
kubectl exec "$POD_NAME" -- cat /www/index.html
Saída esperada:
debug-web-ready
Por fim, teste o servidor web a partir de dentro do mesmo container:
kubectl exec "$POD_NAME" -- wget -qO- http://127.0.0.1:8080
Saída esperada:
debug-web-ready
Testar o Service com Port Forwarding
Nesta etapa, você usará o kubectl port-forward para acessar o Service a partir do seu terminal.
O port-forwarding cria um túnel temporário de uma porta local para um Pod ou Service no cluster. É útil para depuração rápida porque não requer a alteração do tipo de Service, a criação de um Ingress ou a abertura de acesso externo. Um comando kubectl port-forward em primeiro plano continua sendo executado até que você o interrompa; por isso, este laboratório o inicia em segundo plano, testa-o e, em seguida, encerra o processo.
Inicie um port-forward da porta local 18080 para a porta 80 do Service. A saída é gravada em /tmp/debug-web-port-forward.log para que o terminal permaneça utilizável.
kubectl port-forward service/debug-web 18080:80 > /tmp/debug-web-port-forward.log 2>&1 &
PF_PID=$!
sleep 3
cat /tmp/debug-web-port-forward.log
A saída esperada inclui:
Forwarding from 127.0.0.1:18080 -> 8080
Envie uma requisição através da porta local encaminhada:
wget -qO- http://127.0.0.1:18080
Saída esperada:
debug-web-ready
Interrompa o processo de port-forward em segundo plano. Essa limpeza é importante, caso contrário, a porta local permaneceria em uso.
kill "$PF_PID"
wait "$PF_PID" 2>/dev/null || true
Confirme se o log do port-forward registrou uma conexão tratada:
cat /tmp/debug-web-port-forward.log
A saída esperada inclui:
Handling connection for 18080
Resumo
Você praticou duas ferramentas práticas de depuração. Você usou o kubectl exec para inspecionar o hostname, processos, arquivos e a resposta HTTP local de um container em execução. Você também usou o kubectl port-forward para criar uma conexão local temporária com um Service do tipo ClusterIP, testou-a a partir do terminal e encerrou o processo de encaminhamento em segundo plano de forma limpa.
