Your team wants to understand eBPF before depending on it, but nobody knows where to start. The eunomia-bpf/bpf-developer-tutorial repository offers an eBPF tutorial in short lessons, one folder each, with examples in C, Go and Rust. The real operations question is not « which lesson looks best? » but « which lesson runs on our kernels, and which one teaches what we need? ».
So I start from that choice, not from a summary of the table of contents. A word on honesty: span.observer has not installed or run any lesson. I cloned the repository on 11 November 2026 (last commit read: 5 September 2026) and read the README, the LICENSE file, the src/compatibility.md matrix and, in full or mostly, lessons 1, 4, 9 and 11. For the rest of the list I only read the titles. I could not read the star count at the source, so I do not quote it.
eBPF tutorial: what the repository contains, and its licence
The README describes a tutorial built on CO-RE (Compile Once, Run Everywhere). It aims to be practical: very short tools, « starting with twenty lines of code », and no long theory. It uses libbpf, Cilium, libbpf-rs and eunomia-bpf rather than BCC. The src/ directory holds 55 numbered folders, and the README groups them into families: first steps, full projects with libbpf, then advanced topics (networking, tracing, security, scheduler, GPU).
The licence is MIT: the LICENSE file carries the text, and the README ends with « MIT ». You can copy an example into your own repository if you keep the notice. One nuance: the kernel programs in the lessons declare their own licences. Lesson 1 shows Dual BSD/GPL in the code and lesson 4 shows GPL. The kernel requires a GPL-compatible licence at load time, so read each file’s header before reusing it.
Pick your entry point from your kernel
Before reading a line of C, read the compatibility matrix. The project generates it from each lesson’s metadata and explains it carefully: « Not in CI » does not mean someone tested by hand, and a kernel version alone guarantees nothing, because a distribution may disable an option. It has 65 rows. By my count: 23 tested at runtime in CI, 31 only built in CI, 8 outside CI and 3 documentation only.
Source : github.com
Three columns shape your path:
- the minimum kernel: 4.8 for lessons 1 and 4, 5.2 for lessons 7, 9, 20 and 21, 5.7 for lesson 19 (LSM);
- BTF: « Required » for most lessons after lesson 2. Without
/sys/kernel/btf/vmlinux, those lessons do not suit your machine; - the test status: prefer a « CI runtime » lesson to learn, because someone has seen it run.
My reading: a production node with a recent distribution kernel and BTF opens up almost everything. An old enterprise kernel limits you to lessons 1 and 4. Better to know that before you plan a training session.
First program: a hello world that talks to the kernel
Lesson 1 attaches a small function to the sys_enter_write tracepoint. Every write system call therefore triggers a message. Here is the real file from the repository.
Source : github.com
Three details matter to an SRE. The Dual BSD/GPL licence is declared in the program itself. The pid_filter check keeps the output from flooding. Finally, bpf_printk writes to trace_pipe, which is shared by every eBPF program on the machine. The lesson says so itself: that output takes at most three parameters and hurts on high-frequency events. For production, it points to the ring buffers and perf event arrays of later lessons.
To build, lesson 1 uses eunomia-bpf’s ecc (compile) and ecli (run) tools, or a Docker image. Lesson 11 takes the other road, native libbpf, with apt install clang libelf1 libelf-dev zlib1g-dev and then make. Pick one road and stay on it: mixing the two toolchains is the best way to lose an afternoon.
From hello world to measurement: lesson 9 as an example
Lesson 4 teaches how to pass a parameter from user space: the const volatile int pid_target variable filters file opens for a single process, right inside the kernel. That is useful: you do not ship events only to throw them away.
Lesson 9 covers an on-call topic: run queue latency. How long does a ready process wait before it gets a core? The runqlat program answers with a histogram. Below is the sample output from the lesson’s README, reproduced as it stands.
Source : github.com
Read the histogram like an SLI: most of the mass sits between 0 and 15 microseconds, and a tail appears around a millisecond. That tail is what hurts a latency-sensitive service. This output comes from the README, not from my own runs, on a system the lesson describes as heavily loaded. It shows the format, not your load. To see the same idea applied to a Kubernetes fleet, read https://span.observer/en/linnix-linux-observability-ebpf/, which tackles the same waiting with kernel pressure counters.
Where this tutorial stops
- It teaches how to write probes, not how to run a product. For ready-made instrumentation, read https://span.observer/en/grafana-beyla-ebpf-zero-code-tracing/.
- The security lessons (24 to 28, 34) also show offensive techniques, such as hiding a process. Read them knowingly and never on a shared machine.
- The lessons depend on tool and kernel versions: the matrix says so itself. Nothing replaces a test on your own distribution.
- The texts are in English, with a Chinese version. I did not review the quality of every translation.
- Loading an eBPF program needs elevated privileges. This is not a tutorial to follow on a production node.
Good practice for learning eBPF as a team
- Look up the minimum kernel and the BTF requirement in the matrix before opening the lesson.
- Work in a disposable virtual machine with a recent kernel.
- Start with lessons 1, 4 and 9, then pick a family that fits your job: networking, tracing or security.
- Measure a probe’s cost under your own load before proposing it to operations.
- For the cluster networking side, compare with https://span.observer/en/ebpf-kubernetes-cilium-hubble-network-flows/ and https://span.observer/en/ebpf-without-sidecar-service-mesh/.
Frequently asked questions
Do I need to know C to follow this eBPF tutorial?
Yes for the lessons built on libbpf or eunomia-bpf: the examples in the repository are written in C. The README also mentions Go and Rust examples, which I did not read.
Can I reuse the lesson code in a company project?
The repository is under the MIT licence, which allows it if you keep the copyright notice. The kernel programs carry their own declarations (GPL or dual BSD/GPL). Have your legal team review that point.
Which kernel do I need to start?
Lesson 1 states a minimum of 4.8 and recommends 5.15 or newer. Most later lessons need BTF: check that /sys/kernel/btf/vmlinux exists.
Conclusion
This eBPF tutorial has one strength: it lets you measure before you commit. Read the matrix, do lessons 1, 4 and 9 in a disposable machine, then decide whether eBPF earns a place in your stack. The repository is a good place to learn, not a guarantee for production.
This blog is independent and not affiliated with Dynatrace LLC. bpf-developer-tutorial is a third-party project, not published by Dynatrace.
Originally published on span.observer. French version: https://span.observer/fr/tutoriel-ebpf-bpf-developer-tutorial/.


