Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 11: Sandboxing mit RuntimeClass und gVisor

Ziel: Du installierst gVisor auf den Workern, trägst runsc als Runtime-Handler in containerd ein und schickst Pods per RuntimeClass in die Sandbox. · Dauer: ca. 60 min · Voraussetzung: Tag 10

Briefing

  • CKS: Minimize Microservice Vulnerabilities – „Understand and implement isolation techniques (multi-tenancy, sandboxed containers, etc.)“.
  • Normale Container teilen sich den Kernel des Nodes – eine Kernel-Lücke reicht für den Ausbruch. gVisor schiebt einen eigenen Kernel in Go (Sentry) dazwischen.
  • Kette: Pod runtimeClassName → RuntimeClass handler → containerd-Runtime gleichen Namens → Shim containerd-shim-runsc-v1 → runsc.
  • Kubernetes installiert nichts: Binary und containerd-Eintrag gehören auf jeden Node, auf dem solche Pods laufen sollen.
Pod (runtimeClassName: gvisor)
  -> RuntimeClass gvisor (handler: runsc)
     -> containerd ...runtimes.runsc (runtime_type io.containerd.runsc.v1)
        -> Sentry (eigener "Kernel") -> wenige Syscalls -> Node-Kernel

Vorbereitung auf cp1:

mkdir -p ~/cks/tag11 && cd ~/cks/tag11
k create ns tag11
k config set-context --current --namespace=tag11
k get runtimeclass

Erwartet: No resources found

Drill 1: gVisor installieren

Auf worker1 (ssh [email protected]), danach genauso auf worker2. Seit 2026 kommt gVisor als Archiv: runsc, der containerd-Shim und ein Ordner gvisor-bin/, der neben runsc liegen muss. Version fest statt latest, mit Prüfsumme:

cd /tmp
V=20261116.0
ARCH=$(uname -m)
U=https://storage.googleapis.com/gvisor/releases/release/$V/${ARCH}
curl -sSfLO $U/gvisor.tar.zstd
curl -sSfLO $U/gvisor.tar.zstd.sha512
sha512sum -c gvisor.tar.zstd.sha512
tar --zstd -tf gvisor.tar.zstd
sudo tar --zstd -xf gvisor.tar.zstd -C /usr/local/bin
rm gvisor.tar.zstd gvisor.tar.zstd.sha512
runsc --version

Erwartet:

gvisor.tar.zstd: OK
gvisor-bin/
runsc
containerd-shim-runsc-v1
gvisor-bin/checkpointgofer
gvisor-bin/runsc-metric-server
gvisor-bin/runsc-netgofer
gvisor-bin/runsc-fd-parking
gvisor-bin/gvisor-sentry-prewarmer
gvisor-bin/gvisor-proc-umounter
gvisor-bin/gvisor_sentry
runsc version release-20261116.0
spec: 1.2.1

Das .bz2-Archiv bräuchte bzip2, das auf Ubuntu-Servern fehlt – zstd ist da. Alternative für Produktion: das apt-Repository von gVisor (Paket runsc).

Fortschritt speichern? Kostenlos registrieren

Drill 2: Runtime-Handler in containerd eintragen

containerd 2.4 schreibt seine Konfiguration als version = 4; die CRI-Runtimes stehen unter dem Plugin io.containerd.cri.v1.runtime (in containerd 1.x hieß es io.containerd.grpc.v1.cri). Erst nachsehen, dann mit Sicherung anhängen – auf beiden Workern:

sudo head -1 /etc/containerd/config.toml
sudo grep -n 'runtimes\.' /etc/containerd/config.toml
sudo cp -p /etc/containerd/config.toml /etc/containerd/config.toml.tag11
sudo tee -a /etc/containerd/config.toml <<'EOF'

[plugins.'io.containerd.cri.v1.runtime'.containerd.runtimes.runsc]
  runtime_type = 'io.containerd.runsc.v1'
EOF
sudo systemctl restart containerd
systemctl is-active containerd
sudo crictl info | jq -r '.config.containerd.runtimes | keys[]'

Erwartet:

version = 4
64:        [plugins.'io.containerd.cri.v1.runtime'.containerd.runtimes.runc]
80:          [plugins.'io.containerd.cri.v1.runtime'.containerd.runtimes.runc.options]

[plugins.'io.containerd.cri.v1.runtime'.containerd.runtimes.runsc]
  runtime_type = 'io.containerd.runsc.v1'
active
runc
runsc

Der Name runsc hinter runtimes. ist der Handler-Name für Kubernetes. io.containerd.runsc.v1 sagt containerd, dass es containerd-shim-runsc-v1 im PATH suchen soll. Laufende Container überstehen den Neustart von containerd; prüfe trotzdem auf cp1:

k get nodes
k get pods -A --no-headers | grep -v -E 'Running|Completed'

Erwartet: alle Nodes Ready, keine weiteren Zeilen.

Fortschritt speichern? Kostenlos registrieren

Drill 3: RuntimeClass und erster Sandbox-Pod

Auf cp1:

cat > rc.yaml <<'EOF'
apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
  name: gvisor
handler: runsc
EOF
k apply -f rc.yaml
k get runtimeclass
cat > sandbox.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: sandbox
spec:
  runtimeClassName: gvisor
  containers:
  - name: c
    image: busybox:1.37
    command: ["sleep", "1d"]
EOF
k apply -f sandbox.yaml
k wait --for=condition=Ready pod/sandbox
k get pod sandbox -o wide | awk '{print $1, $3, $7}'

Erwartet:

runtimeclass.node.k8s.io/gvisor created
NAME     HANDLER   AGE
gvisor   runsc     0s
pod/sandbox created
pod/sandbox condition met
NAME STATUS NODE
sandbox Running worker2

RuntimeClass ist cluster-weit (kein Namespace) und hat keine k create-Kurzform – das YAML steht in der Doku unter „Runtime Class“.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Nachweis – anderer Kernel

k exec sandbox -- dmesg
k exec sandbox -- uname -r
k run normal --image=busybox:1.37 --overrides='{"spec":{"nodeName":"worker2"}}' \
  -- sleep 1d
k wait --for=condition=Ready pod/normal
k exec normal -- uname -r
k exec normal -- dmesg

Erwartet (gekürzt, die Sprüche wechseln):

[   0.000000] Starting gVisor...
[   0.534806] Granting licence to kill(2)...
[   0.553271] Accelerating teletypewriter to 9600 baud...
...
[   2.151784] Ready!
4.19.0-gvisor
pod/normal condition met
6.8.0-149-generic
dmesg: klogctl: Operation not permitted
command terminated with exit code 1

Im Sandbox-Pod antwortet der gVisor-Kernel (4.19.0-gvisor), im normalen Pod der echte Ubuntu-Kernel des Nodes. Von außen, auf dem Node des Sandbox-Pods (hier worker2):

ps -C sleep -o pid,args
ps -eo comm | grep -E 'runsc|gvisor' | sort | uniq -c
sudo crictl pods --name sandbox -o json | grep -i runtimeHandler

Erwartet (gekürzt):

    PID COMMAND
  27743 sleep 1d
      8 gvisor_sentry
      2 runsc
      1 runsc-fd-parkin
      "runtimeHandler":  "runsc"

Nur ein sleep 1d – der des normalen Pods. Der Prozess im Sandbox-Pod existiert für den Host-Kernel nicht, er lebt in gvisor_sentry.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Fehlerbilder

k create -f - <<'EOF'
apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
  name: tag11-kaputt
handler: kata
EOF
k run kaputt --image=busybox:1.37 \
  --overrides='{"spec":{"runtimeClassName":"tag11-kaputt"}}' -- sleep 1d
k run fehlt --image=busybox:1.37 \
  --overrides='{"spec":{"runtimeClassName":"gibtsnicht"}}' -- sleep 1d
k get pod kaputt -w            # Strg+C nach etwa 15 s
k get events --field-selector involvedObject.name=kaputt,reason=FailedCreatePodSandBox \
  -o jsonpath='{.items[0].message}{"\n"}'

Erwartet (gekürzt):

runtimeclass.node.k8s.io/tag11-kaputt created
pod/kaputt created
Error from server (Forbidden): pods "fehlt" is forbidden: pod rejected: RuntimeClass
"gibtsnicht" not found
NAME     READY   STATUS              RESTARTS   AGE
kaputt   0/1     ContainerCreating   0          15s
Failed to create pod sandbox: rpc error: code = Unknown desc = unable to get OCI runtime
for sandbox "8946f2c7…": no runtime for "kata" is configured

Fehlt die RuntimeClass, lehnt der API-Server ab. Fehlt der Handler auf dem Node, hängt der Pod in ContainerCreating – die Ursache steht nur in den Events. Aufräumen:

k delete pod kaputt --now
k delete runtimeclass tag11-kaputt

Fortschritt speichern? Kostenlos registrieren

Drill 6: Eine echte App in der Sandbox

k create secret generic notes-key --from-literal=NOTES_API_KEY=lab-key-123
k create deploy notes --image=172.16.0.126:30500/notes-api:1.0 --replicas=2 \
  $do > notes.yaml
