Zum Inhalt springen
Trainingslager IT-Trainingslager

Anhang B: Probeprüfung

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

Spielregeln

  • Zeit: 120 Minuten, Uhr stellen. Jede Aufgabe hat ein Gewicht in Prozent, zusammen 100 %, verteilt wie die Lehrplanbereiche der CKNE (15/25/20/25/15 %). Als bestanden gelten hier 66 % – angelehnt an die CKA. Die Bestehensgrenze der echten CKNE steht im Candidate Handbook der Linux Foundation (https://training.linuxfoundation.org); prüfe sie vor dem Termin.
  • Erlaubt: die Kubernetes-Doku, docs.cilium.io, k explain und -h/--help der Werkzeuge. Welche Seiten die echte Prüfung freigibt, 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 (Aufgabe 12 zusätzlich pruef-12-db). Gib ihn bei jedem Befehl mit -n an.
  • Dateien gehören nach ~/ckne/pruef. Aufgabe 6 ändert CoreDNS, Aufgabe 11 und 14 ändern die Helm-Werte von Cilium: vorher sichern.
  • Clusterweite Objekte, die du anlegst, beginnen mit pruef-.
  • Die Lösungen stehen am Ende. Erst nach Ablauf der Zeit lesen.

Vorbereitung

Alle Befehle auf cp1, Kontexte ost und west wie seit Tag 17. Namespaces und Arbeitsverzeichnis:

mkdir -p ~/ckne/pruef/backup && cd ~/ckne/pruef
for i in $(seq -w 1 17); do k create ns pruef-$i; done
k create ns pruef-12-db
k --context west create ns pruef-07
A=registry.k8s.io/e2e-test-images/agnhost:2.66.1
E=registry.k8s.io/gateway-api/echo-basic:v1.5.1
C=curlimages/curl:8.17.0
N=nicolaka/netshoot:v0.16

Für Aufgabe 2 ein Webserver mit Dauerkundschaft:

k -n pruef-02 create deployment web --image=nginx:1.29
k -n pruef-02 expose deployment web --port=80
k -n pruef-02 run client --image=$C --command -- \
  sh -c 'while true; do curl -s -o /dev/null web; sleep 2; done'

Für Aufgabe 3 ein Agent im Host-Netz und ein Konfigurationsdienst:

k -n pruef-03 create deployment config --image=$A --port=8080 \
  -- /agnhost netexec --http-port=8080
k -n pruef-03 expose deployment config --port=80 --target-port=8080
k -n pruef-03 create deployment node-agent --image=$C $do -- sleep infinity \
  > 03-node-agent.yaml
sed -i 's/^    spec:$/    spec:\n      hostNetwork: true/' 03-node-agent.yaml
k apply -f 03-node-agent.yaml

Für Aufgabe 4 und 5 ein Shop und eine StatefulSet-Datenbank ohne Service:

k -n pruef-04 create deployment shop --image=$A --replicas=2 --port=8080 \
  -- /agnhost netexec --http-port=8080
k apply -f - <<'EOF'
apiVersion: apps/v1
kind: StatefulSet
metadata:
  name: db
  namespace: pruef-05
spec:
  serviceName: db
  replicas: 2
  selector:
    matchLabels:
      app: db
  template:
    metadata:
      labels:
        app: db
    spec:
      containers:
      - name: db
        image: registry.k8s.io/e2e-test-images/agnhost:2.66.1
        args: ["netexec", "--http-port=8080"]
EOF
k -n pruef-05 run client --image=$N -- sleep infinity

Für Aufgabe 6 und 7 ein Dienst für interne Namen und ein Katalog in beiden Clustern:

k -n pruef-06 create deployment notes --image=$A --port=8080 \
  -- /agnhost netexec --http-port=8080
k -n pruef-06 expose deployment notes --port=80 --target-port=8080
k -n pruef-06 run client --image=$N -- sleep infinity
for c in ost west; do
  k --context $c -n pruef-07 create deployment catalog-$c --image=$A --port=8080 \
    -- /agnhost netexec --http-port=8080
  k --context $c -n pruef-07 expose deployment catalog-$c --name=catalog \
    --port=80 --target-port=8080
  k --context $c -n pruef-07 run client --image=$N -- sleep infinity
done

Für Aufgabe 8 und 9 eine GatewayClass mit NodePort-Services (wie Tag 10) und die Backends:

k apply -f - <<'EOF'
apiVersion: cilium.io/v2alpha1
kind: CiliumGatewayClassConfig
metadata:
  name: nodeport
  namespace: pruef-08
spec:
  service:
    type: NodePort
---
apiVersion: gateway.networking.k8s.io/v1
kind: GatewayClass
metadata:
  name: pruef-nodeport
spec:
  controllerName: io.cilium/gateway-controller
  parametersRef:
    group: cilium.io
    kind: CiliumGatewayClassConfig
    name: nodeport
    namespace: pruef-08
EOF
cat > echo-basic.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: shop-v1
spec:
  selector:
    matchLabels: {app: shop, version: v1}
  template:
    metadata:
      labels: {app: shop, version: v1}
    spec:
      containers:
      - name: echo
        image: registry.k8s.io/gateway-api/echo-basic:v1.5.1
        env:
        - name: POD_NAME
          valueFrom: {fieldRef: {fieldPath: metadata.name}}
EOF
sed -e 's/shop-v1/shop-v2/' -e 's/version: v1/version: v2/g' echo-basic.yaml \
  > echo-basic-v2.yaml
k -n pruef-08 apply -f echo-basic.yaml -f echo-basic-v2.yaml
k -n pruef-08 expose deployment shop-v1 --port=8080 --target-port=3000
k -n pruef-08 expose deployment shop-v2 --port=8080 --target-port=3000
k -n pruef-09 create deployment app --image=$E
k -n pruef-09 expose deployment app --port=8080 --target-port=3000

Für Aufgabe 9 eine CA in cert-manager:

k apply -f - <<'EOF'
apiVersion: cert-manager.io/v1
kind: Issuer
metadata:
  name: selfsigned
  namespace: pruef-09
spec:
  selfSigned: {}
---
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: pruef-ca
  namespace: pruef-09
spec:
  isCA: true
  commonName: Pruef CA
  secretName: pruef-ca
  privateKey:
    algorithm: ECDSA
  issuerRef:
    name: selfsigned
---
apiVersion: cert-manager.io/v1
kind: Issuer
metadata:
  name: pruef-ca
  namespace: pruef-09
spec:
  ca:
    secretName: pruef-ca
EOF

Für Aufgabe 10 ein öffentlicher Dienst, für Aufgabe 11 zwei Pods auf worker2 und ein Webserver auf dem router, der jede Client-IP protokolliert:

k -n pruef-10 create deployment public --image=$A --port=8080 \
  -- /agnhost netexec --http-port=8080
k -n pruef-11 run legacy --image=$N -l app=legacy \
  --overrides='{"spec":{"nodeName":"worker2"}}' -- sleep infinity
k -n pruef-11 run modern --image=$N \
  --overrides='{"spec":{"nodeName":"worker2"}}' -- sleep infinity
ssh [email protected] 'nohup python3 -m http.server 8011 > pruef-11.log 2>&1 &'

Für Aufgabe 12 bis 15 drei Schichten, ein Abrufer, ein Client-Server-Paar auf zwei Nodes und notes-api mit zwei ServiceAccounts:

k -n pruef-12 run frontend --image=$C -l app=frontend --command -- sleep infinity
k -n pruef-12 create deployment backend --image=$A --port=8080 \
  -- /agnhost netexec --http-port=8080
k -n pruef-12 expose deployment backend --port=8080
k -n pruef-12-db create deployment db --image=$A --port=5432 \
  -- /agnhost netexec --http-port=5432
k -n pruef-12-db expose deployment db --port=5432
k -n pruef-13 run fetch --image=$C -l app=fetch --command -- sleep infinity
k -n pruef-14 run probe --image=$N \
  --overrides='{"spec":{"nodeName":"worker2"}}' -- sleep infinity
k -n pruef-14 run web --image=$A --port=8080 \
  --overrides='{"spec":{"nodeName":"worker1"}}' \
  --command -- /agnhost netexec --http-port=8080
k -n pruef-15 create deployment notes --image=ghcr.io/thomaszachmann/notes-api:0.5.1 \
  --port=8080 $do > 15-notes.yaml
k set env --local -f 15-notes.yaml NOTES_API_KEY=lab-key-123 -o yaml | k apply -f -
k -n pruef-15 expose deployment notes --port=80 --target-port=8080
for sa in reader writer; do
  k -n pruef-15 create sa $sa
  k -n pruef-15 run $sa --image=$C --command \
    --overrides="{\"spec\":{\"serviceAccountName\":\"$sa\"}}" -- sleep infinity
done
k -n pruef-15 run other --image=$C --command -- sleep infinity

Für Aufgabe 16 vier Pods, die regelmäßig Namen auflösen:

for p in billing search inventory; do
  k -n pruef-16 run $p --image=$N --command -- sh -c 'while true; do
    dig +short kubernetes.default.svc.cluster.local >/dev/null; sleep 3; done'
done
k -n pruef-16 run mailer --image=$N --command -- sh -c 'while true; do
  dig +short orders.pruef-16-old.svc.cluster.local >/dev/null; sleep 3; done'

Für Aufgabe 17 eine API mit L7-Sicht und drei Clients:

k -n pruef-17 create deployment api --image=$A --port=8080 \
  -- /agnhost netexec --http-port=8080
k -n pruef-17 expose deployment api --port=80 --target-port=8080
k apply -f - <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: api-l7
  namespace: pruef-17
spec:
  endpointSelector:
    matchLabels:
      app: api
  ingress:
  - fromEntities:
    - cluster
    toPorts:
    - ports:
      - port: "8080"
        protocol: TCP
      rules:
        http:
        - {}
EOF
k -n pruef-17 create deployment shop --image=$C -- sh -c \
  'while true; do curl -s -o /dev/null api/hostname; sleep 1; done'
k -n pruef-17 create deployment crawler --image=$C -- sh -c \
  'while true; do curl -s -o /dev/null "api/echo?msg=admin&code=404"; sleep 2; done'
k -n pruef-17 create deployment reporter --image=$C -- sh -c \
  'while true; do curl -s -o /dev/null "api/echo?msg=backup&code=403"; sleep 4; done'

Zwei Minuten warten, bis alles läuft (k get pods -A | grep pruef | grep -v Running bleibt leer). Uhr starten.

Aufgabe 1: Bestandsaufnahme (5 %)

Schreibe nach ~/ckne/pruef/01.txt drei Zeilen: das Pod-CIDR, das Cilium dem Node worker2 zugeteilt hat; Routing-Modus und Tunnelprotokoll von Cilium (durch ein Leerzeichen getrennt); den Namen der CNI-Konfigurationsdatei auf worker1.

Aufgabe 2: Mitschnitt im Pod (5 %)

Namespace pruef-02. Schneide im Netz-Namespace des Pods von web die nächsten fünf Pakete auf TCP-Port 80 mit und speichere sie als pcap unter ~/ckne/pruef/02.pcap. Das Image von web bleibt unverändert, der Pod wird nicht neu gestartet.

Aufgabe 3: Agent im Host-Netz (5 %)

Namespace pruef-03. Das Deployment node-agent läuft im Host-Netz und muss den Service config über den Namen config.pruef-03 erreichen. Es bleibt im Host-Netz.

Aufgabe 4: Echte Client-IP am NodePort (7 %)

Namespace pruef-04. Mache shop (Container-Port 8080) unter NodePort 30804 (Port 80) erreichbar. Der Pod soll die echte IP des Clients sehen, und ein Client landet immer beim selben Pod. Prüfe vom router mit /clientip.

Aufgabe 5: Namen für jede Replika (6 %)

Namespace pruef-05. Das StatefulSet db läuft, aber db-0.db.pruef-05.svc.cluster.local löst nicht auf. Sorge dafür, dass jede Replika ihren eigenen DNS-Namen hat und db.pruef-05 die IPs aller Replikas liefert.

Aufgabe 6: Interne Zone (6 %)

Jeder Name <service>.intern.lab soll clusterweit auf den gleichnamigen Service in pruef-06 zeigen, etwa notes.intern.lab. Alle anderen Namen bleiben unverändert. Sichere die CoreDNS-Konfiguration vorher nach ~/ckne/pruef/backup/coredns.yaml.

Aufgabe 7: Katalog über zwei Cluster (6 %)

Namespace pruef-07, Service catalog in ost und west. Clients in ost nutzen die Backends aus west nur, wenn ost keine hat. Clients in west dürfen nie bei Backends aus ost landen.

Aufgabe 8: Beta-Kunden und Canary (6 %)

Namespace pruef-08. Lege mit der GatewayClass pruef-nodeport das Gateway web (HTTP, Port 80) und die HTTPRoute shop für shop.pruef.lab an: Anfragen mit dem Header x-beta: on gehen immer an shop-v2, alle anderen zu 80 % an shop-v1 und zu 20 % an shop-v2. Weise die Verteilung mit 50 Anfragen nach.

Aufgabe 9: Nur noch HTTPS (5 %)

Namespace pruef-09. Veröffentliche app über ein Gateway secure (GatewayClass pruef-nodeport) unter https://secure.pruef.lab. Das Zertifikat (Secret secure-tls) stellt der Issuer pruef-ca aus. HTTP auf Port 80 antwortet für diesen Host nur mit 301 auf HTTPS.

Aufgabe 10: Service-IP für den router (5 %)

Namespace pruef-10. Mache public als LoadBalancer-Service unter der festen IP 10.50.0.99 (Port 80 → 8080) vom router aus erreichbar. FRR auf dem router ist fertig (AS 65000, Nachbarn: alle drei Nodes, Cluster-AS 65010). Nur Services aus pruef-10 bekommen IPs aus deinem Pool.

Aufgabe 11: Feste Quell-IP nach draußen (4 %)

Namespace pruef-11. Der Pod legacy läuft auf worker2, soll den Webserver auf dem router (172.16.0.123, Port 8011) aber immer mit der Quell-IP von worker1 (172.16.0.228) erreichen; modern behält seine Node-IP. Bereite Cilium dafür vor und nenne die Policy pruef-11. Weise es mit dem Log ~/pruef-11.log auf dem router nach. Danach nimmst du Policy, Node-Label und Helm-Änderung wieder zurück: Egress-Gateway verträgt sich nicht mit ClusterMesh (Aufgabe 7).

Aufgabe 12: Drei Schichten (7 %)

In pruef-12 und pruef-12-db gilt Default Deny für beide Richtungen; DNS zu CoreDNS bleibt erlaubt. Danach gilt nur: frontend → backend auf TCP 8080, backend → db (in pruef-12-db) auf TCP 5432.

Aufgabe 13: Nur lesen bei example.com (6 %)

Namespace pruef-13. Der Pod fetch darf nach außen nur GET-Anfragen per HTTP (Port 80) an example.com schicken – kein HTTPS, keine anderen Ziele, keine anderen Methoden. Namensauflösung muss funktionieren.

Aufgabe 14: Verschlüsselt zwischen den Nodes (6 %)

Pod-Verkehr zwischen den Nodes von ost soll mit WireGuard verschlüsselt laufen; Verkehr zwischen den Nodes selbst bleibt, wie er ist. Weise nach, dass jeder Agent die beiden anderen Nodes als Peers hat und dass eine Anfrage von probe (worker2) an web (worker1) in pruef-14 nicht mehr als VXLAN über eth0 läuft. Danach nimmst du die Helm-Änderung zurück: west verschlüsselt nicht, und ClusterMesh (Aufgabe 7) soll weiterlaufen.

Aufgabe 15: Rechte nach ServiceAccount (6 %)

Namespace pruef-15. Pods mit dem ServiceAccount reader dürfen bei notes nur GET /notes und GET /version, Pods mit writer zusätzlich POST /notes. Alle anderen Pods erreichen notes gar nicht.

Aufgabe 16: Wer fragt ins Leere? (8 %)

Namespace pruef-16. Einer der vier Pods fragt ständig einen Namen an, den es nicht gibt. Finde Pod und Namen mit Hubble und schreibe beides (pod name) nach ~/ckne/pruef/16.txt. Du darfst eine Policy anlegen, sie darf aber keinen Verkehr sperren.

Aufgabe 17: Wer erzeugt die Fehler? (7 %)

Namespace pruef-17. Ermittle mit Prometheus (tag19-mon) aus den Hubble-Metriken, welcher Workload die meisten 4xx-Antworten von api bekommt. Schreibe die PromQL nach ~/ckne/pruef/17-query.txt und den Namen des Workloads nach ~/ckne/pruef/17.txt.

Uhr stoppen.

Lösungen

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

Lösung 1

k get ciliumnode worker2 -o jsonpath='{.spec.ipam.podCIDRs[0]}{"\n"}' > 01.txt
cilium config view | grep -E '^(routing-mode|tunnel-protocol) ' | awk '{print $2}' \
  | paste -sd' ' >> 01.txt
ssh [email protected] sudo ls /etc/cni/net.d >> 01.txt
cat 01.txt

Erwartet:

10.0.2.0/24
tunnel vxlan
05-cilium.conflist

Mit IPAM cluster-pool steht das Pod-CIDR in der CiliumNode, nicht in node.spec.podCIDR (Tag 3). sudo braucht es, weil /etc/cni/net.d nur root lesen darf.

Lösung 2

Ein ephemerer Container teilt den Netz-Namespace des Pods, ohne Image oder Neustart. tcpdump braucht dafür das Profil netadmin. Erst den Container mit sleep starten, einige Sekunden warten (Image ziehen), dann per exec die Rohdaten nach stdout schreiben:

P=$(k -n pruef-02 get pod -l app=web -o name | cut -d/ -f2)
k -n pruef-02 debug $P --profile=netadmin --image=nicolaka/netshoot:v0.16 -c sniff \
  -- sleep 600
k -n pruef-02 exec $P -c sniff -- tcpdump -i eth0 -c 5 -w - tcp port 80 > 02.pcap
tcpdump -nr 02.pcap 2>/dev/null | cut -c1-72
k -n pruef-02 get pod $P -o jsonpath='{.status.containerStatuses[0].restartCount}'
echo

Erwartet (gekürzt):

tcpdump: listening on eth0, link-type EN10MB (Ethernet), snapshot length 262144 bytes
5 packets captured
03:07:52.832174 IP 10.0.2.61.38152 > 10.0.1.247.80: Flags [S], seq 11322
03:07:52.832246 IP 10.0.1.247.80 > 10.0.2.61.38152: Flags [S.], seq 2888
03:07:52.833112 IP 10.0.2.61.38152 > 10.0.1.247.80: Flags [.], ack 1, wi
03:07:52.833239 IP 10.0.2.61.38152 > 10.0.1.247.80: Flags [P.], seq 1:68
03:07:52.833259 IP 10.0.1.247.80 > 10.0.2.61.38152: Flags [.], ack 68, w
0

Die Statuszeilen von tcpdump gehen nach stderr, die pcap-Daten nach stdout – nur deshalb ist die Datei sauber. k debug -i direkt mit tcpdump -w - liefert im Test eine leere Datei, weil sich attach erst nach dem kurzen Lauf verbindet. Gleichwertig: auf dem Node per crictl inspect die PID holen und nsenter -t <PID> -n tcpdump … (Tag 1).

Lösung 3

k -n pruef-03 exec deploy/node-agent -- curl -sS -m3 config.pruef-03/hostname
k -n pruef-03 exec deploy/node-agent -- grep nameserver /etc/resolv.conf
k -n pruef-03 patch deploy node-agent \
  -p '{"spec":{"template":{"spec":{"dnsPolicy":"ClusterFirstWithHostNet"}}}}'
k -n pruef-03 rollout status deploy node-agent
k -n pruef-03 exec deploy/node-agent -- curl -s -m3 config.pruef-03/hostname; echo
k -n pruef-03 exec deploy/node-agent -- grep nameserver /etc/resolv.conf

Erwartet (gekürzt):

curl: (6) Could not resolve host: config.pruef-03
command terminated with exit code 6
nameserver 172.16.0.15
nameserver 8.8.8.8
nameserver 1.1.1.1
deployment.apps/node-agent patched
deployment "node-agent" successfully rolled out
config-57f88f8956-gd2gv
nameserver 10.96.0.10

Mit hostNetwork: true fällt ClusterFirst stillschweigend auf das DNS des Nodes zurück. Erst ClusterFirstWithHostNet gibt dem Pod CoreDNS.

Lösung 4

k -n pruef-04 expose deployment shop --name=shop-ext --type=NodePort --port=80 \
  --target-port=8080
k -n pruef-04 patch svc shop-ext -p '{"spec":{"externalTrafficPolicy":"Local",
 "sessionAffinity":"ClientIP","ports":[{"port":80,"nodePort":30804}]}}'
