Port-forwarding e debugging de pods em produção

1. Introdução ao Port-Forwarding no Kubernetes

O comando kubectl port-forward é uma das ferramentas mais úteis para desenvolvedores e operadores que precisam acessar serviços internos do cluster sem expô-los publicamente. Ele cria um túnel TCP entre a máquina local e um pod específico no Kubernetes, permitindo que você se conecte a portas internas como se estivessem rodando localmente.

O funcionamento é simples: o kubectl estabelece uma conexão com o servidor da API do Kubernetes, que então cria um proxy para o pod alvo. Todo o tráfego enviado para a porta local é encapsulado e redirecionado para a porta correspondente no pod.

Casos de uso típicos incluem:
- Acesso a bancos de dados internos (PostgreSQL, MySQL, MongoDB)
- Visualização de dashboards como o do Prometheus ou Grafana
- Teste de APIs internas que não possuem exposição externa
- Debugging de aplicações que só aceitam conexões de dentro do cluster

Limitações importantes:
- Funciona apenas com TCP, sem suporte a UDP
- Redireciona para um único pod, sem balanceamento de carga
- A conexão é interrompida se o pod for reiniciado ou movido

# Exemplo básico de port-forward
kubectl port-forward pod/meu-pod 8080:80
# Agora acesse http://localhost:8080

2. Técnicas Avançadas de Port-Forwarding

Para cenários mais complexos, existem técnicas que ampliam as capacidades básicas do port-forwarding.

Redirecionamento de múltiplas portas simultaneamente:

# Forward de duas portas ao mesmo tempo
kubectl port-forward pod/meu-pod 8080:80 5432:5432

Port-forwarding para serviços (ClusterIP) em vez de pods específicos:

# Forward para um serviço (distribui entre os pods do serviço)
kubectl port-forward service/meu-servico 8080:80

Ferramentas como kubefwd e telepresence automatizam o processo, permitindo forward de múltiplos serviços simultaneamente com resolução de nomes DNS local.

# Usando kubefwd para forward de todos os serviços de um namespace
sudo kubefwd svc -n producao

3. Debugging de Pods em Produção: Ferramentas e Comandos Essenciais

O debugging em produção requer ferramentas que minimizem o impacto no ambiente. O Kubernetes oferece vários comandos nativos para essa finalidade.

Inspeção interativa com kubectl exec:

# Acessar shell interativo no container
kubectl exec -it pod/meu-pod -- /bin/sh

# Verificar variáveis de ambiente
kubectl exec pod/meu-pod -- env

# Listar processos em execução
kubectl exec pod/meu-pod -- ps aux

Comandos de diagnóstico essenciais:

# Logs em tempo real
kubectl logs -f pod/meu-pod

# Logs das últimas 100 linhas
kubectl logs --tail=100 pod/meu-pod

# Descrever detalhes do pod (eventos, condições, volumes)
kubectl describe pod/meu-pod

# Métricas de CPU e memória
kubectl top pod meu-pod

Para análise de rede, crie pods temporários com ferramentas de debug:

# Pod temporário com ferramentas de rede
kubectl run debug-pod --image=nicolaka/netshoot -it --rm -- /bin/bash

# Dentro do pod, testar conectividade
curl http://meu-servico:8080/health
nslookup meu-servico
ping 10.100.0.1

4. Ephemeral Containers para Debugging Seguro

Contêineres efêmeros (ephemeral containers) são uma feature avançada do Kubernetes que permite adicionar um container temporário a um pod em execução, sem modificar sua especificação original. Isso é especialmente útil para debugging em produção, pois não requer reinicialização do pod.

# Adicionar um container efêmero de debug
kubectl debug pod/meu-pod -it --image=nicolaka/netshoot --target=meu-container

O parâmetro --target especifica qual container do pod será o alvo do debug. O container efêmero compartilha o mesmo network namespace, permitindo diagnóstico de conectividade.

