Skip to content
Hands-on IT IT Drills

Day 10: Kubernetes from below – kind, crictl, krane

Goal: You start a single-node cluster rootless with Podman, pull notes-api from your registry with a pull secret, look over containerd’s shoulder with crictl and know exactly where krane gets its credentials from. · Duration: approx. 90 min · Prerequisite: Day 9

Briefing

  • kind (“Kubernetes in Docker”) starts an entire Kubernetes node as a container – here rootless in Podman. Today it is just a means to an end; Kubernetes itself is the subject of “Kubernetes hands-on”.
  • Inside the node, containerd works as the runtime. The kubelet talks to it via the CRI (Container Runtime Interface) – and that is exactly the interface crictl uses.
  • krane is crane with additional keychains for cloud registries. Today you check what it really reads.
 VM ct-lab (rootless Podman)
 ┌───────────────────────────────────────────────────────────────────┐
 │ network "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 – install and check rootless

Profile kind
Task Local Kubernetes clusters made of node containers for tests and CI
Special feature Docker or Podman (KIND_EXPERIMENTAL_PROVIDER=podman), rootless too
Project kind.sigs.k8s.io, github.com/kubernetes-sigs/kind (Apache-2.0)
Version in this book 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

Expected (shortened; IDs and times will differ for you):

kind v0.33.0 go1.26.7 linux/arm64
true cgroup v2
cpu memory pids
Mem:            4004         632        1893           5        1774        3372

Rootless kind needs cgroup v2 and the controllers delegated to your user. Ubuntu 26.04 delegates cpu memory pids out of the box – in testing that was enough: no Delegate=yes drop-in, no systemd-run --scope --user, no kernel modules by hand. A node needs a good 800 MB of RAM.

Save your progress? Sign up for free

Drill 2: Prepare the cluster for your own registry

Two hurdles before the node can pull from registry.ct.lab:5000:

  • Podman copies the VM’s /etc/hosts into every container. It contains 127.0.0.1 registry.ct.lab – inside the node, that would be the node itself.
  • containerd inside the node doesn’t know your CA.

The solution: the node gets an empty base /etc/hosts, the registry joins the Podman network kind with the alias registry.ct.lab (Podman’s DNS resolves it), and containerd finds the CA via a certs.d directory:

mkdir -p kind "certs.d/registry.ct.lab:5000"
cat > kind/hosts.toml <<'EOF'
# kind/hosts.toml – state at end of Day 10: containerd host configuration for the 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 – state at end of Day 10: only for kind create
[containers]
base_hosts_file = "none"
EOF
cat > kind/kind-ct-lab.yaml <<'EOF'
# kind/kind-ct-lab.yaml – state at end of Day 10: one node, CA for your own 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

Expected:

certs.d/registry.ct.lab:5000/hosts.toml
certs.d/registry.ct.lab:5000/ca.crt
  • base_hosts_file = "none" (from containers.conf(5)) only applies when CONTAINERS_CONF_OVERRIDE points to the file – so only for kind create, not for your other containers.
  • extraMounts binds the folder into the node, containerdConfigPatches tells containerd to look there for a hosts.toml per registry. In the kind image, config_path is empty otherwise.

