Limitación de Ancho de Banda con tc (Control de Tráfico): Guía Completa

Introducción

Control de Tráfico (tc) es el poderoso framework de Linux para gestionar, dar forma y controlar el ancho de banda de red a nivel del kernel. Como parte de la pila de redes de Linux, tc proporciona mecanismos sofisticados para implementación de Calidad de Servicio (QoS), limitación de ancho de banda, priorización de tráfico y simulación de red. Ya sea que necesites evitar que una sola aplicación consuma todo el ancho de banda disponible, asegurar que las llamadas VoIP reciban prioridad sobre descargas masivas, simular condiciones de red para pruebas o implementar distribución justa de ancho de banda entre múltiples usuarios, tc ofrece las herramientas y flexibilidad requeridas para gestión completa de tráfico.

A diferencia de la simple limitación de ancho de banda a nivel de aplicación, tc opera en la capa de red, haciéndolo transparente a las aplicaciones y universalmente aplicable a todo el tráfico de red. Puede clasificar paquetes basándose en varios criterios (IP origen/destino, puerto, protocolo, marcas de paquetes), asignarlos a diferentes clases con distintas asignaciones de ancho de banda y aplicar disciplinas de encolamiento sofisticadas que determinan cómo se transmiten los paquetes. Este control granular hace que tc sea esencial para gestionar enlaces de red congestionados, implementar acuerdos de nivel de servicio (SLA), optimizar el rendimiento de la red y crear entornos de prueba realistas.

Esta guía completa cubre tc desde conceptos fundamentales hasta configuraciones avanzadas, incluyendo disciplinas de encolamiento (qdiscs), modelado de tráfico basado en clases, mecanismos de filtrado, escenarios prácticos de limitación de ancho de banda, monitoreo de rendimiento y resolución de problemas. Ya sea que estés gestionando el uso de red de un solo servidor o implementando políticas QoS complejas en infraestructura, dominar tc proporciona las capacidades necesarias para gestión efectiva de tráfico.

Entendiendo los Conceptos de Control de Tráfico

Componentes de tc

1. Disciplinas de Encolamiento (qdiscs)

Algoritmos que determinan cómo se encolan y desencolan los paquetes:

  • Qdiscs sin clases - Simples, sin diferenciación de tráfico

    • pfifo_fast (predeterminado)
    • TBF (Token Bucket Filter)
    • SFQ (Stochastic Fairness Queueing)

  • Qdiscs con clases - Soportan clases de tráfico

    • HTB (Hierarchical Token Bucket)
    • CBQ (Class Based Queueing)
    • PRIO (Priority qdisc)
    • HFSC (Hierarchical Fair Service Curve)

2. Clases

Categorías dentro de qdiscs con clases para diferenciación de tráfico:

  • Estructura jerárquica
  • Garantías y límites de ancho de banda
  • Niveles de prioridad

3. Filtros

Reglas para clasificar paquetes en clases:

  • Basados en direcciones IP, puertos, protocolos
  • Usando marcas de firewall (fwmark)
  • Clasificador u32 para coincidencia de encabezados

4. Acciones

Operaciones realizadas en paquetes:

  • Aceptar, descartar, redirigir
  • Marcar paquetes para procesamiento posterior

Cómo Funciona tc

Interfaz de Red → qdisc → clases → filtros → salida
                      ↓
                   encolamiento

Flujo de paquetes:

  1. Paquete llega a la interfaz de red
  2. Qdisc raíz recibe el paquete
  3. Filtros clasifican el paquete en la clase apropiada
  4. Qdisc de la clase encola el paquete según sus reglas
  5. Paquete transmitido cuando hay ancho de banda disponible

Egreso vs Ingreso

Egreso (salida):

  • Capacidades completas de tc disponibles
  • Puede dar forma, priorizar y encolar tráfico
  • Caso de uso más común

Ingreso (entrada):

  • Capacidades limitadas de modelado
  • Típicamente usado para policía (descartar tráfico excesivo)
  • No puede encolar paquetes efectivamente

