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 2pExpected (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/hostsinto every container. It contains127.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 fExpected:
certs.d/registry.ct.lab:5000/hosts.toml
certs.d/registry.ct.lab:5000/ca.crt
base_hosts_file = "none"(fromcontainers.conf(5)) only applies whenCONTAINERS_CONF_OVERRIDEpoints to the file – so only forkind create, not for your other containers.extraMountsbinds the folder into the node,containerdConfigPatchestells containerd to look there for ahosts.tomlper registry. In the kind image,config_pathis 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 -5Expected:
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 -1Expected:
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 versionExpected:
/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-88Expected:
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.UserExpected:
{
"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"}
imageRefis the manifest digest from your registry: the kubelet remembers which image is really running, even if the tag later points somewhere else.crictl execworks 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 notesExpected:
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.tarExpected:
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/leerExpected:
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 kraneExpected:
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" --versionExpected:
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
kubectlno 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).