eBPF en producción: tracing de syscalls con bpftrace para diagnosticar latencia
En el mundo de la administración de sistemas, la latencia es el enemigo silencioso. Un servicio puede estar "funcionando" (procesos vivos, puertos abiertos) pero ofrecer una experiencia pésima al usuario final. Las herramientas tradicionales como strace o perf a menudo resultan invasivas: strace puede ralentizar la aplicación hasta en un orden de magnitud, y perf requiere permisos especiales y configuraciones complejas. Aquí es donde entra eBPF (Extended Berkeley Packet Filter), una tecnología que permite ejecutar sandboxes de código dentro del kernel de Linux de forma segura y eficiente. En este artículo exploraremos cómo usar bpftrace, una herramienta front-end para eBPF, para diagnosticar latencias de syscalls en producción sin penalizar el rendimiento.
¿Por qué eBPF es ideal para producción?
eBPF nació como una mejora de los filtros de paquetes de red, pero evolucionó hasta convertirse en un mecanismo general de instrumentación. La clave está en que el código eBPF se compila a bytecode y se verifica en el kernel antes de ejecutarse. Esto garantiza seguridad (no puede corromper memoria) y eficiencia (se ejecuta directamente en el contexto del kernel, sin cambiar a espacio de usuario).
En términos prácticos, esto significa que podemos adjuntar "probes" (sondas) a puntos específicos del kernel, como la entrada y salida de syscalls, sin necesidad de reiniciar procesos ni modificar binarios. La sobrecarga es mínima: típicamente menos del 1% de CPU, incluso en entornos de alta concurrencia.
Primeros pasos con bpftrace
bpftrace es un lenguaje de scripting de alto nivel para eBPF. Es similar a awk pero orientado a eventos del kernel. La sintaxis básica se compone de probes (dónde escuchar), filtros (qué condiciones aplicar) y actions (qué hacer con los datos).
bpftrace -e 'tracepoint:syscalls:sys_enter_read { @[comm] = count(); }'
El comando anterior cuenta cuántas veces se ejecuta la syscall read por cada proceso (identificado por comm). Tras unos segundos, bpftrace imprime un histograma y sale. Es una prueba rápida para validar la instalación.
Para instalar bpftrace en Debian/Ubuntu:
sudo apt-get install bpftrace
En sistemas Red Hat/CentOS:
sudo yum install bpftrace
Es crucial tener una versión de kernel reciente (5.x+) y permisos de root o capabilities CAP_BPF y CAP_SYS_ADMIN.
Diagnóstico de latencia: el escenario real
Imaginemos una API REST que de repente responde lentamente (de 50ms a 2 segundos). El equipo sospecha de una base de datos, pero los logs no muestran errores. Podemos hipotetizar que el problema es una syscall bloqueante, como read sobre un socket o un archivo. Con eBPF podemos medir el tiempo que cada syscall tarda en completarse.
El enfoque es adjuntar dos probes: una en la entrada (sys_enter) que registra el timestamp y otra en la salida (sys_exit) que calcula la diferencia. bpftrace nos facilita esto con la variable elapsed y la función hist().
bpftrace -e '
tracepoint:syscalls:sys_enter_read {
@start[tid] = nsecs;
}
tracepoint:syscalls:sys_exit_read {
@duration_us = hist((nsecs - @start[tid]) / 1000);
delete(@start[tid]);
}'
Este script genera un histograma de las duraciones de read en microsegundos. Si observamos una cola larga en valores altos (p.ej. > 1ms), sabremos que la latencia proviene de operaciones de lectura bloqueantes.
Filtrar por proceso o PID
En producción, no queremos instrumentar todos los procesos. Podemos filtrar por un PID específico:
bpftrace -e '
tracepoint:syscalls:sys_enter_read /pid == 1234/ {
@start[tid] = nsecs;
}
tracepoint:syscalls:sys_exit_read /pid == 1234/ {
@duration_us = hist((nsecs - @start[tid]) / 1000);
delete(@start[tid]);
}'
El filtro /pid == 1234/ evita que se ejecuten las acciones para otros procesos, reduciendo el overhead.
Latencia de red: syscalls read y write en sockets
La latencia de red suele manifestarse en las syscalls read y write sobre descriptores de socket. Podemos distinguir si un descriptor es un socket mediante la función skb o, más simple, comprobando el tipo de archivo con fdinfo. Sin embargo, bpftrace ofrece atajos: podemos usar kprobe sobre funciones específicas del stack de red, como tcp_sendmsg o tcp_recvmsg.
bpftrace -e 'kprobe:tcp_recvmsg { @start[tid] = nsecs; }
kretprobe:tcp_recvmsg { @recv_us = hist((nsecs - @start[tid])/1000); }'
Este script mide el tiempo de la función tcp_recvmsg (recepción de datos TCP). Si los valores son altos, el problema puede estar en el kernel o en la red, no en la aplicación. Para profundizar, podemos combinar con tracepoint:sock:inet_sock_set_state para detectar retransmisiones o caídas de conexión.
Identificando syscalls más lentas por proceso
Otra técnica útil es generar un ranking de las syscalls más lentas. El siguiente script cuenta el tiempo acumulado por syscall y por proceso:
bpftrace -e '
tracepoint:raw_syscalls:sys_enter {
@start[tid] = nsecs;
}
tracepoint:raw_syscalls:sys_exit {
@syscall[comm, syscall] = sum(nsecs - @start[tid]);
delete(@start[tid]);
}
interval:s:5 {
print(@syscall, 10);
clear(@syscall);
}'
Aquí usamos raw_syscalls para capturar todas las syscalls. Al imprimir los 10 primeros (por tiempo total), identificamos qué operaciones dominan la latencia. Luego podemos investigar por qué una syscall específica, como futex, es lenta (posible contención de locks).
Contexto de usuario y stack traces
Una limitación de las tracepoints es que solo vemos la syscall, no la función del usuario que la llama. Para obtener un stack trace, podemos usar kstack o ustack en las acciones. Sin embargo, esto requiere que el binario tenga símbolos de depuración. Una alternativa es usar kprobe sobre funciones específicas del kernel que correlacionen con el estado de la aplicación.
Ejemplo: si sospechamos que la aplicación está esperando por I/O de disco, podemos rastrear blk_start_request:
bpftrace -e 'kprobe:blk_start_request { @io = hist(latency); }'
Pero cuidado: los kprobes son más frágiles que las tracepoints, ya que dependen de nombres de funciones internas del kernel que pueden cambiar entre versiones. Para entornos de producción, es recomendable usar tracepoint:block:block_rq_issue y block_rq_complete.
Monitoreo continuo y alertas
Para un diagnóstico prolongado, podemos ejecutar bpftrace como un servicio que escriba resultados en un archivo o en un endpoint de métricas (por ejemplo, Prometheus). Aunque bpftrace no está diseñado para monitoreo en tiempo real a largo plazo, podemos usar interval:s:60 para imprimir un resumen cada minuto y redirigir la salida a un archivo:
sudo bpftrace script.bt > /var/log/bpf_latency.log &
Es importante tener en cuenta que bpftrace consume recursos de CPU y memoria del kernel. En sistemas con muchos núcleos, el overhead se distribuye, pero en máquinas pequeñas puede ser notorio. Se recomienda ejecutar durante ventanas de 15-30 minutos, no de forma indefinida.
Consejos finales y mejores prácticas
- Empieza con tracepoints: son estables y seguros. Los kprobes úsalos solo si no existe una tracepoint equivalente.
- Usa filtros: limita por PID o
comentarios(0)
$ dejar comentario