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.yamlErwartet:
^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 backupErwartet:
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 -1Erwartet:
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 -1Erwartet:
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 $FErwartet (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 -1Erwartet:
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 4Symptom:
# auf argo
kubectl -n notes-stage get sealedsecret notes-db \
-o jsonpath='{.status.conditions[0].message}'; echoErwartet:
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, nichtkubectl apply.applyschreibt das ganze Objekt als Annotationkubectl.kubernetes.io/last-applied-configurationdazu – mit dem privaten Schlüssel im Klartext. Die nächste Sicherung verschlüsselt nurdataund hätte die Annotation unverschlüsselt ins Git gebracht. Im Labor hat das der gitleaks-Hook verhindert (Regelprivate-key). Deshalb löscht deryq-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 5Nachweis:
# 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; echoErwartet:
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, danachshred.
# 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 -1Erwartet:
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-*
lsErwartet:
cutoff.yaml
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Zeig, wie viele Schlüssel die Sicherung im Repo enthält. Zeitziel: 20 s
- 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 -enddateErwartet (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 -1Erwartet:
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.pemErwartet:
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-unsealmit 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-systemmit) – aber verschlüsselt und mit getrennten Rechten. - Ein eigener, vorher erzeugter Schlüssel
(
kubectl create secret tlsmit 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_infopro SealedSecret) gehören in die Alarmierung – sonst fällt ein Secret, das nicht mehr aufgeht, erst beim nächsten Pod-Neustart auf.