k -n pruef-04 get svc shop-ext
k -n pruef-04 get pods -o wide
ssh [email protected] curl -s -m3 http://172.16.0.228:30804/clientip; echo
for i in 1 2 3 4; do ssh [email protected] \
  curl -s -m3 http://172.16.0.228:30804/hostname; echo; done | sort | uniq -c

Erwartet (gekürzt):

service/shop-ext exposed
service/shop-ext patched
NAME       TYPE       CLUSTER-IP      EXTERNAL-IP   PORT(S)        AGE
shop-ext   NodePort   10.99.223.156   <none>        80:30804/TCP   1s
NAME                    READY   STATUS    ...   NODE
shop-65c94b46cd-pbfsp   1/1     Running   ...   worker2
shop-65c94b46cd-tmb8q   1/1     Running   ...   worker1
172.16.0.123:36000
      4 shop-65c94b46cd-tmb8q

externalTrafficPolicy: Local erspart das SNAT, der Pod sieht 172.16.0.123. Dafür nur Node-IPs mit lokalem Backend nutzen – auf cp1 gibt es keins (curl Exit 7, Tag 6). Bei nur einem Backend pro Node zeigt erst ein Node mit zwei Pods die Affinität; die Einstellung prüfst du mit k -n pruef-04 get svc shop-ext -o jsonpath='{.spec.sessionAffinity}'.

