Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang B: Abschlussprüfung

Ziel: Du findest und behebst 16 eingebaute Fehler quer durch das Buch in 120 Minuten – jeweils mit Ursache und Nachweis – und bewertest dich selbst. · Dauer: 120 min · Voraussetzung: Tag 0–20

Spielregeln

  • Zeit: 120 Minuten, Uhr stellen. Jede Aufgabe hat ein Gewicht in Prozent, zusammen 100 %.
  • Ein Zertifikat gibt es nicht. Die eigene Messlatte: ab 70 % sitzt das Handwerk.
  • Ein Prüfer (ein Kollege oder du selbst, ohne hinzusehen) führt die Vorbereitung aus. Die Aufgaben beschreiben nur das Symptom.
  • Erlaubt: --help, kubectl explain, kubernetes.io/docs, docs.rke2.io, k9s und deine Dateien unter ~/debug. Nicht erlaubt: dieses Buch während der Zeit.
  • Alles läuft auf dem Cluster debug, Arbeitsplatz cp1, in den Namespaces pruefung, pruefung-psa und pruefung-netz.
  • Eine Aufgabe zählt nur mit Ursache in einem Satz und Nachweis-Befehl. Wer das Symptom beseitigt (Policy, Quota, Pod-Security-Label oder Namespace entfernen, --kubelet-insecure-tls, Pods mit --force löschen), bekommt 0 %.
  • Aufgabe 15 hat eine eigene Vorbereitung, die der Prüfer erst ausführt, wenn du dort angekommen bist.
  • Die Lösungen stehen am Ende. Erst nach Ablauf der Zeit lesen.

Vorbereitung

Der Prüfer kopiert die drei Blöcke nacheinander in ein eigenes Terminal auf cp1.

# auf cp1
mkdir -p ~/debug/pruefung && cd ~/debug/pruefung
kubectl create namespace pruefung
kubectl -n pruefung create configmap app-konfig --from-literal=mode=schnell
cat > fehler.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: rechner, namespace: pruefung}
spec:
  replicas: 1
  selector: {matchLabels: {app: rechner}}
  template:
    metadata: {labels: {app: rechner}}
    spec:
      containers:
      - name: rechner
        image: busybox:1.37
        command: [sleep, infinity]
        resources: {requests: {cpu: "8"}}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: portal, namespace: pruefung}
spec:
  replicas: 1
  selector: {matchLabels: {app: portal}}
  template:
    metadata: {labels: {app: portal}}
    spec:
      containers:
      - name: portal
        image: nginxinc/nginx-unprivileged:1.31.99-alpine
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: konfig, namespace: pruefung}
spec:
  replicas: 1
  selector: {matchLabels: {app: konfig}}
  template:
    metadata: {labels: {app: konfig}}
    spec:
      containers:
      - name: konfig
        image: busybox:1.37
        command: [sh, -c, 'echo "Modus: $MODUS"; sleep infinity']
        env:
        - name: MODUS
          valueFrom: {configMapKeyRef: {name: app-konfig, key: modus}}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: tipper, namespace: pruefung}
spec:
  replicas: 1
  selector: {matchLabels: {app: tipper}}
  template:
    metadata: {labels: {app: tipper}}
    spec:
      containers:
      - name: tipper
        image: busybox:1.37
        command: [slep, infinity]
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: fresser, namespace: pruefung}
spec:
  replicas: 1
  selector: {matchLabels: {app: fresser}}
  template:
    metadata: {labels: {app: fresser}}
    spec:
      containers:
      - name: fresser
        image: busybox:1.37
        command: [sh, -c, 'head -c 50m /dev/zero | tail >/dev/null; sleep infinity']
        resources: {limits: {memory: 16Mi}}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: frontend, namespace: pruefung}
spec:
  replicas: 1
  selector: {matchLabels: {app: frontend}}
  template:
    metadata: {labels: {app: frontend}}
    spec:
      containers:
      - name: frontend
        image: traefik/whoami:v1.11
        readinessProbe:
          httpGet: {path: /, port: 8080}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: backend, namespace: pruefung}
