Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 16: Wettkampf – Desaster-Drills

Ziel: Zehn kaputte Stände unter Zeitdruck erst diagnostizieren und dann reparieren – nur mit den Werkzeugen aus Tag 1–14. · Dauer: ca. 150 min · Voraussetzung: Tag 15

Briefing

  • Jede Runde: Lage, Zeitlimit, kaputter Stand, Hinweis, Lösung. Stell dir eine Uhr. Den Hinweis liest du frühestens nach der halben Zeit.
  • Erst beweisen, dann ändern: Ein Befehl zeigt den Fehler, derselbe Befehl zeigt nach dem Fix, dass er weg ist.
  • Jede Runde legt ~/ct-lab/tag16/rundeNN neu an (Demo-Anwendung plus kaputter Stand aus code/tag16/rundeNN) und baut als Spielleitung auf, was sie braucht. Alles heißt r15-…; Quadlet-Pod, Registry und Schlüssel von Tag 14 bleiben unberührt. Freie Ports: 8081–8090, 5001.
  • Wertung: 2 Punkte in der Zeit ohne Hinweis, 1 Punkt mit Hinweis oder knapp drüber, 0 Punkte mit Lösung. Aufgeräumt wird erst nach dem Kontrollpunkt.

Runde 1: Bei mir baut das

source ~/ct-lab/setup/env.sh
podman unshare rm -rf ~/ct-lab/tag16/runde01 && mkdir -p ~/ct-lab/tag16/runde01
cd ~/ct-lab/tag16/runde01
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag16/runde01/." .
ls

Erwartet:

Containerfile  README.md  index.html  notes-api  notes-web  notes-worker

Jede Runde beginnt so: Ordner leeren (podman unshare, weil Runde 5 Dateien fremder UIDs hinterlässt, Tag 2), Demo-Anwendung hinein, kaputten Stand darüber. Wiederholst du die Zeilen, fängst du von vorn an. Manche Runden brauchen danach noch einen Aufbau – den erledigst du als Spielleitung gleich mit.

Lage: Ein Kollege hat eine Doku-Seite für notes gebaut: „Mit Docker läuft das bei mir.” Bei dir bricht podman build sofort ab. Ziel: Das Image baut, die Basis ist auf eine feste Version gepinnt. Zeitlimit: 5 min.

cat Containerfile
podman build -t localhost/r15-doku:1 .; echo "Exit: $?"

Erwartet:

# runde01/Containerfile – Runde 1 (kaputt): Doku-Seite für notes
FROM nginx:stable-alpine
COPY index.html /usr/share/nginx/html/index.html
STEP 1/2: FROM nginx:stable-alpine
Error: creating build container: short-name "nginx:stable-alpine" did not resolve to
an alias and no unqualified-search registries are defined in
"/etc/containers/registries.conf"
Exit: 125

Hinweis: Was ergänzt Docker bei nginx stillschweigend, Podman nicht (Tag 1)? Und warum findet podman run nginx:1.30.6-alpine bei dir trotzdem ein Image?

Lösung

grep -n 'unqualified-search-registries' /etc/containers/registries.conf
grep -c '"nginx"' /etc/containers/registries.conf.d/shortnames.conf
podman images --format '{{.Repository}}:{{.Tag}}' | grep nginx
podman image inspect nginx:1.30.6-alpine --format '{{.Id}}' | cut -c1-12

Erwartet:

21:# unqualified-search-registries = ["example.com"]
0
docker.io/library/nginx:1.30.6-alpine
88f52f3d58a5

Keine Suchliste, kein Alias für nginx. Ein Short-Name passt nur auf Images, die schon im lokalen Speicher liegen – deshalb klappt nginx:1.30.6-alpine bei dir, auf einem frischen CI-Runner aber nicht. stable-alpine ist außerdem ein wandernder Tag. Also vollqualifiziert und fest:

sed -i 's#^FROM nginx:stable-alpine#FROM docker.io/library/nginx:1.30.6-alpine#' \
  Containerfile
podman build -q -t localhost/r15-doku:1 . | cut -c1-12
podman run -d --rm --name r15-doku -p 127.0.0.1:8081:80 localhost/r15-doku:1 >/dev/null
sleep 1; curl -s 127.0.0.1:8081 | grep '<p>'
podman rm -f r15-doku

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

d2e47fdc45a1
<p>Runde 1: gebaut mit Podman.</p>
r15-doku

Kein Pull nötig: Der Name passt jetzt exakt zum Image von Tag 1.

Fortschritt speichern? Kostenlos registrieren

Runde 2: Wo ist mein (healthy)?

podman unshare rm -rf ~/ct-lab/tag16/runde02 && mkdir -p ~/ct-lab/tag16/runde02
cd ~/ct-lab/tag16/runde02
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag16/runde02/." .
podman rm -f r15-api2 2>/dev/null; ./build.sh >/dev/null 2>&1
podman run -d --name r15-api2 -e NOTES_API_KEY=lab-api-key-123 \
  localhost/notes-api:r02 | cut -c1-12

Erwartet (der Build dauert gut eine halbe Minute, ID weicht ab):

00b650a4bac0

Lage: Der Kollege hat den CI-Build von notes-api auf Buildah umgestellt (build.sh). Seitdem zeigt podman ps nie mehr (healthy), und die Quadlet-Units mit Notify=healthy starten gar nicht mehr (sdnotify policy "healthy" requires a healthcheck to be set). Ziel: Das Image hat wieder einen Healthcheck, r15-api2 ist healthy. Zeitlimit: 10 min.

