Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang B: Probeprüfung

Ziel: Du löst 17 Aufgaben im Stil der CKS in 120 Minuten und bewertest dich selbst. · Dauer: 120 min · Voraussetzung: Tag 0–19

Spielregeln

  • Zeit: 120 Minuten, Uhr stellen. Jede Aufgabe hat ein Gewicht in Prozent, zusammen 100 %, verteilt wie die Lehrplanbereiche der CKS (15/15/10/20/20/20 %). Als bestanden gelten hier 67 % – nach aktuellem Stand auch die Grenze der echten Prüfung; maßgeblich ist https://training.linuxfoundation.org.
  • Erlaubt: die Kubernetes-Doku (kubernetes.io/docs, kubernetes.io/blog), k explain und -h der Werkzeuge. In der echten Prüfung kommt die Doku einzelner Werkzeuge dazu (etwa falco.org/docs) – welche genau, steht in den aktuellen Prüfungshinweisen der Linux Foundation. Nicht erlaubt: dieses Buch während der Zeit.
  • Jede Aufgabe hat ihren eigenen Namespace pruef-NN. Gib ihn bei jedem Befehl mit -n an – wie in der Prüfung, in der jede Aufgabe einen anderen Kontext verlangt.
  • Dateien gehören nach ~/cks/pruef. Aufgabe 2, 6 und 15 ändern die Control Plane: vorher sichern, nachher k get --raw /readyz und k get nodes.
  • Die Lösungen stehen am Ende. Erst nach Ablauf der Zeit lesen.

Vorbereitung

Alle Befehle auf cp1. Namespaces, Arbeitsverzeichnis, Sicherungsordner:

mkdir -p ~/cks/pruef/backup ~/cks/pruef/03 && cd ~/cks/pruef
for i in $(seq -w 1 17); do k create ns pruef-$i; done

Für Aufgabe 1 eine API und zwei Clients:

k create deployment api -n pruef-01 --image=172.16.0.126:30500/notes-api:1.0 \
  --port=8080
k set env deploy/api -n pruef-01 NOTES_API_KEY=lab-key-123
k expose deploy api -n pruef-01 --port=8080
k run web -n pruef-01 --image=busybox:1.37 -l app=web -- sleep 3600
k run test -n pruef-01 --image=busybox:1.37 -- sleep 3600

Für Aufgabe 2 drei Abweichungen vom CIS-Benchmark:

sudo chmod 644 /etc/kubernetes/manifests/kube-scheduler.yaml
sudo chmod 644 /etc/kubernetes/controller-manager.conf
sudo chown root:root /var/lib/etcd

Für Aufgabe 3 ein Shop ohne TLS und zwei Binaries, eines davon verändert:

k create deployment shop -n pruef-03 --image=nginx:1.29-alpine-slim --port=80
k expose deploy shop -n pruef-03 --port=80
cd ~/cks/pruef/03
ARCH=$(dpkg --print-architecture)
U=https://dl.k8s.io/release/v1.37.2/bin/linux/${ARCH}
curl -sSLO $U/kubectl
curl -sSLO $U/kubeadm
echo >> kubeadm
chmod +x kubectl kubeadm
cd ~/cks/pruef

Für Aufgabe 4 ein ServiceAccount mit Vollzugriff im Namespace:

k create sa ci -n pruef-04
k create role ci -n pruef-04 --verb='*' --resource='*.*'
k create rolebinding ci -n pruef-04 --role=ci --serviceaccount=pruef-04:ci
k create configmap app-config -n pruef-04 --from-literal=LOG_LEVEL=info
k create configmap other -n pruef-04 --from-literal=x=1
k create secret generic db -n pruef-04 --from-literal=password=Lab-Pruef-04

Für Aufgabe 5 ein Frontend mit dem Default-ServiceAccount:

k create deployment frontend -n pruef-05 --image=busybox:1.37 -- sleep 3600

Für Aufgabe 6 eine Lücke im API-Server (Sicherung zuerst, danach 1–2 min warten, bis k get --raw /readyz wieder ok meldet):

k create sa viewer -n pruef-06
M=/etc/kubernetes/manifests
sudo cp $M/kube-apiserver.yaml ~/cks/pruef/backup/kube-apiserver.yaml.orig
sudo sed -i 's/--authorization-mode=Node,RBAC$/&,AlwaysAllow/' $M/kube-apiserver.yaml

Für Aufgabe 7 und 8 ein Archiv-Dienst und ein Build-Pod:

k create deployment archiv -n pruef-07 --image=busybox:1.37 -- sleep 3600
cat > 08-builder.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
  name: builder
  namespace: pruef-08
spec:
  securityContext:
    seccompProfile:
      type: Localhost
      localhostProfile: no-mkdir.json
  containers:
  - name: builder
    image: busybox:1.37
    command: ["sleep", "3600"]
EOF
k apply -f 08-builder.yaml

Für Aufgabe 9 eine API und ein Debug-Pod mit Blick auf die Host-Prozesse:

k create deployment api -n pruef-09 --image=172.16.0.126:30500/notes-api:1.0 \
  --port=8080
k set env deploy/api -n pruef-09 NOTES_API_KEY=lab-key-123
k apply -f - <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: debug
  namespace: pruef-09
spec:
  selector:
    matchLabels:
      app: debug
  template:
    metadata:
      labels:
        app: debug
    spec:
      hostPID: true
      containers:
      - name: busybox
        image: busybox:1.37
        command: ["sleep", "3600"]
EOF

Für Aufgabe 10 ein Passwort in einer ConfigMap (Lab-Pruef-10 ist ein reiner Lab-Wert):

k create configmap db-config -n pruef-10 --from-literal=DB_HOST=db.pruef-10 \
  --from-literal=DB_PASSWORD=Lab-Pruef-10
k create deployment app -n pruef-10 --image=busybox:1.37 -- sleep 3600
k set env deploy/app -n pruef-10 --from=configmap/db-config

Für Aufgabe 11 ein Parser für fremde Dateien:

k apply -f - <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: parser
  namespace: pruef-11
spec:
  selector:
    matchLabels:
      app: parser
  template:
    metadata:
      labels:
        app: parser
    spec:
      runtimeClassName: sandbox
      containers:
      - name: busybox
        image: busybox:1.37
        command: ["sleep", "3600"]
EOF

Für Aufgabe 12 drei Deployments mit unterschiedlich alten Images:

k create deployment cache -n pruef-12 --image=redis:7.0.0-alpine
k create deployment web -n pruef-12 --image=httpd:2.4.54-alpine
k create deployment api -n pruef-12 --image=172.16.0.126:30500/notes-api:1.0
k set env deploy/api -n pruef-12 NOTES_API_KEY=lab-key-123

Für Aufgabe 13 ein Manifest, das noch nicht angewendet ist:

