Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 5: Buildah und ko

Ziel: Images mit Buildah aus dem Dockerfile und ganz ohne Dockerfile bauen, sie als OCI-Verzeichnis exportieren und notes-api mit ko direkt aus dem Go-Code containerisieren. · Dauer: ca. 75 min · Voraussetzung: Tag 4

Briefing

  • Buildah ist die Bau-Bibliothek hinter podman build. Als eigenes Werkzeug kann es mehr: Images Schritt für Schritt per Skript bauen, ohne Dockerfile.
  • Buildah und Podman teilen einen Speicher (~/.local/share/containers/storage): Was Buildah baut, sieht Podman sofort.
  • ko baut Go-Programme ohne Dockerfile und ohne Container: go build auf dem Host, das Binary als Layer auf ein schlankes Basis-Image, fertig.
  • ko-Images sind reproduzierbar: gleicher Code, gleicher Digest.
 Dockerfile ──► buildah build ──┐
 Skript: from/run/copy/         │      ~/.local/share/containers/storage
   config/commit ───────────────┼────► localhost/notes-api:0.2.0 …  ◄── podman images
 Go-Code ──► ko build ──────────┘ (über Podman-Socket oder --tarball + podman load)
                    buildah push ──► oci:./out (OCI-Verzeichnis), docker-archive:…

Drill 1: buildah – Steckbrief und Installation

Steckbrief buildah
Aufgabe OCI- und Docker-Images bauen: aus Dockerfiles oder Befehl für Befehl
Besonderheit daemonlos, rootless, Working Container, teilt den Speicher mit Podman
Projekt buildah.io, github.com/containers/buildah
Version im Buch 1.42.1 (Ubuntu-Paket buildah)

Tagesstart mit dem Stand von Tag 4 – der Quadlet-Pod läuft weiter auf 8080 und 3000:

source ~/ct-lab/setup/env.sh
mkdir -p ~/ct-lab/tag05 && cd ~/ct-lab/tag05
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag04/notes/." .
sudo apt-get install -y buildah
apt-cache policy buildah | head -3
buildah --version
dpkg -L buildah | grep bin/

Erwartet:

buildah:
  Installed: 1.42.1+ds1-2build1
  Candidate: 1.42.1+ds1-2build1
buildah version 1.42.1 (image-spec 1.1.1, runtime-spec 1.2.1)
/usr/bin/buildah

So funktioniert Buildah: Ein Build ist ein Working Container – ein Container, der nicht läuft, sondern nur ein Dateisystem plus Konfiguration ist. Du führst Befehle darin aus (run), kopierst Dateien hinein (copy), setzt die Konfiguration (config) und schreibst das Ergebnis als Image (commit). Ein Dockerfile ist nur eine von mehreren Arten, diese Schritte aufzuschreiben.

buildah info | jq '{rootless: .host.rootless, runtime: .host.OCIRuntime,
  driver: .store.GraphDriverName, root: .store.GraphRoot}'
podman info --format '{{.Store.GraphRoot}}'

Erwartet:

{
  "rootless": true,
  "runtime": "crun",
  "driver": "overlay",
  "root": "/home/ubuntu/.local/share/containers/storage"
}
/home/ubuntu/.local/share/containers/storage

Gleicher Pfad, gleiche Konfiguration aus /etc/containers/ und ~/.config/containers/: Buildah und Podman arbeiten auf demselben Speicher.

Fortschritt speichern? Kostenlos registrieren

Drill 2: buildah build aus dem Dockerfile

buildah build (Alias bud, „build using dockerfile”) liest dasselbe Dockerfile wie podman build. Version 0.2.0 von notes-api, gleich im Docker-Format:

buildah build --help | sed -n '/Aliases/,/^$/p'
buildah build --format docker -t localhost/notes-api:0.2.0 \
  --build-arg VERSION=0.2.0 notes-api 2>&1 | grep -E 'STEP 1/|warn|COMMIT|Succ'

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

