Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 8: Images bewegen – skopeo und regctl

Ziel: Du inspizierst Images ohne Pull, migrierst sie zwischen Registries und Formaten und kennst die beiden Werkzeuge, die das am gründlichsten können. · Dauer: ca. 90 min · Voraussetzung: Tag 7

Briefing

  • skopeo stammt aus dem Podman-Projekt und benutzt dieselbe Bibliothek (containers/image): gleiche Logins, gleiche Policy, gleiche Transports (docker://, oci:, dir:, docker-archive:, containers-storage:).
  • regctl (regclient) ist ein reines Registry-Werkzeug: Manifests, Blobs, Tags, Artefakte, Rate-Limits, Images verändern – alles direkt über die API.
  • Beide kopieren ohne Daemon. Der Unterschied steckt im Detail: Wer konvertiert, wer behält Digests, wer verliert unterwegs den HEALTHCHECK?
 docker://docker.io/… ──skopeo copy──► docker://registry.ct.lab:5000/mirror/…
        │                                   │            ▲
        │                  skopeo copy ─────┤            │ regctl image import
        ▼                                   ▼            │
  oci:dir:tag   dir:ordner   docker-archive:x.tar   regctl image export x.tar
  containers-storage:localhost/…  (Podman-Speicher)

Drill 1: skopeo – inspizieren ohne Pull

Steckbrief skopeo
Aufgabe Images inspizieren, kopieren, synchronisieren und löschen – ohne Daemon
Besonderheit Transports für Registry, Ordner, Archive und Podman-Speicher; Policy
Projekt github.com/containers/skopeo (Apache-2.0)
Version im Buch 1.21.0 (Ubuntu-Paket skopeo)
source ~/ct-lab/setup/env.sh
mkdir -p ~/ct-lab/tag08 && cd ~/ct-lab/tag08
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag07/notes/." .
sudo apt-get install -y skopeo >/dev/null
apt-cache policy skopeo | sed -n 2p; skopeo --version
N="docker://$REG/library/nginx:1.30.6-alpine"
skopeo inspect "$N" | jq '{Name, Digest, Architecture, Created, RepoTags}'

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

  Installed: 1.21.0~pre1-2build1
skopeo version 1.21.0-dev
{
  "Name": "registry.ct.lab:5000/library/nginx",
  "Digest": "sha256:0e52bd054126cdc040b1276c0af347aeb02a41b9cfe305d6094767ac30e97949",
  "Architecture": "arm64",
  "Created": "2026-10-22T00:16:56.267286194Z",
  "RepoTags": [
    "1.30.6-alpine"
  ]
}

inspect holt Index, passendes Manifest und Config – keine Layer. Digest ist der des Index, Architecture die deiner Maschine (--override-arch amd64 fragt eine andere an). Die Rohdaten gibt es auch:

skopeo inspect --raw "$N" | jq -r '.mediaType, (.manifests | length)'
skopeo inspect --config "$N" | jq -c '{architecture, variant, cmd: .config.Cmd}'
skopeo inspect --format '{{.Digest}} {{.Architecture}}' \
  "docker://$REG/notes/notes-api:0.1.0"
skopeo inspect --no-tags "docker://$REG/notes/notes-api:0.1.0" \
  | jq -r '.Labels["org.opencontainers.image.version"]'

Erwartet:

application/vnd.oci.image.index.v1+json
16
{"architecture":"arm64","variant":"v8","cmd":["nginx","-g","daemon off;"]}
sha256:9a22b91aff08798c7a7531ca483b799d2cde2492dbdf911f291c161d4ffc7f23 arm64
0.1.0

--raw zeigt das Manifest unverändert, --config die Config, --format nimmt ein Go-Template. --no-tags spart das Auflisten aller Tags – bei Repositories mit tausend Tags merklich schneller.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Registry-Migration mit skopeo copy

Der Klassiker: ein öffentliches Image in die eigene Registry holen.

skopeo copy docker://docker.io/library/nginx:1.30.6-alpine \
  "docker://$REG/mirror/nginx:1.30.6-alpine"
skopeo inspect --raw "docker://$REG/mirror/nginx:1.30.6-alpine" | jq -r .mediaType
skopeo inspect --format '{{.Digest}}' "docker://$REG/mirror/nginx:1.30.6-alpine"

Erwartet:

Getting image source signatures
Copying blob sha256:872998b8576e5aa2dd875c0a156f30bb6bc2573fddce2652fce6884a9893952d
Copying blob sha256:d3531b7a4f217bdc3426c57bcff84c170f086f456a39689d4a615c6d026c4be0
…
Copying config sha256:71f44768e348d88b5e3ea14a77e0e082792bc46d283de47ef08249bd7ae2e223
Writing manifest to image destination
application/vnd.oci.image.manifest.v1+json
sha256:4f7cab9e1cd018f80e67f31e02dc0c6d18560b19504461c4f3dd37e5c63a74c5

Ohne weitere Angabe kopiert skopeo nur deine Plattform: Im Ziel liegt kein Index, sondern das arm64-Manifest (4f7c… kennst du von Tag 7). Für einen echten Spiegel brauchst du --all – diesmal aus deiner Registry, Docker Hub bleibt verschont:

skopeo copy -q --all --preserve-digests "$N" \
  "docker://$REG/mirror/nginx:1.30.6-alpine-all"
skopeo inspect --format '{{.Digest}}' "docker://$REG/mirror/nginx:1.30.6-alpine-all"

Erwartet:

sha256:0e52bd054126cdc040b1276c0af347aeb02a41b9cfe305d6094767ac30e97949

Warum --preserve-digests? skopeo merkt sich in ~/.local/share/containers/cache/blob-info-cache-v1.sqlite, welche komprimierten Blobs denselben Inhalt haben, und darf beim Kopieren einen bekannten, anders komprimierten Blob einsetzen. In einem Testlauf ohne den Schalter ersetzte skopeo so den Alpine-Basis-Layer von amd64 durch den aus notes-web – der Index bekam einen neuen Digest (05ff… statt 0e52…). Mit --preserve-digests passiert das nie; Signaturen und Pins bleiben gültig.

Tipp: --multi-arch index-only kopiert nur den Index ohne die Images – nützlich fast nie, gefährlich oft. Für Spiegel: --all --preserve-digests.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Transports – Ordner, Archive, Podman-Speicher

skopeo copy -q "docker://$REG/notes/notes-api:0.1.0" dir:api-dir
skopeo copy -q "docker://$REG/notes/notes-api:0.1.0" oci:api-oci:0.1.0
skopeo copy -q "docker://$REG/notes/notes-api:0.1.0" \
  docker-archive:api.tar:localhost/notes-api:archiv
ls api-dir api-oci
jq -c '.manifests[] | {mediaType,
  ref: .annotations["org.opencontainers.image.ref.name"]}' api-oci/index.json
