Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 11: Images von innen – dive, diffoci, container-diff

Ziel: Du siehst in jeden Layer eines Images hinein, findest verschwendeten Platz, prüfst ihn automatisch und vergleichst zwei Images Datei für Datei. · Dauer: ca. 75 min · Voraussetzung: Tag 10

Briefing

  • Ein Image ist ein Stapel von Layern. Was ein Layer anlegt und ein späterer löscht, bleibt im Image – unsichtbar, aber mitgeladen.
  • dive zeigt jeden Layer mit seinen Dateien, schätzt die Verschwendung und wird mit --ci zum Prüfschritt in der Pipeline.
  • diffoci vergleicht zwei Images (Manifest, Config, jede Datei) und ignoriert auf Wunsch Zeitstempel – ideal für „ist der Neubau wirklich gleich?“.
  • container-diff (Google) tat Ähnliches, ist aber archiviert. Du baust es einmal selbst und siehst, warum diffoci der Nachfolger ist.
 Containerfile.schlecht ──build──► notes-api:schlecht ──dive──► Layer, Verschwendung
                                                    └─dive --ci + .dive-ci ─► PASS/FAIL
 notes-api:0.1.0 ◄──diffoci──► notes-api:0.2.0 / Neubau / Registry-Kopie

Drill 1: dive – installieren und ein erster Blick

Steckbrief dive
Aufgabe Image Layer für Layer erkunden, verschwendeten Platz finden
Besonderheit Terminal-Oberfläche plus CI-Modus mit Grenzwerten; liest Podman-Images
Projekt github.com/wagoodman/dive (MIT)
Version im Buch 0.13.1

Tagesstart wie immer, dann die Installation – noch einmal von Hand wie an Tag 0, diesmal einzeln:

source ~/ct-lab/setup/env.sh
mkdir -p ~/ct-lab/tag11 && cd ~/ct-lab/tag11
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag10/notes/." .
arch=$(dpkg --print-architecture)
read -r _ _ url sum < <(grep "^dive $arch " "$LAB/setup/tools.lock")
curl -fsSLo /tmp/dive.tgz "$url"
echo "$sum  /tmp/dive.tgz" | sha256sum -c -
sudo tar -C /usr/local/bin -xzf /tmp/dive.tgz dive && rm /tmp/dive.tgz
dive --version

Erwartet (gekürzt):

/tmp/dive.tgz: OK
dive 0.13.1

dive liest Images standardmäßig über die Docker-API – und die liefert seit Tag 4 der Podman-Socket (DOCKER_HOST in ~/.bashrc). Also einfach:

dive docker.io/library/nginx:1.30.6-alpine

Erwartet (Ausschnitt, links oben):

┃ ● Layers ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Cmp   Size  Command
    8.4 MB  FROM 75c137aedfb2760
    4.3 MB  RUN /bin/sh -c set -x     && addgroup -g 101 -S nginx
    1.6 kB  COPY docker-entrypoint.sh / # buildkit
    2.1 kB  COPY 10-listen-on-ipv6-by-default.sh /docker-entrypoint.d
…

Die Oberfläche lernst du in Drill 3 kennen; Strg+C beendet sie. Für Skripte gibt es den nicht-interaktiven Modus – CI=true wirkt wie --ci. Dazu die zweite Quelle: podman://<image> (gleichwertig --source podman <image>) fragt Podman direkt:

CI=true dive podman://docker.io/library/nginx:1.30.6-alpine

Erwartet:

  Using default CI config
Image Source: podman://docker.io/library/nginx:1.30.6-alpine
Extracting image from podman... (this can take a while for large images)
Analyzing image...
  efficiency: 99.4479 %
  wastedBytes: 543920 bytes (544 kB)
  userWastedPercent: 1.0093 %
Inefficient Files:
Count  Wasted Space  File Path
    2        358 kB  /etc/ssl/certs/ca-certificates.crt
    3        163 kB  /lib/apk/db/installed
    2         11 kB  /var/log/apk.log
…
Results:
  PASS: highestUserWastedPercent
  SKIP: highestWastedBytes: rule disabled
  PASS: lowestEfficiency
Result:PASS [Total:3] [Passed:2] [Failed:0] [Warn:0] [Skipped:1]

