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-onlykopiert 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.tarErwartet:
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. Rootlesscontainers-storage:geht deshalb nur überpodman 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/nullErwartet:
["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 .TagsErwartet:
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-88Erwartet:
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 p2Erwartet:
{"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}}'; echoErwartet:
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 .mediaTypeErwartet:
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 headist ein HEAD-Request: Digest ohne Download – zählt bei Docker Hub nicht als Pull.--formatnimmt Go-Templates über die Felder von regclient;raw-bodyliefert das Manifest unverändert für jq.image inspectundimage configlösen den Index automatisch zu deiner Plattform auf,--platformwä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.UserErwartet:
-----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 -1Erwartet:
{"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.jsonErwartet:
["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 .mediaTypeErwartet:
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}}'; echoErwartet: 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.jsonErwartet:
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 -lErwartet:
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}}'; echoErwartet (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 dirbzw.regctl image exportauf ein Medium, auf der anderen Seite zurück in die interne Registry – immer mit--preserve-digests, sonst brechen Signaturen und Pins. - Eine
policy.jsonmitrejectals Default undsigstoreSignedfü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.jsonauf Build-Runnern.