Aliases:
  build, build-using-dockerfile, bud

[1/4] STEP 1/5: FROM --platform=linux/arm64 golang:1.27-alpine AS base
[3/4] STEP 1/3: FROM 4ee0ca423987d840f1eed565ca76c3a6404ecc67861a34491bae66ca256467ad …
[4/4] STEP 1/10: FROM scratch AS final
time="…" level=warning msg="--link is not supported when building without --layers,
ignoring --link"
time="…" level=warning msg="--link is not supported when building without --layers,
ignoring --link"
[4/4] COMMIT localhost/notes-api:0.2.0
Successfully tagged localhost/notes-api:0.2.0

Der Build dauert nur Sekunden: Die Cache-Mounts für Go-Module und Build-Cache von Tag 1 liegen im selben Speicher. Ein Unterschied zu Podman steckt in der Warnung:

buildah images --filter reference='localhost/notes-api'
for t in 0.1.0 0.2.0; do
  echo "$t: $(podman image inspect localhost/notes-api:$t \
    --format '{{len .RootFS.Layers}} Layer, {{.Config.Healthcheck.Test}}')"
done

Erwartet (gekürzt):

REPOSITORY            TAG     IMAGE ID       CREATED                  SIZE
localhost/notes-api   0.2.0   3cac2607c210   Less than a second ago   11.9 MB
localhost/notes-api   0.1.0   e45119e1f158   …                        11.9 MB
0.1.0: 2 Layer, [CMD /notes-api healthcheck]
0.2.0: 1 Layer, [CMD /notes-api healthcheck]
  • podman build arbeitet mit --layers=true: Jeder Schritt wird ein Zwischen-Image, jedes COPY ein Layer. buildah build baut ohne --layers und schreibt die finale Stage als einen Layer – --link ist dann bedeutungslos.
  • Der Healthcheck ist dank --format docker drin. Ohne den Schalter warnt Buildah wie Podman an Tag 1 und lässt ihn weg.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Working Container – from, copy, run

Jetzt dasselbe Image ohne Dockerfile. Zuerst ein Build-Container aus dem Go-Image:

b=$(buildah from --name api-build docker.io/library/golang:1.27-alpine)
echo "$b"
buildah containers
podman ps -a --external --format '{{.Names}}\t{{.Status}}\t{{.Image}}'

Erwartet:

api-build
CONTAINER ID  BUILDER  IMAGE ID     IMAGE NAME                       CONTAINER NAME
93787c789f90     *     f0f96555233b docker.io/library/golang:1.27... api-build
api-build   Storage docker.io/library/golang:1.27-alpine

podman ps -a allein zeigt den Working Container nicht. Mit --external sieht Podman ihn als Container im Zustand Storage: angelegt, aber nie gestartet. Quellcode hinein und kompilieren:

buildah copy "$b" notes-api /src
buildah run --workingdir /src -e CGO_ENABLED=0 "$b" -- \
  go build -trimpath -ldflags="-s -w -X main.version=0.2.0" -o /out/notes-api .
buildah run "$b" -- ls -lh /out/notes-api

Erwartet (gekürzt, go build dauert ca. 1 Minute):

f1d11e0625a753ad4ef249e0c1faba02884c9c134924b58e0f0f6208ef32761e
go: downloading github.com/google/uuid v1.6.0
…
-rwxr-xr-x    1 root     root       11.2M Oct 30 20:18 /out/notes-api
  • buildah copy gibt die Prüfsumme des kopierten Inhalts aus.
  • buildah run ist das RUN aus dem Dockerfile – nur ohne Cache-Mounts. Darum lädt Go die Module hier neu.

Das Ziel-Image beginnt leer: scratch. Binary und CA-Zertifikate holt copy --from direkt aus dem Build-Container:

f=$(buildah from --format docker --name api-final scratch); echo "$f"
buildah copy --from "$b" "$f" /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
buildah copy --from "$b" --chmod 555 "$f" /out/notes-api /notes-api

Erwartet:

api-final
80ad6206abb5e7e2a795392d1f6d18cbf46f722b628a6afabbddea24637d3792
74ac4d9d592a961f151901ac567d4a786f8d254f4fea88b42dfac24f6606e33e

--format docker schon bei from: Dann akzeptiert der Working Container später den Healthcheck ohne Warnung.

Fortschritt speichern? Kostenlos registrieren

Drill 4: buildah mount und buildah unshare

Ein Working Container ist ein Dateisystem – du kannst es einhängen und mit Host-Werkzeugen bearbeiten, auch wenn im Image keine Shell liegt:

buildah mount "$f"; echo "Exit: $?"

Erwartet:

Error: cannot mount using driver overlay in rootless mode. You need to run it in a
`buildah unshare` session
Exit: 125

Rootless darf ubuntu kein overlay einhängen. buildah unshare startet eine Shell im selben User Namespace, in dem auch die Container laufen (Tag 2):

buildah unshare sh -c '
  m=$(buildah mount api-final); echo "$m"
  ls -ln "$m"; id -u
  buildah umount api-final'

Erwartet (gekürzt):

/home/ubuntu/.local/share/containers/storage/overlay/ba9d7748…/merged
total 11448
drwxr-xr-x 3 0 0     4096 Oct 30 20:18 etc
-r-xr-xr-x 1 0 0 11714720 Oct 30 20:18 notes-api
0
api-final

Im Namespace bist du UID 0, die Dateien gehören root. Von außen gehören dieselben Dateien ubuntu (UID 1000). Mit cp, sed oder einem Paketmanager des Hosts (dnf --installroot) ließe sich das Image hier befüllen, ohne dass im Image selbst ein Werkzeug liegt.

Achtung: buildah mount ohne unshare funktioniert nur rootful. Skripte, die mounten, startest du rootless komplett unter buildah unshare ./skript.sh.

Fortschritt speichern? Kostenlos registrieren

Drill 5: config, commit und das Skript

Jetzt die Konfiguration aus dem Dockerfile – EXPOSE, USER, HEALTHCHECK, STOPSIGNAL, ENTRYPOINT, LABEL – als Schalter von buildah config:

buildah config --port 8080 --user 65532:65532 --stop-signal SIGTERM \
  --entrypoint '["/notes-api"]' \
  --healthcheck 'CMD /notes-api healthcheck' --healthcheck-interval 10s \
  --healthcheck-timeout 2s --healthcheck-start-period 5s \
  --healthcheck-start-interval 1s \
  --label org.opencontainers.image.version=0.2.0 "$f"
buildah inspect --format '{{.Docker.Config.User}} {{.Docker.Config.Entrypoint}}
  {{.Docker.Config.Healthcheck.Test}}' "$f" | tr -s '\n ' ' '; echo
buildah commit --format docker --rm "$f" localhost/notes-api:0.2.0-buildah
buildah rm "$b"
buildah containers

Erwartet (gekürzt):

65532:65532 [/notes-api] [CMD /notes-api healthcheck]
Getting image source signatures
Copying blob sha256:4b7ed19a0765…
Copying config sha256:666976c1aaff…
Writing manifest to image destination
666976c1aaffa8265a52292fe11d6c405077776ed1a5a2ca94f98802e7c1a444
93787c789f90c2c63b84571d89c204bcf552d916b39b441ae7dcfd9311336623
CONTAINER ID  BUILDER  IMAGE ID     IMAGE NAME                       CONTAINER NAME
  • --healthcheck 'CMD …' nimmt den Befehl als Text, nicht als JSON-Liste. CMD heißt „direkt ausführen”, CMD-SHELL „über /bin/sh” – in scratch gibt es keine Shell.
  • commit --rm löscht den Working Container nach dem Schreiben. Den Build-Container räumt buildah rm weg.

