Cuando un proceso dentro de un contenedor envía un paquete de red hacia el exterior, en el kernel de Linux se pone en marcha una larga cadena burocrática. Para tu código la llamada parece instantánea, pero entre bastidores el arreglo de bytes pasa por asignación de memoria, copia de búferes, tablas de enrutamiento, reglas de firewall y el sistema de seguimiento de conexiones. En un servidor común, esta cocina interna pasa desapercibida. Pero cuando la velocidad de la tarjeta de red sube a 100 o 200 Gbps y se cuentan decenas de millones de paquetes por segundo, la tubería estándar del kernel se convierte en el principal cuello de botella de la infraestructura.
Con este muro se topó el ingeniero principal de Loophole Labs, Alex Sørlie, al construir la plataforma de migración en vivo Architect. Durante el traslado de un contenedor en ejecución entre nubes, hay que interceptar cada paquete, modificarlo, encapsularlo en un túnel y redirigirlo al nuevo nodo sin cortar la conexión. En Linux, para procesar tráfico a la velocidad del enlace físico existe la tecnología XDP (eXpress Data Path, la ruta rápida de datos basada en eBPF). El detalle es que, por arquitectura del kernel, XDP solo funciona en el tráfico entrante, mientras que para los paquetes salientes de un contenedor no está disponible. ¿Pero es tan infranqueable esta limitación si miramos cómo funcionan las interfaces virtuales?
Por qué Traffic Control se ahoga a 21.1 Gbps y cuánto cuesta un búfer del kernel
Seguramente te preguntarás: ¿para qué forzar XDP en la salida si Linux ya tiene un mecanismo nativo para interceptar paquetes salientes mediante eBPF: el subsistema Traffic Control (TC)? Precisamente en los hooks de TC se apoyan los plugins de red de Kubernetes para filtrar el tráfico saliente. Ya hablamos de la ruta básica de un paquete en el clúster en el análisis sobre la arquitectura de redes de Kubernetes desde la pila de red de Linux hasta eBPF. Frente a las tablas de iptables, que en las pruebas del equipo sobre un enlace de 200 Gbps con MTU 1500 apenas entregaron 15.6 Gbps con picos de latencia por la disputa de CPU, interceptar mediante TC parece un avance.
Sin embargo, en la práctica el rendimiento de Traffic Control choca contra un techo: en un banco de pruebas de 200 Gbps entre dos máquinas AWS EC2, un programa en TC solo logró mover 21.1 Gbps en tráfico saliente y 23 Gbps en entrante. Para la migración en vivo de nodos con alta carga, esto supone perder casi el 90% de la velocidad del enlace.
La razón está en el momento y los datos con los que trabaja TC. El hook se ejecuta tarde: después del enrutamiento, el firewall y la tabla de seguimiento de estados conntrack. Pero el golpe principal lo da la estructura struct sk_buff (el búfer de socket del kernel). Por cada trama, el kernel reserva este pesado objeto en memoria y copia allí los metadatos. Imagina un servicio de mensajería donde cada carta, antes de enviarse, se mete en una caja de madera, se llena de etiquetas para todos los departamentos de clasificación y recién en la puerta del almacén te piden permiso para salir. Con millones de paquetes por segundo, las asignaciones de sk_buff queman ciclos de CPU incluso antes de que arranque el programa eBPF.
Cómo funciona el sprint de XDP en el driver de red y por qué tiene cerrada la salida
A diferencia del búfer de socket, XDP actúa como un control de acceso instantáneo en la puerta misma de la tarjeta de red. Cuando un paquete llega por el cable, el adaptador escribe los bytes mediante acceso directo a memoria (DMA) en el búfer circular de recepción (RX ring buffer) y lanza una interrupción al driver. El driver mueve el puntero del paquete a la cola de recepción (RX queue), y justo ahí se ejecuta el programa XDP. La estructura sk_buff ni siquiera existe todavía, el kernel de Linux aún no sabe que llegó una trama y el procesamiento se hace sobre bytes crudos en modo de copia cero (zero-copy).
¿Por qué entonces este mecanismo veloz funciona solo de entrada? Al revisar el código fuente del kernel de Linux, los ingenieros notaron un detalle clave: el kernel ni siquiera marca los paquetes como «entrantes». El único detonante para invocar XDP es el hecho mismo de que la trama caiga en la cola de recepción RX. Cuando una aplicación dentro del contenedor envía datos hacia fuera, el paquete cae directo en la cola de transmisión (TX queue). La cola RX no se usa, así que el driver simplemente no tiene un punto donde lanzar XDP.
Giro por el túnel espejo veth y el precio de saltarse el kernel por completo
Si el kernel identifica el tráfico entrante únicamente por su llegada a la cola RX, basta con hacer que el paquete saliente del contenedor se haga pasar por entrante para el host. Y la herramienta adecuada ya viene integrada en cualquier servidor con Docker, containerd o Kubernetes.
El espacio de nombres de red (network namespace) de cada contenedor se conecta con el host mediante un par de interfaces virtuales veth (Virtual Ethernet) que funciona como un tubo directo. Un extremo (veth0-A) vive dentro del contenedor y el otro (veth1-A), en el host. Cuando el contenedor envía un paquete a la cola TX de su interfaz veth0-A, el driver simplemente pasa el puntero de memoria del paquete a la cola de recepción RX de su interfaz pareja veth1-A.
¡Desde el punto de vista del host, el paquete acaba de llegar a la cola RX! Como desde Linux 4.19 el driver veth soporta XDP nativo, colgamos el programa XDP en veth1-A, modificamos las cabeceras y mediante el veredicto XDP_REDIRECT enviamos la trama directo a la cola TX de la tarjeta física eth0, saltándonos la pila de red de Linux.
Eso sí, en la primera prueba en el laboratorio los paquetes desaparecieron en el camino: una captura con tcpdump en el switch mostró que el conmutador descartaba las tramas en silencio. Al saltarte la pila de red del kernel, te toca hacer su trabajo a mano: recalcular las sumas de verificación tras cambiar las direcciones IP (NAT) y resolver la dirección MAC del destino por ARP. Para no recalcular la suma sobre todo el búfer y colocar por cuenta propia la MAC del siguiente salto, en el programa XDP se añaden suma incremental y una tabla ARP propia en un mapa eBPF:
static __always_inline __u16 csum16_add(__u16 csum, __u16 addend) {
csum += addend;
return csum + (csum < addend);
}
struct arp_entry { __u8 mac[ETH_ALEN]; };
struct {
__uint(type, BPF_MAP_TYPE_HASH);
__type(key, __be32);
__type(value, struct arp_entry);
__uint(max_entries, 65535);
} arp_table SEC(".maps");
csum = csum16_add(~tcp->check, ~old_ip_high);
csum = csum16_add(csum, ~old_ip_low);
csum = csum16_add(csum, new_ip_high);
csum = csum16_add(csum, new_ip_low);
tcp->check = ~csum;
struct arp_entry *entry = bpf_map_lookup_elem(&arp_table, &dest_ip);
if (entry) memcpy(eth->h_dest, entry->mac, ETH_ALEN);
Veamos cómo este código rescata los paquetes en tiempo de ejecución. La función csum16_add suma palabras de 16 bits teniendo en cuenta el acarreo csum < addend. En lugar de leer todo el paquete, tomamos la suma anterior invertida ~tcp->check, restamos las mitades de la IP antigua (~old_ip_high, ~old_ip_low), sumamos la nueva dirección y guardamos el resultado invertido en tcp->check en un par de ciclos de CPU. Por su parte, la tabla hash arp_table (BPF_MAP_TYPE_HASH de 65,535 entradas) asocia la dirección IP __be32 con la estructura arp_entry: bpf_map_lookup_elem busca la entrada para dest_ip y memcpy copia la dirección física entry->mac en la cabecera de la trama eth->h_dest. Así el switch recibe una trama Ethernet válida sin tocar el kernel de Linux.
Contraste de cuatro modos en el banco de 200 Gbps y límites en Kubernetes
Para probar la solución en condiciones reales, los autores ejecutaron iPerf3 en contenedores estándar con pares veth entre dos instancias AWS EC2 con red de 200 Gbps y MTU 1500. Lo único que cambiaba era el mecanismo para pasar el paquete de veth al adaptador físico:
| Modo en la salida del contenedor | Velocidad (MTU 1500) | Qué ocurre bajo el capó |
|---|---|---|
iptables (PREROUTING) | 15.6 Gbps | Paso por el kernel, NAT y conntrack; disputa de CPU y picos de latencia |
| Traffic Control (TC egress) | 21.1 Gbps | Ejecución tras reservar struct sk_buff y subsistemas base de la pila |
Generic XDP en veth | Menor a 21.1 Gbps | Ejecución por software tras asignar sk_buff, sin las optimizaciones de TC |
Native XDP en veth | 194 Gbps | Interceptación en cola RX antes del kernel; 12.4× frente a iptables y 9.2× frente a TC |
Resulta reveladora la trampa del modo Generic XDP: terminó siendo más lento que Traffic Control porque se ejecuta en modo de prueba después de crear sk_buff, perdiendo la ventaja de la interceptación temprana. Solo al activar el driver nativo (xdpdrv mediante ip link set dev veth1 xdpgeneric off && ip link set dev veth1 xdpdrv object xdp_egress.o section xdp) lograron exprimir 194 Gbps con una variación mínima de latencia.
Para microservicios de red, sistemas de migración en vivo y entornos Docker (el equipo prepara un plugin de red abierto para reemplazar el puente estándar de Docker), esta técnica multiplica la velocidad de red sin parchear el kernel. Sin embargo, en clústeres Kubernetes, saltarse la pila por completo con XDP_REDIRECT implica que los paquetes desaparecen del radar del módulo conntrack. Si en los CNI clásicos los ingenieros luchan contra el lastre de tablas de sesiones infladas (lo analizamos en el artículo sobre cómo eliminar latencias de 80 segundos en Kubernetes causadas por la tabla conntrack en Cilium CNI), al pasar a XDP puro tendrás que encargarte por tu cuenta del seguimiento de estados de conexión y de actualizar la tabla ARP en segundo plano con un demonio en espacio de usuario.
La conclusión práctica es directa: la restricción de XDP al tráfico entrante era solo una consecuencia de cómo el driver trabaja con la cola de recepción, y un par estándar de interfaces veth permite convertir la salida del contenedor en entrada del host y acelerar el envío de paquetes de 21.1 a 194 Gbps sobre un kernel Linux normal.