cat > 13-api.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
  namespace: pruef-13
spec:
  replicas: 1
  selector:
    matchLabels:
      app: api
  template:
    metadata:
      labels:
        app: api
    spec:
      containers:
      - name: notes-api
        image: 172.16.0.126:30500/notes-api:1.0
        env:
        - name: NOTES_API_KEY
          value: lab-key-123
        securityContext:
          privileged: true
          capabilities:
            add: ["SYS_ADMIN"]
EOF

Für Aufgabe 14 ein Deployment mit latest:

k create deployment web -n pruef-14 --image=nginx:latest

Für Aufgabe 15 verschwindet eine ConfigMap:

k create configmap feature-flags -n pruef-15 --from-literal=beta=true
k create sa cleanup -n pruef-15
k create role cleanup -n pruef-15 --verb=get,list,delete --resource=configmaps
k create rolebinding cleanup -n pruef-15 --role=cleanup \
  --serviceaccount=pruef-15:cleanup
T=$(k create token cleanup -n pruef-15 --duration=10m)
curl -s --cacert /etc/kubernetes/pki/ca.crt -H "Authorization: Bearer $T" -X DELETE \
  https://172.16.0.126:6443/api/v1/namespaces/pruef-15/configmaps/feature-flags \
  > /dev/null

Für Aufgabe 16 zwei Deployments, eines davon mit Paketmanager im Dauerlauf:

k create deployment updater -n pruef-16 --image=alpine:3.23 -- \
  sh -c 'while true; do apk --version > /dev/null; sleep 15; done'
k create deployment web -n pruef-16 --image=nginx:1.29-alpine-slim

Für Aufgabe 17 drei Deployments, eines davon mit blindem Passagier:

k create deployment api -n pruef-17 --image=172.16.0.126:30500/notes-api:1.0
k set env deploy/api -n pruef-17 NOTES_API_KEY=lab-key-123
k create deployment web -n pruef-17 --image=nginx:1.29-alpine-slim
k expose deploy web -n pruef-17 --port=80
k create deployment metrics -n pruef-17 --image=busybox:1.37 -- sh -c \
  'mkdir -p /tmp/.x && printf "#!/bin/sh\nnc -lk -p 4444\n" > /tmp/.x/kworkerd &&
  chmod +x /tmp/.x/kworkerd && /tmp/.x/kworkerd & sleep 3600'

Eine Minute warten, bis alles läuft. Uhr starten.

Aufgabe 1: Default Deny mit Ausnahme (6 %)

Namespace pruef-01. Kein Pod im Namespace darf Verbindungen annehmen oder aufbauen – in beide Richtungen gilt Default Deny. Ausnahmen: Alle Pods dürfen DNS in kube-system erreichen, und Pods mit app=web dürfen die Pods von api auf TCP 8080 erreichen. Teste mit web und test.

Aufgabe 2: CIS-Benchmark (5 %)

Prüfe die Control Plane auf cp1 mit kube-bench (Benchmark cis-1.12). Behebe alle FAIL in Gruppe 1.1 (Dateien der Control Plane) und weise nach, dass diese Checks jetzt bestehen. Die übrigen Gruppen bleiben, wie sie sind.

Aufgabe 3: TLS am Ingress, Binaries prüfen (4 %)

Namespace pruef-03. Mache den Service shop über Traefik unter https://shop.pruef.lab:30443 erreichbar – mit einem selbst signierten Zertifikat für shop.pruef.lab im TLS-Secret shop-tls. curl mit --cacert liefert 200. In ~/cks/pruef/03 liegen kubectl und kubeadm v1.37.2: Lösche das Binary, das nicht dem offiziellen Release entspricht.

Aufgabe 4: RBAC minimieren (6 %)

Namespace pruef-04. Der ServiceAccount ci darf nur noch Pods lesen (get, list, watch) und die ConfigMap app-config holen (get) – keine andere ConfigMap, keine Secrets, nichts sonst. Beweise es mit k auth can-i.

Aufgabe 5: Kein Token im Frontend (4 %)

Namespace pruef-05. Das Deployment frontend spricht nie mit der Kubernetes-API. Es soll einen eigenen ServiceAccount frontend nutzen und kein Token mehr eingebunden bekommen. Auch neue Pods mit dem Default-ServiceAccount des Namespace bekommen keins.

Aufgabe 6: Wer hat das erlaubt? (5 %)

Der ServiceAccount viewer in pruef-06 hat keine einzige Rollenbindung, darf aber clusterweit Secrets lesen. Finde die Ursache am API-Server und behebe sie, ohne andere Flags zu ändern.

Aufgabe 7: AppArmor (5 %)

Namespace pruef-07. Auf beiden Workern ist ein AppArmor-Profil geladen, das jeden Schreibzugriff verbietet. Das Deployment archiv soll damit laufen. Beweise, dass der Container das Profil nutzt und nicht schreiben kann.

Aufgabe 8: seccomp (5 %)

Namespace pruef-08. Der Pod builder startet nicht. Er soll mit dem seccomp-Profil no-mkdir.json laufen, das auf den Workern unter /var/lib/kubelet/seccomp/profiles liegt. Repariere ihn und beweise, dass mkdir scheitert.

Aufgabe 9: Pod Security Standards (8 %)

Namespace pruef-09. Der Namespace erzwingt ab sofort den Standard restricted und warnt bei Verstößen dagegen. Das Deployment api läuft danach konform weiter und beantwortet /healthz. Workloads, die Host-Namensräume nutzen, haben im Namespace nichts mehr verloren.

Aufgabe 10: Passwort raus aus der ConfigMap (6 %)

Namespace pruef-10. Das Datenbank-Passwort steht in der ConfigMap db-config. Verschiebe es in das Secret db-pass (Schlüssel DB_PASSWORD); das Deployment app bekommt DB_PASSWORD von dort, DB_HOST weiter aus der ConfigMap. Beweise mit etcdctl, dass die ConfigMap in etcd kein Passwort mehr enthält und das Secret verschlüsselt liegt. Schreibe die ersten 23 Byte des Secrets aus etcd nach ~/cks/pruef/10-etcd.txt.

Aufgabe 11: Sandbox (6 %)

Namespace pruef-11. Das Deployment parser verarbeitet fremde Dateien und soll in der vorhandenen gVisor-Sandbox laufen. Es kommt nicht hoch. Repariere es und beweise, dass der Container in gVisor läuft.

Aufgabe 12: Kritische Images (7 %)

Namespace pruef-12. Kein laufendes Image darf Lücken mit Schweregrad CRITICAL haben. Stelle cache auf redis:8.2-alpine um (prüfe es vorher). Jedes andere betroffene Deployment skalierst du auf 0 und schreibst sein Image nach ~/cks/pruef/12-critical.txt.

