eBPF tutorial: learn step by step with bpf-developer-tutorial

eBPF tutorial: pick lessons from your kernel, read the bpf-developer-tutorial compatibility matrix (MIT licence) and test safely in a disposable machine.
Tutoriel eBPF : apprendre pas à pas avec bpf-developer-tutorial

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.

Excerpt of src/compatibility.md: minimum kernel, BTF requirement and test status for lessons 1, 4, 7, 9, 19, 20 and 21
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.

File src/1-helloworld/minimal.bpf.c: an eBPF program in C that writes a message with bpf_printk on every write system call
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.

Sample runqlat output from lesson 9: histogram of run queue latency in microseconds, most samples between 2 and 3 microseconds
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.

Total
0
Shares
Leave a Reply

Your email address will not be published. Required fields are marked *

Previous Post
codebase-memory-mcp serveur MCP : une carte du code pour agents

codebase-memory-mcp server: a code map for coding agents

Related Posts