Zum Inhalt springen
Trainingslager IT-Trainingslager

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 2p

Erwartet (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/hosts der VM in jeden Container. Dort steht 127.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 f

Erwartet:

certs.d/registry.ct.lab:5000/hosts.toml
certs.d/registry.ct.lab:5000/ca.crt
  • base_hosts_file = "none" (aus containers.conf(5)) gilt nur, wenn CONTAINERS_CONF_OVERRIDE auf die Datei zeigt – also nur für kind create, nicht für deine anderen Container.
  • extraMounts bindet den Ordner in den Node, containerdConfigPatches sagt containerd, dass es dort pro Registry eine hosts.toml suchen soll. Im kind-Image ist config_path sonst 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 -5

Erwartet:

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 -1

Erwartet:

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 version

Erwartet:

/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-88

Erwartet:

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.User

Erwartet:

{
  "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"}
  • imageRef ist der Manifest-Digest aus deiner Registry: Der kubelet merkt sich, welches Image wirklich läuft, auch wenn der Tag später woanders hinzeigt.
  • crictl exec funktioniert 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 notes

Erwartet:

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.tar

Erwartet:

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/leer

Erwartet:

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 krane

Erwartet:

      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" --version

Erwartet:

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 kubectl nicht 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).