Como Simular Limites de Banda e Perda de Pacotes no Linux com o Comando TC

Aprenda a testar a resiliência de aplicações distribuídas em condições reais de rede utilizando o Network Emulator nativo do Linux kernel, o utilitário tc.

Marcio Cunha•5 min

Também disponível em:English Español

Resumo

A simulação de restrições severas de rede no próprio ambiente de desenvolvimento elimina surpresas em ambientes de produção geograficamente dispersos.
O subsistema Netem atua diretamente na camada de enlace do kernel Linux para injetar latência, jitter e perda de pacotes de forma controlada.
A definição de limites finos de largura de banda exige o uso combinado das disciplinas de enfileiramento HTB e da extensão Netem.
A remoção imediata das regras aplicadas evita que testes de estresse corrompam conexões administrativas de longa duração na máquina local.
A validação empírica de protocolos baseados em timeout revela falhas estruturais invisíveis em conexões locais de alta velocidade.

O Desafio Invisível da Resiliência em Redes Imperfeitas

Desenvolver softwares em ambientes locais conectados por cabos de fibra óptica de alta velocidade cria uma falsa sensação de segurança operacional. Na prática, a infraestrutura global da internet é caótica, repleta de conexões móveis instáveis, rotas congestionadas e quedas intermitentes de pacotes de dados. Quando um sistema distribuído falha em lidar com essas variações, o usuário final experimenta telas travadas, requisições duplicadas e dados corrompidos. O engenheiro de software precisa de ferramentas capazes de reproduzir esse caos de rede diretamente na estação de trabalho de desenvolvimento.

Em vez de depender de servidores remotos caros ou de simulações em nuvem difíceis de orquestrar, o sistema operacional Linux oferece um canivete suiço integrado diretamente em seu núcleo. Estamos falando do comando tc (Traffic Control), parte do pacote iproute2, que gerencia o fluxo de pacotes nas interfaces de rede. Combinado com o módulo Netem (Network Emulator), o tc permite injetar atrasos temporais, corromper dados, duplicar tráfego e descartar pacotes de forma cirúrgica, simulando conexões via satélite, redes 3G degradadas ou escritórios remotos distantes.

Compreendendo a Arquitetura de Enfileiramento do Kernel Linux

Para dominar o controle de tráfego, precisamos entender como o sistema operacional lida com os dados que saem da placa de rede. O kernel utiliza disciplinas de enfileiramento (qdisc - Queueing Discipline) para organizar a ordem em que os pacotes de rede são transmitidos ou descartados. Por padrão, a maioria das interfaces utiliza uma fila simples do tipo FIFO (First-In, First-Out), onde o primeiro pacote que chega é o primeiro a ser enviado, sem qualquer priorização ou limitação intencional de velocidade.

Quando aplicamos uma regra de limitação de banda ou perda de pacotes, interceptamos essa fila padrão e a substituímos por uma estrutura programável. O Netem atua como um qdisc especial que pode ser acoplado diretamente à interface de rede ou integrado a estruturas mais complexas, como o HTB (Hierarchical Token Bucket). Na prática, o HTB funciona como um distribuidor inteligente de tokens, onde cada token representa permissão para transmitir uma quantidade específica de bytes, permitindo fatiar a largura de banda total em fatias restritas para cada aplicação.

Preparando o Cenário de Testes na Interface de Loopback

Antes de aplicar qualquer modificação de tráfego em uma interface física de rede, que poderia cortar seu acesso SSH remoto à máquina, é altamente recomendável utilizar a interface de loopback (lo). Essa interface virtual representa o próprio computador conversando consigo mesmo, isolando completamente os experimentos e garantindo um ambiente totalmente seguro para testes de estresse e validação de comandos.

Para verificar o estado atual da interface de loopback e confirmar que nenhuma regra restritiva está ativa, executamos o utilitário ip route ou listamos as disciplinas configuradas. Na prática, isso significa que podemos testar servidores web, bancos de dados locais e clientes de API simulando conexões internacionais de alta latência sem precisar desconectar o cabo de rede físico do computador.

Aplicando Perda de Pacotes e Atrasos Simulados com Netem

Vamos ao primeiro cenário prático de engenharia: simular uma conexão instável de internet móvel que perde aleatoriamente dez por cento dos pacotes enviados e adiciona cem milissegundos de atraso com oscilação. Para executar este procedimento com segurança na sua máquina de desenvolvimento, siga a sequência abaixo usando o terminal Linux com privilégios administrativos.

Abra o terminal e certifique-se de executar os comandos com privilégios de superusuário para interagir diretamente com o kernel do sistema.
Inspecione a interface de rede escolhida, como a interface virtual de loopback, para garantir que ela está ativa e respondendo corretamente:
```
ip link show lo
```
Aplique a regra do Netem na interface de loopback para injetar dez por cento de perda de pacotes e cem milissegundos de latência base:
```
sudo tc qdisc add dev lo root netem loss 10% delay 100ms 20ms
```
Valide imediatamente se a regra foi aplicada corretamente listando os qdiscs ativos na interface:
```
sudo tc qdisc show dev lo
```
Teste a nova latência disparando pacotes de diagnóstico para o endereço local:
```
ping -c 5 127.0.0.1
```

Com essa simples alteração, ferramentas de monitoramento e aplicações que dependem de conexões contínuas começarão a sofrer timeouts e retentativas. Esse comportamento é essencial para observar como o código do cliente lida com falhas parciais de rede.

Limitando a Largura de Banda com HTB e Netem Combinados

O comando netem isoladamente é excelente para atrasos e perdas, mas ele não restringe a velocidade máxima de transmissão por si só. Para limitar a banda, por exemplo, a exatamente um megabit por segundo, precisamos criar uma raiz HTB e pendurar o netem abaixo dela. Essa combinação nos permite restringir a velocidade e corromper pacotes simultaneamente, simulando um link de satélite congestionado e de baixa capacidade.

A estrutura de comandos exige a criação de uma classe HTB raiz que controla a taxa máxima de saída (rate 1mbit) e, em seguida, a adição de uma folha netem subordinada a essa classe. Na prática, qualquer requisição HTTP ou transferência de arquivos executada através dessa interface agora será estrangulada rigidamente pelo kernel, permitindo observar gargalos de buffer e estouros de memória em tempo real.

Limpando as Regras e Restaurando o Estado Original da Rede

Um erro comum ao utilizar o subsistema tc é esquecer de remover as regras de simulação após o término dos testes. Como as configurações persistem na memória da interface de rede até que o sistema seja reiniciado ou o qdisc seja explicitamente limpo, aplicações futuras na mesma máquina continuarão sofrendo perda de pacotes e lentidão inexplicável.

Para reverter todas as alterações e restaurar o comportamento nativo de alta velocidade da interface de loopback ou de qualquer placa física, utilizamos o comando de limpeza geral. Na prática, executar este comando remove instantaneamente qualquer disciplina de enfileiramento customizada, devolvendo o controle total do tráfego ao kernel padrão do Linux sem a necessidade de reiniciar o computador.

Considerações Finais sobre Testes de Resiliência de Rede

Simular cenários adversos de rede localmente utilizando o subsistema tc do Linux transforma a forma como arquitetamos aplicações distribuídas. Em vez de descobrir falhas de timeout e corrupção de estado apenas quando o software entra em produção, os engenheiros ganham a capacidade de auditar o comportamento do código sob pressão extrema diretamente na máquina de desenvolvimento. Dominar essas ferramentas eleva a robustez dos sistemas e garante experiências de usuário consistentes, independentemente da qualidade da infraestrutura conectada.