Verschwendung zählt dive für jede Datei, die in mehr als einem Layer vorkommt: Die CA-Datei legt das Alpine-Basisimage an, nginx schreibt sie neu – beide Fassungen werden geladen. 544 kB bei 64 MB sind vernachlässigbar.

Wie kommt dive an das Image? Ein kleiner Spion im PATH verrät es:

mkdir -p /tmp/spy
printf '#!/bin/sh\necho "podman $*" >&2\nexec /usr/bin/podman "$@"\n' > /tmp/spy/podman
chmod +x /tmp/spy/podman
PATH=/tmp/spy:$PATH dive --ci --source podman docker.io/library/nginx:1.30.6-alpine \
  2>&1 | grep '^podman'
rm -rf /tmp/spy

Erwartet:

podman image save docker.io/library/nginx:1.30.6-alpine

Mit podman:// ruft dive schlicht podman image save auf und liest das Archiv – dafür braucht es weder Socket noch DOCKER_HOST. Dasselbe geht von Hand mit docker-archive://:

podman save -q -o nginx.tar docker.io/library/nginx:1.30.6-alpine
dive --ci docker-archive://nginx.tar | grep efficiency
rm nginx.tar

Erwartet:

  efficiency: 99.4479 %

Fortschritt speichern? Kostenlos registrieren

Drill 2: Ein absichtlich schlechtes Containerfile

Ein einstufiger Build von notes-api, wie man ihn oft findet:

cat > notes-api/Containerfile.schlecht <<'EOF'
# notes-api/Containerfile.schlecht – Stand Ende Tag 11 (absichtlich schlecht)
FROM docker.io/library/golang:1.27-alpine
RUN apk update && apk add git curl
WORKDIR /src
COPY . .
RUN go build -o /usr/local/bin/notes-api .
RUN rm -rf /root/.cache/go-build /go/pkg/mod
RUN chmod 755 /usr/local/bin/notes-api
EXPOSE 8080
ENTRYPOINT ["notes-api"]
EOF
podman build -q --format docker -f notes-api/Containerfile.schlecht \
  -t localhost/notes-api:schlecht notes-api >/dev/null 2>&1
podman history localhost/notes-api:schlecht --format '{{.Size}}\t{{.CreatedBy}}' \
  | cut -c1-60 | head -6
podman images --format '{{.Tag}}\t{{.Size}}' localhost/notes-api \
  | awk '$1 ~ /^(schlecht|besser|0\.1\.0|0\.2\.0)$/'

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

0B  /bin/sh -c #(nop) ENTRYPOINT ["notes-api"]
0B  /bin/sh -c #(nop) EXPOSE 8080
17.1MB  /bin/sh -c chmod 755 /usr/local/bin/notes-api
4.1kB   /bin/sh -c rm -rf /root/.cache/go-build /g...
211MB   /bin/sh -c go build -o /usr/local/bin/note...
27.1kB  /bin/sh -c #(nop) COPY dir:36d41903e3bbf16...
schlecht    511 MB
0.1.0   11.9 MB
0.2.0   11.9 MB

Drei Fehler auf einen Blick: Der go build-Layer bringt 211 MB mit (Modul- und Build-Cache), das rm im nächsten Layer spart davon kein Byte, und chmod kopiert das fertige Binary (17 MB) ein zweites Mal in einen neuen Layer. Dazu kommen Compiler, git und curl, die zur Laufzeit niemand braucht.

Fortschritt speichern? Kostenlos registrieren

Drill 3: dive interaktiv bedienen

dive --source podman localhost/notes-api:schlecht

Erwartet (gekürzt, linke Hälfte der Oberfläche):

┃ ● Layers ┣━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
Cmp   Size  Command
    8.4 MB  FROM 75c137aedfb2760
    418 kB  RUN /bin/sh -c apk add --no-cache ca-certificates # build
    244 MB  COPY /target/ / # buildkit
       0 B  WORKDIR /go
     16 MB  apk update && apk add git curl
     20 kB  #(nop) COPY dir:f803d84a760d99b11ac73441726069a7c6d732f44
    209 MB  go build -o /usr/local/bin/notes-api .
       0 B  rm -rf /root/.cache/go-build /go/pkg/mod
     17 MB  chmod 755 /usr/local/bin/notes-api
