Linux & Serveurs

eBPF : Des superpouvoirs du noyau Linux pour les administrateurs système en 2026

Rh1nux

Rh1nux

— 8 min read
eBPF : Des superpouvoirs du noyau Linux pour les administrateurs système en 2026

Si vous administrez des serveurs Linux depuis un certain temps, vous connaissez cette frustration : une application ralentit, un processus se comporte anormalement, ou vous soupçonnez une compromission… mais vos outils de surveillance sont dépassés. Ils fonctionnent dans l’espace utilisateur et ne détectent les événements qu’après coup. En 2026, une meilleure solution existe. eBPF (Extended Berkeley Packet Filter) vous offre une visibilité et un contrôle au niveau du noyau, sans nécessiter la moindre modification du noyau. Prêt pour la production, adopté par des géants du cloud comme Google, Meta et AWS, vous pouvez l’utiliser dès aujourd’hui sur vos propres serveurs.

Ce guide explique ce qu'est eBPF, pourquoi c'est important pour les administrateurs système et comment déployer de véritables outils basés sur eBPF pour renforcer et surveiller votre infrastructure Linux.

Qu’est-ce que l’eBPF et pourquoi devriez-vous vous en soucier ?

eBPF a été initialement conçu pour filtrer efficacement les paquets réseau au niveau du noyau, sans copier les données dans l'espace utilisateur. La version « étendue » l'a transformé en une machine virtuelle générique s'exécutant en toute sécurité au sein du noyau Linux. Imaginez-la comme un environnement isolé vous permettant d'exécuter votre propre code au niveau du noyau, déclenché par n'importe quel événement système : appels système, paquets réseau, opérations sur les fichiers, planification du processeur, allocation de mémoire.

Avant eBPF, vos options étaient les suivantes :

  • Les modules du noyau — puissants mais dangereux (un seul bogue peut faire planter le système) — nécessitent une recompilation pour chaque version du noyau.
  • Agents espace utilisateur — sûrs, mais ils peuvent manquer des événements, ajoutent de la latence et peuvent être contournés par des attaquants sophistiqués.
  • SystemTap / DTrace — utilisation en production ancienne, complexe et limitée

eBPF vous offre la puissance du noyau tout en garantissant la sécurité de l'espace utilisateur : les programmes sont vérifiés avant leur chargement, ils ne peuvent pas faire planter le noyau et ils sont compilés à la volée pour des performances quasi natives. Le vérificateur du noyau Linux contrôle chaque programme eBPF avant son exécution — aucun débordement de mémoire, aucune boucle infinie.

eBPF en 2026 : Quoi de neuf ?

L'écosystème eBPF a considérablement mûri. Le noyau 6.x a introduit la délégation par jeton BPF , permettant aux utilisateurs non administrateurs de charger des programmes eBPF spécifiques – une avancée majeure pour les environnements mutualisés. La fonctionnalité BPF Arena (noyau 6.9 et versions ultérieures) permet le partage de zones de mémoire entre les programmes eBPF. Des outils comme Cilium, Falco et Pixie sont désormais des solutions d'entreprise éprouvées, et non plus des solutions expérimentales.

Configuration de votre chaîne d'outils eBPF

La plupart des distributions modernes intègrent nativement la prise en charge d'eBPF. Vérifions et installons les outils essentiels.

Vérification des prérequis

# Check kernel version (need 5.8+ for full feature set, 6.x recommended)
uname -r

# Verify eBPF support
grep -i ebpf /boot/config-$(uname -r) | head -5

# Check BTF (BPF Type Format) — required for CO-RE programs
ls -la /sys/kernel/btf/vmlinux

# Check if BPF filesystem is mounted
mount | grep bpffs
# If not mounted:
mount -t bpf bpffs /sys/fs/bpf

Installer les outils principaux

# Ubuntu/Debian
apt-get update && apt-get install -y \
  bpftool \
  bpfcc-tools \
  linux-headers-$(uname -r) \
  python3-bpfcc

# RHEL/Rocky/AlmaLinux
dnf install -y bpftool bcc bcc-tools kernel-devel

# Install bpftrace (powerful one-liner tracing tool)
# Ubuntu 22.04+
apt-get install -y bpftrace

