Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 7: Services und Endpoints

Ziel: Du verfolgst eine Anfrage vom Namen über Service und EndpointSlice bis zum Port im Pod und erkennst, an welcher Station sie hängen bleibt. · Dauer: ca. 60 min · Voraussetzung: Tag 6

Briefing

  • Ein Service ist nur ein Selektor plus eine virtuelle IP. Welche Pods dahinterstehen, schreibt der EndpointSlice-Controller in die EndpointSlice.
  • kube-proxy übersetzt Service-IP und Port auf jedem Knoten in iptables-Regeln.
  • Could not connect to server sagt nur, dass es scheitert. Welche Station schuld ist, zeigen die Spalten PORTS und ENDPOINTS der EndpointSlice.
  • Kubernetes schreibt bei keinem dieser Fehler ein Event.
Fehlerbild Symptom Wo die Antwort steht
Selektor passt nicht ENDPOINTS <unset> Selektor vs. Pod-Labels
targetPort falsch Endpoints da, Port falsch EndpointSlice PORTS, ss
Port-Name fehlt im Pod PORTS <unset> containerPorts[].name
Verteilt nicht immer derselbe Pod sessionAffinity
client ──> backend (DNS) ──> 10.43.x.x:80 (Service) ──> EndpointSlice
             Tag 8              kube-proxy                 Pod-IP:targetPort ──> ss

Drill 1: Der Weg einer Anfrage

Zuerst der gesunde Zustand: zwei whoami-Pods hinter dem Service backend und ein Werkzeug-Pod client mit netshoot.

# auf cp1
mkdir -p ~/debug/tag07 && cd ~/debug/tag07
kubectl create namespace tag07
cat > backend.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata: {name: backend, namespace: tag07}
spec:
  replicas: 2
  selector: {matchLabels: {app: backend}}
  template:
    metadata: {labels: {app: backend}}
    spec:
      containers:
      - name: whoami
        image: traefik/whoami:v1.11
        ports: [{name: http, containerPort: 80}]
---
apiVersion: v1
kind: Service
metadata: {name: backend, namespace: tag07}
spec:
  selector: {app: backend}
  ports: [{name: http, port: 80, targetPort: http}]
---
apiVersion: v1
kind: Pod
metadata: {name: client, namespace: tag07, labels: {app: client}}
spec:
  containers:
  - name: netshoot
    image: nicolaka/netshoot:v0.15
    command: [sleep, infinity]
EOF
kubectl apply -f backend.yaml
kubectl -n tag07 rollout status deploy/backend
kubectl -n tag07 wait pod/client --for=condition=Ready

Jetzt gehst du die Stationen einzeln ab – Name, Service, EndpointSlice, Pod:

# auf cp1
kubectl -n tag07 exec client -- dig +short backend.tag07.svc.cluster.local
kubectl -n tag07 get svc backend -o jsonpath='{.spec.clusterIP} {.spec.ports}{"\n"}'
J='{range .items[*].endpoints[*]}{.addresses[0]} {.conditions.ready} '
J+='{.targetRef.name} {.nodeName}{"\n"}{end}'
kubectl -n tag07 get endpointslice -l kubernetes.io/service-name=backend \
  -o jsonpath="$J"

Erwartet:

10.43.139.59
10.43.139.59 [{"name":"http","port":80,"protocol":"TCP","targetPort":"http"}]
10.42.1.29 true backend-6ddd778465-2tbqs worker1
10.42.2.26 true backend-6ddd778465-884qb worker2

Und die Anfrage selbst, sechsmal über den Service, einmal direkt an eine Pod-IP aus deiner Ausgabe:

# auf cp1
for i in $(seq 6); do kubectl -n tag07 exec client -- curl -s backend | head -1; done
kubectl -n tag07 exec client -- curl -s 10.42.1.29 | head -1

Erwartet:

Hostname: backend-6ddd778465-884qb
Hostname: backend-6ddd778465-2tbqs
Hostname: backend-6ddd778465-2tbqs
Hostname: backend-6ddd778465-884qb
Hostname: backend-6ddd778465-2tbqs
Hostname: backend-6ddd778465-884qb
Hostname: backend-6ddd778465-2tbqs

Warum? whoami nennt in der ersten Zeile den Pod, der geantwortet hat. So siehst du ohne Logs, ob der Service verteilt und welcher Pod hinter einer IP steckt.