Läuft das Image?

podman run -d --name api-buildah -p 127.0.0.1:8081:8080 \
  -e NOTES_API_KEY=lab-api-key-123 localhost/notes-api:0.2.0-buildah
sleep 4
podman ps --format '{{.Names}}\t{{.Status}}' --filter name=api-buildah
curl -s 127.0.0.1:8081/version; echo
podman rm -f api-buildah

Erwartet:

431c4f4fa8c5…
api-buildah Up 4 seconds (healthy)
0.2.0
api-buildah

Port 8081, weil der Quadlet-Pod 8080 belegt. Alle Schritte aus Drill 3 bis 5 stehen als Skript im Begleitcode:

cp "$LAB/code/tag05/notes/buildah-api.sh" .
grep -E '^(b|f)=|^buildah' buildah-api.sh
bash -n buildah-api.sh && echo "Syntax ok"

Erwartet:

b=$(buildah from --name api-build docker.io/library/golang:1.27-alpine)
buildah copy "$b" notes-api /src
buildah run --workingdir /src -e CGO_ENABLED=0 "$b" -- \
f=$(buildah from --format docker --name api-final scratch)
buildah copy --from "$b" "$f" /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/
buildah copy --from "$b" --chmod 555 "$f" /out/notes-api /notes-api
buildah config --port 8080 --user 65532:65532 --stop-signal SIGTERM \
buildah commit --format docker --rm "$f" "localhost/notes-api:$v-buildah"
buildah rm "$b" >/dev/null
Syntax ok

./buildah-api.sh 0.2.0 baut dasselbe Image in einem Rutsch (ca. 1,5 Minuten). Der Vorteil gegenüber einem Dockerfile: Es ist Bash – Schleifen, Bedingungen und Variablen ohne Build-Args.

Fortschritt speichern? Kostenlos registrieren

Drill 6: buildah push in ein OCI-Verzeichnis

push heißt bei Buildah „kopieren an ein Ziel”. Das Ziel muss keine Registry sein: Der Transport vor dem Doppelpunkt bestimmt das Format.

buildah push localhost/notes-api:0.2.0 oci:./out:notes-api
ls out
jq . out/index.json

Erwartet (gekürzt):

Getting image source signatures
Copying blob sha256:f1fca665eac4…
Copying config sha256:745b927671fd…
Writing manifest to image destination
blobs  index.json  oci-layout
{
  "schemaVersion": 2,
  "manifests": [
    {
      "mediaType": "application/vnd.oci.image.manifest.v1+json",
      "digest": "sha256:ac1236914977f94a9a20f5930de44fd2ef94beabbe546c9d36db555c53…",
      "size": 406,
      "annotations": {
        "org.opencontainers.image.ref.name": "notes-api"
      }
    }
  ]
}

Ein OCI-Layout ist eine Registry als Ordner: index.json zeigt auf Manifeste, blobs/sha256/ enthält Manifest, Config und Layer. Skopeo, crane, oras und regctl lesen es (ihre Steckbriefe folgen an Tag 7–9). Aber Vorsicht:

skopeo inspect --config oci:./out:notes-api | jq -c '.config.Healthcheck, .config.User'
buildah push localhost/notes-api:0.2.0 \
  docker-archive:./out/notes-api.tar:localhost/notes-api:0.2.0 2>&1 | tail -1
tar -tf out/notes-api.tar | grep -E 'json$'

Erwartet (gekürzt):

null
"65532:65532"
Writing manifest to image destination
3cac2607c2107e9249e036f40490803ceb478b317a8843262742d122ef375a35.json
d0c83a327373…/json
manifest.json
  • oci: wandelt das Image ins OCI-Format um – und der Healthcheck ist weg, die Config-Prüfsumme ändert sich (745b… statt 3cac…).
  • docker-archive: behält das Docker-Format; die Config-Datei heißt wie die Image-ID. Das ist dasselbe Format wie podman save, und podman load liest es.