Prerequisitos

Antes de implementar control de tráfico, asegúrate de tener:

  • Sistema Linux con kernel 2.6+ (3.x+ recomendado)
  • Privilegios root o sudo
  • Paquete iproute2 instalado (proporciona comando tc)
  • Comprensión básica de conceptos de redes
  • Conocimiento de tu topología de red y límites de ancho de banda
  • Entorno de pruebas antes del despliegue en producción

Instalación

Debian/Ubuntu:

sudo apt update
sudo apt install iproute2 -y

RHEL/CentOS/Rocky Linux:

sudo dnf install iproute-tc -y

Verificar instalación:

tc -V

Identificando Interfaces de Red

# List network interfaces
ip link show

# Check interface speed
ethtool eth0 | grep Speed

# Current qdisc on interface
tc qdisc show dev eth0

Comandos Básicos de tc

Viendo Configuración

# Show qdiscs on all interfaces
tc qdisc show

# Show qdiscs on specific interface
tc qdisc show dev eth0

# Show classes
tc class show dev eth0

# Show filters
tc filter show dev eth0

# Show statistics
tc -s qdisc show dev eth0
tc -s class show dev eth0

Gestionando Qdiscs

# Add qdisc to interface
sudo tc qdisc add dev eth0 root handle 1: htb default 10

# Replace existing qdisc
sudo tc qdisc replace dev eth0 root handle 1: htb default 10

# Delete qdisc (removes all classes and filters)
sudo tc qdisc del dev eth0 root

# Change qdisc parameters
sudo tc qdisc change dev eth0 root handle 1: htb default 20

Gestionando Clases

# Add class
sudo tc class add dev eth0 parent 1: classid 1:1 htb rate 10mbit

# Change class parameters
sudo tc class change dev eth0 parent 1: classid 1:1 htb rate 20mbit

# Delete class
sudo tc class del dev eth0 classid 1:1

Gestionando Filtros

# Add filter
sudo tc filter add dev eth0 protocol ip parent 1:0 prio 1 u32 match ip dst 192.168.1.100 flowid 1:10

# Delete filter
sudo tc filter del dev eth0 parent 1:0 prio 1

# Delete all filters
sudo tc filter del dev eth0

Limitación Simple de Ancho de Banda

Limitar Ancho de Banda Total de Interfaz (TBF)

Token Bucket Filter proporciona limitación simple de tasa:

# Limit eth0 to 10 Mbit/s
sudo tc qdisc add dev eth0 root tbf rate 10mbit burst 32kbit latency 400ms

# Parameters:
# rate - sustained bandwidth limit
# burst - maximum burst size
# latency - maximum packet delay

Entendiendo parámetros TBF:

  • rate: Ancho de banda objetivo (ej., 10mbit, 1gbit)
  • burst: Tamaño del bucket en bytes (permite ráfagas cortas sobre la tasa)
  • latency: Tiempo máximo que un paquete puede esperar en cola

Ejemplo con diferentes tasas:

# 1 Mbit/s limit
sudo tc qdisc add dev eth0 root tbf rate 1mbit burst 32kbit latency 400ms

# 100 Mbit/s limit
sudo tc qdisc add dev eth0 root tbf rate 100mbit burst 128kbit latency 50ms

# Calculate burst size:
# burst = rate / Hz (where Hz is typically 250)
# For 10mbit: burst = 10000000 / 8 / 250 = 5000 bytes ≈ 5kbytes

Eliminar Límite de Ancho de Banda

# Delete qdisc to remove limit
sudo tc qdisc del dev eth0 root

# Verify removal
tc qdisc show dev eth0
# Should show default pfifo_fast

HTB (Hierarchical Token Bucket)

HTB es el método de modelado de tráfico más popular y flexible, ofreciendo:

  • Garantías y límites de ancho de banda
  • Estructura jerárquica de clases
  • Préstamo de clases padre
  • Niveles de prioridad

Configuración Básica de HTB