Now the cluster. The first time, kind downloads the node image (around 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'

Expected (shortened, without 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

No more registry.ct.lab in the node’s hosts file. kind has written ~/.kube/config with the context kind-ct-lab; the API server is reachable only on 127.0.0.1.

Save your progress? Sign up for free

Drill 3: kubectl without installing it, registry into the network

kubectl isn’t installed on the VM – but it is in the node. podman exec calls it there; N holds the node name. Without -i, podman exec doesn’t swallow any input; only apply -f - gets a podman exec -i right away:

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

Expected:

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

You restart the registry with the script from Day 7 – this time in the network kind. The data lives in the volume registry-data and is preserved:

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

Expected:

94d360641989
0.1.0
fc00:f853:ccd:e793::3 registry.ct.lab
curl: (60) SSL certificate problem: unable to get local issu
401

The node finds the registry via the network alias, and with the mounted CA, TLS works. 401 means: now only the login is missing.

Save your progress? Sign up for free

Drill 4: A pod from your own registry

mkdir -p k8s
cat > k8s/notes-api-pod.yaml <<'EOF'
# k8s/notes-api-pod.yaml – state at end of Day 10: notes-api from your own 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.*'

Expected:

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 is fine, but the secret regcred doesn’t exist yet. A pull secret is nothing more than a Docker config.json inside a 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

Expected:

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

Security: In Kubernetes, Secrets are only Base64-encoded. Anyone allowed to read Secrets in the namespace knows the registry password – in production, robot accounts with read-only access belong there.

Save your progress? Sign up for free

Drill 5: crictl – install it and look inside the node

Profile crictl
Task Inspect CRI runtimes (containerd, CRI-O) on a Kubernetes node
Special feature Sees pods and containers the way the kubelet does; for debugging, not for operations
Project github.com/kubernetes-sigs/cri-tools (Apache-2.0)
Version in this book v1.37.0

crictl belongs on the node, not on your machine. You install it on the VM and copy it into the node – there it replaces the bundled 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

Expected:

/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 only needs the runtime’s socket: via --runtime-endpoint or permanently in /etc/crictl.yaml (crictl config --set runtime-endpoint=… writes it). In the node it is already set:

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

Expected:

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 and containers as in the cluster, each pod with its pause container as the sandbox. The image ID 0765… is once again the config digest from Day 7.

Save your progress? Sign up for free

Drill 6: crictl in action – and how it differs from 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

Expected:

{
  "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 is the manifest digest from your registry: the kubelet remembers which image is really running, even if the tag later points somewhere else.
  • crictl exec works even without a shell in the image (scratch) – the binary itself is the command. The health check answers with exit 0.

crictl can pull images too, but it doesn’t know about Secrets from the 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

Expected:

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 (Day 6)
speaks CRI (like the kubelet) containerd API directly
sees pods, sandboxes, containers namespaces, images, containers, tasks
runtimes containerd, CRI-O containerd only
intended for debugging on Kubernetes nodes containerd development, low level

Everything Kubernetes creates lives in containerd’s namespace k8s.io. With ctr you see more there, but without the concept of a pod – and changes behind the kubelet’s back lead to surprises.

Save your progress? Sign up for free

Drill 7: Images without a registry – kind load

For quick tests, kind can load a local image directly into the node:

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

Expected:

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 doesn’t find Podman images with localhost/; the detour via podman save and image-archive always works. Images loaded this way have no registry behind them – in the pod they need imagePullPolicy: Never or IfNotPresent.

Save your progress? Sign up for free

Drill 8: krane – which credentials count?

Profile krane
Task crane commands with additional keychains for cloud registries
Special feature Docker config plus Google, GitHub, Amazon ECR and Azure ACR
Project github.com/google/go-containerregistry, cmd/krane (Apache-2.0)
Version in this book 0.22.1 (in the crane package, Day 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 ]*'

Expected (gleiche Befehle = same commands):

0.22.1
gleiche Befehle
0.1.0
UNAUTHORIZED: authentication required

Without a Docker config and without a Podman login, krane can’t get into your registry – even though ~/.kube/config with full admin rights sits right next to it. The source code (cmd/krane/main.go) combines exactly five keychains: the Docker config, Google, GitHub (GITHUB_TOKEN for ghcr.io), Amazon ECR and Azure ACR (each via their environment variables or workload identity). krane does not read the kubeconfig, ServiceAccount or pull secrets from the cluster.

But the pull secret is a Docker config – so krane can use it if you hand it over as a file:

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

Expected:

0.1.0

The same works in the cluster: a pod gets the Secret mounted as a file, DOCKER_CONFIG points to it, SSL_CERT_FILE to the CA from a 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 – state at end of Day 10: krane in the cluster with the pull secret as a file
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 ]*'

Expected:

configmap/lab-ca created
pod/krane created
pod/krane condition met
sha256:9a22b91aff08798c7a7531ca483b799d2cde2492dbdf911f291c161d4ffc7f23
ca.crt
namespace
token
UNAUTHORIZED: authentication required

With the mounted Secret it works; the ServiceAccount token is in the pod but gets ignored as soon as DOCKER_CONFIG points somewhere else. The image for the test pod is nginx from your registry (Day 7) – the same index gives the node the arm64 variant. krane plays to its strengths in the cloud: in GKE, EKS or AKS it fetches tokens from the pod’s workload identity, without any Secret at all.

Cleaning up – cluster gone, registry back into the default network, remove the network kind:

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"

Expected:

Deleted nodes: ["ct-lab-control-plane"]
RR_ID
kind
pasta
0.1.0

Without an argument, run-registry.sh starts the registry again as on Day 7 in the rootless default network; certificates, password and the data in the volume remain.

Save your progress? Sign up for free

Checkpoint

No kind cluster anymore, the network kind is gone:

cd ~/ct-lab/tag10
source ~/ct-lab/setup/env.sh
KIND_EXPERIMENTAL_PROVIDER=podman kind get clusters
podman network ls --format '{{.Name}}'

Expected:

using podman due to KIND_EXPERIMENTAL_PROVIDER
enabling experimental podman provider
No kind clusters found.
notes
notes_default
podman
podman-default-kube-network

The registry is back in the default network with its port on 127.0.0.1 and has notes-api:

podman port registry
crane ls "$REG/notes/notes-api"

Expected:

5000/tcp -> 127.0.0.1:5000
0.1.0

The kind configuration is kept, and the three tools are installed:

grep config_path kind/kind-ct-lab.yaml
ls kind
command -v kind crictl krane

Expected:

      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

Which versions of containerd and crictl does the kind node image ship with? Find out without starting a cluster.

Hint: After kind delete, the node image is still in your Podman storage – without a tag; kind pins it by digest.

Solution

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

Expected:

docker.io/kindest/node <none> sha256:a1ed56cfb0e7b93589bdf97
containerd v2.3.4
crictl version 1.36.0

A kind node is a perfectly normal image: Debian 13 with systemd, containerd, kubelet and the Kubernetes images preloaded.

Save your progress? Sign up for free

Enterprise Note

  • kind is meant for development and CI. Rootless kind shares the kernel and RAM with everything else on the machine – set limits via Memory= of the user session.
  • Private registries in the cluster: distribute the CA via the node image, a DaemonSet or machine config (/etc/containerd/certs.d/<registry>/hosts.toml), pull secrets per ServiceAccount (imagePullSecrets) instead of in every pod.
  • crictl is the tool of choice when kubectl no longer helps (kubelet hangs, image pull fails). Access to the node socket is equivalent to root – admins only.
  • Pull secrets with read access and a short lifetime; better still, the cloud’s workload identity (where krane plays to its strengths) or a kubelet credential provider.
  • In production, the cluster pulls only from the internal registry (mirror from Day 9), pinned by digest and checked for signatures by an admission policy (Day 14).