Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 4: Konfiguration – ConfigMaps und Secrets

Ziel: Kein Key und keine URL mehr im Manifest – Konfiguration kommt aus einer ConfigMap, der API-Key aus einem Secret, und du rotierst ihn ohne Ausfall. · Dauer: ca. 75 min · Voraussetzung: Tag 3

Briefing

  • Eine ConfigMap hält Schlüssel-Wert-Paare oder ganze Dateien. Ein Secret ist dasselbe für vertrauliche Werte – gespeichert nur base64-kodiert, nicht verschlüsselt.
  • Ein Container bekommt beides als Umgebungsvariable (envFrom, valueFrom) oder als Datei über ein Volume.
  • Dateien aus einem Volume aktualisiert das Kubelet nach einer Änderung, Variablen nicht. Die notes-Dienste lesen ihre Konfiguration ohnehin nur beim Start.
  • Secrets landen nie als YAML im Repo, sondern entstehen per Skript k8s/secrets.sh.
 ConfigMap notes-config ──envFrom────────────► worker  (NOTES_API_URL, INTERVAL)
                        └─valueFrom──────────► web     (NOTES_API_URL)
 Secret notes-api ──Volume /etc/notes/api-key► api, worker (*_FILE)
                  └─secretKeyRef─────────────► web     (NOTES_API_KEY)

Drill 1: Der Key im Klartext

Tagesstart und Stand von Tag 3 holen:

source ~/k8s-lab/setup/env.sh
mkdir -p ~/k8s-lab/tag04 && cd ~/k8s-lab/tag04
cp -R "$LAB/code/notes/." . && cp -R "$LAB/code/tag03/notes/." .

Wo steckt der API-Key heute?

grep -rn 'lab-api-key' k8s/
c='NAME:.metadata.name,ENV:.spec.template.spec.containers[0].env[*].name'
kubectl get deploy -o custom-columns="$c"

Erwartet:

k8s/worker.yaml:27:              value: lab-api-key-123
k8s/api.yaml:31:              value: lab-api-key-123
k8s/web.yaml:27:              value: lab-api-key-123
NAME     ENV
api      NOTES_API_KEY
web      NOTES_API_URL,NOTES_API_KEY
worker   NOTES_API_URL,NOTES_API_KEY

Dreimal derselbe Wert, dreimal im Klartext, jeder mit Lesezugriff auf das Repo kennt ihn. Und NOTES_API_URL steht doppelt. Beides ziehst du heute heraus.

Fortschritt speichern? Kostenlos registrieren

Drill 2: ConfigMap auf drei Wegen

kubectl create configmap baut eine ConfigMap aus Literalen oder Dateien. Mit --dry-run=client -o yaml siehst du nur das Ergebnis, ohne etwas anzulegen:

kubectl create configmap demo --from-literal=INTERVAL=10 --from-literal=MODE=lab \
  --dry-run=client -o yaml
printf 'level=debug\nformat=text\n' > app.properties
kubectl create configmap demo --from-file=app.properties --dry-run=client -o yaml
kubectl create configmap demo --from-env-file=app.properties --dry-run=client -o yaml
rm app.properties

Erwartet:

apiVersion: v1
data:
  INTERVAL: "10"
  MODE: lab
kind: ConfigMap
metadata:
  name: demo
apiVersion: v1
data:
  app.properties: |
    level=debug
    format=text
kind: ConfigMap
metadata:
  name: demo
apiVersion: v1
data:
  format: text
  level: debug
kind: ConfigMap
metadata:
  name: demo

--from-file legt die ganze Datei unter ihrem Namen ab, --from-env-file zerlegt sie in Schlüssel. Für die notes-App reicht der dritte Weg – YAML direkt, versioniert im Repo:

cat > k8s/config.yaml <<'EOF'
# k8s/config.yaml – Stand Ende Tag 4
apiVersion: v1
kind: ConfigMap
metadata:
  name: notes-config
  labels:
    app.kubernetes.io/part-of: notes