#!/bin/bash
# Simple HTB setup limiting total bandwidth to 10 Mbit/s

INTERFACE="eth0"
TOTAL_BANDWIDTH="10mbit"

# Delete existing qdisc
tc qdisc del dev $INTERFACE root 2>/dev/null

# Add root HTB qdisc
tc qdisc add dev $INTERFACE root handle 1: htb default 10

# Add root class with total bandwidth
tc class add dev $INTERFACE parent 1: classid 1:1 htb rate $TOTAL_BANDWIDTH

# Add default class
tc class add dev $INTERFACE parent 1:1 classid 1:10 htb rate $TOTAL_BANDWIDTH

echo "Bandwidth limited to $TOTAL_BANDWIDTH on $INTERFACE"

Configuración HTB Multi-Clase

#!/bin/bash
# HTB with traffic classes

INTERFACE="eth0"
TOTAL_BW="10mbit"

# Clear existing
tc qdisc del dev $INTERFACE root 2>/dev/null

# Root qdisc
tc qdisc add dev $INTERFACE root handle 1: htb default 30

# Root class - total bandwidth
tc class add dev $INTERFACE parent 1: classid 1:1 htb rate $TOTAL_BW

# High priority class - 5 Mbit/s guaranteed, can borrow up to 8 Mbit/s
tc class add dev $INTERFACE parent 1:1 classid 1:10 htb rate 5mbit ceil 8mbit prio 1

# Medium priority - 3 Mbit/s guaranteed
tc class add dev $INTERFACE parent 1:1 classid 1:20 htb rate 3mbit ceil 7mbit prio 2

# Low priority - 2 Mbit/s guaranteed
tc class add dev $INTERFACE parent 1:1 classid 1:30 htb rate 2mbit ceil 10mbit prio 3

# Add fair queuing to each class
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
tc qdisc add dev $INTERFACE parent 1:30 handle 30: sfq perturb 10

echo "HTB classes configured on $INTERFACE"

Parámetros de clase HTB:

  • rate: Ancho de banda garantizado
  • ceil: Ancho de banda máximo (techo)
  • prio: Nivel de prioridad (número menor = prioridad más alta)
  • burst: Tamaño de ráfaga para rate
  • cburst: Tamaño de ráfaga para ceil

Añadiendo Filtros a Clases HTB

Filtrar por puerto de destino:

# HTTP traffic to high priority class
tc filter add dev eth0 protocol ip parent 1:0 prio 1 u32 \
    match ip dport 80 0xffff flowid 1:10

# HTTPS traffic to high priority class
tc filter add dev eth0 protocol ip parent 1:0 prio 1 u32 \
    match ip dport 443 0xffff flowid 1:10

# SSH traffic to medium priority
tc filter add dev eth0 protocol ip parent 1:0 prio 2 u32 \
    match ip dport 22 0xffff flowid 1:20

Filtrar por IP de destino:

# Traffic to specific server
tc filter add dev eth0 protocol ip parent 1:0 prio 1 u32 \
    match ip dst 192.168.1.100 flowid 1:10

# Traffic to subnet
tc filter add dev eth0 protocol ip parent 1:0 prio 1 u32 \
    match ip dst 192.168.1.0/24 flowid 1:20

Filtrar por IP de origen:

# Limit specific client
tc filter add dev eth0 protocol ip parent 1:0 prio 1 u32 \
    match ip src 192.168.1.50 flowid 1:30

Filtrar por protocolo:

# ICMP traffic
tc filter add dev eth0 protocol ip parent 1:0 prio 1 u32 \
    match ip protocol 1 0xff flowid 1:20

Escenarios Prácticos de Limitación de Ancho de Banda

Escenario 1: Limitar Velocidad de Subida

#!/bin/bash
# Limit upload speed to 1 Mbit/s

INTERFACE="eth0"
UPLOAD_LIMIT="1mbit"

tc qdisc del dev $INTERFACE root 2>/dev/null
tc qdisc add dev $INTERFACE root tbf rate $UPLOAD_LIMIT burst 32kbit latency 400ms