tail -1 build.sh
sleep 15
podman ps --filter name=r15-api2 --format '{{.Names}}\t{{.Status}}'
podman healthcheck run r15-api2; echo "Exit: $?"

Erwartet:

buildah build -t localhost/notes-api:r02 --build-arg VERSION=r02 notes-api
r15-api2    Up 15 seconds
Error: container c26949cb4486… has no defined healthcheck
Exit: 125

Hinweis: Welches Image-Format kennt kein HEALTHCHECK, und welches baut Buildah ohne Schalter (Tag 1, Tag 5)?

Lösung

podman image inspect localhost/notes-api:r02 \
  --format '{{.Config.Healthcheck}} {{.ManifestType}}'
./build.sh 2>&1 | grep 'HEALTHCHECK is not' | cut -c1-88
dockle --no-color localhost/notes-api:r02 | grep -A1 CIS-DI-0006

Erwartet:

<nil> application/vnd.oci.image.manifest.v1+json
time="…" level=warning msg="HEALTHCHECK is not supported for OCI imag
INFO    - CIS-DI-0006: Add HEALTHCHECK instruction to the container image
    * not found HEALTHCHECK statement

Drei Werkzeuge, ein Befund: OCI-Manifest, die Warnung im Build-Log (die niemand liest) und dockle. Der Fix ist ein Schalter:

sed -i 's/^buildah build -t/buildah build --format docker -t/' build.sh
./build.sh 2>&1 | grep -c 'HEALTHCHECK is not'
podman image inspect localhost/notes-api:r02 \
  --format '{{.Config.Healthcheck.Test}} {{.ManifestType}}'
podman rm -f r15-api2 >/dev/null
podman run -d --name r15-api2 -e NOTES_API_KEY=lab-api-key-123 \
  localhost/notes-api:r02 >/dev/null
sleep 4; podman ps --filter name=r15-api2 --format '{{.Names}}\t{{.Status}}'

Erwartet:

0
[CMD /notes-api healthcheck] application/vnd.docker.distribution.manifest.v2+json
r15-api2    Up 4 seconds (healthy)

Ein Container behält sein Image – der neue Build wirkt erst nach rm und run.

Fortschritt speichern? Kostenlos registrieren

Runde 3: Port 80, ganz normal

podman unshare rm -rf ~/ct-lab/tag16/runde03 && mkdir -p ~/ct-lab/tag16/runde03
cd ~/ct-lab/tag16/runde03
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag16/runde03/." .
mkdir -p ~/.config/containers/systemd
systemctl --user stop r15-web.service 2>/dev/null
systemctl --user reset-failed r15-web.service 2>/dev/null
cp r15-web.container ~/.config/containers/systemd/
systemctl --user daemon-reload
cat ~/.config/containers/systemd/r15-web.container

Erwartet:

# ~/.config/containers/systemd/r15-web.container – Runde 3 (kaputt)
[Unit]
Description=notes-Doku auf Port 80 (Runde 3)

[Container]
ContainerName=r15-web
Image=docker.io/library/nginx:1.30.6-alpine
PublishPort=127.0.0.1:80:80

[Service]
Restart=on-failure

Lage: Der Kollege will die Doku „ganz normal” auf Port 80 als Quadlet-Dienst betreiben. Der Dryrun ist sauber, trotzdem startet der Dienst nicht. Ziel: Der Dienst läuft – ohne systemweite Einstellung zu ändern. Zeitlimit: 10 min.

systemctl --user start r15-web.service; echo "Exit: $?"

Erwartet:

Job for r15-web.service failed because the control process exited with error code.
See "systemctl --user status r15-web.service" and "journalctl --user -xeu r15-web.serv…
Exit: 1

Hinweis: systemctl sagt nur „failed” – die Ursache steht im Journal der Unit. Was darf ein normaler User bei Ports nicht (Tag 2)?

Lösung

sleep 5
systemctl --user is-active r15-web.service
journalctl --user -u r15-web.service --no-pager -o cat \
  | grep -E 'pasta|Listen|restart counter|Start request' | tail -5
sysctl net.ipv4.ip_unprivileged_port_start

Erwartet:

failed
Listen failed for HOST TCP port 127.0.0.1/80: Permission denied
Error: pasta failed with exit code 1:
Listen failed for HOST TCP port 127.0.0.1/80: Permission denied
r15-web.service: Scheduled restart job, restart counter is at 5.
r15-web.service: Start request repeated too quickly.
net.ipv4.ip_unprivileged_port_start = 1024

Rootless darf pasta keinen Port unter 1024 öffnen. Restart=on-failure probiert es fünfmal, dann gibt systemd auf. Den Sysctl für alle User zu öffnen verbietet die Lage – also ein freier hoher Port (in Produktion davor ein Reverse Proxy):

q=~/.config/containers/systemd
sed -i 's#^PublishPort=127.0.0.1:80:80#PublishPort=127.0.0.1:8088:80#' \
  "$q/r15-web.container"
systemctl --user daemon-reload
systemctl --user reset-failed r15-web.service
systemctl --user start r15-web.service && sleep 2
podman ps --filter name=r15-web --format '{{.Names}}\t{{.Status}}\t{{.Ports}}'
curl -sI 127.0.0.1:8088 | head -1

Erwartet:

r15-web Up 2 seconds    127.0.0.1:8088->80/tcp
HTTP/1.1 200 OK

