Redes no Linux: ip, netstat, ss e tcpdump

1. Fundamentos de Redes para DevOps

1.1. Modelo OSI e camadas relevantes para containers e clusters

Em ambientes de containers e Kubernetes, as camadas 3 (Rede), 4 (Transporte) e 7 (Aplicação) do modelo OSI são as mais críticas. A camada de Rede lida com endereçamento IP e roteamento entre Pods; a camada de Transporte gerencia conexões TCP/UDP e portas; a camada de Aplicação abrange protocolos como HTTP, DNS e gRPC. Compreender essas camadas é essencial para diagnosticar problemas de conectividade em clusters.

1.2. Interfaces de rede no Linux: loopback, bridge, VLANs

No Linux, as interfaces de rede fundamentais incluem:

  • loopback (lo): interface virtual para comunicação local (127.0.0.1)
  • bridge (docker0, cni0): bridge virtual que conecta containers entre si e ao host
  • veth pairs: pares de interfaces virtuais que conectam namespaces de rede
  • VLANs: segmentação lógica de redes físicas

No Docker, a bridge docker0 é criada automaticamente. No Kubernetes, plugins CNI como Calico ou Flannel gerenciam bridges e roteamento entre Pods.

1.3. Namespaces de rede no Linux

Namespaces de rede isolam interfaces, tabelas de roteamento e regras de firewall. Cada container Docker possui seu próprio namespace de rede. No Kubernetes, cada Pod também tem um namespace de rede compartilhado entre seus containers. Esse isolamento permite que múltiplos containers usem as mesmas portas sem conflito.

Para verificar namespaces ativos:

ls /var/run/netns
ip netns list

2. Comando ip: Gerenciamento de Interfaces e Roteamento

2.1. ip addr: visualizando e configurando endereços IP

O comando ip addr substitui o antigo ifconfig. Em um host Docker:

ip addr show docker0

Dentro de um container:

docker exec meu-container ip addr show eth0

Para adicionar um IP a uma interface:

ip addr add 10.0.0.5/24 dev eth0

Visualizando bridges e interfaces virtuais:

ip link show type bridge
ip link show type veth

Criando um par veth para conectar namespaces:

ip link add veth0 type veth peer name veth1
ip link set veth0 netns container1
ip link set veth1 netns container2

2.3. ip route: tabela de roteamento entre Pods

Verificando a tabela de roteamento:

ip route show

Em um cluster Kubernetes, cada nó possui rotas para os Pods de outros nós:

# Rota para Pods em outro nó
10.244.2.0/24 via 192.168.1.101 dev eth0

Para testar conectividade entre Pods:

kubectl exec pod-a -- ip route get 10.244.2.5

3. Comando netstat: Monitoramento de Conexões e Portas

3.1. netstat -tulpn: listando portas abertas

Listando todas as portas TCP/UDP em escuta:

netstat -tulpn

Exemplo de saída:

Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address           Foreign Address         State       PID/Program name
tcp        0      0 0.0.0.0:80              0.0.0.0:*               LISTEN      1234/nginx
tcp        0      0 127.0.0.1:5432          0.0.0.0:*               LISTEN      5678/postgres

Para verificar portas dentro de um container:

docker exec container-web netstat -tulpn

3.2. netstat -i: estatísticas de interfaces

Exibe estatísticas de tráfego por interface:

netstat -i

Saída exemplo:

Kernel Interface table
Iface      MTU    RX-OK RX-ERR RX-DRP RX-OVR    TX-OK TX-ERR TX-DRP TX-OVR Flg
eth0      1500  123456      0      0      0    98765      0      0      0 BMRU
docker0   1500   54321      0      0      0    43210      0      0      0 BMRU

3.3. Diferenças entre netstat legado e alternativas modernas

O netstat faz parte do pacote net-tools, considerado legado. Em muitas distribuições modernas, ele não vem instalado por padrão. As alternativas modernas incluem:

  • ss: mais rápido e com mais opções de filtro
  • ip: substitui ifconfig, route e arp

Para instalar netstat se necessário:

apt-get install net-tools   # Debian/Ubuntu
yum install net-tools       # CentOS/RHEL

4. Comando ss: Análise Rápida de Sockets

4.1. ss -tulpn: substituição eficiente do netstat

O ss é significativamente mais rápido que o netstat para listar sockets:

ss -tulpn

Exemplo de saída:

Netid  State   Recv-Q  Send-Q  Local Address:Port   Peer Address:Port   Process
tcp    LISTEN  0       128     0.0.0.0:80           0.0.0.0:*           users:(("nginx",pid=1234,fd=6))
tcp    LISTEN  0       128     127.0.0.1:5432       0.0.0.0:*           users:(("postgres",pid=5678,fd=8))

Dentro de um container Kubernetes:

kubectl exec pod-nginx -- ss -tulpn

4.2. ss -s: estatísticas de sockets em clusters

Estatísticas resumidas de sockets:

ss -s

Saída:

Total: 1234 (kernel 0)
TCP:   56 (estab 23, closed 15, orphaned 0, synrecv 0, timewait 12/0), ports 34
Transport Total     IP        IPv6
*         0         -         -
RAW       0         0         0
UDP       12        8         4
TCP       41        35        6
INET      53        43        10
FRAG      0         0         0

