Redes são a espinha dorsal da computação moderna, especialmente em ambientes DevOps, onde serviços se comunicam constantemente. Compreender conceitos como IP, portas, DNS, protocolos HTTP/HTTPS, firewalls e ferramentas de diagnóstico é essencial para configurar, depurar e otimizar infraestruturas. Nesta aula, exploraremos cada um desses tópicos com exemplos práticos em bash.

Vamos começar com uma visão geral dos fundamentos de endereçamento e nomeação, depois mergulharemos nos protocolos de aplicação mais comuns, na segurança de rede com firewalls e, por fim, nas ferramentas de linha de comando que todo DevOps deve dominar.

IP, portas, DNS (visão geral)

Endereços IP (Internet Protocol) identificam dispositivos em uma rede. IPv4 (ex.: 192.168.1.1) ainda é amplamente usado, mas IPv6 (ex.: 2001:db8::1) está crescendo. Portas são números de 16 bits (0-65535) que identificam serviços específicos em um host. Por exemplo, HTTP usa porta 80, HTTPS usa 443, SSH usa 22. DNS (Domain Name System) traduz nomes de domínio (como google.com) em endereços IP.

No contexto DevOps, você frequentemente precisará verificar quais portas estão em uso, resolver nomes DNS ou configurar registros DNS para serviços. Ferramentas como nslookup, dig e host ajudam na diagnose de DNS.

# Verificar endereço IP de um domínio
host google.com
# ou
nslookup google.com

# Verificar portas abertas em um host (usando nc)
nc -zv google.com 80

HTTP/HTTPS

HTTP (Hypertext Transfer Protocol) é o protocolo base da web. Ele funciona sobre TCP, geralmente na porta 80. HTTPS (HTTP Secure) adiciona criptografia via TLS/SSL, usando porta 443. Métodos comuns incluem GET, POST, PUT, DELETE. Códigos de status (200 OK, 404 Not Found, 500 Internal Server Error) indicam o resultado da requisição.

Para DevOps, entender HTTP é crucial para configurar proxies, balanceadores de carga, health checks e APIs REST. Ferramentas como curl permitem testar endpoints HTTP diretamente do terminal.

# Fazer uma requisição GET
curl -v http://example.com

# Fazer uma requisição POST com dados JSON
curl -X POST -H "Content-Type: application/json" -d '{"key":"value"}' http://example.com/api

# Verificar cabeçalhos de resposta
curl -I https://google.com

Firewalls

Firewalls controlam o tráfego de rede baseando-se em regras. Podem ser implementados em hardware, software (como iptables no Linux) ou em nuvem (security groups da AWS). Regras típicas permitem ou bloqueiam tráfego por IP, porta e protocolo. Em ambientes DevOps, firewalls protegem serviços internos e externos.

No Linux, iptables e nftables são comuns. Ferramentas como ufw (Uncomplicated Firewall) simplificam a configuração. Verificar regras ativas e logs é essencial para troubleshooting.

# Listar regras do iptables
sudo iptables -L -n -v

# Habilitar porta 80 no ufw
sudo ufw allow 80/tcp

# Verificar status do ufw
sudo ufw status

Diagnóstico (ping, curl, ss)

Ferramentas de diagnóstico são vitais para identificar problemas de rede. ping testa conectividade básica via ICMP. curl testa serviços HTTP/HTTPS. ss (socket statistics) substitui o netstat e mostra sockets, portas em escuta e conexões ativas.

Outras ferramentas úteis incluem traceroute (caminho dos pacotes), nmap (varredura de portas) e tcpdump (captura de pacotes). Saber usá-las acelera a resolução de incidentes.

# Ping em um host
ping -c 4 google.com

# Testar resposta HTTP
curl -o /dev/null -s -w "%{http_code}\n" https://google.com

# Verificar portas em escuta
sudo ss -tlnp

# Verificar conexões estabelecidas
ss -tunp

Boas práticas

Documente regras de firewall e configurações de rede. Use nomes DNS em vez de IPs fixos para facilitar mudanças. Monitore tráfego e logs regularmente. Automatize verificações de conectividade com scripts. Sempre use HTTPS em produção.

Referências

Exercícios

  1. Use host para descobrir o IP do domínio github.com e, em seguida, teste a conectividade com ping.

    2. ✓ Resposta: 
    host github.com
# Saída: github.com has address 140.82.121.4
ping -c 4 140.82.121.4
  2. Faça uma requisição GET para https://httpbin.org/get usando curl e exiba apenas o código de status HTTP.

    3. ✓ Resposta: 
    curl -o /dev/null -s -w "%{http_code}\n" https://httpbin.org/get
# Saída: 200
  3. Usando ss, liste todas as portas TCP que estão em escuta no seu sistema (ou simule com um servidor simples).

    4. ✓ Resposta: 
    sudo ss -tlnp
# Exemplo de saída:
# State    Recv-Q   Send-Q     Local Address:Port     Peer Address:Port   Process
# LISTEN   0        128              0.0.0.0:22            0.0.0.0:*       users:(("sshd",pid=1234,fd=3))
  4. Adicione uma regra no firewall ufw para permitir tráfego na porta 8080 e verifique a regra.

    5. ✓ Resposta: 
    sudo ufw allow 8080/tcp
sudo ufw status
# Saída:
# Status: active
# To                         Action      From
# --                         ------      ----
# 8080/tcp                   ALLOW       Anywhere
  5. Use curl para fazer um POST com JSON para https://httpbin.org/post e verifique o corpo da resposta.

    6. ✓ Resposta: 
    curl -X POST -H "Content-Type: application/json" -d '{"nome":"DevOps"}' https://httpbin.org/post
# Saída (parcial):
# {
#   "args": {}, 
#   "data": "{\"nome\":\"DevOps\"}", 
#   "files": {}, 
#   "form": {}, 
#   "headers": {...}, 
#   "json": {"nome": "DevOps"}, 
#   "url": "https://httpbin.org/post"
# }