skopeo inspect --format '{{.Digest}}' oci:api-oci:0.1.0
du -sh api-dir api-oci api.tar

Erwartet:

api-dir:
0765d1019f4676ebd06a9055cfa442cd6d000689f5e2ba31be8fc998b89faf7b
2f8852384d1b2d65d511677cf4bbe13190ec6619d81d7935942c229f5c19cacb
34a23a5bdaf142798f754d18fa12765aaaf79f520ee3968f1714a79cfcc2aaf0
manifest.json
version

api-oci:
blobs
index.json
oci-layout
{"mediaType":"application/vnd.oci.image.manifest.v1+json","ref":"0.1.0"}
sha256:1389c10cc4811b7ad4f77c740ffae5be4f6d43239f596aebceffc6c409f16df0
4.5M    api-dir
4.5M    api-oci
12M api.tar
Transport Inhalt typisch für
dir: Blobs und Manifest als einzelne Dateien Debuggen, Air-Gap
oci:pfad:tag OCI-Layout (wie crane pull --format oci) Werkzeugketten
docker-archive: docker save-Format, Layer unkomprimiert podman load, alte Tools
containers-storage: Podman-/Buildah-Speicher lokal bauen, dann kopieren

Achte auf den Digest: oci: hat das Docker-Manifest in ein OCI-Manifest umgeschrieben – neuer Digest 1389…. Jetzt der lokale Podman-Speicher:

skopeo copy -q dir:api-dir containers-storage:localhost/notes-api:von-dir
podman unshare skopeo copy -q dir:api-dir \
  containers-storage:localhost/notes-api:von-dir; echo "Exit: $?"
podman images --format '{{.Repository}}:{{.Tag}} {{.ID}}' localhost/notes-api \
  | grep -E ':(0\.1\.0|von-dir) '

Erwartet:

Error during unshare(...): Operation not permitted
Exit: 0
localhost/notes-api:von-dir 0765d1019f46
localhost/notes-api:0.1.0 0765d1019f46

Achtung: Ubuntu 26.04 erlaubt User Namespaces nur Programmen mit AppArmor-Profil (kernel.apparmor_restrict_unprivileged_userns = 1). Podman und Buildah haben eins, skopeo nicht. Rootless containers-storage: geht deshalb nur über podman unshare skopeo … – dann läuft skopeo im Namespace von Podman.

Gleiche Image-ID 0765… wie 0.1.0: Es ist dasselbe Image. Und was passiert beim Konvertieren nach OCI mit dem HEALTHCHECK aus dem Docker-Format?

skopeo copy -q --format oci "docker://$REG/notes/notes-api:0.1.0" \
  "docker://$REG/lab/notes-api:0.1.0-oci"
skopeo inspect --config --raw "docker://$REG/notes/notes-api:0.1.0" \
  | jq -c .config.Healthcheck.Test
skopeo inspect --config --raw "docker://$REG/lab/notes-api:0.1.0-oci" \
  | jq -c .config.Healthcheck.Test
podman rmi localhost/notes-api:von-dir >/dev/null

Erwartet:

["CMD","/notes-api","healthcheck"]
null

skopeo baut die Config beim Konvertieren neu – und die OCI-Spezifikation kennt kein Healthcheck. Ohne --raw zeigt inspect --config übrigens immer die nach OCI übersetzte Config, dort fehlt der HEALTHCHECK also auch beim Original. --preserve-digests zusammen mit --format oci konvertiert gar nicht: Ein neuer Digest wäre ja das Gegenteil.

Fortschritt speichern? Kostenlos registrieren

Drill 4: sync, list-tags, delete, login und Policy

skopeo sync kopiert ganze Repositories – hier als Backup in einen Ordner und in ein anderes Repository:

skopeo sync --src docker --dest dir --scoped "$REG/notes/notes-api" backup/ \
  2>&1 | tail -1
find backup -maxdepth 4 -type d | tail -1
skopeo sync --src docker --dest docker "$REG/notes/notes-web" "$REG/backup" \
  2>&1 | tail -1
skopeo list-tags "docker://$REG/backup/notes-web" | jq -c .Tags

Erwartet:

time="2026-10-30T20:51:27Z" level=info msg="Synced 1 images from 1 sources"
backup/registry.ct.lab:5000/notes/notes-api:0.1.0
time="2026-10-30T20:51:28Z" level=info msg="Synced 1 images from 1 sources"
["0.1.0"]

--scoped legt den vollen Quellpfad im Ziel an. Für mehrere Quellen mit Filtern nimmt sync eine YAML-Datei (--src yaml); --dry-run zeigt nur, was passieren würde:

cat > sync.yaml <<'EOF'
# sync.yaml – Stand Ende Tag 8: Quellen für skopeo sync --src yaml
registry.ct.lab:5000:
  images-by-tag-regex:
    notes/notes-api: ^0\.1\.
    notes/notes-worker: ^0\.
EOF
skopeo sync --src yaml --dest docker --dry-run sync.yaml "$REG/backup" 2>&1 \
  | grep -o 'Would have.*' | cut -c1-88

