Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 15: Docker-Werkzeuge – docker, Buildx, Compose, Colima, Scaffdog

Ziel: Du richtest das Docker-CLI mit Kontexten gezielt auf Docker oder Podman, baust mit Buildx für zwei Plattformen in deine Registry, startest notes mit Docker Compose, kennst Colima als Docker-Unterbau auf dem Mac und erzeugst ein Projektgerüst mit Scaffdog. · Dauer: ca. 120 min · Voraussetzung: Tag 13 (Docker CE), Tag 7

Briefing

  • Das Docker-CLI ist nur ein Client der Docker-Engine-API. Wohin es spricht, bestimmen DOCKER_HOST, --context und der aktive Kontext – in dieser Reihenfolge.
  • Buildx ist das Build-Plugin des CLI und spricht mit BuildKit. Ein eigener Builder (BuildKit im Container) kann für mehrere Plattformen bauen und direkt in eine Registry schieben; Bake baut mehrere Images aus einer Datei.
  • Docker Compose (Plugin docker compose) startet mehrere Container aus einer compose.yaml – das Original zu podman compose aus Tag 4.
  • Colima startet auf dem Mac eine kleine Linux-VM mit Docker Engine (über Lima) und richtet einen Docker-Kontext darauf ein.
  • Scaffdog erzeugt Dateien aus Markdown-Vorlagen – zum Beispiel ein neues Dienst-Gerüst mit Dockerfile, das hadolint auf Anhieb besteht.
 docker ─┬─ DOCKER_HOST / --context ─► Docker CE  │  Podman-Socket  │  Colima-VM
         ├─ buildx ─► Builder ct-lab (moby/buildkit) ─► registry.ct.lab:5000
         └─ compose ─► compose.yaml ─► db, migrate, api, web
 scaffdog (Node im Container) ─► notes-report/{Dockerfile,main.go,…}

Drill 1: docker – das CLI und seine Kontexte

Steckbrief docker (CLI)
Aufgabe Client für die Docker-Engine-API: bauen, starten, verwalten
Besonderheit spricht mit jedem API-Endpunkt; Erweiterungen als CLI-Plugins
Projekt github.com/docker/cli (Apache-2.0), Doku: docs.docker.com/reference/cli
Version im Buch 29.9.2 (Paket docker-ce-cli, seit Tag 13 installiert)

Seit Tag 4 steht in deiner ~/.bashrc ein DOCKER_HOST auf den Podman-Socket. In einer neuen Shell spricht docker deshalb mit Podman:

source ~/ct-lab/setup/env.sh
mkdir -p ~/ct-lab/tag15 && cd ~/ct-lab/tag15
cp -R "$LAB/code/notes/." .
echo "$DOCKER_HOST"
docker version --format '{{.Client.Version}} / {{.Server.Version}}'
docker context ls

Erwartet:

unix:///run/user/1000/podman/podman.sock
29.9.2 / 5.7.0
NAME        DESCRIPTION                               DOCKER ENDPOINT                …
default *   Current DOCKER_HOST based configuration   unix:///run/user/1000/podman/pod…
Warning: DOCKER_HOST environment variable overrides the active context. To use a contex…

Client 29.9.2, Server 5.7.0 – das ist Podman. Sauberer als eine Umgebungsvariable ist ein Kontext: ein benannter Endpunkt, den du pro Befehl mit --context wählst.

docker context create podman --description "Podman rootless" \
  --docker "host=unix://$XDG_RUNTIME_DIR/podman/podman.sock"
unset DOCKER_HOST
docker context ls
docker version --format '{{.Client.Version}} / {{.Server.Version}}'
docker --context podman version --format '{{.Server.Version}}'

Erwartet:

podman
Successfully created context "podman"
NAME        DESCRIPTION                               DOCKER ENDPOINT                …
default *   Current DOCKER_HOST based configuration   unix:///var/run/docker.sock
podman      Podman rootless                           unix:///run/user/1000/podman/pod…
29.9.2 / 29.9.2
5.7.0