Aufgabe 13: Statische Analyse (6 %)

Das Manifest ~/cks/pruef/13-api.yaml ist noch nicht angewendet. Überarbeite es, bis kubesec keine kritischen Befunde mehr meldet und mindestens 10 Punkte vergibt. Wende es dann an; api beantwortet /healthz.

Aufgabe 14: Keine Images ohne Tag (7 %)

Lege eine ValidatingAdmissionPolicy pruef-14-image-tag mit gleichnamigem Binding an, die nur in pruef-14 gilt: Pods, deren Container ein Image ohne Tag oder mit :latest nutzen, werden abgelehnt; Images mit Digest (@sha256:) sind erlaubt. Das Deployment web läuft danach mit nginx:1.29-alpine-slim.

Aufgabe 15: Audit-Log (7 %)

Jemand hat die ConfigMap feature-flags in pruef-15 gelöscht. Schreibe den Benutzernamen nach ~/cks/pruef/15-wer.txt. Erweitere dann die Audit-Policy: Änderungen (create, update, patch, delete) an ConfigMaps in pruef-15 landen mit Level RequestResponse im Log, alle anderen ConfigMaps bleiben bei Metadata. Lege feature-flags mit beta=false neu an und weise den Inhalt im Audit-Log nach.

Aufgabe 16: Falco-Regel (7 %)

Lege für Falco eine Regel Paketmanager im Container an: Priorität WARNING, sie schlägt an, wenn in einem Container apk, apt, apt-get, dpkg, yum oder dnf startet. Ausgabe: %evt.time,%k8s.ns.name,%k8s.pod.name,%proc.name. Finde damit den Pod in pruef-16, schreibe namespace/pod nach ~/cks/pruef/16-befund.txt und skaliere seinen Besitzer auf 0.

Aufgabe 17: Blinder Passagier, unveränderliche Container (6 %)

Namespace pruef-17. Einer der drei Pods startet ein Programm, das er zur Laufzeit selbst angelegt hat, und lauscht auf einem Port, den keiner bestellt hat. Sichere sein YAML und das Programm nach ~/cks/pruef/17-evidence/ und skaliere den Besitzer auf 0. api und web laufen danach mit schreibgeschütztem Root-Dateisystem und bleiben erreichbar.

Uhr stoppen.

Lösungen

Alle Lösungen auf cp1 im Ordner ~/cks/pruef, außer wo ssh steht.

Lösung 1

Vier Policies: Deny für beide Richtungen, DNS für alle, und die Ausnahme zweimal – als Egress bei web und als Ingress bei api.

cat > 01-netpol.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: pruef-01
spec:
  podSelector: {}
  policyTypes:
  - Ingress
  - Egress
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: allow-dns
  namespace: pruef-01
spec:
  podSelector: {}
  policyTypes:
  - Egress
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: kube-system
      podSelector:
        matchLabels:
          k8s-app: kube-dns
    ports:
    - port: 53
      protocol: UDP
    - port: 53
      protocol: TCP
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: web-to-api
  namespace: pruef-01
spec:
  podSelector:
    matchLabels:
      app: web
  policyTypes:
  - Egress
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: api
    ports:
    - port: 8080
      protocol: TCP
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: api-from-web
  namespace: pruef-01
spec:
  podSelector:
    matchLabels:
      app: api
  policyTypes:
  - Ingress
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: web
    ports:
    - port: 8080
      protocol: TCP
EOF
k apply -f 01-netpol.yaml
k exec -n pruef-01 web -- wget -qO- -T3 api:8080/healthz; echo
k exec -n pruef-01 test -- wget -qO- -T3 api:8080/healthz
k exec -n pruef-01 web -- wget -qO- -T3 http://172.16.0.126:30080/
k exec -n pruef-01 test -- nslookup api | grep -A1 Name

Erwartet:

networkpolicy.networking.k8s.io/default-deny created
networkpolicy.networking.k8s.io/allow-dns created
networkpolicy.networking.k8s.io/web-to-api created
networkpolicy.networking.k8s.io/api-from-web created
ok
wget: download timed out
command terminated with exit code 1
wget: download timed out
command terminated with exit code 1
Name:   api.pruef-01.svc.cluster.local
Address: 10.101.170.45

Vorher kamen beide Clients an api und web an Traefik. Die letzte Zeile zeigt: DNS geht trotz Default Deny – ohne allow-dns scheitert schon die Namensauflösung.

Lösung 2

sudo kube-bench run --targets=master --benchmark=cis-1.12 --group=1.1 \
  > 02-vorher.txt 2>&1
grep '^\[FAIL\]' 02-vorher.txt | cut -c1-70
grep -A3 -E '^1\.1\.(5|12|17) ' 02-vorher.txt

Erwartet (gekürzt):

[FAIL] 1.1.5 Ensure that the scheduler pod specification file permissi
[FAIL] 1.1.12 Ensure that the etcd data directory ownership is set to
[FAIL] 1.1.17 Ensure that the controller-manager.conf file permissions
1.1.5 Run the below command (based on the file location on your system) on the …
For example, chmod 600 /etc/kubernetes/manifests/kube-scheduler.yaml
…
1.1.12 On the etcd server node, get the etcd data directory, passed as an argument …
…
For example, chown etcd:etcd /var/lib/etcd
--
1.1.17 Run the below command (based on the file location on your system) on the …
For example,
chmod 600 /etc/kubernetes/controller-manager.conf
sudo chmod 600 /etc/kubernetes/manifests/kube-scheduler.yaml
sudo chmod 600 /etc/kubernetes/controller-manager.conf
sudo chown etcd:etcd /var/lib/etcd
sudo kube-bench run --targets=master --benchmark=cis-1.12 --check=1.1.5,1.1.12,1.1.17 \
  2>/dev/null | grep -E '^\[(PASS|FAIL)' | cut -c1-70

Erwartet:

[PASS] 1.1.5 Ensure that the scheduler pod specification file permissi
[PASS] 1.1.12 Ensure that the etcd data directory ownership is set to
[PASS] 1.1.17 Ensure that the controller-manager.conf file permissions

Rechte und Besitzer zu ändern startet keine Komponente neu – nur ein geänderter Inhalt im Manifest-Ordner tut das.

Lösung 3

openssl req -x509 -newkey rsa:2048 -nodes -days 365 \
  -keyout 03-shop.key -out 03-shop.crt -subj "/CN=shop.pruef.lab" \
  -addext "subjectAltName=DNS:shop.pruef.lab"
k create secret tls shop-tls -n pruef-03 --cert=03-shop.crt --key=03-shop.key
k create ingress shop -n pruef-03 --class=traefik \
  --rule="shop.pruef.lab/*=shop:80,tls=shop-tls"