echo "Upload limited to $UPLOAD_LIMIT on $INTERFACE"

Escenario 2: Priorizar Tráfico VoIP

#!/bin/bash
# Ensure VoIP gets priority and bandwidth

INTERFACE="eth0"
TOTAL_BW="10mbit"
VOIP_PORTS="5060:5090"  # SIP and RTP ports

tc qdisc del dev $INTERFACE root 2>/dev/null

# Root qdisc
tc qdisc add dev $INTERFACE root handle 1: htb default 20

# Root class
tc class add dev $INTERFACE parent 1: classid 1:1 htb rate $TOTAL_BW

# VoIP class - high priority, 3 Mbit/s guaranteed
tc class add dev $INTERFACE parent 1:1 classid 1:10 htb rate 3mbit ceil 5mbit prio 0

# Other traffic - lower priority
tc class add dev $INTERFACE parent 1:1 classid 1:20 htb rate 7mbit ceil 10mbit prio 5

# Add SFQ to classes
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

# Filter VoIP traffic to high priority class
tc filter add dev $INTERFACE protocol ip parent 1:0 prio 1 u32 \
    match ip dport 5060 0xffff flowid 1:10
tc filter add dev $INTERFACE protocol ip parent 1:0 prio 1 u32 \
    match ip sport 5060 0xffff flowid 1:10

echo "VoIP traffic prioritized on $INTERFACE"

Escenario 3: Distribución Justa de Ancho de Banda

#!/bin/bash
# Distribute bandwidth fairly among multiple users/IPs

INTERFACE="eth0"
TOTAL_BW="100mbit"
PER_USER_BW="10mbit"

# List of user IPs
USERS=("192.168.1.10" "192.168.1.11" "192.168.1.12" "192.168.1.13" "192.168.1.14")

tc qdisc del dev $INTERFACE root 2>/dev/null

# Root qdisc
tc qdisc add dev $INTERFACE root handle 1: htb default 99

# Root class
tc class add dev $INTERFACE parent 1: classid 1:1 htb rate $TOTAL_BW

# Create class for each user
CLASSID=10
for USER_IP in "${USERS[@]}"; do
    tc class add dev $INTERFACE parent 1:1 classid 1:$CLASSID htb \
        rate $PER_USER_BW ceil $TOTAL_BW

    # Add SFQ
    tc qdisc add dev $INTERFACE parent 1:$CLASSID handle $CLASSID: sfq perturb 10

    # Filter by source IP
    tc filter add dev $INTERFACE protocol ip parent 1:0 prio 1 u32 \
        match ip src $USER_IP flowid 1:$CLASSID

    echo "Class 1:$CLASSID created for $USER_IP with $PER_USER_BW"

    CLASSID=$((CLASSID + 1))
done

# Default class for other traffic
tc class add dev $INTERFACE parent 1:1 classid 1:99 htb rate 10mbit
tc qdisc add dev $INTERFACE parent 1:99 handle 99: sfq perturb 10

echo "Fair bandwidth distribution configured"

Escenario 4: Limitar Velocidad de Descarga (Ingreso)

#!/bin/bash
# Limit incoming traffic (download)

INTERFACE="eth0"
DOWNLOAD_LIMIT="5mbit"

# Create ifb device for ingress shaping
modprobe ifb
ip link set dev ifb0 up

# Redirect ingress to ifb0
tc qdisc del dev $INTERFACE ingress 2>/dev/null
tc qdisc add dev $INTERFACE handle ffff: ingress
tc filter add dev $INTERFACE parent ffff: protocol ip u32 match u32 0 0 \
    action mirred egress redirect dev ifb0

# Apply egress shaping on ifb0
tc qdisc del dev ifb0 root 2>/dev/null
tc qdisc add dev ifb0 root tbf rate $DOWNLOAD_LIMIT burst 32kbit latency 400ms

echo "Download limited to $DOWNLOAD_LIMIT on $INTERFACE"

Escenario 5: Simular Condiciones de Red (netem)