reset-failed setzt den Zähler aus „Start request repeated too quickly” zurück – sonst verweigert systemd den nächsten Start.

Fortschritt speichern? Kostenlos registrieren

Runde 4: Die Unit, die es nicht gibt

podman unshare rm -rf ~/ct-lab/tag16/runde04 && mkdir -p ~/ct-lab/tag16/runde04
cd ~/ct-lab/tag16/runde04
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag16/runde04/." .
mkdir -p ~/.config/containers/systemd
systemctl --user stop r15-api.service 2>/dev/null
cp r15-api.container ~/.config/containers/systemd/
systemctl --user daemon-reload

Lage: Für einen Lasttest soll eine zweite notes-api auf Port 8084 laufen. Der Kollege hat r15-api.container abgelegt und daemon-reload ausgeführt – systemd behauptet, die Unit gebe es nicht. Ziel: r15-api.service läuft und antwortet. Zeitlimit: 5 min.

systemctl --user start r15-api.service; echo "Exit: $?"
ls ~/.config/containers/systemd/

Erwartet (gekürzt, deine notes-Units von Tag 3 stehen mit in der Liste):

Failed to start r15-api.service: Unit r15-api.service not found.
Exit: 5
…
r15-api.container
r15-web.container

Hinweis: Die Datei liegt am richtigen Ort. Wer übersetzt sie in eine Unit, und wie fragst du ihn, was ihm nicht passt (Tag 3)?

Lösung

/usr/libexec/podman/quadlet -dryrun -user 2>&1 | grep -E 'r15-api|errors' \
  | cut -d' ' -f2-

Erwartet:

Loading source unit file /home/ubuntu/.config/containers/systemd/r15-api.container
converting "r15-api.container": unsupported key 'Enviroment' in group 'Container' in
/home/ubuntu/.config/containers/systemd/r15-api.container
processing encountered some errors

Ein Tippfehler – und der Generator lässt die ganze Unit weg, ohne dass daemon-reload etwas meldet. Der Dryrun nennt Schlüssel und Datei:

q=~/.config/containers/systemd
sed -i 's/^Enviroment=/Environment=/' "$q/r15-api.container"
/usr/libexec/podman/quadlet -dryrun -user >/dev/null 2>&1; echo "Dryrun: $?"
systemctl --user daemon-reload
systemctl --user start r15-api.service; echo "Exit: $?"
podman ps --filter name='^r15-api$' --format '{{.Names}}\t{{.Status}}\t{{.Ports}}'
curl -s 127.0.0.1:8084/version

Erwartet:

Dryrun: 0
Exit: 0
r15-api Up 1 second (healthy)   127.0.0.1:8084->8080/tcp
0.1.0

start kehrt erst zurück, als der Container healthy ist – das ist Notify=healthy. Der Dryrun mit Exit 0 gehört deshalb vor jedes daemon-reload in einem Deploy-Skript.

Fortschritt speichern? Kostenlos registrieren

Runde 5: Postgres darf nicht schreiben

podman unshare rm -rf ~/ct-lab/tag16/runde05 && mkdir -p ~/ct-lab/tag16/runde05
cd ~/ct-lab/tag16/runde05
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag16/runde05/." .
podman rm -f r15-db 2>/dev/null; ./start-db.sh | cut -c1-12
sleep 3
podman ps -a --filter name=r15-db --format '{{.Names}}\t{{.Status}}'

Erwartet (ID weicht ab):

e87da62a31f7
r15-db  Exited (1) 4 seconds ago

Lage: Für einen Test soll Postgres als UID 70 laufen, die Daten im Projektordner unter pgdata/ (start-db.sh). Der Container ist nach einer Sekunde tot. Ziel: Postgres läuft, die Daten liegen weiter in pgdata/. Zeitlimit: 10 min.

Hinweis: Wem gehört pgdata auf dem Host, und wem im Container? podman unshare zeigt die zweite Sicht (Tag 2).

Lösung

podman logs r15-db 2>&1 | tail -1
grep -- '-v ' start-db.sh
ls -ldn pgdata
podman unshare ls -ldn pgdata

Erwartet (gekürzt):

mkdir: can't create directory '/var/lib/postgresql/18/': Permission denied
  -v ./pgdata:/var/lib/postgresql docker.io/library/postgres:18.6-alpine
drwxr-xr-x 2 1000 1000 4096 Oct 30 23:13 pgdata
drwxr-xr-x 2 0 0 4096 Oct 30 23:13 pgdata

Der Ordner gehört dir (1000), im Container also root. UID 70 darf dort nichts anlegen. :U passt den Besitzer vor dem Start an:

podman rm r15-db >/dev/null
sed -i 's#/var/lib/postgresql docker#/var/lib/postgresql:U docker#' start-db.sh
./start-db.sh | cut -c1-12
until podman exec r15-db pg_isready -q -h 127.0.0.1 2>/dev/null; do sleep 1; done
podman ps --filter name=r15-db --format '{{.Names}}\t{{.Status}}'
ls -ldn pgdata
podman unshare ls -ldn pgdata

Erwartet:

dac60181d156
r15-db  Up 6 seconds
drwxr-xr-x 3 100069 100069 4096 Oct 30 23:13 pgdata
drwxr-xr-x 3 70 70 4096 Oct 30 23:13 pgdata