spec:
  replicas: 1
  selector: {matchLabels: {app: backend}}
  template:
    metadata: {labels: {app: backend}}
    spec:
      containers:
      - name: backend
        image: traefik/whoami:v1.11
---
apiVersion: v1
kind: Service
metadata: {name: backend, namespace: pruefung}
spec:
  selector: {app: backend}
  ports: [{port: 80, targetPort: 8080}]
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata: {name: ablage, namespace: pruefung}
spec:
  storageClassName: fast
  accessModes: [ReadWriteOnce]
  resources: {requests: {storage: 100Mi}}
---
apiVersion: v1
kind: Pod
metadata: {name: archiv, namespace: pruefung}
spec:
  containers:
  - name: archiv
    image: busybox:1.37
    command: [sh, -c, 'date > /ablage/stempel; sleep infinity']
    volumeMounts: [{name: ablage, mountPath: /ablage}]
  volumes:
  - name: ablage
    persistentVolumeClaim: {claimName: ablage}
---
apiVersion: v1
kind: ServiceAccount
metadata: {name: leser, namespace: pruefung}
---
apiVersion: rbac.authorization.k8s.io/v1
kind: Role
metadata: {name: pod-leser, namespace: pruefung}
rules:
- apiGroups: [""]
  resources: [pods]
  verbs: [get, list]
---
apiVersion: rbac.authorization.k8s.io/v1
kind: RoleBinding
metadata: {name: leser-darf-lesen, namespace: default}
roleRef: {apiGroup: rbac.authorization.k8s.io, kind: Role, name: pod-leser}
subjects:
- {kind: ServiceAccount, name: leser, namespace: pruefung}
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: skalierer, namespace: pruefung}
spec:
  replicas: 1
  selector: {matchLabels: {app: skalierer}}
  template:
    metadata: {labels: {app: skalierer}}
    spec:
      containers:
      - name: skalierer
        image: traefik/whoami:v1.11
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: shop, namespace: pruefung}
spec:
  replicas: 2
  strategy:
    rollingUpdate: {maxSurge: 1, maxUnavailable: 0}
  selector: {matchLabels: {app: shop}}
  template:
    metadata: {labels: {app: shop}}
    spec:
      containers:
      - name: shop
        image: traefik/whoami:v1.11
---
apiVersion: apps/v1
kind: Deployment
metadata: {name: lager, namespace: pruefung}
spec:
  replicas: 1
  selector: {matchLabels: {app: lager}}
  template:
    metadata: {labels: {app: lager}}
    spec:
      containers:
      - name: lager
        image: traefik/whoami:v1.11
EOF
kubectl apply -f fehler.yaml | wc -l
kubectl -n pruefung run client --image=nicolaka/netshoot:v0.15 -- sleep infinity
kubectl -n pruefung autoscale deploy skalierer --cpu=50% --min=1 --max=3
kubectl -n pruefung rollout status deploy/shop --timeout=120s
kubectl -n pruefung set image deploy/shop shop=traefik/whoami:v1.99

Erwartet (gekürzt):

namespace/pruefung created
configmap/app-konfig created
16
pod/client created
horizontalpodautoscaler.autoscaling/skalierer autoscaled
deployment "shop" successfully rolled out
deployment.apps/shop image updated
# auf cp1
cat > /tmp/vpol.yaml <<'EOF'
apiVersion: policies.kyverno.io/v1
kind: ValidatingPolicy
metadata: {name: pruefung-team}
spec:
  validationActions: [Deny]
  matchConstraints:
    namespaceSelector:
      matchLabels: {kubernetes.io/metadata.name: pruefung}
    objectSelector:
      matchLabels: {app: lager}
    resourceRules:
    - apiGroups: [""]
      apiVersions: [v1]
      operations: [CREATE]
      resources: [pods]
  validations:
  - message: Jeder Pod braucht das Label team.
    expression: has(object.metadata.labels) && 'team' in object.metadata.labels
