Tag 10: Kubernetes von unten – kind, crictl, krane
Ziel: Du startest einen Ein-Node-Cluster rootless mit Podman, ziehst notes-api aus deiner Registry mit Pull-Secret, schaust containerd mit crictl in die Karten und weißt genau, woher krane seine Zugangsdaten nimmt. · Dauer: ca. 90 min · Voraussetzung: Tag 9
Briefing
- kind („Kubernetes in Docker”) startet einen ganzen Kubernetes-Node als Container – hier rootless in Podman. Heute nur Mittel zum Zweck; Kubernetes selbst ist Thema von „Kubernetes zum Anfassen”.
- Im Node arbeitet containerd als Runtime. Der kubelet spricht mit ihm über das CRI (Container Runtime Interface) – und genau diese Schnittstelle bedient crictl.
- krane ist crane mit zusätzlichen Schlüsselbunden für Cloud-Registries. Was er wirklich liest, prüfst du heute nach.
VM ct-lab (rootless Podman)
┌───────────────────────────────────────────────────────────────────┐
│ Netz "kind" │
│ ┌──────────────────────────────┐ ┌───────────────────────┐ │
│ │ ct-lab-control-plane (Node) │ pull │ registry │ │
│ │ kubelet ─CRI─► containerd ───┼─────►│ Alias registry.ct.lab │ │
│ │ crictl ─CRI─┘ certs.d/…/ca │ TLS │ :5000, htpasswd │ │
│ └──────────────────────────────┘ └───────────────────────┘ │
└───────────────────────────────────────────────────────────────────┘
Drill 1: kind – installieren und rootless prüfen
| Steckbrief | kind |
|---|---|
| Aufgabe | lokale Kubernetes-Cluster aus Node-Containern für Tests und CI |
| Besonderheit | Docker oder Podman (KIND_EXPERIMENTAL_PROVIDER=podman),
auch rootless |
| Projekt | kind.sigs.k8s.io, github.com/kubernetes-sigs/kind (Apache-2.0) |
| Version im Buch | v0.33.0 (Kubernetes v1.37.0) |
source ~/ct-lab/setup/env.sh
mkdir -p ~/ct-lab/tag10 && cd ~/ct-lab/tag10
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag09/notes/." .
kind version
podman info --format '{{.Host.Security.Rootless}} cgroup {{.Host.CgroupsVersion}}'
u=$(id -u)
cat "/sys/fs/cgroup/user.slice/user-$u.slice/user@$u.service/cgroup.controllers"
free -m | sed -n 2pErwartet (gekürzt, IDs und Zeiten weichen bei dir ab):
kind v0.33.0 go1.26.7 linux/arm64
true cgroup v2
cpu memory pids
Mem: 4004 632 1893 5 1774 3372
Rootless braucht kind cgroup v2 und die an deinen User delegierten
Controller. Ubuntu 26.04 delegiert cpu memory pids von Haus
aus – im Test reichte das: Kein Delegate=yes-Drop-in, kein
systemd-run --scope --user, keine Kernel-Module von Hand.
Ein Node braucht gut 800 MB RAM.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Den Cluster für die eigene Registry vorbereiten
Zwei Hürden, bevor der Node aus registry.ct.lab:5000
ziehen kann:
- Podman kopiert die
/etc/hostsder VM in jeden Container. Dort steht127.0.0.1 registry.ct.lab– im Node wäre das der Node selbst. - containerd im Node kennt deine CA nicht.
Die Lösung: Der Node bekommt eine leere
Basis-/etc/hosts, die Registry tritt dem Podman-Netz
kind mit dem Alias registry.ct.lab bei
(Podmans DNS löst ihn auf), und containerd findet die CA über ein
certs.d-Verzeichnis:
mkdir -p kind "certs.d/registry.ct.lab:5000"
cat > kind/hosts.toml <<'EOF'
# kind/hosts.toml – Stand Ende Tag 10: containerd-Hostkonfiguration für die Registry
server = "https://registry.ct.lab:5000"
[host."https://registry.ct.lab:5000"]
capabilities = ["pull", "resolve"]
ca = "/etc/containerd/certs.d/registry.ct.lab:5000/ca.crt"
EOF
cp kind/hosts.toml "$LAB/registry/certs/ca.crt" "certs.d/registry.ct.lab:5000/"
cat > kind/containers-kind.conf <<'EOF'
# kind/containers-kind.conf – Stand Ende Tag 10: nur für kind create
[containers]
base_hosts_file = "none"
EOF
cat > kind/kind-ct-lab.yaml <<'EOF'
# kind/kind-ct-lab.yaml – Stand Ende Tag 10: ein Node, CA für die eigene Registry
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: ct-lab
nodes:
- role: control-plane
extraMounts:
- hostPath: /home/ubuntu/ct-lab/tag10/certs.d
containerPath: /etc/containerd/certs.d
readOnly: true
containerdConfigPatches:
- |-
[plugins."io.containerd.grpc.v1.cri".registry]
config_path = "/etc/containerd/certs.d"
EOF
find certs.d -type fErwartet:
certs.d/registry.ct.lab:5000/hosts.toml
certs.d/registry.ct.lab:5000/ca.crt
base_hosts_file = "none"(auscontainers.conf(5)) gilt nur, wennCONTAINERS_CONF_OVERRIDEauf die Datei zeigt – also nur fürkind create, nicht für deine anderen Container.extraMountsbindet den Ordner in den Node,containerdConfigPatchessagt containerd, dass es dort pro Registry einehosts.tomlsuchen soll. Im kind-Image istconfig_pathsonst leer.
Jetzt der Cluster. Beim ersten Mal lädt kind das Node-Image (rund 940 MB):
export KIND_EXPERIMENTAL_PROVIDER=podman
CONTAINERS_CONF_OVERRIDE=$PWD/kind/containers-kind.conf \
kind create cluster --config kind/kind-ct-lab.yaml
podman ps --format '{{.Names}} {{.Ports}}'
podman exec ct-lab-control-plane cat /etc/hosts | grep -v '^::\|^fc00'Erwartet (gekürzt, ohne Emojis):
using podman due to KIND_EXPERIMENTAL_PROVIDER
enabling experimental podman provider
Creating cluster "ct-lab" ...
✓ Ensuring node image (kindest/node:v1.37.0)
✓ Preparing nodes
✓ Writing configuration
✓ Starting control-plane
✓ Installing CNI
✓ Installing StorageClass
Set kubectl context to "kind-ct-lab"
…
registry 127.0.0.1:5000->5000/tcp
ct-lab-control-plane 127.0.0.1:34501->6443/tcp
127.0.0.1 localhost
169.254.1.2 host.containers.internal host.docker.internal
10.89.0.3 ct-lab-control-plane ct-lab-control-plane
Kein registry.ct.lab mehr in der hosts-Datei des Nodes.
kind hat ~/.kube/config mit dem Kontext
kind-ct-lab geschrieben; der API-Server ist nur auf
127.0.0.1 erreichbar.
Fortschritt speichern? Kostenlos registrieren
Drill 3: kubectl ohne Installation, Registry ins Netz
kubectl ist auf der VM nicht installiert – aber im Node.
podman exec ruft es dort auf; den Node-Namen hält
N fest. Ohne -i verschluckt
podman exec keine Eingaben; nur apply -f -
bekommt gleich ein podman exec -i:
N=ct-lab-control-plane
podman exec $N kubectl wait --for=condition=Ready node --all --timeout=120s
podman exec $N kubectl get nodes -o wide | cut -c1-88
podman exec $N kubectl get pods -A | head -5Erwartet:
node/ct-lab-control-plane condition met
NAME STATUS ROLES AGE VERSION INTERNAL-IP EXTERNAL-I
ct-lab-control-plane Ready control-plane 28s v1.37.0 10.89.0.3 <none>
kube-system coredns-559f6c778d-g99jx Running
kube-system coredns-559f6c778d-gwpb6 Running
kube-system etcd-ct-lab-control-plane Running
kube-system kindnet-svlsw Running
Die Registry startest du mit dem Skript von Tag 7 neu – diesmal im
Netz kind. Die Daten liegen im Volume
registry-data und bleiben erhalten:
./run-registry.sh kind | cut -c1-12
crane ls "$REG/notes/notes-api"
N=ct-lab-control-plane
podman exec $N getent hosts registry.ct.lab
podman exec $N curl -sS -o /dev/null https://registry.ct.lab:5000/v2/ 2>&1 \
| head -1 | cut -c1-60
podman exec $N curl -s -o /dev/null -w '%{http_code}\n' \
--cacert /etc/containerd/certs.d/registry.ct.lab:5000/ca.crt \
https://registry.ct.lab:5000/v2/Erwartet:
94d360641989
0.1.0
fc00:f853:ccd:e793::3 registry.ct.lab
curl: (60) SSL certificate problem: unable to get local issu
401
Der Node findet die Registry über den Netz-Alias, und mit der gemounteten CA klappt TLS. 401 heißt: Jetzt fehlt nur noch das Login.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Ein Pod aus der eigenen Registry
mkdir -p k8s
cat > k8s/notes-api-pod.yaml <<'EOF'
# k8s/notes-api-pod.yaml – Stand Ende Tag 10: notes-api aus der eigenen Registry
apiVersion: v1
kind: Pod
metadata:
name: notes-api
labels:
app: notes-api
spec:
imagePullSecrets:
- name: regcred
containers:
- name: notes-api
image: registry.ct.lab:5000/notes/notes-api:0.1.0
ports:
- containerPort: 8080
env:
- name: NOTES_API_KEY
value: lab-api-key-123
EOF
podman exec -i $N kubectl apply -f - < k8s/notes-api-pod.yaml
sleep 10; podman exec $N kubectl get pod notes-api
podman exec $N kubectl get events --field-selector involvedObject.name=notes-api \
-o custom-columns=REASON:.reason --no-headers | sort -u
podman exec $N kubectl get events \
--field-selector involvedObject.name=notes-api,reason=Failed \
-o jsonpath='{.items[0].message}' | grep -o 'pull access.*'Erwartet:
pod/notes-api created
NAME READY STATUS RESTARTS AGE
notes-api 0/1 ErrImagePull 0 10s
BackOff
Failed
FailedToRetrieveImagePullSecret
Pulling
Scheduled
pull access denied, repository does not exist or may require authorization: authoriza
tion failed: no basic auth credentials
TLS passt, aber das Secret regcred gibt es noch nicht.
Ein Pull-Secret ist nichts anderes als eine
Docker-config.json in einem Kubernetes-Secret:
podman exec $N kubectl create secret docker-registry regcred \
--docker-server=registry.ct.lab:5000 \
--docker-username=lab --docker-password=lab-registry-pw-123
podman exec $N kubectl get secret regcred -o jsonpath='{.data.\.dockerconfigjson}' \
| base64 -d | jq -c .
podman exec $N kubectl delete pod notes-api
podman exec -i $N kubectl apply -f - < k8s/notes-api-pod.yaml
sleep 10; podman exec $N kubectl get pod notes-api
podman exec $N kubectl logs notes-api | tail -1Erwartet:
secret/regcred created
{"auths":{"registry.ct.lab:5000":{"username":"lab","password":"lab-registry-pw-123","a
uth":"bGFiOmxhYi1yZWdpc3RyeS1wdy0xMjM="}}}
pod "notes-api" deleted from default namespace
pod/notes-api created
NAME READY STATUS RESTARTS AGE
notes-api 1/1 Running 0 10s
time=2026-10-30T21:05:06.130Z level=INFO msg=listening addr=:8080 version=0.1.0 pid=1
Sicherheit: Secrets sind in Kubernetes nur Base64-kodiert. Wer Secrets im Namespace lesen darf, kennt das Registry-Passwort – in Produktion gehören dort Robot-Accounts mit reinem Leserecht hinein.
Fortschritt speichern? Kostenlos registrieren
Drill 5: crictl – installieren und in den Node schauen
| Steckbrief | crictl |
|---|---|
| Aufgabe | CRI-Runtimes (containerd, CRI-O) auf einem Kubernetes-Node untersuchen |
| Besonderheit | sieht Pods und Container wie der kubelet; zum Debuggen, nicht zum Betrieb |
| Projekt | github.com/kubernetes-sigs/cri-tools (Apache-2.0) |
| Version im Buch | v1.37.0 |
crictl gehört auf den Node, nicht auf deinen Rechner. Du installierst es auf der VM und kopierst es in den Node – dort ersetzt es die mitgelieferte 1.36.0:
arch=$(dpkg --print-architecture)
read -r _ _ url sum < <(grep "^crictl $arch " "$LAB/setup/tools.lock")
curl -fsSLo /tmp/crictl.tgz "$url"
echo "$sum /tmp/crictl.tgz" | sha256sum -c -
sudo tar -C /usr/local/bin -xzf /tmp/crictl.tgz crictl && rm /tmp/crictl.tgz
podman exec $N crictl --version
podman cp /usr/local/bin/crictl $N:/usr/local/bin/crictl
podman exec $N crictl --version
podman exec $N cat /etc/crictl.yaml; echo
podman exec $N crictl --runtime-endpoint unix:///run/containerd/containerd.sock versionErwartet:
/tmp/crictl.tgz: OK
crictl version 1.36.0
crictl version v1.37.0
runtime-endpoint: unix:///run/containerd/containerd.sock
Version: 0.1.0
RuntimeName: containerd
RuntimeVersion: v2.3.4
RuntimeApiVersion: v1
crictl braucht nur den Socket der Runtime: per
--runtime-endpoint oder dauerhaft in
/etc/crictl.yaml
(crictl config --set runtime-endpoint=… schreibt sie). Im
Node ist das schon eingetragen:
podman exec $N crictl pods | cut -c1-88 | head -4
podman exec $N crictl ps | cut -c1-88 | head -4
podman exec $N crictl images | grep -E 'IMAGE|notes|pause|apiserver' | cut -c1-88Erwartet:
POD ID CREATED STATE NAME
81c2ea1ba9fad 30 seconds ago Ready notes-api
3eb8837b0cfbc About a minute ago Ready coredns-559f6c778d-wmbxw
e4b11ae6e59d4 About a minute ago Ready local-path-provisioner-75f7
7417e0232aac3 notes-api default
cc8ea34559253 local-path-provisioner local-path-storage
4554209ba7f9a coredns kube-system
07c4e0a7e1580 coredns kube-system
IMAGE TAG IMAGE
registry.ct.lab:5000/notes/notes-api 0.1.0 0765d1019f467
registry.k8s.io/kube-apiserver-arm64 v1.37.0 bec5f0e1e2eeb
registry.k8s.io/kube-apiserver v1.37.0 bec5f0e1e2eeb
registry.k8s.io/pause 3.10 873ed75102791
Pods und Container wie im Cluster, jeder Pod mit seinem
pause-Container als Sandbox. Die Image-ID
0765… ist wieder der Config-Digest von Tag 7.
Fortschritt speichern? Kostenlos registrieren
Drill 6: crictl im Einsatz – und der Unterschied zu ctr
CID=$(podman exec $N crictl ps --name notes-api -q)
podman exec $N crictl inspect "$CID" | jq -r .status.state
podman exec $N crictl inspect "$CID" | jq -r .status.imageRef
podman exec $N crictl logs --tail 1 "$CID"
podman exec $N crictl exec "$CID" /notes-api healthcheck; echo "Exit: $?"
podman exec $N crictl stats --label io.kubernetes.pod.namespace=default
podman exec $N crictl inspecti registry.ct.lab:5000/notes/notes-api:0.1.0 \
| jq -r .info.imageSpec.config.UserErwartet:
{
"state": "CONTAINER_RUNNING",
"imageRef": "registry.ct.lab:5000/notes/notes-api@sha256:9a22b91aff08798c7a7531ca…",
"user": 65532,
"pid": 1922
}
time=2026-10-30T21:05:06.130Z level=INFO msg=listening addr=:8080 version=0.1.0 pid=1
Exit: 0
CONTAINER NAME CPU %
3a49e7dc63480 notes-api 0.00 1.589MB
{"size":"4645500","user":"65532:65532"}
imageRefist der Manifest-Digest aus deiner Registry: Der kubelet merkt sich, welches Image wirklich läuft, auch wenn der Tag später woanders hinzeigt.crictl execfunktioniert auch ohne Shell im Image (scratch) – das Binary selbst ist der Befehl. Der Healthcheck antwortet mit Exit 0.
crictl kann auch Images ziehen, kennt dabei aber keine Secrets aus dem Cluster:
podman exec $N crictl pull registry.ct.lab:5000/notes/notes-web:0.1.0 2>&1 \
| grep -o 'authorization failed: [a-z ]*' | tail -1
podman exec $N crictl pull --creds lab:lab-registry-pw-123 \
registry.ct.lab:5000/notes/notes-web:0.1.0
podman exec $N crictl rmi registry.ct.lab:5000/notes/notes-web:0.1.0
podman exec $N ctr namespaces ls
podman exec $N ctr -n k8s.io images ls -q | grep notesErwartet:
authorization failed: no basic auth credentials
Image is up to date for sha256:385e5c7c9022f0c925486ea849260d93a1032fc72fceb066902c9a…
Deleted: registry.ct.lab:5000/notes/notes-web:0.1.0
NAME LABELS
k8s.io
registry.ct.lab:5000/notes/notes-api:0.1.0
registry.ct.lab:5000/notes/notes-api@sha256:9a22b91aff08798c7a7531ca483b799d2cde2492dbd…
| crictl | ctr (Tag 6) | |
|---|---|---|
| spricht | CRI (wie der kubelet) | containerd-API direkt |
| sieht | Pods, Sandboxes, Container | Namespaces, Images, Container, Tasks |
| Runtimes | containerd, CRI-O | nur containerd |
| gedacht für | Debuggen auf Kubernetes-Nodes | containerd-Entwicklung, Low-Level |
Alles, was Kubernetes anlegt, liegt bei containerd im Namespace
k8s.io. Mit ctr siehst du dort mehr, aber ohne
Pod-Begriff – und Änderungen an kubelet vorbei führen zu
Überraschungen.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Images ohne Registry – kind load
Für schnelle Tests kann kind ein lokales Image direkt in den Node laden:
kind load docker-image localhost/notes-api:0.2.0 --name ct-lab 2>&1 | tail -1
podman save -q -o api-020.tar localhost/notes-api:0.2.0
kind load image-archive api-020.tar --name ct-lab 2>&1 | tail -1
podman exec $N crictl images | grep notes | awk '{print $1, $2, $3}' && rm api-020.tarErwartet:
ERROR: image: "localhost/notes-api:0.2.0" not present locally
enabling experimental podman provider
localhost/notes-api 0.2.0 770583b7d2dbc
registry.ct.lab:5000/notes/notes-api 0.1.0 0765d1019f467
kind load docker-image findet Podman-Images mit
localhost/ nicht; der Umweg über podman save
und image-archive funktioniert immer. So geladene Images
haben keine Registry hinter sich – im Pod brauchen sie
imagePullPolicy: Never oder IfNotPresent.
Fortschritt speichern? Kostenlos registrieren
Drill 8: krane – welche Zugangsdaten zählen?
| Steckbrief | krane |
|---|---|
| Aufgabe | crane-Befehle mit zusätzlichen Schlüsselbunden für Cloud-Registries |
| Besonderheit | Docker-Config plus Google, GitHub, Amazon ECR und Azure ACR |
| Projekt | github.com/google/go-containerregistry, cmd/krane
(Apache-2.0) |
| Version im Buch | 0.22.1 (im crane-Paket, Tag 7) |
krane version
diff <(crane --help | sed -n '/Available/,/^$/p') \
<(krane --help | sed -n '/Available/,/^$/p') && echo "gleiche Befehle"
krane ls "$REG/notes/notes-api"
mkdir -p /tmp/leer
DOCKER_CONFIG=/tmp/leer env -u XDG_RUNTIME_DIR krane ls "$REG/notes/notes-api" 2>&1 \
| grep -o 'UNAUTHORIZED: [a-z ]*'Erwartet:
0.22.1
gleiche Befehle
0.1.0
UNAUTHORIZED: authentication required
Ohne Docker-Config und ohne Podman-Login kommt krane nicht in deine
Registry – obwohl ~/.kube/config mit vollen Admin-Rechten
daneben liegt. Der Quelltext (cmd/krane/main.go) kombiniert
genau fünf Schlüsselbunde: die Docker-Config, Google, GitHub
(GITHUB_TOKEN für ghcr.io), Amazon ECR und Azure ACR (je
über deren Umgebungsvariablen bzw. Workload-Identity). Kubeconfig,
ServiceAccount und Pull-Secrets aus dem Cluster liest krane
nicht.
Das Pull-Secret ist aber eine Docker-Config – also kann krane es benutzen, wenn du es ihm als Datei gibst:
podman exec $N kubectl get secret regcred -o jsonpath='{.data.\.dockerconfigjson}' \
| base64 -d > /tmp/leer/config.json
DOCKER_CONFIG=/tmp/leer env -u XDG_RUNTIME_DIR krane ls "$REG/notes/notes-api"
rm -rf /tmp/leerErwartet:
0.1.0
Im Cluster genauso: Ein Pod bekommt das Secret als Datei gemountet,
DOCKER_CONFIG zeigt darauf, SSL_CERT_FILE auf
die CA aus einer ConfigMap:
podman exec $N kubectl create configmap lab-ca \
--from-file=ca.crt=/etc/containerd/certs.d/registry.ct.lab:5000/ca.crt
cat > k8s/krane-pod.yaml <<'EOF'
# k8s/krane-pod.yaml – Stand Ende Tag 10: krane im Cluster mit Pull-Secret als Datei
apiVersion: v1
kind: Pod
metadata:
name: krane
spec:
imagePullSecrets:
- name: regcred
containers:
- name: krane
image: registry.ct.lab:5000/library/nginx:1.30.6-alpine
command: ["sleep", "3600"]
env:
- name: DOCKER_CONFIG
value: /docker
- name: SSL_CERT_FILE
value: /certs/ca.crt
volumeMounts:
- name: regcred
mountPath: /docker
readOnly: true
- name: lab-ca
mountPath: /certs
readOnly: true
volumes:
- name: regcred
secret:
secretName: regcred
items:
- key: .dockerconfigjson
path: config.json
- name: lab-ca
configMap:
name: lab-ca
EOF
podman exec -i $N kubectl apply -f - < k8s/krane-pod.yaml
podman exec $N kubectl wait --for=condition=Ready pod/krane --timeout=60s
podman cp /usr/local/bin/krane $N:/tmp/krane
podman exec $N kubectl cp /tmp/krane krane:/usr/local/bin/krane
podman exec $N kubectl exec krane -- \
krane digest registry.ct.lab:5000/notes/notes-api:0.1.0
podman exec $N kubectl exec krane -- ls /var/run/secrets/kubernetes.io/serviceaccount/
podman exec $N kubectl exec krane -- env DOCKER_CONFIG=/tmp krane ls \
registry.ct.lab:5000/notes/notes-api 2>&1 | grep -o 'UNAUTHORIZED: [a-z ]*'Erwartet:
configmap/lab-ca created
pod/krane created
pod/krane condition met
sha256:9a22b91aff08798c7a7531ca483b799d2cde2492dbdf911f291c161d4ffc7f23
ca.crt
namespace
token
UNAUTHORIZED: authentication required
Mit dem gemounteten Secret klappt es; der ServiceAccount-Token liegt
im Pod, wird aber ignoriert, sobald DOCKER_CONFIG woanders
hinzeigt. Das Image für den Test-Pod ist nginx aus deiner Registry (Tag
7) – derselbe Index liefert dem Node die arm64-Variante. krane spielt
seine Stärke in der Cloud aus: In GKE, EKS oder AKS holt er Tokens aus
der Workload-Identity des Pods, ganz ohne Secret.
Aufräumen – Cluster weg, Registry zurück ins Standardnetz, Netz
kind entfernen:
kind delete cluster --name ct-lab 2>&1 | tail -1
./run-registry.sh | cut -c1-12
podman network rm kind
podman inspect registry --format '{{.HostConfig.NetworkMode}}'
crane ls "$REG/notes/notes-api"Erwartet:
Deleted nodes: ["ct-lab-control-plane"]
RR_ID
kind
pasta
0.1.0
Ohne Argument startet run-registry.sh die Registry
wieder wie an Tag 7 im rootless Standardnetz; Zertifikate, Passwort und
Daten im Volume bleiben.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
Kein kind-Cluster mehr, das Netz kind ist weg:
cd ~/ct-lab/tag10
source ~/ct-lab/setup/env.sh
KIND_EXPERIMENTAL_PROVIDER=podman kind get clusters
podman network ls --format '{{.Name}}'Erwartet:
using podman due to KIND_EXPERIMENTAL_PROVIDER
enabling experimental podman provider
No kind clusters found.
notes
notes_default
podman
podman-default-kube-network
Die Registry hängt wieder im Standardnetz mit Port auf 127.0.0.1 und hat notes-api:
podman port registry
crane ls "$REG/notes/notes-api"Erwartet:
5000/tcp -> 127.0.0.1:5000
0.1.0
Die kind-Konfiguration ist aufbewahrt, die drei Werkzeuge sind installiert:
grep config_path kind/kind-ct-lab.yaml
ls kind
command -v kind crictl kraneErwartet:
config_path = "/etc/containerd/certs.d"
containers-kind.conf
hosts.toml
kind-ct-lab.yaml
/usr/local/bin/kind
/usr/local/bin/crictl
/usr/local/bin/krane
Challenge
Welche Versionen von containerd und crictl bringt das kind-Node-Image mit? Finde es heraus, ohne einen Cluster zu starten.
Hinweis: Das Node-Image liegt nach
kind delete noch in deinem Podman-Speicher – ohne Tag, kind
pinnt es per Digest.
Lösung
podman images --digests --format '{{.Repository}} {{.Tag}} {{.Digest}}' \
| grep kindest | cut -c1-60
img=$(podman images --format '{{.ID}}' docker.io/kindest/node)
podman run --rm --entrypoint containerd "$img" --version | cut -d' ' -f1,3
podman run --rm --entrypoint crictl "$img" --versionErwartet:
docker.io/kindest/node <none> sha256:a1ed56cfb0e7b93589bdf97
containerd v2.3.4
crictl version 1.36.0
Ein kind-Node ist ein ganz normales Image: Debian 13 mit systemd, containerd, kubelet und den Kubernetes-Images vorab geladen.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- kind ist für Entwicklung und CI gedacht. Rootless kind teilt sich
Kernel und RAM mit allem anderen auf der Maschine – Grenzen über
Memory=der User-Session setzen. - Private Registries im Cluster: CA per Node-Image, DaemonSet oder
Machine-Config verteilen
(
/etc/containerd/certs.d/<registry>/hosts.toml), Pull-Secrets per ServiceAccount (imagePullSecrets) statt in jedem Pod. - crictl ist das Werkzeug der Wahl, wenn
kubectlnicht mehr hilft (kubelet hängt, Image-Pull scheitert). Zugriff auf den Node-Socket ist root-gleich – nur für Admins. - Pull-Secrets mit Leserecht und kurzer Laufzeit; besser noch Workload-Identity der Cloud (dort spielt krane seine Stärke aus) oder ein Credential-Provider des kubelet.
- In Produktion zieht der Cluster nur aus der internen Registry (Spiegel aus Tag 9), per Digest gepinnt und mit Admission-Policy auf Signaturen geprüft (Tag 14).