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.propertiesErwartet:
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}'; echoErwartet:
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-apiErwartet (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; echoErwartet:
data:
api-key: bGFiLWFwaS1rZXktMTIz
lab-api-key-123
Sicherheit: base64 ist eine Kodierung, keine Verschlüsselung. Wer
get secretdarf, kennt den Wert. Undkubectl applylegt zusätzlich die Annotationkubectl.kubernetes.io/last-applied-configurationmit 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-apiapi 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-keygrep -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_KEYErwartet (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"}'; echoErwartet (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 -2Erwartet (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}'; echoErwartet (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/workerErwartet (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"}'; echoErwartet (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"}'; echoErwartet:
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"}'; echoErwartet (gekürzt):
deployment.apps/web restarted
deployment.apps/worker restarted
{"id":"819e6086-…","text":"alle neu"}
Achtung: Ohne das
sleep 3meldetcurldirekt 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_KEYErwartet:
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_URLErwartet: 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/notesErwartet (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/webErwartet:
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) undget/listauf Secrets per RBAC eng fassen –listliefert 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: truefü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.