EOF
kubectl -n pruefung rollout status deploy/lager --timeout=120s
kubectl apply -f /tmp/vpol.yaml && rm /tmp/vpol.yaml
sleep 5
kubectl -n pruefung rollout restart deploy/lager

Erwartet:

deployment "lager" successfully rolled out
validatingpolicy.policies.kyverno.io/pruefung-team created
deployment.apps/lager restarted
# auf cp1
kubectl create namespace pruefung-psa
kubectl label namespace pruefung-psa pod-security.kubernetes.io/enforce=restricted
kubectl -n pruefung-psa create deployment sicher --image=busybox:1.37 \
  -- sleep infinity 2>&1 | tail -1
kubectl create namespace pruefung-netz
kubectl -n pruefung-netz create deployment ziel --image=traefik/whoami:v1.11
kubectl -n pruefung-netz expose deployment ziel --port 80
kubectl -n pruefung-netz run client --image=nicolaka/netshoot:v0.15 -- sleep infinity
cat > /tmp/np.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: alles-zu, namespace: pruefung-netz}
spec:
  podSelector: {}
  policyTypes: [Egress]
EOF
kubectl apply -f /tmp/np.yaml && rm /tmp/np.yaml

Erwartet:

namespace/pruefung-psa created
namespace/pruefung-psa labeled
deployment.apps/sicher created
namespace/pruefung-netz created
deployment.apps/ziel created
service/ziel exposed
pod/client created
networkpolicy.networking.k8s.io/alles-zu created

Aufgabe 1: Der Rechner (6 %)

Das Deployment rechner startet seinen Pod nicht. Bring ihn zum Laufen; der Container braucht in Wahrheit 50 Millicores.

Aufgabe 2: Das Portal (6 %)

portal startet nicht. Das Team wollte nginx-unprivileged 1.31.7 (Alpine).

Aufgabe 3: Die Konfiguration (6 %)

konfig startet nicht. Die ConfigMap app-konfig ist die Quelle der Wahrheit für den Wert; der Container soll Modus: schnell ausgeben.

Aufgabe 4: Der Tipper (6 %)

tipper startet immer wieder neu. Finde den Exit-Code und repariere den Befehl.

Aufgabe 5: Der Fresser (6 %)

fresser stirbt immer wieder. Er braucht kurz etwa 50 MiB. Gib ihm, was er braucht.

Aufgabe 6: Das Frontend (6 %)

frontend läuft, ist aber nie bereit. Repariere es, ohne die Probe zu entfernen.

Aufgabe 7: Das Backend (6 %)

Der Pod client erreicht http://backend nicht, obwohl backend läuft und bereit ist.

Aufgabe 8: Das Netz (7 %)

In pruefung-netz soll client den Service ziel per Name erreichen. Die Policy alles-zu bleibt; erlaube nur das Nötigste.

Aufgabe 9: Das Archiv (6 %)

Der Pod archiv bleibt Pending. Er soll mit einem Volume aus der StorageClass des Clusters laufen.

Aufgabe 10: Der Leser (6 %)

Der ServiceAccount leser soll die Pods in pruefung lesen dürfen – die Rolle dafür gibt es schon. Beweise es mit kubectl auth can-i.

Aufgabe 11: Sicher (6 %)

Das Deployment sicher in pruefung-psa hat keinen Pod. Der Namespace bleibt auf restricted.

Aufgabe 12: Das Lager (7 %)

lager wurde neu gestartet, der neue Pod kommt nicht. Die Plattform-Regeln gelten weiter. Das Team heißt logistik.

Aufgabe 13: Der Shop (6 %)

Das Update von shop läuft seit Minuten, der Dienst funktioniert. Bring das Deployment in einen sauberen Zustand auf der letzten funktionierenden Version.

Aufgabe 14: Der Skalierer (6 %)

Der HPA skalierer zeigt kein Ziel. Er soll ab 50 % von 20 Millicores skalieren.

Aufgabe 15: Der Knoten (7 %)