Exemplo prático: depuração de problemas de DNS

# Dentro do container efêmero
cat /etc/resolv.conf
nslookup meu-servico.default.svc.cluster.local
dig +short meu-servico

5. Acesso a Bancos de Dados e Serviços Internos

O acesso a bancos de dados em produção através de port-forwarding é uma prática comum, mas requer cuidados especiais.

# Forward para PostgreSQL em produção
kubectl port-forward pod/postgres-0 5432:5432 -n banco-dados

# Conectar com cliente local
psql -h localhost -p 5432 -U admin -d meubanco

Para MySQL:

kubectl port-forward pod/mysql-0 3306:3306 -n banco-dados
mysql -h 127.0.0.1 -P 3306 -u root -p

Cuidados de segurança:
- Nunca exponha port-forward para interfaces de rede públicas (kubectl port-forward --address 0.0.0.0)
- Use namespaces dedicados para bancos de dados
- Configure RBAC para limitar quem pode executar port-forward

# Forward seguro apenas para localhost
kubectl port-forward --address 127.0.0.1 pod/postgres-0 5432:5432

6. Monitoramento e Diagnóstico de Performance

Para análise de tráfego de rede, combine port-forward com ferramentas como Wireshark ou tcpdump.

# Capturar tráfego com tcpdump via exec
kubectl exec pod/meu-pod -- tcpdump -i eth0 -w /tmp/captura.pcap

# Copiar arquivo para máquina local
kubectl cp pod/meu-pod:/tmp/captura.pcap ./captura.pcap

Análise de logs com ferramentas avançadas:

# stern para logs de múltiplos pods simultaneamente
stern "meu-app-*" --tail 50

# kubectl logs com follow e timestamps
kubectl logs --timestamps --tail=200 pod/meu-pod

Monitoramento de performance:

# Verificar uso de recursos
kubectl top pod meu-pod --containers

# Verificar eventos recentes
kubectl get events --sort-by='.lastTimestamp'

7. Boas Práticas e Segurança em Produção

Para operações seguras em produção, siga estas práticas:

Namespaces dedicados para debugging temporário:

# Criar namespace temporário
kubectl create namespace debug-temp

# Usar pods de debug isolados
kubectl run debug-pod -n debug-temp --image=nicolaka/netshoot -it --rm

Políticas de rede para limitar acesso:

# NetworkPolicy que permite apenas debugging autorizado
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-debug
spec:
  podSelector:
    matchLabels:
      app: meuservico
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: debug-temp

Alternativas seguras ao port-forward tradicional:
- Telepresence: substitui pods por proxies locais com interceptação de tráfego
- ksniff: plugin do kubectl para captura de pacotes usando tcpdump
- OpenTelemetry: instrumentação para observabilidade sem acesso direto

8. Casos Reais e Troubleshooting Comum

Cenário 1: Pod preso em CrashLoopBackOff

# Verificar logs do último crash
kubectl logs --previous pod/meu-pod

# Adicionar container efêmero para inspecionar o filesystem
kubectl debug pod/meu-pod -it --image=busybox --copy-to=meu-pod-debug

# Verificar configurações e arquivos
cat /etc/config/app.conf
ls -la /app/

Cenário 2: Aplicação não responde

# Port-forward para testar conectividade
kubectl port-forward pod/meu-pod 8080:8080 &

# Testar com curl
curl -v http://localhost:8080/health

# Testar com grpcurl (para gRPC)
grpcurl -plaintext localhost:8080 list

Cenário 3: Problemas de configuração

# Inspecionar variáveis de ambiente
kubectl exec pod/meu-pod -- env | grep -E "DB_HOST|DB_PORT"

# Verificar secrets montados
kubectl exec pod/meu-pod -- cat /etc/secrets/db-password

# Comparar com a spec do deployment
kubectl get deployment meu-app -o yaml | grep -A5 env:

Referências