Zum Inhalt springen
Trainingslager IT-Trainingslager

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 wide

Erwartet (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.133

Erwartet (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.133

Erwartet (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
exit

Zweites 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 2

Erwartet (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 532

Zweites 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.local

Erwartet (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 2

Erwartet (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-sel

Erwartet:

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-labels

Erwartet (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 -2

Erwartet (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-sel

Erwartet:

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.conf

Erwartet:

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://web

Erwartet:

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://shop

Erwartet (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.233

Erwartet (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://shop

Erwartet (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-policies

Erwartet (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-ccnp2

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Welchen Nameserver und welchen ndots-Wert nutzt Pod c2? Zeitziel: 10 s
  2. Zeige die Backends des Service web in Ciliums Service-Tabelle. Zeitziel: 40 s
  3. Zeige die letzten 5 verworfenen Flows im Namespace tag04. Zeitziel: 15 s
  4. Löse aus c1 die ClusterIP des Service web per 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 pods

Erwartet: c1, c2, c3, zwei web-… und ein shop-…, alle 1/1 Running.

k get endpointslices

Erwartet: web, web-port, web-sel mit Port 80 und beiden web-IPs, shop mit einer IP.

k exec c3 -- cat /etc/resolv.conf

Erwartet: nameserver 10.96.0.10 und options ndots:5.

k exec c1 -- curl -s -o /dev/null -w '%{http_code}\n' http://shop

Erwartet: 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
EOF

Hinweis: 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://api

Erwartet:

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 tag04

Clusterweit 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 → nslookup im 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:5 erzeugt viel DNS-Last für externe Namen – NodeLocal DNSCache oder angepasstes dnsConfig (Tag 8).
  • Readiness-Probes gehören zur Netzwerk-Verfügbarkeit: Ein falscher Probe-Port nimmt einen gesunden Dienst still aus dem Verkehr.