│ Image Details ├────────────────────────────────────────────────────
Image name: localhost/notes-api:schlecht
Total Image size: 495 MB
Potential wasted space: 35 MB
Image efficiency score: 97 %

Links stehen die Layer, rechts der Dateibaum des markierten Layers. Die Bedienung:

Taste Wirkung
Pfeiltasten Layer bzw. Datei wählen
Tab zwischen Layer-Liste und Dateibaum wechseln
Strg+L / Strg+A Layer-Liste: nur dieser Layer / aufsummiert bis hier
Strg+A/R/M/U Dateibaum: hinzugefügt/entfernt/geändert/unverändert ein/aus
Leertaste Ordner auf- und zuklappen
Strg+F Dateibaum filtern
Strg+C beenden

Probier es: Wähle den Layer rm -rf …, wechsle mit Tab in den Dateibaum und drück Strg+U. Übrig bleibt der gelöschte Ordner /go/pkg/mod (54 MB) – gelöscht, aber weiter im Image. Im Layer chmod findest du /usr/local/bin/notes-api als geändert.

Achtung: dive zählt nur Dateien als Verschwendung, die mehrfach vorkommen (hier das Binary: 34 MB). Ein in einem späteren Layer gelöschter Ordner fehlt in der Rechnung – im Test blieben die 211 MB des go build-Layers unberücksichtigt. Die Layer-Größen in der linken Spalte sind deshalb genauso wichtig wie der Score.

Für Skripte gibt es die Analyse auch als JSON:

dive --source podman localhost/notes-api:schlecht -j dive.json >/dev/null
jq '.image | {sizeBytes, inefficientBytes, efficiencyScore}' dive.json
jq -r '.layer[] | "\(.sizeBytes)\t\(.command[0:40])"' dive.json | tail -3

Erwartet:

{
  "sizeBytes": 495353956,
  "inefficientBytes": 34557035,
  "efficiencyScore": 0.9748137601038499
}
208902405   go build -o /usr/local/bin/notes-api .
0   rm -rf /root/.cache/go-build /go/pkg/mod
17054352    chmod 755 /usr/local/bin/notes-api

Fortschritt speichern? Kostenlos registrieren

Drill 4: Grenzwerte mit .dive-ci

Mit den Standardregeln besteht selbst das schlechte Image:

CI=true dive podman://localhost/notes-api:schlecht | tail -2
echo "Exit: ${PIPESTATUS[0]}"

Erwartet:

Result:PASS [Total:3] [Passed:2] [Failed:0] [Warn:0] [Skipped:1]

Exit: 0

Die Standardwerte sind großzügig (mindestens 90 % Effizienz, höchstens 10 % Verschwendung in den eigenen Layern). Eigene Regeln stehen in .dive-ci, das dive im aktuellen Ordner sucht (--ci-config wählt eine andere Datei):

cat > .dive-ci <<'EOF'
# .dive-ci – Stand Ende Tag 11: Grenzwerte für dive --ci
rules:
  lowestEfficiency: 0.98           # mind. 98 % effizient
  highestWastedBytes: 10MB         # höchstens 10 MB doppelt/gelöscht
  highestUserWastedPercent: 0.05   # höchstens 5 % Verschwendung in eigenen Layern
EOF
dive --ci --source podman localhost/notes-api:schlecht | sed -n '/Results/,$p'
echo "Exit: ${PIPESTATUS[0]}"

Erwartet:

Results:
  FAIL: highestUserWastedPercent: too many bytes wasted, relative to the user bytes
added (%-user-wasted-bytes=0.07096897867286082 > threshold=0.05)
  FAIL: highestWastedBytes: too many bytes wasted (wasted-bytes=34557035 >
threshold=10000000)
  FAIL: lowestEfficiency: image efficiency is too low (efficiency=0.9748137601038499
< threshold=0.98)
Result:FAIL [Total:3] [Passed:0] [Failed:3] [Warn:0] [Skipped:0]

Exit: 1

Exit-Code 1 – genau das braucht eine Pipeline. Einzelne Werte lassen sich auch per Flag setzen, etwa --lowestEfficiency 0.98 oder --highestWastedBytes 10MB.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Verschwendung beheben

Bauen, aufräumen und Rechte setzen gehören in einen RUN. go build legt das Binary ohnehin ausführbar an, chmod entfällt; git und curl braucht der Build nicht:

cat > notes-api/Containerfile.besser <<'EOF'
# notes-api/Containerfile.besser – Stand Ende Tag 11 (ein Layer statt drei)
FROM docker.io/library/golang:1.27-alpine
WORKDIR /src
COPY . .
RUN go build -o /usr/local/bin/notes-api . \
 && rm -rf /root/.cache/go-build /go/pkg/mod
EXPOSE 8080
ENTRYPOINT ["notes-api"]
EOF
podman build -q --format docker -f notes-api/Containerfile.besser \
  -t localhost/notes-api:besser notes-api >/dev/null 2>&1
podman images --format '{{.Tag}}\t{{.Size}}' localhost/notes-api \
  | awk '$1 ~ /^(schlecht|besser|0\.1\.0|0\.2\.0)$/'
for t in schlecht besser 0.1.0; do
  echo "== $t"; dive --ci --source podman "localhost/notes-api:$t" \
    | grep -E 'efficiency:|Result:'
done

Erwartet:

besser  283 MB
schlecht    511 MB
0.1.0   11.9 MB
0.2.0   11.9 MB
== schlecht
  efficiency: 97.4814 %
Result:FAIL [Total:3] [Passed:0] [Failed:3] [Warn:0] [Skipped:0]
== besser
  efficiency: 99.9240 %
Result:PASS [Total:3] [Passed:3] [Failed:0] [Warn:0] [Skipped:0]
== 0.1.0
  efficiency: 100.0000 %
Result:PASS [Total:3] [Passed:3] [Failed:0] [Warn:0] [Skipped:0]

Ein RUN halbiert das Image. Den Rest erledigt erst der Multi-Stage-Build aus „Dockerfiles zum Anfassen”: notes-api:0.1.0 hat nur noch Binary und CA-Datei auf scratch – 11.9 MB, keine einzige verschwendete Datei.

Fortschritt speichern? Kostenlos registrieren

Drill 6: diffoci – zwei Images vergleichen

Steckbrief diffoci
Aufgabe zwei Images vergleichen: Index, Manifest, Config, jede Datei in den Layern
Besonderheit --semantic ignoriert Zeitstempel und Reihenfolge; Exit 1 bei Unterschieden
Projekt github.com/reproducible-containers/diffoci (Apache-2.0)
Version im Buch v0.1.8
diffoci --version

Erwartet:

diffoci version v0.1.8

diffoci hast du an Tag 0 installiert, geprüft gegen die SHA-256 aus tools.lock. diffoci holt lokale Podman-Images mit dem Präfix podman://, sonst zieht es aus der Registry. Was unterscheidet 0.1.0 von 0.2.0 aus Tag 5?

diffoci diff --semantic podman://localhost/notes-api:0.1.0 \
  podman://localhost/notes-api:0.2.0 2>/dev/null; echo "Exit: $?"

Erwartet:

TYPE    NAME                  INPUT-0                                     INPUT-1
Cfg     ctx:/config/config    ?                                           ?
File    notes-api             6930767b62b15b01c4154b1e925c485d6d72c80…    5c3fe986ae…
Exit: 1

Zwei Unterschiede: die Config und das Binary. Dass 0.2.0 an Tag 5 mit Buildah in einem einzigen Layer gebaut wurde, stört den semantischen Vergleich nicht – er vergleicht Dateien, nicht Layer-Grenzen. Welche Felder der Config? --verbose zeigt es:

diffoci diff --semantic --verbose podman://localhost/notes-api:0.1.0 \
  podman://localhost/notes-api:0.2.0 2>&1 | grep -A3 -B1 'image.version'

Erwartet:

            "org.opencontainers.image.title":       "notes-api",
-           "org.opencontainers.image.version":     "0.1.0",
+           "org.opencontainers.image.version":     "0.2.0",
        },
        StopSignal:  "SIGTERM",

Weiter oben in derselben Ausgabe steht auch das Label org.opencontainers.image.revision (tag03 aus Tag 3 gegen unknown).

Mit --report-dir=bericht legt diffoci zusätzlich ein report.json und die beiden abweichenden Dateien unter bericht/input-0/… und bericht/input-1/… ab – praktisch, um die Binaries danach mit eigenen Werkzeugen zu vergleichen.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Ist der Neubau gleich?

