Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 8: Base-Images wählen

Ziel: Dasselbe notes-api-Binary auf scratch, distroless, Chainguard und Wolfi vergleichen, Base-Images per Digest pinnen und einen Container ohne Shell debuggen. · Dauer: ca. 70 min · Voraussetzung: Tag 7

Briefing

  • Das Base-Image bestimmt, was neben deinem Programm im Image steckt: libc, Shell, Paketmanager, CA-Zertifikate, Benutzer – und damit Größe, CVE-Zahl und Debugbarkeit.
  • alpine nutzt musl, slim (Debian) glibc. Ein Go-Binary mit CGO_ENABLED=0 braucht keine von beiden.
  • distroless und Chainguard static sind fast leer, aber mit Zertifikaten, Zeitzonen und /etc/passwd; scratch ist ganz leer.
  • Ein Tag ist ein Name, der wandern kann. Nur der Digest garantiert dasselbe Image.
 Inhalt        scratch  distroless/static  chainguard/static  wolfi-base  slim/alpine
 libc          –        –                  –                  glibc       glibc/musl
 Shell         –        –                  –                  ✔           ✔
 Paketmanager  –        –                  –                  apk         apt/apk
 CA, tzdata    selbst   ✔                  ✔                  ✔           ✔/teils

Drill 1: Ein Binary, vier Laufzeit-Images

source ~/docker-lab/setup/env.sh
mkdir -p ~/docker-lab/tag08 && cd ~/docker-lab/tag08
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag07/notes/." .

Die zweite Kopie legt den Stand vom Ende von Tag 7 darüber – auch wenn du ihn übersprungen hast. Für den Vergleich gibt es ein eigenes Dockerfile mit einer build-Stage und vier Laufzeit-Stages:

grep -E '^(FROM|# )' "$LAB/code/tag08/Dockerfile.bases"

Erwartet:

# syntax=docker/dockerfile:1
# Tag 8: dasselbe notes-api-Binary auf vier Laufzeit-Images.
# Bauen mit --target rt-scratch | rt-distroless | rt-chainguard | rt-wolfi
FROM golang:1.27-alpine AS build
# nichts außer dem, was du hineinkopierst
FROM scratch AS rt-scratch
# Debian-basiert, ohne Shell, mit CA-Zertifikaten, tzdata und /etc/passwd
FROM gcr.io/distroless/static-debian13:nonroot AS rt-distroless
# Wolfi-basiert, ohne Shell; frei verfügbar ist nur der Tag latest,
# darum hier DL3007 bewusst ignoriert – in Produktion: @sha256:… pinnen
# hadolint ignore=DL3007
FROM cgr.dev/chainguard/static:latest AS rt-chainguard
# Wolfi mit Shell und apk – zum Vergleich, nicht als Laufzeit gedacht
# hadolint ignore=DL3007
FROM cgr.dev/chainguard/wolfi-base:latest AS rt-wolfi

Chainguard stellt seine Images unter cgr.dev/chainguard/… frei bereit, aber nur mit dem Tag latest; versionierte Tags gibt es im kostenpflichtigen Katalog. Bauen:

for v in scratch distroless chainguard wolfi; do
  docker build -q -f "$LAB/code/tag08/Dockerfile.bases" --target "rt-$v" \
    -t "notes-api:tag08-$v" notes-api
done
docker image ls --format '{{.Repository}}:{{.Tag}}\t{{.Size}}' \
  | grep -E '^(notes-api:tag08|golang:1.27-alpine|python:3.13-slim|node:24-alpine)' \
  | sort -k2 -h

Erwartet (gekürzt, Größen weichen bei dir ab):

sha256:…
sha256:…
sha256:…
sha256:…
notes-api:tag08-scratch       6.4MB
notes-api:tag08-chainguard    7.3MB
notes-api:tag08-distroless    8.4MB
notes-api:tag08-wolfi         19.6MB
python:3.13-slim              131MB
node:24-alpine                166MB
golang:1.27-alpine            373MB

Die vier notes-api-Varianten liegen zusammen unter 20 MB; den Unterschied macht nur das Base-Image. Größen, Digests und CVE-Zahlen in diesem Kapitel sind Momentaufnahmen und weichen bei dir ab. Alle Varianten müssen gleich laufen:

for v in scratch distroless chainguard wolfi; do
  docker run -d --name "notes-$v" -e NOTES_API_KEY=lab-api-key-123 \
    "notes-api:tag08-$v" >/dev/null
done
sleep 2
for v in scratch distroless chainguard wolfi; do
  printf '%-11s %s\n' "$v" "$(docker logs "notes-$v" 2>&1 | grep -c listening)"
done
docker rm -f notes-scratch notes-distroless notes-chainguard notes-wolfi >/dev/null

Erwartet:

scratch     1
distroless  1
chainguard  1
wolfi       1

Fortschritt speichern? Kostenlos registrieren

Drill 2: Shell, Paketmanager, libc, User

Was steckt außer notes-api in jedem Image? Eine Shell ist die Voraussetzung für alle anderen Fragen:

for img in notes-api:tag08-scratch notes-api:tag08-distroless \
    notes-api:tag08-chainguard notes-api:tag08-wolfi node:24-alpine \
    python:3.13-slim; do
  user=$(docker image inspect -f '{{.Config.User}}' "$img")
  info=$(docker run --rm --entrypoint sh "$img" -c \
    'for c in apk apt-get; do command -v $c >/dev/null && printf "%s " $c; done
     ls /lib/ld-*' \
    2>/dev/null) || info="keine Shell"
  printf '%-28s user=%-12s %s\n' "$img" "${user:-root}" "$info"
done

Erwartet (gekürzt, kann je nach Version abweichen):

notes-api:tag08-scratch      user=65532:65532  keine Shell
notes-api:tag08-distroless   user=65532:65532  keine Shell
notes-api:tag08-chainguard   user=65532:65532  keine Shell
notes-api:tag08-wolfi        user=65532:65532  apk /lib/ld-linux-aarch64.so.1
node:24-alpine               user=root         apk /lib/ld-musl-aarch64.so.1
python:3.13-slim             user=root         apt-get /lib/ld-linux-aarch64.so.1

Zwei Lektionen: ld-musl gegen ld-linux ist der Unterschied zwischen musl und glibc. Ein Programm, das gegen glibc gelinkt ist, startet auf alpine mit einem verwirrenden not found, obwohl die Datei da ist; Python-Wheels gibt es getrennt als manylinux (glibc) und musllinux. Und die beiden offiziellen Sprach-Images laufen ohne USER als root, das musst du selbst ändern (Tag 6, Tag 9).

Tipp: distroless bietet zusätzlich Tags mit debug im Namen, die eine Busybox-Shell enthalten. Für Produktion nimmst du die Variante ohne.

Fortschritt speichern? Kostenlos registrieren

Drill 3: CVEs zählen mit trivy

for img in golang:1.27-alpine node:24-alpine python:3.13-slim \
    notes-api:tag08-scratch notes-api:tag08-distroless \
    notes-api:tag08-chainguard notes-api:tag08-wolfi; do
  trivy image -q --format json "$img" | jq -r --arg i "$img" '
    [.Results[]?.Vulnerabilities[]?.Severity] as $s
    | "\($i)\t\($s | length) gesamt\t\($s | map(select(. == "HIGH"
      or . == "CRITICAL")) | length) high/critical"'
done | column -t -s $'\t'

Erwartet (gekürzt, Zahlen weichen bei dir ab):

golang:1.27-alpine          0 gesamt   0 high/critical
node:24-alpine              3 gesamt   1 high/critical
python:3.13-slim            41 gesamt  2 high/critical
notes-api:tag08-scratch     0 gesamt   0 high/critical
notes-api:tag08-distroless  0 gesamt   0 high/critical
notes-api:tag08-chainguard  0 gesamt   0 high/critical
notes-api:tag08-wolfi       0 gesamt   0 high/critical

Der erste Lauf lädt die Schwachstellen-Datenbank und dauert länger. Die Debian- Pakete in slim bringen viele, meist niedrig bewertete Funde mit, die minimalen Images fast keine. Bei scratch prüft trivy nur noch das Go-Binary selbst: Abhängigkeiten aus go.sum und die Version der Go-Standardbibliothek. Ein Fund dort verschwindet nicht durch ein anderes Base-Image, sondern nur durch einen Rebuild mit neuerem Go.