Vorbereitung

Der Prüfer führt aus:

# auf cp1
ssh -n worker1 sudo mkdir -p /etc/rancher/rke2/config.yaml.d
echo 'kubelet-arg: [image-gc-high=85]' \
  | ssh worker1 sudo tee /etc/rancher/rke2/config.yaml.d/90-pruefung.yaml
ssh -n worker1 sudo systemctl restart rke2-agent

Nach einer Wartung meldet sich worker1 nicht mehr. Finde die Ursache und bring den Knoten zurück. Gemeint war die Schwelle für die Image-Bereinigung bei 85 %.

Aufgabe 16: Vor dem Eingriff (7 %)

Bevor jemand an der Control Plane arbeitet: Lege einen etcd-Snapshot mit dem Namen pruefung an und belege mit je einem Befehl, dass API-Server und etcd gesund sind.

Lösungen

Lösung 1

# auf cp1
kubectl -n pruefung get pods -l app=rechner
kubectl -n pruefung events --types=Warning | grep -m1 FailedScheduling \
  | grep -o '0/3 nodes.*Insufficient cpu'
kubectl -n pruefung set resources deploy/rechner --requests=cpu=50m
kubectl -n pruefung rollout status deploy/rechner --timeout=60s | tail -1

Erwartet:

NAME                       READY   STATUS    RESTARTS   AGE
rechner-6b8c797f95-7cmbv   0/1     Pending   0          13s
0/3 nodes are available: 3 Insufficient cpu
deployment.apps/rechner resource requirements updated
deployment "rechner" successfully rolled out

Ursache: Request 8 CPU, kein Knoten hat so viel frei (Tag 3).

Lösung 2

# auf cp1
kubectl -n pruefung get pods -l app=portal
kubectl -n pruefung events --types=Warning | grep -m1 'Failed to pull' \
  | grep -o 'Failed to pull.*' | cut -c1-260 | fold -w 86
kubectl -n pruefung set image deploy/portal \
  portal=nginxinc/nginx-unprivileged:1.31.7-alpine
kubectl -n pruefung rollout status deploy/portal --timeout=90s | tail -1

Erwartet:

NAME                      READY   STATUS         RESTARTS   AGE
portal-69fbd94bb9-mn5zt   0/1     ErrImagePull   0          16s
Failed to pull image "nginxinc/nginx-unprivileged:1.31.99-alpine": rpc error: code = N
otFound desc = failed to pull and unpack image "docker.io/nginxinc/nginx-unprivileged:
1.31.99-alpine": failed to resolve reference "docker.io/nginxinc/nginx-unprivileged:1.
31
deployment.apps/portal image updated
deployment "portal" successfully rolled out

Ursache: Den Tag 1.31.99-alpine gibt es nicht (not found, Tag 4).

Lösung 3

# auf cp1
kubectl -n pruefung get pods -l app=konfig
kubectl -n pruefung events --types=Warning | grep -m1 'couldn' | grep -o 'Error:.*'
kubectl -n pruefung get configmap app-konfig -o jsonpath='{.data}{"\n"}'
kubectl -n pruefung patch deploy konfig --type=json -p '[{"op": "replace",
  "path": "/spec/template/spec/containers/0/env/0/valueFrom/configMapKeyRef/key",
  "value": "mode"}]'
kubectl -n pruefung rollout status deploy/konfig --timeout=60s | tail -1
kubectl -n pruefung logs deploy/konfig

Erwartet:

NAME                      READY   STATUS                       RESTARTS   AGE
konfig-6959997796-nrdj9   0/1     CreateContainerConfigError   0          19s
Error: couldn't find key modus in ConfigMap pruefung/app-konfig
{"mode":"schnell"}
deployment.apps/konfig patched
deployment "konfig" successfully rolled out
Found 2 pods, using pod/konfig-89696cf57-kn4g5
Modus: schnell

Ursache: Das Deployment liest den Schlüssel modus, die ConfigMap hat mode (CreateContainerConfigError, Tag 4). Die ConfigMap ist die Quelle, also wird das Deployment korrigiert.

