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,--contextund 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 einercompose.yaml– das Original zupodman composeaus 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 lsErwartet:
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-apiErwartet (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 lsErwartet:
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=$BUILDPLATFORMauf amd64 und lässt Go mitGOARCH=$TARGETARCHquer kompilieren. EinRUNauf arm64 bräuchte dagegen QEMU (binfmt). - Unter dem Tag liegt ein Index mit beiden Images.
Die Einträge
unknown/unknownsind die Provenance-Attestations, die Buildx standardmäßig mitschiebt. - Mit dem eingebauten Builder
defaultginge 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")"; doneErwartet:
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=unconfinedhängt Postgres beim Start mit voller CPU und wird nie gesund. Das AppArmor-Profildocker-defaultverbietet dem Einstiegs-Helfergosuund Postgres Signale an die eigenen Prozesse – dieselbe Falle wie beinerdctl-defaultan 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 -1Erwartet:
{"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-rosettaHomebrew 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 versionErwartet (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] listErwartet:
---
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/nullErwartet:
✔ 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 PlatformErwartet:
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
remoteoderkubernetes) 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.