sed -i 's/^    spec:/&\n      runtimeClassName: gvisor/' notes.yaml
k apply -f notes.yaml
k set env deploy/notes --from=secret/notes-key
k rollout status deploy/notes
k expose deploy notes --port=8080
k get pods -l app=notes -o wide | awk '{print $1, $3, $7}'
k exec normal -- wget -qO- -T5 http://notes:8080/healthz; echo
k exec deploy/notes -- uname -r

Erwartet (gekürzt):

deployment "notes" successfully rolled out
service/notes exposed
NAME STATUS NODE
notes-5ddf68d9ff-4p62s Running worker2
notes-5ddf68d9ff-cjzsh Running worker1
ok
4.19.0-gvisor

runtimeClassName gehört ins Pod-Template (spec.template.spec). Netz, DNS, Service und Cilium funktionieren unverändert; gVisor bringt seinen eigenen Netzwerk-Stack mit, die Pakete verlassen die Sandbox über das normale veth-Interface.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Scheduling in der RuntimeClass

cp1 hat kein gVisor. Damit Sandbox-Pods nie auf einem Node ohne Handler landen, trägt die RuntimeClass selbst einen nodeSelector (und bei Bedarf tolerations):

k label node worker1 sandbox=gvisor
k patch runtimeclass gvisor --type=merge \
  -p '{"scheduling":{"nodeSelector":{"sandbox":"gvisor"}}}'
k rollout restart deploy/notes
k rollout status deploy/notes
k get pods -l app=notes \
  -o custom-columns=NAME:.metadata.name,NODE:.spec.nodeName,SEL:.spec.nodeSelector

Erwartet (gekürzt):

node/worker1 labeled
runtimeclass.node.k8s.io/gvisor patched
deployment "notes" successfully rolled out
NAME                     NODE      SEL
notes-679466cd77-dzxpx   worker1   map[sandbox:gvisor]
notes-679466cd77-w9hvq   worker1   map[sandbox:gvisor]

Der Admission-Controller RuntimeClass mischt den Selektor beim Anlegen in jeden Pod. Beide Pods landen jetzt auf worker1, weil nur er das Label hat. worker2 hat gVisor auch:

k label node worker2 sandbox=gvisor
k get nodes -L sandbox

Erwartet:

node/worker2 labeled
NAME      STATUS   ROLES           AGE   VERSION   SANDBOX
cp1       Ready    control-plane   97m   ...
worker1   Ready    <none>          95m   ...       gvisor
worker2   Ready    <none>          95m   ...       gvisor

Fortschritt speichern? Kostenlos registrieren

Drill 8: Grenzen

k run hp --image=busybox:1.37 \
  --overrides='{"spec":{"runtimeClassName":"gvisor","hostPID":true}}' -- sleep 1d
k wait --for=condition=Ready pod/hp
k exec hp -- ps -o pid,args
k patch runtimeclass gvisor --type=merge -p '{"handler":"runc"}'
k delete pod hp --now

Erwartet (gekürzt):

pod/hp condition met
PID   COMMAND
    1 /pause
    2 sleep 1d
    3 ps -o pid,args
The RuntimeClass "gvisor" is invalid: handler: ... field is immutable

hostPID wird angenommen, aber der Pod sieht trotzdem nur seine Sandbox. Was gVisor nicht kann oder schlecht kann:

  • Host-Zugriffe (Host-Namespaces, Geräte, Kernel-Module) – CNI-, CSI-, Monitoring-Pods bleiben bei runc.
  • Nicht jeder Syscall ist umgesetzt; I/O- und syscall-lastige Apps werden langsamer, jeder Pod braucht mehr Speicher (overhead.podFixed in der RuntimeClass rechnet das ins Scheduling ein).
  • Host-Werkzeuge, die Syscalls per eBPF beobachten (Tag 16, 17), sehen nur die Sentry, nicht die Prozesse im Pod.
  • Der Handler einer RuntimeClass ist unveränderlich – Wechsel heißt löschen und neu anlegen.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Welche Runtime-Handler kennt containerd auf worker1? Zeitziel: 1 min
  2. Pod sb (busybox:1.37, sleep 1d) in gVisor starten und es mit einem Befehl im Pod beweisen. Zeitziel: 1 min
  3. Liste alle Pods im Cluster mit ihrer RuntimeClass. Zeitziel: 1 min

Lösung

ssh [email protected] \
  "sudo crictl info | jq -r '.config.containerd.runtimes | keys[]'"
k run sb --image=busybox:1.37 \
  --overrides='{"spec":{"runtimeClassName":"gvisor"}}' -- sleep 1d