Lösung 4

# auf cp1
J='{.items[0].status.containerStatuses[0].lastState.terminated}'
kubectl -n pruefung get pods -l app=tipper -o jsonpath="$J" \
  | jq -r '"\(.exitCode) \(.reason)", .message' | cut -c1-200 | fold -w 86
kubectl -n pruefung patch deploy tipper --type=json -p '[{"op": "replace",
  "path": "/spec/template/spec/containers/0/command", "value": ["sleep", "infinity"]}]'
kubectl -n pruefung rollout status deploy/tipper --timeout=60s | tail -1

Erwartet:

128 StartError
failed to create containerd task: failed to create shim task: OCI runtime create faile
d: runc create failed: unable to start container process: error during container init:
 exec: "slep": executable fi
deployment.apps/tipper patched
deployment "tipper" successfully rolled out

Ursache: slep gibt es nicht. Weil command das Programm direkt startet (ohne Shell), meldet die Runtime Exit-Code 128 mit StartError statt 127 (Tag 1, 5).

Lösung 5

# auf cp1
kubectl -n pruefung get pods -l app=fresser \
  -o jsonpath='{.items[0].status.containerStatuses[0].lastState.terminated.reason}'
echo
kubectl -n pruefung set resources deploy/fresser --limits=memory=128Mi
kubectl -n pruefung rollout status deploy/fresser --timeout=60s | tail -1
sleep 10
kubectl -n pruefung get pods -l app=fresser

Erwartet:

OOMKilled
deployment.apps/fresser resource requirements updated
deployment "fresser" successfully rolled out
NAME                      READY   STATUS    RESTARTS   AGE
fresser-9d886c8cd-vs56r   1/1     Running   0          12s

Ursache: Limit 16 MiB, der Prozess braucht 50 MiB – OOMKilled, Exit 137 (Tag 5).

Lösung 6

# auf cp1
kubectl -n pruefung get pods -l app=frontend
kubectl -n pruefung events --types=Warning | grep -m1 'Readiness probe failed' \
  | grep -o 'Readiness.*' | cut -c1-86
kubectl -n pruefung patch deploy frontend --type=json -p '[{"op": "replace",
  "path": "/spec/template/spec/containers/0/readinessProbe/httpGet/port", "value": 80}]'
kubectl -n pruefung rollout status deploy/frontend --timeout=60s | tail -1

Erwartet:

NAME                        READY   STATUS    RESTARTS   AGE
frontend-6748988878-h27vj   0/1     Running   0          38s
Readiness probe failed: Get "http://10.42.2.187:8080/": dial tcp 10.42.2.187:8080: con
deployment.apps/frontend patched
deployment "frontend" successfully rolled out

Ursache: Die Probe fragt Port 8080, whoami hört auf 80 (Tag 5).

Lösung 7

# auf cp1
kubectl -n pruefung exec client -- curl -sS -m 5 http://backend 2>&1 | head -1
kubectl -n pruefung get endpointslices -l kubernetes.io/service-name=backend
kubectl -n pruefung patch service backend --type=json \
  -p '[{"op": "replace", "path": "/spec/ports/0/targetPort", "value": 80}]'
kubectl -n pruefung exec client -- curl -s -m 5 http://backend | grep Hostname

Erwartet:

curl: (7) Failed to connect to backend port 80 after 8 ms: Could not connect to server
NAME            ADDRESSTYPE   PORTS   ENDPOINTS     AGE
backend-gpdmj   IPv4          8080    10.42.1.184   41s
service/backend patched
Hostname: backend-5fd77dddc7-26jbd

Ursache: targetPort: 8080 statt 80 – der Service zeigt auf einen Port, auf dem niemand hört (Tag 7).

Lösung 8

