Grafana Beyla: autoinstrumentación eBPF de HTTP y gRPC sin código

Grafana Beyla: instrumenta HTTP y gRPC con eBPF sin tocar el código. Requisitos del kernel, permisos Linux, límites de las trazas y OpenTelemetry OBI.
Grafana Beyla : auto-instrumentation eBPF HTTP et gRPC sans code

Grafana Beyla es una herramienta de autoinstrumentación eBPF: observa tus servicios HTTP y gRPC desde el kernel de Linux y produce trazas y métricas RED sin tocar el código ni reiniciar la aplicación. Para un equipo de plataforma que hereda decenas de servicios sin instrumentar, es una forma rápida de obtener una primera visibilidad.

Esta guía práctica explica qué hace realmente Beyla, cómo lanzarlo en un contenedor, qué permisos Linux exige, dónde se detienen sus trazas y por qué ha cambiado su estatus: el código se donó a OpenTelemetry en 2025. Todo procede de la documentación oficial de Grafana y de OpenTelemetry. El contenido no depende de Dynatrace SaaS ni de Dynatrace Managed; solo los une la salida OTLP, a través de un backend compatible.

En resumen

  • Beyla captura los spans de transacciones web y las métricas Rate, Errors, Duration (RED) de servicios HTTP/S y gRPC, sin modificar el código ni la configuración de la aplicación (documentación de Grafana).
  • Requisitos: kernel Linux 5.8 o superior con BTF; 5.17 o superior para la propagación del contexto de traza mediante cabeceras HTTP.
  • Las métricas RED son lo más seguro; las trazas están «soportadas con límites» según el lenguaje.
  • El código vive ahora en origen en OpenTelemetry eBPF Instrumentation (OBI); Beyla es la distribución soportada por Grafana.

Grafana Beyla: qué observa la herramienta y cómo

Según la documentación de Grafana, Beyla inspecciona los ejecutables de las aplicaciones y la capa de red del sistema operativo gracias a eBPF. De ahí obtiene spans de transacciones web y métricas RED para los servicios Linux HTTP/S y gRPC. Los lenguajes citados incluyen Go, C/C++, Rust, Python, Ruby, Java (incluido GraalVM Native), Node.js y .NET.

La exportación es neutra respecto al proveedor: formato OpenTelemetry (OTLP) o métricas nativas de Prometheus. Beyla también escucha la API de Kubernetes para enriquecer métricas y trazas con los metadatos de pods y servicios, y se integra con Grafana Alloy.

Por qué un agente fuera del proceso cambia la medición

Un agente clásico mide el tiempo de servicio, es decir, el tiempo pasado en el manejador de peticiones. Beyla observa en el nivel de red del kernel. Según su documentación, sus latencias reflejan por tanto lo que ve el cliente, incluida la cola interna. Para un SLO de latencia esta diferencia importa: un servicio saturado cuyos hilos están todos ocupados parece rápido visto desde dentro y lento visto por el usuario.

Otra consecuencia documentada: el código de instrumentación no se ejecuta en la memoria de la aplicación. Se puede añadir o retirar sin reiniciar, y un fallo del componente eBPF no tumba el servicio vigilado. Estos puntos vienen de Grafana; conviene validarlos con tu carga real.

Requisitos y permisos Linux

La página de inicio de la documentación de Beyla fija las siguientes condiciones:

  • kernel Linux 5.8 o superior con BTF activado (archivo /sys/kernel/btf/vmlinux); los kernels 4.18 de la familia RHEL 8 también están soportados;
  • propagación del contexto mediante cabeceras HTTP: kernel 5.17 o superior, porque la herramienta usa el helper bpf_loop;
  • aplicaciones Go compiladas con Go 1.17 o posterior.

Beyla carga programas eBPF y lee /proc: necesita privilegios. La página Security recomienda concederle solo las capacidades necesarias en lugar de root completo. Al arrancar, avisa si falta una capacidad; la variable BEYLA_ENFORCE_SYS_CAPS=1 hace que falle de inmediato.

Lista de las capacidades de Linux que requiere Beyla: CAP_BPF, CAP_NET_RAW, CAP_NET_ADMIN, CAP_PERFMON, CAP_SYS_PTRACE, CAP_SYS_ADMIN y su uso

Un punto de atención en los clústeres gestionados: según la documentación, AKS y EKS tienen por defecto un valor de perf_event_paranoid superior a 1, lo que obliga a usar CAP_SYS_ADMIN en lugar de CAP_PERFMON. Las distribuciones Debian suelen usar el valor 3, con el mismo efecto. Haz que tu equipo de seguridad valide este requisito antes de cualquier despliegue.

