El comando Traffic Control (tc) es una herramienta que todo administrador de red debería conocer. Lo que hace tc es permitir al administrador configurar la programación de paquetes del kernel para simular retraso y pérdida de paquetes para aplicaciones UDP/TCP o para limitar el uso del ancho de banda para un servicio específico.

Linux ofrece herramientas para gestionar y manipular la transmisión de  paquetes. El subsistema Linux Traffic Control (TC) ayuda a controlar,  clasificar, dar forma y programar el tráfico de red. TC también manipula  el contenido del paquete durante la clasificación utilizando filtros y acciones. El subsistema TC consigue esto utilizando disciplinas de colas (qdisc), un elemento fundamental de la arquitectura TC.

El mecanismo de programación ordena o reorganiza los paquetes antes de que que entren o salgan de las distintas colas. El planificador más habitual es el programador FIFO (primero en entrar, primero en salir). Puede realizar las operaciones qdiscs temporalmente utilizando la utilidad tc o permanentemente utilizando NetworkManager.

Traffic Control

tc es una herramienta que nos da el poder de manipular las configuraciones de control de tráfico en el kernel de Linux. Con tc, podemos controlar y simular varias configuraciones de red en general.

Introducción

• tc (Traffic Control) es una herramienta que permite realizar el control de tráfico en Linux.

• tc utiliza disciplinas de colas, denominadas qdisc (queueing discipline).

• Cada vez que el kernel tiene que enviar un paquete a una interfaz, se encola en la qdisc configurada en dicha interfaz. El kernel trata de sacar el máximo número de paquetes de dicha qdisc para entregárselos al driver de la tarjeta de red.

• El tipo de qdisc más simple es FIFO (First In First Out). Si el driver de la tarjeta de red está ocupado, el paquete se quedará guardado en la cola.

Interfaces de entrada/salida de un router

• El control de tráfico se puede aplicar en la interfaz de entrada de un router o en la interfaz de salida del router.

• Cada interfaz de red de un router puede actuar como entrada de paquetes, para los paquetes que se reciben en dicha interfaz, y como interfaz de salida, para los paquetes que se envían a través de dicha interfaz.

Qdisc/Class/Filter

• Qdisc (Disciplina de cola): determina qué paquetes se reenviarán antes que otros. Las hay de 2 tipos:

  • Disciplina de colas sin clases de tráfico: ejemplo FIFO.

 Disciplina de colas con clases de tráfico: ejemplo PRIO

• Class (Clase de tráfico): especifica las diferentes categorías de tráfico. Una clase de tráfico está asociada a una disciplina de cola (qdisc).

• Filter (Filtro de tráfico): identifica el tráfico que se corresponde con cada clase (class).

Para controlar el tráfico en el kernel, lo primero que tenemos que hacer es conocer el nombre de la interfaz de red de nuestro dispositivo. Para ello, podemos utilizar la utilidad: ifconfig (configuración de interfaz) o ip a

Voy a demostrarlo añadiendo un retardo constante a la interfaz ens5 de mi máquina. Para ser más específico, voy a retrasar el tráfico de salida (egress) en el dispositivo 50 ms. Para ello, el comando sería

sudo tc qdisc add dev ens5 root tbf rate 1024kbit latency 50ms burst 1540

Las opciones del comando anterior son:

• qdisc indica a tc que modifique el planificador
• add indica a tc que añada una nueva regla
• dev ens5 indica a tc que las reglas se aplicarán al dispositivo ens5
• root indica a tc que modifique el programador de tráfico saliente
• tbf rate 1024kbit indica a tc que reduzca el tráfico a la velocidad de 1024kbit
• latency 50ms indica a tc que retrasará el tráfico 50ms
• burst 1540 indica a tc el tamaño de nuestro bucket

Una vez que haya emitido el comando, puede verificar que los parámetros se aplicaron con el comando

sudo tc qdisc show dev ens5

Para eliminar la regla recién añadida, ejecute el comando

sudo tc qdisc del dev ens5 root

Una cosa muy importante a recordar es que sólo se puede aplicar una regla a una interfaz a la vez. Por este motivo, para crear una regla diferente para una interfaz, primero debe eliminar la regla anterior.

Veremos otro simple ejemplo de tc:

$ sudo tc qdisc add dev enp0s3 root netem loss 3%

Dado que estamos tratando con modificaciones de funciones del kernel, se requieren privilegios sudo o root. En particular, estamos modificando cómo los paquetes en el dispositivo enp0s3 (dev enp0s3) se ponen en cola para su procesamiento (qdisc) añadiendo (add) una regla que afecta al tráfico saliente (outbount) (también llamado root).

La regla simplemente dirige los datos a través de la disciplina de colas netem (emulador de red), aplicando una pérdida del 3%.

 Limitación del tráfico de salida

Veamos ahora cómo podemos limitar el tráfico de salida utilizando tc:

$ sudo tc qdisc add dev enp0s3 root tbf rate 500kbit burst 16kbit latency 50ms

En este caso, utilizamos tbf (token bucket filter) en lugar de netem. Esta disciplina funciona con tokens, que, de forma similar a los bytes, representan aproximadamente la capacidad de nuestra cola para gestionar el tráfico de diferentes formas.

Por ejemplo, limitamos la velocidad de transferencia a 500kbit. Además, configuramos la ráfaga: un búfer que se llena con cada paquete entrante. Es importante que sea lo suficientemente grande como para contener todos los paquetes que tengamos que enviar de una vez.

Por último, imponemos un retardo de tráfico de 50 ms con la opción de latencia.

Comparación del rendimiento de la red

Tenemos que comprobar si este comando funciona correctamente inspeccionando el rendimiento de la red antes y después de su aplicación. Si tenemos acceso tanto a un servidor como a un cliente, podemos utilizar la herramienta iperf para nuestros propósitos.

Sin embargo, sería más sencillo utilizar speedtest-cli.

Visualización y eliminación de las reglas actuales

Cuando queramos ver las reglas existentes en una interfaz concreta, podemos volver a utilizar tc:

$ sudo tc qdisc show dev enp0s3

qdisc tbf 8003: root refcnt 2 rate 500Kbit burst 16Kb lat 50.0ms 

Además, también podemos borrar reglas:

$ sudo tc qdisc del dev enp0s3 root

Este comando borra (del) todas las reglas salientes (root). Por supuesto, también podemos aplicar lo mismo a las reglas de entrada, pero en este caso no hemos establecido ninguna.

Cómo simular la pérdida de paquetes

Digamos, por ejemplo, que estás desarrollando una aplicación y necesitas probar cómo manejará la pérdida de paquetes en tu red. Esto puede ser crucial para asegurar que tu aplicación puede tolerar redes mal configuradas o poco fiables. Aquí hay dos comandos tc de ejemplo para simular la pérdida de paquetes:

sudo tc qdisc add dev ens5 root netem loss 0.1%

El comando anterior dejará caer paquetes aleatoriamente, con una probabilidad del 0,1%.

¿Qué pasa si queremos una probabilidad de pérdida de paquetes del 0,3% con una decisión de caída del 25% para los paquetes anteriores? Ese comando sería

sudo tc qdisc add dev ens5 root netem loss 0.3% 25%

Una vez establecida esta regla, inicia tu aplicación y comprueba si funciona correctamente cuando la red no está en condiciones. Si la aplicación falla, tienes más trabajo que hacer.

Si esa regla de pérdida de paquetes en particular no es suficiente para ti, puedes emplear el esquema Gilbert-Elliot, que define dos estados:

• Bueno (o drop Gap)
• Malo (o drop Burst)

Este esquema ofrece un modelo más cercano a las deficiencias de la red, en lugar de la simple pérdida de paquetes. Para utilizar el esquema Gilbert-Elliot, el comando sería algo parecido a esto:

sudo tc qdisc add dev ens5 root netem loss gemodel 1% 10% 70% 0.1%

Ahora, cuando ejecutamos nuestra prueba de ping, deberíamos ver números similares a los de antes, pero la pérdida de paquetes debería ser más realista para sus propósitos de prueba.

Limpieza de tc

Los ajustes de salida, entrada o ambos pueden sustituirse por su versión mejorada a continuación. primero deben limpiarse los ajustes anteriores.

Para eliminar los ajustes tc aplicados anteriormente, basta con borrar los qdiscs root e ingress. Todo lo que esté por debajo de ellos, incluidos los filtros, también se eliminará. El qdisc raíz de interfaz predeterminado con el manejador reservado 0: se volverá a colocar.

tc qdisc del dev eth0 root

tc qdisc del dev eth0 ingress

Script TC-Limit (limit-tc.sh)

#!/bin/bash  

# Full path to tc binary 

TC=$(which tc)

#

# NETWORK CONFIGURATION

# interface - name of your interface device

# interface_speed - speed in mbit of your $interface

# ip - IP address of your server, change this if you don't want to use

#      the default catch all filters.

#

interface=eth0

interface_speed=100mbit

ip=4.1.2.3 # The IP address bound to the interface

# Define the upload and download speed limit, follow units can be 

# passed as a parameter:

# kbps: Kilobytes per second

# mbps: Megabytes per second

# kbit: kilobits per second

# mbit: megabits per second

# bps: Bytes per second

download_limit=512kbit

upload_limit=10mbit    

# Filter options for limiting the intended interface.

FILTER="$TC filter add dev $interface protocol ip parent 1: prio 1 u32"

#

# This function starts the TC rules and limits the upload and download speed

# per already configured earlier.

# 

