El filtro de paquetes extendido Berkeley (eBPF) ha revolucionado la observabilidad, el monitoreo del rendimiento y la seguridad del kernel de Linux. eBPF permite a los desarrolladores ejecutar programas en espacio aislado directamente en el kernel sin modificar el código del kernel, desbloqueando el poder de monitorear, rastrear y manipular datos de manera eficiente. Combinado con el lenguaje de programación Go ebpf, conocido por su simplicidad, concurrencia y ecosistema robusto, eBPF se convierte en una potente herramienta para crear aplicaciones eficaces, seguras y escalables. En este artículo, exploraremos eBPF en Go, cómo funciona, sus casos de uso y un ejemplo práctico.

¿Qué es eBPF?
eBPF, originalmente diseñado para el filtrado de paquetes, ha evolucionado hasta convertirse en una tecnología de propósito más general utilizada para una amplia gama de tareas de programación a nivel de kernel. Los programas eBPF se ejecutan dentro del kernel de Linux, lo que permite la interacción con eventos del sistema, paquetes de red y llamadas al sistema, todo sin la necesidad de cambiar el kernel mismo.

Al utilizar eBPF, los desarrolladores obtienen:
• Profunda visibilidad del funcionamiento interno del núcleo.
• Seguridad mediante ejecución en espacio aislado con verificación estricta.
• Rendimiento a través de gastos generales mínimos y manejo de eventos en tiempo real.
• Flexibilidad para rastrear, crear perfiles y hacer cumplir políticas de seguridad.
Esta versatilidad ha llevado a que eBPF se vuelva popular en herramientas de observabilidad como Prometheus, plataformas de seguridad como Cilium y herramientas de red.

¿Por qué utilizar Go con eBPF?
Go es un lenguaje de programación moderno conocido por su simplicidad, modelo de concurrencia y sólida biblioteca estándar. Estas cualidades lo hacen ideal para trabajar con eBPF porque Go simplifica el desarrollo de sistemas escalables y eficientes manteniendo al mismo tiempo la base de código manejable. El rico ecosistema de herramientas y bibliotecas de Go, combinado con el poder de eBPF, permite a los ingenieros escribir código de alto rendimiento a nivel de kernel en un lenguaje más fácil de mantener.

Ventajas de usar Go con eBPF:
• Alto rendimiento: Go es rápido y, al combinarlo con la sobrecarga mínima de eBPF, las aplicaciones pueden operar a velocidades cercanas al kernel.
• Facilidad de uso: la sintaxis y el modelo de concurrencia de Go permiten ciclos de desarrollo más rápidos.
• Gestión eficiente de la memoria: la recolección de basura de Go garantiza que la memoria se maneje limpiamente, lo que reduce el riesgo de pérdidas de memoria comunes en los programas eBPF basados ​​en C.

Conceptos clave de eBPF en Go
Antes de sumergirnos en el código Go, veamos algunos conceptos fundamentales de eBPF:
1. Programas eBPF
Un programa eBPF es una pequeña función que se ejecuta en el kernel en respuesta a un evento determinado. El programa está protegido y sujeto a varias comprobaciones para garantizar que no daña el sistema. Los eventos típicos incluyen manejo de paquetes de red, seguimiento de funciones y contadores de rendimiento.
2. Mapas eBPF
Los mapas eBPF son estructuras de datos que se utilizan para almacenar datos a los que pueden acceder los programas eBPF. Estos mapas pueden contener métricas, datos de configuración y otra información esencial compartida entre el espacio de usuario y el espacio del kernel.
3. Verificador eBPF
Antes de la ejecución, el programa eBPF debe pasar por el verificador, que busca cualquier comportamiento inseguro o erróneo. El verificador garantiza que el programa no bloqueará el kernel ni filtrará datos.
4. Ganchos eBPF
Los programas eBPF se adjuntan a los eventos del kernel a través de enlaces, que pueden incluir puntos de seguimiento, kprobes (puntos de entrada de funciones), uprobes (seguimiento de funciones en el espacio de usuario) y filtros de socket.
Creación de programas eBPF en Go
Para trabajar con eBPF en Go, la biblioteca principal a utilizar es Cilium/ebpf, una biblioteca nativa de Go que le permite interactuar con programas, mapas y ayudas de eBPF.

Requisitos previos
Para seguirlo, asegúrese de tener:

1. Un sistema Linux con versión de kernel 4.14 o posterior.
2. Vaya instalado en su sistema.
3. Biblioteca eBPF de Cilium: Vaya a github.com/cilium/ebpf

Escribir un programa eBPF básico en Go
A continuación se muestra un ejemplo sencillo de cómo adjuntar un programa eBPF para rastrear llamadas al sistema:

1. Cree el programa eBPF en C
Aunque los programas eBPF se pueden escribir en otros lenguajes, C sigue siendo el más común. Escriba un programa simple que incremente un contador cada vez que se realiza una llamada específica al sistema:

#include 
#include 

BPF_HASH(syscall_count, u32, u64);

int trace_syscall(struct pt_regs *ctx) {
    u32 pid = bpf_get_current_pid_tgid();
    u64 *count = syscall_count.lookup(&pid);
    if (count) {
        (*count)  ;
    } else {
        u64 initial_count = 1;
        syscall_count.update(&pid, &initial_count);
    }
    return 0;
}

Este programa rastrea las llamadas al sistema realizadas por procesos, almacenando el número de llamadas al sistema por ID de proceso.

2. Compilando el programa eBPF
Una vez escrito, compila el programa eBPF usando LLVM:
clang -O2 -target bpf -c syscall_counter.c -o syscall_counter.o

3. Cargando y ejecutando el programa eBPF en Go
Ahora, escribe el código Go que carga e interactúa con el programa eBPF.
paquete principal

import (
    "log"
    "github.com/cilium/ebpf"
    "golang.org/x/sys/unix"
)

func main() {
    // Load the precompiled eBPF program
    prog, err := ebpf.LoadProgram("syscall_counter.o")
    if err != nil {
        log.Fatalf("failed to load eBPF program: %v", err)
    }
    defer prog.Close()

    // Attach the eBPF program to the system call entry point
    err = unix.SetSyscallEntry(prog, unix.SYS_write)
    if err != nil {
        log.Fatalf("failed to attach eBPF program: %v", err)
    }

    log.Println("eBPF program successfully attached.")
}

Aquí, cargamos el programa eBPF compilado y lo adjuntamos a la llamada al sistema de escritura usando el paquete syscall de Go.

4. Observando la salida
Una vez que se ejecuta el programa, comienza a rastrear las llamadas al sistema. Puede inspeccionar los recuentos accediendo al mapa eBPF, que se realiza en Go usando la biblioteca eBPF.

func readMap() {
    syscallCount := ebpf.Map("syscall_count")
    defer syscallCount.Close()

    iter := syscallCount.Iterate()
    var pid uint32
    var count uint64

    for iter.Next(&pid, &count) {
        log.Printf("PID: %d, Syscall Count: %d\n", pid, count)
    }
}

Casos de uso de Go eBPF
La combinación de Go y eBPF tiene varios casos de uso potentes en diferentes dominios:

1. Observabilidad y seguimiento
Herramientas como bpftrace aprovechan eBPF para recopilar métricas y registros granulares sin grandes gastos generales. En Go, puedes crear canalizaciones de métricas personalizadas que monitorean el rendimiento de las aplicaciones o el tráfico de la red en tiempo real.
2. Aplicación de la seguridad
Con Go, puede crear sistemas que monitoreen automáticamente eventos sensibles a la seguridad (por ejemplo, llamadas no autorizadas al sistema, comportamiento sospechoso de la red) escribiendo programas eBPF personalizados que observen y registren estas actividades.
3. Optimización del rendimiento de la red
eBPF permite un monitoreo detallado de los paquetes de red y el uso del ancho de banda. Combinando esto con el rendimiento de Go, puede crear sistemas eficientes para el equilibrio de carga, la configuración del tráfico y el análisis de la red en tiempo real.

Conclusión
Go eBPF brinda a los desarrolladores la capacidad de escribir aplicaciones eficientes y de alto rendimiento que aprovechan la observabilidad y el control a nivel de kernel. Ya sea que esté creando herramientas para monitorear el rendimiento, aplicar medidas de seguridad u optimizar la red, combinar Go con la flexibilidad de eBPF ofrece un enorme potencial. Al comprender los conceptos clave y adquirir experiencia práctica con Go eBPF, podrá desbloquear el verdadero poder del kernel de Linux para sus aplicaciones.