Lösung 5

Ein StatefulSet bekommt Pod-Namen im DNS nur über einen headless Service mit dem Namen aus serviceName:

k -n pruef-05 create service clusterip db --clusterip=None --tcp=8080:8080
k -n pruef-05 get svc db -o jsonpath='{.spec.selector}'; echo
k -n pruef-05 get pods -o wide
k -n pruef-05 exec client -- dig +short db-0.db.pruef-05.svc.cluster.local
k -n pruef-05 exec client -- dig +short db.pruef-05.svc.cluster.local
k -n pruef-05 exec client -- curl -s -m3 db-1.db:8080/hostname; echo

Erwartet (gekürzt):

service/db created
{"app":"db"}
NAME     READY   STATUS    RESTARTS   AGE   IP           ...
client   1/1     Running   0          3m    10.0.2.122   ...
db-0     1/1     Running   0          3m    10.0.1.148   ...
db-1     1/1     Running   0          3m    10.0.2.134   ...
10.0.1.148
10.0.1.148
10.0.2.134
db-1

k create service setzt den Selector app=<name> – hier passt er zufällig zu den Pods. Sonst --dry-run und den Selector im YAML anpassen.

Lösung 6

k -n kube-system get cm coredns -o yaml > backup/coredns.yaml
k -n kube-system get cm coredns -o jsonpath='{.data.Corefile}' > Corefile
sed -i 's/^    ready$/    ready\n    rewrite name regex (.*)\\.intern\\.lab\\.$ '\
'{1}.pruef-06.svc.cluster.local. answer auto/' Corefile
sed -n 6,7p Corefile
coredns -conf Corefile 2>&1 | tail -1
k -n kube-system create configmap coredns --from-file=Corefile $do | k replace -f -