Tipp: Findet trivy unter Colima keinen Docker-Daemon, zeig ihm den Socket: export DOCKER_HOST="unix://$HOME/.colima/default/docker.sock".

Fortschritt speichern? Kostenlos registrieren

Drill 4: Was hinter einem Tag steckt

docker buildx imagetools inspect liest Manifeste direkt aus der Registry, ohne etwas zu ziehen:

docker buildx imagetools inspect golang:1.27-alpine --format '{{json .Manifest}}' \
  | jq -r '"Index: \(.digest[0:19])…",
           (.manifests[] | "  \(.platform.os)/\(.platform.architecture)"
           + "\(.platform.variant // "" | if . == "" then "" else "/" + . end)"
           + "  \(.digest[0:19])…")'

Erwartet (gekürzt, Digests weichen ab):

Index: sha256:…
  linux/amd64  sha256:…
  linux/arm/v6  sha256:…
  linux/arm/v7  sha256:…
  linux/arm64/v8  sha256:…
  linux/386  sha256:…
  linux/ppc64le  sha256:…
  linux/riscv64  sha256:…
  linux/s390x  sha256:…
  unknown/unknown  sha256:…

Ein Tag zeigt auf einen Index, der Index auf ein Manifest je Plattform (die unknown-Einträge sind wieder Attestations). Welcher Digest liegt lokal?

docker image inspect --format '{{index .RepoDigests 0}}' golang:1.27-alpine

Erwartet (gekürzt, Digests weichen ab):

golang@sha256:…

Lokal steht der Index-Digest. Genau den pinnst du, nicht den arm64-Digest: Nur der Index-Digest funktioniert auf dem Mac, im amd64-CI und für Multi-Plattform-Builds (Tag 7). Zum Vergleich ein Image, das nie neu gebaut zu werden scheint:

docker image inspect -f '{{.Created}}' gcr.io/distroless/static-debian13:nonroot

Erwartet (kann je nach Version abweichen):

1970-01-01T00:00:00Z

distroless setzt das Erstellungsdatum für reproduzierbare Builds auf null. Das Alter eines Images verrät also nicht Created, sondern nur der Vergleich der Digests.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Base-Image per Digest pinnen

Welcher Index-Digest gehört gerade zum Tag?

docker buildx imagetools inspect golang:1.27-alpine | grep Digest

Erwartet (Digest weicht ab):

Digest:    sha256:d200d2dd76b03a99b52651fd1325aff7dcd35422c35c01bac56571b0507f3deb

Leg eine Kopie des Dockerfiles an und hänge den Digest im Editor an den Tag im ersten FROM an:

cp notes-api/Dockerfile notes-api/Dockerfile.pinned

Danach:

grep '^FROM' notes-api/Dockerfile.pinned

Erwartet (gekürzt, Digest weicht ab):

FROM --platform=$BUILDPLATFORM golang:${GO_VERSION}-alpine@sha256:… AS base
FROM base AS test
FROM base AS build
FROM scratch AS final

Build Checks und Build:

docker build --check -f notes-api/Dockerfile.pinned notes-api 2>&1 | tail -1
docker build -q -f notes-api/Dockerfile.pinned -t notes-api:tag08-pinned notes-api

Erwartet (gekürzt):

Check complete, no warnings found.
sha256:…

name:tag@sha256:… ist erlaubt, und der Digest gewinnt. Das ist bequem zu lesen, aber eine Falle, wie diese Probe zeigt:

docker build -q -f notes-api/Dockerfile.pinned --target base \
  --build-arg GO_VERSION=1.26 -t notes-api:tag08-base notes-api >/dev/null
docker run --rm --entrypoint go notes-api:tag08-base version

Erwartet (gekürzt, kann je nach Version abweichen):

go version go1.27.… linux/arm64

Der Tag sagt 1.26, gebaut wurde mit 1.27: Mit Digest ist der Tag nur noch ein Kommentar. Wer die Version ändert, muss auch den Digest neu holen. Das erledigen in der Praxis Renovate oder Dependabot, die Tag und Digest gemeinsam per Merge-Request aktualisieren.

Im kanonischen Dockerfile bleiben die Tags, damit der Begleitcode nicht veraltet. Übernimm nur den Hinweis darauf und räum die Probe weg:

cp "$LAB/code/tag08/notes/notes-api/Dockerfile" notes-api/
grep -n 'pinnen' notes-api/Dockerfile
rm notes-api/Dockerfile.pinned

Erwartet:

5:# in Produktion: @sha256:… pinnen, siehe Tag 8

Achtung: Ein Digest friert auch Sicherheitslücken ein. Pinnen ohne automatische Aktualisierung ist schlechter als ein Tag, der regelmäßig neu gezogen wird.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Debuggen ohne Shell

Die Varianten aus Drill 1 haben bis auf Wolfi keine Shell, docker exec läuft ins Leere:

docker run -d --name notes-api -e NOTES_API_KEY=lab-api-key-123 \
  notes-api:tag08-chainguard
docker exec notes-api sh

Erwartet (gekürzt, kann je nach Version abweichen):

OCI runtime exec failed: exec failed: unable to start container process: exec: "sh":
executable file not found in $PATH: unknown

Docker Desktop bringt dafür docker debug mit, das eine Werkzeug-Shell in Container und Images ohne Shell hängt. Es ist eine Funktion von Docker Desktop; unter Colima mit Docker Engine fehlt der Befehl:

docker debug notes-api

Erwartet (unter Colima, gekürzt, kann je nach Version abweichen):

docker: unknown command: docker debug

Der Weg, der überall funktioniert, ist ein Sidecar: ein zweiter Container mit Werkzeugen, der sich in die Namespaces des ersten hängt. --pid=container: teilt die Prozesse, --network=container: das Netzwerk, SYS_PTRACE erlaubt den Blick in einen Prozess eines anderen Users:

docker run --rm --name notes-debug --user 0:0 \
  --pid=container:notes-api --network=container:notes-api --cap-add SYS_PTRACE \
  cgr.dev/chainguard/wolfi-base:latest sh -c '
    ps -o pid,user,args
    ls /proc/1/root/
    wget -qO- http://127.0.0.1:8080/healthz
    tr "\0" "\n" < /proc/1/environ | grep NOTES'

Erwartet (gekürzt, kann je nach Version abweichen):

PID   USER     COMMAND
    1 65532    /notes-api
    7 root     sh -c  ps -o pid,user,args …
   13 root     ps -o pid,user,args
dev         etc         notes-api   proc        sys         …
ok
NOTES_API_KEY=lab-api-key-123

notes-api ist PID 1, sein Dateisystem liegt unter /proc/1/root, 127.0.0.1:8080 ist sein Port. Und die letzte Zeile ist eine Warnung für Tag 14: Wer in den PID-Namespace darf, liest jede Umgebungsvariable, also auch den API-Key.

docker rm -f notes-api >/dev/null

Sicherheit: Der Debug-Container hat mehr Rechte als die Anwendung. In Kubernetes heißt das Gegenstück kubectl debug mit einem Ephemeral Container; beides gehört in Produktion hinter eine Freigabe.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Alle vier Varianten aus Drill 1 sind gebaut:

cd ~/docker-lab/tag08
docker image ls notes-api

Erwartet (gekürzt, Größen weichen ab):

IMAGE                        ID             DISK USAGE   CONTENT SIZE   EXTRA
notes-api:tag08-base         4d6dfb1ace03        364MB         71.5MB
notes-api:tag08-chainguard   7c54350e403a       14.5MB         3.59MB
notes-api:tag08-distroless   836d6a46adda         17MB         3.99MB
notes-api:tag08-pinned       8c2b732e6148       10.7MB         3.23MB
notes-api:tag08-scratch      6ae7675528e9       10.7MB         3.23MB
notes-api:tag08-wolfi        c6aa5d5c4538       38.1MB         11.3MB

distroless hat keine Shell (scratch und chainguard genauso):

docker run --rm --entrypoint sh notes-api:tag08-distroless -c true

Erwartet (gekürzt):

docker: Error response from daemon: failed to create task for container: …
… exec: "sh": executable file not found in $PATH
Run 'docker run --help' for more information

chainguard läuft als UID 65532:

docker image inspect --format '{{.Config.User}}' notes-api:tag08-chainguard

Erwartet:

65532:65532