# auf cp1
kubectl -n pruefung-netz exec client -- curl -sS -m 5 http://ziel 2>&1 | head -1
cat > ~/debug/pruefung/netz-erlaubt.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata: {name: client-zu-ziel, namespace: pruefung-netz}
spec:
  podSelector: {matchLabels: {run: client}}
  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}]
  - to:
    - podSelector: {matchLabels: {app: ziel}}
    ports: [{port: 80, protocol: TCP}]
EOF
kubectl apply -f ~/debug/pruefung/netz-erlaubt.yaml
sleep 5
kubectl -n pruefung-netz exec client -- curl -s -m 5 http://ziel | grep Hostname
kubectl -n pruefung-netz exec client -- curl -sS -m 5 -o /dev/null https://example.com \
  2>&1 | head -1

Erwartet:

curl: (28) Resolving timed out after 5002 milliseconds
networkpolicy.networking.k8s.io/client-zu-ziel created
Hostname: ziel-68bd68d544-bdq59
curl: (28) Connection timed out after 5001 milliseconds

Ursache: Default-Deny-Egress sperrt auch DNS (Tag 8). Die neue Policy erlaubt nur DNS und ziel:80; die Gegenprobe ins Internet scheitert weiter.

Lösung 9

# auf cp1
kubectl -n pruefung get pvc ablage | cut -c1-80
kubectl get storageclass | cut -c1-80
kubectl -n pruefung delete pod archiv
kubectl -n pruefung delete pvc ablage
cat > ablage.yaml <<'EOF'
apiVersion: v1
kind: PersistentVolumeClaim
metadata: {name: ablage, namespace: pruefung}
spec:
  storageClassName: local-path
  accessModes: [ReadWriteOnce]
  resources: {requests: {storage: 100Mi}}
---
apiVersion: v1
kind: Pod
metadata: {name: archiv, namespace: pruefung}
spec:
  containers:
  - name: archiv
    image: busybox:1.37
    command: [sh, -c, 'date > /ablage/stempel; sleep infinity']
    volumeMounts: [{name: ablage, mountPath: /ablage}]
  volumes:
  - name: ablage
    persistentVolumeClaim: {claimName: ablage}
EOF
kubectl apply -f ablage.yaml
kubectl -n pruefung wait --for=condition=Ready pod/archiv --timeout=90s
kubectl -n pruefung get pvc ablage | cut -c1-60

Erwartet:

NAME     STATUS    VOLUME   CAPACITY   ACCESS MODES   STORAGECLASS   VOLUMEATTRI
ablage   Pending                                      fast           <unset>    
NAME         PROVISIONER             RECLAIMPOLICY   VOLUMEBINDINGMODE      ALLO
local-path   rancher.io/local-path   Delete          WaitForFirstConsumer   fals
pod "archiv" deleted from pruefung namespace
persistentvolumeclaim "ablage" deleted from pruefung namespace
persistentvolumeclaim/ablage created
pod/archiv created
pod/archiv condition met
NAME     STATUS   VOLUME                                    
ablage   Bound    pvc-a5722729-9455-41ed-9231-e5721bceb7de  

Ursache: Die StorageClass fast gibt es nicht; storageClassName ist an einem PVC unveränderlich, deshalb PVC und Pod neu (Tag 3, 10).

Lösung 10

# auf cp1
S=system:serviceaccount:pruefung:leser
kubectl auth can-i list pods -n pruefung --as=$S
kubectl get rolebinding -A -o custom-columns=NS:.metadata.namespace,\
NAME:.metadata.name,ROLE:.roleRef.name | grep leser
kubectl -n default delete rolebinding leser-darf-lesen
kubectl -n pruefung create rolebinding leser-darf-lesen --role=pod-leser \
  --serviceaccount=pruefung:leser
kubectl auth can-i list pods -n pruefung --as=$S
kubectl auth can-i delete pods -n pruefung --as=$S

Erwartet:

no
default              leser-darf-lesen                                      pod-leser
rolebinding.rbac.authorization.k8s.io "leser-darf-lesen" deleted from default namespace
rolebinding.rbac.authorization.k8s.io/leser-darf-lesen created
yes
no

