O Extended Berkeley Packet Filter (eBPF) revolucionou a observabilidade, o monitoramento de desempenho e a segurança do kernel Linux. O eBPF permite que os desenvolvedores executem programas em sandbox diretamente no kernel sem modificar o código do kernel, liberando o poder de monitorar, rastrear e manipular dados com eficiência. Combinado com a linguagem de programação Go ebpf, conhecida por sua simplicidade, simultaneidade e ecossistema robusto, o eBPF se torna uma ferramenta potente para a construção de aplicativos de alto desempenho, seguros e escaláveis. Neste artigo, exploraremos o eBPF em Go, como ele funciona, seus casos de uso e um exemplo prático.

O que é eBPF?
O eBPF, originalmente projetado para filtragem de pacotes, evoluiu para uma tecnologia de uso mais geral, usada para uma ampla gama de tarefas de programação em nível de kernel. Os programas eBPF são executados dentro do kernel Linux, permitindo a interação com eventos do sistema, pacotes de rede e chamadas do sistema, tudo sem a necessidade de alterar o próprio kernel.

Ao utilizar o eBPF, os desenvolvedores ganham:
• Visibilidade profunda do funcionamento interno do kernel.
• Segurança por meio de execução em sandbox com verificação rigorosa.
• Desempenho por meio de sobrecarga mínima e manipulação de eventos em tempo real.
• Flexibilidade para rastreamento, criação de perfil e aplicação de políticas de segurança.
Essa versatilidade fez com que o eBPF se tornasse popular em ferramentas de observabilidade como Prometheus, plataformas de segurança como Cilium e ferramentas de rede.

Por que usar Go com eBPF?
Go é uma linguagem de programação moderna conhecida por sua simplicidade, modelo de simultaneidade e forte biblioteca padrão. Essas qualidades o tornam ideal para trabalhar com eBPF porque Go simplifica o desenvolvimento de sistemas escaláveis ​​e eficientes, ao mesmo tempo que mantém a base de código gerenciável. O rico ecossistema de ferramentas e bibliotecas do Go, combinado com o poder do eBPF, permite que os engenheiros escrevam código de alto desempenho em nível de kernel em uma linguagem mais fácil de manter.

Vantagens de usar Go com eBPF:
• Alto desempenho: Go é rápido e combiná-lo com a sobrecarga mínima do eBPF significa que os aplicativos podem operar em velocidades próximas às do kernel.
• Facilidade de uso: a sintaxe e o modelo de simultaneidade do Go permitem ciclos de desenvolvimento mais rápidos.
• Gerenciamento eficiente de memória: a coleta de lixo do Go garante que a memória seja tratada de forma limpa, reduzindo o risco de vazamentos de memória comuns em programas eBPF baseados em C.

Conceitos-chave do eBPF em Go
Antes de mergulharmos no código Go, vamos dar uma olhada em alguns conceitos fundamentais do eBPF:
1. Programas eBPF
Um programa eBPF é uma pequena função executada no kernel em resposta a um determinado evento. O programa está em uma área restrita e sujeito a várias verificações para garantir que não prejudica o sistema. Os eventos típicos incluem manipulação de pacotes de rede, rastreamento de funções e contadores de desempenho.
2. Mapas eBPF
Os mapas eBPF são estruturas de dados usadas para armazenar dados que os programas eBPF podem acessar. Esses mapas podem conter métricas, dados de configuração e outras informações essenciais compartilhadas entre o espaço do usuário e o espaço do kernel.
3. Verificador eBPF
Antes da execução, o programa eBPF deve passar pelo verificador, que verifica qualquer comportamento inseguro ou errôneo. O verificador garante que o programa não travará o kernel ou vazará dados.
4. Ganchos eBPF
Os programas eBPF são anexados a eventos do kernel por meio de ganchos, que podem incluir tracepoints, kprobes (pontos de entrada de função), uprobes (rastreamento de função do espaço do usuário) e filtros de soquete.
Construindo programas eBPF em Go
Para trabalhar com eBPF em Go, a biblioteca principal a ser usada é Cilium/ebpf, uma biblioteca nativa Go que permite interagir com programas, mapas e auxiliares eBPF.

Pré-requisitos
Para acompanhar, certifique-se de ter:

1. Um sistema Linux com kernel versão 4.14 ou mais recente.
2. Vá instalado em seu sistema.
3. Biblioteca eBPF do Cilium: acesse github.com/cilium/ebpf

Escrevendo um programa eBPF básico em Go
Aqui está um exemplo simples de anexar um programa eBPF para rastrear chamadas do sistema:

1. Crie o Programa eBPF em C
Embora os programas eBPF possam ser escritos em outras linguagens, C continua sendo a mais comum. Escreva um programa simples que incremente um contador toda vez que uma chamada de sistema específica é feita:

#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 rastreia chamadas de sistema feitas por processos, armazenando o número de syscalls por ID de processo.

2. Compilando o Programa eBPF
Depois de escrito, compile o programa eBPF usando LLVM:
clang -O2 -target bpf -c syscall_counter.c -o syscall_counter.o

3. Carregando e executando o programa eBPF em Go
Agora, escreva o código Go que carrega e interage com o programa eBPF.
pacote 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.")
}

Aqui, carregamos o programa eBPF compilado e o anexamos à chamada de sistema write usando o pacote syscall de Go.

4. Observando a saída
Depois que o programa é executado, ele começa a rastrear as chamadas do sistema. Você pode inspecionar as contagens acessando o mapa eBPF, que é feito em Go usando a 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 para Go eBPF
A combinação de Go e eBPF tem vários casos de uso poderosos em diferentes domínios:

1. Observabilidade e monitoramento
Ferramentas como o bpftrace aproveitam o eBPF para coletar métricas e logs granulares sem grande sobrecarga. No Go, você pode criar pipelines de métricas personalizadas que monitoram o desempenho do aplicativo ou o tráfego de rede em tempo real.
2. Aplicação de segurança
Com Go, você pode construir sistemas que monitoram automaticamente eventos sensíveis à segurança (por exemplo, chamadas de sistema não autorizadas, comportamento de rede suspeito) escrevendo programas eBPF personalizados que observam e registram essas atividades.
3. Otimização de desempenho de rede
O eBPF permite monitoramento detalhado de pacotes de rede e uso de largura de banda. Combinando isso com o desempenho do Go, você pode construir sistemas eficientes para balanceamento de carga, modelagem de tráfego e análise de rede em tempo real.

Conclusão
Go eBPF capacita os desenvolvedores com a capacidade de escrever aplicativos eficientes e de alto desempenho que aproveitam a observabilidade e o controle em nível de kernel. Esteja você criando ferramentas para monitoramento de desempenho, aplicação de segurança ou otimização de rede, combinar Go com a flexibilidade do eBPF oferece um enorme potencial. Ao compreender os principais conceitos e obter experiência prática com Go eBPF, você pode desbloquear o verdadeiro poder do kernel Linux para seus aplicativos.