Außen 100069, innen 70. Die Kehrseite kennst du: Löschen geht jetzt nur noch mit podman unshare rm -rf pgdata – genau deshalb beginnt jede Runde mit podman unshare.

Fortschritt speichern? Kostenlos registrieren

Runde 6: Login vergessen?

podman unshare rm -rf ~/ct-lab/tag16/runde06 && mkdir -p ~/ct-lab/tag16/runde06
cd ~/ct-lab/tag16/runde06
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag16/runde06/." .

Lage: Auf einem neuen CI-Runner kopiert ci-attach.sh notes-api nach lab/notes-api:r06 und hängt eine SBOM an. Der Kollege hat sich laut Doku „einmal mit regctl angemeldet”, regctl tag ls klappt auch – dann bricht der Job ab. Der frische Runner ist mit DOCKER_CONFIG auf einen leeren Ordner nachgestellt. Ziel: Der Job läuft durch, mit einem Login. Zeitlimit: 10 min.

./ci-attach.sh 2>&1 | cut -c1-88; echo "Exit: ${PIPESTATUS[0]}"

Erwartet:

0.1.0
2026/10/30 23:13:30 Copying from registry.ct.lab:5000/notes/notes-api:0.1.0 to registry.
Error: fetching "registry.ct.lab:5000/notes/notes-api:0.1.0": GET https://registry.ct.la
Exit: 1

Ungekürzt endet die Fehlermeldung mit UNAUTHORIZED: authentication required.

Hinweis: Welche Datei schreibt regctl registry login, welche liest crane – und wohin zeigt hier DOCKER_CONFIG (Tabelle in Tag 7)?

Lösung

grep -nE 'DOCKER_CONFIG=|login' ci-attach.sh
ls -A ci-docker; echo "(leer)"
regctl registry whoami "$REG"
echo "$REG" | DOCKER_CONFIG=$PWD/ci-docker crane auth get; echo "Exit: $?"

Erwartet:

7:export DOCKER_CONFIG="$PWD/ci-docker"      # frischer Runner: leere Docker-Config
9:echo "$REG_PASS" | regctl registry login "$REG" -u "$REG_USER" --pass-stdin
(leer)
lab
credentials not found in native keychain
Exit: 1

regctl hat sein Login in ~/.regctl/config.json – crane, syft und oras suchen in $DOCKER_CONFIG/config.json und finden nichts. Der umgekehrte Weg funktioniert: Ein Login in die Docker-Config lesen alle drei und regctl.

sed -i 's/regctl registry login/crane auth login/; s/--pass-stdin/--password-stdin/' \
  ci-attach.sh
grep -n 'auth login' ci-attach.sh
./ci-attach.sh 2>&1 | grep -E 'logged in|digest:|^Attached|✔'
echo "Exit: ${PIPESTATUS[0]}"
jq -c '.auths | keys' ci-docker/config.json
oras discover "$REG/lab/notes-api:r06" | sed -n 2p

Erwartet (gekürzt):

9:echo "$REG_PASS" | crane auth login "$REG" -u "$REG_USER" --password-stdin
… logged in via /home/ubuntu/ct-lab/tag16/runde06/ci-docker/config.json
… registry.ct.lab:5000/lab/notes-api:r06: digest: sha256:9d16f0c69716… size: 591
Attached to [registry] registry.ct.lab:5000/lab/notes-api@sha256:9d16f0c69716…
✔ SBOM angehängt
Exit: 0
["registry.ct.lab:5000"]
└── application/spdx+json

Tipp: Auch podman login schreibt nach $DOCKER_CONFIG/config.json, wenn die Variable gesetzt ist und REGISTRY_AUTH_FILE nicht – im Test war das ebenfalls ein Login für alle. In CI deshalb DOCKER_CONFIG auf einen Ordner pro Job setzen und ihn am Ende löschen.

Fortschritt speichern? Kostenlos registrieren

Runde 7: curl ja, crane nein

podman unshare rm -rf ~/ct-lab/tag16/runde07 && mkdir -p ~/ct-lab/tag16/runde07
cd ~/ct-lab/tag16/runde07
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag16/runde07/." .
mkdir -p certs
openssl req -newkey rsa:3072 -nodes -subj "/CN=$REG_HOST" \
  -keyout certs/test.key -out certs/test.csr 2>/dev/null
openssl x509 -req -in certs/test.csr -CA "$LAB/registry/certs/ca.crt" \
  -CAkey "$LAB/registry/certs/ca.key" -CAcreateserial -days 30 \
  -out certs/test.crt 2>/dev/null
podman rm -f -v r15-registry 2>/dev/null
podman run -d --name r15-registry -p "127.0.0.1:$((REG_PORT + 1)):5000" \
  -v "$PWD/certs:/certs:ro" -e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/test.crt \
  -e REGISTRY_HTTP_TLS_KEY=/certs/test.key docker.io/library/registry:3.1.2 \
  | cut -c1-12
sleep 2

Lage: Der Kollege hat eine Test-Registry auf Port 5001 aufgesetzt, Zertifikat von deiner Labor-CA. „curl geht, also liegt es an crane.” Ziel: crane copy nach registry.ct.lab:5001 funktioniert. Zeitlimit: 10 min.

T="$REG_HOST:$((REG_PORT + 1))"; echo "$T"
curl -sS "https://$T/v2/"; echo " curl: $?"
crane copy "$REG/notes/notes-api:0.1.0" "$T/notes/notes-api:0.1.0" 2>&1 | tail -1

Erwartet:

registry.ct.lab:5001
{} curl: 0
Error: Get "https://registry.ct.lab:5001/v2/": tls: failed to verify certificate: x509:
certificate relies on legacy Common Name field, use SANs instead

Hinweis: Welchen Teil des Zertifikats prüfen Go-Programme beim Hostnamen, und welchen nimmt curl notfalls auch (Tag 7, Drill 1)?

Lösung

openssl s_client -connect "$T" -servername "$REG_HOST" </dev/null 2>/dev/null \
  | openssl x509 -noout -subject -issuer -ext subjectAltName
openssl x509 -in "$LAB/registry/certs/registry.crt" -noout -ext subjectAltName

Erwartet:

subject=CN=registry.ct.lab
issuer=CN=ct-lab CA (ubuntu)
No extensions in certificate
X509v3 Subject Alternative Name:
    DNS:registry.ct.lab

Die CA stimmt, der Name im CN auch – aber das Zertifikat hat keinen subjectAltName. curl (OpenSSL) fällt dann auf den CN zurück, Go nicht mehr: Das trifft crane, regctl, oras, cosign, Podman und containerd gleichermaßen. Neu ausstellen mit der ext.cnf von Tag 7:

ca="$LAB/registry/certs"
openssl x509 -req -in certs/test.csr -CA "$ca/ca.crt" -CAkey "$ca/ca.key" \
  -CAcreateserial -days 30 -extfile "$ca/ext.cnf" -out certs/test.crt
openssl x509 -in certs/test.crt -noout -ext subjectAltName
podman restart r15-registry >/dev/null && sleep 2
crane copy "$REG/notes/notes-api:0.1.0" "$T/notes/notes-api:0.1.0" 2>&1 | tail -1 \
  | cut -c21-88
crane ls "$T/notes/notes-api"

Erwartet:

Certificate request self-signature ok
subject=CN=registry.ct.lab
X509v3 Subject Alternative Name:
    DNS:registry.ct.lab
registry.ct.lab:5001/notes/notes-api:0.1.0: digest: sha256:9d16f0c69
0.1.0

Der CSR bleibt, nur die Signatur ist neu. Die Test-Registry hat kein Login – crane schreibt anonym.

Fortschritt speichern? Kostenlos registrieren

Runde 8: Das Air-Gap-Archiv

podman unshare rm -rf ~/ct-lab/tag16/runde08 && mkdir -p ~/ct-lab/tag16/runde08
cd ~/ct-lab/tag16/runde08
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag16/runde08/." .

Lage: Für ein Netz ohne Internet soll notes-api als Archiv auf einen USB-Stick. export-airgap.sh liest direkt aus dem Podman-Speicher und scheitert. Ziel: Archiv mit Prüfsummen-Datei, ohne das Skript auf sudo umzustellen. Zeitlimit: 5 min.

./export-airgap.sh; echo "Exit: $?"

Erwartet:

Error during unshare(...): Operation not permitted
Exit: 1

Hinweis: Warum dürfen podman und buildah auf Ubuntu 26.04 einen User Namespace anlegen, skopeo aber nicht (Tag 8)?

Lösung

sysctl kernel.apparmor_restrict_unprivileged_userns
ls /etc/apparmor.d | grep -E '^(podman|buildah|skopeo)$'

Erwartet:

kernel.apparmor_restrict_unprivileged_userns = 1
buildah
podman

Ohne eigenes AppArmor-Profil darf skopeo keinen User Namespace öffnen – und ohne den kommt es rootless nicht an containers-storage:. Also läuft skopeo im Namespace von Podman:

sed -i 's#^skopeo copy#podman unshare skopeo copy#' export-airgap.sh
./export-airgap.sh 2>&1 | tail -2; echo "Exit: ${PIPESTATUS[0]}"
skopeo inspect --format '{{.Architecture}}' docker-archive:notes-api-0.1.0.tar
sha256sum -c notes-api-0.1.0.tar.sha256

Erwartet:

Writing manifest to image destination
✔ notes-api-0.1.0.tar fertig
Exit: 0
arm64
notes-api-0.1.0.tar: OK

Lesen aus docker-archive: braucht keinen Namespace – skopeo inspect läuft ohne unshare. podman save -o wäre der zweite Weg zum selben Archiv.

Fortschritt speichern? Kostenlos registrieren

Runde 9: Gestern grün, heute rot

podman unshare rm -rf ~/ct-lab/tag16/runde09 && mkdir -p ~/ct-lab/tag16/runde09
cd ~/ct-lab/tag16/runde09
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag16/runde09/." .

Lage: Das Schwachstellen-Gate (gate.sh) für notes-api war gestern grün. Heute schlägt es an, obwohl niemand Code oder Image geändert hat. Das Update von golang.org/x/text kommt nächste Woche mit notes-api 0.1.1 (Ticket LAB-15). Ziel: Gate wieder grün, mit nachvollziehbarer Ausnahme. Zeitlimit: 10 min.

./gate.sh | grep -E 'Total|CVE' | tr -s ' ' | cut -c1-88; echo "Exit: ${PIPESTATUS[0]}"

Erwartet:

Total: 2 (HIGH: 2, CRITICAL: 0)
│ golang.org/x/text │ CVE-2026-56851 │ HIGH │ fixed │ v0.29.0 │ 0.41.0 │ golang.org/x/te
│ │ CVE-2026-56852 │ │ │ │ 0.39.0 │ golang.org/x/text: golang.org/x/text: Denial of Serv
Exit: 1

