Votre équipe veut comprendre eBPF avant d’en dépendre, mais personne ne sait par où commencer. Le dépôt eunomia-bpf/bpf-developer-tutorial propose un tutoriel eBPF en leçons courtes, chacune dans son dossier, avec des exemples en C, Go et Rust. La vraie question d’exploitation n’est pas « quelle leçon est la plus belle ? » mais « quelle leçon peut tourner sur nos noyaux, et laquelle apprend ce dont on a besoin ? ».
Je pars donc de ce choix plutôt que d’un résumé du sommaire. Honnêteté : span.observer n’a installé ni exécuté aucune leçon. J’ai cloné le dépôt le 11 novembre 2026 (dernier commit lu : 5 septembre 2026) et lu le README, le fichier LICENSE, la matrice src/compatibility.md et, en entier ou en grande partie, les leçons 1, 4, 9 et 11. Le reste du sommaire n’a été lu que dans ses titres. Le nombre d’étoiles n’a pas pu être relu à la source : je ne le cite pas.
Tutoriel eBPF : ce que contient le dépôt, et sous quelle licence
Le README décrit un tutoriel fondé sur CO-RE (Compile Once, Run Everywhere). Il se veut pratique : des outils très courts, « à partir de vingt lignes de code », sans longue théorie. Il utilise libbpf, Cilium, libbpf-rs et eunomia-bpf, et non BCC. Le dossier src/ contient 55 dossiers numérotés, et le README les range en grandes familles : premiers pas, projets complets avec libbpf, puis sujets avancés (réseau, traçage, sécurité, ordonnanceur, GPU).
La licence est la MIT : le fichier LICENSE en porte le texte, et le README conclut par « MIT ». Vous pouvez donc copier un exemple dans votre propre dépôt en gardant la mention. Une nuance : les programmes noyau des leçons déclarent leurs propres licences. La leçon 1 affiche Dual BSD/GPL dans le code et la leçon 4 GPL. Le noyau exige une licence compatible GPL au chargement, donc lisez l’en-tête de chaque fichier avant de le réutiliser.
Choisir son point d’entrée selon votre noyau
Avant de lire une ligne de C, lisez la matrice de compatibilité. Le projet la génère à partir des métadonnées de chaque leçon et l’explique avec prudence : « Not in CI » ne veut pas dire qu’un test manuel a eu lieu, et une version de noyau seule ne garantit rien, car une distribution peut désactiver une option. Elle compte 65 lignes. D’après mon décompte : 23 testées à l’exécution en CI, 31 seulement compilées en CI, 8 hors CI et 3 limitées à la documentation.

Trois colonnes décident de votre parcours :
- le noyau minimal : 4.8 pour les leçons 1 et 4, 5.2 pour les leçons 7, 9, 20 et 21, 5.7 pour la leçon 19 (LSM) ;
- BTF : « Required » pour la plupart des leçons après la 2. Sans
/sys/kernel/btf/vmlinux, ces leçons ne conviennent pas à votre machine ; - le statut des tests : préférez une leçon « CI runtime » pour apprendre, car quelqu’un l’a vue tourner.
Ma lecture : un nœud de production avec un noyau de distribution récent et BTF vous ouvre presque tout. Un vieux noyau d’entreprise vous limite aux leçons 1 et 4. Mieux vaut le savoir avant de planifier une formation.
Premier programme : un hello world qui parle au noyau
La leçon 1 attache une petite fonction au point de trace sys_enter_write. Chaque appel système write déclenche donc un message. Voici le fichier réel du dépôt.