Lanzar Beyla en un contenedor, paso a paso

Lo más sencillo para probarlo es el modo Docker de la documentación: un contenedor Beyla comparte el espacio de PID del contenedor que se quiere instrumentar.

  1. Arrancar un servicio de prueba. La documentación usa un pequeño blog en Go, mariomac/goblog:dev, que escucha en HTTPS en el puerto interno 8443.
  2. Elegir el proceso. La variable BEYLA_OPEN_PORT=8443 selecciona el proceso que escucha en ese puerto. BEYLA_AUTO_TARGET_EXE selecciona por ruta del ejecutable (patrón glob).
  3. Mostrar las trazas en texto. BEYLA_TRACE_PRINTER=text las imprime en la salida estándar, útil para validar antes de exportar.
  4. Lanzar Beyla con --pid="container:goblog" y con --privileged o bien las capacidades listadas arriba.
Comandos docker run del servicio goblog y después de Beyla con BEYLA_OPEN_PORT y BEYLA_TRACE_PRINTER, seguidos de las líneas de traza impresas
docker run -p 18443:8443 --name goblog mariomac/goblog:dev

docker run --rm \
  -e BEYLA_OPEN_PORT=8443 \
  -e BEYLA_TRACE_PRINTER=text \
  --pid="container:goblog" \
  --privileged \
  grafana/beyla:latest

Cómo comprobar que funciona

Abre https://localhost:18443, navega y mira la salida de Beyla. Cada petición aparece como una línea con duración, código HTTP, método, ruta y direcciones, por ejemplo «200 GET /». Si no se muestra nada, busca en los logs el aviso de capacidades que faltan y comprueba después el puerto elegido.

Pasar a un archivo de configuración y a OTLP

Para una operación duradera, la configuración pasa a YAML. Según la documentación, las variables de entorno prevalecen sobre el archivo. La sección discovery.instrument describe los servicios objetivo; la clave open_ports acepta puertos y rangos (80,443,8000-8999), y exe_path un patrón sobre la ruta del ejecutable. En Kubernetes también acepta filtros como k8s_namespace o k8s_deployment_name.

Archivo beyla-config.yaml con discovery.instrument open_ports, ebpf context_propagation all, otel_traces_export endpoint y prometheus_export port 8999
discovery:
  instrument:
    - open_ports: 8443
ebpf:
  context_propagation: "all"
otel_traces_export:
  endpoint: http://otel-collector:4318
prometheus_export:
  port: 8999
  path: /metrics
log_level: INFO

El ejemplo anterior reúne claves presentes en la documentación (la dirección del Collector es ficticia). Si apuntas a un Collector, nuestra guía sobre el Collector de OpenTelemetry en Kubernetes describe un pipeline de recepción OTLP completo, con envío a Dynatrace. Para limitar después el volumen de trazas, consulta el tail sampling.

El puerto de Prometheus sirve para que un servidor Prometheus recoja las métricas RED; nuestro artículo sobre Prometheus y Dynatrace en Kubernetes cubre esa recolección.

Los límites de las trazas, lenguaje por lenguaje

La documentación ofrece una matriz de compatibilidad que conviene leer antes de prometer trazas a un equipo. Sus conclusiones: Beyla es más sólido como capa base sin código para las métricas RED y los grafos de servicios, mientras que los SDK de OpenTelemetry siguen siendo la opción recomendada para trazas distribuidas detalladas.

  • Go HTTP, HTTP/2, HTTPS y gRPC: trazas recomendadas. Go es el caso mejor cubierto.
  • Java clásico, Node.js, Python, Ruby: trazas «soportadas con límites».
  • Java reactivo o con cambio de hilo: trazas no recomendadas; los spans aislados pueden no vincularse a la traza correcta.
  • .NET: correcto si el servicio no es el primero de la cadena; si es el punto de entrada, el trazado puede funcionar mal.
  • Servicio ya instrumentado con un SDK de OpenTelemetry: Beyla desactiva automáticamente sus propias trazas y sigue recomendado para las métricas RED.

Propagación del contexto entre servicios

Las trazas distribuidas se basan en la cabecera W3C traceparent. Beyla lee el contexto entrante, sigue la ejecución y añade traceparent a las peticiones HTTP y gRPC salientes; si la aplicación ya lo ha puesto, reutiliza ese valor. La propagación en el nivel de red está desactivada por defecto: se activa con BEYLA_BPF_CONTEXT_PROPAGATION=all o ebpf.context_propagation. Requiere capacidades adicionales (CAP_NET_ADMIN y CAP_PERFMON). Para entender qué aporta una propagación correcta en colas de mensajes, lee nuestro artículo sobre la propagación de contexto con Kafka.