# Or from GitHub for latest version
wget https://github.com/bpftrace/bpftrace/releases/latest/download/bpftrace -O /usr/local/bin/bpftrace
chmod +x /usr/local/bin/bpftrace

# Verify
bpftool version
bpftrace --version

Cas d'utilisation concret n° 1 : Observabilité du système avec bpftrace

bpftrace est l'outil multifonction par excellence pour l'observabilité eBPF. Il utilise une syntaxe similaire à celle d'awk pour écrire des commandes puissantes en une seule ligne qui permettent de suivre en temps réel le fonctionnement interne du noyau.

Diagnostic des E/S disque lentes

# Trace block I/O latency — see which processes are causing disk slowness
bpftrace -e '
kprobe:blk_account_io_start { @start[arg0] = nsecs; }
kprobe:blk_account_io_done /@start[arg0]/
{
  @usecs = hist((nsecs - @start[arg0]) / 1000);
  delete(@start[arg0]);
}
END { print(@usecs); }'

# Quick check: top files being read/written (last 5 seconds)
opensnoop -d 5

# Trace slow syscalls (> 10ms)
bpftrace -e '
tracepoint:raw_syscalls:sys_enter { @start[tid] = nsecs; @name[tid] = args->id; }
tracepoint:raw_syscalls:sys_exit
/@start[tid] && (nsecs - @start[tid]) > 10000000/
{
  @slow[ksym(@name[tid])] = count();
  delete(@start[tid]);
}'

Tracer les connexions réseau

# See every new TCP connection (like tcpdump but at kernel level)
bpftrace -e '
kprobe:tcp_connect {
  printf("%-6d %-16s --> ", pid, comm);
  printf("%s\n", ntop(((struct sock *)arg0)->__sk_common.skc_daddr));
}'

# Monitor DNS lookups in real time (catches malware C2 callbacks)
bpftrace -e '
tracepoint:net:net_dev_xmit
/str(args->name) == "eth0"/
{
  printf("tx: %d bytes from PID %d (%s)\n", args->len, pid, comm);
}'

# Track all processes spawning new child processes
bpftrace -e '
tracepoint:sched:sched_process_fork
{
  printf("FORK: PID %d (%s) spawned PID %d\n",
    args->parent_pid, args->parent_comm, args->child_pid);
}'

Cas d'utilisation concret n° 2 : Surveillance de la sécurité avec Falco

Falco est un outil de sécurité d'exécution certifié CNCF et basé sur eBPF. Il surveille les événements du noyau et alerte en cas de comportement suspect grâce à un moteur de règles ; on peut le considérer comme un système de détection d'intrusion (IDS) qui analyse tout au niveau du noyau.

Déploiement de Falco avec pilote eBPF

# Add Falco repository
curl -fsSL https://falco.org/repo/falcosecurity-packages.asc | \
  gpg --dearmor -o /usr/share/keyrings/falco-archive-keyring.gpg

echo "deb [signed-by=/usr/share/keyrings/falco-archive-keyring.gpg] \
  https://download.falco.org/packages/deb stable main" \
  > /etc/apt/sources.list.d/falcosecurity.list

apt-get update && apt-get install -y falco

# Configure Falco to use eBPF driver (no kernel module needed)
# Edit /etc/falco/falco.yaml
sed -i 's/engine: kmod/engine: ebpf/' /etc/falco/falco.yaml

# Start Falco
systemctl enable --now falco

# Watch alerts in real time
journalctl -fu falco | grep -E "(Warning|Critical|Error)"

Écrire des règles Falco personnalisées

cat >> /etc/falco/rules.d/custom_rules.yaml << 'EOF'
# Alert when any process writes to /etc/passwd or /etc/shadow
- rule: Write to sensitive files
  desc: Detect writes to /etc/passwd, /etc/shadow, /etc/sudoers
  condition: >
    open_write and
    (fd.name startswith /etc/passwd or
     fd.name startswith /etc/shadow or
     fd.name startswith /etc/sudoers)
  output: >
    Sensitive file opened for writing
    (user=%user.name command=%proc.cmdline file=%fd.name)
  priority: CRITICAL
  tags: [filesystem, mitre_persistence]

