Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 7: kube-proxy und Alternativen

Ziel: Du kennst die Modi von kube-proxy, liest Ciliums eBPF-Load-Balancer aus und schaltest Native Routing, Maglev und DSR live ein – mit Nachweis per tcpdump. · Dauer: ca. 90 min · Voraussetzung: Tag 6

Briefing

  • CKNE: Service Networking and DNS (25 %) – „Understanding kube-proxy and CNI Alternatives“.
  • kube-proxy übersetzt ClusterIPs per iptables, nftables oder IPVS in Pod-Adressen. Cilium ersetzt ihn komplett (KPR): Service-Einträge in eBPF-Maps, Übersetzung am Socket oder an der Netzwerkkarte.
  • Heute mit Eingriff in den Datenpfad: Routing-Modus und Load-Balancer-Modus werden umgestellt und am Ende des Tages wieder zurückgesetzt.
 router .123 ──NodePort :30707──> cp1 ──(SNAT: zurück über cp1 | DSR: direkt)──┐
                                          v                                     │
                                   worker2: echo-… (2 Pods) ────────────────────┘

Drill 1: Die Modi von kube-proxy

Das Labor hat keinen kube-proxy (Tag 0). Was kubeadm sonst ausrollen würde:

mkdir -p ~/ckne/tag07 && cd ~/ckne/tag07
k -n kube-system get cm kube-proxy
kubeadm config print init-defaults --component-configs KubeProxyConfiguration \
  | sed -n '/kind: KubeProxyConfiguration/,$p' | grep -E '^mode|^nftables' -A0

Erwartet:

Error from server (NotFound): configmaps "kube-proxy" not found
mode: iptables
nftables:
Modus Technik Stand in v1.37
iptables Kette pro Service und Endpunkt, Zufallsauswahl Standard
nftables nftables-Maps, schnellere Updates stabil, Kernel ab 5.13
ipvs Kernel-Load-Balancer (rr, lc, sh …) deprecated seit v1.35

Den Modus setzt mode in der ConfigMap kube-proxy (Schlüssel config.conf) oder --proxy-mode. IPVS soll ab v1.40 standardmäßig abgeschaltet und in v1.43 entfernt werden (kubernetes.io, „Virtual IPs and Service Proxies“); der Standard wechselt künftig zu nftables – deshalb den Modus immer explizit setzen. So sieht ein Service im iptables-Modus aus (gekürzt, kann je nach Version abweichen – im Labor nicht vorhanden):

-A KUBE-SERVICES -d 10.97.241.38/32 -p tcp -m tcp --dport 80 -j KUBE-SVC-ABCDEF...
-A KUBE-SVC-ABCDEF... -m statistic --mode random --probability 0.5 -j KUBE-SEP-111...
-A KUBE-SVC-ABCDEF... -j KUBE-SEP-222...
-A KUBE-SEP-111... -p tcp -m tcp -j DNAT --to-destination 10.0.2.144:8080
-A KUBE-SEP-222... -p tcp -m tcp -j DNAT --to-destination 10.0.2.246:8080

Jedes Paket einer neuen Verbindung läuft die Ketten linear ab; tausende Services heißen zehntausende Regeln. Prüfen würdest du das mit sudo iptables-save | grep KUBE-SVC bzw. sudo nft list table ip kube-proxy.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Was Cilium stattdessen tut

k create ns tag07
k config set-context --current --namespace=tag07
k create deployment echo --image=registry.k8s.io/e2e-test-images/agnhost:2.66.1 \
  --replicas=2 --port=8080 -- /agnhost netexec --http-port=8080
k patch deployment echo -p \
  '{"spec":{"template":{"spec":{"nodeSelector":{"kubernetes.io/hostname":"worker2"}}}}}'
k run client --image=nicolaka/netshoot:v0.16 \
  --overrides='{"spec":{"nodeName":"worker1"}}' -- sleep infinity
k expose deployment echo --port=80 --target-port=8080
k expose deployment echo --name=echo-np --type=NodePort --port=80 --target-port=8080
k patch svc echo-np -p '{"spec":{"ports":[{"port":80,"nodePort":30707}]}}'
k rollout status deployment echo
k wait --for=condition=Ready pod/client
k get pods -o wide
sudo iptables-save | grep -c KUBE-SVC
sudo nft list tables
W1=$(k -n kube-system get pod -l k8s-app=cilium \
  --field-selector spec.nodeName=worker1 -o name)