data:
  NOTES_API_URL: http://api:8080
  INTERVAL: "10"
EOF
kubectl apply --dry-run=server -f k8s/config.yaml
kubectl apply -f k8s/config.yaml
kubectl get configmap notes-config -o jsonpath='{.data}'; echo

Erwartet:

configmap/notes-config created (server dry run)
configmap/notes-config created
{"INTERVAL":"10","NOTES_API_URL":"http://api:8080"}

"10" steht in Anführungszeichen: Werte einer ConfigMap sind immer Strings, eine nackte 10 lehnt der API-Server ab.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Secret per Skript

cat > k8s/secrets.sh <<'EOF'
#!/usr/bin/env bash
# k8s/secrets.sh – Stand Ende Tag 4: legt die Secrets an (idempotent, nur Lab-Werte)
set -euo pipefail
kubectl -n notes create secret generic notes-api \
  --from-literal=api-key="${NOTES_API_KEY:-lab-api-key-123}" \
  --dry-run=client -o yaml | kubectl apply -f -
EOF
chmod +x k8s/secrets.sh
bash -n k8s/secrets.sh && ./k8s/secrets.sh
./k8s/secrets.sh
kubectl get secret notes-api

Erwartet (gekürzt, Namen, IPs und Zeiten weichen bei dir ab):

secret/notes-api created
secret/notes-api unchanged
NAME        TYPE     DATA   AGE
notes-api   Opaque   1      1s

create … --dry-run=client -o yaml erzeugt nur das Objekt, kubectl apply -f - legt es an oder gleicht es ab. Darum läuft das Skript beliebig oft – create allein würde beim zweiten Mal mit AlreadyExists scheitern. Der Wert kommt aus der Umgebung, im Repo steht nur der Lab-Standard.

Wie geheim ist ein Secret?

kubectl get secret notes-api -o yaml | grep -A1 '^data'
kubectl get secret notes-api -o jsonpath='{.data.api-key}' | base64 -d; echo

Erwartet:

data:
  api-key: bGFiLWFwaS1rZXktMTIz
lab-api-key-123

Sicherheit: base64 ist eine Kodierung, keine Verschlüsselung. Wer get secret darf, kennt den Wert. Und kubectl apply legt zusätzlich die Annotation kubectl.kubernetes.io/last-applied-configuration mit demselben Wert an. Schutz bieten nur RBAC und Verschlüsselung im etcd (Enterprise-Notiz).

Fortschritt speichern? Kostenlos registrieren

Drill 4: envFrom, valueFrom und Secret als Datei

Die drei Deployments bekommen ihre Werte jetzt aus ConfigMap und Secret. Übernimm die vollständigen Dateien aus dem Begleitcode:

cp "$LAB/code/tag04/notes/k8s/"{api,web,worker}.yaml k8s/

Die Unterschiede zeigen drei Ausschnitte. worker holt mit envFrom alle Schlüssel der ConfigMap und den Key als Datei:

# k8s/worker.yaml (Ausschnitt) – Stand Ende Tag 4
    spec:
      containers:
        - name: worker
          image: notes-worker:0.1.0
          envFrom:
            - configMapRef:
                name: notes-config
          env:
            - name: NOTES_API_KEY_FILE
              value: /etc/notes/api-key
          volumeMounts:
            - name: api-key
              mountPath: /etc/notes
              readOnly: true
      volumes:
        - name: api-key
          secret:
            secretName: notes-api

api bekommt dasselbe Volume und NOTES_API_KEY_FILE, aber keine ConfigMap. web holt mit valueFrom gezielt einzelne Schlüssel – auch aus dem Secret, denn notes-web kennt nur NOTES_API_KEY:

# k8s/web.yaml (Ausschnitt) – Stand Ende Tag 4
          env:
            - name: NOTES_API_URL
              valueFrom:
                configMapKeyRef:
                  name: notes-config
                  key: NOTES_API_URL
            - name: NOTES_API_KEY
              valueFrom:
                secretKeyRef:
                  name: notes-api
                  key: api-key