# Alert on reverse shell attempts
- rule: Reverse shell detected
  desc: Detect stdin/stdout/stderr redirected to network socket
  condition: >
    spawned_process and
    proc.name in (bash, sh, zsh, dash) and
    (fd.num in (0, 1, 2) and fd.typechar = '4')
  output: >
    Possible reverse shell (user=%user.name command=%proc.cmdline)
  priority: CRITICAL
  tags: [network, shell, mitre_execution]
EOF

# Reload rules
systemctl restart falco

Cas d'utilisation concret 3 : Politique réseau avec Cilium

Cilium remplace iptables par un réseau basé sur eBPF, offrant des politiques réseau prenant en compte l'identité, un chiffrement transparent et des performances nettement supérieures. Sur Kubernetes, il s'impose comme CNI par défaut, et ce à juste titre.

Cilium sur un serveur autonome (Service Mesh Lite)

# Install Cilium CLI
CILIUM_CLI_VERSION=$(curl -s https://raw.githubusercontent.com/cilium/cilium-cli/main/stable.txt)
curl -L --remote-name-all \
  https://github.com/cilium/cilium-cli/releases/download/${CILIUM_CLI_VERSION}/cilium-linux-amd64.tar.gz
tar xzvf cilium-linux-amd64.tar.gz -C /usr/local/bin
rm cilium-linux-amd64.tar.gz

# On Kubernetes cluster
cilium install --version 1.16
cilium status --wait

# Check eBPF programs loaded by Cilium
bpftool prog list | grep -i cilium | wc -l
echo "Cilium eBPF programs loaded"

# Monitor network flows in real time (like tcpdump but identity-aware)
cilium monitor --type drop    # Show dropped packets
cilium monitor --type trace   # Show all traffic

Politique réseau basée sur eBPF (sans iptables)

# Verify Cilium bypasses iptables
iptables -L | grep -c CILIUM
# Should return 0 — Cilium uses eBPF maps, not iptables chains

# Check eBPF maps used for network policy
bpftool map list | grep cilium_policy
bpftool map dump name cilium_policy | head -20

# Performance comparison: eBPF vs iptables (simplified)
# eBPF = O(1) lookup in hash maps
# iptables = O(n) linear scan through rules
# At 10,000 rules: eBPF is ~100x faster

Cas d'utilisation concret n° 4 : Profilage des performances

Lorsque votre application est lente et que vous ne parvenez pas à en déterminer la raison, le profilage basé sur eBPF vous fournit des graphiques de flammes au niveau du noyau — aucune instrumentation de votre code n’est requise.

# Install BCC tools
apt-get install -y bpfcc-tools  # Ubuntu
# Tools are in /usr/sbin/ with -bpfcc suffix

# CPU profiling — sample stack traces at 99Hz for 30 seconds
profile-bpfcc -F 99 -f 30 > /tmp/flame.txt

# Generate flame graph (requires FlameGraph tools)
git clone https://github.com/brendangregg/FlameGraph /opt/FlameGraph
/opt/FlameGraph/flamegraph.pl /tmp/flame.txt > /tmp/flame.svg
# Open flame.svg in browser — identifies hotspots instantly

# Off-CPU analysis — find where threads are sleeping/blocked
offcputime-bpfcc -df 30 > /tmp/offcpu.txt
/opt/FlameGraph/flamegraph.pl --color=io --title="Off-CPU" \
  /tmp/offcpu.txt > /tmp/offcpu.svg

# Memory allocation profiling — find memory hogs by allocation site
memleak-bpfcc -p $(pgrep nginx) --top 10

# Track syscall frequency per process (5 second window)
syscount-bpfcc -d 5 -L -p $(pgrep python3)

Renforcement de la sécurité : restreindre l’accès à eBPF

eBPF est un langage puissant ; il est donc essentiel de limiter son utilisation en production. Par défaut, le chargement de programmes eBPF nécessite CAP_BPF ou CAP_SYS_ADMIN. Voici comment le sécuriser :

# Check current eBPF privilege requirements
sysctl kernel.unprivileged_bpf_disabled
# 0 = unprivileged users can use eBPF (dangerous)
# 1 = only root (CAP_SYS_ADMIN) can use eBPF
# 2 = permanently locked to privileged only

# Restrict eBPF to privileged users only
sysctl -w kernel.unprivileged_bpf_disabled=1

# Make persistent
echo "kernel.unprivileged_bpf_disabled = 1" >> /etc/sysctl.d/99-ebpf-hardening.conf
sysctl -p /etc/sysctl.d/99-ebpf-hardening.conf

# Audit which eBPF programs are currently loaded
bpftool prog list
bpftool prog list | awk '{print $1, $2, $4}' | column -t

# Check which eBPF maps exist (data structures used by eBPF programs)
bpftool map list | column -t

# Enable audit logging for BPF syscalls
# Add to /etc/audit/rules.d/bpf.rules:
echo '-a always,exit -F arch=b64 -S bpf -k bpf_syscall' \
  >> /etc/audit/rules.d/bpf.rules
auditctl -R /etc/audit/rules.d/bpf.rules

Liste de contrôle de démarrage rapide pour la production

Voici une liste de contrôle condensée pour passer de zéro à une protection renforcée contre eBPF en moins d'une heure :

#!/bin/bash
# eBPF Production Readiness Check
echo "=== eBPF Production Readiness ==="

# 1. Kernel version
KERNEL=$(uname -r | cut -d. -f1,2)
echo "[1] Kernel: $(uname -r)"
[ $(echo "$KERNEL >= 5.8" | bc -l) -eq 1 ] && echo "    ✓ Version OK" || echo "    ✗ Upgrade needed (min 5.8)"

# 2. BTF support
[ -f /sys/kernel/btf/vmlinux ] && echo "[2] ✓ BTF available (CO-RE programs supported)" || echo "[2] ✗ BTF missing"

# 3. BPF filesystem
mount | grep -q bpffs && echo "[3] ✓ BPFfs mounted" || echo "[3] ✗ BPFfs not mounted — run: mount -t bpf bpffs /sys/fs/bpf"

# 4. Privilege restriction
PRIV=$(sysctl -n kernel.unprivileged_bpf_disabled 2>/dev/null)
[ "$PRIV" = "1" ] || [ "$PRIV" = "2" ] && echo "[4] ✓ Unprivileged BPF disabled" || echo "[4] ✗ WARNING: Unprivileged BPF enabled — set kernel.unprivileged_bpf_disabled=1"

# 5. Falco running
systemctl is-active falco &>/dev/null && echo "[5] ✓ Falco runtime security active" || echo "[5] ✗ Falco not running"

# 6. bpftool available
which bpftool &>/dev/null && echo "[6] ✓ bpftool installed" || echo "[6] ✗ Install bpftool"

echo "=== Check complete ==="

Conclusion

eBPF a fondamentalement transformé les possibilités offertes par Linux. En 2026, cette technologie n'est plus à la pointe du progrès : elle est désormais incontournable pour les infrastructures. Les hyperscalers l'utilisent à l'échelle du pétaoctet. Vos serveurs peuvent dès aujourd'hui bénéficier de cette même technologie grâce à des outils comme bpftrace , Falco et Cilium .

Les points clés à retenir :

  • Observabilité : bpftrace vous offre un traçage au niveau du noyau en quelques lignes de commande — fini les devinettes sur les raisons de la lenteur de votre application
  • Sécurité : Falco, avec le pilote eBPF, assure une détection des menaces en temps réel impossible à contourner par des attaquants dans l'espace utilisateur.
  • Réseau : Cilium remplace iptables par des mappages BPF, offrant ainsi de meilleures performances et des politiques prenant en compte l'identité.
  • Renforcement de la sécurité : Limiter les accès au chargement des programmes eBPF et auditer tous les appels système BPF.

Prochaines étapes :

  • Commencez par les phrases courtes bpftrace — la courbe d'apprentissage est douce et les résultats sont immédiats.
  • Déployez Falco avec le pilote eBPF en priorité sur vos serveurs les plus critiques.
  • Explorez la carte de l'écosystème ebpf.io pour trouver les outils adaptés à votre cas d'utilisation spécifique.
  • Découvrez le répertoire d'outils BCC — plus de 100 scripts prêts à l'emploi
  • Suivez le travail de Brendan Gregg , pionnier de l'analyse des performances Linux avec eBPF.

L'ère des angles morts dans l'infrastructure Linux touche à sa fin. eBPF voit tout — et maintenant, vous aussi.

Read more