Tag 7: Eigene Registry und crane
Ziel: Du baust dir eine eigene Registry mit TLS und Login, sprichst ihre API mit curl und bearbeitest Images mit crane direkt in der Registry – ohne Pull, ohne Build. · Dauer: ca. 90 min · Voraussetzung: Tag 6
Briefing
- Eine Registry speichert Blobs (Layer, Config) und Manifests in Repositories. Ein Tag ist ein Name, der auf ein Manifest zeigt; der Digest ist die SHA-256 des Inhalts und ändert sich bei jedem Byte.
- Ein Index (Multi-Arch) listet ein Manifest pro Plattform. Jedes Manifest nennt eine Config und die Layer.
- Die Registry heute:
registry:3.1.2(CNCF Distribution), rootless mit Podman, TLS über eine eigene CA, Login per htpasswd. - crane spricht die Distribution-API direkt: kein Daemon, kein lokaler Speicher.
nginx:1.30.6-alpine ──► Index sha256:0e52… ─┬─► Manifest linux/arm64 sha256:4f7c…
└─► Manifest linux/amd64 … │
Config (= Image-ID) ◄┤
Layer 1 … 8 (Blobs) ◄┘
GET /v2/<repo>/manifests/<tag|digest> GET /v2/<repo>/blobs/<digest>
Drill 1: Eigene CA und Server-Zertifikat
Tagesstart, dann eine CA nur für dein Labor und ein Zertifikat für
registry.ct.lab.
source ~/ct-lab/setup/env.sh
mkdir -p ~/ct-lab/tag07 && cd ~/ct-lab/tag07
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag06/notes/." .
echo "$REG"
mkdir -p "$LAB/registry/certs" "$LAB/registry/auth" && cd "$LAB/registry/certs"
openssl req -x509 -newkey rsa:3072 -nodes -days 365 -subj "/CN=ct-lab CA ($USER)" \
-keyout ca.key -out ca.crt 2>/dev/null
openssl req -newkey rsa:3072 -nodes -subj "/CN=$REG_HOST" \
-keyout registry.key -out registry.csr 2>/dev/null
printf 'subjectAltName=DNS:%s\nextendedKeyUsage=serverAuth\n' "$REG_HOST" > ext.cnf
openssl x509 -req -in registry.csr -CA ca.crt -CAkey ca.key -CAcreateserial \
-days 90 -extfile ext.cnf -out registry.crt
openssl x509 -in registry.crt -noout -subject -issuer -ext subjectAltName -enddate
openssl verify -CAfile ca.crt registry.crtErwartet (gekürzt, IDs und Zeiten weichen bei dir ab):
registry.ct.lab:5000
Certificate request self-signature ok
subject=CN=registry.ct.lab
subject=CN=registry.ct.lab
issuer=CN=ct-lab CA (ubuntu)
X509v3 Subject Alternative Name:
DNS:registry.ct.lab
notAfter=Jan 28 20:44:53 2027 GMT
registry.crt: OK
-x509macht aus dem Request gleich ein selbst signiertes CA-Zertifikat.- Clients prüfen den Namen im SAN (Subject
Alternative Name), nicht im CN. Ohne
subjectAltNamelehnt Go – also crane, regctl, oras, containerd – das Zertifikat ab.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Die Registry starten
Name, Passwortdatei, dann der Container. Das Startskript liegt im Arbeitsordner, weil du es an Tag 10 mit einem Netz-Argument noch einmal brauchst:
grep -q " $REG_HOST\$" /etc/hosts || echo "127.0.0.1 $REG_HOST" | sudo tee -a /etc/hosts
getent hosts "$REG_HOST"
htpasswd -Bbn "$REG_USER" "$REG_PASS" > "$LAB/registry/auth/htpasswd"
head -1 "$LAB/registry/auth/htpasswd" | cut -c1-20
cd ~/ct-lab/tag07
cat > run-registry.sh <<'EOF'
#!/usr/bin/env bash
# run-registry.sh – Stand Ende Tag 7
# Startet die Registry rootless (neu); die Daten bleiben im Volume registry-data.
# Aufruf: ./run-registry.sh [netz] (Tag 10: ./run-registry.sh kind)
set -euo pipefail
# shellcheck source=/dev/null
source "$HOME/ct-lab/setup/env.sh"
dir="$LAB/registry"
net=()
if [ -n "${1:-}" ]; then net=(--network "$1" --network-alias "$REG_HOST"); fi
podman rm -f registry >/dev/null 2>&1 || true
podman run -d --name registry "${net[@]}" -p "127.0.0.1:$REG_PORT:5000" \
-v "$dir/certs:/certs:ro" -v "$dir/auth:/auth:ro" \
-v registry-data:/var/lib/registry \
-e REGISTRY_HTTP_TLS_CERTIFICATE=/certs/registry.crt \
-e REGISTRY_HTTP_TLS_KEY=/certs/registry.key \
-e REGISTRY_AUTH=htpasswd -e REGISTRY_AUTH_HTPASSWD_REALM=ct-lab \
-e REGISTRY_AUTH_HTPASSWD_PATH=/auth/htpasswd \
docker.io/library/registry:3.1.2
EOF
chmod +x run-registry.sh && ./run-registry.sh | tail -1
podman ps --format '{{.Names}} {{.Image}} {{.Ports}}'
curl -sS "https://$REG/v2/"; echo "Exit: $?"Erwartet (gekürzt):
127.0.0.1 registry.ct.lab
lab:$2y$05$N1ejsQJhg
6cb587078fba37f3ad4f3984e4fcdef6928e0162e33268e791b10d78e5aab649
registry docker.io/library/registry:3.1.2 127.0.0.1:5000->5000/tcp
curl: (60) SSL certificate OpenSSL verify result: unable to get local issuer
certificate (20)
…
Exit: 60
htpasswd -B speichert bcrypt, nie das Klartextpasswort.
Die Registry läuft, aber curl kennt deine CA nicht. Also kommt sie in
den Zertifikatsspeicher des Systems – den lesen curl, Podman, Skopeo und
alle Go-Werkzeuge:
sudo install -m 0644 "$LAB/registry/certs/ca.crt" \
"/usr/local/share/ca-certificates/ct-lab-$USER.crt"
sudo update-ca-certificates
curl -sS -i "https://$REG/v2/" | grep -iE '^(HTTP|www-auth|docker-dist)'
curl -sS -u "$REG_USER:$REG_PASS" "https://$REG/v2/"; echo
curl -sS -u "$REG_USER:$REG_PASS" "https://$REG/v2/_catalog"; echoErwartet:
Updating certificates in /etc/ssl/certs...
1 added, 0 removed; done.
Running hooks in /etc/ca-certificates/update.d...
done.
HTTP/2 401
docker-distribution-api-version: registry/2.0
www-authenticate: Basic realm="ct-lab"
{}
{"repositories":[]}
/v2/ ist der Einstieg der Distribution-API: 401 mit
www-authenticate sagt dem Client, wie er sich anmelden soll
(hier Basic, Docker Hub nutzt Bearer-Token). {} heißt:
angemeldet, API-Version 2. _catalog listet die Repositories
– noch keine.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Logins – wer speichert was wo?
echo "$REG_PASS" | podman login -u "$REG_USER" --password-stdin "$REG"
ls -l "$XDG_RUNTIME_DIR/containers/auth.json"
jq . "$XDG_RUNTIME_DIR/containers/auth.json"
echo bGFiOmxhYi1yZWdpc3RyeS1wdy0xMjM= | base64 -d; echo
ls ~/.docker 2>&1Erwartet:
Login Succeeded!
-rw------- 1 ubuntu ubuntu 96 Oct 30 20:45 /run/user/1000/containers/auth.json
{
"auths": {
"registry.ct.lab:5000": {
"auth": "bGFiOmxhYi1yZWdpc3RyeS1wdy0xMjM="
}
}
}
lab:lab-registry-pw-123
ls: cannot access '/home/ubuntu/.docker': No such file or directory
Base64 ist keine Verschlüsselung – die Datei ist so viel wert wie das
Passwort. $XDG_RUNTIME_DIR liegt im RAM
(/run/user/1000): Nach einem Neustart ist der Podman-Login
weg. Und die anderen Werkzeuge?
crane catalog "$REG"; echo "crane: $?"
regctl tag ls "$REG/notes/notes-api" 2>&1 | cut -c1-70
oras repo ls "$REG" 2>&1 | head -1Erwartet:
crane: 0
failed to list tags for registry.ct.lab:5000/notes/notes-api:latest: no
Error: basic credential not found
crane liest neben ~/.docker/config.json auch die
Podman-Datei (leerer Katalog, aber Exit 0). regctl und oras kennen nur
die Docker-Datei. Ein Login mit crane legt sie an:
echo "$REG_PASS" | crane auth login "$REG" -u "$REG_USER" --password-stdin
jq -c . ~/.docker/config.jsonErwartet:
WARNING! Your credentials are stored unencrypted in '/home/ubuntu/.docker/config.json'.
Configure a credential helper to remove this warning. See
https://docs.docker.com/go/credential-store/
2026/10/30 20:47:25 logged in via /home/ubuntu/.docker/config.json
{"auths":{"registry.ct.lab:5000":{"auth":"bGFiOmxhYi1yZWdpc3RyeS1wdy0xMjM="}}}
| Werkzeug | schreibt Login nach | liest außerdem |
|---|---|---|
| podman, buildah, skopeo | $XDG_RUNTIME_DIR/containers/auth.json |
~/.docker/config.json |
| crane, krane | ~/.docker/config.json |
Podman-auth.json |
| regctl (Tag 8) | ~/.regctl/config.json |
~/.docker/config.json |
| oras, cosign (Tag 9/14) | ~/.docker/config.json |
– |
Ab jetzt findet jedes Werkzeug im Buch dein Login. Wer die Datei teilt oder ins Backup legt, teilt das Passwort.
Fortschritt speichern? Kostenlos registrieren
Drill 4: notes pushen und die API von Hand
for s in api web worker; do
podman push -q "localhost/notes-$s:0.1.0" "$REG/notes/notes-$s:0.1.0"
done
A=(-sS -u "$REG_USER:$REG_PASS")
curl "${A[@]}" "https://$REG/v2/_catalog"; echo
curl "${A[@]}" "https://$REG/v2/notes/notes-api/tags/list"; echo
M="https://$REG/v2/notes/notes-api/manifests/0.1.0"
H='Accept: application/vnd.docker.distribution.manifest.v2+json'
curl "${A[@]}" -I -H "$H" "$M" | grep -iE 'content-type|docker-content-digest'
curl "${A[@]}" -H "$H" "$M" | sha256sumErwartet:
{"repositories":["notes/notes-api","notes/notes-web","notes/notes-worker"]}
{"name":"notes/notes-api","tags":["0.1.0"]}
content-type: application/vnd.docker.distribution.manifest.v2+json
docker-content-digest: sha256:9a22b91aff08798c7a7531ca483b799d2cde2492dbdf911f291c161d…
9a22b91aff08798c7a7531ca483b799d2cde2492dbdf911f291c161d4ffc7f23 -
Der Digest ist wörtlich die SHA-256 des Manifests – jeder kann ihn
nachrechnen. podman push behält das Format des Builds
(--format docker seit Tag 1), daher der Docker-Medientyp.
Das Manifest nennt die Config, und die liegt als Blob daneben:
C=$(curl "${A[@]}" -H "$H" "$M" | jq -r .config.digest); echo "$C"
curl "${A[@]}" -L "https://$REG/v2/notes/notes-api/blobs/$C" | sha256sum
curl "${A[@]}" -L "https://$REG/v2/notes/notes-api/blobs/$C" | jq -c '{architecture,
User: .config.User, v: .config.Labels["org.opencontainers.image.version"]}'
podman image inspect localhost/notes-api:0.1.0 --format '{{.Id}}'Erwartet:
sha256:0765d1019f4676ebd06a9055cfa442cd6d000689f5e2ba31be8fc998b89faf7b
0765d1019f4676ebd06a9055cfa442cd6d000689f5e2ba31be8fc998b89faf7b -
{"architecture":"arm64","User":"65532:65532","v":"0.1.0"}
0765d1019f4676ebd06a9055cfa442cd6d000689f5e2ba31be8fc998b89faf7b
Die Image-ID bei Podman ist der Config-Digest. Der
Manifest-Digest dagegen entsteht erst beim Push (Layer werden dabei
komprimiert); podman push --digestfile datei schreibt ihn
mit.
Fortschritt speichern? Kostenlos registrieren
Drill 5: crane – installieren und lesen
| Steckbrief | crane |
|---|---|
| Aufgabe | Images und Registries direkt über die Distribution-API bearbeiten |
| Besonderheit | kein Daemon, kein lokaler Speicher; kopiert und ändert in der Registry |
| Projekt | github.com/google/go-containerregistry (Apache-2.0) |
| Version im Buch | 0.22.1 |
Das Paket enthält drei Programme: crane, krane (Tag
10) und gcrane (crane plus Extras für Google-Registries
wie gc und rekursives Kopieren – im Buch nicht
installiert). Installiert hast du crane an Tag 0; hier noch einmal mit
tools.lock:
arch=$(dpkg --print-architecture)
read -r _ _ url sum < <(grep "^crane $arch " "$LAB/setup/tools.lock")
curl -fsSLo /tmp/crane.tgz "$url"
echo "$sum /tmp/crane.tgz" | sha256sum -c -
sudo tar -C /usr/local/bin -xzf /tmp/crane.tgz crane krane && rm /tmp/crane.tgz
crane versionErwartet:
/tmp/crane.tgz: OK
0.22.1
Lesen geht ohne Login, auch auf Docker Hub. Welche Tags hat nginx, welche für 1.30.6?
crane ls docker.io/library/nginx | wc -l
crane ls docker.io/library/nginx | grep '^1\.30\.6-alpine'
crane digest docker.io/library/nginx:1.30.6-alpine
crane digest docker.io/library/nginx:stable-alpine
crane digest --platform linux/arm64 docker.io/library/nginx:1.30.6-alpineErwartet:
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
sha256:0e52bd054126cdc040b1276c0af347aeb02a41b9cfe305d6094767ac30e97949
sha256:0e52bd054126cdc040b1276c0af347aeb02a41b9cfe305d6094767ac30e97949
sha256:4f7cab9e1cd018f80e67f31e02dc0c6d18560b19504461c4f3dd37e5c63a74c5
stable-alpine und 1.30.6-alpine sind heute
dasselbe Image – morgen vielleicht nicht mehr. Der Digest bleibt. Ohne
--platform bekommst du den Digest des Index, mit
--platform den des Manifests für arm64. Wie sieht der Index
aus?
crane manifest docker.io/library/nginx:1.30.6-alpine > idx.json
jq -r '.mediaType, (.manifests | length)' idx.json
jq -r '.manifests[] | "\(.platform.os)/\(.platform.architecture)\(.platform.variant
// "") \(.annotations["vnd.docker.reference.type"] // "-")"' idx.json | head -4
jq '.manifests[6] | {digest, mediaType, platform}' idx.json && rm idx.jsonErwartet:
application/vnd.oci.image.index.v1+json
16
linux/amd64 -
unknown/unknown attestation-manifest
linux/armv6 -
unknown/unknown attestation-manifest
{
"digest": "sha256:4f7cab9e1cd018f80e67f31e02dc0c6d18560b19504461c4f3dd37e5c63a74c5",
"mediaType": "application/vnd.oci.image.manifest.v1+json",
"platform": {
"architecture": "arm64",
"os": "linux",
"variant": "v8"
}
}
Acht Plattformen, dazu acht Attestation-Manifests
(unknown/unknown): Docker Hub legt zu jedem Build eine SBOM
und Provenance ab.
Achtung: Docker Hub begrenzt anonyme Pulls (im Test 100 pro Stunde und IP).
crane lsundcrane digest(HEAD-Request) zählen nicht,crane manifest(GET) schon. Deshalb kopierst du nginx gleich einmal und arbeitest danach lokal.
Fortschritt speichern? Kostenlos registrieren
Drill 6: crane copy und config
time crane copy docker.io/library/nginx:1.30.6-alpine \
"$REG/library/nginx:1.30.6-alpine" 2>&1 | tail -1
crane digest "$REG/library/nginx:1.30.6-alpine"
crane catalog "$REG"
N="$REG/library/nginx:1.30.6-alpine"
crane manifest --platform linux/arm64 "$N" \
| jq -c '{mediaType, config: .config.digest[0:19], layers: [.layers[].size]}'Erwartet:
2026/10/30 20:47:02 registry.ct.lab:5000/library/nginx:1.30.6-alpine: digest: sha256:0
e52bd054126cdc040b1276c0af347aeb02a41b9cfe305d6094767ac30e97949 size: 10317
real 0m21.063s
sha256:0e52bd054126cdc040b1276c0af347aeb02a41b9cfe305d6094767ac30e97949
library/nginx
notes/notes-api
notes/notes-web
notes/notes-worker
{"mediaType":"application/vnd.oci.image.manifest.v1+json","config":"sha256:71f44768e3
48","layers":[4190488,1901479,627,963,404,1211,1399,19858889]}
crane copy überträgt alle Plattformen samt Attestations
Blob für Blob und lässt jedes Byte unverändert – der Digest in deiner
Registry ist derselbe wie auf Docker Hub. Die Daten fließen durch crane
hindurch, nichts landet auf der Platte. Jetzt die Config:
crane config --platform linux/arm64 "$N" | jq '{architecture, variant, created,
config: .config | {Env, Entrypoint, Cmd, ExposedPorts, StopSignal},
layers: (.rootfs.diff_ids | length)}'
podman image inspect docker.io/library/nginx:1.30.6-alpine --format '{{.Id}}'Erwartet (gekürzt):
{
"architecture": "arm64",
"variant": "v8",
"created": "2026-10-22T00:16:56.267286194Z",
"config": {
"Env": [
"PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin",
"NGINX_VERSION=1.30.6",
…
],
"Entrypoint": [
"/docker-entrypoint.sh"
],
"Cmd": [
"nginx",
"-g",
"daemon off;"
],
"ExposedPorts": {
"80/tcp": {}
},
"StopSignal": "SIGQUIT"
},
"layers": 8
}
71f44768e348d88b5e3ea14a77e0e082792bc46d283de47ef08249bd7ae2e223
Wieder: Image-ID im lokalen Speicher = Config-Digest in der Registry.
Was crane dabei über die Leitung schickt, zeigt -v:
crane digest -v "$REG/notes/notes-api:0.1.0" 2>&1 | grep -E '(-->|<--)' \
| cut -c21- | sed 's/ (.*//'Erwartet:
--> GET https://registry.ct.lab:5000/v2/
<-- 401 https://registry.ct.lab:5000/v2/
--> HEAD https://registry.ct.lab:5000/v2/notes/notes-api/manifests/0.1.0
<-- 200 https://registry.ct.lab:5000/v2/notes/notes-api/manifests/0.1.0
Genau die Aufrufe aus Drill 2 und 4 – crane ist ein sehr komfortables curl.
Fortschritt speichern? Kostenlos registrieren
Drill 7: pull, push, tag und delete
lab/ ist ab jetzt deine Spielwiese in der Registry:
cd ~/ct-lab/tag07
crane pull "$REG/notes/notes-api:0.1.0" api.tar && tar -tf api.tar
crane pull --format oci "$REG/notes/notes-api:0.1.0" api-oci && ls api-oci
crane push api.tar "$REG/lab/notes-api:tarball" 2>/dev/null
crane push api-oci "$REG/lab/notes-api:oci" 2>/dev/null
crane tag "$REG/lab/notes-api:oci" stabil 2>/dev/null
crane ls "$REG/lab/notes-api"Erwartet:
sha256:0765d1019f4676ebd06a9055cfa442cd6d000689f5e2ba31be8fc998b89faf7b
2f8852384d1b2d65d511677cf4bbe13190ec6619d81d7935942c229f5c19cacb.tar.gz
34a23a5bdaf142798f754d18fa12765aaaf79f520ee3968f1714a79cfcc2aaf0.tar.gz
manifest.json
blobs index.json oci-layout
registry.ct.lab:5000/lab/notes-api@sha256:9a22b91aff08798c7a7531ca483b799d2cde2492dbd…
registry.ct.lab:5000/lab/notes-api@sha256:9a22b91aff08798c7a7531ca483b799d2cde2492dbd…
oci
stabil
tarball
crane pull schreibt ein Tarball (für
podman load) oder ein OCI-Layout
(--format oci), crane push lädt beides zurück
– mit identischem Digest. crane tag setzt einen Tag, ohne
ein einziges Layer anzufassen. Und Löschen?
crane delete "$REG/lab/notes-api:stabil"; echo "Exit: $?"
crane ls "$REG/lab/notes-api"
crane delete "$REG/lab/notes-api@$(crane digest "$REG/lab/notes-api:oci")"
crane ls "$REG/lab/notes-api"; echo "(leer)"
podman exec registry grep -A1 'delete:' /etc/distribution/config.ymlErwartet:
Exit: 0
oci
tarball
(leer)
delete:
enabled: true
- Per Tag löscht Registry 3.x nur diesen Tag. Per Digest löscht sie
das Manifest – und damit alle Tags, die darauf zeigen
(
ociundtarball). - Die Konfiguration im Image
registry:3.1.2schaltet Löschen schon ein. Ältere Anleitungen setzen dafürREGISTRY_STORAGE_DELETE_ENABLED=true– das ist dieselbe Einstellung als Umgebungsvariable (storage.delete.enabled).
So sieht eine Registry aus, die Löschen verbietet – kurz, ohne TLS,
nur auf 127.0.0.1:5001:
podman run -d --name reg-nodelete -p 127.0.0.1:5001:5000 \
-e REGISTRY_STORAGE_DELETE_ENABLED=false docker.io/library/registry:3.1.2 >/dev/null
sleep 2
crane copy --insecure "$REG/notes/notes-api:0.1.0" 127.0.0.1:5001/test:1 2>/dev/null
crane delete --insecure 127.0.0.1:5001/test:1; echo "Exit: $?"
podman rm -f reg-nodelete >/dev/nullErwartet:
Error: DELETE http://127.0.0.1:5001/v2/test/manifests/1: UNSUPPORTED: The operation is
unsupported.
Exit: 1
Gelöschte Manifests geben den Speicher nicht frei. Die Blobs räumt erst die Garbage Collection weg – in Produktion bei gestoppter oder schreibgeschützter Registry:
podman exec registry registry garbage-collect --dry-run \
/etc/distribution/config.yml 2>&1 | grep 'blobs marked'Erwartet:
133 blobs marked, 0 blobs and 0 manifests eligible for deletion
Nichts frei: Die Layer von lab/notes-api gehören auch zu
notes/notes-api.
Fortschritt speichern? Kostenlos registrieren
Drill 8: Images ändern ohne Build – mutate, append, export
crane copy "$REG/notes/notes-api:0.1.0" "$REG/lab/notes-api:0.1.0" 2>/dev/null
crane mutate "$REG/lab/notes-api:0.1.0" --label lab.tag=07 --env NOTES_LOG=debug \
-t "$REG/lab/notes-api:0.1.0-mut" 2>/dev/null
crane config "$REG/lab/notes-api:0.1.0-mut" \
| jq -c '.config | {Env, lab: .Labels["lab.tag"]}'
crane config "$REG/lab/notes-api:0.1.0" | jq -c '.config.Labels["lab.tag"]'Erwartet:
registry.ct.lab:5000/lab/notes-api@sha256:ba71428aa0a172676289d606866805823269983bc55a…
{"Env":["PATH=/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin","NOTES_LOG
=debug"],"lab":"07"}
null
mutate schreibt eine neue Config und ein neues Manifest;
die Layer bleiben, wo sie sind. Ohne -t würde crane nur per
Digest pushen. Ein zusätzlicher Layer kommt mit append –
aus einem gewöhnlichen tar:
mkdir -p extra/etc/notes && echo "gebaut ohne Build: Tag 7" > extra/etc/notes/README
tar --owner=0 --group=0 -C extra -cf extra.tar etc
crane append -b "$REG/lab/notes-api:0.1.0" -f extra.tar \
-t "$REG/lab/notes-api:0.1.0-extra" 2>/dev/null
crane manifest "$REG/lab/notes-api:0.1.0-extra" | jq -r '.layers[].size'
crane export "$REG/lab/notes-api:0.1.0-extra" - | tar -t
crane export "$REG/lab/notes-api:0.1.0-extra" - | tar -xO etc/notes/README
crane validate --remote "$REG/lab/notes-api:0.1.0-extra"Erwartet:
registry.ct.lab:5000/lab/notes-api@sha256:097bb022375621579f98a39b4e4687566e249aeb7853…
105673
4535388
204
etc
etc/notes
etc/notes/README
notes-api
etc/ssl
etc/ssl/certs
etc/ssl/certs/ca-certificates.crt
gebaut ohne Build: Tag 7
PASS: registry.ct.lab:5000/lab/notes-api:0.1.0-extra
export liefert das zusammengesetzte Dateisystem als ein
tar – praktisch, um in ein scratch-Image zu schauen, das
keine Shell hat. --owner=0 sorgt dafür, dass die Datei im
Image root gehört und nicht deiner UID 1000. crane blob
holt einzelne Blobs, und crane auth get zeigt, was crane
für eine Registry findet:
L=$(crane manifest "$REG/lab/notes-api:0.1.0-extra" | jq -r '.layers[-1].digest')
crane blob "$REG/lab/notes-api@$L" | tar -tz
echo "$REG" | crane auth get; echoErwartet:
etc/
etc/notes/
etc/notes/README
{"Username":"lab","Secret":"lab-registry-pw-123"}
Spielwiese aufräumen – Löschen per Digest nimmt alle Tags mit:
for t in 0.1.0 0.1.0-mut 0.1.0-extra; do
crane delete "$REG/lab/notes-api@$(crane digest "$REG/lab/notes-api:$t")"
done
crane ls "$REG/lab/notes-api"; echo "(leer)"
rm -rf api.tar api-oci extra extra.tarErwartet:
(leer)
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
Die Registry antwortet mit TLS und Login:
cd ~/ct-lab/tag07
source ~/ct-lab/setup/env.sh
curl -s -o /dev/null -w '%{http_code}\n' -u "$REG_USER:$REG_PASS" "https://$REG/v2/"Erwartet:
200
Podman und crane & Co. sind angemeldet:
jq -r '.auths | keys[]' "$XDG_RUNTIME_DIR/containers/auth.json"
jq -r '.auths | keys[]' ~/.docker/config.jsonErwartet:
registry.ct.lab:5000
registry.ct.lab:5000
Die drei notes-Images und nginx mit Original-Digest:
crane catalog "$REG"
crane digest "$REG/library/nginx:1.30.6-alpine"Erwartet:
lab/notes-api
library/nginx
notes/notes-api
notes/notes-web
notes/notes-worker
sha256:0e52bd054126cdc040b1276c0af347aeb02a41b9cfe305d6094767ac30e97949
Die Spielwiese lab/notes-api ist leer:
crane ls "$REG/lab/notes-api" | wc -lErwartet:
0
Challenge
Wie viele Bytes lädt ein arm64-Rechner herunter, der
nginx:1.30.6-alpine zieht? Beantworte die Frage aus deiner
Registry, ohne ein Image zu ziehen.
Hinweis: Die Layer-Größen im Manifest sind die komprimierten Größen – genau das, was über die Leitung geht.
Lösung
crane manifest --platform linux/arm64 "$REG/library/nginx:1.30.6-alpine" \
| jq '[.layers[].size] | add'
crane manifest --platform linux/arm64 "$REG/library/nginx:1.30.6-alpine" \
| jq '.config.size'Erwartet:
25955460
12310
Rund 26 MB Layer plus eine Config von gut 12 kB. Ausgepackt ist das
Image größer (podman images zeigt die entpackte Größe).
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Statt eigener CA: Zertifikat aus der Firmen-PKI oder ACME; die CA-Verteilung auf alle Clients (System-Speicher, Build-Runner, Kubernetes-Nodes) ist die eigentliche Arbeit.
- htpasswd reicht fürs Labor. Produktiv: Harbor, Zot, GitLab, Artifactory oder ein Cloud-Registry-Dienst mit SSO, Robot-Accounts pro Pipeline und Rechten pro Repository.
- Logins nie unverschlüsselt in
~/.docker/config.jsonauf geteilten Maschinen: Credential-Helper (pass,secretservice) oder kurzlebige Tokens aus der CI. - Löschen ist in Produktion meist eine Retention-Policy der Registry (z. B. „behalte die letzten 10 Tags”) plus regelmäßige Garbage Collection im Wartungsfenster.
crane mutate/appendändern signierte Images – die Signatur gilt danach nicht mehr (neuer Digest). Solche Schritte gehören vor die Signatur (Tag 14).