Zum Inhalt springen
Trainingslager IT-Trainingslager

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 subPath wird 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=1

Erwartet:

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/shop

Erwartet (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: subPath ist 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-88

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

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

Erwartet:

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-helm

Erwartet:

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 --set gerendertes Secret liegt zusätzlich im Release-Secret von Helm: helm -n shop get manifest shop-helm | grep db_password zeigt 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 inotify

Erwartet (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=1

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

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Lege pro Plattform fest, welcher Zustellweg Standard ist, und dokumentiere die maximale Rotationslatenz (ESO-Intervall + kubelet-Sync + Rollout).
  • Verbiete subPath fü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.