Fortschritt speichern? Kostenlos registrieren

Drill 7: ko – Steckbrief und Installation

Steckbrief ko
Aufgabe Go-Programme ohne Dockerfile als Image bauen und veröffentlichen
Besonderheit kein Container beim Bauen, reproduzierbare Digests, SBOM eingebaut
Projekt ko.build, github.com/ko-build/ko
Version im Buch 0.19.1 (Release-Binary)

Installation wie an Tag 0 – laden, prüfen, auspacken, installieren:

mkdir -p /tmp/dl && cd /tmp/dl
V=0.19.1
BASE=https://github.com/ko-build/ko/releases/download/v$V
curl -fsSLO "$BASE/ko_${V}_Linux_arm64.tar.gz"
curl -fsSLO "$BASE/checksums.txt"
grep "ko_${V}_Linux_arm64" checksums.txt
sha256sum -c --ignore-missing checksums.txt
grep '^ko arm64' ~/ct-lab/setup/tools.lock | awk '{print $4}'
tar -xzf "ko_${V}_Linux_arm64.tar.gz" ko
sudo install -m 0755 ko /usr/local/bin/
ko version
cd ~/ct-lab/tag05 && rm -rf /tmp/dl

Erwartet:

4099b2d1170d3b8a70e049237462efc2dd14d5fa30e9d2e5e108fb4f778cdd3f  ko_0.19.1_Linux_arm64…
ko_0.19.1_Linux_arm64.tar.gz: OK
4099b2d1170d3b8a70e049237462efc2dd14d5fa30e9d2e5e108fb4f778cdd3f
0.19.1

So funktioniert ko: ko ruft go build auf dem Host auf, packt das Binary als einzigen neuen Layer nach /ko-app/<name> und legt ihn auf ein Basis-Image. Es läuft kein Container, es gibt keine Shell-Schritte. Dafür braucht ko ein Go auf dem Host:

sudo apt-get install -y golang-go
go version
cd notes-api && go version && cd ..

Erwartet:

go version go1.26.8 linux/arm64
go: downloading go1.27.0 (linux/arm64)
go version go1.27.0 linux/arm64

Ubuntu liefert Go 1.26, go.mod von notes-api verlangt go 1.27.0. Mit der Voreinstellung GOTOOLCHAIN=auto lädt Go die passende Toolchain selbst nach – geprüft gegen die Prüfsummen-Datenbank sum.golang.org – und legt sie unter ~/go/pkg/mod ab.

Fortschritt speichern? Kostenlos registrieren

Drill 8: ko build mit Podman

ko veröffentlicht standardmäßig in eine Registry (KO_DOCKER_REPO). Die kommt erst an Tag 7. Ohne Ziel nur bauen:

cd ~/ct-lab/tag05/notes-api
ko build .; echo "Exit: $?"
ko build --push=false . 2>&1 | grep -v 'git repository'

Erwartet (gekürzt, der erste Lauf lädt die Go-Module, ca. 2 Minuten):

Error: error creating publisher: KO_DOCKER_REPO environment variable is unset
Exit: 1
… Using base cgr.dev/chainguard/static:latest@sha256:fc42af33e643… for example.com/n…
… Building example.com/notes-api for linux/arm64
notes-api-4d3f48c33b4baaff2e00a1ef72b3f0c1:latest@sha256:6080fdfd318a96a2019a22afdba7…

Der Name ist <paketname>-<md5 des Importpfads>, das Basis-Image ohne Konfiguration cgr.dev/chainguard/static. Mit --local lädt ko das Image in einen „Docker-Daemon” – über die Docker-API. Die spricht dein Podman-Socket seit Tag 4:

echo "$DOCKER_HOST"
env -u DOCKER_HOST ko build --local . 2>&1 | tail -1 | cut -c1-88
ko build --local . 2>&1 | tail -1
podman images --format '{{.Repository}}:{{.Tag}} {{.Size}} {{.Created}}' \
  --filter reference='ko.local/*' | cut -c1-88

Erwartet (gekürzt):

unix:///run/user/1000/podman/podman.sock
Error: failed to publish images: error publishing ko://example.com/notes-api: error lo…
ko.local/notes-api-4d3f48c33b4baaff2e00a1ef72b3f0c1:6080fdfd318a96a2019a22afdba77e62b…
ko.local/notes-api-4d3f48c33b4baaff2e00a1ef72b3f0c1:latest 19.2 MB 47 hours ago
ko.local/notes-api-4d3f48c33b4baaff2e00a1ef72b3f0c1:6080fdfd318a96a2019a22afdba77e62b2…
  • Ohne DOCKER_HOST sucht ko /var/run/docker.sock und scheitert. Mit Socket landet das Image in Podmans Speicher, Präfix ko.local/.
  • Derselbe Digest 6080fd… wie beim Lauf ohne Push: Das Ergebnis hängt nur vom Code und vom Basis-Image ab.

Fortschritt speichern? Kostenlos registrieren

Drill 9: .ko.yaml, SBOM und reproduzierbare Digests

Das Basis-Image :latest, kein Versions-String, ein Name mit Hash – das regelt eine .ko.yaml neben go.mod. Als Basis dient distroless (wie im Buch „Dockerfiles zum Anfassen”):

cat > .ko.yaml <<'EOF'
# notes-api/.ko.yaml – Stand Ende Tag 5
defaultBaseImage: gcr.io/distroless/static-debian13:nonroot
builds:
  - id: notes-api
    main: .
    env:
      - CGO_ENABLED=0
    flags:
      - -trimpath
    ldflags:
      - -s -w
      - -X main.version={{.Env.VERSION}}
EOF
export VERSION=0.2.0
KO_DOCKER_REPO=ko.local/notes-api ko build --bare -t 0.2.0 \
  --sbom-dir ../out/sbom . 2>&1 | grep -E 'Using base|Added|^ko'

Erwartet (gekürzt):

… Using base gcr.io/distroless/static-debian13:nonroot@sha256:18f4cc26c9ff… for exam…
… Added tag 0.2.0
ko.local/notes-api:602007fe947d467d43d1e60ad6ced4de1eb67a5575b401eb93504be49a9ea342
  • KO_DOCKER_REPO=ko.local/… wirkt wie --local. --bare nimmt den Namen ohne Zusatz, -t setzt den Tag.
  • {{.Env.VERSION}} ist eine Vorlage: ko setzt die Umgebungsvariable VERSION ein. Fehlt sie, bricht ko ab: executing "argsTmpl" at <.Env.VERSION>: map has no entry for key "VERSION".
  • KO_DEFAULTBASEIMAGE überschreibt defaultBaseImage – so pinnst du das Basis-Image per Digest, ohne die Datei zu ändern.

Ganz ohne Daemon geht es auch: als Archiv, das podman load liest.

KO_DOCKER_REPO=localhost/notes-api ko build --bare -t 0.2.0-ko --push=false \
  --tarball ../out/ko.tar . 2>&1 | tail -1
podman load -i ../out/ko.tar | tail -1
podman images --format '{{.Repository}}:{{.Tag}} {{.ID}} {{.Created}}' \
  --filter reference='*/notes-api:0.2.0*' | cut -c1-88

Erwartet (gekürzt):

… Saved ../out/ko.tar
Loaded image: localhost/notes-api:0.2.0-ko
localhost/notes-api:0.2.0-buildah 666976c1aaff 10 minutes ago
localhost/notes-api:0.2.0 3cac2607c210 20 minutes ago
localhost/notes-api:0.2.0-ko 2acfdf58f9a3 56 years ago
ko.local/notes-api:0.2.0 2acfdf58f9a3 56 years ago
ko.local/notes-api:602007fe947d467d43d1e60ad6ced4de1eb67a5575b401eb93504be49a9ea342 2a…