curl -s -o /dev/null -w "%{http_code}\n" --cacert 03-shop.crt \
  --resolve shop.pruef.lab:30443:172.16.0.126 https://shop.pruef.lab:30443/
curl -sv --cacert 03-shop.crt --resolve shop.pruef.lab:30443:172.16.0.126 \
  https://shop.pruef.lab:30443/ -o /dev/null 2>&1 | grep -E "subject:|verify ok"

Erwartet (gekürzt):

secret/shop-tls created
ingress.networking.k8s.io/shop created
200
*  subject: CN=shop.pruef.lab
*  SSL certificate verify ok.

verify ok heißt: Traefik liefert wirklich das Zertifikat aus shop-tls, nicht sein eigenes Standardzertifikat. Dann die Binaries gegen die offiziellen Prüfsummen:

cd ~/cks/pruef/03
./kubectl version --client
ARCH=$(dpkg --print-architecture)
U=https://dl.k8s.io/release/v1.37.2/bin/linux/${ARCH}
echo "$(curl -sSL $U/kubectl.sha512)  kubectl" | sha512sum -c
echo "$(curl -sSL $U/kubeadm.sha512)  kubeadm" | sha512sum -c
rm kubeadm
cd ~/cks/pruef

Erwartet:

Client Version: v1.37.2
kubectl: OK
kubeadm: FAILED
sha512sum: WARNING: 1 computed checksum did NOT match

Die Versionsangabe allein beweist nichts – ein manipuliertes Binary meldet dieselbe Version. Nur die Prüfsumme zählt.

Lösung 4

--resource-name gilt bei k create role für alle Regeln. Zwei Regeln mit unterschiedlichen Namen gehen nur per YAML:

cat > 04-role.yaml <<'EOF'
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata:
  name: ci
  namespace: pruef-04
rules:
- apiGroups: [""]
  resources: ["pods"]
  verbs: ["get", "list", "watch"]
- apiGroups: [""]
  resources: ["configmaps"]
  resourceNames: ["app-config"]
  verbs: ["get"]
EOF
k replace -f 04-role.yaml
SA=system:serviceaccount:pruef-04:ci
k auth can-i list pods -n pruef-04 --as=$SA
k auth can-i get configmap/app-config -n pruef-04 --as=$SA
k auth can-i get configmap/other -n pruef-04 --as=$SA
k auth can-i list configmaps -n pruef-04 --as=$SA
k auth can-i get secrets -n pruef-04 --as=$SA
k auth can-i delete pods -n pruef-04 --as=$SA

Erwartet:

role.rbac.authorization.k8s.io/ci replaced
yes
yes
no
no
no
no

list configmaps ist no, obwohl app-config erlaubt ist: resourceNames wirkt nicht bei list und watch. Genau das verlangt die Aufgabe.

Lösung 5

k create sa frontend -n pruef-05
k patch sa frontend -n pruef-05 -p '{"automountServiceAccountToken":false}'
k patch sa default -n pruef-05 -p '{"automountServiceAccountToken":false}'
k set serviceaccount deploy frontend frontend -n pruef-05
k rollout status -n pruef-05 deploy/frontend
k exec -n pruef-05 deploy/frontend -- ls /var/run/secrets/kubernetes.io/serviceaccount
k get sa -n pruef-05 \
  -o custom-columns=NAME:.metadata.name,AUTOMOUNT:.automountServiceAccountToken

Erwartet (gekürzt):

serviceaccount/frontend created
serviceaccount/frontend patched
serviceaccount/default patched
deployment.apps/frontend serviceaccount updated
deployment "frontend" successfully rolled out
ls: /var/run/secrets/kubernetes.io/serviceaccount: No such file or directory
command terminated with exit code 1
NAME       AUTOMOUNT
default    false
frontend   false

Vorher stand dort ca.crt namespace token. Der alte Pod braucht noch 30 s bis zum Ende (sleep reagiert nicht auf SIGTERM) – in k get pods ist er bis dahin Terminating.

Lösung 6

Erst beweisen, dass keine Bindung schuld ist, dann den API-Server ansehen:

k auth can-i get secrets -A --as=system:serviceaccount:pruef-06:viewer
k get rolebindings,clusterrolebindings -A -o wide | grep pruef-06:viewer
sudo kube-bench run --targets=master --benchmark=cis-1.12 --group=1.2 2>/dev/null \
  | grep '^\[FAIL\]' | cut -c1-80
ps -o args= -C kube-apiserver | tr ' ' '\n' | grep authorization-mode

Erwartet (gekürzt):

yes
[FAIL] 1.2.5 Ensure that the --kubelet-certificate-authority argument is set as
[FAIL] 1.2.6 Ensure that the --authorization-mode argument is not set to AlwaysA
[FAIL] 1.2.17 Ensure that the --audit-log-maxage argument is set to 30 or as app
…
--authorization-mode=Node,RBAC,AlwaysAllow

Die Autorisierer werden der Reihe nach gefragt. RBAC verweigert nie ausdrücklich, es erlaubt nur – findet es keine Regel, fragt der API-Server den nächsten, und AlwaysAllow sagt Ja. Sichern, korrigieren, gegen das Original vergleichen:

M=/etc/kubernetes/manifests
sudo cp $M/kube-apiserver.yaml ~/cks/pruef/backup/kube-apiserver.yaml.06
sudo sed -i 's/,AlwaysAllow$//' $M/kube-apiserver.yaml
sudo cmp $M/kube-apiserver.yaml ~/cks/pruef/backup/kube-apiserver.yaml.orig \
  && echo gleich

Erwartet: gleich

Nach 1–2 Minuten:

k get --raw /readyz; echo
ps -o args= -C kube-apiserver | tr ' ' '\n' | grep authorization-mode
k auth can-i get secrets -A --as=system:serviceaccount:pruef-06:viewer
sudo kube-bench run --targets=master --benchmark=cis-1.12 --check=1.2.6 2>/dev/null \
  | grep -E '^\[(PASS|FAIL)' | cut -c1-80
k get nodes

Erwartet (gekürzt):

ok
--authorization-mode=Node,RBAC
no
[PASS] 1.2.6 Ensure that the --authorization-mode argument is not set to AlwaysA
NAME      STATUS   ROLES           AGE    VERSION
cp1       Ready    control-plane   165m   …
worker1   Ready    <none>          163m   …
worker2   Ready    <none>          163m   …

Die übrigen FAILs in 1.2 (kubelet-CA, Audit-Größen, Token-Laufzeit) gehören zum Laborstand und sind nicht Teil der Aufgabe. Der Controller-Manager und der Scheduler gehen nach dem Neustart oft kurz in CrashLoopBackOff (Leader Election) – abwarten.

Lösung 7

Welche Profile geladen sind und wie das schreibende heißt, zeigt der Node (vom eigenen Rechner):