k -n kube-system exec $W1 -c cilium-agent -- cilium-dbg status --verbose \
  | sed -n '/KubeProxyReplacement Details/,/HostPort/p'

Erwartet (gekürzt):

deployment "echo" successfully rolled out
NAME                   READY   STATUS    RESTARTS   AGE   IP           NODE
client                 1/1     Running   0          24s   10.0.1.149   worker1
echo-cc8555f69-f5z5x   1/1     Running   0          25s   10.0.2.246   worker2
echo-cc8555f69-j2qrv   1/1     Running   0          25s   10.0.2.144   worker2
0
table ip mangle
table ip filter
table ip nat
table ip raw
...
KubeProxyReplacement Details:
  Status:               True
  Socket LB:            Enabled
  Socket LB Tracing:    Enabled
  Socket LB Coverage:   Full
  Devices:              eth0    172.16.0.228 ... (Direct Routing)
  Mode:                 SNAT
  Backend Selection:    Random
  Session Affinity:     Enabled
  ...
  Services:
  - ClusterIP:      Enabled
  - NodePort:       Enabled (Range: 30000-32767)
  - LoadBalancer:   Enabled
  - externalIPs:    Enabled
  - HostPort:       Enabled

Keine einzige KUBE-SVC-Regel, keine nftables-Tabelle von kube-proxy. Die drei Zeilen, die du heute änderst: Mode (SNAT/DSR), Backend Selection (Random/Maglev) und – im Hintergrund – der Routing-Modus. Socket LB Coverage: Full heißt: Socket-LB gilt auch in den Pods. Ab Tag 10 steht hier Hostns-only – das Chart erzwingt es, sobald die Gateway API eingeschaltet ist.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Socket-LB – Übersetzung vor dem ersten Paket

Vom Node cp1 aus (Host-Namespace) die ClusterIP aufrufen und mitschneiden:

CIP=$(k get svc echo -o jsonpath='{.spec.clusterIP}'); echo $CIP
sudo timeout 5 tcpdump -nn -i any -c 2 "tcp and (host $CIP or port 8080)" &
sleep 1; curl -s http://$CIP/hostname; echo; wait

Erwartet (gekürzt):

10.97.241.38
echo-cc8555f69-j2qrv
00:01:31.027551 cilium_vxlan Out IP 10.0.0.88.54334 > 10.0.2.144.8080: Flags [S], ...
00:01:31.028554 cilium_vxlan P   IP 10.0.2.144.8080 > 10.0.0.88.54334: Flags [S.], ...

Die ClusterIP taucht auf keiner Schnittstelle auf: Schon beim connect() hat Ciliums eBPF-Programm am Socket das Ziel auf 10.0.2.144:8080 umgeschrieben – kein NAT pro Paket, kein Conntrack-Eintrag für die ClusterIP. Und im Pod?

k exec client -- sh -c "timeout 5 tcpdump -nn -i eth0 -c 2 tcp port 80 or port 8080 \
  2>/dev/null & sleep 1; curl -s echo/hostname; echo; sleep 2"

Erwartet (gekürzt, Pod- und Backend-IPs aus einem späteren Lauf):

echo-84b6bd9b74-mx94v
03:32:50.891746 IP 10.0.1.199.35868 > 10.0.2.163.8080: Flags [S], ...
03:32:50.892497 IP 10.0.2.163.8080 > 10.0.1.199.35868: Flags [S.], ...

Auch im Pod steht direkt die Backend-IP: Bei Coverage Full übersetzt der Socket-LB schon beim connect() im Pod. Ab Tag 10 (Hostns-only) gilt Socket-LB nur im Host-Namespace; dann verlassen Pod-Pakete den Pod mit der ClusterIP und werden am lxc-Interface per eBPF (tc) übersetzt.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Services in den eBPF-Maps

X="kubectl -n kube-system exec $W1 -c cilium-agent --"
$X cilium-dbg service list | grep -A1 -E "$CIP:|:30707"
$X cilium-dbg bpf lb list | grep -E 'SERVICE ADDRESS|'"$CIP:80"
$X cilium-dbg map list | grep -E '^Name|lb4_'

Erwartet (gekürzt):

69   10.97.241.38:80/TCP       ClusterIP      1 => 10.0.2.144:8080/TCP (active)
                                              2 => 10.0.2.246:8080/TCP (active)
73   0.0.0.0:30707/TCP         NodePort       1 => 10.0.2.144:8080/TCP (active)
                                              2 => 10.0.2.246:8080/TCP (active)
