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 buildauf 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}}')"
doneErwartet (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 buildarbeitet mit--layers=true: Jeder Schritt wird ein Zwischen-Image, jedesCOPYein Layer.buildah buildbaut ohne--layersund schreibt die finale Stage als einen Layer –--linkist dann bedeutungslos.- Der Healthcheck ist dank
--format dockerdrin. 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-apiErwartet (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 copygibt die Prüfsumme des kopierten Inhalts aus.buildah runist dasRUNaus 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-apiErwartet:
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 mountohneunsharefunktioniert nur rootful. Skripte, die mounten, startest du rootless komplett unterbuildah 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 containersErwartet (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.CMDheißt „direkt ausführen”,CMD-SHELL„über/bin/sh” – in scratch gibt es keine Shell.commit --rmlöscht den Working Container nach dem Schreiben. Den Build-Container räumtbuildah rmweg.
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-buildahErwartet:
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.jsonErwartet (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…statt3cac…).docker-archive:behält das Docker-Format; die Config-Datei heißt wie die Image-ID. Das ist dasselbe Format wiepodman save, undpodman loadliest 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/dlErwartet:
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-88Erwartet (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_HOSTsucht ko/var/run/docker.sockund scheitert. Mit Socket landet das Image in Podmans Speicher, Präfixko.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.--barenimmt den Namen ohne Zusatz,-tsetzt den Tag.{{.Env.VERSION}}ist eine Vorlage: ko setzt die UmgebungsvariableVERSIONein. Fehlt sie, bricht ko ab:executing "argsTmpl" at <.Env.VERSION>: map has no entry for key "VERSION".KO_DEFAULTBASEIMAGEüberschreibtdefaultBaseImage– 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-88Erwartet (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
doneErwartet:
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,6pErwartet:
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-koErwartet:
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"
doneErwartet:
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}}' | sortErwartet:
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 -lErwartet:
[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.serviceErwartet:
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-noreproErwartet (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 unsharenur, wenn gemountet wird. - Basis-Images per Digest pinnen
(
KO_DEFAULTBASEIMAGE=…@sha256:…,FROM …@sha256:…) und per Renovate aktualisieren.:latestmacht 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.