Skip to content
Hands-on IT IT Drills

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

  1. Type, don’t copy. Every command once by yourself.
  2. Compare with Expected. After every drill you find what you should see. If it differs, that is where the real lesson is.
  3. Pass the checkpoint. Only when every command shows what is expected do you move on.
  4. Solve the challenge on your own. First the hint, then the solution.
  5. Lab values stay in the lab. lab-api-key-123, lab-db-pw-123, lab-registry-pw-123, lab-cosign-pw-123 and all other lab-… 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, --help or man inside 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