Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 15: Entscheiden und migrieren

Ziel: Du entscheidest begründet zwischen sops, Sealed Secrets und einem externen Speicher, ziehst einen Namespace ohne Ausfall von Sealed Secrets nach sops um und legst ein neues Repo mit allen Schutzmaßnahmen dieses Buchs an. · Dauer: ca. 60 min · Voraussetzung: Tag 14

Briefing

  • Alle drei Wege lösen dasselbe Problem – Secrets gehören nicht im Klartext nach Git –, aber an verschiedenen Stellen.
  • Migrieren heißt hier: Das Secret im Cluster bleibt stehen, nur sein Besitzer wechselt. Kein Pod merkt etwas.
  • Ein neues Repo bekommt alles auf einmal: .sops.yaml, .gitignore, .gitattributes, .gitleaks.toml und den versionierten Hook.
Frage sops Sealed Secrets Externer Speicher (ESO + OpenBao)
Wer entschlüsselt? Menschen, CI, Flux, Argo CD nur der Controller niemand, Werte liegen nicht in Git
Was liegt in Git? verschlüsselte Werte versiegelte Werte nur Verweise
Mehrere Cluster ein Recipient je Cluster je Cluster neu versiegeln ein Speicher für alle
Nicht-Kubernetes-Dateien ja (YAML, JSON, dotenv, INI, binär) nein über eigene Clients
Wert lesen ohne Cluster ja, mit Schlüssel nur mit der Schlüsselsicherung (Tag 13) über die API des Speichers
Betriebsaufwand Schlüsselverwaltung Controller + Sicherung hochverfügbarer Speicher

Faustregel: Sealed Secrets für kleine Teams, die nur Kubernetes ausrollen und niemandem Schlüssel geben wollen. sops, sobald Menschen, CI oder Nicht-Kubernetes- Dateien die Werte brauchen. Externer Speicher, wenn Secrets rotieren, ablaufen oder dynamisch entstehen – das zeigen die OpenBao-Bücher der Reihe.

Drill 1: Inventur

Vor jeder Migration: Was liegt wo?

# auf argo
mkdir -p ~/sops/tag15 && cd ~/sops/repo
echo "sops-Dateien: $(for f in $(git ls-files '*.yaml' '*.env' '*.json'); do
  sops filestatus "$f" 2>/dev/null; done | grep -c '"encrypted":true')"
echo "SealedSecrets in Git: $(git ls-files 'sealed/*' | wc -l)"
kubectl -n notes-stage get sealedsecret --no-headers | awk '{print $1}'

Erwartet:

sops-Dateien: 8
SealedSecrets in Git: 3
notes-api
notes-db
regcred

Ziel dieses Tages: notes-stage wird ein sops-Ordner stage/ mit dem prod-Schlüssel, und sealed/ verschwindet.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Eine Regel für stage

# auf argo
cd ~/sops/repo
P=$(age-keygen -y ~/sops/tag04/prod.key)
yq -i '.creation_rules += [{"path_regex": "^stage/.*\\.yaml$",
  "encrypted_regex": "^(data|stringData)$", "age": "'"$P"'"}]' .sops.yaml
sed -i 's#backup/\*)#backup/*|stage/*)#' hooks/pre-commit
grep -c 'stage/\*' hooks/pre-commit
mkdir -p stage

Erwartet:

1

Fortschritt speichern? Kostenlos registrieren

Drill 3: Ein SealedSecret wird eine sops-Datei

Der Klartext steht im Cluster. Von dort holst du ihn – ohne status, uid, ownerReferences und Annotationen – direkt in die Datei, die gleich verschlüsselt wird.

# auf argo
cd ~/sops/repo
kubectl -n notes-stage get secret notes-db -o yaml | yq '{"apiVersion": .apiVersion,
  "kind": .kind, "metadata": {"name": .metadata.name,
  "namespace": .metadata.namespace}, "type": .type, "data": .data}' \
  > stage/notes-db.yaml