ssh [email protected] 'sudo aa-status | grep cks'

Erwartet:

   cks-deny-etc
   cks-deny-write

Dasselbe auf worker2 (172.16.0.83). Zurück auf cp1:

cat > 07-patch.yaml <<'EOF'
spec:
  template:
    spec:
      containers:
      - name: busybox
        securityContext:
          appArmorProfile:
            type: Localhost
            localhostProfile: cks-deny-write
EOF
k patch deploy archiv -n pruef-07 --patch-file 07-patch.yaml
k rollout status -n pruef-07 deploy/archiv
k exec -n pruef-07 deploy/archiv -- cat /proc/1/attr/current; echo
k exec -n pruef-07 deploy/archiv -- touch /tmp/x

Erwartet:

deployment.apps/archiv patched
deployment "archiv" successfully rolled out
cks-deny-write (enforce)
touch: /tmp/x: Permission denied
command terminated with exit code 1

Vorher stand in /proc/1/attr/current das Standardprofil cri-containerd.apparmor.d (enforce). Der Container heißt busybox, weil k create deployment ihn nach dem Image benennt.

Lösung 8

k get pod builder -n pruef-08
k describe pod builder -n pruef-08 | grep 'seccomp profile'

Erwartet (gekürzt):

NAME      READY   STATUS                 RESTARTS   AGE
builder   0/1     CreateContainerError   0          9s
  Warning  Failed  …  failed to create containerd container: cannot load seccomp
profile "/var/lib/kubelet/seccomp/no-mkdir.json": open
/var/lib/kubelet/seccomp/no-mkdir.json: no such file or directory

localhostProfile ist relativ zu /var/lib/kubelet/seccomp – es fehlt profiles/. Das Feld ist im laufenden Pod unveränderlich, also ersetzen:

sed -i 's#localhostProfile: no-mkdir.json#localhostProfile: profiles/no-mkdir.json#' \
  08-builder.yaml
k replace --force -f 08-builder.yaml
k wait -n pruef-08 --for=condition=Ready pod/builder --timeout=60s
k exec -n pruef-08 builder -- grep Seccomp: /proc/1/status
k exec -n pruef-08 builder -- mkdir /tmp/neu
k exec -n pruef-08 builder -- touch /tmp/datei && echo touch-ok

Erwartet:

pod "builder" deleted from pruef-08 namespace
pod/builder replaced
pod/builder condition met
Seccomp:    2
mkdir: can't create directory '/tmp/neu': Operation not permitted
command terminated with exit code 1
touch-ok

touch geht weiter: Das Profil sperrt nur mkdir/mkdirat, alles andere erlaubt es.

Lösung 9

Erst per Server-Dry-Run sehen, was gegen restricted verstößt:

k label --dry-run=server --overwrite ns pruef-09 \
  pod-security.kubernetes.io/enforce=restricted

Erwartet (gekürzt):

Warning: existing pods in namespace "pruef-09" violate the new PodSecurity enforce
level "restricted:latest"
Warning: api-7cf6764965-j9gd8: allowPrivilegeEscalation != false, unrestricted
capabilities, runAsNonRoot != true, seccompProfile
Warning: debug-67794d55cb-xlxqf: host namespaces, allowPrivilegeEscalation != false,
unrestricted capabilities, runAsNonRoot != true, seccompProfile
namespace/pruef-09 labeled (server dry run)

api lässt sich reparieren (das Image läuft schon als 65532), debug mit hostPID nicht – es fliegt raus:

k label --overwrite ns pruef-09 pod-security.kubernetes.io/enforce=restricted \
  pod-security.kubernetes.io/warn=restricted
cat > 09-patch.yaml <<'EOF'
spec:
  template:
    spec:
      securityContext:
        runAsNonRoot: true
        seccompProfile:
          type: RuntimeDefault
      containers:
      - name: notes-api
        securityContext:
          allowPrivilegeEscalation: false
          capabilities:
            drop: ["ALL"]
EOF
k patch deploy api -n pruef-09 --patch-file 09-patch.yaml
k delete deploy debug -n pruef-09
k rollout status -n pruef-09 deploy/api
k label --dry-run=server --overwrite ns pruef-09 \
  pod-security.kubernetes.io/enforce=restricted
k exec -n pruef-09 deploy/api -- wget -qO- localhost:8080/healthz; echo
k run probe -n pruef-09 --image=busybox:1.37 --privileged -- sleep 1

Erwartet (gekürzt):