Erwartet:

    ready
    rewrite name regex (.*)\.intern\.lab\.$ {1}.pruef-06.svc.cluster.local. answer auto
plugin/kubernetes: unable to load in-cluster configuration, KUBERNETES_SERVICE_HOST and
KUBERNETES_SERVICE_PORT must be defined
configmap/coredns replaced

Die Meldung von coredns -conf ist das gute Ergebnis (Syntax in Ordnung, Tag 8). answer auto schreibt den Namen in der Antwort zurück, sonst verwirft der Client eine Antwort für einen Namen, den er nicht gefragt hat. Nach etwa einer Minute:

k -n kube-system logs -l k8s-app=kube-dns --since=90s --prefix | grep 'Reloading c'
k -n pruef-06 exec client -- dig notes.intern.lab | grep -A1 'ANSWER SECTION'
k -n pruef-06 exec client -- curl -s -m3 notes.intern.lab/hostname; echo
k -n pruef-06 exec client -- dig +short kubernetes.default.svc.cluster.local \
  example.com

Erwartet:

[pod/coredns-7cd4959b5-87shd/coredns] [INFO] Reloading complete
[pod/coredns-7cd4959b5-nkb2d/coredns] [INFO] Reloading complete
;; ANSWER SECTION:
notes.intern.lab.   30  IN  A   10.107.136.103
notes-67fbbb656f-2fjq4
10.96.0.1
172.66.147.243
104.20.23.154

Lösung 7

ost nutzt fremde Backends nur im Notfall (affinity=local) und gibt seine eigenen nicht heraus (shared=false). west muss global sein, damit ost seine Backends sieht:

k -n pruef-07 annotate svc catalog service.cilium.io/global=true \
  service.cilium.io/affinity=local service.cilium.io/shared=false
k --context west -n pruef-07 annotate svc catalog service.cilium.io/global=true
for i in $(seq 8); do k -n pruef-07 exec client -- curl -s -m3 catalog/hostname
  echo; done | sort | uniq -c
for i in $(seq 8); do k --context west -n pruef-07 exec client -- \
  curl -s -m3 catalog/hostname; echo; done | sort | uniq -c
k -n pruef-07 scale deployment catalog-ost --replicas=0
for i in $(seq 4); do k -n pruef-07 exec client -- curl -s -m3 catalog/hostname
  echo; done | sort | uniq -c
k -n pruef-07 scale deployment catalog-ost --replicas=1

Erwartet:

service/catalog annotated
service/catalog annotated
      8 catalog-ost-7f9cbb9fc8-5lwtt
      8 catalog-west-5fd9689fc7-vmqrn