SERVICE ADDRESS               BACKEND ADDRESS (REVNAT_ID) (SLOT)
10.97.241.38:80/TCP (1)       10.0.2.144:8080/TCP (69) (1)
10.97.241.38:80/TCP (0)       0.0.0.0:0 (69) (0) [ClusterIP, non-routable]
10.97.241.38:80/TCP (2)       10.0.2.246:8080/TCP (69) (2)
Name                       Num entries   Num errors   Cache enabled
cilium_lb4_reverse_sk      23            0            true
cilium_lb4_affinity        1             0            true
cilium_lb4_backends_v3     22            0            true
cilium_lb4_reverse_nat     21            0            true
cilium_lb4_maglev          0             0            true
cilium_lb4_source_range    0             0            true
cilium_lb4_services_v2     64            0            true

service list ist die Sicht des Agenten, bpf lb list der Inhalt der Map cilium_lb4_services_v2: Slot 0 ist der Service selbst (mit Flags), Slots 1…n die Backends. Die Zahl in Klammern ist die RevNAT-ID, mit der Antworten zurückübersetzt werden. Ein Lookup kostet unabhängig von der Anzahl der Services gleich viel – der größte Unterschied zu iptables.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Native Routing live

Achtung: Die nächsten beiden Drills starten alle Cilium-Agenten neu und ändern den Datenpfad. Vorher die Werte sichern; in Drill 7 geht alles zurück.

helm get values cilium -n kube-system -o yaml > values-vorher.yaml
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 --reuse-values \
  --set routingMode=native --set autoDirectNodeRoutes=true \
  --set ipv4NativeRoutingCIDR=10.0.0.0/16
k -n kube-system rollout restart ds/cilium
k -n kube-system rollout status ds/cilium
cilium status --wait | grep -E 'Cilium:|Operator:'
cilium config view | grep -E '^routing-mode|^auto-direct|native-routing-cidr'
ssh [email protected] "ip route | grep 10.0."
W1=$(k -n kube-system get pod -l k8s-app=cilium \
  --field-selector spec.nodeName=worker1 -o name)
k -n kube-system exec $W1 -c cilium-agent -- cilium-dbg status | grep Routing

Erwartet (gekürzt):

daemon set "cilium" successfully rolled out
 /¯¯\__/¯¯\    Cilium:             OK
 \__/¯¯\__/    Operator:           OK
auto-direct-node-routes                           true
ipv4-native-routing-cidr                          10.0.0.0/16
routing-mode                                      native
10.0.0.0/24 via 172.16.0.126 dev eth0 proto kernel
10.0.1.0/24 via 10.0.1.116 dev cilium_host proto kernel src 10.0.1.116
10.0.1.116 dev cilium_host proto kernel scope link
10.0.2.0/24 via 172.16.0.83 dev eth0 proto kernel
Routing:                 Network: Native   Host: Legacy

Vorher zeigten alle fremden Pod-Netze auf cilium_host (mit MTU 1450 für VXLAN), jetzt auf die Node-IP über eth0. autoDirectNodeRoutes legt diese Routen an – das geht nur, weil alle Nodes im selben L2-Netz liegen. ipv4NativeRoutingCIDR sagt Cilium, welches Ziel ohne Masquerading geroutet wird. Bestehende Pods behalten ihre Route mit mtu 1450 aus dem Tunnel-Modus – erst neu erzeugte Pods bekommen 1500. Also Backends und Client neu anlegen, dann der Nachweis auf worker1:

k rollout restart deployment echo
k rollout status deployment echo
k delete pod client $now
k run client --image=nicolaka/netshoot:v0.16 \
  --overrides='{"spec":{"nodeName":"worker1"}}' -- sleep infinity
k wait --for=condition=Ready pod/client
k exec client -- ip route | head -1
EIP=$(k get pod -l app=echo --sort-by=.metadata.creationTimestamp \
  -o jsonpath='{.items[-1:].status.podIP}')
ssh [email protected] \
  "sudo timeout 8 tcpdump -nn -i eth0 -c 3 host $EIP and tcp port 8080" &
sleep 2; k exec client -- curl -s -m3 http://$EIP:8080/hostname; echo; wait

Erwartet (gekürzt; Pod-Namen und -IPs ändern sich mit dem Neustart, auch in den folgenden Ausgaben):

