Emulando parametros de red con Shapy

Este post pretende explicar como emular parámetros de redes tales como la latencia, jitter, pérdida de paquetes y ancho de banda por medio de la creación de un entorno de pruebas enfocado principlamente  para sistemas  GNU/Linux. 

¿Para que emular?

Sirve por ejemplo, en situaciones donde se desea evaluar el comportamiento de diversos protocolos del stack de TCP/IP en redes de datos, verificar el tratamiento que se da a los paquetes con condiciones particulares, y con ello poder predecir posibles fallos o anomalías que puedan ocurrir.

Latencia: Es la demora en la entrega de los paquetes, desde que estos salen hasta que llegan a su destino.

Jitter: Se define como las variaciones en el tiempo (demoras) cuando se transmiten los paquetes, generalmente esas demoras son causadas por un encolamiento al existir altos niveles de tráfico en la red.

Perdida de paquetes: Se presenta cuando los niveles de tráfico son muy altos y  los paquetes tienden a perderse al ser rechazados por los dispositivos de red, especialmente cuando los buffers se llenan.

¿Como hacerlo?

Bien, existen diversas aplicaciones y software para realizar este tipo de pruebas, uno de los mas conocidos es TC (Traffic Control) viene incluido en un modulo del Kernel llamado NetEM para mas información en este link:  http://www.lartc.org/#download.

Sin embargo una forma fácil de entender  y de implementar la podemos realizar por medio de un framework  de python llamado Shapy el cual se apoya en el modulo NetEM,

Shapy

Se asume que python esta instalado  y el gestor de paquetes pip, este ultimo puede ser descargado e instalado en sistemas linux basados en debian o ubuntu ejecutando en una terminal:

sudo apt-get install python-pip

Para instalar shapy simplemente digitamos lo siguiente:

sudo pip install shapy

¿Como configurarlo?

Lo primero es crear un archivo  de configuración de la siguiente forma:

UNITS = 'kbit'
ENV = {'PATH': '/sbin:/bin:/usr/bin'}
HTB_DEFAULT_CLASS = '1ff'
EMU_INTERFACES = ('eth0',"wlan0","lo",)

Donde UNITS son las unidades para limitar ancho de manda puede ser kbits o mbits, ENV es la variable de entorno con la ruta donde esta el comando tc, HTB_DEFAULT_CLASS es la clase que va indentificar cada una de las reglas para cada interfaz de red y asi poder aplicarle un Token Bucket Jerarquico  (Ver el link anterior) y finalmente EMU_INTERFACES son las interfaces de red que se pretenden emular. Lo anterior debe ser guardado en un archivo .py.

Aplicando parametros

A continuación creamos un archivo de python de la siguiente manera:

#IMPORTAR LIBRERIAS
from shapy.emulation.shaper import Shaper
from shapy import register_settings
#LLAMAR ARCHIVO DE CONFIGURACION
register_settings('archivo_configuracion.py')
#APLICAR REGLAS
ip ="192.168.1.1"
subida = 1000
bajada = 500
latencia = 250
jitter = 25
regla = {(ip,) : {'upload': subida, 'download': bajada, 'delay': latencia, 'jitter': jitter},}
sh = Shaper()
sh.set_shaping(regla)

Finalmente las reglas fueron aplicadas en la interfaz donde esta la IP 192.168.1.1, ancho de banda de subida de 1000 kbps, bajada 500 kbps, latencia de 250 milisegundos y jitter de 25 milisegundos.

¿Y la perdida de paquetes?

Hay dos formas de emular perdida de paquetes (que conozco):

1-Usando iptables:

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

Con lo anterior se rechazaran el 15% de los paquetes entrantes en todas las interfaces.

2- Taffic control:

tc qdisc add dev  eth0 parent 1:1 handle 512: netem loss 15%

Con lo anterior se rechazaran el 15% de los paquetes entrantes en  eth0.

Finalmente recomiendo ver el siguiente video para ver de forma práctica como se comporta una red con parametros emulados.