Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 13: Sealed Secrets – Schlüssel sichern, erneuern, wiederherstellen

Ziel: Du sicherst den Schlüssel des Controllers – mit sops verschlüsselt im Git –, erneuerst ihn vorzeitig, versiegelst neu, überlebst den Verlust des Clusters und entschlüsselst im Notfall ganz ohne Cluster. · Dauer: ca. 75 min · Voraussetzung: Tag 12

Briefing

  • Der Controller hat eine Liste von Schlüsseln. Alle 30 Tage legt er einen neuen an und versiegelt ab dann damit; die alten behält er zum Entschlüsseln.
  • Ohne Sicherung ist ein verlorener Cluster ein verlorenes Repo: Kein Mensch kann SealedSecrets entschlüsseln. Die Sicherung ist also Pflicht – und sie ist das geheimste Objekt überhaupt.
  • Hier kommen beide Welten zusammen: Die Schlüssel von Sealed Secrets liegen, mit sops verschlüsselt, im selben Repo.
  • Schlüssel erneuern und neu versiegeln ändert nichts an alten Ständen im Git. Wer einen alten Schlüssel hat, liest alte Werte. Ist ein Schlüssel verbrannt, wechselst du die Werte.
 kube-system: sealed-secrets-key<a> (alt)  sealed-secrets-key<b> (neu, versiegelt)
                    │ kubectl get -l … -o yaml │
                    ▼                           ▼
 repo: backup/sealed-secrets-keys.yaml  ── sops (prod.key + ich) ──► Git
                    │ Katastrophe: sops decrypt | kubectl create, Pod neu starten
                    ▼
 neuer Cluster entschlüsselt wieder alle SealedSecrets aus sealed/

Drill 1: Der Schlüssel im Cluster

# auf argo
mkdir -p ~/sops/tag13 && cd ~/sops/tag13
kubectl -n kube-system get secret -l sealedsecrets.bitnami.com/sealed-secrets-key \
  -o custom-columns='NAME:.metadata.name,CREATED:.metadata.creationTimestamp'
kubectl -n kube-system get secret -l sealedsecrets.bitnami.com/sealed-secrets-key \
  -o json | jq -r '.items[0].data | keys[]'

Erwartet:

NAME                      CREATED
sealed-secrets-keyk7bkd   2026-11-20T18:23:56Z
tls.crt
tls.key

tls.crt ist das Zertifikat, das kubeseal --fetch-cert ausliefert. tls.key ist der private Schlüssel – wer ihn hat, entschlüsselt jedes SealedSecret dieses Clusters, auch alle alten Stände im Git.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Verschlüsselt sichern

Die Sicherung landet im Ordner backup/. Er bekommt eine eigene sops-Regel (nach dem Muster von prod: prod-Schlüssel plus deiner) und wird in den Hook aufgenommen. Die neue Regel steht ganz oben – die erste passende gewinnt (Tag 4).

# auf argo
cd ~/sops/repo
P=$(age-keygen -y ~/sops/tag04/prod.key)
I=$(age-keygen -y ~/.config/sops/age/keys.txt)
yq -i '.creation_rules = [{"path_regex": "^backup/.*\\.yaml$",
  "encrypted_regex": "^(data|stringData)$", "age": "'"$P,$I"'"}]
  + .creation_rules' .sops.yaml
yq '.creation_rules[0].path_regex' .sops.yaml
sed -i 's#tresor/\*)#tresor/*|backup/*)#' hooks/pre-commit
grep -c 'backup/\*' hooks/pre-commit
mkdir -p backup
kubectl -n kube-system get secret -l sealedsecrets.bitnami.com/sealed-secrets-key \
  -o yaml | yq 'del(.items[].metadata.uid, .items[].metadata.resourceVersion,
  .items[].metadata.creationTimestamp, .items[].metadata.managedFields,
  .items[].metadata.annotations)' \
  > backup/sealed-secrets-keys.yaml

Erwartet:

^backup/.*\.yaml$
1

Erst die Probe: Was passiert, wenn jemand die Datei so committet?