Der Pin-Hinweis steht im Dockerfile (Drill 5):

grep -c 'pinnen, siehe Tag 8' notes-api/Dockerfile

Erwartet:

1

Challenge

Pinne in einer Kopie von Dockerfile.bases auch die Laufzeit-Images von distroless und Chainguard per Index-Digest und bau die Stage rt-distroless daraus.

Hinweis: docker buildx imagetools inspect zeigt den Digest des Index, der für alle Plattformen gilt. Der Tag darf zur Lesbarkeit vor dem @ stehen bleiben.

Lösung

Die FROM-Zeilen und die beiden Digests:

cp "$LAB/code/tag08/Dockerfile.bases" Dockerfile.bases.pinned
grep '^FROM' Dockerfile.bases.pinned
docker buildx imagetools inspect gcr.io/distroless/static-debian13:nonroot | grep Digest
docker buildx imagetools inspect cgr.dev/chainguard/static:latest | grep Digest

Erwartet (gekürzt, Digests weichen ab):

FROM golang:1.27-alpine AS build
FROM scratch AS rt-scratch
FROM gcr.io/distroless/static-debian13:nonroot AS rt-distroless
FROM cgr.dev/chainguard/static:latest AS rt-chainguard
FROM cgr.dev/chainguard/wolfi-base:latest AS rt-wolfi
Digest:    sha256:25ac8f0c3b2334a9eb05452266bd4697864a8c8ef0ef71e5e6480d7f92868329
Digest:    sha256:fc42af33e643f20d08baf03cddcc1c02ba57052dfb02edb0d79f3fc47bcea8d9

Trag beide Digests im Editor hinter die Tags ein, dann:

grep '^FROM' Dockerfile.bases.pinned
docker build -q -f Dockerfile.bases.pinned --target rt-distroless \
  -t notes-api:tag08-distroless-pinned notes-api

Erwartet (gekürzt, Digests weichen ab):

FROM golang:1.27-alpine AS build
FROM scratch AS rt-scratch
FROM gcr.io/distroless/static-debian13:nonroot@sha256:25ac8f0c3b23… AS rt-distroless
FROM cgr.dev/chainguard/static:latest@sha256:fc42af33e643… AS rt-chainguard
FROM cgr.dev/chainguard/wolfi-base:latest AS rt-wolfi
sha256:a54cfabc8e79…

Genau das macht ein Renovate-Bot: Tag lesen, Index-Digest nachschlagen, beides gemeinsam ins FROM schreiben – und den Digest per Pull-Request aktualisieren, wenn es einen neuen gibt. Zum Schluss aufräumen:

docker ps -a --filter name=^notes- --format '{{.Names}}' | xargs -r docker rm -f
docker image ls --format '{{.Repository}}:{{.Tag}}' \
  | grep -E '^(notes-|localhost:5001/)' | xargs -r docker rmi
docker buildx prune --builder docker-lab --all --force

Tipp: Die Base-Images aus diesem Kapitel bleiben nach dem Aufräumen liegen. Brauchst du den Platz, entfernst du sie gezielt, etwa mit docker image rm cgr.dev/chainguard/wolfi-base:latest.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Ein Plattform-Team pflegt „Golden Base Images” (meist distroless oder Wolfi-basiert) in der eigenen Registry; Teams dürfen nur davon ableiten, durchgesetzt per Policy (Kyverno, OPA Gatekeeper) oder Build-Check in der Pipeline.
  • Pinnen nur zusammen mit Renovate oder Dependabot: Digest-Updates als Merge-Request, Rebuild und Scan in CI, dazu ein SLA für kritische CVEs.
  • Versionierte Chainguard-Tags gibt es nur im kostenpflichtigen Katalog; der freie latest-Tag eignet sich zum Evaluieren, für reproduzierbare Builds nur mit Digest. Dasselbe gilt für jeden Anbieter gehärteter Images: Konditionen vorher prüfen.
  • musl gegen glibc ist eine Betriebsfrage: DNS-Auflösung, Locale und Performance verhalten sich unterschiedlich. Wer auf alpine wechselt, testet unter Last.
  • Debuggen in Produktion läuft über kubectl debug mit Ephemeral Containers und Audit-Log, nicht über eine Shell im Image.