Fundamentos de Redes no Linux
Quando você trabalha com Linux, entender redes é essencial. A maioria dos servidores e máquinas Linux executa serviços que precisam se comunicar pela rede, seja para receber requisições HTTP, conectar-se a bancos de dados remotos ou simplesmente permitir que você faça SSH em uma máquina. Linux oferece ferramentas poderosas para inspecionar, configurar e diagnosticar sua rede, mas muitos iniciantes se sentem perdidos porque há muitas opções.
A chave para dominar redes em Linux é entender que tudo é separado em camadas. Você tem a camada de aplicação (seu navegador, seu servidor web), a camada de transporte (TCP, UDP), a camada IP (roteamento, endereços) e a camada de link (placas de rede, ARP). Cada ferramenta que vamos estudar se concentra em uma ou mais dessas camadas. Neste artigo, você aprenderá a usar as ferramentas padrão do Linux para entender exatamente o que sua rede está fazendo.
Configuração e Visualização de Interfaces com ip
O comando ip é a ferramenta moderna do Linux para gerenciar tudo relacionado a redes. Ele substitui antigas ferramentas como ifconfig e oferece muito mais funcionalidade. Quando você executa ip, você está falando diretamente com o kernel Linux para gerenciar suas interfaces de rede, rotas, endereços IP e muito mais.
Inspecionando Interfaces de Rede
O primeiro passo é ver quais interfaces de rede sua máquina tem e qual é sua configuração atual:
ip link show
Este comando lista todas as interfaces de rede, incluindo seu estado (UP ou DOWN) e informações de camada 2 (MAC address, MTU, etc.). Para ver só as que estão ativas:
ip link show up
Se você quer informações mais detalhadas, inclusive endereços IP:
ip addr show
Você verá algo assim:
1: lo: <LOOPBACK,UP,LOWER_UP> mtu 65536 qdisc noqueue state UNKNOWN group default qlen 1000
link/loopback 00:00:00:00:00:00 brd 00:00:00:00:00:00
inet 127.0.0.1/8 scope host lo
inet6 ::1/128 scope host
2: eth0: <BROADCAST,MULTICAST,UP,LOWER_UP> mtu 1500 qdisc mq state UP group default qlen 1000
link/ether 08:00:27:00:4e:3f brd ff:ff:ff:ff:ff:ff
inet 192.168.1.100/24 brd 192.168.1.255 scope global eth0
inet6 fe80::a00:27ff:fe00:4e3f/64 scope link
Aqui você vê que eth0 tem o endereço IP 192.168.1.100/24, o que significa que pode alcançar máquinas de 192.168.1.0 até 192.168.1.255.
Atribuindo Endereços IP
Para atribuir um endereço IP a uma interface:
sudo ip addr add 192.168.1.50/24 dev eth0
Para remover:
sudo ip addr del 192.168.1.50/24 dev eth0
Note que mudanças feitas com ip são temporárias e serão perdidas ao reiniciar. Para persistir, você precisa editar arquivos de configuração como /etc/netplan/ (Ubuntu/Debian moderno) ou /etc/network/interfaces (Debian antigo).
Gerenciando Rotas
Rotas dizem ao seu sistema como alcançar redes remotas. Para ver suas rotas atuais:
ip route show
Saída típica:
default via 192.168.1.1 dev eth0
192.168.1.0/24 dev eth0 proto kernel scope link src 192.168.1.100
A primeira linha é a rota padrão — qualquer tráfego para redes desconhecidas vai através do gateway 192.168.1.1. A segunda é a rota direta para sua rede local.
Para adicionar uma rota para uma rede remota:
sudo ip route add 10.0.0.0/24 via 192.168.1.254 dev eth0
Isto diz: "para alcançar a rede 10.0.0.0/24, envie pelo gateway 192.168.1.254 através da interface eth0".
Inspecionando Conexões Ativas com ss e netstat
Agora que você entende sua configuração de rede, precisa saber quais conexões estão ativas no momento. O comando ss (socket statistics) é a ferramenta moderna, enquanto netstat ainda funciona mas é legado. Ambos mostram sockets (conexões) TCP, UDP e Unix domain socket em sua máquina.
Usando ss para Listar Conexões
O comando mais útil é:
ss -tunap
Vamos quebrar os flags:
- -t mostra sockets TCP
- -u mostra sockets UDP
- -n mostra números (IPs e portas) em vez de tentar resolver nomes
- -a mostra todos os sockets, não só os conectados
- -p mostra qual processo está usando cada socket
Saída esperada:
Netid State Recv-Q Send-Q Local Address:Port Peer Address:Port Process
tcp LISTEN 0 128 127.0.0.1:22 *:* users:(("sshd",pid=1234,fd=3))
tcp ESTAB 0 0 192.168.1.100:50234 8.8.8.8:443 users:(("curl",pid=5678,fd=3))
tcp TIME_WAIT 0 0 192.168.1.100:50235 8.8.8.8:443
Esta saída te diz que há um serviço SSH ouvindo na porta 22, uma conexão estabelecida para Google (8.8.8.8:443), e uma conexão fechada que ainda está em TIME_WAIT (estado temporário após fechamento).
Filtrando Conexões por Estado e Porta
Se você quer apenas conexões estabelecidas:
ss -tan state established
Se quer apenas ver o que está ouvindo (listening):
ss -tln
Ou se quer ver que programa está usando a porta 8080:
ss -tlnp | grep 8080
Comparação com netstat
O netstat foi a ferramenta padrão antes de ss ser desenvolvido. Ainda funciona, mas é mais lento porque usa arquivos /proc em vez de chamadas de sistema diretas. O comando equivalente seria:
netstat -tunap
Os flags significam a mesma coisa. Você verá saída similar, mas em Linux moderno, ss é preferido porque é mais rápido e oferece mais opções de filtragem.
Um caso onde netstat ainda é útil é para statisticas de rede:
netstat -s
Isto mostra pacotes transmitidos, recebidos, erros, etc. Com ss, você precisaria usar nstat para algo similar.
Filtrando Tráfego com iptables
O iptables é a ferramenta para gerenciar o firewall do Linux. Ele trabalha com regras que decidem se pacotes são aceitos, rejeitados ou encaminhados. Isso é complexo porque o iptables tem várias tabelas e cadeias, mas o conceito fundamental é simples: cada pacote que entra ou sai do seu sistema passa por um conjunto de regras.
Estrutura Básica do iptables
O iptables funciona com tabelas, cadeias e regras:
- Tabelas:
filter(padrão, controla se pacotes passam),nat(tradução de endereços),mangle(modificação de pacotes) - Cadeias:
INPUT(pacotes entrando),OUTPUT(pacotes saindo),FORWARD(pacotes sendo reenviados) - Ações:
ACCEPT(deixa passar),DROP(descarta silenciosamente),REJECT(descarta e avisa o remetente)
Quando você executa:
sudo iptables -L
Você vê as regras atuais na tabela filter:
Chain INPUT (policy ACCEPT)
target prot opt source destination
ACCEPT tcp -- anywhere anywhere tcp dpt:ssh
DROP tcp -- anywhere anywhere tcp dpt:telnet
Chain FORWARD (policy ACCEPT)
target prot opt source destination
Chain OUTPUT (policy ACCEPT)
target prot opt source destination
Isto diz que SSH (porta 22) é aceito, Telnet (porta 23) é descartado, e tudo mais por padrão é aceito.
Adicionando e Removendo Regras
Para aceitar conexões SSH:
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
Vamos entender cada parte:
- -A INPUT adiciona uma regra na cadeia INPUT
- -p tcp filtra por protocolo TCP
- --dport 22 filtra por porta destino 22
- -j ACCEPT a ação é aceitar
Para descartar Telnet:
sudo iptables -A INPUT -p tcp --dport 23 -j DROP
Para listar com números de linha:
sudo iptables -L INPUT --line-numbers
Para deletar uma regra pelo número:
sudo iptables -D INPUT 2
Isto deleta a 2ª regra da cadeia INPUT.
Um Exemplo Prático: Firewall Básico
Vamos criar um firewall que bloqueia tudo por padrão, exceto SSH:
# Limpar regras anteriores
sudo iptables -F
# Setar política padrão
sudo iptables -P INPUT DROP
sudo iptables -P OUTPUT ACCEPT
sudo iptables -P FORWARD DROP
# Aceitar localhost
sudo iptables -A INPUT -i lo -j ACCEPT
# Aceitar conexões já estabelecidas
sudo iptables -A INPUT -m state --state ESTABLISHED,RELATED -j ACCEPT
# Aceitar SSH
sudo iptables -A INPUT -p tcp --dport 22 -j ACCEPT
# Aceitar HTTP e HTTPS se estiver servindo web
sudo iptables -A INPUT -p tcp --dport 80 -j ACCEPT
sudo iptables -A INPUT -p tcp --dport 443 -j ACCEPT
Isto é um firewall funcional. A regra com -m state --state ESTABLISHED,RELATED é crucial porque permite respostas a requisições que você fez.
Persistindo Regras do iptables
O problema é que regras do iptables são perdidas ao reiniciar. Para persistir, você pode usar iptables-save:
sudo iptables-save > /etc/iptables/rules.v4
E restaurar com:
sudo iptables-restore < /etc/iptables/rules.v4
Para automatizar na inicialização, em sistemas com iptables-persistent instalado:
sudo apt-get install iptables-persistent
sudo netfilter-persistent save
Diagnóstico de Conectividade
Quando algo não funciona na rede, você precisa de forma sistemática descobrir onde está o problema. Linux fornece várias ferramentas para testar conectividade em diferentes camadas.
Verificando Conectividade Local com ping
O ping testa se uma máquina remota está alcançável enviando pacotes ICMP:
ping -c 4 8.8.8.8
Saída típica:
PING 8.8.8.8 (8.8.8.8) 56(84) bytes of data.
64 bytes from 8.8.8.8: icmp_seq=1 ttl=119 time=20.5 ms
64 bytes from 8.8.8.8: icmp_seq=2 ttl=119 time=21.2 ms
64 bytes from 8.8.8.8: icmp_seq=3 ttl=119 time=19.8 ms
64 bytes from 8.8.8.8: icmp_seq=4 ttl=119 time=22.1 ms
--- 8.8.8.8 statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3005ms
rtt min/avg/max/mdev = 19.8/20.9/22.1/0.9 ms
Se receber "Destination Host Unreachable", o roteador não sabe como chegar à máquina. Se receber "Network Unreachable", é um problema de rota local.
Rastreando o Caminho com traceroute
O traceroute mostra todos os saltos (routers) entre você e um destino:
traceroute google.com
Saída típica:
traceroute to google.com (142.250.80.46), 30 hops max, 60 byte packets
1 _gateway (192.168.1.1) 2.234 ms 2.102 ms 1.987 ms
2 router.isp.com (203.0.113.1) 15.432 ms 14.876 ms 15.123 ms
3 * * *
4 142.250.80.46 (142.250.80.46) 22.456 ms 21.987 ms 22.134 ms
Se um hop responde com * * *, significa que não responde a ICMP (comum em roteadores corporativos). Se para em um hop específico, o problema está ali. Use traceroute -m 30 para aumentar o número máximo de hops se não conseguir alcançar o destino.
Testando Portas Específicas com telnet e nc
Se quer verificar se uma porta específica está aberta:
nc -zv 8.8.8.8 443
A flag -z faz uma varredura sem enviar dados, -v é verbose. Resposta:
Connection to 8.8.8.8 443 port [tcp/https] succeeded!
Ou com telnet:
telnet google.com 443
Ctrl+C para sair. Telnet é mais antigo, mas útil para testar conexões em texto plano.
Analisando DNS com dig e nslookup
Se o ping falha mas o nc funciona, pode ser problema de DNS:
dig google.com
Isto mostra a resposta do servidor DNS:
; <<>> DiG 9.16.1-Ubuntu <<>> google.com
;; global options: +cmd
;; Got answer:
;; ->>HEADER<<- opcode: QUERY, status: NOERROR, id: 12345
;google.com. 300 IN A 142.250.80.46
Se receber status NXDOMAIN, o domínio não existe. Se receber status SERVFAIL, o servidor DNS teve um problema. Para testar um servidor DNS específico:
dig @1.1.1.1 google.com
Analisando Pacotes com tcpdump
Quando tudo mais falha, você precisa ver os pacotes reais. tcpdump captura pacotes na rede:
sudo tcpdump -i eth0 -n 'tcp port 443'
Isto captura pacotes TCP na porta 443 da interface eth0, sem resolver nomes (-n).
Saída:
10:23:45.123456 IP 192.168.1.100.50234 > 142.250.80.46.443: Flags [S], seq 0, win 64240, length 0
10:23:45.234567 IP 142.250.80.46.443 > 192.168.1.100.50234: Flags [S.], seq 0, ack 1, win 65160, length 0
10:23:45.245678 IP 192.168.1.100.50234 > 142.250.80.46.443: Flags [.], ack 1, win 64240, length 0
Flags [S] é SYN (início de conexão), [S.] é SYN-ACK (resposta), [.] é ACK (confirmação). Isto mostra um handshake TCP bem-sucedido.
Para capturar e salvar em arquivo:
sudo tcpdump -i eth0 -w captura.pcap 'tcp port 443'
Depois você pode analisar em ferramentas como Wireshark.
Verificando Disponibilidade de Serviços com curl
Para testar conectividade HTTP/HTTPS de forma mais realista:
curl -v http://example.com
Flag -v mostra headers HTTP, erros de certificado SSL, etc:
* Trying 93.184.216.34:80...
* Connected to example.com (93.184.216.34) port 80 (#0)
> GET / HTTP/1.1
> Host: example.com
> User-Agent: curl/7.68.0
< HTTP/1.1 200 OK
< Content-Type: text/html
...
Se receber "Connection refused", a porta está fechada. Se receber "Connection timeout", há um problema de roteamento.
Conclusão
Dominar redes em Linux significa entender que você tem ferramentas em cada camada. Com ip, você configura sua máquina na rede. Com ss e netstat, você vê o que está acontecendo agora. Com iptables, você controla o fluxo de tráfego. E quando algo quebra, você tem um conjunto sistemático de ferramentas de diagnóstico (ping, traceroute, nc, dig, tcpdump, curl) para encontrar o problema.
A chave é seguir uma metodologia: primeiro verifique conectividade básica com ping, depois rastreie o caminho com traceroute, teste portas específicas com nc, verifique DNS com dig, e finalmente analise pacotes com tcpdump se necessário. Assim você resolve 99% dos problemas de rede no Linux.
Por fim, lembre-se que iptables é poderoso mas precisa ser usado com cuidado — uma regra errada e você perde acesso SSH à máquina. Sempre mantenha uma conexão de acesso físico ou console antes de fazer mudanças no firewall.
Referências
- Linux man page: ip(8) — Documentação oficial do comando ip
- Linux man page: ss(8) — Documentação oficial do ss
- Linux man page: iptables(8) — Documentação oficial do iptables
- Debian Wiki: NetworkConfiguration — Guia prático de rede no Debian/Ubuntu
- TCP/IP Illustrated, Volume 1 — Livro referência sobre TCP/IP