Tag 3: Services und DNS
Ziel: die api hinter einen Service mit festem Namen stellen, DNS im Cluster verstehen, web per NodePort auf den Mac bringen und worker dazunehmen. · Dauer: ca. 75 min · Voraussetzung: Tag 2
Briefing
- Pod-IPs wechseln mit jedem neuen Pod. Ein Service gibt allen Pods mit passendem Label eine feste virtuelle IP (ClusterIP) und einen DNS-Namen.
- Welche Pods gerade dahinterstehen, steht in EndpointSlices. kube-proxy auf jedem Node verteilt neue Verbindungen auf diese Pods.
- CoreDNS löst
apiim eigenen Namespace auf, vollständig heißt der Serviceapi.notes.svc.cluster.local. - Ein NodePort-Service öffnet einen Port
(30000–32767) auf jedem Node. kind reicht 30080 an
localhost:30080auf dem Mac weiter (Tag 0).
Mac: curl localhost:30080
│ extraPortMappings (Tag 0)
▼
Node :30080 ──► Service web (NodePort) ──► Pods web ×2
│ http://api:8080
▼
Service api (ClusterIP) ──► Pods api ×3
▲
Pod worker ─┘
Drill 1: Tagesstart, wandernde IPs
source ~/k8s-lab/setup/env.sh
mkdir -p ~/k8s-lab/tag03 && cd ~/k8s-lab/tag03
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag02/notes/." .
kubectl get pods -o custom-columns='NAME:.metadata.name,IP:.status.podIP'
kubectl delete "$(kubectl get pods -o name | head -1)"
sleep 3
kubectl get pods -o custom-columns='NAME:.metadata.name,IP:.status.podIP'Erwartet (gekürzt, Namen, IPs und Zeiten weichen bei dir ab):
NAME IP
api-9cb44cd5b-8wq98 10.244.2.12
api-9cb44cd5b-g9qfn 10.244.2.13
api-9cb44cd5b-twrzx 10.244.1.8
pod "api-9cb44cd5b-8wq98" deleted from notes namespace
NAME IP
api-9cb44cd5b-6sf6d 10.244.1.10
api-9cb44cd5b-g9qfn 10.244.2.13
api-9cb44cd5b-twrzx 10.244.1.8
Neuer Pod, neue IP. Wer die api erreichen will, braucht etwas Festes davor.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Ein Service für die api
Der Service kommt in dieselbe Datei wie das Deployment, getrennt
durch ---:
cat > k8s/api.yaml <<'EOF'
# k8s/api.yaml – Stand Ende Tag 3
apiVersion: apps/v1
kind: Deployment
metadata:
name: api
labels:
app.kubernetes.io/name: api
app.kubernetes.io/part-of: notes
spec:
replicas: 3
revisionHistoryLimit: 5
strategy:
type: RollingUpdate
rollingUpdate:
maxSurge: 1
maxUnavailable: 0
selector:
matchLabels:
app.kubernetes.io/name: api
template:
metadata:
labels:
app.kubernetes.io/name: api
app.kubernetes.io/part-of: notes
spec:
containers:
- name: api
image: notes-api:0.2.0
env:
- name: NOTES_API_KEY
value: lab-api-key-123
ports:
- containerPort: 8080
---
apiVersion: v1
kind: Service
metadata:
name: api
labels:
app.kubernetes.io/name: api
app.kubernetes.io/part-of: notes
spec:
selector:
app.kubernetes.io/name: api
ports:
- name: http
port: 8080
targetPort: 8080
EOF
kubectl apply --dry-run=server -f k8s/api.yaml
kubectl apply -f k8s/api.yaml
kubectl get svc api
kubectl get endpointslices -l kubernetes.io/service-name=apiErwartet (gekürzt):
deployment.apps/api unchanged (server dry run)
service/api created (server dry run)
deployment.apps/api unchanged
service/api created
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
api ClusterIP 10.96.247.150 <none> 8080/TCP 0s
NAME ADDRESSTYPE PORTS ENDPOINTS AGE
api-dtnfk IPv4 8080 10.244.1.10,10.244.1.8,10.244.2.13 1s
selectorwählt die Pods – dieselben Labels wie beim Deployment, aber der Service kennt das Deployment gar nicht.portist der Port des Service,targetPortder im Container.- Die EndpointSlice hat der Control-Plane-Controller
angelegt: genau die drei Pod-IPs aus Drill 1. Ohne
typeist ein ServiceClusterIP.
kubectl get endpointslice -l kubernetes.io/service-name=api -o yaml \
| grep -E 'addresses:|- 10\.|ready:|name: api-'Erwartet (gekürzt):
- addresses:
- 10.244.1.10
ready: true
name: api-9cb44cd5b-6sf6d
- addresses:
- 10.244.1.8
ready: true
name: api-9cb44cd5b-twrzx
…
Nur Pods mit ready: true bekommen Verkehr. Wann ein Pod
bereit ist, bestimmst du an Tag 5 mit einer Readiness-Probe.
Fortschritt speichern? Kostenlos registrieren
Drill 3: web und worker
Beide sprechen die api über ihren Service-Namen an. web bekommt einen NodePort-Service:
cat > k8s/web.yaml <<'EOF'
# k8s/web.yaml – Stand Ende Tag 3
apiVersion: apps/v1
kind: Deployment
metadata:
name: web
labels:
app.kubernetes.io/name: web
app.kubernetes.io/part-of: notes
spec:
replicas: 2
selector:
matchLabels:
app.kubernetes.io/name: web
template:
metadata:
labels:
app.kubernetes.io/name: web
app.kubernetes.io/part-of: notes
spec:
containers:
- name: web
image: notes-web:0.1.0
env:
- name: NOTES_API_URL
value: http://api:8080
- name: NOTES_API_KEY
value: lab-api-key-123
ports:
- containerPort: 3000
---
apiVersion: v1
kind: Service
metadata:
name: web
labels:
app.kubernetes.io/name: web
app.kubernetes.io/part-of: notes
spec:
type: NodePort
selector:
app.kubernetes.io/name: web
ports:
- name: http
port: 3000
targetPort: 3000
nodePort: 30080
EOF
cat > k8s/worker.yaml <<'EOF'
# k8s/worker.yaml – Stand Ende Tag 3
apiVersion: apps/v1
kind: Deployment
metadata:
name: worker
labels:
app.kubernetes.io/name: worker
app.kubernetes.io/part-of: notes
spec:
replicas: 1
selector:
matchLabels:
app.kubernetes.io/name: worker
template:
metadata:
labels:
app.kubernetes.io/name: worker
app.kubernetes.io/part-of: notes
spec:
containers:
- name: worker
image: notes-worker:0.1.0
env:
- name: NOTES_API_URL
value: http://api:8080
- name: NOTES_API_KEY
value: lab-api-key-123
EOF
kubectl apply --dry-run=server -f k8s/web.yaml -f k8s/worker.yaml
kubectl apply -f k8s/web.yaml -f k8s/worker.yaml
kubectl rollout status deploy/web && kubectl rollout status deploy/worker
kubectl get deploy,svcErwartet (gekürzt):
deployment.apps/web created (server dry run)
service/web created (server dry run)
deployment.apps/worker created (server dry run)
deployment.apps/web created
service/web created
deployment.apps/worker created
…
deployment "web" successfully rolled out
deployment "worker" successfully rolled out
NAME READY UP-TO-DATE AVAILABLE AGE
deployment.apps/api 3/3 3 3 3m58s
deployment.apps/web 2/2 2 2 3s
deployment.apps/worker 1/1 1 1 3s
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
service/api ClusterIP 10.96.247.150 <none> 8080/TCP 13s
service/web NodePort 10.96.84.172 <none> 3000:30080/TCP 3s
worker hat keinen Service: Niemand ruft ihn auf, er ruft nur die api. Die Images von web und worker sind noch 0.1.0 – die App-Version zählt hier nur bei der api.
Fortschritt speichern? Kostenlos registrieren
Drill 4: DNS im Cluster
notes-web basiert auf Alpine und hat eine Shell mit wget
und nslookup. Damit ist deploy/web dein
Werkzeug für Abrufe im Cluster:
kubectl exec deploy/web -- cat /etc/resolv.conf
kubectl exec deploy/web -- nslookup api.notes.svc.cluster.local
kubectl exec deploy/web -- wget -qO- http://api:8080/version
kubectl exec deploy/web -- wget -qO- http://api.notes.svc.cluster.local:8080/version
kubectl exec deploy/web -- wget -qO- -T 3 http://api.default:8080/versionErwartet (gekürzt):
search notes.svc.cluster.local svc.cluster.local cluster.local …
nameserver 10.96.0.10
options ndots:5
Server: 10.96.0.10
Address: 10.96.0.10:53
Name: api.notes.svc.cluster.local
Address: 10.96.247.150
0.2.0
0.2.0
wget: bad address 'api.default:8080'
command terminated with exit code 1
nameserverist die ClusterIP von CoreDNS,searchhängt die Suffixe an: Ausapiwird zuerstapi.notes.svc.cluster.local.- Die Antwort ist die ClusterIP des Service, nicht die eines Pods.
api.defaultsucht im Namespacedefault– dort gibt es keine api. Über Namespaces hinweg schreibst du<service>.<namespace>.
Zusätzlich setzt Kubernetes in jedem Pod Variablen für die Services, die bei seinem Start schon existierten:
kubectl exec deploy/web -- sh -c 'env | grep ^API_SERVICE'Erwartet (Reihenfolge kann abweichen):
API_SERVICE_PORT=8080
API_SERVICE_PORT_HTTP=8080
API_SERVICE_HOST=10.96.247.150
Verlass dich auf DNS, nicht auf diese Variablen: Ein Service, der nach dem Pod entsteht, fehlt darin.
Achtung: Naheliegend wäre ein Wegwerf-Pod:
kubectl run tmp --rm -i --restart=Never --image=busybox:1.37 -- wget -qO- …. Bei so kurzen Befehlen kommt kubectl oft zu spät und meldetcouldn't attach to pod/tmp, falling back to streaming logs– die Ausgabe fehlt oder erscheint doppelt. Dazu warnt kubectl, dass Eingaben in den Container-Logs landen. Für einmalige Abrufe nimmkubectl exec deploy/web -- wget …odercurlvom Mac auf den NodePort.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Wenn der Selektor nicht passt
Der häufigste Service-Fehler: Der Service steht, aber kein Pod passt zum Selektor.
kubectl create service clusterip api-falsch --tcp 8080:8080
kubectl get svc api-falsch -o jsonpath='{.spec.selector}'; echo
kubectl get endpointslices -l kubernetes.io/service-name=api-falsch
kubectl exec deploy/web -- wget -qO- -T 3 http://api-falsch:8080/version
kubectl delete svc api-falschErwartet (gekürzt):
service/api-falsch created
{"app":"api-falsch"}
NAME ADDRESSTYPE PORTS ENDPOINTS AGE
api-falsch-x89dd IPv4 <unset> <unset> 0s
wget: can't connect to remote host (10.96.56.78): Connection refused
command terminated with exit code 1
service "api-falsch" deleted from notes namespace
DNS funktioniert, die ClusterIP existiert, aber die EndpointSlice ist
leer – also wird die Verbindung abgewiesen. Merke die Reihenfolge bei
der Fehlersuche: Service → EndpointSlice → Labels der Pods
(kubectl get pods --show-labels).
Fortschritt speichern? Kostenlos registrieren
Drill 6: Vom Mac auf den NodePort
curl -s localhost:30080/healthz; echo
curl -s localhost:30080/ | head -5
curl -s localhost:30080/api/notes
curl -s localhost:30080/api/notes -d '{"text":"ohne Header"}'; echoErwartet:
ok
<!doctype html>
<html lang="de">
<head><meta charset="utf-8"><title>notes</title></head>
<body>
<h1>notes</h1>
[]
{"error":"text required"}
Der Weg: Mac localhost:30080 → Colima → Port 30080 des
Containers lab-control-plane → kube-proxy → einer der
beiden web-Pods → Service api → ein api-Pod.
http://localhost:30080 funktioniert auch im Browser.
Ohne Content-Type: application/json schickt curl
Formulardaten, notes-web liest keinen Text und die api antwortet
text required. Den API-Key hängt web selbst an.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Wessen Notizen?
Sechs Notizen über web anlegen, dann mehrmals lesen:
for i in 1 2 3 4 5 6; do
curl -s localhost:30080/api/notes -H 'Content-Type: application/json' \
-d "{\"text\":\"Notiz $i\"}"
done
for i in 1 2 3 4 5 6; do curl -s localhost:30080/api/notes | jq -c 'map(.text)'; doneErwartet (gekürzt, die Verteilung weicht bei dir ab):
{"id":"9c041330-…","text":"Notiz 1"}
…
{"id":"ca4bf083-…","text":"Notiz 6"}
["Notiz 2","Notiz 3","Notiz 4","Notiz 6"]
["Notiz 2","Notiz 3","Notiz 4","Notiz 6"]
["Notiz 1","Notiz 5"]
["Notiz 1","Notiz 5"]
["Notiz 1","Notiz 5"]
["Notiz 1","Notiz 5"]
Jede api-Replik hat ihren eigenen Speicher. Frag jede einzeln:
for ip in $(kubectl get pods -l app.kubernetes.io/name=api \
-o jsonpath='{.items[*].status.podIP}'); do
printf '%s ' "$ip"
kubectl exec deploy/web -- wget -qO- "http://$ip:8080/notes" | jq -c 'map(.text)'
done
kubectl logs deploy/worker --tail 2Erwartet (gekürzt):
10.244.1.10 []
10.244.2.13 ["Notiz 1","Notiz 5"]
10.244.1.8 ["Notiz 2","Notiz 3","Notiz 4","Notiz 6"]
summary: 0 notes, 0 words
summary: 0 notes, 0 words
Der Service verteilt Verbindungen, nicht Anfragen. Jeder curl vom Mac ist eine neue Verbindung und landet bei einem zufälligen web-Pod. Jeder web-Pod hält seine Verbindung zur api offen (Keep-Alive) und spricht im Test immer mit derselben api-Replik; der worker ebenso – und seine Replik hat gar keine Notizen. Drei Repliken mit Speicher im Prozess sind drei getrennte Datenbestände. Die Lösung ist ein gemeinsamer Speicher: Postgres als StatefulSet an Tag 7.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
kubectl get deployErwartet: api 3/3, web 2/2, worker
1/1.
NAME READY UP-TO-DATE AVAILABLE AGE
api 3/3 3 3 32s
web 2/2 2 2 14s
worker 1/1 1 1 14s
kubectl get endpointslices -l kubernetes.io/service-name=apiErwartet: drei Adressen hinter dem Service api, eine pro
Pod.
NAME ADDRESSTYPE PORTS ENDPOINTS AGE
api-rzgvm IPv4 8080 10.244.2.6,10.244.1.5,10.244.2.7 14s
kubectl exec deploy/web -- wget -qO- http://api.notes.svc.cluster.local:8080/versionErwartet: Der volle DNS-Name löst auf, die api antwortet mit ihrer Version.
0.2.0
curl -s localhost:30080/healthz; echoErwartet: web antwortet über den NodePort.
ok
kubectl logs deploy/worker --tail 1Erwartet: eine Zeile summary: (die Zahlen weichen
ab).
summary: 0 notes, 0 words
Challenge
Stelle die api zusätzlich unter dem Namen api-intern auf
Port 80 bereit, ohne eine Datei zu schreiben, und rufe
http://api-intern/version aus einem web-Pod auf. Räum
danach auf.
Hinweis: kubectl expose übernimmt den
Selektor aus einem Deployment; --port und
--target-port dürfen verschieden sein.
Lösung
kubectl expose deploy api --name api-intern --port 80 --target-port 8080
kubectl get svc api-intern
kubectl get endpointslices -l kubernetes.io/service-name=api-intern
kubectl exec deploy/web -- wget -qO- http://api-intern/version
kubectl get svc api-intern -o jsonpath='{.spec.selector}'; echo
kubectl delete svc api-internErwartet (gekürzt):
service/api-intern exposed
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
api-intern ClusterIP 10.96.82.30 <none> 80/TCP 1s
NAME ADDRESSTYPE PORTS ENDPOINTS AGE
api-intern-rbvmv IPv4 8080 10.244.1.10,10.244.1.8,10.244.2.13 0s
0.2.0
{"app.kubernetes.io/name":"api"}
service "api-intern" deleted from notes namespace
Der Service lauscht auf 80, die EndpointSlice nennt die Container-Ports 8080. Zwei Services mit demselben Selektor sind erlaubt; so lassen sich Ports oder Namen ändern, ohne die Pods anzufassen.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- NodePorts gehen selten direkt nach außen. Davor steht ein Load Balancer (Cloud oder MetalLB) oder ein Gateway, das HTTP versteht (Tag 11, „Gateway API zum Anfassen”).
- Weil Services Verbindungen verteilen, nicht Anfragen, landen bei Keep-Alive, HTTP/2 und gRPC alle Anfragen eines Clients auf einem Pod. Abhilfe: L7-Proxy oder Service Mesh.
- Wer welchen Service im Cluster erreichen darf, regeln NetworkPolicies (Tag 11). Ohne sie spricht jeder Pod mit jedem.
ndots:5lässt kurze externe Namen erst durch alle Suchdomänen laufen. Bei vielen externen Aufrufen lohnt der vollständige Name mit Punkt am Ende (api.example.com.) oder ein angepasstesdnsConfig.