🎨 Sysprovider Code
Sysprovider LogoWiki
🇪🇸Hosting español para ecommerce

Configuración de eBPF para Observabilidad en Linux

Actualizado el 8 de mayo de 2026

¡Bienvenido al futuro del diagnóstico en sistemas Linux! Si eres SysAdmin y aún no has integrado eBPF en tu stack de observabilidad Linux, estás operando con un mapa desactualizado. eBPF (extended Berkeley Packet Filter) no es una moda pasajera; es la tecnología que, para SysAdmin 2025, se ha convertido en el estándar de facto para monitorizar, depurar y proteger kernels de Linux sin modificar el código fuente ni reiniciar servicios.

Este artículo es una guía técnica, práctica y profunda para que configures eBPF desde cero, entiendas su arquitectura y lo despliegues en producción. Olvídate de los agentes pesados; aquí hablamos de instrumentación segura, eficiente y en tiempo real.

¿Qué es eBPF y por qué es la Revolución de la Observabilidad?

eBPF permite ejecutar programas sandboxed en el kernel de Linux sin necesidad de cargar módulos o cambiar el kernel. Es como tener una sonda quirúrgica que inyecta código seguro en el sistema operativo. Para el SysAdmin 2025, esto significa:

  • Visibilidad total: Desde llamadas al sistema (syscalls) hasta eventos de red, memoria y CPU.
  • Bajo overhead: Los programas eBPF se compilan a bytecode y se verifican antes de ejecutarse, garantizando que no bloqueen el kernel.
  • Dinamismo: Se pueden cargar y descargar en caliente. Sin reinicios, sin downtime.

El stack típico de observabilidad Linux con eBPF se compone de:

  1. Kernel con soporte BPF (Linux 4.18+ para funcionalidades completas, aunque 5.x+ es lo recomendado).
  2. Herramientas de usuario: bpftrace, bcc (BPF Compiler Collection), libbpf, cilium/ebpf (Go).
  3. Frontends de visualización: Grafana con plugins de eBPF, Prometheus exportadores, o dashboards personalizados.

[INFO] Si trabajas con kernels antiguos (3.x), eBPF no estará disponible. Planifica una migración a Rocky Linux 9, Ubuntu 22.04+ o cualquier distro con kernel 5.10+ para SysAdmin 2025.

Requisitos y Preparación del Sistema

Antes de lanzar comandos, verifica que tu kernel y sistema estén listos. Aquí los pasos críticos:

1. Verifica el Kernel y Habilita BPF

# Comprobar versión del kernel
uname -r

# Verificar si el sistema soporta eBPF
cat /proc/sys/kernel/bpf_stats_enabled  # Si no existe, necesitas habilitarlo

# Habilitar en caliente (no persistente)
echo 1 > /proc/sys/kernel/bpf_stats_enabled

# Para hacerlo permanente, añade a /etc/sysctl.conf o /etc/sysctl.d/99-bpf.conf
echo "kernel.bpf_stats_enabled = 1" >> /etc/sysctl.d/99-bpf.conf
sysctl -p /etc/sysctl.d/99-bpf.conf

2. Instala las Herramientas Esenciales

Dependiendo de tu distribución, elige el método:

Ubuntu/Debian (22.04+):

apt update && apt install -y bpfcc-tools linux-headers-$(uname -r) bpftrace

RHEL/CentOS Stream 9 / Rocky Linux 9:

dnf install -y bcc-tools bpftrace kernel-devel

Verifica la instalación:

# Listar herramientas BCC disponibles
ls /usr/share/bcc/tools/

# Probar un comando simple (necesitas permisos root)
sudo bpftrace -e 'tracepoint:syscalls:sys_enter_open { printf("%s\n", comm); }'

Si ves nombres de procesos apareciendo, ¡el motor eBPF está funcionando!

Configuración de Programas eBPF para Monitorización en Tiempo Real

Ahora vamos a configurar sondas específicas para monitorización rendimiento. Usaremos bpftrace para scripts rápidos y BCC para programas más complejos.

3.1. Monitorización de Llamadas al Sistema (Syscalls)

Uno de los usos más potentes es rastrear qué procesos están haciendo qué llamadas al sistema. Esto es oro puro para detectar cuellos de botella.

