Tag 4: Pod-Konnektivität debuggen
Ziel: Du verfolgst ein Paket von Pod zu Pod durch den VXLAN-Tunnel, prüfst DNS im Pod und findest vier typische Fehler in Minuten statt Stunden. · Dauer: ca. 90 min · Voraussetzung: Tag 1
Briefing
„Pod A erreicht Service B nicht“ ist die häufigste Netzwerkaufgabe.
Arbeite von unten nach oben: Pod läuft und ist Ready →
Pod-IP direkt erreichbar → Service hat Endpunkte → DNS löst auf → Policy
verwirft nichts. Lehrplanbezug: „CKNE: Core Infrastructure and CNI“ und
„Service Networking and DNS“.
worker1 .228 worker2 .83
c1 10.0.1.58 --lxc--+ +--lxc-- web 10.0.2.133
| eBPF | eBPF
cilium_vxlan cilium_vxlan
| |
eth0 ==UDP 8472==> eth0 VNI = Security Identity
Drill 1: Pod zu Pod – gleicher und anderer Node
Zwei web-Pods und je ein netshoot-Client pro Worker.
nodeName per --overrides setzt den Node fest,
am Scheduler vorbei:
mkdir -p ~/ckne/tag04 && cd ~/ckne/tag04
k create ns tag04
k config set-context --current --namespace=tag04
k create deployment web --image=nginx:1.29 --replicas=2 --port=80
k expose deployment web --port=80
k run c1 --image=nicolaka/netshoot:v0.16 \
--overrides='{"spec":{"nodeName":"worker1"}}' -- sleep infinity
k run c2 --image=nicolaka/netshoot:v0.16 \
--overrides='{"spec":{"nodeName":"worker2"}}' -- sleep infinity
k rollout status deploy web
k wait --for=condition=Ready pod/c1 pod/c2
k get pods -o wideErwartet (gekürzt):
deployment "web" successfully rolled out
NAME READY STATUS RESTARTS AGE IP NODE ...
c1 1/1 Running 0 2s 10.0.1.58 worker1 ...
c2 1/1 Running 0 2s 10.0.2.9 worker2 ...
web-c5748c689-ch6ck 1/1 Running 0 3s 10.0.1.28 worker1 ...
web-c5748c689-mmfhx 1/1 Running 0 3s 10.0.2.133 worker2 ...
Landen beide web-Pods auf demselben Node, k delete pod
auf einen davon, bis sie verteilt sind. Jetzt von c1 zu
beiden web-Pods – deine IPs einsetzen:
k exec c1 -- ping -c 2 10.0.1.28
k exec c1 -- ping -c 2 10.0.2.133
k exec c1 -- traceroute -n -w 1 -q 1 10.0.2.133
k exec c1 -- curl -s -o /dev/null -w '%{remote_ip} %{http_code}\n' \
http://10.0.2.133Erwartet (gekürzt):
64 bytes from 10.0.1.28: icmp_seq=1 ttl=63 time=0.486 ms
64 bytes from 10.0.1.28: icmp_seq=2 ttl=63 time=0.181 ms
64 bytes from 10.0.2.133: icmp_seq=1 ttl=63 time=1.16 ms
64 bytes from 10.0.2.133: icmp_seq=2 ttl=63 time=0.985 ms
traceroute to 10.0.2.133 (10.0.2.133), 30 hops max, 46 byte packets
1 *
2 10.0.2.133 1.125 ms
10.0.2.133 200
Beide Male ttl=63: Cilium routet genau einmal, der
Tunnel zählt nicht als Hop. Den Hop 1 (*) beantwortet
niemand – Cilium verwirft Pakete mit abgelaufener TTL ohne ICMP-Antwort
(Hubble zeigt sie als TTL exceeded DROPPED). Der andere
Node kostet knapp eine Millisekunde mehr.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Ein Paket im VXLAN-Tunnel
Auf worker2 an der echten Netzwerkkarte
mitschneiden. Dort sieht man den Tunnel von außen: UDP-Port 8472, darin
das Original-Paket. grep -B1 zeigt Außen- und Innenzeile
zusammen, -l schaltet den Puffer von tcpdump ab:
ssh [email protected]
sudo tcpdump -l -i eth0 -nn udp port 8472 | grep -B1 '10.0.2.133.80'Zweites Terminal auf cp1:
k exec c1 -- curl -s -o /dev/null http://10.0.2.133Erwartet (gekürzt, auf worker2; Strg+C beendet):
23:23:28.461401 IP 172.16.0.228.33863 > 172.16.0.83.8472: OTV, flags [I] (0x08),
overlay 0, instance 15560
IP 10.0.1.58.49676 > 10.0.2.133.80: Flags [S], seq 1386761792, win 64860, ...
23:23:28.461902 IP 172.16.0.83.35844 > 172.16.0.228.8472: OTV, flags [I] (0x08),
overlay 0, instance 7949
IP 10.0.2.133.80 > 10.0.1.58.49676: Flags [S.], seq 1652975976, ack 1386761793, ...
Außen sprechen nur die Nodes miteinander (172.16.0.228 → .83), innen
die Pods. tcpdump hält 8472 für das Cisco-Protokoll OTV und nennt die
VXLAN-ID instance. Cilium schreibt dort die
Security Identity des Absenders hinein: 15560 ist
c1, 7949 sind die web-Pods
(k get ciliumendpoints zeigt die Zahlen). So kennt der
Ziel-Node die Identität, ohne die IP nachschlagen zu müssen.
Zum Vergleich: c2 liegt auf demselben Node wie der
web-Pod. Weiter auf worker2:
sudo tcpdump -i any -nn -c 4 host 10.0.2.9 and tcp port 80
exitZweites Terminal:
k exec c2 -- curl -s -o /dev/null http://10.0.2.133
Erwartet (gekürzt):
23:24:09.968758 lxc611782528228 In IP 10.0.2.9.59196 > 10.0.2.133.80: Flags [S], ...
23:24:09.968843 lxc5c7bb2eb961a Out IP 10.0.2.9.59196 > 10.0.2.133.80: Flags [S], ...
23:24:09.968906 lxc5c7bb2eb961a In IP 10.0.2.133.80 > 10.0.2.9.59196: Flags [S.], ...
23:24:09.968936 lxc611782528228 Out IP 10.0.2.133.80 > 10.0.2.9.59196: Flags [S.], ...
Von lxc zu lxc, kein
cilium_vxlan, nichts auf eth0.
Tunnel oder Native Routing? Das Labor läuft im Tunnelmodus:
cilium config view | grep -E '^routing-mode|^tunnel-protocol|^auto-direct'Erwartet:
auto-direct-node-routes false
routing-mode tunnel
tunnel-protocol vxlan
Tunnel (VXLAN, UDP 8472, oder Geneve, UDP 6081) braucht vom Netz nur,
dass sich die Nodes erreichen – kostet aber 50 Byte pro Paket (MTU 1450)
und etwas CPU. Bei Native Routing
(routingMode=native) gehen Pod-Pakete unverpackt über
eth0; das Netz muss dann die Pod-CIDRs kennen – per
autoDirectNodeRoutes (alle Nodes in einem L2-Segment) oder
BGP (Tag 15). Umgeschaltet wird in Tag 7.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Hubble und cilium-dbg zum selben Paket
hubble observe zeigt Flows mit Pod-Namen und Identity.
Wie in Tag 0 baut -P --port-forward-port 0 für jeden Aufruf
einen eigenen Port-Forward zum Relay auf:
k exec c1 -- curl -s -o /dev/null http://10.0.2.133
hubble observe -P --port-forward-port 0 --pod tag04/c1 --tcp-flags SYN --last 2Erwartet (gekürzt, ohne Zeitstempel):
tag04/c1:54660 (ID:15560) -> tag04/web-...-mmfhx:80 (ID:7949) to-endpoint FORWARDED (TCP
Flags: SYN)
tag04/c1:54660 (ID:15560) <- tag04/web-...-mmfhx:80 (ID:7949) to-overlay FORWARDED (TCP
Flags: SYN, ACK)
tag04/c1:54660 (ID:15560) -> tag04/web-...-mmfhx:80 (ID:7949) to-overlay FORWARDED (TCP
Flags: SYN)
tag04/c1:54660 (ID:15560) <- tag04/web-...-mmfhx:80 (ID:7949) to-endpoint FORWARDED (TCP
Flags: SYN, ACK)
--last 2 gilt pro Node, deshalb vier Zeilen. Jedes Paket
über Nodes hinweg erscheint zweimal: to-overlay auf dem
sendenden Node (ab in den Tunnel), to-endpoint auf dem
empfangenden (Zustellung an den Pod). Fehlt eine Hälfte, bleibt das
Paket dazwischen hängen – Tunnel, Firewall, MTU. Die Reihenfolge wirkt
vertauscht, weil jeder Node mit seiner eigenen Uhr stempelt.
Dieselbe Verbindung im Agenten von worker2. Die
Endpoint-ID kommt aus endpoint list:
CP=$(k -n kube-system get pod -l k8s-app=cilium \
--field-selector spec.nodeName=worker2 -o name)
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg endpoint list \
| grep -E 'ENDPOINT|10.0.2.133 '
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg endpoint health 532
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg monitor --related-to 532Zweites Terminal:
k exec c1 -- curl -s -o /dev/null http://10.0.2.133, dann
Strg+C.
Erwartet (gekürzt):
ENDPOINT POLICY (ingress) ... IDENTITY LABELS IPv4 STATUS
532 Disabled ... 7949 k8s:app=web 10.0.2.133 ready
Overall Health: OK
BPF Health: OK
Policy Health: OK
Connected: yes
Listening for events on 2 CPUs with 64x4096 of shared memory
-> endpoint 532 flow 0x0 , identity 15560->7949 state new ifindex lxc5c7bb2eb961a
orig-ip 10.0.1.58: 10.0.1.58:51150 -> 10.0.2.133:80 tcp SYN
-> overlay flow 0x9bc4cf10 , identity 7949->15560 state reply ifindex cilium_vxlan
orig-ip 0.0.0.0: 10.0.2.133:80 -> 10.0.1.58:51150 tcp SYN, ACK
monitor ist die Rohsicht des Datenpfads auf einem Node,
Hubble die aufbereitete Sicht über alle Nodes. --type drop
filtert nur Verwerfungen.
Fortschritt speichern? Kostenlos registrieren
Drill 4: DNS im Pod
k exec c1 -- cat /etc/resolv.conf
k -n kube-system get svc kube-dns
k exec c1 -- nslookup web
k exec c1 -- dig +short web
k exec c1 -- dig +short +search web
k exec c1 -- dig +short 10-0-1-28.tag04.pod.cluster.localErwartet (gekürzt):
search tag04.svc.cluster.local svc.cluster.local cluster.local localdomain
nameserver 10.96.0.10
options ndots:5
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
kube-dns ClusterIP 10.96.0.10 <none> 53/UDP,53/TCP,9153/TCP 47m
Server: 10.96.0.10
Address: 10.96.0.10#53
Name: web.tag04.svc.cluster.local
Address: 10.108.6.68
10.108.6.68
10.0.1.28
dig web gibt nichts zurück: dig nutzt die
search-Liste nur mit +search,
nslookup und Anwendungen immer. localdomain
stammt aus der resolv.conf des Nodes. ndots:5
bedeutet: Namen mit weniger als fünf Punkten probiert der Resolver
zuerst mit jedem Suffix. Wie teuer das für externe Namen ist:
k exec c1 -- dig +search +showsearch +noall +question example.com
k exec c1 -- dig +search +showsearch +noall +question example.com.Erwartet:
;example.com.tag04.svc.cluster.local. IN A
;example.com.svc.cluster.local. IN A
;example.com.cluster.local. IN A
;example.com.localdomain. IN A
;example.com. IN A
;example.com. IN A
Fünf Anfragen statt einer – vier davon NXDOMAIN. Der
Punkt am Ende macht den Namen absolut. Tag 8 senkt ndots
und zeigt, wie ein node-lokaler DNS-Cache mit Cilium funktioniert.
Hubble zeigt, wohin die Anfragen wirklich gehen:
hubble observe -P --port-forward-port 0 --from-pod tag04/c1 --port 53 --last 2Erwartet (gekürzt):
tag04/c1:52764 (ID:15560) -> kube-system/coredns-559f6c778d-vwrtf:53 (ID:13185)
to-overlay FORWARDED (UDP)
tag04/c1:52764 (ID:15560) -> kube-system/coredns-559f6c778d-vwrtf:53 (ID:13185)
to-endpoint FORWARDED (UDP)
Ziel ist direkt ein CoreDNS-Pod, nicht 10.96.0.10: Ciliums Socket-LB
übersetzt die Service-IP schon beim
connect()/sendmsg() im Pod.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Fehler – falscher Port und kaputter Selector
Zwei kaputte Services auf dasselbe Deployment:
k expose deploy web --name=web-port --port=80 --target-port=8080
k expose deploy web --name=web-sel --port=80 --selector=app=wep
k exec c1 -- curl -sS -m 3 http://web-port
k exec c1 -- curl -sS -m 3 http://web-selErwartet:
curl: (7) Failed to connect to web-port:80 after 29 ms: Could not connect to server
command terminated with exit code 7
curl: (7) Failed to connect to web-sel:80 after 25 ms: Could not connect to server
command terminated with exit code 7
Gleiche Fehlermeldung, verschiedene Ursachen. Die EndpointSlices trennen beide:
k get endpointslices
k describe svc web-sel | grep -E 'Selector|Endpoints'
k get pods --show-labelsErwartet (gekürzt):
NAME ADDRESSTYPE PORTS ENDPOINTS AGE
web-7ddlt IPv4 80 10.0.1.28,10.0.2.133 2m
web-port-54k6z IPv4 8080 10.0.2.133,10.0.1.28 1s
web-sel-n6bkf IPv4 <unset> <unset> 1s
Selector: app=wep
Endpoints:
NAME READY STATUS RESTARTS AGE LABELS
web-c5748c689-ch6ck 1/1 Running 0 2m9s app=web,pod-template-hash=...
web-port hat Endpunkte, aber auf Port 8080 – nginx
lauscht auf 80 (Tag 1, ss -tlnp). web-sel hat
gar keine: Kein Pod trägt app=wep. Dasselbe sieht Cilium
(deine Service-IPs einsetzen):
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 service list \
| grep -A1 -E '10.108.101.88|10.105.22.150'
hubble observe -P --port-forward-port 0 --pod tag04/c1 --last 200 \
| grep 8080 | tail -2Erwartet (gekürzt):
53 10.108.101.88:80/TCP ClusterIP 1 => 10.0.1.28:8080/TCP (active)
2 => 10.0.2.133:8080/TCP (active)
54 10.105.22.150:80/TCP ClusterIP
tag04/c1:59886 (ID:15560) -> tag04/web-...-ch6ck:8080 (ID:7949) to-endpoint FORWARDED
(TCP Flags: SYN)
tag04/c1:59886 (ID:15560) <- tag04/web-...-ch6ck:8080 (ID:7949) to-endpoint FORWARDED
(TCP Flags: ACK, RST)
Falscher Port: Das Paket kommt an, der Pod antwortet mit
RST. Leerer Selector: In Hubble gibt es gar
keinen Flow, denn ohne Backend lehnt der Socket-LB das
connect() ab, bevor ein Paket entsteht. Reparatur:
k patch svc web-port -p '{"spec":{"ports":[{"port":80,"targetPort":80}]}}'
k set selector svc web-sel app=web
k exec c1 -- curl -s -o /dev/null -w '%{http_code}\n' http://web-port
k exec c1 -- curl -s -o /dev/null -w '%{http_code}\n' http://web-selErwartet:
service/web-port patched
service/web-sel selector updated
200
200
Fortschritt speichern? Kostenlos registrieren
Drill 6: Fehler – dnsPolicy None
Ein Pod mit eigener DNS-Konfiguration. Ohne dnsConfig
lehnt der API-Server dnsPolicy: None ab – mit einem
falschen Nameserver nicht:
cat > c3.yaml <<'EOF'
apiVersion: v1
kind: Pod
metadata:
labels:
run: c3
name: c3
spec:
dnsPolicy: None
dnsConfig:
nameservers:
- 172.16.0.1
containers:
- name: c3
image: nicolaka/netshoot:v0.16
args: ["sleep", "infinity"]
EOF
k apply -f c3.yaml
k wait --for=condition=Ready pod/c3
k exec c3 -- curl -sS -m 5 http://web
k exec c3 -- dig +short example.com
k exec c3 -- cat /etc/resolv.confErwartet:
pod/c3 created
pod/c3 condition met
curl: (6) Could not resolve host: web (Domain name not found)
command terminated with exit code 6
104.20.23.154
172.66.147.243
nameserver 172.16.0.1
Externe Namen gehen, Cluster-Namen nicht: kein CoreDNS, keine
search-Liste. Der Router des Heimnetzes kennt
web nicht. dnsPolicy lässt sich an einem
laufenden Pod nicht ändern
(pod updates may not change fields …), also Manifest
korrigieren und ersetzen:
sed -i '/dnsPolicy/,/172.16.0.1/d' c3.yaml
k replace --force -f c3.yaml
k wait --for=condition=Ready pod/c3
k exec c3 -- curl -s -o /dev/null -w '%{http_code}\n' http://webErwartet:
pod "c3" deleted from tag04 namespace
pod/c3 replaced
pod/c3 condition met
200
Ohne dnsPolicy gilt der Standard
ClusterFirst. Default hieße übrigens nicht
„Standard“, sondern „DNS des Nodes“ – eine beliebte Falle
(k explain pod.spec.dnsPolicy).
Fortschritt speichern? Kostenlos registrieren
Drill 7: Fehler – Pod ohne Endpunkt
Der Pod läuft, der Service zeigt auf ihn – und trotzdem kommt nichts an. Die Readiness-Probe prüft den falschen Port:
cat > shop.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: shop
spec:
replicas: 1
selector:
matchLabels:
app: shop
template:
metadata:
labels:
app: shop
spec:
containers:
- image: nginx:1.29
name: nginx
ports:
- containerPort: 80
readinessProbe:
httpGet:
path: /
port: 8080
periodSeconds: 3
EOF
k apply -f shop.yaml
k expose deployment shop --port=80
k get pods -l app=shop -o wide
k exec c1 -- curl -sS -m 3 http://shopErwartet (gekürzt, nach rund 15 Sekunden):
NAME READY STATUS RESTARTS AGE IP NODE ...
shop-5788d84c8b-m5msf 0/1 Running 0 15s 10.0.2.233 worker2 ...
curl: (7) Failed to connect to shop:80 after 38 ms: Could not connect to server
0/1 ist der Hinweis. Die EndpointSlice führt den Pod,
aber als nicht bereit:
J='{range .items[*].endpoints[*]}{.addresses[0]}'
J+=' ready={.conditions.ready}{"\n"}{end}'
k get endpointslices -l kubernetes.io/service-name=shop -o jsonpath="$J"
k get events --field-selector reason=Unhealthy | tail -1
k -n kube-system exec $CP -c cilium-agent -- cilium-dbg service list \
| grep -A1 "$(k get svc shop -o jsonpath='{.spec.clusterIP}')"
k exec c1 -- curl -s -o /dev/null -w '%{http_code}\n' http://10.0.2.233Erwartet (gekürzt):
10.0.2.233 ready=false
0s Warning Unhealthy pod/shop-5788d84c8b-m5msf Readiness probe failed:
Get "http://10.0.2.233:8080/": dial tcp 10.0.2.233:8080: connect: connection refused
56 10.102.96.240:80/TCP ClusterIP 1 => 10.0.2.233:80/TCP (maintenance)
200
Cilium führt das Backend als maintenance und schickt
nichts hin. Direkt über die Pod-IP antwortet nginx – das Netz ist also
in Ordnung, nur die Probe nicht. Reparatur:
k patch deploy shop --type=json -p '[{"op":"replace",
"path":"/spec/template/spec/containers/0/readinessProbe/httpGet/port","value":80}]'
k rollout status deploy shop
k exec c1 -- curl -s -o /dev/null -w '%{http_code}\n' http://shopErwartet (gekürzt):
deployment.apps/shop patched
deployment "shop" successfully rolled out
200
Fortschritt speichern? Kostenlos registrieren
Drill 8: cilium connectivity test – nur ein Test
Der komplette Selbsttest dauert 20 Minuten (Tag 0).
--test nimmt reguläre Ausdrücke und wählt einzelne Tests,
--test-namespace den Namen des Test-Namespace (eine Nummer
wird angehängt):
cilium connectivity test --test-namespace tag04-ct --test no-policiesErwartet (gekürzt, ohne Symbole, nach rund 30 Sekunden):
[kubernetes] Creating namespace tag04-ct-1 for connectivity check...
...
[kubernetes] Creating namespace cilium-test-ccnp1 for connectivity check...
[kubernetes] Creating namespace cilium-test-ccnp2 for connectivity check...
...
[tag04-ct-1] Running 138 tests ...
[=] [tag04-ct-1] Test [no-policies] [1/138]
....................................................
[=] [tag04-ct-1] Test [no-policies-extra] [4/138]
..................
[tag04-ct-1] All 2 tests (70 actions) successful, 136 tests skipped, 0 scenarios
skipped.
no-policies prüft Pod-zu-Pod, Pod-zu-Service,
Pod-zu-Host und NodePorts auf beiden Nodes ohne Policies – ein guter
Schnelltest nach jeder Netzwerkänderung. Die Namen aller Tests stehen in
der Ausgabe eines Laufs. Die beiden ccnp-Namespaces legt
der Test immer an. Aufräumen:
k delete ns tag04-ct-1 cilium-test-ccnp1 cilium-test-ccnp2Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Welchen Nameserver und welchen
ndots-Wert nutzt Podc2? Zeitziel: 10 s - Zeige die Backends des Service
webin Ciliums Service-Tabelle. Zeitziel: 40 s - Zeige die letzten 5 verworfenen Flows im Namespace
tag04. Zeitziel: 15 s - Löse aus
c1die ClusterIP des Servicewebper Reverse-Lookup in einen Namen auf. Zeitziel: 20 s
Lösung
k exec c2 -- cat /etc/resolv.conf
W=$(k get svc web -o jsonpath='{.spec.clusterIP}')
k -n kube-system exec ds/cilium -c cilium-agent -- cilium-dbg service list \
| grep -A1 "$W:80"
hubble observe -P --port-forward-port 0 -n tag04 --verdict DROPPED --last 5
k exec c1 -- dig +short -x "$W"Erwartet (gekürzt):
search tag04.svc.cluster.local svc.cluster.local cluster.local localdomain
nameserver 10.96.0.10
options ndots:5
50 10.108.6.68:80/TCP ClusterIP 1 => 10.0.1.28:80/TCP (active)
2 => 10.0.2.133:80/TCP (active)
tag04/c1:58918 (ID:15560) <> tag04/web-...-ch6ck:33435 (ID:7949) TTL exceeded DROPPED
(UDP)
web.tag04.svc.cluster.local.
Die Service-Tabelle ist auf allen Nodes gleich, deshalb reicht hier
ds/cilium. Die verworfenen Flows stammen vom
traceroute aus Drill 1.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
k get podsErwartet: c1, c2,
c3, zwei web-… und ein shop-…,
alle 1/1 Running.
k get endpointslicesErwartet: web, web-port,
web-sel mit Port 80 und beiden web-IPs,
shop mit einer IP.
k exec c3 -- cat /etc/resolv.confErwartet: nameserver 10.96.0.10 und
options ndots:5.
k exec c1 -- curl -s -o /dev/null -w '%{http_code}\n' http://shopErwartet: 200
k get ns | grep -E 'tag04-ct|cilium-test'Erwartet: keine Ausgabe.
Challenge
Lege das folgende Deployment api mit Service an. Der
Service hat einen Endpunkt, aber curl http://api aus
c1 scheitert. Finde und behebe den Fehler, ohne das
Deployment zu ändern.
k apply -f - <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: api
spec:
replicas: 1
selector:
matchLabels:
app: api
template:
metadata:
labels:
app: api
spec:
containers:
- name: nginx
image: nginx:1.29
ports:
- name: web
containerPort: 80
---
apiVersion: v1
kind: Service
metadata:
name: api
spec:
selector:
app: api
ports:
- port: 80
targetPort: http
EOFHinweis: Schau auf die Spalte PORTS der
EndpointSlice und vergleiche mit den ports des
Containers.
Lösung
k get endpointslices -l kubernetes.io/service-name=api
k get pod -l app=api -o jsonpath='{.items[0].spec.containers[0].ports}'; echo
k patch svc api -p '{"spec":{"ports":[{"port":80,"targetPort":"web"}]}}'
k get endpointslices -l kubernetes.io/service-name=api
k exec c1 -- curl -s -o /dev/null -w '%{http_code}\n' http://apiErwartet:
NAME ADDRESSTYPE PORTS ENDPOINTS AGE
api-dbkbn IPv4 <unset> 10.0.1.139 2s
[{"containerPort":80,"name":"web","protocol":"TCP"}]
service/api patched
NAME ADDRESSTYPE PORTS ENDPOINTS AGE
api-dbkbn IPv4 80 10.0.1.139 14s
200
Ein benannter targetPort muss genau so im Container
heißen. Passt der Name nicht, bleibt der Port der EndpointSlice leer,
und Cilium legt den Service ganz ohne Backends an.
Fortschritt speichern? Kostenlos registrieren
Aufräumen
k config set-context --current --namespace=default
k delete ns tag04Clusterweit bleibt nichts zurück; an Cilium wurde heute nichts geändert.
Prüfungstipp
- Reihenfolge:
k get pods -o wide(Ready?) → Pod-IP direkt (curl) →k get endpointslices→nslookupim Pod →hubble observe --verdict DROPPED. - Gleiche curl-Meldung heißt nicht gleiche Ursache: kein Flow in
Hubble = kein Backend;
RST= falscher Port;0/1 Ready= Probe. - Doku: kubernetes.io „Debug Services“ und „Debugging DNS Resolution“, docs.cilium.io „Troubleshooting“ und „Routing“.
Enterprise-Notiz
- Native Routing spart Overhead und macht Pod-IPs im Netz sichtbar, braucht aber Absprache mit dem Netzwerkteam (Routen oder BGP); Tunnel ist der bequeme Standard.
- UDP 8472 (VXLAN) bzw. 6081 (Geneve) und TCP 4240 (Health) müssen zwischen allen Nodes offen sein – Cloud-Security-Groups sind der häufigste Grund für „nur Node-übergreifend kaputt“.
- MTU durchgängig planen: Tunnel plus Verschlüsselung (Tag 13) plus
VPN kann Pakete sprengen; Symptom sind hängende TLS-Handshakes bei
funktionierendem
ping. ndots:5erzeugt viel DNS-Last für externe Namen – NodeLocal DNSCache oder angepasstesdnsConfig(Tag 8).- Readiness-Probes gehören zur Netzwerk-Verfügbarkeit: Ein falscher Probe-Port nimmt einen gesunden Dienst still aus dem Verkehr.