Zum Inhalt springen
Trainingslager IT-Trainingslager

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 api im eigenen Namespace auf, vollständig heißt der Service api.notes.svc.cluster.local.
  • Ein NodePort-Service öffnet einen Port (30000–32767) auf jedem Node. kind reicht 30080 an localhost:30080 auf 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=api

Erwartet (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
  • selector wählt die Pods – dieselben Labels wie beim Deployment, aber der Service kennt das Deployment gar nicht.
  • port ist der Port des Service, targetPort der im Container.
  • Die EndpointSlice hat der Control-Plane-Controller angelegt: genau die drei Pod-IPs aus Drill 1. Ohne type ist ein Service ClusterIP.
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,svc

Erwartet (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/version

Erwartet (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
  • nameserver ist die ClusterIP von CoreDNS, search hängt die Suffixe an: Aus api wird zuerst api.notes.svc.cluster.local.
  • Die Antwort ist die ClusterIP des Service, nicht die eines Pods.
  • api.default sucht im Namespace default – 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 meldet couldn'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 nimm kubectl exec deploy/web -- wget … oder curl vom 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-falsch

Erwartet (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"}'; echo

Erwartet:

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)'; done

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

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

Erwartet: 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=api

Erwartet: 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/version

Erwartet: Der volle DNS-Name löst auf, die api antwortet mit ihrer Version.

0.2.0
curl -s localhost:30080/healthz; echo

Erwartet: web antwortet über den NodePort.

ok
kubectl logs deploy/worker --tail 1

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

Erwartet (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:5 lä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 angepasstes dnsConfig.