Beyla, OBI y OpenTelemetry: ¿en qué punto estamos?

La documentación de Grafana lo indica: el código de Beyla se donó en 2025 al proyecto OpenTelemetry con el nombre de OpenTelemetry eBPF Instrumentation (OBI), hoy mantenido por un consorcio de colaboradores entre los que está Grafana. Beyla es la distribución de OBI soportada por Grafana e importa el código de OBI como una biblioteca. Toda funcionalidad de OBI está, pues, en Beyla, pero lo contrario no es cierto: process metrics, el modo survey o la integración con Alloy no existen en OBI.

Dos diferencias prácticas que recordar para un despliegue: las variables de entorno de OBI empiezan por OTEL_EBPF_ (Beyla acepta ambos prefijos), y las métricas sin convención semántica llevan el prefijo beyla_ u obi_. El esquema YAML es el mismo. El sitio de OpenTelemetry describe OBI como una herramienta de arranque para la observabilidad de aplicaciones, con HTTP/S, gRPC, Kafka y varias bases de datos, sobre kernel 5.8 o superior. La versión concreta de Beyla que instalar no se ha verificado aquí: consulta la página de releases del repositorio antes de fijar una versión.

Este movimiento va en el sentido de un estándar: si construyes una estrategia OpenTelemetry, la autoinstrumentación eBPF encuentra ahí su lugar, sin depender de un único proveedor. Nuestra comparación OpenTelemetry y Prometheus plantea el marco general.

Qué cambia para un equipo SRE

Beyla reduce el coste de la primera capa de observabilidad: se obtienen métricas RED, es decir SLI de disponibilidad y latencia, en servicios que nadie puede recompilar. No sustituye el trabajo de instrumentación en los servicios críticos, donde los spans de negocio y la correlación con los logs siguen siendo más ricos con un SDK. Nuestro artículo observabilidad y monitorización recuerda por qué estas señales se complementan.

Buenas prácticas

  • Empezar por un solo servicio y BEYLA_TRACE_PRINTER=text, antes de cualquier exportación.
  • Limitar el descubrimiento con discovery.instrument en Kubernetes, en lugar de instrumentar todo el nodo.
  • Configurar rutas de baja cardinalidad (Routes Decorator) para obtener trazas aprovechables, como aconseja la documentación.
  • Conceder capacidades precisas y documentar la excepción CAP_SYS_ADMIN si el nodo la exige.
  • No duplicar Beyla y un SDK en las trazas de un mismo servicio; reservar Beyla para las métricas RED.
  • Probar en un kernel de producción idéntico: los requisitos dependen de la versión del kernel.

Preguntas frecuentes

¿Grafana Beyla sustituye a los SDK de OpenTelemetry?

No. Según la documentación de Grafana, Beyla es más fuerte como capa base para las métricas RED, mientras que los SDK siguen recomendándose para trazas distribuidas detalladas. Ambos pueden coexistir, y Beyla corta entonces sus propias trazas.

¿Hay que reiniciar la aplicación para instrumentar con Beyla?

No. La documentación indica que Beyla instrumenta sin reinicio y sin modificar la aplicación. Eso sí, hay que darle los permisos Linux necesarios y un kernel compatible.

¿Sigue manteniéndose Beyla tras la donación a OpenTelemetry?

Sí. Grafana lo presenta como la distribución de OBI que soporta, y precisa que su ciclo de versiones suele ser más rápido que el de OBI. El repositorio de GitHub indica además que el desarrollo migra al repositorio de origen de OBI.

Conclusión

Beyla ofrece un camino corto hacia métricas RED y trazas parciales, a costa de permisos Linux elevados y de límites de trazado según el lenguaje. Pruébalo en un servicio, lee la matriz de compatibilidad y decide después dónde sigue siendo necesario un SDK.

Fuentes

span.observer es un blog independiente de la comunidad, no afiliado a Dynatrace LLC ni a Grafana Labs. Dynatrace es una marca de Dynatrace LLC. Las marcas citadas pertenecen a sus propietarios; los ejemplos de configuración se ofrecen con fines didácticos, direcciones ficticias incluidas. Comprueba siempre los valores (puertos, versiones, tamaños) en la documentación oficial correspondiente a tu versión.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
DDU Dynatrace : calculer la consommation des métriques et de la licence

DDU Dynatrace: calcular el consumo de métricas y de la licencia

Next Post
Agent SRE AIOps : ce que promettent les plateformes

Agente SRE AIOps: lo que prometen las plataformas

Related Posts