# auf argo
cd ~/sops/repo
git add backup && git commit -q -m "tag13: Schlüssel (Klartext)"; echo "rc=$?"
git restore --staged backup

Erwartet:

6:25PM WRN leaks found: 1
rc=1

gitleaks erkennt den privaten Schlüssel und der Hook bricht sofort ab. Wäre der Schlüssel in einem Format, das gitleaks nicht kennt, hielte die Strukturprüfung den fehlenden sops-Block auf. Jetzt richtig:

# auf argo
cd ~/sops/repo
sops encrypt -i backup/sealed-secrets-keys.yaml
grep -E 'tls\.(crt|key):' backup/sealed-secrets-keys.yaml | cut -c1-50
git add .sops.yaml hooks backup
git commit -q -m "tag13: Sealed-Secrets-Schlüssel gesichert" && git push -q
git log --oneline | head -1

Erwartet:

      tls.crt: ENC[AES256_GCM,data:hYh3lRAVWQiOmh6
      tls.key: ENC[AES256_GCM,data:vcjxgHiUeawCvAI
30c26d3 tag13: Sealed-Secrets-Schlüssel gesichert

Achtung: Die Sicherung ist nur so sicher wie die Schlüssel, die sie öffnen. Hier sind es der prod-Schlüssel und deiner – im Betrieb ein Notfallschlüssel im Tresor oder Shamir mit 2 von 3 (Tag 6).

Fortschritt speichern? Kostenlos registrieren

Drill 3: Vorzeitig erneuern

Der Controller erneuert alle 30 Tage (keyrenewperiod). Sofort geht es mit einer Stichzeit: Ist der neueste Schlüssel älter als keycutofftime, legt der Controller beim Start einen neuen an. Das Format ist RFC 1123 – genau das, was date -R liefert.

Einbauen:

# auf argo
helm upgrade sealed-secrets sealed-secrets/sealed-secrets --version 2.22.0 \
  -n kube-system --reuse-values --set-string keycutofftime="$(date -R)" 2>&1 \
  | tail -1

Erwartet:

Error: failed parsing --set-string data: key " 20 Nov 2026 18:25:37 +0000" has no value

Ursache: date -R beginnt mit Fri, – und das Komma trennt bei --set und --set-string zwei Zuweisungen.

Fix: Den Wert in eine kleine Values-Datei schreiben.

# auf argo
cd ~/sops/tag13
printf 'keycutofftime: "%s"\n' "$(date -R)" > cutoff.yaml
cat cutoff.yaml
helm upgrade sealed-secrets sealed-secrets/sealed-secrets --version 2.22.0 \
  -n kube-system --reuse-values -f cutoff.yaml --wait 2>&1 | grep REVISION
sleep 5
kubectl -n kube-system get secret -l sealedsecrets.bitnami.com/sealed-secrets-key \
  -o custom-columns='NAME:.metadata.name,CREATED:.metadata.creationTimestamp'
kubectl -n kube-system logs deploy/sealed-secrets-controller \
  | grep -oE 'msg="(registered private key|New key written)".*name=[a-z0-9-]+'

Erwartet:

keycutofftime: "Fri, 20 Nov 2026 18:25:37 +0000"
REVISION: 2
NAME                      CREATED
sealed-secrets-keyk7bkd   2026-11-20T18:23:56Z
sealed-secrets-keytbvdh   2026-11-20T18:25:44Z
msg="registered private key" secretname=sealed-secrets-keyk7bkd
msg="New key written" namespace=kube-system name=sealed-secrets-keytbvdh

Der alte Schlüssel bleibt – alle SealedSecrets im Cluster bleiben True. Neues Versiegeln nutzt ab jetzt den neuen.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Neu versiegeln und die Sicherung nachziehen

kubeseal --re-encrypt schickt ein SealedSecret an den Controller und bekommt es mit dem neuesten Schlüssel versiegelt zurück. Die Werte erfährst du dabei nicht.

# auf argo
cd ~/sops/repo
kubeseal --fetch-cert | openssl x509 -noout -startdate
F=sealed/notes-stage/notes-db.sealed.yaml
yq '.spec.encryptedData.password' $F | cut -c1-30
kubeseal --re-encrypt -o yaml < $F > ~/sops/tag13/re.yaml && mv ~/sops/tag13/re.yaml $F
yq '.spec.encryptedData.password' $F | cut -c1-30
kubectl apply -f $F

Erwartet (gekürzt):

notBefore=Nov 20 18:25:44 2026 GMT
AgBSdZTkmSh+TfAFRXkLhHi2vN2KKa
AgA6ebX9p1fAelGyRW4ukMYBeZaSXu
sealedsecret.bitnami.com/notes-db configured

--re-encrypt ändert nur die Datei; in den Cluster kommt der neue Stand erst mit kubectl apply (oder über GitOps).

Und die Sicherung aus Drill 2?

# auf argo
cd ~/sops/repo
echo "Sicherung: $(sops decrypt backup/sealed-secrets-keys.yaml | yq '.items | length')"
echo "Cluster:   $(kubectl -n kube-system get secret --no-headers \
  -l sealedsecrets.bitnami.com/sealed-secrets-key | wc -l)"

Erwartet:

Sicherung: 1
Cluster:   2

Die Sicherung kennt den neuen Schlüssel nicht – mit ihr ließe sich notes-db nach einem Verlust nicht mehr öffnen. Nach jeder Erneuerung wird neu gesichert:

# auf argo
cd ~/sops/repo
kubectl -n kube-system get secret -l sealedsecrets.bitnami.com/sealed-secrets-key \
  -o yaml | yq 'del(.items[].metadata.uid, .items[].metadata.resourceVersion,
  .items[].metadata.creationTimestamp, .items[].metadata.managedFields,
  .items[].metadata.annotations)' \
  > backup/sealed-secrets-keys.yaml
sops encrypt -i backup/sealed-secrets-keys.yaml
git add backup sealed
git commit -q -m "tag13: neuer Schlüssel, Sicherung erneuert, notes-db neu versiegelt"
git push -q && git log --oneline | head -1

Erwartet:

854c3f1 tag13: neuer Schlüssel, Sicherung erneuert, notes-db neu versiegelt

Fortschritt speichern? Kostenlos registrieren

Drill 5: Der Cluster ist weg

Einbauen: Controller, Schlüssel und Namespace verschwinden. Ein neuer Controller wird installiert, die SealedSecrets kommen aus Git.

Achtung: Das Löschen der Schlüssel-Secrets ist unumkehrbar. Hier nur, weil die Sicherung aus Drill 4 im Repo liegt – prüfe vorher, dass sie zwei Schlüssel enthält.

# auf argo
cd ~/sops/repo
helm uninstall sealed-secrets -n kube-system >/dev/null
kubectl -n kube-system delete secret -l sealedsecrets.bitnami.com/sealed-secrets-key
kubectl delete namespace notes-stage
helm install sealed-secrets sealed-secrets/sealed-secrets --version 2.22.0 \
  -n kube-system --set-string fullnameOverride=sealed-secrets-controller \
  --wait 2>&1 | grep STATUS
kubectl create namespace notes-stage
kubectl apply -f sealed/notes-stage/
sleep 4

Symptom:

# auf argo
kubectl -n notes-stage get sealedsecret notes-db \
  -o jsonpath='{.status.conditions[0].message}'; echo

Erwartet:

no key could decrypt secret (password, user)

Ursache: Der neue Controller hat sich beim Start einen neuen Schlüssel erzeugt. Mit dem lassen sich die alten SealedSecrets nicht öffnen.

Fix: Die gesicherten Schlüssel zurückspielen und den Controller neu starten – er liest beim Start alle Secrets mit dem Label ein.

Achtung: kubectl create, nicht kubectl apply. apply schreibt das ganze Objekt als Annotation kubectl.kubernetes.io/last-applied-configuration dazu – mit dem privaten Schlüssel im Klartext. Die nächste Sicherung verschlüsselt nur data und hätte die Annotation unverschlüsselt ins Git gebracht. Im Labor hat das der gitleaks-Hook verhindert (Regel private-key). Deshalb löscht der yq-Filter beim Sichern zusätzlich alle Annotationen.

# auf argo
cd ~/sops/repo
sops decrypt backup/sealed-secrets-keys.yaml | kubectl create -f -
kubectl -n kube-system delete pod -l app.kubernetes.io/name=sealed-secrets
kubectl -n kube-system rollout status deploy/sealed-secrets-controller --timeout=60s
sleep 5

Nachweis:

# auf argo
kubectl -n kube-system get secret --no-headers \
  -l sealedsecrets.bitnami.com/sealed-secrets-key | wc -l
kubectl -n notes-stage get sealedsecret --no-headers | awk '{print $1, $2}'
kubectl -n notes-stage get secret notes-db -o jsonpath='{.data.password}' \
  | base64 -d; echo

Erwartet:

3
notes-api True
notes-db True
regcred True
lab-db-stage-456

Drei Schlüssel: die zwei gesicherten und der, den der neue Controller beim Start angelegt hat. Er ist jetzt der neueste und versiegelt – also gleich wieder sichern (Kontrollpunkt).

Fortschritt speichern? Kostenlos registrieren

Drill 6: Ohne Cluster entschlüsseln

Der Cluster ist nicht mehr da, aber du brauchst den Wert von notes-db – etwa für die Datenbank im neuen Rechenzentrum. kubeseal --recovery-unseal entschlüsselt mit den privaten Schlüsseln aus der Sicherung, ganz ohne Controller.

Achtung: Die privaten Schlüssel liegen dabei kurz als Datei auf der Platte. umask 077, eigener Ordner, danach shred.

# auf argo
cd ~/sops/tag13
umask 077
sops decrypt ~/sops/repo/backup/sealed-secrets-keys.yaml \
  | yq '.items[] | .data."tls.key"' | while read -r k; do echo "$k" | base64 -d; done \
  > recovery.pem
csplit -s -z -f key- recovery.pem '/-----BEGIN/' '{*}'
ls key-*
kubeseal --recovery-unseal --recovery-private-key key-00,key-01 -o yaml \
  < ~/sops/repo/sealed/notes-stage/notes-db.sealed.yaml \
  | yq '.data.password' | base64 -d; echo
kubeseal --recovery-unseal --recovery-private-key key-00 -o yaml \
  < ~/sops/repo/sealed/notes-stage/notes-db.sealed.yaml 2>&1 | tail -1

Erwartet:

key-00
key-01
lab-db-stage-456
error: no key could decrypt secret (password, user)

Mit beiden Schlüsseln klappt es, mit dem alten allein nicht: notes-db ist seit Drill 4 mit dem neuen versiegelt. Die Sicherung muss also alle Schlüssel enthalten, mit denen noch irgendein SealedSecret versiegelt ist.

# auf argo
cd ~/sops/tag13
shred -u recovery.pem key-*
ls

Erwartet:

cutoff.yaml

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig, wie viele Schlüssel die Sicherung im Repo enthält. Zeitziel: 20 s
  2. Zeig das Ablaufdatum des Zertifikats, mit dem gerade versiegelt wird. Zeitziel: 20 s

Lösung

# auf argo
sops decrypt ~/sops/repo/backup/sealed-secrets-keys.yaml | yq '.items | length'
kubeseal --fetch-cert | openssl x509 -noout -enddate

Erwartet (Datum abweichend):

2
notAfter=Nov 17 18:26:22 2036 GMT

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Nach Drill 5 hat der Cluster einen Schlüssel mehr als die Sicherung. Zieh die Sicherung nach und prüfe:

# auf argo
cd ~/sops/repo
kubectl -n kube-system get secret -l sealedsecrets.bitnami.com/sealed-secrets-key \
  -o yaml | yq 'del(.items[].metadata.uid, .items[].metadata.resourceVersion,
  .items[].metadata.creationTimestamp, .items[].metadata.managedFields,
  .items[].metadata.annotations)' \
  > backup/sealed-secrets-keys.yaml
