Simule pacotes atrasados ​​e descartados no Linux

Eu gostaria de simular o atraso e a perda de pacotes para UDPe TCPno Linux para medir o desempenho de um aplicativo. Existe uma maneira simples de fazer isso?

O netem aproveita a funcionalidade já incorporada no Linux e nos utilitários de espaço do usuário para simular redes. É a isso que a resposta de Marcos se refere, por um nome diferente.

Os exemplos na página inicial já mostram como você pode conseguir o que pediu:

Exemplos

Emulação de atrasos na rede de área ampla

Este é o exemplo mais simples, apenas adiciona uma quantidade fixa de atraso a todos os pacotes que saem da Ethernet local.

# tc qdisc add dev eth0 root netem delay 100ms

Agora, um simples teste de ping para hospedar na rede local deve mostrar um aumento de 100 milissegundos. O atraso é limitado pela resolução do relógio do kernel (Hz). Na maioria dos sistemas 2.4, o relógio do sistema é executado em 100 Hz, o que permite atrasos em incrementos de 10 ms. Em 2.6, o valor é um parâmetro de configuração de 1000 a 100 Hz.

Exemplos posteriores apenas alteram os parâmetros sem recarregar o qdisc

Redes reais de área ampla mostram variabilidade, portanto é possível adicionar variação aleatória.

# tc qdisc change dev eth0 root netem delay 100ms 10ms

Isso faz com que o atraso adicionado seja de 100 ± 10 ms. A variação do atraso da rede não é puramente aleatória, de modo a emular que também existe um valor de correlação.

# tc qdisc change dev eth0 root netem delay 100ms 10ms 25%

Isso faz com que o atraso adicionado seja de 100 ± 10 ms, com o próximo elemento aleatório dependendo de 25% no último. Isso não é uma correlação estatística verdadeira, mas uma aproximação.

Atraso na distribuição

Normalmente, o atraso em uma rede não é uniforme. É mais comum usar algo como uma distribuição normal para descrever a variação no atraso. A disciplina netem pode usar uma tabela para especificar uma distribuição não uniforme.

# tc qdisc change dev eth0 root netem delay 100ms 20ms distribution normal

As tabelas reais (normal, pareto, paretonormal) são geradas como parte da compilação iproute2 e colocadas em / usr / lib / tc; portanto, é possível com algum esforço fazer sua própria distribuição com base em dados experimentais.

Perda de pacotes

A perda aleatória de pacotes é especificada no comando 'tc' em porcentagem. O menor valor diferente de zero possível é:

2 ⁻³² = 0.0000000232%

# tc qdisc change dev eth0 root netem loss 0.1%

Isso faz com que 1/10 de um por cento (ou seja, 1 em 1000) pacotes sejam descartados aleatoriamente.

Uma correlação opcional também pode ser adicionada. Isso faz com que o gerador de números aleatórios seja menos aleatório e pode ser usado para emular perdas de burst de pacotes.

# tc qdisc change dev eth0 root netem loss 0.3% 25%

Isso fará com que 0,3% dos pacotes sejam perdidos e cada probabilidade sucessiva depende de um quarto da última.

Problema _n = 0,25 × Problema _n-1 + 0,75 × Aleatório

Observe que você deve usar tc qdisc addse você não possui regras para essa interface ou tc qdisc changese já possui regras para essa interface. Tentar usar tc qdisc changeem uma interface sem regras dará o erro RTNETLINK answers: No such file or directory.

Para pacotes descartados, eu simplesmente usaria o iptables e o módulo estatístico .

iptables -A INPUT -m statistic --mode random --probability 0.01 -j DROP

Acima, o pacote será recebido com uma probabilidade de 1%. Tenha cuidado, qualquer coisa acima de 0,14 e a maioria das conexões TCP provavelmente travará completamente.

Dê uma olhada no man iptables e procure por "estatística" para obter mais informações.

Um dos meus colegas usa o tc para fazer isso. Consulte a página do manual para obter mais informações. Você pode ver um exemplo de seu uso aqui .

O iptables (8) possui um módulo de correspondência estatística que pode ser usado para corresponder a cada enésimo pacote. Para descartar este pacote, basta acrescentar -j DROP .

Este tutorial sobre simulações de física de rede contém uma classe C ++ no código de exemplo para simular a latência e a perda de pacotes em uma conexão UDP e pode ser uma orientação. Veja as variáveis ​​de latência pública e packetLoss da classe Connection encontradas no arquivo Connection.h do código-fonte disponível para download .

Ainda não tentei, mas esta página possui uma lista de módulos de plug-in que são executados no sistema de filtragem de iptables embutido no Linux. Um dos módulos é chamado "enésimo" e permite que você configure uma regra que reduzirá uma taxa configurável dos pacotes. Pode ser um bom lugar para começar, pelo menos.

Você pode tentar http://snad.ncsl.nist.gov/nistnet/ É um projeto NIST bastante antigo (última versão de 2005), mas funciona para mim.

Uma ferramenta de injeção de falhas de rede fácil de usar é o Saboteur . Pode simular:

• Partição total de rede
• Serviço remoto inoperante (não escutando na porta esperada)
• Atrasos
• Perda de pacote - Tempo limite da conexão TCP (normalmente acontece quando dois sistemas são separados por um firewall com estado)

Uma das ferramentas mais utilizadas na comunidade científica para esse fim é o DummyNet . Depois de instalar o ipfwmódulo do kernel, para introduzir um atraso de propagação de 50ms entre duas máquinas, execute estes comandos:

./ipfw pipe 1 config delay 50ms
./ipfw add 1000 pipe 1 ip from $IP_MACHINE_1 to $IP_MACHINE_2

Para introduzir também 50% das perdas de pacotes, você deve executar:

./ipfw pipe 1 config plr 0.5

Aqui mais detalhes.