function start_tc { 

    tc qdisc show dev $interface | grep -q "qdisc pfifo_fast 0"  

    [ "$?" -gt "0" ] && tc qdisc del dev $interface root; sleep 1  

    # start the tc configuration

    $TC qdisc add dev $interface root handle 1: htb default 30

    $TC class add dev $interface parent 1: classid 1:1 htb rate $interface_speed burst 15k

    $TC class add dev $interface parent 1:1 classid 1:10 htb rate $download_limit burst 15k

    $TC class add dev $interface parent 1:1 classid 1:20 htb rate $upload_limit burst 15k

    $TC qdisc add dev $interface parent 1:10 handle 10: sfq perturb 10

    $TC qdisc add dev $interface parent 1:20 handle 20: sfq perturb 10

    # Apply the filter rules

    

    # Catch-all IP rules, which will set global limit on the server

    # for all IP addresses on the server. 

    $FILTER match ip dst 0.0.0.0/0 flowid 1:10

    $FILTER match ip src 0.0.0.0/0 flowid 1:20

    # If you want to limit the upload/download limit based on specific IP address

    # you can comment the above catch-all filter and uncomment these:

    #

    # $FILTER match ip dst $ip/32 flowid 1:10

    # $FILTER match ip src $ip/32 flowid 1:20

}

#

# Removes the network speed limiting and restores the default TC configuration

#

function stop_tc {

    tc qdisc show dev $interface | grep -q "qdisc pfifo_fast 0"

    [ "$?" -gt "0" ] && tc qdisc del dev $interface root

}

function show_status {

        $TC -s qdisc ls dev $interface

}

#

# Display help 

#

function display_help {

        echo "Usage: tc [OPTION]"

        echo -e "\tstart - Apply the tc limit"

        echo -e "\tstop - Remove the tc limit"

        echo -e "\tstatus - Show status"

}

# Start

if [ -z "$1" ]; then

        display_help

elif [ "$1" == "start" ]; then

        start_tc

elif [ "$1" == "stop" ]; then

        stop_tc

elif [ "$1" == "status" ]; then

        show_status

fi

Wondershaper

Esta es la herramienta más fácil que puedes encontrar para limitar el ancho de banda de una interfaz en particular. Todo lo que se necesitas es

$ sudo wondershaper  -a {interfaz} -u {upload} -d {download}

el {download} y {upload}

 son el ancho de banda en kilobits. Así, por ejemplo, si deseas limitar el 

ancho de banda de la interfaz eth1 a 256kbps uplink y 128kbps downlink,

$ sudo wondershaper eth1 256 128

Para borrar el límite,

$ sudo wondershaper clear eth1

Trickle

Por último, pero no menos importante, podemos utilizar una herramienta ligera para estrangular el ancho de banda de la red llamada trickle. Trickle modela el ancho de banda de las aplicaciones manipulando el tráfico de datos a través de sockets. También nos permite gestionar el ancho de banda sobre aplicaciones y procesos, no sobre interfaces como otras.

A diferencia de wondershaper, que limita el ancho de banda a una interfaz entera, 

trickle es una herramienta de limitación de ancho de banda en el espacio de usuario. La sintaxis es,

$ trickle -u {up} -d {down} {program}

Tanto {up} como {down} y ancho de banda en KB/s. Ahora si lo invocas como,

$ trickle -u 8 -d 8 firefox

 Firefox, limitando el ancho de banda a 8KB/s. Esto es muy  útil especialmente si usted es un desarrollador web y desea probar su  aplicación bajo varias condiciones de ancho de banda.

Además, también puedes ejecutar trickle como demonio (trickled) que puede limitar el ancho de banda a varios programas.

Control del ancho de banda con Trickle

Usar trickle para controlar el ancho de banda es bastante intuitivo, como wondershaper. Lancemos un navegador web con ancho de banda limitado:

$ trickle -s -d 2048 -u 512 firefox

El comando anterior lanzará el navegador web Firefox con aproximadamente 2 MB/s de velocidad de descarga (-d 2048) y 0,5 MB/s de velocidad de subida (-u 512) utilizando el modo independiente (-s) no demonio de Trickle. Además, ten en cuenta que, a diferencia de wondershaper, no necesitamos privilegios sudo.

Limitar el ancho de banda en un comando

Además, podemos hacer que trickle limite también el ancho de banda en un comando:

$ trickle -s -d 512 wget https://releases.ubuntu.com/20.04.4/ubuntu-20.04.4-desktop-amd64.iso

Lanzamiento de un intérprete de comandos Bash con la configuración de ancho de banda deseada

Convenientemente, podemos lanzar un shell Bash completo con las limitaciones de ancho de banda especificadas:

$ trickle -s -d 1000 -u 50 bash

En ella, cada comando tendrá la cantidad de ancho de banda especificada. Para eliminar las limitaciones, podemos simplemente salir de ese intérprete de comandos Bash.