Ursache: Die RoleBinding liegt in default, die Role in pruefung – eine RoleBinding gilt nur in ihrem eigenen Namespace (Tag 11).

Lösung 11

# auf cp1
kubectl -n pruefung-psa events --types=Warning | tail -1 \
  | grep -o 'violates PodSecurity.*' | cut -c1-250 | fold -w 86
kubectl -n pruefung-psa patch deploy sicher --type=strategic -p '{"spec":{"template":
  {"spec":{"securityContext":{"runAsNonRoot":true,"runAsUser":1000,
  "seccompProfile":{"type":"RuntimeDefault"}},"containers":[{"name":"busybox",
  "securityContext":{"allowPrivilegeEscalation":false,
  "capabilities":{"drop":["ALL"]}}}]}}}}'
kubectl -n pruefung-psa rollout status deploy/sicher --timeout=60s | tail -1

Erwartet:

violates PodSecurity "restricted:latest": allowPrivilegeEscalation != false (container
 "busybox" must set securityContext.allowPrivilegeEscalation=false), unrestricted capa
bilities (container "busybox" must set securityContext.capabilities.drop=["ALL
deployment.apps/sicher patched
deployment "sicher" successfully rolled out

Ursache: restricted verlangt Nicht-Root, Seccomp, kein Privilege Escalation und drop: [ALL]; das Deployment wird angenommen, die Pods abgelehnt (Tag 11).

Lösung 12

# auf cp1
kubectl -n pruefung get rs -l app=lager
kubectl -n pruefung events --types=Warning | grep FailedCreate | grep lager \
  | tail -1 | grep -o 'Error creating.*' | fold -w 86
kubectl get vpol
kubectl -n pruefung patch deploy lager \
  -p '{"spec":{"template":{"metadata":{"labels":{"team":"logistik"}}}}}'
kubectl -n pruefung rollout status deploy/lager --timeout=90s | tail -1

Erwartet:

NAME               DESIRED   CURRENT   READY   AGE
lager-59fbc5f76f   1         0         0       63s
lager-6c79d5cf9c   1         1         1       72s
Error creating: admission webhook "vpol.validate.kyverno.svc-fail" denied the request:
 Policy pruefung-team failed: Jeder Pod braucht das Label team.
NAME            AGE   READY
pruefung-team   69s   true
deployment.apps/lager patched
deployment "lager" successfully rolled out

Ursache: Die ValidatingPolicy pruefung-team lehnt Pods ohne Label team ab; der Fehler steht am ReplicaSet (Tag 12).

Lösung 13

# auf cp1
kubectl -n pruefung rollout status deploy/shop --timeout=5s
kubectl -n pruefung get rs -l app=shop
kubectl -n pruefung rollout undo deploy/shop 2>&1 | tail -1
kubectl -n pruefung rollout status deploy/shop --timeout=60s | tail -1
kubectl -n pruefung get deploy shop \
  -o jsonpath='{.spec.template.spec.containers[0].image}{"\n"}'

Erwartet (Zeile umbrochen):

Waiting for deployment "shop" rollout to finish: 1 out of 2 new replicas have been upd
ated...
error: timed out waiting for the condition
NAME              DESIRED   CURRENT   READY   AGE
shop-64cdcf94f5   1         1         0       78s
shop-74498966f5   2         2         2       81s
deployment.apps/shop rolled back
deployment "shop" successfully rolled out
traefik/whoami:v1.11

Ursache: Image whoami:v1.99 gibt es nicht; mit maxUnavailable: 0 bleiben die alten Pods stehen, der Rollout steht still (Tag 17).

Lösung 14

# auf cp1
kubectl -n pruefung get hpa skalierer | cut -c1-80
kubectl -n pruefung set resources deploy/skalierer --requests=cpu=20m
kubectl -n pruefung rollout status deploy/skalierer --timeout=60s | tail -1
sleep 60
kubectl -n pruefung get hpa skalierer | cut -c1-80

Erwartet:

NAME        REFERENCE              TARGETS              MINPODS   MAXPODS   REPL
skalierer   Deployment/skalierer   cpu: <unknown>/50%   1         3         1   
deployment.apps/skalierer resource requirements updated
deployment "skalierer" successfully rolled out
NAME        REFERENCE              TARGETS       MINPODS   MAXPODS   REPLICAS   
skalierer   Deployment/skalierer   cpu: 0%/50%   1         3         1          

Ursache: Ohne CPU-Request kann der HPA keine Prozent rechnen (Tag 17).

Lösung 15

# auf cp1
sleep 60
kubectl get node worker1
ssh -n worker1 "sudo grep 'unknown flag' /var/lib/rancher/rke2/agent/logs/kubelet.log" \
  | tail -1 | grep -o 'err=.*'
ssh -n worker1 sudo cat /etc/rancher/rke2/config.yaml.d/90-pruefung.yaml
echo 'kubelet-arg: [image-gc-high-threshold=85]' \
  | ssh worker1 sudo tee /etc/rancher/rke2/config.yaml.d/90-pruefung.yaml
ssh -n worker1 sudo systemctl restart rke2-agent
kubectl wait --for=condition=Ready node/worker1 --timeout=120s
kubectl get --raw /api/v1/nodes/worker1/proxy/configz \
  | jq .kubeletconfig.imageGCHighThresholdPercent

Erwartet:

NAME      STATUS     ROLES    AGE   VERSION
worker1   NotReady   <none>   8h    v1.37.2+rke2r1
err="failed to parse kubelet flag: unknown flag: --image-gc-high"
kubelet-arg: [image-gc-high=85]
kubelet-arg: [image-gc-high-threshold=85]
node/worker1 condition met
85

Ursache: image-gc-high ist kein Kubelet-Flag; RKE2 reicht kubelet-arg ungeprüft durch, das Kubelet bricht ab (Tag 14). Richtig heißt es image-gc-high-threshold.

Lösung 16

# auf cp1
sudo -i rke2 etcd-snapshot save --name pruefung 2>&1 | grep -o 'Snapshot .* saved.'
kubectl get --raw '/readyz?verbose' | tail -1
kubectl get --raw '/readyz/etcd'; echo

Erwartet:

Snapshot pruefung-cp1-1795185329 saved.
readyz check passed
ok

Bewertung

Bereich Aufgaben Gewicht
Pods und Container 1–6 36 %
Netz und Storage 7–9 19 %
Admission und Rechte 10–12 19 %
Betrieb 13–16 26 %
Ergebnis Einschätzung
ab 90 % Du findest Fehler schneller, als andere sie beschreiben.
70–89 % Das Handwerk sitzt; die verpassten Tage einmal wiederholen.
unter 70 % Tag 1 (Methode) und die Tage der verpassten Aufgaben noch einmal.

Aufräumen

# auf cp1
ssh -n worker1 sudo rm /etc/rancher/rke2/config.yaml.d/90-pruefung.yaml
ssh -n worker1 sudo rmdir /etc/rancher/rke2/config.yaml.d
ssh -n worker1 sudo systemctl restart rke2-agent
kubectl wait --for=condition=Ready node/worker1 --timeout=120s
kubectl delete vpol pruefung-team
kubectl delete namespace pruefung pruefung-psa pruefung-netz
S=$(sudo -i rke2 etcd-snapshot ls 2>/dev/null | awk '/^pruefung-/{print $1}')
sudo -i rke2 etcd-snapshot delete $S 2>&1 | grep -o 'Snapshot [^ ]* deleted'
kubectl get pv --no-headers | wc -l

Erwartet:

node/worker1 condition met
validatingpolicy.policies.kyverno.io "pruefung-team" deleted
namespace "pruefung" deleted
namespace "pruefung-psa" deleted
namespace "pruefung-netz" deleted
Snapshot pruefung-cp1-1795185329 deleted
No resources found
0

Damit ist der Cluster wieder im Zustand vor der Prüfung: drei Knoten, Kyverno ohne Policies, keine Prüfungsreste.