deployment.apps/api patched
deployment.apps "debug" deleted from pruef-09 namespace
deployment "api" successfully rolled out
namespace/pruef-09 not labeled (server dry run)
ok
Error from server (Forbidden): pods "probe" is forbidden: violates PodSecurity
"restricted:latest": privileged (container "probe" must not set …

Der zweite Dry-Run ohne Warnung ist der Beweis: Kein laufender Pod verletzt mehr restricted. Das Label allein hätte debug nicht beendet – PSA prüft nur neue Pods.

Lösung 10

Ausgangslage in etcd (der Wert ist Klartext, grep -a zählt ihn):

P=/etc/kubernetes/pki
E="--cacert=$P/etcd/ca.crt --cert=$P/apiserver-etcd-client.crt"
E="$E --key=$P/apiserver-etcd-client.key"
sudo etcdctl $E get /registry/configmaps/pruef-10/db-config --print-value-only \
  | grep -ac Lab-Pruef-10

Erwartet: 1

Secret anlegen, Schlüssel aus der ConfigMap löschen, Variable umhängen:

k create secret generic db-pass -n pruef-10 --from-literal=DB_PASSWORD=Lab-Pruef-10
k patch cm db-config -n pruef-10 --type=json \
  -p '[{"op":"remove","path":"/data/DB_PASSWORD"}]'
k set env deploy/app -n pruef-10 DB_PASSWORD-
k set env deploy/app -n pruef-10 --from=secret/db-pass
k rollout status -n pruef-10 deploy/app
k set env deploy/app -n pruef-10 --list
k exec -n pruef-10 deploy/app -- env | grep DB_

Erwartet (gekürzt):

secret/db-pass created
configmap/db-config patched
deployment.apps/app env updated
deployment.apps/app env updated
deployment "app" successfully rolled out
# Deployment app, container busybox
# DB_HOST from configmap db-config, key DB_HOST
# DB_PASSWORD from secret db-pass, key DB_PASSWORD
DB_HOST=db.pruef-10
DB_PASSWORD=Lab-Pruef-10

Nachweis in etcd:

sudo etcdctl $E get /registry/configmaps/pruef-10/db-config --print-value-only \
  | grep -ac Lab-Pruef-10
sudo etcdctl $E get /registry/secrets/pruef-10/db-pass --print-value-only \
  | head -c 23 > 10-etcd.txt
cat 10-etcd.txt; echo

Erwartet:

0
k8s:enc:aescbc:v1:key2:

ConfigMaps verschlüsselt die EncryptionConfiguration aus Tag 10 nicht – nur resources: [secrets]. Darum gehört ein Passwort nie in eine ConfigMap.

Lösung 11

k get deploy,pods -n pruef-11
k get events -n pruef-11 --field-selector reason=FailedCreate \
  -o jsonpath='{.items[0].message}'; echo
k get runtimeclass

Erwartet:

NAME                     READY   UP-TO-DATE   AVAILABLE   AGE
deployment.apps/parser   0/1     0            0           5s
Error creating: pods "parser-5bf6896dc7-" is forbidden: pod rejected: RuntimeClass
"sandbox" not found
NAME     HANDLER   AGE
gvisor   runsc     76m
k patch deploy parser -n pruef-11 \
  -p '{"spec":{"template":{"spec":{"runtimeClassName":"gvisor"}}}}'
k rollout status -n pruef-11 deploy/parser
k get pod -n pruef-11 -o wide | awk '{print $1, $3, $7}'
k exec -n pruef-11 deploy/parser -- dmesg | head -1
k exec -n pruef-11 deploy/parser -- uname -r

Erwartet:

deployment.apps/parser patched
deployment "parser" successfully rolled out
NAME STATUS NODE
parser-6466d7fddb-wsv8v Running worker2
[   0.000000] Starting gVisor...
4.19.0-gvisor

Ohne Pods keine Pod-Events: Den Grund findest du im Event des ReplicaSets (FailedCreate), nicht in k describe pod.

Lösung 12

k get pods -n pruef-12 -o jsonpath='{.items[*].spec.containers[*].image}' \
  | tr ' ' '\n' | sort -u
trivy image -q --scanners vuln --severity CRITICAL redis:7.0.0-alpine | grep ^Total
trivy image -q --scanners vuln --severity CRITICAL httpd:2.4.54-alpine | grep ^Total
trivy image -q --scanners vuln --severity CRITICAL --insecure --exit-code 1 \
  172.16.0.126:30500/notes-api:1.0 > /dev/null; echo $?
trivy image -q --scanners vuln --severity CRITICAL --exit-code 1 \
  redis:8.2-alpine > /dev/null; echo $?

Erwartet:

172.16.0.126:30500/notes-api:1.0
httpd:2.4.54-alpine
redis:7.0.0-alpine
Total: 1 (CRITICAL: 1)
Total: 6 (CRITICAL: 6)
0
0

Betroffen sind cache und web; notes-api:1.0 und das Ersatz-Image sind frei von CRITICAL (Stand der Trivy-DB vom 2026-11-18):

k set image deploy/cache -n pruef-12 redis=redis:8.2-alpine
k scale deploy web -n pruef-12 --replicas=0
echo httpd:2.4.54-alpine > 12-critical.txt
k rollout status -n pruef-12 deploy/cache
k get deploy -n pruef-12 -o custom-columns=NAME:.metadata.name,\
READY:.status.readyReplicas,IMAGE:.spec.template.spec.containers[0].image

Erwartet:

deployment.apps/cache image updated
deployment.apps/web scaled
deployment "cache" successfully rolled out
NAME    READY    IMAGE
api     1        172.16.0.126:30500/notes-api:1.0
cache   1        redis:8.2-alpine
web     <none>   httpd:2.4.54-alpine

Ohne Treffer gibt Trivy keine Total-Zeile aus – darum für „sauber“ den Exit-Code prüfen, nicht nach Total greppen.

Lösung 13

kubesec scan 13-api.yaml | jq -r '.[0] | .score, .message'
kubesec scan 13-api.yaml | jq -r '.[0].scoring.critical[] | .id + ": " + .selector'

Erwartet:

-60
Failed with a score of -60 points
CapSysAdmin: containers[] .securityContext .capabilities .add == SYS_ADMIN
Privileged: containers[] .securityContext .privileged == true

Die beiden kritischen Punkte entfernen, dann die Ratschläge aus .scoring.advise abarbeiten:

cat > 13-api.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: api
  namespace: pruef-13
spec:
  replicas: 1
  selector:
    matchLabels:
      app: api
  template:
    metadata:
      labels:
        app: api
    spec:
      automountServiceAccountToken: false
      securityContext:
        runAsNonRoot: true
        runAsUser: 65532
        runAsGroup: 65532
        seccompProfile:
          type: RuntimeDefault
      containers:
      - name: notes-api
        image: 172.16.0.126:30500/notes-api:1.0
        env:
        - name: NOTES_API_KEY
          value: lab-key-123
        securityContext:
          allowPrivilegeEscalation: false
          readOnlyRootFilesystem: true
          capabilities:
            drop: ["ALL"]
        resources:
          requests:
            cpu: 50m
            memory: 32Mi
          limits:
            cpu: 200m
            memory: 64Mi
EOF
kubesec scan 13-api.yaml | jq -r '.[0] | .score, .message'
kubesec scan 13-api.yaml | jq -r '.[0].scoring.critical | length'
k apply -f 13-api.yaml
k rollout status -n pruef-13 deploy/api
k exec -n pruef-13 deploy/api -- wget -qO- localhost:8080/healthz; echo

Erwartet:

12
Passed with a score of 12 points
0
deployment.apps/api created
deployment "api" successfully rolled out
ok

Ein hoher Score nützt nichts, wenn die Anwendung danach nicht startet – darum zum Schluss immer /healthz.

Lösung 14

Der Name des Images steht hinter dem letzten /; nur dort zeigt ein : ein Tag an (davor kann der Port der Registry stehen):

cat > 14-vap.yaml <<'EOF'
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingAdmissionPolicy
metadata:
  name: pruef-14-image-tag
spec:
  failurePolicy: Fail
  matchConstraints:
    resourceRules:
    - apiGroups: [""]
      apiVersions: ["v1"]
      operations: ["CREATE", "UPDATE"]
      resources: ["pods"]
  validations:
  - expression: >-
      object.spec.containers.all(c, c.image.contains('@sha256:') ||
      (c.image.substring(c.image.lastIndexOf('/') + 1).contains(':') &&
      !c.image.endsWith(':latest')))
    messageExpression: >-
      "Image ohne festes Tag: " + object.spec.containers.map(c, c.image).join(", ")
---
apiVersion: admissionregistration.k8s.io/v1
kind: ValidatingAdmissionPolicyBinding
metadata:
  name: pruef-14-image-tag
spec:
  policyName: pruef-14-image-tag
  validationActions: ["Deny"]
  matchResources:
    namespaceSelector:
      matchLabels:
        kubernetes.io/metadata.name: pruef-14
EOF
k apply -f 14-vap.yaml
k run probe -n pruef-14 --image=nginx
k run probe -n pruef-14 --image=nginx:latest
k run probe -n pruef-14 --image=nginx:1.29-alpine-slim --dry-run=server
k get pods -n pruef-14

Erwartet (gekürzt):

validatingadmissionpolicy.admissionregistration.k8s.io/pruef-14-image-tag created
validatingadmissionpolicybinding.admissionregistration.k8s.io/pruef-14-image-tag
created
The pods "probe" is invalid: : ValidatingAdmissionPolicy 'pruef-14-image-tag' with
binding 'pruef-14-image-tag' denied request: Image ohne festes Tag: nginx
The pods "probe" is invalid: : ValidatingAdmissionPolicy 'pruef-14-image-tag' with
binding 'pruef-14-image-tag' denied request: Image ohne festes Tag: nginx:latest
pod/probe created (server dry run)
NAME                  READY   STATUS    RESTARTS   AGE
web-d8f7cc9c9-wtnpb   1/1     Running   0          8s

Der alte web-Pod läuft weiter – Admission prüft nur neue Anfragen. Neue Pods mit latest würden abgelehnt, also das Image festnageln:

k set image deploy/web -n pruef-14 nginx=nginx:1.29-alpine-slim
k rollout status deploy/web -n pruef-14
k get deploy web -n pruef-14 -o wide | awk '{print $1, $2, $7}'

Erwartet:

deployment.apps/web image updated
deployment "web" successfully rolled out
NAME READY IMAGES
web 1/1 nginx:1.29-alpine-slim

Ohne Binding wirkt die Policy nicht. Fehler in der CEL-Formel zeigt k get validatingadmissionpolicy pruef-14-image-tag -o yaml unter status.typeChecking.

Lösung 15

L=/var/log/kubernetes/audit/audit.log
sudo jq -c 'select(.objectRef.resource=="configmaps"
  and .objectRef.name=="feature-flags" and .verb=="delete")
  | [.user.username, .responseStatus.code, .sourceIPs[0], .stageTimestamp]' $L