Tipp: kubectl get endpoints funktioniert noch, warnt aber seit 1.33: v1 Endpoints is deprecated in v1.33+; use discovery.k8s.io/v1 EndpointSlice. Jede EndpointSlice trägt das Label kubernetes.io/service-name.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der Selektor passt nicht

Einbauen:

# auf cp1
cat > svc-selektor.yaml <<'EOF'
apiVersion: v1
kind: Service
metadata: {name: backend, namespace: tag07}
spec:
  selector: {app: backend-api}
  ports: [{name: http, port: 80, targetPort: http}]
EOF
kubectl apply -f svc-selektor.yaml

Symptom:

# auf cp1
kubectl -n tag07 exec client -- curl -sS -m 5 backend

Erwartet:

curl: (7) Failed to connect to backend port 80 after 3 ms: Could not connect to server
command terminated with exit code 7

Der Name löst auf (sonst käme Could not resolve host), die Verbindung scheitert in 3 ms. Hinter der Service-IP wartet niemand.

Untersuchen:

# auf cp1
kubectl -n tag07 get endpointslices -l kubernetes.io/service-name=backend
kubectl -n tag07 get svc backend -o jsonpath='{.spec.selector}{"\n"}'
kubectl -n tag07 get pods --show-labels
kubectl -n tag07 events --for service/backend

Erwartet:

NAME            ADDRESSTYPE   PORTS     ENDPOINTS   AGE
backend-zdtk5   IPv4          <unset>   <unset>     68s
{"app":"backend-api"}
NAME                       READY   STATUS    RESTARTS   AGE   LABELS
backend-6ddd778465-2tbqs   1/1     Running   0          68s   app=backend,pod-templa...
backend-6ddd778465-884qb   1/1     Running   0          68s   app=backend,pod-templa...
client                     1/1     Running   0          68s   app=client
No events found in tag07 namespace.

Ursache: Der Service sucht app=backend-api, die Pods tragen app=backend. Die EndpointSlice bleibt leer, und Kubernetes meldet das nirgends – kein Event, kein Status. Die Gegenprobe kubectl -n tag07 get pods -l app=backend-api liefert No resources found.

Fix:

# auf cp1
kubectl apply -f backend.yaml

Nachweis:

# auf cp1
kubectl -n tag07 get endpointslices -l kubernetes.io/service-name=backend
kubectl -n tag07 exec client -- curl -s backend | head -1

Erwartet:

NAME            ADDRESSTYPE   PORTS   ENDPOINTS               AGE
backend-zdtk5   IPv4          80      10.42.1.29,10.42.2.26   80s
Hostname: backend-6ddd778465-2tbqs

Warum? Scheitert dagegen die Readiness-Probe, ist die EndpointSlice nicht leer: Die IPs stehen darin, aber mit ready: false (Tag 5), und get pods zeigt 0/1. <unset> bei 1/1 spricht für den Selektor.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Endpoints da, Verbindung trotzdem abgelehnt

Einbauen:

# auf cp1
cat > svc-port.yaml <<'EOF'
apiVersion: v1
kind: Service
metadata: {name: backend, namespace: tag07}
spec:
  selector: {app: backend}
  ports: [{name: http, port: 80, targetPort: 8080}]
EOF
kubectl apply -f svc-port.yaml

Symptom:

# auf cp1
kubectl -n tag07 exec client -- curl -sS -m 5 backend

Erwartet:

curl: (7) Failed to connect to backend port 80 after 6 ms: Could not connect to server
command terminated with exit code 7

Dieselbe Meldung wie in Drill 2 – an curl allein erkennst du die Station nicht.

Untersuchen:

# auf cp1
kubectl -n tag07 get endpointslices -l kubernetes.io/service-name=backend
IP=$(kubectl -n tag07 get pod -l app=backend -o jsonpath='{.items[0].status.podIP}')
kubectl -n tag07 exec client -- curl -s -o /dev/null -w '%{http_code}\n' $IP:80
kubectl -n tag07 exec client -- curl -sS -m 5 $IP:8080

Erwartet (Zeile umbrochen):