Trois détails méritent l’attention d’un SRE. La licence Dual BSD/GPL est déclarée dans le programme lui-même. Le filtre pid_filter évite d’inonder la sortie. Enfin, bpf_printk écrit dans trace_pipe, partagé par tous les programmes eBPF de la machine. La leçon le dit elle-même : cette sortie est limitée à trois paramètres et pénalise les événements très fréquents. Pour la production, elle renvoie vers les tampons circulaires et les tableaux d’événements perf des leçons suivantes.
Pour compiler, la leçon 1 utilise les outils ecc (compilation) et ecli (exécution) d’eunomia-bpf, ou une image Docker. La leçon 11 prend l’autre route, libbpf natif, avec apt install clang libelf1 libelf-dev zlib1g-dev puis make. Choisissez une route et tenez-vous-y : mélanger les deux chaînes d’outils est la meilleure façon de perdre une après-midi.
Du hello world à la mesure : la leçon 9 en exemple
La leçon 4 apprend à passer un paramètre depuis l’espace utilisateur : la variable const volatile int pid_target filtre les ouvertures de fichiers d’un seul processus, directement dans le noyau. C’est utile : on n’envoie pas d’événements qu’on jette ensuite.
La leçon 9, elle, parle d’un sujet d’astreinte : la latence de la file d’exécution. Combien de temps un processus prêt attend-il avant d’obtenir un cœur ? Le programme runqlat répond par un histogramme. Voici la sortie d’exemple du README de la leçon, reproduite telle quelle.

Lisez l’histogramme comme un SLI : la masse est entre 0 et 15 microsecondes, et une queue apparaît vers la milliseconde. C’est la queue qui fait mal à un service sensible à la latence. Cette sortie vient du README, pas de mes essais, sur un système que la leçon décrit comme très chargé. Elle illustre le format, pas votre charge. Pour voir cette idée sur un parc Kubernetes, voir /?s=linnix+observabilite+linux+ebpf, qui s’attaque à la même attente avec les compteurs de pression du noyau.
Où ce tutoriel s’arrête
- Il enseigne à écrire des sondes, pas à exploiter un produit. Pour une instrumentation prête à l’emploi, voir https://span.observer/fr/grafana-beyla-ebpf-auto-instrumentation/.
- Les leçons de sécurité (24 à 28, 34) montrent aussi des techniques offensives, comme masquer un processus. Lisez-les en connaissance de cause et jamais sur une machine partagée.
- Les leçons dépendent des versions d’outils et de noyaux : la matrice le dit elle-même. Rien ne remplace un essai sur votre distribution.
- Les textes sont en anglais, avec une version chinoise. Je n’ai pas relu la qualité de chaque traduction.
- Charger un programme eBPF demande des privilèges élevés. Ce n’est pas un tutoriel à suivre sur un nœud de production.
Bonnes pratiques pour apprendre eBPF en équipe
- Cherchez d’abord le noyau minimal et le besoin de BTF dans la matrice, avant d’ouvrir la leçon.
- Travaillez dans une machine virtuelle jetable, avec un noyau récent.
- Commencez par les leçons 1, 4 et 9, puis choisissez une famille selon votre métier : réseau, traçage ou sécurité.
- Mesurez le coût d’une sonde sur votre charge avant de la proposer à l’exploitation.
- Pour le côté réseau en cluster, comparez avec https://span.observer/fr/ebpf-kubernetes-cilium-hubble-flux-reseau/ et https://span.observer/fr/ebpf-sans-sidecar-service-mesh/.
Questions fréquentes
Faut-il savoir écrire du C pour suivre ce tutoriel eBPF ?
Oui pour les leçons avec libbpf ou eunomia-bpf : les exemples du dépôt sont écrits en C. Le README mentionne aussi des exemples en Go et en Rust, que je n’ai pas lus.
Peut-on réutiliser le code des leçons dans un projet d’entreprise ?
Le dépôt est sous licence MIT, ce qui l’autorise avec mention du copyright. Les programmes noyau portent leurs propres déclarations (GPL ou double licence BSD/GPL). Faites relire ce point par votre juriste.
Quel noyau faut-il pour commencer ?
La leçon 1 annonce un minimum de 4.8 et recommande 5.15 ou plus récent. La plupart des leçons suivantes demandent BTF : vérifiez la présence de /sys/kernel/btf/vmlinux.
Conclusion
Ce tutoriel eBPF a un atout : il vous laisse mesurer avant de vous engager. Lisez la matrice, faites les leçons 1, 4 et 9 dans une machine jetable, puis décidez si eBPF mérite une place dans votre pile. Le dépôt est un bon terrain d’apprentissage, pas une garantie pour la production.
Ce blog est indépendant et non affilié à Dynatrace LLC. bpf-developer-tutorial est un projet tiers, non édité par Dynatrace.