Zum Inhalt springen
Trainingslager IT-Trainingslager

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, kubeseal verschlü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) oder cluster-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-key

Erwartet:

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; echo

Erwartet (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; echo

Erwartet:

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 3

Symptom 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 -1

Erwartet:

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; echo

Erwartet:

    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.yaml

Erwartet (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; echo

Erwartet:

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>&1

Erwartet:

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}'; echo

Erwartet:

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; echo

Erwartet:

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

Erwartet:

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

Erwartet:

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

Erwartet:

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=0 nichts.

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Prüfe, ob sealed/notes-stage/notes-db.sealed.yaml zum Controller passt (--validate). Zeitziel: 20 s
  2. Zeig, welchen Scope nswide.sealed.yaml hat. Zeitziel: 15 s
  3. 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.yaml

Erwartet:

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.toml

Erwartet:

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

Erwartet:

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-into einsetzen – lesen kann ihn niemand.

Enterprise-Notiz

  • cert.pem ins 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-wide nur 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 --validate gegen das Zertifikat bzw. den Controller vor dem Merge.
  • Secret-Scanner brauchen eine Ausnahme für versiegelte Werte – eng formuliert und mit Gegenbeispiel getestet.