Tag 12: Sealed Secrets – Controller und kubeseal
Ziel: Du versiegelst Secrets mit
kubeseal– online und offline –, wählst den passenden Scope, änderst einzelne Werte, ohne den Rest zu kennen, und legst SealedSecrets ins Repo, ohne dass der Hook Fehlalarm schlägt. · Dauer: ca. 75 min · Voraussetzung: Tag 11
Briefing
- Sealed Secrets dreht das sops-Modell um: Es gibt
einen Schlüssel, und der liegt im Cluster. Der
Controller erzeugt ein Schlüsselpaar,
kubesealverschlüsselt mit dem öffentlichen Zertifikat, nur der Controller kann entschlüsseln. - Im Git liegt ein SealedSecret (eigene Ressource). Der Controller macht daraus ein normales Secret und bleibt dessen Besitzer.
- Der Scope bestimmt, wo das SealedSecret gültig ist:
strict(Name und Namespace fest, Standard),namespace-wide(Name frei) odercluster-wide. - Ohne den Schlüssel des Controllers kann kein Mensch ein SealedSecret
wieder entschlüsseln – auch du nicht. Ändern heißt: neu versiegeln oder
einzelne Werte zusammenführen (
--merge-into). - Schlüssel sichern, rotieren, wiederherstellen: Tag 13.
du: Secret (Klartext, nur lokal) ──kubeseal (Zertifikat)──► SealedSecret ──► Git
│
Cluster: sealed-secrets-controller (privater Schlüssel) ◄────────┘ kubectl apply
└─► Secret notes-stage/notes-db (ownerReferences: SealedSecret)
Drill 1: Controller und kubeseal
Das Helm-Chart liegt unter bitnami.github.io (die alte
Adresse bitnami-labs.github.io liefert 404). Der Name
sealed-secrets-controller ist der, den
kubeseal ohne weitere Angaben sucht.
# auf argo
mkdir -p ~/sops/tag12 && cd ~/sops/tag12
ARCH=$(dpkg --print-architecture)
K=https://github.com/bitnami-labs/sealed-secrets/releases/download/v0.41.2
curl -fsSLO $K/kubeseal-0.41.2-linux-$ARCH.tar.gz
curl -fsSLO $K/sealed-secrets_0.41.2_checksums.txt
grep " kubeseal-0.41.2-linux-$ARCH.tar.gz$" sealed-secrets_0.41.2_checksums.txt \
| sha256sum -c
tar -xzf kubeseal-0.41.2-linux-$ARCH.tar.gz kubeseal
sudo install -m 0755 kubeseal /usr/local/bin/kubeseal
kubeseal --version
helm repo add sealed-secrets https://bitnami.github.io/sealed-secrets >/dev/null
helm repo update sealed-secrets >/dev/null
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 -n kube-system get secret -l sealedsecrets.bitnami.com/sealed-secrets-keyErwartet:
kubeseal-0.41.2-linux-amd64.tar.gz: OK
kubeseal version: 0.41.2
STATUS: deployed
NAME TYPE DATA AGE
sealed-secrets-keyk7bkd kubernetes.io/tls 2 1s
Das Secret sealed-secrets-key… ist das Schlüsselpaar des
Controllers. Es ist das Einzige, was du in Tag 13 sichern musst.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Das erste SealedSecret
# auf argo
cd ~/sops/tag12
kubectl create namespace notes-stage
kubectl create secret generic notes-db -n notes-stage \
--from-literal=password=lab-db-stage-123 --dry-run=client -o yaml > notes-db.yaml
kubeseal -f notes-db.yaml -w notes-db.sealed.yaml
rm notes-db.yaml
grep -A1 encryptedData notes-db.sealed.yaml | cut -c1-60
kubectl apply -f notes-db.sealed.yaml
sleep 3
kubectl -n notes-stage get sealedsecret notes-db
kubectl -n notes-stage get secret notes-db -o jsonpath='{.data.password}' \
| base64 -d; echoErwartet (gekürzt):
namespace/notes-stage created
encryptedData:
password: AgBlOj+CXpOSMSq+gc+5Ze2g8U121pv2wNBkSy5q9HC…
sealedsecret.bitnami.com/notes-db created
NAME STATUS SYNCED AGE
notes-db True 3s
lab-db-stage-123
kubeseal holt sich das Zertifikat vom Controller (über
die Kubernetes-API) und verschlüsselt jeden Wert einzeln. Die
Klartextdatei notes-db.yaml löschst du sofort – sie war nur
das Formular.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Offline versiegeln
Wer versiegelt, braucht keinen Zugriff auf den Cluster – nur das öffentliche Zertifikat. Das ist der Weg für Entwickler ohne Cluster-Rechte und für CI.
# auf argo
cd ~/sops/tag12
kubeseal --fetch-cert > cert.pem
openssl x509 -in cert.pem -noout -enddate
kubectl create secret generic notes-api -n notes-stage \
--from-literal=api_key=lab-key-stage-123 --dry-run=client -o yaml \
| kubeseal --cert cert.pem -o yaml > notes-api.sealed.yaml
kubectl apply -f notes-api.sealed.yaml >/dev/null
sleep 2
kubectl -n notes-stage get secret notes-api -o jsonpath='{.data.api_key}' \
| base64 -d; echoErwartet:
notAfter=Nov 17 18:23:56 2036 GMT
lab-key-stage-123
Das Zertifikat darf öffentlich sein (üblich ist es, es ins Repo zu
legen). Es gilt zehn Jahre, aber der Controller erneuert seinen
Schlüssel regelmäßig – ein altes cert.pem versiegelt weiter
gültig, nur nicht mit dem neuesten Schlüssel (Tag 13).
Fortschritt speichern? Kostenlos registrieren
Drill 4: Scopes
Einbauen: Dasselbe SealedSecret soll in einem zweiten Namespace laufen. Du änderst nur den Namespace.
# auf argo
cd ~/sops/tag12
kubectl create namespace notes-test
sed 's/namespace: notes-stage/namespace: notes-test/' notes-db.sealed.yaml \
> moved.yaml
kubectl apply -f moved.yaml
sleep 3Symptom und Untersuchen:
# auf argo
kubectl -n notes-test get sealedsecret notes-db
kubectl -n kube-system logs deploy/sealed-secrets-controller --tail=5 \
| grep -o 'error=.*' | head -1Erwartet:
NAME STATUS SYNCED AGE
notes-db no key could decrypt secret (password) False 4s
error="no key could decrypt secret (password)"
Ursache: Im Scope strict fließen
Namespace und Name in die Verschlüsselung ein. Ein umgezogenes
SealedSecret lässt sich nicht entschlüsseln – Absicht: Wer im Namespace
notes-test arbeiten darf, soll die Secrets aus
notes-stage nicht einfach kopieren können.
Fix: Bewusst einen weiteren Scope wählen.
# auf argo
cd ~/sops/tag12
kubectl delete -f moved.yaml >/dev/null && rm moved.yaml
kubectl create secret generic notes-db -n notes-stage \
--from-literal=password=lab-db-stage-123 --dry-run=client -o yaml \
| kubeseal --scope namespace-wide -o yaml > nswide.sealed.yaml
grep -m1 namespace-wide nswide.sealed.yaml
sed 's/name: notes-db/name: notes-db-kopie/' nswide.sealed.yaml | kubectl apply -f -
kubectl create secret generic shared -n notes-stage \
--from-literal=token=lab-shared-123 --dry-run=client -o yaml \
| kubeseal --scope cluster-wide -o yaml > shared.sealed.yaml
sed 's/namespace: notes-stage/namespace: notes-test/' shared.sealed.yaml \
| kubectl apply -f -
sleep 3
kubectl -n notes-stage get sealedsecret notes-db-kopie
kubectl -n notes-test get secret shared -o jsonpath='{.data.token}' | base64 -d; echoErwartet:
sealedsecrets.bitnami.com/namespace-wide: "true"
sealedsecret.bitnami.com/notes-db-kopie created
sealedsecret.bitnami.com/shared created
NAME STATUS SYNCED AGE
notes-db-kopie True 3s
lab-shared-123
| Scope | Name frei | Namespace frei | Annotation |
|---|---|---|---|
strict |
nein | nein | – |
namespace-wide |
ja | nein | …/namespace-wide: "true" |
cluster-wide |
ja | ja | …/cluster-wide: "true" |
cluster-wide heißt: Jeder, der irgendwo SealedSecrets
anlegen darf, kann den Wert in seinen Namespace holen. Nur für Werte,
die ohnehin überall gelten.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Einzelne Werte ändern
Ein SealedSecret kann niemand entschlüsseln – wie änderst du dann ein
Passwort, ohne die anderen Werte zu kennen? --raw
versiegelt einen einzelnen Wert, --merge-into setzt Werte
in eine bestehende Datei ein.
# auf argo
cd ~/sops/tag12
printf lab-db-stage-456 | kubeseal --raw --namespace notes-stage --name notes-db \
--from-file=/dev/stdin | cut -c1-40
kubectl create secret generic notes-db -n notes-stage \
--from-literal=password=lab-db-stage-456 --from-literal=user=notes \
--dry-run=client -o yaml | kubeseal --merge-into notes-db.sealed.yaml
head -3 notes-db.sealed.yamlErwartet (gekürzt):
AgAh4aVmw98ciz6NUoiDcuz+PN0lxvcGu4ok0ONe
{
"kind": "SealedSecret",
"apiVersion": "bitnami.com/v1alpha1",
Die Datei ist jetzt JSON. --merge-into schreibt im
Ausgabeformat von kubeseal, und das ist ohne
-o JSON – im Git-Diff sieht das wie eine komplett neue
Datei aus. yq -P macht wieder YAML daraus:
# auf argo
cd ~/sops/tag12
yq -P -i notes-db.sealed.yaml
head -3 notes-db.sealed.yaml
yq '.spec.encryptedData | keys' notes-db.sealed.yaml
kubectl apply -f notes-db.sealed.yaml >/dev/null
sleep 3
kubectl -n notes-stage get secret notes-db -o jsonpath='{.data.password}' \
| base64 -d; echoErwartet:
kind: SealedSecret
apiVersion: bitnami.com/v1alpha1
metadata:
- password
- user
lab-db-stage-456
Merke: beim nächsten Mal gleich
kubeseal --merge-into datei.yaml -o yaml.
--raw brauchst du, wenn du den Wert selbst in eine Datei
einsetzt – etwa in einem Helm-Template; Name und Namespace müssen dabei
zum Scope passen.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Besitz und fremde Secrets
Der Controller ist Besitzer des Secrets – mit allen Folgen.
# auf argo
kubectl -n notes-stage get secret notes-db \
-o jsonpath='{.metadata.ownerReferences[0].kind}'; echo
kubectl -n notes-stage delete sealedsecret notes-db-kopie
sleep 2
kubectl -n notes-stage get secret notes-db-kopie 2>&1Erwartet:
SealedSecret
sealedsecret.bitnami.com "notes-db-kopie" deleted from notes-stage namespace
Error from server (NotFound): secrets "notes-db-kopie" not found
Einbauen: Ein Secret, das jemand von Hand angelegt hat, soll künftig aus Git kommen.
# auf argo
cd ~/sops/tag12
kubectl -n notes-stage create secret generic handmade --from-literal=x=lab-x-123
kubectl create secret generic handmade -n notes-stage --from-literal=x=lab-x-456 \
--dry-run=client -o yaml | kubeseal -o yaml > handmade.sealed.yaml
kubectl apply -f handmade.sealed.yaml
sleep 3
kubectl -n notes-stage get sealedsecret handmade \
-o jsonpath='{.status.conditions[0].message}'; echoErwartet:
secret/handmade created
sealedsecret.bitnami.com/handmade created
failed update: Resource "handmade" already exists and is not managed by SealedSecret
Ursache: Der Controller überschreibt kein Secret, das ihm nicht gehört.
Fix und Nachweis: Das vorhandene Secret zur Übernahme freigeben und das SealedSecret neu anlegen (der Controller versucht es sonst erst nach einer Pause wieder).
# auf argo
cd ~/sops/tag12
kubectl -n notes-stage annotate secret handmade sealedsecrets.bitnami.com/managed=true
kubectl delete -f handmade.sealed.yaml >/dev/null
kubectl apply -f handmade.sealed.yaml >/dev/null
sleep 4
kubectl -n notes-stage get sealedsecret handmade
kubectl -n notes-stage get secret handmade -o jsonpath='{.data.x}' | base64 -d; echoErwartet:
secret/handmade annotated
NAME STATUS SYNCED AGE
handmade True 4s
lab-x-456
Fortschritt speichern? Kostenlos registrieren
Drill 7: Die Vorlage
Unter spec.template steht, wie das erzeugte Secret
aussehen soll: Typ, Labels, Annotationen. Das ist der Ort für alles, was
nicht geheim ist.
# auf argo
cd ~/sops/tag12
kubectl create secret docker-registry regcred -n notes-stage \
--docker-server=registry.lab.test --docker-username=lab \
--docker-password=lab-reg-123 --dry-run=client -o yaml \
| kubeseal -o yaml > regcred.sealed.yaml
yq -i '.spec.template.metadata.labels.team = "notes"' regcred.sealed.yaml
yq '.spec.template' regcred.sealed.yaml
kubectl apply -f regcred.sealed.yaml >/dev/null
sleep 3
kubectl -n notes-stage get secret regcred --show-labelsErwartet:
metadata:
name: regcred
namespace: notes-stage
labels:
team: notes
type: kubernetes.io/dockerconfigjson
NAME TYPE DATA AGE LABELS
regcred kubernetes.io/dockerconfigjson 1 3s team=notes
Labels in der Vorlage darfst du nachträglich ändern – sie sind nicht
versiegelt. Name und Namespace dagegen gehören im Scope
strict zur Verschlüsselung.
Fortschritt speichern? Kostenlos registrieren
Drill 8: Ins Repo – und der Hook
SealedSecrets dürfen ins Git. Sie bekommen einen eigenen Ordner
sealed/, weil der Hook aus Tag 9 in den sops-Ordnern
sops-Metadaten verlangt.
Einbauen:
# auf argo
cd ~/sops/repo
mkdir -p sealed/notes-stage
cp ~/sops/tag12/notes-db.sealed.yaml ~/sops/tag12/notes-api.sealed.yaml \
~/sops/tag12/regcred.sealed.yaml sealed/notes-stage/
git add sealed
git commit -q -m "tag12: SealedSecrets für notes-stage"; echo "rc=$?"Symptom:
6:24PM WRN leaks found: 2
rc=1
Zahl und Dateien schwanken: Ob gitleaks einen versiegelten Wert meldet, hängt von seiner Entropie ab – und die ist bei jedem Versiegeln anders.
Untersuchen:
# auf argo
cd ~/sops/repo
GIT_CONFIG_COUNT=1 GIT_CONFIG_KEY_0=diff.sopsdiffer.textconv GIT_CONFIG_VALUE_0=cat \
gitleaks git --pre-commit --staged --redact --no-banner --no-color -v . 2>&1 \
| grep -E 'RuleID|File'Erwartet:
RuleID: generic-api-key
File: sealed/notes-stage/notes-db.sealed.yaml
RuleID: generic-api-key
File: sealed/notes-stage/notes-api.sealed.yaml
Ursache: Die Regel generic-api-key
sucht Schlüsselwörter wie password oder
api_key mit einem Wert hoher Entropie. Ein versiegelter
Wert ist genau das – nur eben verschlüsselt. Ein Fehlalarm.
Fix: Eine gitleaks-Konfiguration im Repo, die die
Standardregeln behält und nur Werte erlaubt, die wie versiegelte
aussehen (beginnen mit Ag, sehr lang).
# auf argo
cd ~/sops/repo
cat > .gitleaks.toml <<'EOF'
[extend]
useDefault = true
[[allowlists]]
description = "SealedSecret-Werte: RSA-verschlüsselt, base64, beginnen mit Ag"
regexTarget = "secret"
regexes = ['''^Ag[A-Za-z0-9+/]{300,}={0,2}$''']
EOF
git add .gitleaks.toml sealed
git commit -q -m "tag12: SealedSecrets für notes-stage"; echo "rc=$?"
git push -qErwartet:
rc=0
Nachweis: Die Ausnahme darf echte Lecks nicht durchlassen. Ein GitHub-Token im selben Ordner:
# auf argo
cd ~/sops/repo
printf 'token: ghp_%s\n' "$(head -c 200 /dev/urandom | base64 | tr -dc 'A-Za-z0-9' \
| head -c 36)" > sealed/notes-stage/falsch.yaml
git add sealed/notes-stage/falsch.yaml
git commit -q -m test; echo "rc=$?"
git restore --staged sealed/notes-stage/falsch.yaml && rm sealed/notes-stage/falsch.yaml
git status -sb | head -1Erwartet:
6:25PM WRN leaks found: 1
rc=1
## main...origin/main
Tipp: Teste eine Ausnahme immer mit einem Gegenbeispiel, das sicher erkannt wird. Ein selbst ausgedachtes „Passwort“ erkennt gitleaks oft gar nicht (Tag 9) – dann beweist ein
rc=0nichts.
Fortschritt speichern? Kostenlos registrieren
Übung: Speed-Drills
- Prüfe, ob
sealed/notes-stage/notes-db.sealed.yamlzum Controller passt (--validate). Zeitziel: 20 s - Zeig, welchen Scope
nswide.sealed.yamlhat. Zeitziel: 15 s - Zeig die Namen der Werte in
regcred.sealed.yaml. Zeitziel: 15 s
Lösung
# auf argo
cd ~/sops/tag12
kubeseal --validate < ~/sops/repo/sealed/notes-stage/notes-db.sealed.yaml \
&& echo gültig
yq '.metadata.annotations' nswide.sealed.yaml
yq '.spec.encryptedData | keys' regcred.sealed.yamlErwartet:
gültig
sealedsecrets.bitnami.com/namespace-wide: "true"
- .dockerconfigjson
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
# auf argo
kubectl get sealedsecrets -A --no-headers | awk '{print $1, $2, $3}'
ls ~/sops/repo/sealed/notes-stage
grep -c useDefault ~/sops/repo/.gitleaks.tomlErwartet:
notes-stage handmade True
notes-stage notes-api True
notes-stage notes-db True
notes-stage regcred True
notes-test shared True
notes-api.sealed.yaml
notes-db.sealed.yaml
regcred.sealed.yaml
1
Challenge
Ein Kollege hat nur das Zertifikat cert.pem, keinen
Cluster-Zugang. Er soll im SealedSecret notes-api einen
zweiten Wert webhook_token ergänzen, ohne
lab-key-stage-123 zu kennen. Spiel es mit
--cert durch und prüfe im Cluster, dass beide Werte da
sind.
Hinweis: --merge-into funktioniert auch
offline.
Lösung
# auf argo
cd ~/sops/tag12
kubectl create secret generic notes-api -n notes-stage \
--from-literal=webhook_token=lab-hook-123 --dry-run=client -o yaml \
| kubeseal --cert cert.pem --merge-into notes-api.sealed.yaml -o yaml
yq '.spec.encryptedData | keys' notes-api.sealed.yaml
kubectl apply -f notes-api.sealed.yaml >/dev/null
sleep 3
kubectl -n notes-stage get secret notes-api -o jsonpath='{.data}' | jq -r 'keys[]'Erwartet:
- api_key
- webhook_token
api_key
webhook_token
Fortschritt speichern? Kostenlos registrieren
Aufräumen
Der Controller, sein Schlüssel und notes-stage bleiben
für Tag 13. Weg kommen nur der Test-Namespace und die Downloads.
# auf argo
kubectl delete namespace notes-test
rm ~/sops/tag12/kubeseal-0.41.2-linux-*.tar.gz ~/sops/tag12/kubeseal
kubectl get sealedsecrets -A --no-headers | wc -lErwartet:
namespace "notes-test" deleted
4
Interview-Notiz
- SOPS oder Sealed Secrets? SOPS: Menschen und Werkzeuge entschlüsseln, mehrere Schlüssel, auch außerhalb von Kubernetes. Sealed Secrets: nur der Cluster entschlüsselt, ein Schlüssel, nur Kubernetes-Secrets (Tag 15).
- Was bedeutet Scope
strict? Name und Namespace sind Teil der Verschlüsselung; ein kopiertes SealedSecret lässt sich anderswo nicht entschlüsseln. - Wie änderst du einen Wert? Neu versiegeln und mit
--merge-intoeinsetzen – lesen kann ihn niemand.
Enterprise-Notiz
cert.pemins Repo oder auf eine interne URL (kubeseal --cert https://…), damit niemand Cluster-Zugriff zum Versiegeln braucht.- RBAC: Wer SealedSecrets im Namespace anlegen darf, bekommt das
Secret – also so eng vergeben wie Secrets selbst.
cluster-widenur nach Freigabe. - Ein Cluster = ein Schlüsselpaar. Mehrere Cluster brauchen pro Cluster versiegelte Dateien (oder denselben Schlüssel, was die Trennung aufhebt).
- In CI:
kubeseal --validategegen das Zertifikat bzw. den Controller vor dem Merge. - Secret-Scanner brauchen eine Ausnahme für versiegelte Werte – eng formuliert und mit Gegenbeispiel getestet.