#!/bin/bash
# Network emulation for testing

INTERFACE="eth0"

# Add latency (100ms)
tc qdisc add dev $INTERFACE root netem delay 100ms

# Add packet loss (10%)
tc qdisc add dev $INTERFACE root netem loss 10%

# Add latency with jitter
tc qdisc add dev $INTERFACE root netem delay 100ms 20ms

# Combination: latency, jitter, and packet loss
tc qdisc add dev $INTERFACE root netem delay 100ms 20ms loss 5%

# Bandwidth limitation with netem
tc qdisc add dev $INTERFACE root netem rate 1mbit

# Packet corruption (1%)
tc qdisc add dev $INTERFACE root netem corrupt 1%

# Packet duplication (0.5%)
tc qdisc add dev $INTERFACE root netem duplicate 0.5%

# Remove netem
tc qdisc del dev $INTERFACE root

Escenario 6: Limitación de Tasa por Aplicación

#!/bin/bash
# Limit specific application using iptables marks

INTERFACE="eth0"

# Mark packets from specific application
# Example: Mark traffic from Apache (assuming it uses specific source port range)
iptables -t mangle -A OUTPUT -p tcp --sport 80 -j MARK --set-mark 1
iptables -t mangle -A OUTPUT -p tcp --sport 443 -j MARK --set-mark 1

# Configure tc to use marks
tc qdisc del dev $INTERFACE root 2>/dev/null
tc qdisc add dev $INTERFACE root handle 1: htb default 10

tc class add dev $INTERFACE parent 1: classid 1:1 htb rate 100mbit
tc class add dev $INTERFACE parent 1:1 classid 1:10 htb rate 100mbit
tc class add dev $INTERFACE parent 1:1 classid 1:20 htb rate 10mbit

# Filter marked packets to limited class
tc filter add dev $INTERFACE parent 1:0 protocol ip prio 1 handle 1 fw flowid 1:20

echo "Application bandwidth limited via firewall marks"

Monitoreo y Estadísticas

Ver Estadísticas

# Detailed statistics
tc -s qdisc show dev eth0

# Class statistics
tc -s class show dev eth0

# Filter statistics
tc -s filter show dev eth0

# Continuous monitoring
watch -n 1 'tc -s qdisc show dev eth0'

Entendiendo Salida de Estadísticas

$ tc -s class show dev eth0

class htb 1:10 parent 1:1 prio 1 rate 5Mbit ceil 8Mbit burst 1600b cburst 1600b
 Sent 1048576 bytes 1024 pkt (dropped 0, overlimits 0 requeues 0)
 rate 2Mbit 256pps backlog 0b 0p requeues 0
 lended: 512 borrowed: 256 giants: 0
 tokens: 204800 ctokens: 204800

Métricas clave:

  • Sent: Total de bytes y paquetes transmitidos
  • dropped: Paquetes descartados por desbordamiento de cola
  • overlimits: Veces que la clase excedió la tasa
  • rate: Tasa de transmisión actual
  • backlog: Bytes y paquetes encolados
  • lended: Paquetes enviados a tasa garantizada
  • borrowed: Paquetes enviados usando ancho de banda prestado

Graficando Estadísticas

#!/bin/bash
# Collect bandwidth statistics

INTERFACE="eth0"
LOG_FILE="/var/log/tc-stats.log"

while true; do
    TIMESTAMP=$(date +%s)
    STATS=$(tc -s class show dev $INTERFACE | grep "class htb 1:10" -A 3)
    RATE=$(echo "$STATS" | grep "rate" | awk '{print $2}')

    echo "$TIMESTAMP $RATE" >> $LOG_FILE

    sleep 5
done

Usar gnuplot o herramientas similares para visualizar:

gnuplot << EOF
set terminal png size 800,600
set output 'bandwidth.png'
set xlabel 'Time'
set ylabel 'Bandwidth (Mbit/s)'
plot '$LOG_FILE' using 1:2 with lines title 'Bandwidth'
EOF

