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' -A0Erwartet:
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; waitErwartet (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 RoutingErwartet (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; waitErwartet (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
exitErwartet (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 -cErwartet:
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; echoErwartet (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
- Zeige, ob im Cluster ein kube-proxy läuft und in welchem Modus Cilium Services umsetzt. Zeitziel: 45 s
- Zeige alle Backends des Service
echoaus Sicht des Agenten aufworker2. Zeitziel: 45 s - Zeige Routing-Modus und Tunnel-Protokoll der laufenden Konfiguration. Zeitziel: 20 s
- 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 servicesErwartet (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 GLEICHErwartet: 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 nodesErwartet: 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 listErwartet (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/ciliumErwartet (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 zeigtcilium-dbg status --verbosedie Details der Ersetzung. - DSR ohne Native Routing (oder Geneve) funktioniert nicht; Native
Routing braucht Routen zu den Pod-CIDRs
(
autoDirectNodeRoutesnur 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=geneveoderloadBalancer.mode=hybrid: DSR für TCP, SNAT für UDP). - Maglev kostet Speicher pro Service (Tabellengröße × Services); für
sehr viele Services
maglev.tableSizebewusst wählen. - Bei Migrationen von kube-proxy zu Cilium: alte
KUBE-*-Regeln auf den Nodes aufräumen (kube-proxy --cleanup), sonst konkurrieren zwei Datenpfade.