Foreword
Read little, type a lot. From “Dockerfiles hands-on” and “Docker
Compose hands-on” you know docker build,
docker run and docker compose up. Around these
three commands, though, a whole toolbox has grown: Podman runs without a
daemon and without root, Quadlet turns containers into systemd services,
crane and skopeo copy images between registries without ever unpacking
them, trivy and grype find vulnerabilities, syft writes the bill of
materials and cosign signs the whole thing.
This book introduces 34 of these tools, and it does so in a way that
lets you really know each one: What is it for, how do you install it
cleanly, how does it work, and what exactly do you do with it? Every
tool gets its own section with a profile, installation with a verified
checksum, a short explanation and examples – using the demo application
notes, which you know from the sister books, and public
images such as docker.io/library/nginx.
Until Day 14, docker itself barely appears: you install
Docker CE on Day 13, because docker scout does not run without it. Day
15 then deliberately catches up on the Docker tools – the CLI with
contexts, Buildx, Compose, Colima for the Mac and Scaffdog for project
scaffolds.
The book is aimed at developers, platform engineers, and ops and security people who have mastered Dockerfiles and Compose and now want to know which tool is the right one for which job – and why.
The training rules
- Type, don’t copy. Every command once by yourself.
- Compare with Expected. After every drill you find what you should see. If it differs, that is where the real lesson is.
- Pass the checkpoint. Only when every command shows what is expected do you move on.
- Solve the challenge on your own. First the hint, then the solution.
- Lab values stay in the lab.
lab-api-key-123,lab-db-pw-123,lab-registry-pw-123,lab-cosign-pw-123and all otherlab-…values are practice data. A real password or token never belongs in a file from this book.
Warning: All output in the book comes from real test runs. Container IDs, digests, times, IP addresses and image sizes will differ on your machine. What matters is what happens: which command works, which one fails and why.
Structure of each training day
| Section | Purpose |
|---|---|
| Briefing | The essentials in a few bullet points |
| Drills | Commands with expected output, a profile for each tool |
| Checkpoint | Check script: did everything work? |
| Challenge | A task without instructions |
| Enterprise Note | What is different in production |
The training plan
| Part | Day | Tools |
|---|---|---|
| Ground | 0 | Lab VM, installation principle, all tools, notes |
| A – Podman | 1 | podman: run, build, short names, rootful
and rootless |
| 2 | podman rootless in detail, pods,
kube generate/kube play |
|
| 3 | Quadlet: containers as systemd services,
auto-update |
|
| 4 | Podman socket, podman compose, lazydocker, ctop |
|
| B – Building and runtimes | 5 | buildah, ko |
| 6 | ctr, nerdctl, buildctl, BuildKit with Lima (Mac) | |
| C – Registries and clusters | 7 | your own registry with TLS, crane |
| 8 | skopeo, regctl | |
| 9 | regsync, oras | |
| 10 | kind, crictl, krane | |
| D – Inspecting and securing | 11 | dive, diffoci, container-diff |
| 12 | hadolint, dockle, ShellCheck | |
| 13 | trivy, grype, docker scout | |
| 14 | syft, cosign | |
| E – Docker tools | 15 | docker (contexts), Buildx, Bake, Docker Compose, Colima, Scaffdog |
| Competition | 16 | Disaster drills across all tools |
| Appendix | A | Cheat sheet: installation and core commands |
| B | Final exam: from Containerfile to Quadlet |
Part A makes you familiar with Podman, the tool you use to start
containers throughout the whole book: first like docker,
then without root, in pods, as a systemd service and behind a
Docker-compatible socket. Part B builds images without a Docker daemon
and looks under the hood of containerd. Part C runs your own registry
and moves images, manifests and artifacts between registries and into a
Kubernetes cluster. Part D takes images apart into their layers, checks
them against rules and vulnerability databases and signs them together
with their bill of materials. Part E catches up on the Docker tools,
from the CLI to Colima on the Mac. Day 16 trains for the emergency,
Appendix B puts everything together into a pipeline.
The lab
Everything runs in an Ubuntu 26.04 VM. In the book you create it with
Multipass on a Mac, ct-lab with 2 CPUs, 4 GB RAM and a 40
GB disk. Any other Ubuntu 26.04 VM with SSH and sudo works
just the same, including in the cloud or under Linux on your own
machine. You work as user ubuntu in ~/ct-lab,
rootless; you only need sudo for packages, for the
comparison with rootful Podman and on a few days for system
services.
Podman, Buildah, Skopeo and ShellCheck come from the Ubuntu packages,
all other tools as release binaries from GitHub, pinned in
setup/tools.lock and verified against their SHA-256
checksum before installation. From Day 7 on, your own registry
registry.ct.lab:5000 with TLS and login
lab/lab-registry-pw-123 joins in.
You fetch the companion code with all scripts, Containerfiles and the
state of each day on Day 0 via git clone from
github.com/thomaszachmann/container-tools-zum-anfassen.
Tip: The tested versions are listed on Day 0. If an option differs on your machine,
--helpormaninside the VM will help, not a blog post from 2019.
The sister books
- “Dockerfiles hands-on” – the three notes images, multi-stage, non-root, cache.
- “Docker Compose hands-on” – notes with Postgres as a Compose stack.
- “Kubernetes hands-on” – notes in the cluster.
- “Secure supply chains hands-on” – signatures, SBOMs and policies in the pipeline in depth.
You need none of them to work through this book. The Dockerfiles and the demo application are ready in the companion code.
Let’s go.
Thomas Zachmann, 2026