Resolución de Problemas

Problemas Comunes

Comandos tc no funcionan:

# Check if iproute2 is installed
which tc

# Install if missing
sudo apt install iproute2  # Debian/Ubuntu
sudo dnf install iproute-tc  # RHEL/CentOS

Cambios no tienen efecto:

# Delete existing qdisc first
sudo tc qdisc del dev eth0 root

# Then add new configuration
sudo tc qdisc add dev eth0 root htb default 10

No se puede eliminar qdisc:

# Error: RTNETLINK answers: No such file or directory

# Check if qdisc exists
tc qdisc show dev eth0

# Try deleting ingress separately
tc qdisc del dev eth0 ingress
tc qdisc del dev eth0 root

Límite de ancho de banda no funciona:

# Verify qdisc is applied
tc qdisc show dev eth0

# Check class configuration
tc class show dev eth0

# Verify filters
tc filter show dev eth0

# Test with iperf
iperf3 -s  # On remote server
iperf3 -c server-ip -t 30  # On local machine

Alta caída de paquetes:

# Check statistics
tc -s qdisc show dev eth0

# Increase queue length
tc qdisc change dev eth0 root htb default 10 r2q 1

# Adjust burst size
tc class change dev eth0 parent 1:1 classid 1:10 htb rate 10mbit burst 15k

Depuración

Salida detallada:

# Use verbose mode (not available in tc, use strace)
strace tc qdisc add dev eth0 root htb default 10 2>&1 | less

Probar configuración:

#!/bin/bash
# Test bandwidth limit

INTERFACE="eth0"
LIMIT="10mbit"

# Apply limit
tc qdisc add dev $INTERFACE root tbf rate $LIMIT burst 32kbit latency 400ms

# Test with curl
echo "Testing download speed..."
time curl -o /dev/null http://speedtest.tele2.net/100MB.zip

# Remove limit
tc qdisc del dev $INTERFACE root

echo "Testing without limit..."
time curl -o /dev/null http://speedtest.tele2.net/100MB.zip

Temas Avanzados

Combinando tc con iptables

# Mark packets with iptables
iptables -t mangle -A POSTROUTING -p tcp --dport 80 -j MARK --set-mark 1
iptables -t mangle -A POSTROUTING -p tcp --dport 443 -j MARK --set-mark 2

# Use marks in tc filters
tc qdisc add dev eth0 root handle 1: htb default 30

tc class add dev eth0 parent 1: classid 1:1 htb rate 100mbit
tc class add dev eth0 parent 1:1 classid 1:10 htb rate 50mbit
tc class add dev eth0 parent 1:1 classid 1:20 htb rate 30mbit
tc class add dev eth0 parent 1:1 classid 1:30 htb rate 20mbit

tc filter add dev eth0 parent 1: protocol ip prio 1 handle 1 fw flowid 1:10
tc filter add dev eth0 parent 1: protocol ip prio 1 handle 2 fw flowid 1:20

HFSC (Hierarchical Fair Service Curve)

# More precise latency control than HTB

tc qdisc add dev eth0 root handle 1: hfsc default 10

# Real-time service curve for VoIP
tc class add dev eth0 parent 1: classid 1:10 hfsc sc rate 2mbit ul rate 5mbit

# Link-sharing service curve for bulk traffic
tc class add dev eth0 parent 1: classid 1:20 hfsc ls rate 1mbit ul rate 10mbit

CBQ (Class Based Queueing)

# Legacy alternative to HTB

tc qdisc add dev eth0 root handle 1: cbq bandwidth 100mbit avpkt 1000 cell 8

tc class add dev eth0 parent 1: classid 1:1 cbq bandwidth 100mbit \
    rate 10mbit weight 1mbit prio 5 allot 1514 cell 8 maxburst 20 avpkt 1000

Persistencia

Hacer la Configuración Persistente

Método de servicio systemd:

# Create tc configuration script
sudo nano /usr/local/bin/tc-setup.sh

#!/bin/bash
# /usr/local/bin/tc-setup.sh

