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 serversagt nur, dass es scheitert. Welche Station schuld ist, zeigen die SpaltenPORTSundENDPOINTSder 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=ReadyJetzt 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 -1Erwartet:
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 endpointsfunktioniert noch, warnt aber seit 1.33:v1 Endpoints is deprecated in v1.33+; use discovery.k8s.io/v1 EndpointSlice. Jede EndpointSlice trägt das Labelkubernetes.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.yamlSymptom:
# auf cp1
kubectl -n tag07 exec client -- curl -sS -m 5 backendErwartet:
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/backendErwartet:
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.yamlNachweis:
# auf cp1
kubectl -n tag07 get endpointslices -l kubernetes.io/service-name=backend
kubectl -n tag07 exec client -- curl -s backend | head -1Erwartet:
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.yamlSymptom:
# auf cp1
kubectl -n tag07 exec client -- curl -sS -m 5 backendErwartet:
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:8080Erwartet (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.yamlNachweis:
# auf cp1
kubectl -n tag07 get endpointslices -l kubernetes.io/service-name=backend
kubectl -n tag07 exec client -- curl -s backend | head -1Erwartet:
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.yamlSymptom:
# auf cp1
kubectl -n tag07 exec client -- curl -sS -m 5 backend
kubectl -n tag07 get endpointslices -l kubernetes.io/service-name=backendErwartet:
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[*].nameErwartet:
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.yamlNachweis:
# auf cp1
kubectl -n tag07 get endpointslices -l kubernetes.io/service-name=backendErwartet:
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/backendErwartet:
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
- Zeig die Pod-IPs hinter dem Service
backend. Zeitziel: 15 s - Zeig Selektor,
targetPortund Endpoints des Service in drei Zeilen. Zeitziel: 20 s - Ruf den Service sechsmal auf und zähl, welcher Pod wie oft antwortet. Zeitziel: 30 s
- 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 -1Erwartet:
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 -1Erwartet:
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 -cErwartet:
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 tag07Erwartet:
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 mitready: false→ Readiness,PORTSfalsch 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
nftablesoder 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
appallein sind riskant: Zwei Teams mitapp: apiim selben Namespace teilen sich plötzlich einen Service. Mehrere Labels kombinieren. sessionAffinityist 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.