NAME            ADDRESSTYPE   PORTS   ENDPOINTS               AGE
backend-zdtk5   IPv4          8080    10.42.1.29,10.42.2.26   82s
200
curl: (7) Failed to connect to 10.42.1.29 port 8080 after 1 ms: Could not connect to
  server
command terminated with exit code 7

Ursache: Die Spalte PORTS der EndpointSlice zeigt den Port im Pod (targetPort), nicht den Service-Port. Dort lauscht niemand; der Pod antwortet mit einem TCP-Reset. Direkt auf Port 80 antwortet er mit 200.

Fix:

# auf cp1
kubectl apply -f backend.yaml

Nachweis:

# auf cp1
kubectl -n tag07 get endpointslices -l kubernetes.io/service-name=backend
kubectl -n tag07 exec client -- curl -s backend | head -1

Erwartet:

NAME            ADDRESSTYPE   PORTS   ENDPOINTS               AGE
backend-zdtk5   IPv4          80      10.42.1.29,10.42.2.26   116s
Hostname: backend-6ddd778465-2tbqs

Warum? targetPort: http verweist auf den benannten Port im Pod-Template. Dann steht die Zahl nur an einer Stelle, und ein Port-Wechsel im Image betrifft nur das Deployment.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Auf welchem Port lauscht der Pod wirklich?

Die Zahl in containerPort ist nur Doku – sie öffnet keinen Port; wirken tut nur ihr Name als Ziel von targetPort (Drill 3). Was zählt, ist der Socket im Container. whoami hat keine Shell:

# auf cp1
P=$(kubectl -n tag07 get pod -l app=backend -o jsonpath='{.items[0].metadata.name}')
kubectl -n tag07 exec $P -- sh 2>&1 | grep -o 'exec: "sh".*'

Erwartet:

exec: "sh": executable file not found in $PATH

Also ein Ephemeral Container wie in Tag 6. Er teilt das Netz des Pods und sieht dieselben Sockets:

# auf cp1
kubectl -n tag07 debug $P --image=nicolaka/netshoot:v0.15 --target=whoami \
  --container=ports -- ss -ltnp
sleep 3
kubectl -n tag07 logs $P -c ports
kubectl -n tag07 get pod $P -o jsonpath='{.spec.containers[0].ports}{"\n"}'

Erwartet:

Targeting container "whoami". If you don't see processes from this container it may
be because the container runtime doesn't support this feature.
State  Recv-Q Send-Q Local Address:Port Peer Address:PortProcess
LISTEN 0      4096               *:80              *:*    users:(("whoami",pid=1,fd=3))
[{"containerPort":80,"name":"http","protocol":"TCP"}]

Warum? *:80 heißt: auf allen Adressen des Pods. Lauscht ein Prozess nur auf 127.0.0.1:80, ist er per kubectl exec … curl localhost erreichbar, über den Service aber nicht – auch das zeigt ss sofort.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Endpoints ohne Port

Einbauen:

# auf cp1
cat > svc-name.yaml <<'EOF'
apiVersion: v1
kind: Service
metadata: {name: backend, namespace: tag07}
spec:
  selector: {app: backend}
  ports: [{name: http, port: 80, targetPort: web}]
EOF
kubectl apply -f svc-name.yaml

Symptom:

# auf cp1
kubectl -n tag07 exec client -- curl -sS -m 5 backend
kubectl -n tag07 get endpointslices -l kubernetes.io/service-name=backend

Erwartet:

curl: (7) Failed to connect to backend port 80 after 7 ms: Could not connect to server
command terminated with exit code 7
NAME            ADDRESSTYPE   PORTS     ENDPOINTS               AGE
backend-zdtk5   IPv4          <unset>   10.42.1.29,10.42.2.26   2m1s

Pods gefunden, aber kein Port: eine dritte Variante neben Drill 2 (<unset> bei beidem) und Drill 3 (falsche Zahl).

Untersuchen:

# auf cp1
kubectl -n tag07 get svc backend -o jsonpath='{.spec.ports[0].targetPort}{"\n"}'
kubectl -n tag07 get pods -l app=backend \
  -o custom-columns=NAME:.metadata.name,PORTNAME:.spec.containers[*].ports[*].name

Erwartet:

web
NAME                       PORTNAME
backend-6ddd778465-2tbqs   http
backend-6ddd778465-884qb   http