sops encrypt -i stage/notes-db.yaml
sops filestatus stage/notes-db.yaml
SOPS_AGE_KEY_FILE=~/sops/tag04/prod.key \
  sops decrypt --extract '["data"]["password"]' stage/notes-db.yaml | base64 -d; echo

Erwartet:

{"encrypted":true}
lab-db-stage-456

sops encrypt braucht nur den öffentlichen Schlüssel aus .sops.yaml; zum Prüfen nimmst du den privaten prod-Schlüssel.

Jetzt die Übergabe. Das SealedSecret wird gelöscht, ohne das Secret mitzunehmen, dann übernimmt der sops-Stand.

Achtung: kubectl delete sealedsecret ohne --cascade=orphan löscht über die ownerReferences auch das Secret – die Anwendung verliert ihr Passwort.

# auf argo
cd ~/sops/repo
kubectl -n notes-stage delete sealedsecret notes-db --cascade=orphan
kubectl -n notes-stage get secret notes-db -o jsonpath='{.metadata.ownerReferences}'
echo "|"
SOPS_AGE_KEY_FILE=~/sops/tag04/prod.key sops decrypt stage/notes-db.yaml \
  | kubectl apply --server-side --force-conflicts -f -
kubectl -n notes-stage get secret notes-db -o jsonpath='{.metadata.annotations}'
echo "|"
git rm -q sealed/notes-stage/notes-db.sealed.yaml
git add .sops.yaml hooks stage
git commit -q -m "tag15: notes-db von Sealed Secrets nach sops" && git push -q

Erwartet:

sealedsecret.bitnami.com "notes-db" deleted from notes-stage namespace
|
secret/notes-db serverside-applied
|

Keine ownerReferences mehr, und – dank --server-side – keine last-applied-configuration mit Klartext (Tag 11, Tag 13). Im Betrieb übernimmt diesen Schritt Flux oder Argo CD.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Der Rest in einer Schleife

# auf argo
cd ~/sops/repo
for s in $(kubectl -n notes-stage get secret -o name); do
  n=${s#secret/}
  [ -f "stage/$n.yaml" ] && continue
  kubectl -n notes-stage get "$s" -o yaml | yq '{"apiVersion": .apiVersion,
    "kind": .kind, "metadata": {"name": .metadata.name,
    "namespace": .metadata.namespace}, "type": .type, "data": .data}' \
    > "stage/$n.yaml"
  sops encrypt -i "stage/$n.yaml"
  kubectl -n notes-stage delete sealedsecret "$n" --cascade=orphan
  SOPS_AGE_KEY_FILE=~/sops/tag04/prod.key sops decrypt "stage/$n.yaml" \
    | kubectl apply --server-side --force-conflicts -f -
  git rm -q "sealed/notes-stage/$n.sealed.yaml"