Zweimal gebaut, zwei Wege – eine Image-ID. ko setzt alle Zeitstempel auf den 1.1.1970 („56 years ago”); deshalb sind die Digests reproduzierbar. Gegenprobe:

for v in 0.2.0 0.2.0 0.2.1; do
  VERSION=$v ko build --push=false . 2>/dev/null | cut -d@ -f2 | cut -c1-19
done

Erwartet:

sha256:602007fe947d
sha256:602007fe947d
sha256:812db6dd0568

Gleiche Eingabe, gleicher Digest; eine andere Version im Binary ergibt einen anderen. Das SBOM hat ko nebenbei geschrieben:

ls ../out/sbom
jq -r '.spdxVersion, .creationInfo.creators[]' ../out/sbom/*.spdx.json
jq -r '.packages[] | "\(.name) \(.versionInfo)"' ../out/sbom/*.spdx.json \
  | sed -n 3,6p

Erwartet:

notes-api-linux-arm64.spdx.json
SPDX-2.3
Tool: ko 0.19.1
example.com/notes-api null
github.com/google/uuid v1.6.0
github.com/jackc/pgpassfile v1.0.0
github.com/jackc/pgservicefile v0.0.0-20240606120523-5a60cdf6a761

Die Go-Module stammen aus den Build-Infos im Binary, das Basis-Image steht mit Digest drin. Beim Push in eine Registry hängt ko das SBOM ans Image; SBOMs als Referrer siehst du an Tag 9 und Tag 14. Läuft das Image?

podman run -d --name api-ko -p 127.0.0.1:8081:8080 \
  -e NOTES_API_KEY=lab-api-key-123 \
  --health-cmd '["/ko-app/notes-api", "healthcheck"]' localhost/notes-api:0.2.0-ko
sleep 3
curl -s 127.0.0.1:8081/version; echo
podman healthcheck run api-ko && echo gesund
podman top api-ko user huser args
podman rm -f api-ko

Erwartet:

b3e6aa0032b6…
0.2.0
gesund
USER        HUSER       COMMAND
nonroot     165531      /ko-app/notes-api
api-ko

ko kennt kein HEALTHCHECK (es baut OCI). Den Check gibst du beim Start mit – als JSON-Liste, denn distroless hat keine Shell für CMD-SHELL. Der User nonroot (65532) kommt aus dem Basis-Image. Zum Schluss der Größenvergleich:

cd ~/ct-lab/tag05
for t in 0.2.0 0.2.0-buildah 0.2.0-ko; do
  podman image inspect "localhost/notes-api:$t" \
    --format "$t: {{.Size}} Byte, {{len .RootFS.Layers}} Layer"
done

Erwartet:

0.2.0: 11902501 Byte, 1 Layer
0.2.0-buildah: 11900337 Byte, 1 Layer
0.2.0-ko: 15127209 Byte, 15 Layer

Das ko-Image ist gut 3 MB größer: distroless bringt /etc/passwd, Zeitzonen, CA-Zertifikate und Lizenzdateien in 14 Layern mit. Die ko.local/-Namen brauchst du nicht mehr:

podman images --format '{{.Repository}}:{{.Tag}}' | grep '^ko.local/' \
  | xargs -r podman rmi >/dev/null
podman images --format '{{.Repository}}' | grep -c '^ko.local/'

Erwartet:

0

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Drei Varianten von notes-api, gebaut mit Podman, Buildah und ko:

cd ~/ct-lab/tag05
podman images --filter reference=localhost/notes-api --format '{{.Tag}}' | sort

Erwartet:

0.1.0
0.2.0
0.2.0-buildah
0.2.0-ko

Das Skript-Image hat einen Healthcheck, kein Working Container ist übrig:

podman image inspect localhost/notes-api:0.2.0-buildah \
  --format '{{.Config.Healthcheck.Test}}'
buildah containers -q | wc -l

Erwartet:

[CMD /notes-api healthcheck]
0

ko hat ein OCI-Layout mit SBOM geschrieben (im Dateinamen steht deine Architektur), mit festem Zeitstempel:

jq -r '.manifests[0].annotations["org.opencontainers.image.ref.name"]' out/index.json
ls out/sbom
podman image inspect localhost/notes-api:0.2.0-ko --format '{{.Created}}'

Erwartet (gekürzt):

notes-api
notes-api-linux-amd64.spdx.json
1970-01-01 00:00:00 +0000 UTC

ko.local ist aufgeräumt, der Quadlet-Pod läuft:

podman images -q --filter reference='ko.local/*' | wc -l
systemctl --user is-active notes-pod.service

Erwartet:

0
active

Challenge

Mach buildah build reproduzierbar: Zwei Builds desselben Dockerfiles sollen dieselbe Image-ID ergeben, zwei Builds ohne deinen Schalter zwei verschiedene.

Hinweis: buildah build --help | grep -i timestamp.

Lösung

cd ~/ct-lab/tag05
for i in 1 2; do
  buildah build -q --format docker --timestamp 0 -t localhost/notes-api:0.2.0-repro \
    --build-arg VERSION=0.2.0 notes-api 2>/dev/null
done
for i in 1 2; do
  buildah build -q --format docker -t localhost/notes-api:0.2.0-norepro \
    --build-arg VERSION=0.2.0 notes-api 2>/dev/null
done
podman images --format '{{.Tag}} {{.ID}} {{.Created}}' \
  --filter reference='localhost/notes-api:*repro'
podman rmi localhost/notes-api:0.2.0-repro localhost/notes-api:0.2.0-norepro

Erwartet (gekürzt):

c883c262ec92c43bc25057d5ef11d78abffaf663dc8c8da1b4be8d20ea8ba746
c883c262ec92c43bc25057d5ef11d78abffaf663dc8c8da1b4be8d20ea8ba746
630c5ec096f5e8f2c62ed90a5bd5174e1676a4e06a23e5b01993f76ef1f29bc2
1a797d3caaff3f6616fbc4dfedb874229fec621321261a595d5dca8394664386
0.2.0-norepro 1a797d3caaff 1 second ago
0.2.0-repro c883c262ec92 56 years ago
Untagged: localhost/notes-api:0.2.0-repro
…

--timestamp 0 setzt Erstellungszeit und alle Datei-Zeitstempel in den Layern auf den 1.1.1970 – wie ko. Ohne den Schalter steckt die aktuelle Uhrzeit in der Config, jede Sekunde ergibt eine neue ID. Der Go-Compiler selbst ist dank -trimpath schon reproduzierbar.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Buildah-Skripte passen in CI-Runner ohne Daemon und ohne privilegierten Container – rootless reicht, buildah unshare nur, wenn gemountet wird.
  • Basis-Images per Digest pinnen (KO_DEFAULTBASEIMAGE=…@sha256:…, FROM …@sha256:…) und per Renovate aktualisieren. :latest macht reproduzierbare Builds wertlos.
  • Reproduzierbare Digests (ko, --timestamp 0, SOURCE_DATE_EPOCH) erlauben es, ein Image unabhängig nachzubauen und mit dem veröffentlichten zu vergleichen – ein Baustein für SLSA.
  • ko für Go-Dienste spart Dockerfiles und Multi-Stage-Builds; Images ohne Go (Python, Node) bleiben bei Buildah/BuildKit.
  • SBOMs nicht nur erzeugen, sondern mit dem Image veröffentlichen und signieren (Tag 14) – sonst weiß im Ernstfall niemand, welches SBOM zu welchem Digest gehört.