Hinweis: Die Ausnahmen stehen in .trivyignore. Was steht hinter jeder CVE, und welches Datum ist heute (Tag 13)?

Lösung

trivy image -q --scanners vuln --severity HIGH,CRITICAL --show-suppressed \
  localhost/notes-api:0.1.0 | grep -c Suppressed
grep -v '^#' .trivyignore; date +%F

Erwartet:

0
CVE-2026-56851 exp:2026-09-30
CVE-2026-56852 exp:2026-09-30
2026-10-30

Nichts unterdrückt: Beide Ausnahmen sind am 30.09. abgelaufen – genau dafür gibt es exp:. Die richtige Reparatur ist das Update (Challenge von Tag 13). Bis dahin eine neue Frist, mit Grund und Ticket:

cat > .trivyignore <<'EOF'
# .trivyignore – Runde 9: bewusst akzeptierte Befunde, je mit Grund und Ablauf
# golang.org/x/text v0.29.0 in notes-api: Update eingeplant (Ticket LAB-13)
# verlängert bis Ende November, Update kommt mit notes-api 0.1.1 (Ticket LAB-15)
CVE-2026-56851 exp:2026-11-30
CVE-2026-56852 exp:2026-11-30
EOF
./gate.sh | tail -1; echo "Exit: ${PIPESTATUS[0]}"
trivy image -q --scanners vuln --severity HIGH,CRITICAL --show-suppressed \
  localhost/notes-api:0.1.0 | grep -E 'Suppressed|CVE' | tr -s ' '

Erwartet:

✔ Gate bestanden
Exit: 0
Suppressed Vulnerabilities (Total: 2)
│ golang.org/x/text │ CVE-2026-56851 │ HIGH │ ignored │ N/A │ .trivyignore │
│ │ CVE-2026-56852 │ │ │ │ │

Eine Ausnahme ohne Ablaufdatum wäre in Sekunden repariert – und in einem Jahr noch da.

Fortschritt speichern? Kostenlos registrieren

Runde 10: Signiert ist signiert?

podman unshare rm -rf ~/ct-lab/tag16/runde10 && mkdir -p ~/ct-lab/tag16/runde10
cd ~/ct-lab/tag16/runde10
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag16/runde10/." .
export COSIGN_PASSWORD=lab-cosign-pw-123
r="$REG/lab/release-api"
podman rm -f r15-api10 2>/dev/null
podman push -q localhost/notes-api:0.1.0 "$r:stabil"
cosign sign --key ~/ct-lab/keys/cosign.key --signing-config lab-signing-config.json \
  --yes "$r@$(crane digest "$r:stabil")" >/dev/null 2>&1
podman push -q localhost/notes-api:0.2.0 "$r:stabil"

Lage: Die Freigabe von notes-api wurde mit deinem Schlüssel signiert und als lab/release-api:stabil veröffentlicht. deploy.sh startet nur signierte Images – heute verweigert es den Start. Der Kollege schwört, er habe signiert („danach nur noch schnell einen Fix gepusht”). Ziel: Es läuft das freigegebene Image, und deploy.sh ist dicht. Zeitlimit: 15 min.

./deploy.sh; echo "Exit: $?"

Erwartet:

WARNING: Skipping tlog verification is an insecure practice that lacks transparency…
Error: no signatures found
error during command execution: no signatures found
Exit: 10

Hinweis: cosign signiert einen Digest, kein Tag. Auf welchen Digest zeigt stabil heute, und für welchen liegt ein sha256-…-Tag in der Registry (Tag 14)?

Lösung

r="$REG/lab/release-api"
crane digest "$r:stabil"
crane ls "$r"
crane config "$r:stabil" | jq -r '.config.Labels["org.opencontainers.image.version"]'
good="sha256:$(crane ls "$r" | sed -n 's/^sha256-//p')"; echo "$good"
cosign verify --key ~/ct-lab/keys/cosign.pub --insecure-ignore-tlog=true "$r@$good" \
  2>/dev/null | jq -r '.[0].critical.image["docker-manifest-digest"]'
crane config "$r@$good" | jq -r '.config.Labels["org.opencontainers.image.version"]'

Erwartet:

sha256:f046628da01b9158ac892a18f2033dcfcf16bc071fc51a73919e14b6b89f86c7
sha256-9d16f0c69716a49b3b9d13935c47b4dc45cbd1385bae869e9bb9896489156059
stabil
0.2.0
sha256:9d16f0c69716a49b3b9d13935c47b4dc45cbd1385bae869e9bb9896489156059
sha256:9d16f0c69716a49b3b9d13935c47b4dc45cbd1385bae869e9bb9896489156059
0.1.0

Die Signatur gilt 9d16… (notes-api 0.1.0). Der „schnelle Fix” hat den Tag auf f046… (0.2.0) umgehängt – ein ungeprüftes Image unter dem Namen der Freigabe. Zwei Reparaturen: deploy.sh löst den Tag einmal zum Digest auf und prüft und startet genau diesen; und stabil zeigt wieder auf die Freigabe.

cat > deploy.sh <<'EOF'
#!/usr/bin/env bash
# runde10/deploy.sh – Runde 10 (repariert): Digest einmal auflösen, prüfen, starten
set -euo pipefail
# shellcheck source=/dev/null
source "$HOME/ct-lab/setup/env.sh"
img="$REG/lab/release-api@$(crane digest "$REG/lab/release-api:stabil")"
cosign verify --key ~/ct-lab/keys/cosign.pub --insecure-ignore-tlog=true \
  "$img" >/dev/null 2>verify.log || { tail -1 verify.log; exit 1; }