sops encrypt -i backup/sealed-secrets-keys.yaml
git add backup && git commit -q -m "tag13: Sicherung nach Wiederherstellung"
git push -q
sops decrypt backup/sealed-secrets-keys.yaml | yq '.items | length'
git status -sb | head -1

Erwartet:

3
## main...origin/main

Challenge

Versiegle alle Dateien in sealed/notes-stage/ mit dem aktuellen Schlüssel neu, committe sie und beweise mit --recovery-unseal, dass dafür nur noch dieser eine Schlüssel nötig ist.

Hinweis: Welcher Schlüssel versiegelt, verrät das Zertifikat von kubeseal --fetch-cert – vergleiche Fingerprints. Der creationTimestamp hilft nach einer Wiederherstellung nicht: Zurückgespielte Schlüssel bekommen einen neuen.

Lösung

# auf argo
cd ~/sops/repo
for f in sealed/notes-stage/*.yaml; do
  kubeseal --re-encrypt -o yaml < "$f" > ~/sops/tag13/re.yaml
  mv ~/sops/tag13/re.yaml "$f"
done
git add sealed && git commit -q -m "tag13: alles neu versiegelt" && git push -q
cd ~/sops/tag13 && umask 077
C=$(kubeseal --fetch-cert | openssl x509 -noout -fingerprint -sha256)
for s in $(kubectl -n kube-system get secret -o name \
    -l sealedsecrets.bitnami.com/sealed-secrets-key); do
  F=$(kubectl -n kube-system get "$s" -o jsonpath='{.data.tls\.crt}' | base64 -d \
    | openssl x509 -noout -fingerprint -sha256)
  [ "$F" = "$C" ] && kubectl -n kube-system get "$s" -o jsonpath='{.data.tls\.key}' \
    | base64 -d > neu.pem
done
for f in ~/sops/repo/sealed/notes-stage/*.yaml; do
  kubeseal --recovery-unseal --recovery-private-key neu.pem -o yaml < "$f" \
    | yq '.metadata.name'
done
shred -u neu.pem

Erwartet:

notes-api
notes-db
regcred

Jetzt könnten die älteren Schlüssel aus dem Cluster entfernt werden – aber nur, wenn kein anderes Repo und kein Branch mehr Dateien mit ihnen enthält. In der Praxis lässt man sie liegen.

Fortschritt speichern? Kostenlos registrieren

Aufräumen

Nichts. Controller, drei Schlüssel, notes-stage und die Sicherung bleiben für die Fehlerbilder in Tag 14.

Interview-Notiz

  • Was ist bei Sealed Secrets das Wichtigste im Betrieb? Die Sicherung der Controller-Schlüssel – verschlüsselt, außerhalb des Clusters, nach jeder Erneuerung aktualisiert.
  • Macht die Schlüsselerneuerung alte SealedSecrets im Git sicherer? Nein. Alte Stände bleiben mit alten Schlüsseln lesbar; ein verbrannter Schlüssel heißt: Werte wechseln.
  • Wie kommst du ohne Cluster an einen Wert? kubeseal --recovery-unseal mit den gesicherten privaten Schlüsseln.

Enterprise-Notiz

  • Die Sicherung automatisieren: ein CronJob oder die Backup-Lösung des Clusters (Velero sichert die Secrets in kube-system mit) – aber verschlüsselt und mit getrennten Rechten.
  • Ein eigener, vorher erzeugter Schlüssel (kubectl create secret tls mit dem Label) macht Cluster reproduzierbar: Neue Cluster bekommen denselben Schlüssel aus dem Tresor statt eines zufälligen.
  • Ein Wiederherstellungstest gehört in den Notfallplan – einmal im Quartal auf einem leeren Cluster.
  • Die Metriken des Controllers (Port 8081, u. a. sealed_secrets_controller_condition_info pro SealedSecret) gehören in die Alarmierung – sonst fällt ein Secret, das nicht mehr aufgeht, erst beim nächsten Pod-Neustart auf.