default via 10.0.1.116 dev eth0 mtu 1500
echo-cc8555f69-f5z5x
00:05:29.587231 IP 10.0.1.149.40578 > 10.0.2.246.8080: Flags [S], ... mss 1460 ...
00:05:29.588129 IP 10.0.2.246.8080 > 10.0.1.149.40578: Flags [S.], ... mss 1460 ...
00:05:29.588423 IP 10.0.1.149.40578 > 10.0.2.246.8080: Flags [.], ack 1, ...

Pod-IPs direkt auf eth0, kein 172.16.0.228.x > 172.16.0.83.8472: OTV mehr wie in Tag 4 – und die MSS der neuen Pods steigt von 1410 auf 1460, weil 50 Byte VXLAN-Kopf wegfallen. Ein alter Pod mit mtu 1450 hätte weiter mss 1410 gezeigt.

Fortschritt speichern? Kostenlos registrieren

Drill 6: DSR und Maglev

Mit SNAT (Tag 6) antwortet das Backend über den Node, der die Anfrage angenommen hat, und sieht dessen Adresse als Absender. DSR (Direct Server Return) lässt das Backend direkt antworten; Maglev wählt das Backend per konsistentem Hash statt zufällig.

helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 --reuse-values \
  --set loadBalancer.mode=dsr --set loadBalancer.algorithm=maglev
k -n kube-system rollout restart ds/cilium
k -n kube-system rollout status ds/cilium
cilium status --wait | grep -E 'Cilium:|Operator:'
cilium config view | grep -E '^bpf-lb-mode |^bpf-lb-algorithm '
W1=$(k -n kube-system get pod -l k8s-app=cilium \
  --field-selector spec.nodeName=worker1 -o name)
k -n kube-system exec $W1 -c cilium-agent -- cilium-dbg status --verbose \
  | grep -E '^  (Mode|Backend Selection):'
k -n kube-system exec $W1 -c cilium-agent -- cilium-dbg bpf lb list \
  | grep '30707/TCP (0)'

Erwartet (gekürzt):

 /¯¯\__/¯¯\    Cilium:             OK
 \__/¯¯\__/    Operator:           OK
bpf-lb-algorithm                                  maglev
bpf-lb-mode                                       dsr
  Mode:                  DSR
  Backend Selection:     Maglev (Table Size: 16381)
172.16.0.228:30707/TCP (0)    0.0.0.0:0 (74) (0) [NodePort, dsr]
0.0.0.0:30707/TCP (0)         0.0.0.0:0 (73) (0) [NodePort, non-routable, dsr]

DSR braucht Native Routing (oder Geneve als Tunnel): Der erste Node reicht das Paket mit der Original-Quelle an das Backend weiter und hängt Service-IP und -Port als IP-Option an (loadBalancer.dsrDispatch=opt, Standard). Der Nachweis vom router, mit Ethernet-Adressen (-e):

ssh [email protected]
sudo timeout 8 tcpdump -nn -e -i eth0 -c 2 tcp port 30707 &
sleep 2; curl -s -m3 http://172.16.0.126:30707/clientip; echo; wait
exit

Erwartet (gekürzt):

172.16.0.123:48046
00:06:42.927752 bc:24:11:4d:d9:08 > bc:24:11:52:2f:dd, ethertype IPv4 (0x0800),
length 74: 172.16.0.123.48046 > 172.16.0.126.30707: Flags [S], ...
00:06:42.928994 bc:24:11:79:de:21 > bc:24:11:4d:d9:08, ethertype IPv4 (0x0800),
length 74: 172.16.0.126.30707 > 172.16.0.123.48046: Flags [S.], ...

Die Anfrage geht an die MAC von cp1 (…:52:2f:dd), die Antwort kommt mit Absender 172.16.0.126 – aber von der MAC von worker2 (…:79:de:21, siehe ip -br link show eth0 auf worker2): Das Backend antwortet selbst. Und der Pod sieht die echte Client-IP 172.16.0.123, obwohl externalTrafficPolicy auf Cluster steht (mit SNAT stand hier 10.0.0.88). Nun die Maglev-Tabelle:

k -n kube-system exec $W1 -c cilium-agent -- cilium-dbg bpf lb maglev list \
  | cut -c1-60
k -n kube-system exec $W1 -c cilium-agent -- cilium-dbg bpf lb maglev list \
  | grep '^\[74\]' | tr -d '[]' | tr -s ' ' '\n' | tail -n +2 | sort | uniq -c

Erwartet:

SVC ID    LOOKUP TABLE
[74]/v4   [59 60 59 59 59 60 60 60 59 60 59 59 59 60 60 60 5
   8191 59
   8190 60

Für das NodePort-Frontend 74 gibt es eine Tabelle mit 16381 Plätzen (eine Primzahl), verteilt auf die Backend-IDs 59 und 60. Jeder Node berechnet dieselbe Tabelle; dieselbe Verbindung landet also auf jedem Node beim selben Backend, und fällt ein Backend weg, wandern nur dessen Plätze um. Wichtig hinter ECMP-Routern (Tag 15), wenn Pakete einer Verbindung an verschiedenen Nodes ankommen. Maglev gilt für Verkehr von außen (NodePort, LoadBalancer); interne ClusterIP-Verbindungen wählt weiter der Socket-LB.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Zurück zu Tunnel, SNAT und Random

Die Sicherung enthält die Schlüssel von heute nicht – also nicht --reuse-values, sondern genau die gesicherten Werte:

helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 -f values-vorher.yaml
diff values-vorher.yaml <(helm get values cilium -n kube-system -o yaml) && echo GLEICH
k -n kube-system rollout restart ds/cilium
k -n kube-system rollout status ds/cilium
cilium status --wait | grep -E 'Cilium:|Operator:'
cilium config view | grep -E '^routing-mode|^auto-direct|^bpf-lb-mode |^bpf-lb-algo'
W1=$(k -n kube-system get pod -l k8s-app=cilium \
  --field-selector spec.nodeName=worker1 -o name)
ssh [email protected] "ip route | grep 10.0.2."
ssh [email protected] curl -s -m3 http://172.16.0.126:30707/clientip; echo

Erwartet (gekürzt):

GLEICH
daemon set "cilium" successfully rolled out
 /¯¯\__/¯¯\    Cilium:             OK
 \__/¯¯\__/    Operator:           OK
auto-direct-node-routes                           false
routing-mode                                      tunnel
10.0.2.0/24 via 10.0.1.116 dev cilium_host proto kernel src 10.0.1.116 mtu 1450
10.0.0.88:54782

bpf-lb-mode und bpf-lb-algorithm fehlen wieder in der ConfigMap – es gelten die Defaults SNAT und Random. Der Client ist wieder hinter cp1 (10.0.0.88) versteckt. Nach dem Neustart heißt der Agent auf worker1 anders – deshalb W1 neu ermitteln.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeige, ob im Cluster ein kube-proxy läuft und in welchem Modus Cilium Services umsetzt. Zeitziel: 45 s
  2. Zeige alle Backends des Service echo aus Sicht des Agenten auf worker2. Zeitziel: 45 s
  3. Zeige Routing-Modus und Tunnel-Protokoll der laufenden Konfiguration. Zeitziel: 20 s
  4. Wie viele Service-Einträge stehen in der eBPF-Map auf worker1? Zeitziel: 30 s

Lösung

k -n kube-system get ds,cm | grep -c kube-proxy
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg status --verbose \
  | grep -E '^  (Status|Mode|Backend Selection):'
W2=$(k -n kube-system get pod -l k8s-app=cilium \
  --field-selector spec.nodeName=worker2 -o name)
k -n kube-system exec $W2 -c cilium-agent -- cilium-dbg service list \
  | grep -A1 "$(k get svc echo -o jsonpath='{.spec.clusterIP}'):"
cilium config view | grep -E '^routing-mode|^tunnel-protocol'
k -n kube-system exec $W1 -c cilium-agent -- cilium-dbg map list | grep services

Erwartet (gekürzt):

0
  Status:               True
  Mode:                 SNAT
  Backend Selection:    Random
69   10.97.241.38:80/TCP       ClusterIP      1 => 10.0.2.144:8080/TCP (active)
                                              2 => 10.0.2.246:8080/TCP (active)
routing-mode                                      tunnel
tunnel-protocol                                   vxlan
cilium_lb4_services_v2     64            0            true

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

diff values-vorher.yaml <(helm get values cilium -n kube-system -o yaml) && echo GLEICH

Erwartet: GLEICH

cilium config view | grep -E '^routing-mode|^bpf-lb-mode '

Erwartet: nur routing-mode tunnel – kein bpf-lb-mode.

ssh [email protected] "ip route | grep 10.0.2."

Erwartet: Route über cilium_host mit mtu 1450.

k get nodes

Erwartet: alle Ready.

k get pods -A | grep -vE 'Running|Completed'

Erwartet: nur die Kopfzeile.

Challenge

Schalte Maglev nur für den Service echo-np ein, ohne die globale Einstellung zu ändern, und weise die Tabelle nach. Entferne die Einstellung danach wieder.

Hinweis: Die Annotation service.cilium.io/lb-algorithm wirkt nur, wenn bpf-lb-algorithm-annotation auf true steht (Helm bpf.lbAlgorithmAnnotation, im Labor an Tag 7 noch false; ab Tag 10 setzt das Chart es mit der Gateway API selbst).

Lösung

cilium config view | grep bpf-lb-algorithm-annotation
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 --reuse-values \
  --set bpf.lbAlgorithmAnnotation=true
k -n kube-system rollout restart ds/cilium
k -n kube-system rollout status ds/cilium
W1=$(k -n kube-system get pod -l k8s-app=cilium \
  --field-selector spec.nodeName=worker1 -o name)
k annotate svc echo-np service.cilium.io/lb-algorithm=maglev
k -n kube-system exec $W1 -c cilium-agent -- cilium-dbg bpf lb maglev list \
  | cut -c1-60
k annotate svc echo-np service.cilium.io/lb-algorithm-
k -n kube-system exec $W1 -c cilium-agent -- cilium-dbg bpf lb maglev list

Erwartet (gekürzt, Service- und Backend-IDs je nach Lauf):

bpf-lb-algorithm-annotation                       false
Release "cilium" has been upgraded. Happy Helming!
daemon set "cilium" successfully rolled out
service/echo-np annotated
SVC ID    LOOKUP TABLE
[79]/v4   [127 128 127 128 128 128 127 127 128 127 128 127 1
[77]/v4   [127 128 127 128 128 128 127 127 128 127 128 127 1
service/echo-np annotated
SVC ID   LOOKUP TABLE

Ohne den Helm-Wert bleibt die Tabelle leer. Der Agent-Neustart ist einmalig; danach ist die Annotation der schonendere Weg für einzelne Services. Den Helm-Wert nimmt das Aufräumen wieder zurück.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

k delete namespace tag07
k config set-context --current --namespace=default
helm upgrade cilium cilium/cilium -n kube-system --version 1.20.5 -f values-vorher.yaml
diff values-vorher.yaml <(helm get values cilium -n kube-system -o yaml) && echo GLEICH
k -n kube-system rollout restart ds/cilium
k -n kube-system rollout status ds/cilium

Erwartet (gekürzt): GLEICH und daemon set "cilium" successfully rolled out.

Routing-Modus und Load-Balancer-Modus sind seit Drill 7 zurückgesetzt, der Helm-Upgrade nimmt nur bpf.lbAlgorithmAnnotation aus der Challenge zurück (ohne Challenge ändert er nichts).

Prüfungstipp

  • kube-proxy-Modus steht in der ConfigMap kube-proxy (mode:); ohne kube-proxy zeigt cilium-dbg status --verbose die Details der Ersetzung.
  • DSR ohne Native Routing (oder Geneve) funktioniert nicht; Native Routing braucht Routen zu den Pod-CIDRs (autoDirectNodeRoutes nur im selben L2-Netz, sonst BGP).
  • Doku-Stellen: kubernetes.io „Virtual IPs and Service Proxies“, docs.cilium.io „Kubernetes Without kube-proxy“ (Maglev, DSR) und „Routing“.

Enterprise-Notiz

  • Routing- und LB-Modus beim Aufbau festlegen; ein Wechsel im Betrieb startet alle Agenten neu und unterbricht laufende Verbindungen kurz.
  • Native Routing spart Overhead und MTU-Probleme, verlangt aber ein Netz, das Pod-CIDRs kennt (BGP zu Top-of-Rack-Switches, Cloud-Routen) – sonst bleibt der Tunnel.
  • DSR erhält Client-IPs und entlastet den Eingangs-Node, kann aber an Firewalls mit asymmetrischem Routing oder an IP-Options-Filtern scheitern (dann dsrDispatch=geneve oder loadBalancer.mode=hybrid: DSR für TCP, SNAT für UDP).
  • Maglev kostet Speicher pro Service (Tabellengröße × Services); für sehr viele Services maglev.tableSize bewusst wählen.
  • Bei Migrationen von kube-proxy zu Cilium: alte KUBE-*-Regeln auf den Nodes aufräumen (kube-proxy --cleanup), sonst konkurrieren zwei Datenpfade.