Essas estatísticas ajudam a identificar problemas como excesso de conexões TIME_WAIT em clusters com alta rotatividade de Pods.

4.3. Filtros avançados: estado de conexões

Filtrando por estado da conexão:

# Conexões estabelecidas
ss -t state established

# Conexões em TIME_WAIT
ss -t state time-wait

# Sockets em escuta na porta 8080
ss -tln sport = :8080

# Conexões para um IP específico
ss -t dst 10.244.1.5

Para debugging de timeouts em serviços Kubernetes:

# Verificar conexões half-open
ss -t state closing

# Sockets com buffer cheio (possível gargalo)
ss -t -o state established '( dport = :80 or sport = :80 )'

5. Comando tcpdump: Captura e Análise de Pacotes

5.1. Sintaxe básica: filtros por host, porta e protocolo

Capturando tráfego HTTP em um container:

tcpdump -i eth0 -nn port 80

Filtros combinados:

# Tráfego entre dois hosts específicos
tcpdump -i any host 10.244.1.5 and host 10.244.2.10

# Pacotes DNS (porta 53)
tcpdump -i docker0 -nn port 53

# Tráfego TCP SYN (novas conexões)
tcpdump -i eth0 'tcp[tcpflags] & (tcp-syn) != 0'

5.2. Captura em interfaces virtuais

Para depurar tráfego entre containers:

# Identificar interfaces veth
ip link show type veth

# Capturar em uma interface veth específica
tcpdump -i veth1234 -nn

# Capturar na bridge docker0
tcpdump -i docker0 -nn

Para depuração de DNS em Service Mesh (ex: Istio):

# Capturar consultas DNS no Pod
kubectl exec pod-app -- tcpdump -i eth0 -nn port 53

# Capturar tráfego de sidecar Envoy
kubectl exec pod-app -c istio-proxy -- tcpdump -i eth0 -nn

5.3. Salvando capturas para análise offline

Salvando pacotes para análise no Wireshark:

# Capturar 100 pacotes e salvar
tcpdump -i eth0 -c 100 -w captura.pcap

# Capturar por 30 segundos
tcpdump -i eth0 -G 30 -W 1 -w captura_%Y-%m-%d_%H:%M:%S.pcap

# Capturar apenas cabeçalhos (menos dados)
tcpdump -i eth0 -s 64 -w cabecalhos.pcap

Para transferir o arquivo pcap para análise:

kubectl cp pod-name:/tmp/captura.pcap ./captura.pcap

6. Aplicações Práticas no Contexto DevOps

6.1. Diagnóstico de falhas entre containers no Docker Compose

Problema: container web não consegue acessar container api.

# Verificar redes disponíveis
docker network ls

# Inspecionar a rede do compose
docker network inspect projeto_default

# Testar conectividade
docker exec container-web ping container-api
docker exec container-web ss -tulpn | grep 8080

# Capturar tráfego na interface bridge
tcpdump -i br-abcdef123456 -nn port 8080

6.2. Verificação de conectividade entre Pods e Services

Testando comunicação entre Pods no Kubernetes:

# Obter IP do Pod de destino
kubectl get pod pod-destino -o wide

# Testar conectividade
kubectl exec pod-origem -- ping 10.244.2.5
kubectl exec pod-origem -- curl -v http://10.244.2.5:8080

# Verificar resolução DNS do Service
kubectl exec pod-origem -- nslookup service-name

# Testar ClusterIP
kubectl exec pod-origem -- curl -v http://service-name:80

# Verificar regras iptables do Service
iptables-save | grep service-name

6.3. Troubleshooting de regras iptables

Problemas comuns de firewall que afetam comunicação:

# Listar regras da chain FORWARD
iptables -L FORWARD -n -v

# Verificar regras específicas do Docker
iptables -t nat -L POSTROUTING -n -v

# Rastrear pacotes descartados
iptables -I FORWARD -j LOG --log-prefix "DROPPED: " --log-level 4

# Verificar logs do kernel
dmesg | tail -20 | grep DROPPED

7. Ferramentas Complementares e Boas Práticas

7.1. nslookup e dig: resolução de DNS

Testando DNS em containers:

# nslookup básico
nslookup kubernetes.default.svc.cluster.local

# dig com consulta detalhada
dig @10.96.0.10 service-name +short

# Verificar servidores DNS configurados
cat /etc/resolv.conf

7.2. ping e traceroute: testes de latência

Testando latência entre Pods:

# Ping contínuo para monitorar perda de pacotes
ping -c 10 10.244.1.5

# Traceroute para identificar rota
traceroute -n 10.244.2.5

# MTR combina ping e traceroute
mtr -r -c 10 10.244.2.5

7.3. Checklist de diagnóstico

Sequência lógica para resolver problemas de rede:

  1. Verificar conectividade básica: ping
  2. Confirmar resolução DNS: nslookup / dig
  3. Verificar portas abertas: ss -tulpn
  4. Analisar tabela de roteamento: ip route
  5. Inspecionar regras de firewall: iptables -L
  6. Capturar tráfego suspeito: tcpdump
  7. Verificar logs do container: kubectl logs pod
  8. Testar com ferramenta específica: curl, wget, telnet

Referências