deployment.apps/catalog-ost scaled
      4 catalog-west-5fd9689fc7-vmqrn
deployment.apps/catalog-ost scaled

Lösung 8

Die Regel mit Header-Match ist spezifischer und gewinnt; die Regel ohne matches fängt den Rest:

cat > 08-gw.yaml <<'EOF'
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: web
  namespace: pruef-08
spec:
  gatewayClassName: pruef-nodeport
  listeners:
  - name: http
    protocol: HTTP
    port: 80
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: shop
  namespace: pruef-08
spec:
  parentRefs:
  - name: web
  hostnames:
  - shop.pruef.lab
  rules:
  - matches:
    - headers:
      - name: x-beta
        value: "on"
    backendRefs:
    - name: shop-v2
      port: 8080
  - backendRefs:
    - name: shop-v1
      port: 8080
      weight: 80
    - name: shop-v2
      port: 8080
      weight: 20
EOF
k apply -f 08-gw.yaml
k -n pruef-08 wait --for=condition=Programmed gateway web
NP=$(k -n pruef-08 get svc cilium-gateway-web -o jsonpath='{.spec.ports[0].nodePort}')
for i in $(seq 50); do curl -s -H 'Host: shop.pruef.lab' http://172.16.0.228:$NP/ \
  | jq -r .pod; done | cut -d- -f1,2 | sort | uniq -c
for i in $(seq 10); do curl -s -H 'Host: shop.pruef.lab' -H 'x-beta: on' \
  http://172.16.0.228:$NP/ | jq -r .pod; done | cut -d- -f1,2 | sort | uniq -c

Erwartet (Verteilung schwankt):

gateway.gateway.networking.k8s.io/web created
httproute.gateway.networking.k8s.io/shop created
gateway.gateway.networking.k8s.io/web condition met
     39 shop-v1
     11 shop-v2
     10 shop-v2

"on" steht in Anführungszeichen – unquotiert macht YAML daraus den Wahrheitswert true, und der API-Server lehnt das Feld ab.

Lösung 9

cat > 09.yaml <<'EOF'
apiVersion: cert-manager.io/v1
kind: Certificate
metadata:
  name: secure
  namespace: pruef-09
spec:
  secretName: secure-tls
  dnsNames:
  - secure.pruef.lab
  issuerRef:
    name: pruef-ca
---
apiVersion: gateway.networking.k8s.io/v1
kind: Gateway
metadata:
  name: secure
  namespace: pruef-09
spec:
  gatewayClassName: pruef-nodeport
  listeners:
  - name: http
    protocol: HTTP
    port: 80
    hostname: secure.pruef.lab
  - name: https
    protocol: HTTPS
    port: 443
    hostname: secure.pruef.lab
    tls:
      mode: Terminate
      certificateRefs:
      - name: secure-tls
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: redirect
  namespace: pruef-09
spec:
  parentRefs:
  - name: secure
    sectionName: http
  rules:
  - filters:
    - type: RequestRedirect
      requestRedirect:
        scheme: https
        statusCode: 301
---
apiVersion: gateway.networking.k8s.io/v1
kind: HTTPRoute
metadata:
  name: app
  namespace: pruef-09
spec:
  parentRefs:
  - name: secure
    sectionName: https
  rules:
  - backendRefs:
    - name: app
      port: 8080
EOF
k apply -f 09.yaml
k -n pruef-09 wait --for=condition=Ready certificate secure
k -n pruef-09 wait --for=condition=Programmed gateway secure
S=cilium-gateway-secure
NPH=$(k -n pruef-09 get svc $S -o jsonpath='{.spec.ports[?(@.port==80)].nodePort}')
NPS=$(k -n pruef-09 get svc $S -o jsonpath='{.spec.ports[?(@.port==443)].nodePort}')
k -n pruef-09 get secret secure-tls -o jsonpath='{.data.ca\.crt}' | base64 -d \
  > 09-ca.crt
curl -sI -H 'Host: secure.pruef.lab' http://172.16.0.228:$NPH/x \
  | grep -iE '^HTTP|^location'
curl -s --cacert 09-ca.crt --resolve secure.pruef.lab:$NPS:172.16.0.228 \
  https://secure.pruef.lab:$NPS/ -o /dev/null -w '%{http_code}\n'

Erwartet (gekürzt):

certificate.cert-manager.io/secure condition met
gateway.gateway.networking.k8s.io/secure condition met
HTTP/1.1 301 Moved Permanently
location: https://secure.pruef.lab:443/x
200

Der Redirect zeigt auf Port 443 – im Labor liegt HTTPS auf einem NodePort, mit einem LoadBalancer vor dem Gateway stimmt die Adresse.

Lösung 10

k -n pruef-10 expose deployment public --type=LoadBalancer --port=80 \
  --target-port=8080 --labels=announce=pruef-10
k -n pruef-10 annotate svc public lbipam.cilium.io/ips=10.50.0.99
cat > 10-bgp.yaml <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumLoadBalancerIPPool
metadata:
  name: pruef-10
spec:
  blocks:
  - cidr: 10.50.0.0/24
  serviceSelector:
    matchLabels:
      io.kubernetes.service.namespace: pruef-10
---
apiVersion: cilium.io/v2
kind: CiliumBGPClusterConfig
metadata:
  name: pruef-10
spec:
  nodeSelector:
    matchLabels:
      kubernetes.io/os: linux
  bgpInstances:
  - name: ost
    localASN: 65010
    peers:
    - name: router
      peerASN: 65000
      peerAddress: 172.16.0.123
      peerConfigRef:
        name: pruef-10
---
apiVersion: cilium.io/v2
kind: CiliumBGPPeerConfig
metadata:
  name: pruef-10
spec:
  families:
  - afi: ipv4
    safi: unicast
    advertisements:
      matchLabels:
        advertise: pruef-10
---
apiVersion: cilium.io/v2
kind: CiliumBGPAdvertisement
metadata:
  name: pruef-10
  labels:
    advertise: pruef-10
spec:
  advertisements:
  - advertisementType: Service
    service:
      addresses:
      - LoadBalancerIP
    selector:
      matchLabels:
        announce: pruef-10
EOF
k apply -f 10-bgp.yaml
k -n pruef-10 get svc public
cilium bgp routes advertised ipv4 unicast --node worker1
ssh [email protected] curl -s -m3 http://10.50.0.99/hostname; echo

Erwartet (gekürzt, nach etwa 20 s):