grep -rn 'lab-api-key' k8s/*.yaml; echo "Exit: $?"
kubectl apply --dry-run=server -f k8s/ >/dev/null && kubectl apply -f k8s/
for d in api web worker; do kubectl rollout status deploy/$d >/dev/null; done
kubectl logs deploy/api | head -2
kubectl exec deploy/worker -- env | grep -E '^(NOTES|INTERVAL)' | sort
kubectl exec deploy/web -- printenv NOTES_API_URL NOTES_API_KEY

Erwartet (gekürzt):

Exit: 1
deployment.apps/api configured
service/api unchanged
configmap/notes-config unchanged
namespace/notes unchanged
deployment.apps/web configured
service/web unchanged
deployment.apps/worker configured
time=… level=INFO msg="api key loaded" source=file
time=… level=INFO msg="store ready" store=memory
INTERVAL=10
NOTES_API_KEY_FILE=/etc/notes/api-key
NOTES_API_URL=http://api:8080
http://api:8080
lab-api-key-123

source=file – api las den Key aus der Datei, nicht aus einer Variablen. In worker steht der Key nirgends in der Umgebung, in web schon. Wie sieht die Datei aus?

kubectl exec deploy/worker -- ls -la /etc/notes
curl -s -X POST localhost:30080/api/notes -H 'Content-Type: application/json' \
  -d '{"text":"Key kommt aus dem Secret"}'; echo

Erwartet (gekürzt):

drwxrwxrwt 3 root root  100 Oct 30 14:34 .
drwxr-xr-x 1 root root 4096 Oct 30 14:34 ..
drwxr-xr-x 2 root root   60 Oct 30 14:34 ..2026_10_30_14_34_29.420101691
lrwxrwxrwx 1 root root   31 Oct 30 14:34 ..data -> ..2026_10_30_14_34_29.420101691
lrwxrwxrwx 1 root root   14 Oct 30 14:34 api-key -> ..data/api-key
{"id":"13bf6e3a-…","text":"Key kommt aus dem Secret"}

api-key ist ein Symlink über ..data auf ein Verzeichnis mit Zeitstempel. Bei einer Änderung schreibt das Kubelet ein neues Verzeichnis und biegt ..data in einem Schritt um – Leser sehen nie eine halbe Datei. Das Volume ist ein tmpfs, der Key liegt nie auf der Platte des Nodes.

Weg Feld aktualisiert sich?
alle Schlüssel als Variablen envFrom nein
ein Schlüssel als Variable valueFrom (configMapKeyRef, secretKeyRef) nein
Schlüssel als Dateien volumes (configMap, secret) ja, nach ca. 60–90 s

Fortschritt speichern? Kostenlos registrieren

Drill 5: Konfiguration ändern

Der worker soll alle 5 statt 10 Sekunden zählen:

kubectl patch configmap notes-config --type merge -p '{"data":{"INTERVAL":"5"}}'
sleep 20
kubectl exec deploy/worker -- printenv INTERVAL
kubectl logs deploy/worker --timestamps | tail -2

Erwartet (gekürzt):

configmap/notes-config patched
10
2026-10-30T14:34:57.64…Z summary: 1 notes, 5 words
2026-10-30T14:35:07.70…Z summary: 1 notes, 5 words

Nichts passiert. Eine Umgebungsvariable wird beim Start des Containers gesetzt und bleibt. Neue Pods müssen her:

kubectl rollout restart deploy/worker
kubectl rollout status deploy/worker >/dev/null
kubectl exec deploy/worker -- printenv INTERVAL
sleep 11; kubectl logs deploy/worker --timestamps | tail -3
kubectl get deploy worker -o jsonpath='{.spec.template.metadata.annotations}'; echo

Erwartet (gekürzt):

deployment.apps/worker restarted
5
2026-10-30T14:35:18.96…Z worker started, api=http://api:8080, interval=5s
2026-10-30T14:35:19.75…Z summary: 0 notes, 0 words
2026-10-30T14:35:24.78…Z summary: 1 notes, 5 words
{"kubectl.kubernetes.io/restartedAt":"2026-10-30T14:35:12Z"}

rollout restart setzt nur eine Annotation mit der Uhrzeit ins Pod-Template. Das Template ändert sich, also rollt das Deployment wie bei einem neuen Image – mit derselben Strategie, ohne Ausfall. Die 0 notes sind übrigens die Speicher-Repliken von Tag 3: Der worker hat eine andere api erwischt.

Zurück auf den Stand im Repo:

kubectl apply -f k8s/config.yaml
kubectl rollout restart deploy/worker && kubectl rollout status deploy/worker

Erwartet (gekürzt):

configmap/notes-config configured
deployment.apps/worker restarted
deployment "worker" successfully rolled out

Fortschritt speichern? Kostenlos registrieren

Drill 6: Key rotieren

Der Key ist durchgesickert, ein neuer muss her. Neues Secret anlegen und zuschauen, wann die Datei im worker umspringt:

NOTES_API_KEY=lab-api-key-456 ./k8s/secrets.sh
s=$SECONDS
until [ "$(kubectl exec deploy/worker -- cat /etc/notes/api-key)" \
  = lab-api-key-456 ]; do sleep 2; done
echo "Datei nach $((SECONDS - s)) s aktualisiert"
kubectl exec deploy/web -- printenv NOTES_API_KEY
curl -s -X POST localhost:30080/api/notes -H 'Content-Type: application/json' \
  -d '{"text":"vor dem Neustart"}'; echo

Erwartet (gekürzt, die Sekunden weichen ab):

secret/notes-api configured
Datei nach 72 s aktualisiert
lab-api-key-123
{"id":"7ba3655d-…","text":"vor dem Neustart"}

Die Datei folgt nach rund einer Minute (Sync-Intervall des Kubelets plus Cache), die Variable in web nie. Der POST klappt trotzdem: api hat den alten Key beim Start gelesen, web schickt den alten mit. Jetzt die Falle – nur api neu starten:

kubectl rollout restart deploy/api && kubectl rollout status deploy/api >/dev/null
curl -s -X POST localhost:30080/api/notes -H 'Content-Type: application/json' \
  -d '{"text":"nur api neu"}'; echo

Erwartet:

deployment.apps/api restarted
{"error":"invalid api key"}

api kennt jetzt …-456, web schickt noch …-123. Eine Rotation ist erst fertig, wenn alle Leser neu gestartet sind:

kubectl rollout restart deploy/web deploy/worker
kubectl rollout status deploy/web >/dev/null
kubectl rollout status deploy/worker >/dev/null
sleep 3
curl -s -X POST localhost:30080/api/notes -H 'Content-Type: application/json' \
  -d '{"text":"alle neu"}'; echo

Erwartet (gekürzt):

deployment.apps/web restarted
deployment.apps/worker restarted
{"id":"819e6086-…","text":"alle neu"}

Achtung: Ohne das sleep 3 meldet curl direkt nach dem Rollout von web gelegentlich nichts (Exit 56, Verbindung zurückgesetzt). Ein alter web-Pod bekam noch Verkehr, während er schon beendet wurde. Was dagegen hilft, zeigt Tag 5.

Drill zu Ende – zurück auf den Lab-Key, damit der Endstand stimmt:

./k8s/secrets.sh
kubectl rollout restart deploy/api deploy/web deploy/worker
for d in api web worker; do kubectl rollout status deploy/$d >/dev/null; done
sleep 3; kubectl exec deploy/web -- printenv NOTES_API_KEY

Erwartet:

secret/notes-api configured
deployment.apps/api restarted
deployment.apps/web restarted
deployment.apps/worker restarted
lab-api-key-123

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

kubectl exec deploy/worker -- printenv INTERVAL NOTES_API_URL

Erwartet: beide Werte aus der ConfigMap notes-config.

10
http://api:8080
kubectl logs deploy/api | grep 'api key'

Erwartet: source=file, der Key kommt aus dem Secret-Volume.

Found 3 pods, using pod/api-9bcdb694-zx2cx
time=… level=INFO msg="api key loaded" source=file
grep -rl lab-api-key k8s/

Erwartet: nur secrets.sh, kein Manifest enthält den Key.

k8s/secrets.sh
curl -s -X POST localhost:30080/api/notes -H 'Content-Type: application/json' \
  -d '{"text":"Kontrollpunkt Tag 4"}'

Erwartet: web reicht den Key weiter, die api legt die Notiz an.

{"id":"dbba8751-…","text":"Kontrollpunkt Tag 4"}

Challenge

Ein Kollege vertippt sich im Schlüsselnamen des Secrets bei web (apikey statt api-key) und spielt das per kubectl patch ein. Was sieht man an den Pods, warum bleibt die Seite erreichbar, und wie findest du die Ursache?

Hinweis: Schau dir die Events des neuen Pods an – und überleg, was die RollingUpdate-Strategie mit den alten macht.

Lösung

kubectl patch deploy web --type json -p '[{"op":"replace",
  "path":"/spec/template/spec/containers/0/env/1/valueFrom/secretKeyRef/key",
  "value":"apikey"}]'
sleep 15
kubectl get pods -l app.kubernetes.io/name=web
kubectl rollout status deploy/web --timeout 10s; echo "Exit: $?"
kubectl get events --field-selector type=Warning,reason=Failed \
  -o custom-columns=MESSAGE:.message | tail -1
curl -s -o /dev/null -w '%{http_code}\n' localhost:30080/api/notes

Erwartet (gekürzt):

deployment.apps/web patched
NAME                   READY   STATUS                       RESTARTS   AGE
web-5f7797cd47-88d5f   1/1     Running                      0          33s
web-5f7797cd47-qmp95   1/1     Running                      0          36s
web-8495c45c4d-wnjxn   0/1     CreateContainerConfigError   0          16s
Waiting for deployment "web" rollout to finish: 1 out of 2 new replicas have been…
error: timed out waiting for the condition
Exit: 1
Error: couldn't find key apikey in Secret notes/notes-api
200

Fehlt ein Schlüssel oder ein ganzes Secret, kann das Kubelet die Umgebung nicht bauen: CreateContainerConfigError. Die alten Pods laufen weiter, weil die Strategie erst einen neuen Pod bereit sehen will, bevor sie einen alten abbaut – der Rollout hängt, die App nicht. Reparatur mit der Datei aus dem Repo:

kubectl apply -f k8s/web.yaml && kubectl rollout status deploy/web

Erwartet:

deployment.apps/web configured
service/web unchanged
Waiting for deployment "web" rollout to finish: 1 old replicas are pending…
deployment "web" successfully rolled out

kubectl rollout undo deploy/web ginge auch, warnt aber, dass die Annotation last-applied-configuration danach nicht mehr zum Cluster passt.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Secrets im etcd verschlüsseln (EncryptionConfiguration, ideal mit KMS-Provider) und get/list auf Secrets per RBAC eng fassen – list liefert alle Werte mit.
  • Secrets gehören nicht ins Git, auch nicht base64-kodiert. Üblich sind External Secrets Operator mit Vault/OpenBao („OpenBao-Secrets zum Anfassen”), Sealed Secrets oder SOPS.
  • Automatische Neustarts nach Konfig-Änderung: Prüfsummen-Annotation im Pod-Template (Helm, Tag 10) oder ein Controller wie Reloader.
  • immutable: true für ConfigMaps und Secrets, die sich nie ändern, entlastet den API-Server und verhindert versehentliche Änderungen; neue Werte heißt dann neuer Name.
  • subPath-Mounts bekommen keine Aktualisierungen – wer auf Live-Reload setzt, mountet das ganze Verzeichnis.