k wait --for=condition=Ready pod/sb
k exec sb -- dmesg | head -1
k get pods -A -o custom-columns=\
NS:.metadata.namespace,NAME:.metadata.name,RC:.spec.runtimeClassName | grep -v '<none>'

Erwartet (gekürzt):

runc
runsc
pod/sb condition met
[   0.000000] Starting gVisor...
NS                   NAME                                      RC
tag11                notes-679466cd77-dzxpx                    gvisor
tag11                notes-679466cd77-w9hvq                    gvisor
tag11                sandbox                                   gvisor
tag11                sb                                        gvisor

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

ssh [email protected] 'runsc --version | head -1'

Erwartet: runsc version release-20261116.0 (auf 172.16.0.228 genauso).

k get runtimeclass gvisor -o jsonpath='{.handler} {.scheduling.nodeSelector}{"\n"}'

Erwartet: runsc {"sandbox":"gvisor"}

k get nodes -l sandbox=gvisor

Erwartet: worker1 und worker2.

k get ns tag11 tag11-ch

Erwartet (nach dem Aufräumen): zweimal NotFound.

Im Labor bleiben: gVisor (/usr/local/bin/runsc, Shim, gvisor-bin/) und der containerd-Eintrag runsc auf beiden Workern, die RuntimeClass gvisor mit nodeSelector sowie das Label sandbox=gvisor auf beiden Workern. Tag 19 nutzt sie.

Challenge

Im Namespace tag11-ch läuft ein Webserver (unten). Er soll ab sofort in gVisor laufen, über eine neue RuntimeClass tag11-untrusted. Beweise für jeden Pod, dass er in der Sandbox läuft.

k create ns tag11-ch
k -n tag11-ch create deploy web --image=busybox:1.37 --replicas=2 \
  -- httpd -f -p 8080

Hinweis: Ein Patch auf das Pod-Template erzwingt den Rollout von selbst.

Lösung

k create -f - <<'EOF'
apiVersion: node.k8s.io/v1
kind: RuntimeClass
metadata:
  name: tag11-untrusted
handler: runsc
EOF
k -n tag11-ch patch deploy web \
  -p '{"spec":{"template":{"spec":{"runtimeClassName":"tag11-untrusted"}}}}'
k -n tag11-ch rollout status deploy/web
k -n tag11-ch get pods -o custom-columns=\
NAME:.metadata.name,RC:.spec.runtimeClassName,NODE:.spec.nodeName
for p in $(k -n tag11-ch get pods -l app=web -o name); do
  k -n tag11-ch exec $p -- dmesg | head -1
done

Erwartet (gekürzt, nachdem die alten Pods weg sind):

deployment "web" successfully rolled out
NAME                  RC                NODE
web-5745ffc6b-rpcmf   tag11-untrusted   worker2
web-5745ffc6b-rrg8t   tag11-untrusted   worker1
[   0.000000] Starting gVisor...
[   0.000000] Starting gVisor...

Aufräumen (die RuntimeClass gvisor bleibt):

k config set-context --current --namespace=default
k delete ns tag11 tag11-ch
k delete runtimeclass tag11-untrusted

Fortschritt speichern? Kostenlos registrieren

Prüfungstipp

  • In der Prüfung ist gVisor meist schon installiert: handler aus der containerd-Config ablesen (runtimes.<name>), RuntimeClass anlegen, runtimeClassName ins Pod-Template. Den Nachweis per dmesg oder uname -r im Pod nicht vergessen.
  • Steht ein Pod in ContainerCreating, sagen die Events, ob der Handler auf diesem Node fehlt. Nach einer containerd-Änderung immer systemctl restart containerd.
  • Doku: kubernetes.io → Concepts → Containers → „Runtime Class“; gvisor.dev → „Containerd Quick Start“.

Enterprise-Notiz

  • Verwaltete Angebote: GKE Sandbox (gVisor), AKS Pod Sandboxing und Kata Containers (leichte VMs statt Sentry) – gleiche RuntimeClass-Mechanik, anderer Handler.
  • Sandboxing lohnt für fremden oder unsicheren Code: Build-Jobs, Kunden-Plugins, Multi-Tenant-Plattformen. Für eigene, geprüfte Dienste ist der Aufpreis meist zu hoch.
  • Node-Pools mit Sandbox per Label und Taint trennen; die RuntimeClass bringt passenden nodeSelector und tolerations mit.
  • Admission-Regeln (Kyverno, ValidatingAdmissionPolicy) können runtimeClassName für bestimmte Namespaces erzwingen.
  • gVisor regelmäßig aktualisieren wie jede Laufzeit – Release-Kanal und Prüfsumme festhalten.