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
--cizum 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 --versionErwartet (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-alpineErwartet (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-alpineErwartet:
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/spyErwartet:
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.tarErwartet:
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:schlechtErwartet (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 -3Erwartet:
{
"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:'
doneErwartet:
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 --versionErwartet:
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.txtErwartet:
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 versionErwartet (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-60Erwartet:
-----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-neuErwartet:
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-ciErwartet:
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.jsonErwartet:
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 --cimit eigener.dive-cigehö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
--semanticist 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.