Erwartet:

Would have copied image ref 1/1" from="docker://registry.ct.lab:5000/notes/notes-work
Would have copied image ref 1/1" from="docker://registry.ct.lab:5000/notes/notes-api:
Would have synced 2 images from 2 sources

Löschen und Logins:

skopeo delete "docker://$REG/backup/notes-web:0.1.0"
skopeo list-tags "docker://$REG/backup/notes-web" | jq -c .Tags
skopeo logout "$REG" && cat "$XDG_RUNTIME_DIR/containers/auth.json"; echo
skopeo list-tags "docker://$REG/notes/notes-api" | jq -c .Tags
echo "$REG_PASS" | skopeo login -u "$REG_USER" --password-stdin "$REG"

Erwartet:

[]
Removed login credentials for registry.ct.lab:5000
{
    "auths": {}
}
["0.1.0"]
Login Succeeded!

Nach dem Logout klappt list-tags trotzdem: skopeo greift auf ~/.docker/config.json zurück (crane-Login von Tag 7). skopeo login schreibt dieselbe Datei wie podman login.

Zum Schluss die Policy: /etc/containers/policy.json entscheidet, welche Images skopeo und Podman überhaupt annehmen. Ubuntu liefert „alles erlaubt”:

jq -c . /etc/containers/policy.json
cat > policy-lab.json <<'EOF'
{
  "default": [{"type": "reject"}],
  "transports": {
    "docker": {"registry.ct.lab:5000": [{"type": "insecureAcceptAnything"}]},
    "dir": {"": [{"type": "insecureAcceptAnything"}]}
  }
}
EOF
skopeo --policy policy-lab.json copy -q "docker://$REG/notes/notes-api:0.1.0" dir:p1
echo "Exit: $?"
skopeo --policy policy-lab.json copy -q oci:api-oci:0.1.0 dir:p2; echo "Exit: $?"
rm -rf p1 p2

Erwartet:

{"default":[{"type":"insecureAcceptAnything"}]}
Exit: 0
time="2026-10-30T20:51:52Z" level=fatal msg="Source image rejected: Running image oci:
api-oci:0.1.0 is rejected by policy."
Exit: 1

Nur deine Registry und dir: sind erlaubt, alles andere wird abgewiesen. Statt insecureAcceptAnything kann dort sigstoreSigned mit einem Schlüssel stehen – dann nimmt Podman nur signierte Images an (Tag 14). Systemweit gilt die Datei in /etc/containers/, pro Benutzer in ~/.config/containers/policy.json.

Fortschritt speichern? Kostenlos registrieren

Drill 5: regctl – installieren, anmelden, Tags

Steckbrief regctl
Aufgabe Registry-Werkzeug für Manifests, Blobs, Tags, Artefakte und Images
Besonderheit Rate-Limit-Anzeige, Mirrors, Go-Templates, Images verändern (image mod)
Projekt github.com/regclient/regclient, regclient.org (Apache-2.0)
Version im Buch v0.11.7

regctl ist ein einzelnes Binary:

arch=$(dpkg --print-architecture)
read -r _ _ url sum < <(grep "^regctl $arch " "$LAB/setup/tools.lock")
curl -fsSLo /tmp/regctl "$url"
echo "$sum  /tmp/regctl" | sha256sum -c -
sudo install -m 0755 /tmp/regctl /usr/local/bin/regctl && rm /tmp/regctl
regctl version --format '{{.VCSTag}}'; echo
regctl tag ls "$REG/notes/notes-api"
regctl registry whoami "$REG"

Erwartet:

/tmp/regctl: OK
v0.11.7
0.1.0
no login found for registry.ct.lab:5000

Die Tags liest regctl schon – mit dem Login aus ~/.docker/config.json. whoami kennt aber nur regctls eigene Konfiguration. Ein eigener Login:

echo "$REG_PASS" | regctl registry login "$REG" -u "$REG_USER" --pass-stdin
ls -l ~/.regctl/config.json
jq '.hosts | map_values(keys)' ~/.regctl/config.json
regctl registry whoami "$REG"