NAME     TYPE           CLUSTER-IP     EXTERNAL-IP   PORT(S)        AGE
public   LoadBalancer   10.101.75.48   10.50.0.99    80:30208/TCP   21s
Node      VRouter   Peer           Prefix          NextHop        Age   Attrs
worker1   65010     172.16.0.123   10.50.0.99/32   172.16.0.228   21s   [{Origin: i} ...
public-5d8587dd9-4g27g

Vier Objekte, eine Kette: ClusterConfig → PeerConfig per Name (peerConfigRef), PeerConfig → Advertisement per Label (advertise), Advertisement → Service per Label (announce); der Pool wählt per Namespace. Die feste IP setzt die Annotation lbipam.cilium.io/ips (Tag 15).

Lösung 11

Egress-Gateway braucht zwei Helm-Schlüssel (Tag 16). Vorher die Werte sichern:

helm get values cilium -n kube-system -o yaml > backup/cilium-values.yaml
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 \
  --reuse-values --set egressGateway.enabled=true --set bpf.masquerade=true
k -n kube-system rollout restart ds/cilium deploy/cilium-operator
k -n kube-system rollout status ds/cilium
cilium config view | grep -E 'enable-egress-gateway|enable-bpf-masquerade'
k label node worker1 pruef-egress=true
cat > 11-egw.yaml <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumEgressGatewayPolicy
metadata:
  name: pruef-11
spec:
  selectors:
  - podSelector:
      matchLabels:
        app: legacy
        io.kubernetes.pod.namespace: pruef-11
  destinationCIDRs:
  - 172.16.0.123/32
  egressGateway:
    nodeSelector:
      matchLabels:
        pruef-egress: "true"
EOF
k apply -f 11-egw.yaml
for p in legacy modern; do k -n pruef-11 exec $p -- \
  curl -s -m3 -o /dev/null -w '%{http_code}\n' http://172.16.0.123:8011/; done
ssh [email protected] tail -2 pruef-11.log
CP=$(k -n kube-system get pod -l k8s-app=cilium \
  --field-selector spec.nodeName=worker1 -o name)
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg bpf egress list

Erwartet (gekürzt):

daemon set "cilium" successfully rolled out
enable-bpf-masquerade                             true
enable-egress-gateway                             true
node/worker1 labeled
ciliumegressgatewaypolicy.cilium.io/pruef-11 created
200
200
172.16.0.228 - - [19/Nov/2026 03:47:24] "GET / HTTP/1.1" 200 -
172.16.0.83 - - [19/Nov/2026 03:47:24] "GET / HTTP/1.1" 200 -
Source IP   Destination CIDR   Egress IP      Gateway IP     Egress Ifindex
10.0.2.58   172.16.0.123/32    172.16.0.228   172.16.0.228   2

legacy kommt als worker1 an, modern weiter als worker2. Der Namespace steht als Label io.kubernetes.pod.namespace im podSelector, weil die CEGP clusterweit gilt. Jetzt zurückbauen wie in Tag 16, genau auf die Sicherung:

k delete cegp pruef-11
k label node worker1 pruef-egress-
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 \
  -f backup/cilium-values.yaml
diff backup/cilium-values.yaml <(helm get values cilium -n kube-system -o yaml) \
  && echo GLEICH
k -n kube-system rollout restart ds/cilium deploy/cilium-operator
k -n kube-system rollout status ds/cilium
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg status \
  | grep Masquerading

Erwartet (gekürzt):

ciliumegressgatewaypolicy.cilium.io "pruef-11" deleted
node/worker1 unlabeled
GLEICH
daemon set "cilium" successfully rolled out
Masquerading:            IPTables [IPv4: Enabled, IPv6: Disabled]

Laut Doku sind Egress-Gateway und ClusterMesh nicht kompatibel. Im Labor lief Aufgabe 7 mit Egress-Gateway allein zwar weiter, unterstützt ist die Kombination aber nicht – deshalb gehört der Rückbau zur Aufgabe.

Lösung 12

Default Deny mit DNS-Ausnahme in einer Policy pro Namespace, dann jede Verbindung zweimal – Egress an der Quelle, Ingress am Ziel:

cat > 12-netpol.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: pruef-12
spec:
  podSelector: {}
  policyTypes: [Ingress, Egress]
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: kube-system
      podSelector:
        matchLabels:
          k8s-app: kube-dns
    ports:
    - {protocol: UDP, port: 53}
    - {protocol: TCP, port: 53}
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: frontend-to-backend
  namespace: pruef-12
spec:
  podSelector:
    matchLabels:
      app: frontend
  policyTypes: [Egress]
  egress:
  - to:
    - podSelector:
        matchLabels:
          app: backend
    ports:
    - port: 8080
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backend-from-frontend
  namespace: pruef-12
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes: [Ingress]
  ingress:
  - from:
    - podSelector:
        matchLabels:
          app: frontend
    ports:
    - port: 8080
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: backend-to-db
  namespace: pruef-12
spec:
  podSelector:
    matchLabels:
      app: backend
  policyTypes: [Egress]
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: pruef-12-db
      podSelector:
        matchLabels:
          app: db
    ports:
    - port: 5432
EOF
cat > 12-db.yaml <<'EOF'
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: default-deny
  namespace: pruef-12-db
spec:
  podSelector: {}
  policyTypes: [Ingress, Egress]
  egress:
  - to:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: kube-system
      podSelector:
        matchLabels:
          k8s-app: kube-dns
    ports:
    - {protocol: UDP, port: 53}
    - {protocol: TCP, port: 53}
---
apiVersion: networking.k8s.io/v1
kind: NetworkPolicy
metadata:
  name: db-from-backend
  namespace: pruef-12-db
spec:
  podSelector:
    matchLabels:
      app: db
  policyTypes: [Ingress]
  ingress:
  - from:
    - namespaceSelector:
        matchLabels:
          kubernetes.io/metadata.name: pruef-12
      podSelector:
        matchLabels:
          app: backend
    ports:
    - port: 5432
EOF
k apply -f 12-netpol.yaml -f 12-db.yaml
k -n pruef-12 exec frontend -- curl -s -m3 backend:8080/hostname; echo
k -n pruef-12 exec deploy/backend -- /agnhost connect db.pruef-12-db:5432 \
  --timeout=3s; echo "rc=$?"
k -n pruef-12 exec frontend -- curl -s -m3 db.pruef-12-db:5432/hostname; echo " rc=$?"
k -n pruef-12 run fremd --image=curlimages/curl:8.17.0 --rm -i --restart=Never \
  --command -- curl -s -m3 backend:8080/hostname; echo " rc=$?"

Erwartet (gekürzt):

networkpolicy.networking.k8s.io/default-deny created
networkpolicy.networking.k8s.io/frontend-to-backend created
networkpolicy.networking.k8s.io/backend-from-frontend created
networkpolicy.networking.k8s.io/backend-to-db created
networkpolicy.networking.k8s.io/default-deny created
networkpolicy.networking.k8s.io/db-from-backend created
backend-75c579f4-q7bn4
rc=0
command terminated with exit code 28
 rc=28
pod pruef-12/fremd terminated (Error)
 rc=28

agnhost connect prüft nur den TCP-Aufbau – Exit 0 heißt: backend erreicht db. Über Namespaces hinweg gehören namespaceSelector und podSelector in ein Listenelement (UND), sonst wird daraus ein ODER (Tag 12).

Lösung 13

cat > 13-cnp.yaml <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: fetch-egress
  namespace: pruef-13
spec:
  endpointSelector:
    matchLabels:
      app: fetch
  egress:
  - toEndpoints:
    - matchLabels:
        k8s:io.kubernetes.pod.namespace: kube-system
        k8s:k8s-app: kube-dns
    toPorts:
    - ports:
      - port: "53"
        protocol: ANY
      rules:
        dns:
        - matchPattern: "*"
  - toFQDNs:
    - matchName: example.com
    toPorts:
    - ports:
      - port: "80"
        protocol: TCP
      rules:
        http:
        - method: GET
EOF
k apply -f 13-cnp.yaml
F="kubectl -n pruef-13 exec fetch -- curl -s -m5 -o /dev/null -w %{http_code}\n"
$F http://example.com/
$F -X POST http://example.com/
$F https://example.com/
$F http://kubernetes.io/
hubble observe -P --port-forward-port 0 -n pruef-13 --protocol http --last 2

Erwartet (gekürzt):

ciliumnetworkpolicy.cilium.io/fetch-egress created
200
403
000
command terminated with exit code 28
000
command terminated with exit code 28
pruef-13/fetch:57426 (ID:88003) -> 104.20.23.154:80 (ID:16777217) http-request
  DROPPED (HTTP/1.1 POST http://example.com/)
pruef-13/fetch:57426 (ID:88003) <- 104.20.23.154:80 (ID:16777217) http-response
  FORWARDED (HTTP/1.1 403 0ms (POST http://example.com/))

Falle: Eine DNS-Regel nur mit matchName: example.com lässt curl hängen. Der Resolver fragt zuerst die Suchliste ab (example.com.pruef-13.svc.cluster.local …), der DNS-Proxy antwortet darauf mit REFUSED, und musl gibt auf. Die Namen beschränkt toFQDNs, nicht die DNS-Regel.

Lösung 14

WireGuard ist ein Helm-Wert mit Agent-Neustart (Tag 13); nodeEncryption bleibt aus, weil nur Pod-Verkehr verschlüsselt werden soll. Die Werte hast du in Aufgabe 11 gesichert, sonst jetzt helm get values … > backup/cilium-values.yaml:

helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 --reuse-values \
  --set encryption.enabled=true --set encryption.type=wireguard
k -n kube-system rollout restart ds/cilium
k -n kube-system rollout status ds/cilium
cilium config view | grep enable-wireguard
for n in cp1 worker1 worker2; do
  CP=$(k -n kube-system get pod -l k8s-app=cilium \
    --field-selector spec.nodeName=$n -o name)
  echo "$n $(k -n kube-system exec $CP -c cilium-agent -- cilium-dbg encrypt status \
    | grep peers)"
done

Erwartet (gekürzt):

daemon set "cilium" successfully rolled out
enable-wireguard                                  true
cp1     Number of peers: 2
worker1     Number of peers: 2
worker2     Number of peers: 2

Nachweis auf der Leitung: in einem zweiten Terminal auf worker1 mitschneiden, dann von probe aus web aufrufen:

ssh [email protected] "sudo timeout 15 tcpdump -nn -i eth0 -c 4 \
  'host 172.16.0.83 and (udp port 8472 or udp port 51871)'"
WEB=$(k -n pruef-14 get pod web -o jsonpath='{.status.podIP}')
k -n pruef-14 exec probe -- curl -s -m3 $WEB:8080/hostname; echo

Erwartet (gekürzt):

web
03:54:43.814553 IP 172.16.0.228.51871 > 172.16.0.83.51871: UDP, length 144
03:54:43.814843 IP 172.16.0.228.51871 > 172.16.0.83.51871: UDP, length 144
03:54:43.815974 IP 172.16.0.83.51871 > 172.16.0.228.51871: UDP, length 144
03:54:43.815975 IP 172.16.0.83.51871 > 172.16.0.228.51871: UDP, length 144

Zwischen den Workern läuft nur noch UDP 51871 (WireGuard), kein VXLAN auf UDP 8472 – das VXLAN-Paket steckt verschlüsselt im Tunnel. Ohne rollout restart bleibt Encryption: Disabled.

Verschlüsselt nur ost, erreichte im Labor kein Pod aus ost mehr einen Pod in west (Aufgabe 7). Im ClusterMesh verschlüsseln alle Cluster mit derselben Methode – hier also zurück zu den gesicherten Werten:

helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 \
  -f backup/cilium-values.yaml
k -n kube-system rollout restart ds/cilium
k -n kube-system rollout status ds/cilium
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg status | grep Encryption

Erwartet (gekürzt):

daemon set "cilium" successfully rolled out
Encryption:              Disabled

Lösung 15

Jeder Pod trägt seinen ServiceAccount als Label io.cilium.k8s.policy.serviceaccount in der Identität (Tag 14):

cat > 15-cnp.yaml <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: notes-by-sa
  namespace: pruef-15
spec:
  endpointSelector:
    matchLabels:
      app: notes
  ingress:
  - fromEndpoints:
    - matchLabels:
        io.cilium.k8s.policy.serviceaccount: reader
    toPorts:
    - ports:
      - port: "8080"
        protocol: TCP
      rules:
        http:
        - method: GET
          path: "/(notes|version)"
  - fromEndpoints:
    - matchLabels:
        io.cilium.k8s.policy.serviceaccount: writer
    toPorts:
    - ports:
      - port: "8080"
        protocol: TCP
      rules:
        http:
        - method: GET
          path: "/(notes|version)"
        - method: POST
          path: "/notes"
EOF
k apply -f 15-cnp.yaml
T='-s -m3 -o /dev/null -w %{http_code}\n'
W='-X POST -H X-API-Key:lab-key-123 -d {"text":"x"}'
for p in reader writer other; do
  echo "$p: GET $(k -n pruef-15 exec $p -- curl $T notes/notes)" \
    "POST $(k -n pruef-15 exec $p -- curl $T $W notes/notes)"
done

Erwartet (gekürzt):

ciliumnetworkpolicy.cilium.io/notes-by-sa created
reader: GET 200 POST 403
writer: GET 200 POST 201
command terminated with exit code 28
command terminated with exit code 28
other: GET 000 POST 000

Lösung 16

Ohne DNS-Regel sieht Hubble nur UDP-Pakete zu Port 53, keine Namen:

hubble observe -P --port-forward-port 0 -n pruef-16 --protocol dns --last 2
hubble observe -P --port-forward-port 0 -n pruef-16 --to-port 53 --last 1

Erwartet (gekürzt; der erste Befehl liefert nichts):

pruef-16/mailer:39303 (ID:68289) -> kube-system/coredns-7cd4959b5-nkb2d:53
  (ID:70078) to-endpoint FORWARDED (UDP)

Eine CNP mit DNS-Regel schaltet den DNS-Proxy ein. Weil eine Egress-Regel Default Deny für die gewählten Pods bedeutet, erlaubt toEntities: all den Rest:

cat > 16-dns-sicht.yaml <<'EOF'
apiVersion: cilium.io/v2
kind: CiliumNetworkPolicy
metadata:
  name: dns-sicht
  namespace: pruef-16
spec:
  endpointSelector: {}
  egress:
  - toEndpoints:
    - matchLabels:
        k8s:io.kubernetes.pod.namespace: kube-system
        k8s:k8s-app: kube-dns
    toPorts:
    - ports:
      - port: "53"
        protocol: ANY
      rules:
        dns:
        - matchPattern: "*"
  - toEntities:
    - all
EOF
k apply -f 16-dns-sicht.yaml
hubble observe -P --port-forward-port 0 -n pruef-16 --protocol dns --last 20 -o json \
  | jq -r 'select(.flow.l7.dns.rcode == 3)
      | .flow.destination.pod_name + " " + .flow.l7.dns.query' | sort | uniq -c
echo "mailer orders.pruef-16-old.svc.cluster.local" > 16.txt
hubble observe -P --port-forward-port 0 --pod pruef-16/mailer --protocol dns --last 1

Erwartet (gekürzt):

ciliumnetworkpolicy.cilium.io/dns-sicht created
      8 mailer orders.pruef-16-old.svc.cluster.local.
pruef-16/mailer:46729 (ID:68289) <- kube-system/coredns-7cd4959b5-nkb2d:53
  (ID:70078) dns-response proxy FORWARDED (DNS Answer RCode: Non-Existent Domain
  TTL: 4294967295 (Proxy orders.pruef-16-old.svc.cluster.local. A))

Rcode 3 ist NXDOMAIN. Die Antwort kommt von CoreDNS, deshalb steht der fragende Pod dort als destination.

Lösung 17

Die Funktion pq aus Tag 19 fragt Prometheus im Pod ab:

pq() {
  k -n tag19-mon exec prometheus-kps-kube-prometheus-stack-prometheus-0 \
    -c prometheus -- promtool query instant http://localhost:9090 "$1"
}
pq 'sum by (source_workload, status) (rate(hubble_http_requests_total{
  destination_namespace="pruef-17"}[2m]))'
Q='topk(1, sum by (source_workload) (rate(hubble_http_requests_total{
  destination_namespace="pruef-17", status=~"4.."}[2m])))'