Bau 0.1.0 noch einmal ohne Cache und vergleiche – erst streng, dann semantisch:

podman build -q --no-cache --format docker --build-arg VERSION=0.1.0 \
  --build-arg REVISION=tag03 -t localhost/notes-api:0.1.0-neu "$NOTES/notes-api" \
  >/dev/null 2>&1
diffoci diff podman://localhost/notes-api:0.1.0 \
  podman://localhost/notes-api:0.1.0-neu > diff.txt 2>/dev/null; echo "Exit: $?"
awk 'NR > 1 {print $1}' diff.txt | sort | uniq -c
grep '^File' diff.txt | tr -s ' \t' ' '
diffoci diff --semantic podman://localhost/notes-api:0.1.0 \
  podman://localhost/notes-api:0.1.0-neu 2>/dev/null; echo "Exit: $?"
rm diff.txt

Erwartet:

Exit: 1
      1 Cfg
      4 Desc
      1 File
      1 Mani
File notes-api 2026-10-30 22:08:13 +0000 UTC 2026-10-30 22:12:56 +0000 UTC
Exit: 0

Der strenge Vergleich findet neue Digests für Manifest, Config und Layer – Ursache ist allein der Zeitstempel des Binarys. Der semantische Vergleich ist leer mit Exit 0: Inhaltlich ist der Neubau identisch, der Build ist bis auf Zeitstempel reproduzierbar.

Auch die Kopie in deiner Registry lässt sich vergleichen. diffoci nutzt dafür das Login aus ~/.docker/config.json (Tag 7, crane):

diffoci diff --semantic podman://localhost/notes-api:0.1.0 \
  "$REG/notes/notes-api:0.1.0" 2>/dev/null | awk '{print $1, $NF}'

Erwartet:

TYPE INPUT-1
Desc application/vnd.docker.image.rootfs.diff.tar.gzip
Desc application/vnd.docker.image.rootfs.diff.tar.gzip

Keine File- und keine Cfg-Zeile: Dateien und Config sind gleich, auch der HEALTHCHECK. Manifest und Config bleiben im Docker-Format (--format docker seit Tag 1, podman push behält es bei). Anders sind nur die Medientypen der beiden Layer: Lokal liegen sie unkomprimiert, in der Registry gzip-komprimiert (…diff.tar.gzip).

Fortschritt speichern? Kostenlos registrieren

Drill 8: container-diff – kurz und archiviert

Steckbrief container-diff
Aufgabe Images analysieren und vergleichen (Dateien, Größe, Pakete, Metadaten)
Besonderheit archiviert; letzte Version v0.19.0, keine versionierten/arm64-Binaries
Projekt github.com/GoogleContainerTools/container-diff (Apache-2.0)
Version im Buch v0.19.0, selbst gebaut

Der naheliegende Weg go install …@v0.19.0 scheitert:

mkdir -p bin
podman run --rm -v "$PWD/bin:/out:Z" -e GOBIN=/out -e CGO_ENABLED=0 \
  docker.io/library/golang:1.27-alpine \
  go install github.com/GoogleContainerTools/[email protected]

Erwartet:

go: downloading github.com/GoogleContainerTools/container-diff v0.19.0
go: github.com/GoogleContainerTools/[email protected] (in github.com/…):
    The go.mod file for the module providing named packages contains one or
    more replace directives. It must not contain directives that would cause
    it to be interpreted differently than if it were the main module.

go install pkg@version verbietet replace-Direktiven im go.mod. Der Ausweg: den Modulquelltext mit go mod download holen und dort bauen.

podman run --rm -v "$PWD/bin:/out:Z" -e CGO_ENABLED=0 \
  docker.io/library/golang:1.27-alpine sh -c '
  m=github.com/GoogleContainerTools/[email protected]
  cd "$(go mod download -json "$m" | sed -n "s/.*\"Dir\": \"\(.*\)\",/\1/p")"
  go build -o /out/container-diff .' 2>&1 | tail -1
./bin/container-diff version

Erwartet (dauert ein bis zwei Minuten):

go: downloading github.com/go-logr/stdr v1.2.2
v0.19.0 built from git (unknown)