Erwartet:

-rw------- 1 ubuntu ubuntu 113 Oct 30 20:52 /home/ubuntu/.regctl/config.json
{
  "registry.ct.lab:5000": [
    "pass",
    "user"
  ]
}
lab

Jetzt das Beispiel aus dem Briefing: alle Tags von nginx – mit Filter.

regctl tag ls docker.io/library/nginx | wc -l
regctl tag ls --include '1\.30\.6-alpine.*' docker.io/library/nginx
regctl image ratelimit docker.io/library/nginx:1.30.6-alpine
regctl image ratelimit "$REG/notes/notes-api:0.1.0" --format '{{.Set}}'; echo

Erwartet:

1381
1.30.6-alpine
1.30.6-alpine-otel
1.30.6-alpine-perl
1.30.6-alpine-slim
1.30.6-alpine3.24
1.30.6-alpine3.24-otel
1.30.6-alpine3.24-perl
1.30.6-alpine3.24-slim
{
  "Remain": 53,
  "Limit": 100,
  "Reset": 0,
  "Set": true,
  "Policies": [
    "100;w=3600"
  ]
}
false

--include und --exclude sind reguläre Ausdrücke über den ganzen Tag. ratelimit schickt einen HEAD-Request und liest die Header ratelimit-remaining und ratelimit-limit: noch 53 von 100 Pulls in diesem Stundenfenster (w=3600). HEAD zählt selbst nicht. Deine Registry hat kein Limit (Set: false).

Fortschritt speichern? Kostenlos registrieren

Drill 6: Manifests und Templates

N="$REG/library/nginx:1.30.6-alpine"
regctl manifest head "$N"
regctl manifest get "$N" | sed -n 2p | tr -s ' '
regctl manifest get "$N" --format '{{range .Manifests}}{{if ne .Platform.OS "unknown"}}
  {{- .Platform.Architecture}}{{with .Platform.Variant}}/{{.}}{{end}} {{end}}{{end}}'
echo
regctl image digest --platform linux/arm64 "$N"
regctl image inspect "$N" --format '{{.Architecture}}/{{.Variant}} {{.Created}}'; echo
regctl image config "$N" --format '{{len .RootFS.DiffIDs}} Layer'; echo
regctl manifest get "$REG/notes/notes-api:0.1.0" --format raw-body | jq -r .mediaType

Erwartet:

sha256:0e52bd054126cdc040b1276c0af347aeb02a41b9cfe305d6094767ac30e97949
MediaType: application/vnd.oci.image.index.v1+json
amd64 arm/v6 arm/v7 arm64/v8 386 ppc64le riscv64 s390x
sha256:4f7cab9e1cd018f80e67f31e02dc0c6d18560b19504461c4f3dd37e5c63a74c5
arm64/v8 2026-10-22 00:16:56.267286194 +0000 UTC
8 Layer
application/vnd.docker.distribution.manifest.v2+json
  • manifest head ist ein HEAD-Request: Digest ohne Download – zählt bei Docker Hub nicht als Pull.
  • --format nimmt Go-Templates über die Felder von regclient; raw-body liefert das Manifest unverändert für jq.
  • image inspect und image config lösen den Index automatisch zu deiner Plattform auf, --platform wählt eine andere.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Kopieren, verändern, exportieren

regctl image copy "$REG/notes/notes-api:0.1.0" "$REG/lab/notes-api:rc"
regctl image mod "$REG/lab/notes-api:rc" --to-oci --label lab.tag=08 \
  --create 0.1.0-oci08
regctl manifest get "$REG/lab/notes-api:0.1.0-oci08" --format raw-body \
  | jq -r .mediaType
regctl image inspect "$REG/lab/notes-api:0.1.0-oci08" \
  --format '{{index .Config.Labels "lab.tag"}} {{json .Config.Healthcheck.Test}}'

Erwartet:

registry.ct.lab:5000/lab/notes-api:rc
registry.ct.lab:5000/lab/notes-api:0.1.0-oci08
application/vnd.oci.image.manifest.v1+json
08 ["CMD","/notes-api","healthcheck"]

image mod schreibt ein neues Image unter dem Tag aus --create (oder ersetzt mit --replace den alten). Anders als skopeo ändert --to-oci nur die Medientypen und lässt die Config in Ruhe – der HEALTHCHECK bleibt. Weitere Schalter von image mod: --env, --annotation, --layer-strip-file, --time und --reproducible.

Dateien, Archive, Blobs:

regctl image get-file "$REG/notes/notes-api:0.1.0" /etc/ssl/certs/ca-certificates.crt \
  | head -1
regctl image export "$REG/notes/notes-api:0.1.0" api-regctl.tar
tar -tf api-regctl.tar | head -4
regctl image import "$REG/lab/notes-api:import" api-regctl.tar
regctl image digest "$REG/lab/notes-api:import"
C=$(regctl manifest get "$REG/notes/notes-api:0.1.0" --format '{{.Config.Digest}}')
regctl blob head "$REG/notes/notes-api" "$C" \
  | grep -E '^(Content-Length|Docker-Content)'
regctl blob get "$REG/notes/notes-api" "$C" | jq -r .config.User

Erwartet:

-----BEGIN CERTIFICATE-----
oci-layout
index.json
manifest.json
blobs/
sha256:9a22b91aff08798c7a7531ca483b799d2cde2492dbdf911f291c161d4ffc7f23
Content-Length: 3848
Docker-Content-Digest: sha256:0765d1019f4676ebd06a9055cfa442cd6d000689f5e2ba31be8fc998…
65532:65532

get-file holt eine einzelne Datei aus den Layern, ohne das Image auszupacken. Das Exportformat ist zugleich OCI-Layout und docker save-Archiv (manifest.json) – Import in Podman oder in eine Registry ohne Digest-Änderung. Tags und Repositories:

regctl tag ls "$REG/lab/notes-api"
regctl tag rm "$REG/lab/notes-api:rc"
regctl tag ls "$REG/lab/notes-api"
regctl repo ls "$REG"

Erwartet:

0.1.0-oci
0.1.0-oci08
import
rc
0.1.0-oci
0.1.0-oci08
import
backup/notes-web
lab/notes-api
library/nginx
mirror/nginx
notes/notes-api
notes/notes-web
notes/notes-worker

tag rm löscht nur den Tag – anders als crane delete per Digest bleiben andere Tags auf demselben Manifest (import) stehen. backup/notes-web bleibt in der Liste, obwohl es keinen Tag mehr hat: Die Registry vergisst leere Repositories nicht.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Registry-Optionen und Mirror

regctl merkt sich Optionen pro Registry. Ein Mirror leitet Anfragen für Docker Hub zuerst an deine Registry, dazu eine Bremse von zwei Anfragen pro Sekunde:

regctl registry set docker.io --mirror "$REG" --req-per-sec 2
regctl registry config docker.io | jq -c '{hostname, mirrors, reqPerSec}'
regctl -v trace image digest docker.io/library/nginx:1.30.6-alpine 2>&1 \
  | grep -o 'req-method=HEAD req-url="https://[^/]*' | head -1

Erwartet:

{"hostname":"registry-1.docker.io","mirrors":["registry.ct.lab:5000"],"reqPerSec":2}
req-method=HEAD req-url="https://registry.ct.lab:5000

Der erste Request geht an deine Registry: docker.io/library/nginx wird dort als library/nginx gesucht – genau der Pfad, unter den du nginx an Tag 7 kopiert hast. Fehlt das Image im Mirror, fragt regctl Docker Hub. Wieder entfernen: --mirror "" hinterlässt einen leeren Eintrag, sauberer ist jq:

jq 'del(.hosts["docker.io"])' ~/.regctl/config.json > /tmp/rc.json
install -m 0600 /tmp/rc.json ~/.regctl/config.json && rm /tmp/rc.json
jq -c '.hosts | keys' ~/.regctl/config.json