echo "$Q" > 17-query.txt
pq "$Q"
echo crawler > 17.txt

Erwartet (gekürzt, Werte schwanken):

{source_workload="shop", status="200"} => 0.9545454545454545 @[1795057428.741]
{source_workload="crawler", status="404"} => 0.45579386363636365 @[1795057428.741]
{source_workload="reporter", status="403"} => 0.22175625 @[1795057428.741]
{source_workload="crawler"} => 0.45847999999999994 @[1795057429.41]

Das Label source_workload gibt es nur, weil die Hubble-Metrik httpV2 in Tag 19 mit labelsContext=…source_workload… eingeschaltet wurde. Ohne L7-Policy (api-l7) gäbe es gar keine HTTP-Metriken.

Auswertung

Zähle die Gewichte der Aufgaben, die vollständig und nachweisbar gelöst sind – Teilpunkte gibt es hier nicht. Wer eine Vorgabe umgeht (etwa allowedRoutes: All, Policies löschen, method: ".*"), bekommt für die Aufgabe null.

Ergebnis Einschätzung
85–100 % prüfungsreif
66–84 % bestanden, aber knapp: Schwachstellen wiederholen
unter 66 % die Tage zu den verfehlten Aufgaben wiederholen und neu starten
Aufgaben Lehrplanbereich Tage
1–3 Core Infrastructure and CNI (15 %) 1–5
4–7 Service Networking and DNS (25 %) 6–9, 17
8–11 Advanced Traffic Management (20 %) 10, 11, 15, 16
12–15 Network Security and Policy (25 %) 12–14
16, 17 Observability (15 %) 19, 20