podman run -d --name r15-api10 -p 127.0.0.1:8090:8080 \
  -e NOTES_API_KEY=lab-api-key-123 "$img" >/dev/null
echo "✔ $img gestartet"
EOF
./deploy.sh; echo "Exit: $?"
crane tag "$r@$good" stabil 2>/dev/null
./deploy.sh | cut -c1-88; echo "Exit: ${PIPESTATUS[0]}"
sleep 3; curl -s 127.0.0.1:8090/version

Erwartet (gekürzt):

error during command execution: no signatures found
Exit: 1
Trying to pull registry.ct.lab:5000/lab/release-api@sha256:9d16f0c69716a49b3b9d13935c…
…
✔ registry.ct.lab:5000/lab/release-api@sha256:9d16f0c69716a49b3b9d13935c47b4dc45cbd1385b
Exit: 0
0.1.0

Das neue Skript lehnt den ungeprüften Stand weiter ab – so soll es sein. Erst nach crane tag läuft die Freigabe, gestartet per Digest: Selbst wenn jemand stabil zwischen Prüfung und Start umhängt, startet Podman das geprüfte Image. Der Fix 0.2.0 braucht eine eigene Freigabe mit eigener Signatur.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Wertung: Trag deine Punkte (0–2) pro Runde zusammen. Die Befehle zeigen, ob die reparierten Stände wirklich da sind.

R1 – FROM vollqualifiziert, Image gebaut:

source ~/ct-lab/setup/env.sh
cd ~/ct-lab/tag16
grep '^FROM' runde01/Containerfile
podman images --filter reference=localhost/r15-doku --format '{{.Tag}}'

Erwartet:

FROM docker.io/library/nginx:1.30.6-alpine
1

R2 – Healthcheck im Image, r15-api2 healthy:

podman ps --filter name=r15-api2 --format '{{.Status}}'

Erwartet (Zeit weicht ab):

Up About a minute (healthy)

R3 – r15-web aktiv auf 8088:

systemctl --user is-active r15-web.service
curl -s -o /dev/null -w '%{http_code}\n' 127.0.0.1:8088

Erwartet:

active
200

R4 – Dryrun sauber, r15-api aktiv:

/usr/libexec/podman/quadlet -dryrun -user >/dev/null 2>&1; echo "Exit: $?"
systemctl --user is-active r15-api.service

Erwartet:

Exit: 0
active

R5 – Postgres läuft mit :U:

podman ps --filter name=r15-db --format '{{.Status}}'
grep -o 'postgresql:U' runde05/start-db.sh

Erwartet (Zeit weicht ab):

Up 43 seconds
postgresql:U

R6 – SBOM hängt an lab/notes-api:r06:

oras discover "$REG/lab/notes-api:r06"

Erwartet (gekürzt):

registry.ct.lab:5000/lab/notes-api@sha256:322f88bdda87…
└── application/spdx+json
    └── sha256:d9d533be6cdec8b98c8cd12362ec7b76c59b0c2b9d0ff8e43db16585d9c071aa
        └── [annotations]
            └── org.opencontainers.image.created: "…"

R7 – Test-Registry mit SAN:

crane ls "$REG_HOST:5001/notes/notes-api"

Erwartet:

0.1.0

R8 – Air-Gap-Archiv mit Prüfsumme:

cd runde08
sha256sum -c notes-api-0.1.0.tar.sha256
cd ..

Erwartet:

notes-api-0.1.0.tar: OK

R9 – Gate grün, Ausnahme mit neuem Ablauf:

runde09/gate.sh >/dev/null; echo "Exit: $?"
grep -o 'exp:2026-11-30' runde09/.trivyignore

Erwartet:

Exit: 0
exp:2026-11-30
exp:2026-11-30

R10 – stabil signiert, r15-api10 läuft per Digest:

cosign verify --key ~/ct-lab/keys/cosign.pub --insecure-ignore-tlog=true \
  "$REG/lab/release-api:stabil" >/dev/null 2>&1; echo "Exit: $?"
podman ps --filter name=r15-api10 --format '{{.Image}}'

Erwartet:

Exit: 0
registry.ct.lab:5000/lab/release-api@sha256:322f88bdda8796c68536e83ff42ca49e3fa97d7415f…
Punkte Urteil
17–20 Wettkampfreif: weiter mit Anhang B
10–16 Solide: die Runden mit 0 Punkten am Tag dahinter nachtrainieren
unter 10 Tag 1–8 noch einmal, dann Revanche

Challenge

Drei Gates, ein Containerfile: code/tag16/challenge enthält eine alpine-basierte notes-api, die bei hadolint, dive --ci (Regeln aus .dive-ci) und dockle -c 1 durchfällt. Bring sie durch alle drei – das Image muss weiter laufen und healthy sein.

Hinweis: Jeder RUN nach dem COPY kostet: chmod verdoppelt das Binary, und für den Healthcheck braucht es kein curl (Tag 1, Tag 11, Tag 12).

Lösung

Diagnose:

podman unshare rm -rf ~/ct-lab/tag16/challenge && mkdir -p ~/ct-lab/tag16/challenge
cd ~/ct-lab/tag16/challenge
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag16/challenge/." .
hadolint --no-color notes-api/Containerfile | cut -c1-88
podman build -q --format docker -f notes-api/Containerfile \
  -t localhost/r15-api:challenge notes-api >/dev/null 2>&1