Solange DOCKER_HOST gesetzt ist, gewinnt er gegen jeden Kontext – das CLI warnt deshalb schon bei docker context ls. Ohne ihn ist default wieder Docker CE. Kontexte liegen in ~/.docker/contexts; mit docker context use podman wechselst du dauerhaft. Wir bleiben in dieser Shell beim Default und nennen Podman ausdrücklich.

Fortschritt speichern? Kostenlos registrieren

Drill 2: docker – bauen, starten, nachsehen

docker build -q -t ct-lab/notes-api:0.1.0 --build-arg VERSION=0.1.0 notes-api
docker image ls ct-lab/notes-api --format '{{.Repository}}:{{.Tag}} {{.Size}}'
docker run -d --name ct15-api -p 127.0.0.1:8095:8080 \
  -e NOTES_API_KEY=lab-api-key-123 ct-lab/notes-api:0.1.0
sleep 6
curl -s localhost:8095/version; echo
docker ps --filter name=ct15-api --format '{{.Names}}\t{{.Status}}\t{{.Ports}}'
docker exec ct15-api /notes-api healthcheck; echo "Exit: $?"
docker logs ct15-api 2>&1 | tail -1
docker stats --no-stream --format '{{.Name}} {{.MemUsage}}' ct15-api
docker rm -f ct15-api

Erwartet (gekürzt, IDs und Zeiten weichen bei dir ab):

sha256:122f0da849f2…
ct-lab/notes-api:0.1.0 16.4MB
71dbb13839c2…
0.1.0
ct15-api    Up 6 seconds (healthy)  127.0.0.1:8095->8080/tcp
Exit: 0
time=… level=INFO msg=listening addr=:8080 version=0.1.0 pid=1
ct15-api 1.977MiB / 3.911GiB
ct15-api

Die Befehle kennst du von podman – Podman hat sie Docker nachgebaut. Unterschiede: Docker CE hat einen Daemon als root, Images heißen ohne Präfix localhost/, und das Image landet im eigenen Speicher von Docker, nicht bei Podman. docker build ist seit Docker 23 schon Buildx mit dem eingebauten Builder default.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Buildx – ein eigener Builder

Steckbrief Docker Buildx
Aufgabe Builds mit BuildKit: mehrere Plattformen, Cache, Attestations, Bake
Besonderheit Builder-Treiber docker, docker-container, kubernetes, remote
Projekt github.com/docker/buildx (Apache-2.0)
Version im Buch v0.38.1 (Paket docker-buildx-plugin), BuildKit v0.34.1
docker buildx version
docker buildx ls

Erwartet:

github.com/docker/buildx v0.38.1 0dbe87f36ed472fe36b6796c3f70b4210a731fc5
NAME/NODE     DRIVER/ENDPOINT   STATUS     BUILDKIT   PLATFORMS
default*      docker
 \_ default    \_ default       running    v0.34.0    linux/amd64 (+3)
podman        docker-container
 \_ podman     \_ podman        inactive

Zu jedem Kontext zeigt Buildx einen Builder – auch zu podman. Der Builder default steckt im Docker-Daemon und kann nur in Dockers Speicher bauen. Ein eigener Builder mit dem Treiber docker-container startet BuildKit als Container. Er soll deiner Lab-CA vertrauen und – wegen 127.0.0.1 registry.ct.lab – das Netz des Hosts nutzen:

cat > buildkitd.toml <<EOF
# tag15/buildkitd.toml – Stand Ende Tag 15: BuildKit vertraut der Lab-CA
[registry."$REG"]
  ca = ["$LAB/registry/certs/ca.crt"]
EOF
docker buildx create --name ct-lab --driver docker-container \
  --driver-opt image=docker.io/moby/buildkit:v0.34.1 --driver-opt network=host \
  --buildkitd-config buildkitd.toml --bootstrap 2>&1 | tail -2
docker buildx inspect ct-lab | grep -E '^Driver|^Status|^BuildKit version|^Platforms'

Erwartet:

#1 DONE 23.8s
ct-lab
Driver:        docker-container
Driver Options:        image="docker.io/moby/buildkit:v0.34.1" network="host"
Status:                running
BuildKit version:      v0.34.1
Platforms:             linux/amd64, linux/amd64/v2, linux/amd64/v3, linux/386