container-diff kennt Docker-Daemon (daemon://), Registry (remote://) und Archive. Podman-Images gibst du als Archiv:

podman save -q -o api-010.tar localhost/notes-api:0.1.0
podman save -q -o api-020.tar localhost/notes-api:0.2.0
./bin/container-diff diff api-010.tar api-020.tar --type=file --type=size
echo "Exit: $?"
./bin/container-diff analyze "remote://$REG/notes/notes-api:0.1.0" --type=size \
  | cut -c1-60

Erwartet:

-----File-----

These entries have been added to api-020.tar: None

These entries have been deleted from api-020.tar: None

These entries have been changed between api-010.tar and api-020.tar:
FILE              SIZE1        SIZE2
/notes-api        11.2M        11.2M


-----Size-----

Image size difference between api-010.tar and api-020.tar: None
Exit: 0

-----Size-----

Analysis for registry.ct.lab:5000/notes/notes-api:0.1.0:
IMAGE                                             DIGEST
registry.ct.lab:5000/notes/notes-api:0.1.0        sha256:5e37fbeda667…

Es läuft noch – mit eigener CA und Login aus ~/.docker/config.json. Aber: Exit 0 trotz Unterschied, kein Podman-Zugriff, kein Analyzer für Alpine-Pakete (--type=apk meldet Argument apk is not a valid analyzer), keine Sicherheitsupdates mehr.

Empfehlung: Für Vergleiche diffoci, für Paketlisten syft (Tag 14). Aufräumen:

rm -rf bin api-0?0.tar dive.json ~/.container-diff
podman rmi localhost/notes-api:0.1.0-neu

Erwartet:

Untagged: localhost/notes-api:0.1.0-neu
Deleted: 8fcfd81436b7…
…

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Beide Varianten sind gebaut, .dive-ci liegt da:

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

Erwartet:

0.1.0
0.2.0
0.2.0-buildah
0.2.0-buildctl
0.2.0-ko
besser
schlecht
.dive-ci

schlecht fällt bei dive durch, besser besteht:

dive --ci --source podman localhost/notes-api:schlecht >/dev/null; echo "Exit: $?"
dive --ci --source podman localhost/notes-api:besser >/dev/null; echo "Exit: $?"

Erwartet:

Exit: 1
Exit: 0

diffoci sieht Unterschiede zwischen 0.1.0 und 0.2.0:

diffoci diff --semantic podman://localhost/notes-api:0.1.0 \
  podman://localhost/notes-api:0.2.0 >/dev/null 2>&1; echo "Exit: $?"

Erwartet:

Exit: 1

Challenge

Finde ohne Oberfläche heraus, welcher Layer von nginx:1.30.6-alpine die Datei /etc/nginx/nginx.conf anlegt und wie groß dieser Layer ist.

Hinweis: dive -j schreibt je Layer eine fileList; die Pfade stehen dort ohne führenden Schrägstrich.

Lösung

dive --source podman docker.io/library/nginx:1.30.6-alpine -j nginx.json >/dev/null
jq -r '.layer[] | select(any(.fileList[]; .path == "etc/nginx/nginx.conf"))
       | "\(.index) \(.sizeBytes) \(.command[0:40])"' nginx.json
rm nginx.json

Erwartet:

1 4299327 RUN /bin/sh -c set -x     && addgroup -g

Layer 1 (4.3 MB) – der große RUN aus dem nginx-Dockerfile, der Benutzer anlegt und nginx per apk installiert.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • dive --ci mit eigener .dive-ci gehört direkt hinter den Build; Grenzwerte im Repository versionieren, nicht in der CI-Konfiguration verstecken.
  • Der Effizienz-Score übersieht gelöschte Ordner – zusätzlich die Image-Größe begrenzen (z. B. podman image inspect --format '{{.Size}}' gegen einen Schwellwert).
  • diffoci --semantic ist der Nachweis für reproduzierbare Builds: Zwei Builds aus demselben Commit müssen leer vergleichen. Für bitgenaue Digests braucht es zusätzlich feste Zeitstempel (SOURCE_DATE_EPOCH).
  • Archivierte Werkzeuge wie container-diff nicht mehr in Pipelines einsetzen: keine Sicherheitsupdates, keine arm64-Binaries, selbst gebaut ohne Prüfsumme des Projekts.