Script básico con bpftrace:

#!/usr/bin/env bpftrace
# syscall_count.bt - Cuenta syscalls por proceso

BEGIN
{
    printf("Contando syscalls... Ctrl+C para ver resultados\n");
}

tracepoint:syscalls:sys_enter_*
{
    @[comm] = count();
}

END
{
    printf("\nTop procesos por syscalls:\n");
    print(@, 10);
    clear(@);
}

Ejecuta: sudo bpftrace syscall_count.bt

Salida típica:

@[chrome]: 45231
@[mysqld]: 32100
@[sshd]: 120
@[node]: 890

3.2. Análisis de Latencia de Disco

Con eBPF podemos medir el tiempo exacto que tarda una operación de E/S en completarse, algo que iostat no te da con tanta granularidad.

Usando BCC (Python):

# Herramienta BCC: biolatency
sudo biolatency -D  # Muestra histograma de latencia de disco

Salida:

     usecs               : count     distribution
         0 -> 1          : 0        |                                        |
         2 -> 3          : 0        |                                        |
         4 -> 7          : 0        |                                        |
         8 -> 15         : 0        |                                        |
        16 -> 31         : 0        |                                        |
        32 -> 63         : 0        |                                        |
        64 -> 127        : 0        |                                        |
       128 -> 255        : 0        |                                        |
       256 -> 511        : 0        |                                        |
       512 -> 1023       : 0        |                                        |
      1024 -> 2047       : 0        |                                        |
      2048 -> 4095       : 0        |                                        |
      4096 -> 8191       : 0        |                                        |
      8192 -> 16383      : 0        |                                        |
     16384 -> 32767      : 0        |                                        |
     32768 -> 65535      : 0        |                                        |
     65536 -> 131071     : 0        |                                        |
    131072 -> 262143     : 0        |                                        |
    262144 -> 524287     : 0        |                                        |
    524288 -> 1048575    : 0        |                                        |

Si ves picos en rangos altos (>10ms), tienes un problema de disco.

3.3. Rastreo de Conexiones de Red (TCP)

Para monitorizar conexiones activas, usar tcpconnect de BCC:

sudo tcpconnect -L  # Muestra todas las conexiones TCP salientes

Salida:

PID    COMM         IP SADDR            DADDR            DPORT
1234   curl         4  10.0.0.5         93.184.216.34    80
5678   wget         4  10.0.0.5         151.101.1.140    443

[WARNING] eBPF captura eventos a nivel kernel. No te asustes si ves muchos eventos; es normal. Usa filtros (-P para puerto, -p para PID) para reducir ruido.

Integración con Sistemas de Observabilidad Existentes

Para SysAdmin 2025, la clave es conectar eBPF con Prometheus y Grafana. Aquí te muestro cómo hacerlo con ebpf_exporter (proyecto de Cloudflare).

Paso 1: Instalar ebpf_exporter

# Descargar binario (ejemplo para AMD64)
wget https://github.com/cloudflare/ebpf_exporter/releases/download/v2.0.0/ebpf_exporter-linux-amd64
chmod +x ebpf_exporter-linux-amd64
sudo mv ebpf_exporter-linux-amd64 /usr/local/bin/ebpf_exporter

Paso 2: Configurar un Exportador Simple

Crea un archivo YAML /etc/ebpf_exporter/config.yaml:

programs:
  - name: "syscount"
    metrics:
      counters:
        - name: "ebpf_syscall_count"
          help: "Número de syscalls por proceso"
          table: "syscall_counts"
          labels:
            - name: "comm"
              size: 16
    code: |
      #include <uapi/linux/ptrace.h>
      struct key_t {
          char comm[16];
      };
      BPF_HASH(counts, struct key_t);
      int trace_syscall(struct pt_regs *ctx) {
          struct key_t key = {};
          bpf_get_current_comm(&key.comm, sizeof(key.comm));
          counts.increment(key);
          return 0;
      }

Paso 3: Ejecutar y Exponer Métricas

sudo ebpf_exporter --config.file=/etc/ebpf_exporter/config.yaml --web.listen-address=":9435"

Ahora visita http://tu-servidor:9435/metrics y verás algo como:

# HELP ebpf_syscall_count Número de syscalls por proceso
# TYPE ebpf_syscall_count counter
ebpf_syscall_count{comm="chrome"} 12345
ebpf_syscall_count{comm="mysqld"} 9876

Luego configura Prometheus para que raspe ese endpoint y tendrás dashboards en Grafana.

Buenas Prácticas y Troubleshooting

4.1. Seguridad: El Verificador BPF

El kernel verifica cada programa eBPF antes de ejecutarlo. Si tu programa es inseguro (bucles infinitos, accesos a memoria no válidos), el kernel lo rechazará.

Errores comunes:

  • BPF program is too large: Simplifica el código o usa mapas para almacenar datos.
  • Permission denied: Ejecuta con sudo o asegura que el usuario tenga CAP_BPF.

4.2. Rendimiento: No Saturares el Kernel

Aunque eBPF es ligero, demasiados programas pueden degradar el rendimiento. Reglas de oro:

  • Usa filtros en el kernel: No traigas todos los eventos a userspace. Por ejemplo, en lugar de capturar todas las syscalls, filtra por PID o por tipo.
  • Reduce la frecuencia de muestreo: Si no necesitas microsegundos, usa tracepoint en lugar de kprobe (kprobes tienen más overhead).

[TIP] Para producción, prefiere libbpf (C) o cilium/ebpf (Go) en lugar de BCC Python, ya que evitan el compilador en tiempo de ejecución y son más estables.

4.3. Depuración con bpftool

bpftool es el navaja suiza para inspeccionar el estado de eBPF:

# Listar todos los programas eBPF cargados
sudo bpftool prog list

# Ver el bytecode de un programa específico (ID 123)
sudo bpftool prog dump xlated id 123

# Mostrar estadísticas de ejecución
sudo bpftool prog show id 123

Salida de ejemplo:

123: kprobe  name trace_syscall  tag 1234567890abcdef  gpl
    loaded_at 2025-03-15T10:30:00+0000  uid 0
    xlated 96B  jited 64B  memlock 4096B
    map_ids 456
    btf_id 789
    # stats (since load): 12345 runs, 0 errors

Si ves errors > 0, algo está mal en tu programa.

Casos de Uso Reales para SysAdmin 2025

5.1. Detección de Fugas de Memoria

Usa memleak de BCC para rastrear asignaciones no liberadas:

sudo memleak -p $(pidof mysqld) --interval=5

5.2. Análisis de Contención de CPU (Run Queue Latency)

El script runqlat mide cuánto tiempo esperan los procesos en la cola de ejecución:

sudo runqlat -m  # Muestra histograma en microsegundos

Si ves colas > 1000us, tu CPU está sobrecargada.

5.3. Seguridad: Detectar Ejecución de Binarios No Autorizados

Con execsnoop puedes ver cada nuevo proceso que se ejecuta:

sudo execsnoop

Ideal para detectar malware o scripts maliciosos.

Conclusión: El Nuevo Estándar en Observabilidad

La configuración de eBPF para Observabilidad en Linux no es opcional para el SysAdmin 2025; es la herramienta que separa a los administradores reactivos de los proactivos. Con eBPF puedes:

  • Rastrear cualquier evento del kernel con overhead mínimo.
  • Construir dashboards en tiempo real que antes requerían agentes pesados.
  • Depurar problemas de rendimiento en segundos, no en horas.

El camino de aprendizaje es empinado (bytecode, mapas, hooks), pero las herramientas como bpftrace, BCC y ebpf_exporter lo hacen accesible. Empieza con scripts pequeños, intégralos en tu monitorización existente y verás cómo la visibilidad de tu infraestructura se vuelve quirúrgica.

[INFO] Para profundizar, visita la documentación oficial de BCC y bpftrace. Y recuerda: en SysAdmin 2025, quien no usa eBPF, está ciego.

¿Listo para inyectar sondas en tu kernel? El futuro de la observabilidad Linux ya está aquí, y se llama eBPF.

¿Necesitas ayuda?Son dos de nuestros técnicos, Agustín y Mikel, y están disponibles para resolver cualquier problema.

Hablar con ellos ahora
Agustín y Mikel