Nicht abgefragt: ReferenceGrant (Tag 10, Tag 21 Runde 6), LLM-Traffic (Tag 18), Mutual Auth (Tag 14) und Multus (Tag 5) – diese Tage vor der Prüfung noch einmal durchgehen.

Aufräumen – CoreDNS zurück, Webserver auf dem router beenden, clusterweite Objekte und Namespaces weg (die Helm-Werte haben Aufgabe 11 und 14 schon zurückgebaut):

grep -v 'resourceVersion:' backup/coredns.yaml | k replace -f -
ssh [email protected] 'pkill -f "http.server 8011"; rm -f pruef-11.log'
k delete -f 10-bgp.yaml
k delete gatewayclass pruef-nodeport
k --context west delete ns pruef-07 --wait=false
for i in $(seq -w 1 17); do k delete ns pruef-$i --wait=false; done
k delete ns pruef-12-db --wait=false

Kontrollpunkt

k get ns | grep -c '^pruef-'; k --context west get ns | grep -c '^pruef-'

Erwartet (nach etwa einer Minute): 0 und 0.

diff <(k -n kube-system get cm coredns -o jsonpath='{.data}') \
  <(k create -f ~/ckne/pruef/backup/coredns.yaml $do -o jsonpath='{.data}') \
  && echo IDENTISCH

Erwartet: IDENTISCH (beide CoreDNS-Pods laden nach etwa einer Minute neu).

k get cegp,ippools,ciliumbgpclusterconfigs,ciliumbgppeerconfigs,ciliumbgpadvertisements
k get gatewayclass

Erwartet: No resources found; als GatewayClass nur cilium.

diff backup/cilium-values.yaml <(helm get values cilium -n kube-system -o yaml) \
  && echo GLEICH
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg status \
  | grep -E 'Masquerading|Encryption'

Erwartet: GLEICH, Masquerading: IPTables … und Encryption: Disabled.

ssh [email protected] "ip route | grep -c proto.bgp"

Erwartet: 0

cilium status | grep -E 'Cilium:|Operator:|Hubble Relay:|ClusterMesh:'
k get pods -A | grep -vE 'Running|Completed'

Erwartet: viermal OK, nur die Kopfzeile.

Viel Erfolg in der Prüfung.