Buildx kopiert die CA-Datei aus buildkitd.toml beim Anlegen in den Container. Ohne --use bleibt default der aktive Builder; den neuen wählst du mit --builder ct-lab.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Buildx – zwei Plattformen in die eigene Registry

Für --push braucht Buildx einen Login – den macht docker login und legt ihn in ~/.docker/config.json ab, wo crane und cosign ihn seit Tag 7 auch lesen:

echo "$REG_PASS" | docker login "$REG" -u "$REG_USER" --password-stdin 2>&1 | tail -1
docker buildx build --builder ct-lab --platform linux/amd64,linux/arm64 \
  --build-arg VERSION=0.1.0 -t "$REG/lab/notes-api:0.1.0" --push notes-api 2>&1 \
  | grep -E 'pushing manifest|ERROR' | tail -1 | cut -c1-88
docker buildx imagetools inspect "$REG/lab/notes-api:0.1.0" \
  | grep -E '^MediaType|Platform'

Erwartet (gekürzt):

Login Succeeded
#16 pushing manifest for registry.ct.lab:5000/lab/notes-api:0.1.0@sha256:769ddc950…
MediaType: application/vnd.oci.image.index.v1+json
  Platform:    linux/amd64
  Platform:    linux/arm64
  Platform:    unknown/unknown
  Platform:    unknown/unknown
  • Der Builder hat keine arm64-Plattform und braucht auch keine: Das Dockerfile baut mit FROM --platform=$BUILDPLATFORM auf amd64 und lässt Go mit GOARCH=$TARGETARCH quer kompilieren. Ein RUN auf arm64 bräuchte dagegen QEMU (binfmt).
  • Unter dem Tag liegt ein Index mit beiden Images. Die Einträge unknown/unknown sind die Provenance-Attestations, die Buildx standardmäßig mitschiebt.
  • Mit dem eingebauten Builder default ginge das nicht in deine Registry: Dem Docker-Daemon müsstest du die CA gesondert geben.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Buildx – Bake für alle drei Images

Bake liest die Builds aus einer Datei (HCL, JSON oder compose.yaml) und baut sie parallel. Die Datei liegt im Begleitcode:

cp "$LAB/code/tag15/notes/docker-bake.hcl" .
grep -E '^(variable|group|target)|platforms' docker-bake.hcl
docker buildx bake --print 2>/dev/null \
  | jq -c '.target | to_entries[] | {t: .key, p: .value.platforms}'

Erwartet:

variable "REG" {
variable "VERSION" {
group "default" {
target "_common" {
  platforms = ["linux/amd64"]
target "api" {
  platforms = ["linux/amd64", "linux/arm64"]   # Go kompiliert quer, ohne QEMU
target "worker" {
target "web" {
{"t":"api","p":["linux/amd64","linux/arm64"]}
{"t":"web","p":["linux/amd64"]}
{"t":"worker","p":["linux/amd64"]}

_common ist ein abstraktes Target, das die anderen per inherits erben. Worker (Python) und Web (Node) führen RUN-Schritte auf der Zielplattform aus und bleiben deshalb bei amd64. --print zeigt das aufgelöste Ergebnis, ohne zu bauen.

docker buildx bake --builder ct-lab --push --progress=quiet && echo gepusht
for r in notes-api notes-worker notes-web; do echo "$r: $(crane ls "$REG/lab/$r")"; done

Erwartet:

gepusht
notes-api: 0.1.0
notes-worker: 0.1.0
notes-web: 0.1.0

Fortschritt speichern? Kostenlos registrieren

Drill 6: Docker Compose – notes mit einem Befehl

Steckbrief Docker Compose
Aufgabe Mehrere Container, Netze und Volumes aus einer compose.yaml
Besonderheit CLI-Plugin docker compose; baut mit Buildx, wartet auf Healthchecks
Projekt github.com/docker/compose (Apache-2.0), Spezifikation: compose-spec.io
Version im Buch v5.6.1 (Paket docker-compose-plugin)

Die Tiefe steht in „Docker Compose zum Anfassen”. Hier zählt das Zusammenspiel: Compose baut die Images aus dem Quellcode, wartet auf die Datenbank, lässt die Migration laufen und startet web erst, wenn api gesund ist.

cp "$LAB/code/tag15/notes/compose.yaml" .
grep -E '^  [a-z]+:|apparmor|condition' compose.yaml
docker compose version
docker compose up -d --build --wait 2>&1 | grep -E 'Built|Healthy' | head -4
docker compose ps -a --format '{{.Service}}\t{{.Status}}'

Erwartet:

  db:
      - apparmor=unconfined    # Ubuntu 26.04: docker-default verbietet gosu Signale
  migrate:
        condition: service_healthy
  api:
        condition: service_completed_successfully
  web:
        condition: service_healthy      # HEALTHCHECK aus dem Dockerfile
  pgdata:
Docker Compose version v5.6.1
 Image ct-lab/notes-api:0.1.0 Built
 Image ct-lab/notes-web:0.1.0 Built
 Container ct15-db-1 Healthy
 Container ct15-api-1 Healthy
api Up 3 seconds (healthy)
db  Up 14 seconds (healthy)
migrate Exited (0) 3 seconds ago
web Up 1 second

Achtung: Ohne apparmor=unconfined hängt Postgres beim Start mit voller CPU und wird nie gesund. Das AppArmor-Profil docker-default verbietet dem Einstiegs-Helfer gosu und Postgres Signale an die eigenen Prozesse – dieselbe Falle wie bei nerdctl-default an Tag 6 (sudo journalctl -k | grep DENIED).

curl -s -X POST -H 'X-API-Key: lab-api-key-123' -H 'Content-Type: application/json' \
  -d '{"text":"aus Docker Compose"}' localhost:8096/notes; echo
until curl -fs -o /dev/null localhost:3006/healthz; do sleep 1; done
curl -s localhost:3006/api/notes | jq -r '.[].text'
docker compose down 2>&1 | tail -1
docker compose up -d --wait >/dev/null 2>&1
curl -s localhost:8096/notes | jq -r '.[].text'
docker compose down 2>&1 | tail -1

Erwartet:

{"id":"34d9711a-…","text":"aus Docker Compose"}
aus Docker Compose
 Network ct15_default Removed
aus Docker Compose
 Network ct15_default Removed

down entfernt Container und Netz, das Volume ct15_pgdata bleibt – die Notiz überlebt. Erst down -v löscht auch die Daten. --wait wartet, bis alle Dienste laufen und gesund sind; web hat keinen Healthcheck und gilt mit dem Start als bereit, darum die Schleife vor dem curl.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Colima – Docker auf dem Mac

Steckbrief Colima
Aufgabe Container-Laufzeit auf macOS (und Linux) in einer Lima-VM
Besonderheit Docker oder containerd, optional k3s; legt Docker-Kontext colima an
Projekt github.com/abiosoft/colima (MIT)
Version im Buch v0.10.3, Lima 2.2.1

Docker Engine braucht einen Linux-Kernel. Docker Desktop bringt dafür eine VM mit, Colima ist die schlanke, freie Alternative. Auf dem Mac, nicht in der VM ct-lab:

brew install colima docker docker-buildx docker-compose
mkdir -p ~/.docker && [ -f ~/.docker/config.json ] || echo '{}' > ~/.docker/config.json
jq --arg d "$(brew --prefix)/lib/docker/cli-plugins" '.cliPluginsExtraDirs = [$d]' \
  ~/.docker/config.json > /tmp/config.json && mv /tmp/config.json ~/.docker/config.json
colima start --cpu 2 --memory 4 --disk 40 --vm-type vz --vz-rosetta

Homebrew legt die Plugins docker-buildx und docker-compose unter $(brew --prefix)/lib/docker/cli-plugins ab; cliPluginsExtraDirs sagt dem CLI, wo es sie findet. --vm-type vz nutzt Apples Virtualization.framework, --vz-rosetta führt amd64-Binaries auf Apple Silicon mit Rosetta statt QEMU aus. Danach:

colima status
docker context ls
docker run --rm docker.io/library/alpine:3.24 uname -m
docker buildx version && docker compose version

Erwartet (gekürzt; mit Colima unter Linux und QEMU geprüft – auf dem Mac stehen dort vz, aarch64, /Users/… und die Versionen aus Homebrew):

time="…" level=info msg="colima is running using QEMU"
time="…" level=info msg="arch: x86_64"
time="…" level=info msg="runtime: docker"
time="…" level=info msg="docker socket: unix:///home/…/.config/colima/default/docker.so…
NAME       DESCRIPTION                               DOCKER ENDPOINT                 …
colima *   colima                                    unix:///home/…/.config/colima/…
default    Current DOCKER_HOST based configuration   unix:///var/run/docker.sock
x86_64
github.com/docker/buildx v0.38.1 0dbe87f36ed472fe36b6796c3f70b4210a731fc5
Docker Compose version v5.6.1

Colima legt den Kontext colima an und macht ihn zum aktiven. Alles aus diesem Tag funktioniert damit auf dem Mac genauso – Buildx, Compose, Kontexte. Weitere Befehle:

colima list                      # alle Profile mit CPU, RAM, Platte, Laufzeit
colima ssh                       # Shell in der VM
colima start --kubernetes        # zusätzlich k3s, Kontext für kubectl
colima stop / colima delete      # anhalten / VM samt Daten löschen
docker context use default       # zurück zu Docker Desktop oder einem anderen Kontext

Fortschritt speichern? Kostenlos registrieren

Drill 8: Scaffdog – Gerüste aus Markdown

Steckbrief Scaffdog
Aufgabe Dateien und Ordner aus Markdown-Vorlagen erzeugen
Besonderheit Vorlage = .md-Datei; Fragen im Frontmatter, Platzhalter {{ }}
Projekt github.com/scaffdog/scaffdog (MIT), Doku: scaff.dog
Version im Buch 4.1.0 (npm), ausgeführt in node:26.13.0-alpine

Scaffdog ist ein Node-Programm. Statt Node auf der VM zu installieren, läuft es per npx in einem Wegwerf-Container, mit deiner UID, damit die Dateien dir gehören:

cp -R "$LAB/code/tag15/notes/.scaffdog" .
sed -n '1,10p' .scaffdog/go-dienst.md
grep '^# `' .scaffdog/go-dienst.md
docker pull -q docker.io/library/node:26.13.0-alpine
docker run --rm -u "$(id -u):$(id -g)" -e HOME=/tmp -e NO_COLOR=1 \
  -v "$PWD":/work -w /work \
  docker.io/library/node:26.13.0-alpine npx --yes [email protected] list

Erwartet:

---
name: 'go-dienst'
root: '.'
output: '.'
questions:
  name: 'Name des Dienstes (z. B. notes-report)?'
  port:
    message: 'Port im Container?'
    initial: '8080'
---
# `{{ inputs.name }}/go.mod`
# `{{ inputs.name }}/main.go`
# `{{ inputs.name }}/Dockerfile`
# `{{ inputs.name }}/.dockerignore`
docker.io/library/node:26.13.0-alpine
- go-dienst (.scaffdog/go-dienst.md, 4 templates, 2 questions)
1 file found.

-u setzt deine UID, damit die erzeugten Dateien dir gehören, HOME=/tmp gibt npm einen beschreibbaren Cache, -v und -w hängen den Projektordner als /work ein und machen ihn zum Arbeitsordner. Jede Überschrift # `pfad` mit dem Codeblock darunter wird eine Datei. Ohne -a fragt Scaffdog interaktiv; mit -a name:wert beantwortest du die Fragen im Skript:

docker run --rm -u "$(id -u):$(id -g)" -e HOME=/tmp -e NO_COLOR=1 \
  -v "$PWD":/work -w /work \
  docker.io/library/node:26.13.0-alpine \
  npx --yes [email protected] generate go-dienst -a name:notes-report -a port:8097 --force
hadolint notes-report/Dockerfile && echo "hadolint: keine Befunde"
docker buildx build --builder ct-lab --platform linux/amd64,linux/arm64 \
  -t "$REG/lab/notes-report:0.1.0" --push --progress=quiet notes-report && echo gepusht
docker run -d -q --name ct15-report -p 127.0.0.1:8097:8097 \
  "$REG/lab/notes-report:0.1.0" >/dev/null
sleep 2; curl -s localhost:8097/; docker rm -f ct15-report >/dev/null

Erwartet:

     ✔ notes-report/go.mod
     ✔ notes-report/main.go
     ✔ notes-report/Dockerfile
     ✔ notes-report/.dockerignore
hadolint: keine Befunde
sha256:4ef28eb63696…
gepusht
notes-report läuft

Vom leeren Ordner zum signierbaren Multi-Plattform-Image in drei Befehlen. Die Vorlage gehört ins Team-Repo: Jeder neue Dienst startet mit denselben Regeln (scratch, non-root, gepinnte Basis), statt ein altes Dockerfile zu kopieren.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Der Docker-Kontext podman zeigt auf den Podman-Socket:

cd ~/ct-lab/tag15
unset DOCKER_HOST
docker context ls --format '{{.Name}} {{.DockerEndpoint}}'

Erwartet:

default unix:///var/run/docker.sock
podman unix:///run/user/1000/podman/podman.sock

Der Builder ct-lab läuft:

docker buildx inspect ct-lab | grep '^Status'

Erwartet:

Status:                running

notes-api liegt für zwei Plattformen in der Registry:

docker buildx imagetools inspect "$REG/lab/notes-api:0.1.0" | grep Platform

Erwartet:

  Platform:    linux/amd64
  Platform:    linux/arm64
  Platform:    unknown/unknown
  Platform:    unknown/unknown

Die vier Images liegen in lab/, daneben die regsync-Konfiguration von Tag 9:

crane catalog "$REG" | grep '^lab/'

Erwartet:

lab/notes-api
lab/notes-report
lab/notes-web
lab/notes-worker
lab/regsync-config

Das Gerüst aus Scaffdog besteht hadolint:

hadolint notes-report/Dockerfile; echo "Exit: $?"

Erwartet:

Exit: 0

Challenge

Nimm notes-report in die Bake-Datei auf (Target report, amd64 und arm64) und baue nur dieses Target als Version 0.2.0 in deine Registry.

Hinweis: Variablen einer Bake-Datei lassen sich per Umgebungsvariable gleichen Namens überschreiben; das Target nennst du als Argument.

Lösung

cat >> docker-bake.hcl <<'EOF'

target "report" {
  inherits  = ["_common"]
  context   = "notes-report"
  platforms = ["linux/amd64", "linux/arm64"]
  tags      = ["${REG}/lab/notes-report:${VERSION}"]
}
EOF
VERSION=0.2.0 docker buildx bake --builder ct-lab --push --progress=quiet report \
  && echo gepusht
crane ls "$REG/lab/notes-report"

Erwartet:

gepusht
0.1.0
0.2.0

Das Target steht nicht in der Gruppe default – ein einfaches docker buildx bake baut weiter nur die drei notes-Images.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Docker Desktop ist für größere Firmen lizenzpflichtig. Colima, Rancher Desktop oder Podman Desktop sind freie Alternativen; prüfe vorher, welche Funktionen (Extensions, Scout-Integration, Enhanced Container Isolation) das Team braucht.
  • Builder in CI: Ein gemeinsamer BuildKit (Treiber remote oder kubernetes) mit Registry-Cache (--cache-to type=registry,…) spart Minuten pro Build.
  • QEMU nur, wenn Quer-Kompilieren nicht geht – native arm64-Runner sind schneller und zuverlässiger.
  • Kontexte statt DOCKER_HOST: Benannte Kontexte machen sichtbar, wohin ein Befehl geht – wichtig, sobald entfernte Hosts (host=ssh://…) dazukommen.
  • Vorlagen pflegen: Scaffdog-Vorlagen gehören versioniert ins Plattform-Repo, mit einem CI-Job, der jedes erzeugte Gerüst baut und lintet.