Ursache: targetPort: web sucht in jedem Pod einen Container-Port mit dem Namen web. Den gibt es nicht, also trägt der Controller die Pods ohne Port ein, und kube-proxy behandelt den Service wie einen ohne Endpoints.

Fix:

# auf cp1
kubectl apply -f backend.yaml

Nachweis:

# auf cp1
kubectl -n tag07 get endpointslices -l kubernetes.io/service-name=backend

Erwartet:

NAME            ADDRESSTYPE   PORTS   ENDPOINTS               AGE
backend-zdtk5   IPv4          80      10.42.2.26,10.42.1.29   2m30s

Fortschritt speichern? Kostenlos registrieren

Drill 6: Was kube-proxy daraus macht

kube-proxy läuft in RKE2 als Static Pod auf jedem Knoten und schreibt iptables-Regeln. Du liest sie nur. Der Client-Pod läuft auf cp1, also gelten dessen Regeln:

# auf cp1
kubectl -n kube-system get pods -l component=kube-proxy -o wide | cut -c1-79
sudo iptables-save | grep -o '"tag07/backend[^"]*"' | sort | uniq -c
sudo iptables-save | grep 'tag07/backend' | grep -o 'probability [0-9.]*'

Erwartet:

NAME                 READY   STATUS    RESTARTS   AGE   IP             NODE
kube-proxy-cp1       1/1     Running   0          38m   172.16.0.126   cp1
kube-proxy-worker1   1/1     Running   0          37m   172.16.0.228   worker1
kube-proxy-worker2   1/1     Running   0          37m   172.16.0.83    worker2
      1 "tag07/backend:http -> 10.42.1.29:80"
      1 "tag07/backend:http -> 10.42.2.26:80"
      2 "tag07/backend:http cluster IP"
      4 "tag07/backend:http"
probability 0.50000000000

Eine Regel pro Endpoint mit DNAT auf Pod-IP:Port, die erste mit Wahrscheinlichkeit 0,5 – das ist die ganze Lastverteilung. Und ohne Endpoints?

# auf cp1
kubectl -n tag07 scale deploy backend --replicas=0
sleep 4
sudo iptables-save | grep -o '"tag07/backend[^"]*"' | sort | uniq -c
kubectl -n tag07 scale deploy backend --replicas=2
kubectl -n tag07 rollout status deploy/backend

Erwartet:

deployment.apps/backend scaled
      1 "tag07/backend:http has no endpoints"
deployment.apps/backend scaled
...
deployment "backend" successfully rolled out

Warum? Für einen Service ohne (portfähige) Endpoints setzt kube-proxy eine Regel REJECT --reject-with icmp-port-unreachable. Deshalb scheiterten Drill 2 und 5 in wenigen Millisekunden statt mit Timeout. Fehlen dagegen die KUBE-SVC-Regeln ganz, obwohl die EndpointSlice gefüllt ist, liegt das Problem bei kube-proxy selbst: kubectl -n kube-system logs kube-proxy-cp1.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig die Pod-IPs hinter dem Service backend. Zeitziel: 15 s
  2. Zeig Selektor, targetPort und Endpoints des Service in drei Zeilen. Zeitziel: 20 s
  3. Ruf den Service sechsmal auf und zähl, welcher Pod wie oft antwortet. Zeitziel: 30 s
  4. Ruf einen Backend-Pod direkt an, am Service vorbei. Zeitziel: 30 s

Lösung

# auf cp1
kubectl -n tag07 get endpointslice -l kubernetes.io/service-name=backend
kubectl -n tag07 describe svc backend | grep -E '^(Selector|TargetPort|Endpoints)'
for i in $(seq 6); do kubectl -n tag07 exec client -- curl -s backend | head -1
done | sort | uniq -c
kubectl -n tag07 exec client -- curl -s \
  $(kubectl -n tag07 get pod -l app=backend -o jsonpath='{.items[0].status.podIP}') \
  | head -1

Erwartet:

NAME            ADDRESSTYPE   PORTS   ENDPOINTS               AGE
backend-zdtk5   IPv4          80      10.42.1.31,10.42.2.28   3m47s
Selector:                 app=backend
TargetPort:               http/TCP
Endpoints:                10.42.1.31:80,10.42.2.28:80
      3 Hostname: backend-6ddd778465-5nrkz
      3 Hostname: backend-6ddd778465-pg2z9