echo system:serviceaccount:pruef-15:cleanup > 15-wer.txt

Erwartet (gekürzt):

["system:serviceaccount:pruef-15:cleanup",200,"172.16.0.126","2026-11-18T20:01:21…"]

In der Policy gilt die erste passende Regel. Die neue Regel muss also vor die bestehende Metadata-Regel für Secrets und ConfigMaps. Sichern, dann mit sudo vim /etc/kubernetes/audit/policy.yaml direkt hinter der Regel für watch einfügen:

sudo cp /etc/kubernetes/audit/policy.yaml ~/cks/pruef/backup/policy.yaml.orig
- level: RequestResponse
  namespaces: ["pruef-15"]
  verbs: ["create", "update", "patch", "delete"]
  resources:
  - group: ""
    resources: ["configmaps"]
sudo sed -n '/verbs: \["watch"\]/,/serviceaccounts/p' /etc/kubernetes/audit/policy.yaml

Erwartet:

  verbs: ["watch"]
- level: RequestResponse
  namespaces: ["pruef-15"]
  verbs: ["create", "update", "patch", "delete"]
  resources:
  - group: ""
    resources: ["configmaps"]
- level: Metadata
  resources:
  - group: ""
    resources: ["secrets", "configmaps", "serviceaccounts/token"]

Die Policy liest der API-Server nur beim Start. Das Manifest ändert sich nicht, also den Container gezielt stoppen; der kubelet startet ihn neu:

sudo crictl stop $(sudo crictl ps --name kube-apiserver -q)

Nach 1–2 Minuten (k get --raw /readyz meldet ok):

k create configmap feature-flags -n pruef-15 --from-literal=beta=false
k create configmap other -n pruef-16 --from-literal=x=1
sudo jq -c 'select(.objectRef.resource=="configmaps" and .verb=="create"
  and (.objectRef.namespace=="pruef-15" or .objectRef.namespace=="pruef-16"))
  | [.level, .objectRef.namespace, .requestObject.data]' $L | tail -2
k delete cm other -n pruef-16

Erwartet:

configmap/feature-flags created
configmap/other created
["RequestResponse","pruef-15",{"beta":"false"}]
["Metadata","pruef-16",null]
configmap "other" deleted from pruef-16 namespace

Laborpflicht nach der Prüfung (die Audit-Policy aus Tag 15 bleibt der Standard):

sudo cp ~/cks/pruef/backup/policy.yaml.orig /etc/kubernetes/audit/policy.yaml
sudo crictl stop $(sudo crictl ps --name kube-apiserver -q)

Danach wieder auf readyz warten.

Lösung 16

Werte sichern, Regel per Helm-Wert customRules ergänzen:

helm get values falco -n falco -o yaml > backup/falco-values.yaml
cat > 16-rules.yaml <<'EOF'
customRules:
  pruef-16.yaml: |-
    - list: pkg_tools
      items: [apk, apt, apt-get, dpkg, yum, dnf]
    - rule: Paketmanager im Container
      desc: Ein Paketmanager startet in einem laufenden Container
      condition: spawned_process and container and proc.name in (pkg_tools)
      output: "%evt.time,%k8s.ns.name,%k8s.pod.name,%proc.name"
      priority: WARNING
EOF
helm upgrade falco falcosecurity/falco --version 9.2.2 -n falco --reuse-values \
  -f 16-rules.yaml
k -n falco rollout status ds/falco

Erwartet (gekürzt):

Release "falco" has been upgraded. Happy Helming!
daemon set "falco" successfully rolled out

Nach einer Minute die Meldungen aller Falco-Pods auswerten:

k -n falco logs -l app.kubernetes.io/name=falco -c falco --since=5m \
  | grep '^[0-9:.]*: Warning [0-9]' | cut -d' ' -f3 | cut -d, -f2-4 | sort | uniq -c

Erwartet:

      3 pruef-16,updater-57b5dd6d7f-m8lrt,apk

Eine vollständige Meldung sieht so aus (gekürzt) – Falco hängt die Container-Felder selbst an:

20:04:35.715182780: Warning 20:04:35.715182780,pruef-16,updater-57b5dd6d7f-m8lrt,apk
container_id=ebcd6f4014f2 container_name=alpine … k8s_ns_name=pruef-16
k get pod -n pruef-16 updater-57b5dd6d7f-m8lrt \
  -o jsonpath='{.metadata.ownerReferences[0].name}'; echo
echo pruef-16/updater-57b5dd6d7f-m8lrt > 16-befund.txt
k scale deploy updater -n pruef-16 --replicas=0

Erwartet:

updater-57b5dd6d7f
deployment.apps/updater scaled

Der Besitzer des Pods ist das ReplicaSet; dessen Name ohne den Hash ist das Deployment. Laborpflicht nach der Prüfung – Falco auf die Standardregeln aus Tag 16 zurücksetzen:

helm upgrade falco falcosecurity/falco --version 9.2.2 -n falco --reset-values \
  --set driver.kind=modern_ebpf --set tty=true \
  --set falcoctl.artifact.follow.enabled=false \
  --set resources.requests.cpu=50m --set resources.requests.memory=128Mi
k -n falco rollout status ds/falco
helm get values falco -n falco -o yaml | diff - backup/falco-values.yaml && echo gleich

Erwartet (gekürzt):

Release "falco" has been upgraded. Happy Helming!
daemon set "falco" successfully rolled out
gleich

Lösung 17

Prozesse aller drei Pods ansehen:

for d in api web metrics; do echo "== $d"
  k exec -n pruef-17 deploy/$d -- ps -o pid,args; done

Erwartet:

== api
PID   COMMAND
    1 notes-api
   13 ps -o pid,args
== web
PID   COMMAND
    1 nginx: master process nginx -g daemon off;
   31 nginx: worker process
   32 nginx: worker process
   33 ps -o pid,args
== metrics
PID   COMMAND
    1 sleep 3600
    7 {kworkerd} /bin/sh /tmp/.x/kworkerd
   10 nc -lk -p 4444
   11 ps -o pid,args

Ein „Kernel-Thread“ als Shell-Skript aus einem versteckten Ordner unter /tmp – das ist der Passagier:

k exec -n pruef-17 deploy/metrics -- netstat -tln
k exec -n pruef-17 deploy/metrics -- ls -la /tmp/.x
P=$(k get pod -n pruef-17 -l app=metrics -o name)
mkdir -p 17-evidence
k get -n pruef-17 $P -o yaml > 17-evidence/pod.yaml
k exec -n pruef-17 $P -- cat /tmp/.x/kworkerd > 17-evidence/kworkerd
k scale deploy metrics -n pruef-17 --replicas=0
ls 17-evidence

Erwartet (gekürzt):

Proto Recv-Q Send-Q Local Address           Foreign Address         State
tcp        0      0 :::4444                 :::*                    LISTEN
-rwxr-xr-x    1 root     root            25 Nov 18 20:06 kworkerd
deployment.apps/metrics scaled
kworkerd
pod.yaml

Erst sichern, dann skalieren – mit dem Pod verschwindet seine beschreibbare Schicht und damit das Beweisstück. Jetzt web und api unveränderlich machen. nginx braucht Schreibplätze für Cache und PID-Datei:

cat > 17-web.yaml <<'EOF'
spec:
  template:
    spec:
      containers:
      - name: nginx
        securityContext:
          readOnlyRootFilesystem: true
        volumeMounts:
        - name: cache
          mountPath: /var/cache/nginx
        - name: run
          mountPath: /run
      volumes:
      - name: cache
        emptyDir: {}
      - name: run
        emptyDir: {}
EOF
k patch deploy web -n pruef-17 --patch-file 17-web.yaml
k patch deploy api -n pruef-17 -p '{"spec":{"template":{"spec":{"containers":[
  {"name":"notes-api","securityContext":{"readOnlyRootFilesystem":true}}]}}}}'
k rollout status -n pruef-17 deploy/web
k rollout status -n pruef-17 deploy/api
k get deploy -n pruef-17
k exec -n pruef-17 deploy/web -- touch /usr/share/nginx/html/x
k exec -n pruef-17 deploy/api -- touch /x
k exec -n pruef-17 deploy/api -- wget -qO- -T3 web | grep -o '<title>.*</title>'

Erwartet (gekürzt):

deployment.apps/web patched
deployment.apps/api patched
deployment "web" successfully rolled out
deployment "api" successfully rolled out
NAME      READY   UP-TO-DATE   AVAILABLE   AGE
api       1/1     1            1           22s
metrics   0/0     0            0           21s
web       1/1     1            1           21s
touch: /usr/share/nginx/html/x: Read-only file system
command terminated with exit code 1
touch: /x: Read-only file system
command terminated with exit code 1
<title>Welcome to nginx!</title>

notes-api schreibt nichts auf die Platte und braucht deshalb kein emptyDir.

Auswertung

Zähle die Gewichte der Aufgaben, die vollständig und nachweisbar gelöst sind – Teilpunkte gibt es hier nicht. Wer eine Härtung abschaltet, damit etwas läuft, bekommt für die Aufgabe null.

Ergebnis Einschätzung
85–100 % prüfungsreif
67–84 % bestanden, aber knapp: Schwachstellen wiederholen
unter 67 % die Tage zu den verfehlten Aufgaben wiederholen und neu starten
Aufgaben Lehrplanbereich Tage
1–3 Cluster Setup (15 %) 2–4
4–6 Cluster Hardening (15 %) 5, 6
7, 8 System Hardening (10 %) 7, 8
9–11 Minimize Microservice Vulnerabilities (20 %) 9–12
12–14 Supply Chain Security (20 %) 13, 14
15–17 Monitoring, Logging and Runtime Security (20 %) 15–18

Aufräumen (API-Server, Audit-Policy und Falco sind nach Lösung 6, 15 und 16 schon im Ausgangszustand):

for i in $(seq -w 1 17); do k delete ns pruef-$i --wait=false; done
k delete -f 14-vap.yaml
rm ~/cks/pruef/03/kubectl

Kontrollpunkt

k get ns | grep -c '^pruef-'

Erwartet (nach etwa einer Minute): 0

k get validatingadmissionpolicies,validatingadmissionpolicybindings

Erwartet: No resources found

ps -o args= -C kube-apiserver | tr ' ' '\n' \
  | grep -E 'authorization-mode|authentication-config|encryption-pro|audit-policy'

Erwartet:

--authorization-mode=Node,RBAC
--authentication-config=/etc/kubernetes/authn/authn-config.yaml
--encryption-provider-config=/etc/kubernetes/enc/enc.yaml
--audit-policy-file=/etc/kubernetes/audit/policy.yaml
sudo diff ~/cks/pruef/backup/policy.yaml.orig /etc/kubernetes/audit/policy.yaml \
  && echo gleich

Erwartet: gleich

sudo stat -c '%a %U:%G %n' /etc/kubernetes/manifests/kube-scheduler.yaml \
  /etc/kubernetes/controller-manager.conf /var/lib/etcd

Erwartet:

600 root:root /etc/kubernetes/manifests/kube-scheduler.yaml
600 root:root /etc/kubernetes/controller-manager.conf
700 etcd:etcd /var/lib/etcd
helm get values falco -n falco -o yaml | grep -c customRules

Erwartet: 0

k get --raw /readyz; echo
k get nodes
k get pods -A --no-headers | grep -vc Running

Erwartet: ok, drei Nodes Ready, 0.

Viel Erfolg in der Prüfung.