dive --ci --source podman localhost/r15-api:challenge \
  | grep -E 'efficiency:|wastedBytes:|Result:'
dockle --no-color -c 1 localhost/r15-api:challenge | grep -E '^[A-Z]'
podman images --format '{{.Tag}} {{.Size}}' localhost/r15-api

Erwartet (gekürzt):

notes-api/Containerfile:10 DL3018 warning: Pin versions in apk add. Instead of `apk add
notes-api/Containerfile:10 DL3019 info: Use the `--no-cache` switch to avoid the need to
notes-api/Containerfile:10 DL3059 info: Multiple consecutive `RUN` instructions. Conside
notes-api/Containerfile:12 DL3025 error: Use arguments JSON notation for CMD and ENTRYPO
  efficiency: 66.4577 %
  wastedBytes: 34148117 bytes (34 MB)
Result:FAIL [Total:3] [Passed:0] [Failed:3] [Warn:0] [Skipped:0]
FATAL   - DKL-DI-0004: Use "apk add" with --no-cache
WARN    - CIS-DI-0001: Create a user for the container
challenge 51.2 MB

hadolint stört sich an apk add ohne Pin und --no-cache und am Healthcheck in Shell-Form (DL3025, aus der Projekt-.hadolint.yaml als Fehler). dive findet das doppelte Binary aus chmod (go build legt es schon ausführbar an), dockle den apk-Cache und root als User. Alle drei verschwinden mit weniger Zeilen:

cat > notes-api/Containerfile <<'EOF'
# challenge/notes-api/Containerfile – Challenge Tag 16 (repariert)
FROM docker.io/library/golang:1.27-alpine AS build
WORKDIR /src
COPY . .
RUN CGO_ENABLED=0 go build -o /out/notes-api .

FROM docker.io/library/alpine:3.24
COPY --from=build /out/notes-api /usr/local/bin/notes-api
USER 65532:65532
EXPOSE 8080
HEALTHCHECK CMD ["/usr/local/bin/notes-api", "healthcheck"]
ENTRYPOINT ["notes-api"]
EOF
hadolint notes-api/Containerfile; echo "hadolint: $?"
podman build -q --format docker -f notes-api/Containerfile \
  -t localhost/r15-api:challenge notes-api >/dev/null 2>&1
dive --ci --source podman localhost/r15-api:challenge | grep -E 'efficiency:|Result:'
dockle --no-color -c 1 localhost/r15-api:challenge; echo "dockle: $?"
podman run -d --name r15-challenge -e NOTES_API_KEY=lab-api-key-123 \
  localhost/r15-api:challenge >/dev/null
sleep 5; podman ps --filter name=r15-challenge --format '{{.Names}}\t{{.Status}}'
podman images --format '{{.Tag}} {{.Size}}' localhost/r15-api

Erwartet:

hadolint: 0
  efficiency: 100.0000 %
Result:PASS [Total:3] [Passed:3] [Failed:0] [Warn:0] [Skipped:0]
dockle: 0
r15-challenge   Up 6 seconds (healthy)
challenge 25.8 MB

Halb so groß, drei grüne Gates. dockle meldet nichts mehr – CIS-DI-0005 steht in der .dockleignore von Tag 12. Zum Schluss alles aus Tag 16 abräumen:

for u in r15-web r15-api; do
  systemctl --user stop "$u.service" 2>/dev/null
  rm -f ~/.config/containers/systemd/"$u.container"
done
systemctl --user daemon-reload
podman ps -aq --filter name='^r15-' | xargs -r podman rm -f -v -t 0 >/dev/null
podman images -q --filter reference='localhost/r15-*' \
  | xargs -r podman rmi -f >/dev/null
podman rmi -f localhost/notes-api:r02 >/dev/null 2>&1
for r in lab/notes-api lab/release-api; do
  for t in $(regctl tag ls "$REG/$r"); do regctl tag rm "$REG/$r:$t"; done
done
podman ps -aq --filter name='^r15-' | wc -l
regctl tag ls "$REG/lab/notes-api" | wc -l

Erwartet:

0
0

Die Rundenordner bleiben zum Nachlesen liegen; Quadlet-Pod, Registry und Schlüssel sind unverändert.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Desaster-Drills eignen sich als Team-Gameday: rotierende Spielleitung, feste Zeitlimits, nach jeder Runde fünf Minuten „Welches Gate hätte das gefangen?“.
  • Fast jede Runde ist ein fehlender Pipeline-Schritt: Quadlet-Dryrun vor daemon-reload, --format docker plus Healthcheck-Prüfung nach dem Build, vollqualifizierte FROM-Zeilen per trustedRegistries.
  • Deploys arbeiten mit Digests, nie mit Tags: einmal auflösen, prüfen, genau diesen Digest starten (Runde 10) – in Kubernetes erzwingt das ein Admission-Controller.
  • Ausnahmen (.trivyignore, .dockleignore, hadolint-Pragmas) laufen ab und haben ein Ticket. Ein Gate, das „plötzlich” rot wird, ist oft eine abgelaufene Ausnahme.
  • CI-Runner bekommen einen eigenen DOCKER_CONFIG pro Job und kurzlebige Zugangsdaten; Zertifikate kommen aus der Firmen-PKI – immer mit SAN.