Hostname: backend-6ddd778465-5nrkz

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf cp1
kubectl -n tag07 get endpointslice -l kubernetes.io/service-name=backend \
  -o custom-columns=NAME:.metadata.name,PORT:.ports[0].port,\
IPS:.endpoints[*].addresses[0]

Erwartet:

NAME            PORT   IPS
backend-zdtk5   80     10.42.1.31,10.42.2.28
# auf cp1
kubectl -n tag07 exec client -- curl -s -m 5 backend | head -1

Erwartet:

Hostname: backend-6ddd778465-5nrkz

Challenge

Leg einen zweiten Service sticky an, der ebenfalls auf app=backend zeigt, aber sessionAffinity: ClientIP setzt. Ein Kollege meldet: „Der Service verteilt nicht, immer antwortet derselbe Pod.“ Weise das nach, finde die Ursache in Service und iptables und stell die Verteilung her.

Hinweis: Die EndpointSlice ist diesmal völlig in Ordnung.

Lösung

# auf cp1
cat > sticky.yaml <<'EOF'
apiVersion: v1
kind: Service
metadata: {name: sticky, namespace: tag07}
spec:
  selector: {app: backend}
  sessionAffinity: ClientIP
  ports: [{name: http, port: 80, targetPort: http}]
EOF
kubectl apply -f sticky.yaml
sleep 3
for i in $(seq 6); do kubectl -n tag07 exec client -- curl -s sticky | head -1
done | sort | uniq -c
kubectl -n tag07 get svc sticky \
  -o jsonpath='{.spec.sessionAffinity} {.spec.sessionAffinityConfig}{"\n"}'
sudo iptables-save | grep 'tag07/sticky' | grep -o 'recent.*seconds [0-9]*' | head -1
kubectl -n tag07 patch svc sticky -p '{"spec":{"sessionAffinity":"None"}}'
for i in $(seq 6); do kubectl -n tag07 exec client -- curl -s sticky | head -1
done | sort | uniq -c

Erwartet:

service/sticky created
      6 Hostname: backend-6ddd778465-pg2z9
ClientIP {"clientIP":{"timeoutSeconds":10800}}
recent --rcheck --seconds 10800
service/sticky patched
      2 Hostname: backend-6ddd778465-5nrkz
      4 Hostname: backend-6ddd778465-pg2z9

Mit ClientIP merkt sich kube-proxy per iptables-Modul recent drei Stunden lang, welcher Pod einer Quell-IP zugeordnet ist. Ein einzelner Client – oder ein Ingress-Controller, der alles von einer IP schickt – landet dann immer beim selben Pod. Zufall bleibt Zufall: Auch 2:4 ist eine gesunde Verteilung.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

# auf cp1
kubectl delete namespace tag07
sudo iptables-save | grep -c tag07

Erwartet:

namespace "tag07" deleted
0

Interview-Notiz

  • Service antwortet nicht – erste Frage? Hat er Endpoints? get endpointslice -l kubernetes.io/service-name=…: ENDPOINTS <unset> → Selektor, IPs mit ready: false → Readiness, PORTS falsch oder <unset> → targetPort.
  • Was macht kube-proxy? Er programmiert pro Knoten DNAT-Regeln von Service-IP:Port auf Pod-IP:targetPort; Verteilung per Zufall, Service ohne Endpoints → REJECT.
  • Warum benannte Ports? Die Portnummer steht nur im Pod-Template; der Service verweist per Name.

Enterprise-Notiz

  • Große Cluster nutzen statt iptables oft nftables oder ein CNI ohne kube-proxy (Cilium); IPVS ist seit 1.35 deprecated. Die EndpointSlice bleibt dieselbe Wahrheit, nur die Regeln liest du anders.
  • Selektoren auf app allein sind riskant: Zwei Teams mit app: api im selben Namespace teilen sich plötzlich einen Service. Mehrere Labels kombinieren.
  • sessionAffinity ist selten die richtige Antwort auf Sitzungsprobleme; zustandslose Pods und ein gemeinsamer Session-Speicher skalieren besser.
  • Service-Mesh-Fehler (Sidecar, mTLS) sehen aus wie Drill 3 – siehe „Linkerd zum Anfassen“, Tag 16.