Tag 9: Ausrollen und Neuladen
Ziel: Du rotierst ein Secret in OpenBao und weißt für jeden Zustellweg, wann und ob es beim Pod ankommt. · Dauer: ca. 120 min · Voraussetzung: Tag 3, Tag 8
Briefing
- Env-Variablen werden beim Containerstart gesetzt und ändern sich danach nie.
- Gemountete Kubernetes-Secrets aktualisiert der kubelet, aber
verzögert (im Lab gut 80 s). Ein Mount mit
subPathwird nie aktualisiert. - Ein neuer Wert in der Datei nützt nichts, wenn die App ihn nicht neu liest.
- Für alles andere braucht es einen Neustart: Stakater Reloader oder eine Checksum-Annotation im Helm-Chart.
OpenBao KV ──(ESO refresh / Skript)──► K8s Secret ──kubelet-Sync──► Datei im Pod
│ (nicht bei subPath)
└──Reloader──► Rollout ──► neue Env-Werte
Drill 1: Ein Secret, drei Zustellwege
Das K8s-Secret shop-db entsteht hier per Skript aus
OpenBao, wie in Tag 1. Das Deployment liest dasselbe Passwort als
Env-Variable, als Datei im Volume und als einzelne Datei per
subPath.
mkdir -p ~/secrets-lab/tag09 && cd ~/secrets-lab/tag09
export BAO_ADDR=http://127.0.0.1:8200 BAO_TOKEN=root
bao kv patch secret/shop/api db_password=lab-db-pw-123 >/dev/null
kubectl -n shop create secret generic shop-db --save-config \
--from-literal=db_password="$(bao kv get -field=db_password secret/shop/api)"
# shop-api aus Tag 6 (CSI-Variante) entfernen, hier entsteht eine neue
kubectl -n shop delete deploy shop-api --ignore-not-found >/dev/null
cat > shop-api.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: shop-api
namespace: shop
spec:
replicas: 1
selector:
matchLabels: {app: shop-api}
template:
metadata:
labels: {app: shop-api}
spec:
serviceAccountName: shop-api
terminationGracePeriodSeconds: 1
containers:
- name: app
image: busybox:1.37
command: ["sh", "-c"]
args:
- while true; do
echo "$(date +%T) env=$DB_PASSWORD
vol=$(cat /etc/shop/db_password)
subpath=$(cat /etc/db_password)";
sleep 5;
done
env:
- name: DB_PASSWORD
valueFrom:
secretKeyRef: {name: shop-db, key: db_password}
volumeMounts:
- {name: db, mountPath: /etc/shop, readOnly: true}
- {name: db, mountPath: /etc/db_password, subPath: db_password,
readOnly: true}
volumes:
- name: db
secret: {secretName: shop-db}
EOF
kubectl apply -f shop-api.yaml
kubectl -n shop rollout status deploy/shop-api --timeout=120s
kubectl -n shop logs deploy/shop-api --tail=1Erwartet:
secret/shop-db created
deployment.apps/shop-api created
deployment "shop-api" successfully rolled out
06:54:08 env=lab-db-pw-123 vol=lab-db-pw-123 subpath=lab-db-pw-123
Fortschritt speichern? Kostenlos registrieren
Drill 2: Rotation – was kommt an?
Neues Passwort in OpenBao, dann das K8s-Secret nachziehen. Die Schleife misst, wann die Datei im Volume den neuen Wert zeigt.
bao kv patch secret/shop/api db_password=lab-db-pw-200 >/dev/null
kubectl -n shop create secret generic shop-db \
--from-literal=db_password="$(bao kv get -field=db_password secret/shop/api)" \
--dry-run=client -o yaml | kubectl apply -f -
S=$(date +%s)
until kubectl -n shop logs deploy/shop-api --tail=1 | grep -q 'vol=lab-db-pw-200'; do
sleep 3
done
echo "nach $(( $(date +%s) - S )) s"
kubectl -n shop logs deploy/shop-api --tail=1
kubectl -n shop exec deploy/shop-api -- ls -la /etc/shopErwartet (gekürzt):
secret/shop-db configured
nach 82 s
06:55:34 env=lab-db-pw-123 vol=lab-db-pw-200 subpath=lab-db-pw-123
drwxr-xr-x 2 root root 60 Oct 12 06:55 ..2026_10_12_06_55_30.2661270642
lrwxrwxrwx 1 root root 32 Oct 12 06:55 ..data -> ..2026_10_12_06_55_30.2661270642
lrwxrwxrwx 1 root root 18 Oct 12 06:54 db_password -> ..data/db_password
Nur das Volume ist aktuell. Der kubelet schreibt ein neues
Zeitstempel-Verzeichnis und tauscht den Symlink ..data
atomar. Ein subPath-Mount zeigt aber direkt auf die alte
Datei und bekommt den Tausch nie mit. Die Verzögerung hängt von
syncFrequency und dem Cache des kubelet ab. Rechne mit bis
zu zwei Minuten.
Achtung:
subPathist die häufigste Ursache für „Rotation kommt nicht an”. Mounte Secrets als Verzeichnis und lass die App den Dateinamen darin lesen.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Stakater Reloader
Reloader beobachtet Secrets und ConfigMaps und stößt bei Änderungen einen Rollout der Deployments an, die per Annotation darum bitten.
helm repo add stakater https://stakater.github.io/stakater-charts >/dev/null
helm upgrade --install reloader stakater/reloader --version 2.2.18 \
-n reloader --create-namespace --wait
kubectl -n reloader get pods
kubectl -n shop annotate deploy/shop-api reloader.stakater.com/auto="true"
bao kv patch secret/shop/api db_password=lab-db-pw-300 >/dev/null
kubectl -n shop create secret generic shop-db \
--from-literal=db_password="$(bao kv get -field=db_password secret/shop/api)" \
--dry-run=client -o yaml | kubectl apply -f -
kubectl -n shop rollout status deploy/shop-api --timeout=120s
sleep 10; kubectl -n shop logs deploy/shop-api --tail=1
kubectl -n reloader logs deploy/reloader-reloader --tail=1 | cut -c1-88Erwartet (gekürzt):
NAME READY STATUS RESTARTS AGE
reloader-reloader-747db87b76-tzv5k 1/1 Running 0 16s
deployment.apps/shop-api annotated
secret/shop-db configured
deployment "shop-api" successfully rolled out
06:56:03 env=lab-db-pw-300 vol=lab-db-pw-300 subpath=lab-db-pw-300
time="2026-10-12T06:56:03Z" level=info msg="Changes detected in 'shop-db' of type 'SECRE
Alle drei Wege sind jetzt aktuell, weil der Pod neu gestartet ist. Woran Reloader den Rollout auslöst, zeigt das Pod-Template:
kubectl -n shop get deploy shop-api -o jsonpath=\
'{range .spec.template.spec.containers[0].env[*]}{.name}{"\n"}{end}'Erwartet:
STAKATER_SHOP_DB_SECRET
DB_PASSWORD
Im Standard-Modus schreibt Reloader einen Hash des Secrets als
Env-Variable ins Template. Das ändert das Template, und der
Deployment-Controller rollt aus. Mit
reloader.reloadStrategy=annotations nimmt er stattdessen
eine Annotation, was sich mit GitOps-Werkzeugen besser verträgt (Tag
13).
Fortschritt speichern? Kostenlos registrieren
Drill 4: ESO-Refresh plus Reloader
ESO (Grundlagen in Tag 3) holt das Secret regelmäßig aus OpenBao,
Reloader startet den Pod neu. Zusammen ergibt das eine Kette ohne
manuelles Zutun. Für das Lab reicht ESO ohne Webhook und
Cert-Controller. Läuft ESO aus Tag 3 noch, überspringst du den
helm-Befehl.
helm repo add external-secrets https://charts.external-secrets.io >/dev/null
helm upgrade --install external-secrets external-secrets/external-secrets \
--version 2.12.0 -n external-secrets --create-namespace \
--set webhook.create=false --set certController.create=false --wait
cat > eso-reloader.yaml <<'EOF'
apiVersion: external-secrets.io/v1
kind: SecretStore
metadata:
name: openbao
namespace: shop
spec:
provider:
vault:
server: http://openbao.openbao.svc:8200
path: secret
version: v2
auth:
kubernetes:
mountPath: kubernetes
role: shop-api
serviceAccountRef:
name: shop-api
audiences: [openbao]
---
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
name: shop-db-eso
namespace: shop
spec:
refreshInterval: 15s # Lab: kurz, damit man es sieht
secretStoreRef: {kind: SecretStore, name: openbao}
target: {name: shop-db-eso}
data:
- secretKey: db_password
remoteRef: {key: shop/api, property: db_password}
---
apiVersion: apps/v1
kind: Deployment
metadata:
name: shop-api-eso
namespace: shop
annotations:
reloader.stakater.com/auto: "true"
spec:
replicas: 1
selector:
matchLabels: {app: shop-api-eso}
template:
metadata:
labels: {app: shop-api-eso}
spec:
terminationGracePeriodSeconds: 1
containers:
- name: app
image: busybox:1.37
command: ["sh", "-c", "echo \"$(date +%T) env=$DB_PASSWORD\"; sleep 3600"]
env:
- name: DB_PASSWORD
valueFrom:
secretKeyRef: {name: shop-db-eso, key: db_password}
EOF
kubectl apply -f eso-reloader.yaml
kubectl -n shop wait --for=condition=Ready externalsecret/shop-db-eso --timeout=60s
kubectl -n shop rollout status deploy/shop-api-eso --timeout=60s
kubectl -n shop logs deploy/shop-api-esoErwartet (gekürzt):
secretstore.external-secrets.io/openbao created
externalsecret.external-secrets.io/shop-db-eso created
deployment.apps/shop-api-eso created
externalsecret.external-secrets.io/shop-db-eso condition met
deployment "shop-api-eso" successfully rolled out
07:17:43 env=lab-db-pw-300
Jetzt nur noch in OpenBao rotieren, kein kubectl
mehr:
S=$(date +%s); bao kv patch secret/shop/api db_password=lab-db-pw-700 >/dev/null
until kubectl -n shop logs deploy/shop-api-eso 2>/dev/null | grep -q pw-700; do
sleep 2
done
echo "nach $(( $(date +%s) - S )) s"
kubectl -n shop logs deploy/shop-api-eso
kubectl -n reloader logs deploy/reloader-reloader --tail=1 | cut -c1-88Erwartet:
nach 15 s
07:17:58 env=lab-db-pw-700
time="2026-10-12T07:17:58Z" level=info msg="Changes detected in 'shop-db-eso' of type 'S
Die Latenz ist höchstens refreshInterval plus
Rollout-Dauer. Produktiv sind Minuten statt 15 s üblich, jeder Refresh
ist ein Lesezugriff auf OpenBao und eine Zeile im Audit-Log (Tag
14).
Fortschritt speichern? Kostenlos registrieren
Drill 5: Checksum-Annotation in Helm
Rendert Helm das Secret selbst, geht es ohne Reloader: Ein Hash des gerenderten Secrets als Annotation im Pod-Template erzwingt bei jeder Änderung einen Rollout.
mkdir -p shop-chart/templates
cat > shop-chart/Chart.yaml <<'EOF'
apiVersion: v2
name: shop-chart
version: 0.1.0
EOF
cat > shop-chart/values.yaml <<'EOF'
dbPassword: "" # kommt per --set aus OpenBao, nie in Git
EOF
cat > shop-chart/templates/secret.yaml <<'EOF'
apiVersion: v1
kind: Secret
metadata:
name: shop-db-helm
stringData:
db_password: {{ required "dbPassword fehlt" .Values.dbPassword | quote }}
EOF
cat > shop-chart/templates/deployment.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: shop-api-helm
spec:
replicas: 1
selector:
matchLabels: {app: shop-api-helm}
template:
metadata:
labels: {app: shop-api-helm}
annotations:
# ändert sich der gerenderte Secret-Inhalt, ändert sich das Pod-Template
checksum/secret: {{ include (print $.Template.BasePath "/secret.yaml") .
| sha256sum }}
spec:
terminationGracePeriodSeconds: 1
containers:
- name: app
image: busybox:1.37
command: ["sh", "-c", "echo env=$DB_PASSWORD; sleep 3600"]
env:
- name: DB_PASSWORD
valueFrom:
secretKeyRef: {name: shop-db-helm, key: db_password}
EOF
deploy() {
helm upgrade --install shop-helm ./shop-chart -n shop --wait \
--set dbPassword="$(bao kv get -field=db_password secret/shop/api)" >/dev/null
kubectl -n shop get deploy shop-api-helm \
-o jsonpath='{.spec.template.metadata.annotations.checksum/secret}' | cut -c1-16
}
deploy
bao kv patch secret/shop/api db_password=lab-db-pw-400 >/dev/null
deploy
kubectl -n shop rollout status deploy/shop-api-helm >/dev/null
sleep 10; kubectl -n shop logs deploy/shop-api-helmErwartet:
733a251645c9aaa5
013d7802998a6c98
env=lab-db-pw-400
Neuer Hash, neues Pod-Template, neuer Pod. Der erste Hash hängt vom aktuellen Passwort ab und sieht bei dir anders aus. Das Muster wirkt nur, wenn Helm das Secret rendert. Ein von ESO verwaltetes Secret ändert sich außerhalb von Helm, dort hilft nur Reloader.
Sicherheit: Ein per
--setgerendertes Secret liegt zusätzlich im Release-Secret von Helm:helm -n shop get manifest shop-helm | grep db_passwordzeigt den Klartext. Jeder mit Leserecht auf Secrets im Namespace sieht so auch alle alten Versionen.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Die App lädt die Datei selbst neu
Ohne Neustart geht es nur, wenn die App die Datei erneut liest. Zwei
Varianten: Polling im App-Container und inotifyd als
Beobachter des Verzeichnisses.
cat > shop-api-watch.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: shop-api-watch
namespace: shop
spec:
replicas: 1
selector:
matchLabels: {app: shop-api-watch}
template:
metadata:
labels: {app: shop-api-watch}
spec:
terminationGracePeriodSeconds: 1
containers:
- name: app
image: busybox:1.37
command: ["sh", "-c"]
args:
- |
F=/etc/shop/db_password
OLD=$(cat $F); echo "$(date +%T) start: ***${OLD#lab-db-pw-}"
while sleep 5; do # Polling: robust, einfach
NEW=$(cat $F)
if [ "$NEW" != "$OLD" ]; then
echo "$(date +%T) neu geladen: ***${NEW#lab-db-pw-}"
OLD=$NEW # hier: DB-Pool neu aufbauen
fi
done
volumeMounts:
- {name: db, mountPath: /etc/shop, readOnly: true}
- name: inotify
image: busybox:1.37
# beobachtet das Verzeichnis, nicht die Datei: kubelet tauscht Symlinks
command: ["inotifyd", "-", "/etc/shop:nmdy"]
volumeMounts:
- {name: db, mountPath: /etc/shop, readOnly: true}
volumes:
- name: db
secret: {secretName: shop-db}
EOF
kubectl apply -f shop-api-watch.yaml
kubectl -n shop rollout status deploy/shop-api-watch --timeout=60s
kubectl -n shop annotate deploy/shop-api reloader.stakater.com/auto-
bao kv patch secret/shop/api db_password=lab-db-pw-500 >/dev/null
kubectl -n shop create secret generic shop-db \
--from-literal=db_password="$(bao kv get -field=db_password secret/shop/api)" \
--dry-run=client -o yaml | kubectl apply -f -
until kubectl -n shop logs deploy/shop-api-watch -c app | grep -q 'neu geladen'; do
sleep 3
done
kubectl -n shop logs deploy/shop-api-watch -c app
kubectl -n shop logs deploy/shop-api-watch -c inotifyErwartet (gekürzt):
deployment.apps/shop-api-watch created
deployment "shop-api-watch" successfully rolled out
deployment.apps/shop-api annotated
secret/shop-db configured
07:01:07 start: ***300
07:02:37 neu geladen: ***500
n /etc/shop ..2026_10_12_07_02_36.2535364209
n /etc/shop ..data_tmp
m /etc/shop ..data_tmp
y /etc/shop ..data
d /etc/shop ..2026_10_12_07_01_06.1686137420
Die Ereignisse zeigen den Ablauf: neues Verzeichnis anlegen
(n), temporären Symlink anlegen und umbenennen
(m/y), altes Verzeichnis löschen
(d). Ein Watch direkt auf db_password sieht
davon nichts, weil sich der Symlink selbst nie ändert. Beobachte also
das Verzeichnis oder poll den Dateiinhalt.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Vergleichsmatrix – wann was?
Die Methoden des Buchs im Überblick. „etcd” heißt: Das Secret liegt als Kubernetes-Secret im Cluster.
| Methode | Secret in etcd? | Rotation beim Pod | Aufwand |
|---|---|---|---|
| KV direkt per Skript (Tag 1) | ja | Skript neu + Neustart | gering, fehleranfällig |
| ESO (Tag 3/4) | ja | refreshInterval + Reloader |
mittel, ein Operator |
| Agent Injector (Tag 5) | nein | Sidecar rendert Datei neu | mittel, Sidecar je Pod |
| CSI Driver (Tag 6) | nein (optional Sync) | Datei, wenn Rotation aktiv | mittel, DaemonSet |
App-SDK / bao agent (Tag 8) |
nein | App liest selbst / exec-Neustart | hoch, Code im Team |
| Methode | Templating | Env-Variablen | Gut für |
|---|---|---|---|
| KV direkt per Skript | Shell | ja, statisch | Bootstrap, Einmal-Jobs |
| ESO | target.template |
ja, mit Reloader | Standard-Apps, GitOps |
| Agent Injector | Consul-Template | nur über Datei/source |
Legacy-Apps mit Dateien |
| CSI Driver | nein | nur über Sync-Secret | Dateien ohne Sidecar |
App-SDK / bao agent |
Code / env_template |
bao agent exec |
dynamische Secrets, volle Kontrolle |
Faustregel: Kann die App Dateien neu lesen, gewinnt jeder dateibasierte Weg ohne Neustart. Braucht sie Env-Variablen, plane Reloader von Anfang an mit ein.
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
cd ~/secrets-lab/tag09
want=$(bao kv get -field=db_password secret/shop/api)
kubectl -n reloader get deploy reloader-reloader >/dev/null 2>&1 \
&& echo "✔ Reloader installiert" || echo "✘ Reloader fehlt"
[ "$(kubectl -n shop get secret shop-db -o jsonpath='{.data.db_password}' \
| base64 -d)" = "$want" ] && echo "✔ shop-db aktuell" || echo "✘ shop-db veraltet"
kubectl -n shop logs deploy/shop-api-watch -c app | grep -q "${want#lab-db-pw-}" \
&& echo "✔ shop-api-watch hat neu geladen" || echo "✘ shop-api-watch veraltet"
kubectl -n shop get deploy shop-api-helm -o yaml | grep -q 'checksum/secret' \
&& echo "✔ Checksum-Annotation" || echo "✘ Checksum-Annotation fehlt"
grep -q subPath shop-api.yaml \
&& echo "✔ subPath-Falle dokumentiert (shop-api.yaml)" || echo "✘ subPath fehlt"Challenge
Reloader soll shop-api nur noch bei Änderungen an
shop-db neu starten, nicht bei jedem Secret, das das
Deployment irgendwann referenziert. Weise nach, dass eine Änderung an
einem anderen Secret keinen Rollout auslöst.
Hinweis: Statt auto gibt es eine
Annotation, die Secrets namentlich auflistet.
Lösung
kubectl -n shop annotate deploy/shop-api secret.reloader.stakater.com/reload=shop-db
kubectl -n shop create secret generic shop-other --from-literal=x=1 --save-config
REV=$(kubectl -n shop get deploy shop-api \
-o jsonpath='{.metadata.annotations.deployment\.kubernetes\.io/revision}')
kubectl -n shop create secret generic shop-other --from-literal=x=2 \
--dry-run=client -o yaml | kubectl apply -f -
sleep 5
kubectl -n shop get deploy shop-api \
-o jsonpath='{.metadata.annotations.deployment\.kubernetes\.io/revision}{"\n"}'
echo "vorher: $REV"
bao kv patch secret/shop/api db_password=lab-db-pw-600 >/dev/null
kubectl -n shop create secret generic shop-db \
--from-literal=db_password="$(bao kv get -field=db_password secret/shop/api)" \
--dry-run=client -o yaml | kubectl apply -f -
kubectl -n shop rollout status deploy/shop-api --timeout=60s
sleep 10; kubectl -n shop logs deploy/shop-api --tail=1Erwartet (gekürzt):
deployment.apps/shop-api annotated
secret/shop-other created
secret/shop-other configured
2
vorher: 2
secret/shop-db configured
deployment "shop-api" successfully rolled out
07:15:40 env=lab-db-pw-600 vol=lab-db-pw-600 subpath=lab-db-pw-600
Die Revision bleibt nach der Änderung an shop-other
gleich: kein Rollout. Erst shop-db löst einen aus.
Aufräumen für Tag 10:
kubectl -n shop delete deploy shop-api-watch
helm -n shop uninstall shop-helm
kubectl -n shop delete secret shop-otherFortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Lege pro Plattform fest, welcher Zustellweg Standard ist, und dokumentiere die maximale Rotationslatenz (ESO-Intervall + kubelet-Sync + Rollout).
- Verbiete
subPathfür Secret-Volumes per Policy oder Review-Checkliste, wenn Rotation zugesagt ist. - Rollouts durch Reloader brauchen
maxUnavailable/PodDisruptionBudgets und gesunde Readiness-Probes. Eine Rotation darf keinen Ausfall erzeugen. - Rotiere Passwörter mit Überlappung: Neues und altes Credential gelten kurz parallel, bis alle Pods neu gelesen haben. Dynamische Secrets (Tag 7) lösen das eleganter.
- Helm-Release-Secrets und
kubectl-Historie gehören in die Betrachtung, wer Secrets lesen kann.