INTERFACE="eth0"

tc qdisc del dev $INTERFACE root 2>/dev/null

tc qdisc add dev $INTERFACE root handle 1: htb default 10
tc class add dev $INTERFACE parent 1: classid 1:1 htb rate 100mbit
tc class add dev $INTERFACE parent 1:1 classid 1:10 htb rate 100mbit

# Add more configuration...

# Make executable
sudo chmod +x /usr/local/bin/tc-setup.sh

# Create systemd service
sudo nano /etc/systemd/system/tc-setup.service

[Unit]
Description=Traffic Control Setup
After=network.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/tc-setup.sh
RemainAfterExit=yes

[Install]
WantedBy=multi-user.target

# Enable and start service
sudo systemctl daemon-reload
sudo systemctl enable tc-setup.service
sudo systemctl start tc-setup.service

Método de interfaz de red (Debian/Ubuntu):

# Add to /etc/network/interfaces

auto eth0
iface eth0 inet static
    address 192.168.1.100
    netmask 255.255.255.0
    gateway 192.168.1.1
    post-up /usr/local/bin/tc-setup.sh
    pre-down tc qdisc del dev eth0 root

Mejores Prácticas

1. Probar Antes de Producción

# Test in lab environment
# Verify bandwidth limits work as expected
# Monitor for packet drops and latency issues

2. Empezar Simple

# Begin with basic TBF before complex HTB hierarchies
tc qdisc add dev eth0 root tbf rate 10mbit burst 32kbit latency 400ms

# Gradually add complexity as needed

3. Monitorear Estadísticas

# Regularly check for drops and overlimits
tc -s class show dev eth0

# Adjust burst sizes if seeing drops

4. Documentar Configuración

# Comment scripts thoroughly
# Maintain network diagrams with bandwidth allocations
# Document reasoning behind class priorities

5. Planificar para Uso Pico

# Don't allocate 100% of bandwidth
# Leave headroom for overhead and bursts
# If link is 100mbit, limit to 95mbit total

6. Usar Tamaños de Ráfaga Apropiados

# Calculate burst:
# burst = rate / HZ
# where HZ is typically 250 on Linux

# For 10mbit rate:
# burst = 10,000,000 / 8 / 250 = 5,000 bytes

tc class add dev eth0 parent 1:1 classid 1:10 htb rate 10mbit burst 5kb

7. Priorizar Tráfico Interactivo

# SSH, DNS, ICMP should get high priority
# Bulk transfers (backup, downloads) lower priority

Conclusión

Control de Tráfico (tc) proporciona capacidades completas de gestión de ancho de banda esenciales para optimizar el rendimiento de la red, implementar políticas de Calidad de Servicio y asegurar distribución justa de recursos. Ya sea limitando ancho de banda para aplicaciones específicas, priorizando tráfico sensible al tiempo como VoIP, o simulando condiciones de red para pruebas, tc ofrece el control granular necesario para gestión efectiva de tráfico en sistemas Linux.

Puntos clave:

  • HTB es el qdisc más flexible y ampliamente usado para modelado de tráfico
  • Filtros clasifican paquetes en clases apropiadas
  • Clases definen garantías y límites de ancho de banda
  • SFQ proporciona equidad dentro de clases
  • netem permite simulación de condiciones de red para pruebas
  • Persistencia requiere scripting y configuración de servicios
  • Monitoreo asegura que las políticas funcionen como se pretende

Domina tc para ganar capacidades poderosas de gestión de tráfico, optimizar la utilización de recursos de red, implementar políticas QoS sofisticadas y crear entornos de prueba realistas. Las habilidades desarrolladas a través de tc aplican en diversos escenarios desde gestión de ancho de banda de un solo servidor hasta optimización compleja de redes empresariales.

Para escenarios avanzados, explora integración con políticas de enrutamiento, combinando tc con nftables para marcado de paquetes, e implementando asignación dinámica de ancho de banda basada en condiciones de red usando scripts automatizados y herramientas de monitoreo.