Erwartet:

["registry.ct.lab:5000"]

Spielwiese aufräumen:

for t in 0.1.0-oci 0.1.0-oci08 import; do regctl tag rm "$REG/lab/notes-api:$t"; done
regctl tag rm "$REG/mirror/nginx:1.30.6-alpine-all"
rm -rf api-dir api-oci api.tar api-regctl.tar backup
regctl tag ls "$REG/mirror/nginx"

Erwartet:

1.30.6-alpine

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

mirror/nginx ist ein Einzel-Manifest:

cd ~/ct-lab/tag08
source ~/ct-lab/setup/env.sh
skopeo inspect --raw "docker://$REG/mirror/nginx:1.30.6-alpine" | jq -r .mediaType

Erwartet:

application/vnd.oci.image.manifest.v1+json

Es enthält nur die Architektur deines Rechners:

regctl image inspect "$REG/mirror/nginx:1.30.6-alpine" \
  --format '{{.Architecture}}'; echo

Erwartet: arm64 auf einem Mac mit Apple-Chip, auf einem Intel-Rechner wie hier amd64.

amd64

regctl ist angemeldet, ein Mirror für docker.io ist nicht mehr eingetragen:

jq -r '.hosts | keys[]' ~/.regctl/config.json

Erwartet:

registry.ct.lab:5000

Die Policy weist fremde Quellen ab, lab/notes-api ist leer:

jq -r '.default[0].type' policy-lab.json
regctl tag ls "$REG/lab/notes-api" | wc -l

Erwartet:

reject
0

Challenge

Sind postgres:18.6-alpine und postgres:18-alpine auf Docker Hub gerade dasselbe Image? Beweise zusätzlich, dass deine Prüfung keinen einzigen Pull verbraucht hat.

Hinweis: Digests per HEAD-Request zählen nicht – vergleiche das Rate-Limit davor und danach.

Lösung

regctl image ratelimit docker.io/library/postgres:18-alpine --format '{{.Remain}}'; echo
for t in 18.6-alpine 18-alpine 18.6-alpine3.24; do
  echo "$t $(regctl image digest "docker.io/library/postgres:$t")"
done
regctl image ratelimit docker.io/library/postgres:18-alpine --format '{{.Remain}}'; echo

Erwartet (die Zahl hängt von deinen Pulls der letzten Stunde ab):

100
18.6-alpine sha256:10a5c69a83035ab5239f5620d708520e8b28f5aa1f2b20143e6024532edadfb5
18-alpine sha256:10a5c69a83035ab5239f5620d708520e8b28f5aa1f2b20143e6024532edadfb5
18.6-alpine3.24 sha256:10a5c69a83035ab5239f5620d708520e8b28f5aa1f2b20143e6024532edadfb5
100

Drei Tags, ein Digest – und das Limit steht unverändert. Im Compose-File gehört der Digest hinter den Tag (postgres:18.6-alpine@sha256:10a5…), dann ist er verbindlich.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Air-Gap-Transfer: skopeo sync --dest dir bzw. regctl image export auf ein Medium, auf der anderen Seite zurück in die interne Registry – immer mit --preserve-digests, sonst brechen Signaturen und Pins.
  • Eine policy.json mit reject als Default und sigstoreSigned für die eigene Registry macht Podman-Hosts zu Abnehmern nur geprüfter Images.
  • Docker-Hub-Limits treffen ganze NAT-Netze: zentraler Pull-Through-Cache oder Spiegel (regsync, Tag 9) statt hunderter Clients mit anonymen Pulls.
  • Format-Konvertierungen (skopeo --format oci) ändern Digests und können Felder wie HEALTHCHECK verlieren. In Pipelines bewusst einmal konvertieren, dann nur noch digest-erhaltend kopieren.
  • regctl in CI: Logins per --host reg=…,user=…,pass=… oder Umgebung, nie die persönliche ~/.regctl/config.json auf Build-Runnern.