done
git add stage && git commit -q -m "tag15: notes-stage komplett mit sops" && git push -q
for f in stage/*.yaml; do echo "$f $(sops filestatus "$f")"; done
kubectl -n notes-stage get sealedsecret 2>&1
ls sealed 2>&1 | cut -c1-40

Erwartet:

sealedsecret.bitnami.com "notes-api" deleted from notes-stage namespace
secret/notes-api serverside-applied
sealedsecret.bitnami.com "regcred" deleted from notes-stage namespace
secret/regcred serverside-applied
stage/notes-api.yaml {"encrypted":true}
stage/notes-db.yaml {"encrypted":true}
stage/regcred.yaml {"encrypted":true}
No resources found in notes-stage namespace.
ls: cannot access 'sealed': No such file

Die Schleife holt alle Secrets eines Namespaces. In echten Clustern sind darunter auch fremde (Helm-Releases sh.helm.release.v1.*, Tokens) – filtere vorher, was wirklich dir gehört.

Tipp: Die Schleife läuft im Repo, nicht in einem Hilfsordner. sops sucht .sops.yaml ab dem aktuellen Verzeichnis aufwärts und vergleicht path_regex mit dem Pfad relativ dazu – aus einem anderen Ordner heraus greift keine Regel („config file not found …“, mit --config „no matching creation rules found“).

Fortschritt speichern? Kostenlos registrieren

Drill 5: Die Gegenrichtung

Manchmal soll ein Wert aus einem sops-Repo in einen Cluster, für den es nur Sealed Secrets gibt (fremdes Team, Kunde). Eine Zeile:

# auf argo
cd ~/sops/repo
SOPS_AGE_KEY_FILE=~/sops/tag04/prod.key sops decrypt stage/notes-api.yaml \
  | kubeseal -o yaml | yq '.kind, (.spec.encryptedData | keys)'

Erwartet:

SealedSecret
- api_key

Der Klartext existiert nur in der Pipe, nie auf der Platte.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Ein neues Repo – richtig von Anfang an

Alles aus diesem Buch in einem frischen Repo: eigener Schlüssel für CI, Regel, Ignore, Diff-Treiber, gitleaks-Konfiguration, versionierter Hook.

# auf argo
cd ~/sops/tag15 && mkdir neu && cd neu && git init -q -b main
age-keygen -o ~/sops/tag15/neu-ci.key 2>/dev/null
C=$(age-keygen -y ~/sops/tag15/neu-ci.key)
I=$(age-keygen -y ~/.config/sops/age/keys.txt)
cat > .sops.yaml <<EOF
creation_rules:
  - path_regex: ^secrets/.*\.yaml\$
    encrypted_regex: ^(data|stringData)\$
    age: $I,$C
stores:
  yaml:
    indent: 2
EOF
printf '*.key\n*.token\nkeys.txt\n*.dec.*\n' > .gitignore
printf '*.yaml diff=sopsdiffer\n' > .gitattributes
cp ~/sops/repo/.gitleaks.toml .
mkdir -p hooks secrets && cp ~/sops/repo/hooks/pre-commit hooks/
sed -i 's#^    dev/\*.*)$#    secrets/*)#' hooks/pre-commit
git config core.hooksPath hooks
git config diff.sopsdiffer.textconv "sops decrypt"
ls -A

Erwartet:

.git
.gitattributes
.gitignore
.gitleaks.toml
.sops.yaml
hooks
secrets

Der Nachweis ist ein erster Commit – einmal falsch, einmal richtig:

# auf argo
cd ~/sops/tag15/neu
kubectl create secret generic app -n app --from-literal=token=lab-app-123 \
  --dry-run=client -o yaml > secrets/app.yaml
git add -A && git commit -q -m klartext; echo "rc=$?"
sops encrypt -i secrets/app.yaml
git add -A && git commit -q -m "Gerüst"; echo "rc=$?"
git log --oneline | wc -l

Erwartet:

6:31PM WRN leaks found: 2
rc=1
rc=0
1
Datei Zweck Tag
.sops.yaml Regeln, Recipients, Einrückung 4, 8
.gitignore Schlüssel und entschlüsselte Kopien fernhalten 9
.gitattributes + diff.sopsdiffer lesbare Diffs 8
.gitleaks.toml Standardregeln + Ausnahme für versiegelte Werte 9, 12
hooks/pre-commit + core.hooksPath Muster- und Strukturprüfung 9

Fortschritt speichern? Kostenlos registrieren

Übung: Speed-Drills

  1. Zeig, welche Regel aus .sops.yaml für stage/notes-db.yaml gilt (Recipients). Zeitziel: 30 s
  2. Zeig, dass im Namespace notes-stage kein Secret mehr einem SealedSecret gehört. Zeitziel: 30 s

Lösung

# auf argo
cd ~/sops/repo
yq '.sops.age[].recipient' stage/notes-db.yaml
kubectl -n notes-stage get secret -o json \
  | jq '[.items[] | select(.metadata.ownerReferences)] | length'

Erwartet:

age1r025nv6kv083tjhqa7xpslvkc0m8qm2jljd0aqn55nzr859xqe7q4798ks
0

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

# auf argo
cd ~/sops/repo && git status -sb | head -1
git ls-files stage | wc -l
kubectl -n notes-stage get secret notes-db -o jsonpath='{.data.password}' \
  | base64 -d; echo

Erwartet:

## main...origin/main
3
lab-db-stage-456

Challenge

Ein Kollege will für stage/ nicht den prod-Schlüssel benutzen, sondern einen eigenen Stage-Schlüssel. Leg ihn an, stell die Regel um und schlüssle die drei Dateien so um, dass der prod-Schlüssel sie nicht mehr öffnen kann.

Hinweis: updatekeys tauscht die Recipients, rotate zusätzlich den Datenschlüssel (Tag 5). Zum Umschlüsseln brauchst du noch einmal den alten Schlüssel.

Lösung

# auf argo
cd ~/sops/repo
age-keygen -o ~/sops/tag15/stage.key 2>/dev/null
S=$(age-keygen -y ~/sops/tag15/stage.key)
yq -i '(.creation_rules[] | select(.path_regex == "^stage/.*\\.yaml$")).age
  = "'"$S"'"' .sops.yaml
for f in stage/*.yaml; do
  SOPS_AGE_KEY_FILE=~/sops/tag04/prod.key sops updatekeys -y "$f" >/dev/null 2>&1
  SOPS_AGE_KEY_FILE=~/sops/tag15/stage.key sops rotate -i "$f"
done
SOPS_AGE_KEY_FILE=~/sops/tag04/prod.key XDG_CONFIG_HOME=/nirgends \
  sops decrypt stage/notes-db.yaml 2>&1 | grep -c FAILED
SOPS_AGE_KEY_FILE=~/sops/tag15/stage.key XDG_CONFIG_HOME=/nirgends \
  sops decrypt --extract '["metadata"]["name"]' stage/notes-db.yaml
git add .sops.yaml stage && git commit -q -m "tag15: eigener Stage-Schlüssel" \
  && git push -q

Erwartet:

2
notes-db

Fortschritt speichern? Kostenlos registrieren

Aufräumen

Der Sealed-Secrets-Controller bleibt für den Wettkampf (Tag 16), ebenso notes-stage. Das Übungsrepo neu darf weg.

# auf argo
rm -rf ~/sops/tag15/neu ~/sops/tag15/neu-ci.key
cd ~/sops/repo && git status -sb | head -1

Erwartet:

## main...origin/main

Interview-Notiz

  • Wann Sealed Secrets, wann sops? Sealed Secrets, wenn nur der Cluster die Werte sehen soll; sops, wenn Menschen, CI oder andere Dateiformate sie brauchen.
  • Wie migrierst du ohne Ausfall? Klartext aus dem Cluster holen, verschlüsseln, SealedSecret mit --cascade=orphan löschen, neuen Stand server-seitig anwenden.
  • Was gehört in ein neues Secrets-Repo? Regeln, Ignore-Liste, Diff-Treiber, Scanner-Konfiguration und ein versionierter Hook – plus dieselben Prüfungen in CI.

Enterprise-Notiz

  • External Secrets Operator mit OpenBao ist der Standard, wenn Secrets rotieren oder ablaufen sollen. sops bleibt dann oft für Bootstrap-Secrets (das Token für ESO selbst) und Nicht-Kubernetes-Konfiguration.
  • Migrationen pro Namespace planen und in Git sichtbar machen (ein Commit pro Namespace), damit ein Zurück einfach ist.
  • Eine Vorlage für neue Repos (Template-Repository in Forgejo, GitLab, GitHub) mit den fünf Dateien aus Drill 6 spart jede Diskussion.
  • Nach einer Migration die alten SealedSecrets nicht vergessen: Branches, Forks und Backups enthalten sie weiter – der Controller-Schlüssel bleibt damit ein Geheimnis.