Kapitel 6: Secrets-Management, Rotation und Ablösung von Zugangsdaten im Repository (Vault/OpenBao, External Secrets Operator)
In diesem Kapitel lernst du:
- wie du eingecheckte Zugangsdaten in einem Repository samt Historie findest
- wie Vault (bzw. OpenBao) Secrets speichert, verteilt, protokolliert und wieder einzieht
- den Unterschied zwischen statischen und dynamischen Secrets mit Lease und TTL
- wie der External Secrets Operator Secrets aus Vault in Kubernetes synchronisiert und Rotationen nachzieht
- einen belastbaren Ablösungsplan für ein geleaktes Credential: erst rotieren, dann aufräumen
Worum geht es?
Stell dir ein Bürogebäude vor. In vielen Firmen hängt der Generalschlüssel an einem Haken neben der Tür, für alle sichtbar, seit Jahren derselbe. Wer einmal da war, kann ihn nachmachen lassen. Niemand weiß, wie viele Kopien es gibt.
Ein besseres Gebäude hat einen Pförtner mit Schlüsselschrank. Du zeigst deinen Ausweis, bekommst einen Schlüssel für genau die Räume, die du brauchst, und musst ihn nach einer festen Zeit zurückgeben. Der Pförtner schreibt jede Ausgabe in ein Buch. Verliert jemand einen Schlüssel, tauscht der Pförtner das Schloss aus.
Ein Passwort im Git-Repository ist der Schlüssel am Haken. Vault oder OpenBao ist der Pförtner mit Schlüsselschrank und Ausgabebuch. Der External Secrets Operator (ESO) ist der Bote, der Schlüssel aus dem Schrank holt und in Kubernetes dort ablegt, wo die Anwendung sie erwartet.
Entwickler/CI Vault / OpenBao Kubernetes (kind)
+-------------+ Login +-------------------+ Login +--------------------+
| GitLab-Job |-- JWT ----->| Auth-Methoden |<-- SA-JWT--| External Secrets |
| (id_tokens) | | jwt, kubernetes, | | Operator (ESO) |
+-------------+ | approle | +---------+----------+
| Policies | |
Git-Repo | Secrets Engines | liest kv/... v
+-------------+ gitleaks | kv v2, database |-----------> K8s-Secret
| config.py |--> Fund! | Audit-Log | (refreshInterval)
+-------------+ +---------+---------+ |
| erzeugt/widerruft v
v Pod der demo-app
+---------------+
| PostgreSQL | dynamische User mit TTL
+---------------+
Die Konzepte in einfach
Was ist ein Secret?
Ein Secret ist jede Information, mit der man sich als jemand ausgeben oder etwas entschlüsseln kann: Passwörter, API-Tokens, private Schlüssel, Zertifikate, Verbindungs-Strings mit Passwort, Cloud-Zugangsschlüssel. Faustregel: Wenn ein Angreifer es in einem öffentlichen Gist findet und du danach schlecht schläfst, ist es ein Secret.
Der Lebenszyklus eines Secrets
Secrets sind keine Konfiguration, die man einmal setzt. Sie haben einen Lebenszyklus (Secret Lifecycle):
| Phase | Frage | Beispiel im Lab |
|---|---|---|
| Erzeugen | Wer erzeugt es, wie stark? | Vault erzeugt DB-User |
| Speichern | Wo liegt es verschlüsselt? | KV v2 in Vault |
| Verteilen | Wie kommt es zur Anwendung? | ESO, Vault-Agent, CI-Job |
| Nutzen | Wer darf es lesen? | Policy demo-app-read |
| Rotieren | Wie oft wird es erneuert? | neuer KV-Wert, neue Lease |
| Widerrufen | Wie ziehe ich es sofort ein? | vault lease revoke |
| Prüfen | Wer hat es wann gelesen? | Audit-Log |
Ein Passwort im Repository überspringt fast alle Phasen: Es wird von
Hand erzeugt, in Klartext gespeichert, per git clone an
alle verteilt, nie rotiert und lässt sich nicht widerrufen, weil niemand
weiß, wo überall Kopien liegen.
Statische und dynamische Secrets
Ein statisches Secret existiert unabhängig vom Tresor. Du legst etwa das Datenbank-Passwort in Vault ab. Vault bewahrt es nur auf. Rotieren musst du selbst (oder ein Skript).
Ein dynamisches Secret entsteht erst bei Abfrage. Fragt die Anwendung nach Datenbank-Zugangsdaten, legt Vault in diesem Moment einen neuen Datenbank-User an, gibt ihn heraus und löscht ihn nach Ablauf wieder. Jeder Abnehmer bekommt eigene Zugangsdaten. Ein Leck betrifft nur eine kurze Zeitspanne und lässt sich einem Abnehmer zuordnen.
Lease und TTL
Zu jedem dynamischen Secret gehört eine Lease
(Mietvertrag). Sie hat eine ID und eine TTL (Time to
Live, Lebensdauer). Läuft die TTL ab, widerruft Vault das Secret
automatisch. Die Anwendung kann die Lease bis zur max_ttl
verlängern (renew). Ein Mensch kann sie jederzeit vorzeitig widerrufen
(revoke), auch alle Leases einer Rolle auf einmal
(-prefix).
Auch Vault-Tokens haben eine TTL. Ein Token, das nach 15 Minuten verfällt, ist ein deutlich kleineres Problem als eines, das ewig gilt.
Auth-Methoden: Wie weist sich ein Abnehmer aus?
Vault gibt nichts heraus, ohne dass sich der Abnehmer anmeldet. Das Henne-Ei-Problem lautet: Womit meldet man sich an, ohne wieder ein Passwort zu speichern? Antwort: mit einer Identität, die die Plattform ohnehin ausstellt.
| Methode | Wer nutzt sie? | Identitätsnachweis |
|---|---|---|
kubernetes |
Pods, ESO | ServiceAccount-Token (JWT) |
jwt / oidc |
GitLab-CI-Jobs, Menschen | signiertes JWT vom IdP |
approle |
Maschinen ohne Plattform-ID | Role-ID + Secret-ID |
token |
Admin, Notfall | Vault-Token |
Kubernetes-Auth: Der Pod schickt sein ServiceAccount-Token an Vault. Vault fragt die Kubernetes-API per TokenReview: „Ist das echt, und zu welchem ServiceAccount gehört es?” Passt die Antwort zu einer Vault-Rolle (Namespace und ServiceAccount-Name), bekommt der Pod ein Vault-Token mit den Policies dieser Rolle.
JWT/OIDC für GitLab CI: GitLab stellt jedem Job auf
Wunsch ein signiertes JWT aus. Du forderst es in der
.gitlab-ci.yml über id_tokens an. Das Token
enthält Claims (Aussagen) wie project_path,
ref, ref_protected und
environment. Vault prüft die Signatur über den
JWKS-Endpunkt von GitLab und vergleicht die Claims mit
bound_claims der Rolle. So bekommt nur der Job auf dem
geschützten main-Branch des richtigen Projekts das
Produktions-Secret. Kein gespeichertes Vault-Token in CI-Variablen
nötig.
vault auth enable jwt
vault write auth/jwt/config \
oidc_discovery_url="https://gitlab.example.internal" \
bound_issuer="https://gitlab.example.internal"
vault write auth/jwt/role/demo-app-ci - <<'EOF'
{
"role_type": "jwt",
"user_claim": "user_login",
"bound_audiences": ["https://vault.example.internal"],
"bound_claims": {
"project_path": "root/demo-app",
"ref": "main",
"ref_protected": "true"
},
"token_policies": ["demo-app-read"],
"token_explicit_max_ttl": 300
}
EOFDer passende Job in GitLab:
read-secret:
image: hashicorp/vault:1.18
id_tokens:
VAULT_ID_TOKEN:
aud: https://vault.example.internal
variables:
VAULT_ADDR: https://vault.example.internal
script:
- LOGIN="auth/jwt/login role=demo-app-ci jwt=$VAULT_ID_TOKEN"
- export VAULT_TOKEN="$(vault write -field=token $LOGIN)"
- vault kv get -field=username kv/demo-app/dbTipp: GitLab Premium bietet mit dem Schlüsselwort
secrets:eine eingebaute Vault-Anbindung, die genau diesen Login für dich erledigt. Der Mechanismus darunter ist derselbe.
AppRole ist für Maschinen ohne eigene Plattform-Identität gedacht, etwa eine VM oder einen alten Jenkins. Die Role-ID ist wie ein Benutzername, die Secret-ID wie ein kurzlebiges Passwort. Das Problem verschiebt sich dabei nur: Die Secret-ID muss sicher zur Maschine kommen (Stichwort „Secret Zero”). Nutze AppRole deshalb nur, wenn Kubernetes- oder JWT-Auth nicht gehen.
vault auth enable approle
vault write auth/approle/role/legacy-job \
token_policies=demo-app-read secret_id_ttl=10m secret_id_num_uses=1
vault read -field=role_id auth/approle/role/legacy-job/role-id
vault write -f -field=secret_id auth/approle/role/legacy-job/secret-idPolicies
Eine Policy ist eine Liste von Pfaden mit erlaubten Fähigkeiten
(read, create, update,
delete, list, deny). Alles, was
nicht erlaubt ist, ist verboten (Default Deny). Policies schreibt man in
HCL.
Merke: Bei KV Version 2 liegen die Daten unter
<mount>/data/...und die Metadaten unter<mount>/metadata/.... Die CLI blendet das aus (vault kv get kv/demo-app/db), die Policy aber nicht. Eine Policy aufkv/demo-app/*greift deshalb ins Leere. Richtig istkv/data/demo-app/*.
Audit-Log
Vault kann jede Anfrage und jede Antwort in ein Audit-Device schreiben (Datei, Syslog, Socket). Secret-Werte erscheinen dort nicht im Klartext, sondern als HMAC-Hash. So kannst du später nachweisen, wer wann welchen Pfad gelesen hat, ohne dass das Log selbst zum Secret-Lager wird.
Achtung: Ist ein Audit-Device aktiviert, aber nicht beschreibbar (Platte voll), verweigert Vault die Anfragen. Das ist Absicht: lieber kein Zugriff als ein unprotokollierter. Für die Produktion heißt das: mindestens zwei Audit-Devices und Platz überwachen.
Vault oder OpenBao?
HashiCorp hat Vault im August 2023 ab Version 1.15 von der Open-Source-Lizenz MPL 2.0 auf die Business Source License (BSL 1.1) umgestellt. Die BSL erlaubt die eigene Nutzung, verbietet aber, ein konkurrierendes Produkt darauf aufzubauen. Für viele Behörden und Firmen mit strengen Lizenzregeln ist das ein Prüfpunkt. 2025 hat IBM HashiCorp übernommen.
Als Reaktion entstand OpenBao, ein Fork des letzten
MPL-Stands unter dem Dach der Linux Foundation. OpenBao ist
API-kompatibel, die CLI heißt bao, das Container-Image
openbao/openbao. Die meisten Befehle in diesem Kapitel
funktionieren, wenn du vault durch bao
ersetzt. Umgebungsvariablen heißen dort BAO_ADDR und
BAO_TOKEN. Funktionen der Vault-Enterprise-Edition (etwa
Performance-Replikation oder Namespaces in der alten Form) fehlen oder
sind anders umgesetzt. ESO spricht OpenBao über denselben
vault-Provider an.
| Merkmal | Vault | OpenBao |
|---|---|---|
| Lizenz | BSL 1.1 (ab 1.15) | MPL 2.0 |
| Träger | HashiCorp / IBM | Linux Foundation |
| CLI / Image | vault, hashicorp/vault |
bao, openbao/openbao |
| Support | kommerziell verfügbar | Community, Dienstleister |
External Secrets Operator (ESO)
ESO ist ein Kubernetes-Operator. Er liest Secrets aus einem externen Tresor und legt sie als normale Kubernetes-Secrets an. Die Anwendung merkt nichts von Vault. Drei Objekte sind wichtig:
| Objekt | Bereich | Aufgabe |
|---|---|---|
SecretStore |
ein Namespace | Wie komme ich an den Tresor? (URL, Auth) |
ClusterSecretStore |
ganzer Cluster | dasselbe, für alle Namespaces nutzbar |
ExternalSecret |
ein Namespace | Welche Werte, in welches K8s-Secret? |
Das Feld refreshInterval im ExternalSecret legt fest,
wie oft ESO im Tresor nachsieht. Ändert sich dort ein Wert, aktualisiert
ESO das Kubernetes-Secret. So wird eine Rotation in Vault automatisch im
Cluster sichtbar.
Merke: Ein
ClusterSecretStoreist bequem, aber mächtig: Jeder Namespace kann ihn referenzieren. In Mandanten-Clustern ist einSecretStorepro Namespace mit eigener Vault-Rolle die sicherere Wahl.
Hands-on-Lab: Vom Leck im Repo zum rotierenden Secret im Cluster
Du arbeitest in ~/seclab/kap06. Voraussetzung: der
kind-Cluster seclab aus Kapitel 0 läuft, die Werkzeuge
gitleaks, vault, helm,
kubectl, jq sind installiert.
Schritt 1: Vorbereitung
mkdir -p ~/seclab/kap06 && cd ~/seclab/kap06
kubectl config use-context kind-seclab
docker network ls --filter name=^kind$
gitleaks version
vault versionErwartung: Das Netz kind wird gelistet,
gitleaks meldet eine Version 8.x, vault eine
Version 1.x. Notiere die gitleaks-Version. Ab 8.19 gibt es die
Unterbefehle git und dir, ältere Versionen
kennen nur detect und protect.
Schritt 2: Ein Demo-Repo mit Leck anlegen
Du simulierst einen typischen Fehler: Jemand checkt Zugangsdaten ein und „repariert” das später mit einem zweiten Commit.
mkdir leak-demo && cd leak-demo
git init -b main
cat > config.py <<'EOF'
# Lab-Werte, absichtlich falsch und ungueltig!
DB_HOST = "postgres"
DB_PASSWORD = "Lab-9xQ2mZ7vK4pR8tW1"
GITLAB_TOKEN = "glpat-LabFake0000Abcd1234X"
EOF
git add config.py && git commit -m "feat: DB-Konfiguration"
cat > config.py <<'EOF'
import os
DB_HOST = os.environ.get("DB_HOST", "postgres")
DB_PASSWORD = os.environ["DB_PASSWORD"]
EOF
git commit -am "fix: Secrets aus Code entfernt"
git log --onelineErwartung: zwei Commits. Die aktuelle config.py enthält
kein Secret mehr.
Sicherheit: Alle Werte hier sind erfundene Lab-Werte. Verwende in Übungen nie echte Tokens, auch nicht „nur kurz”.
Schritt 3: gitleaks auf Arbeitskopie und Historie
Zuerst nur die Dateien, wie sie jetzt auf der Platte liegen:
# gitleaks >= 8.19:
gitleaks dir . -v
# aeltere Versionen:
gitleaks detect --source . --no-git -vErwartung: no leaks found. Die Arbeitskopie ist sauber.
Nun die gesamte Git-Historie:
# gitleaks >= 8.19:
gitleaks git . -v
# aeltere Versionen (in neuen Versionen noch vorhanden, aber veraltet):
gitleaks detect --source . -v
echo "Exit-Code: $?"Erwartete Ausgabe (gekürzt):
Finding: GITLAB_TOKEN = "glpat-LabFake0000Abcd1234X"
Secret: glpat-LabFake0000Abcd1234X
RuleID: gitlab-pat
File: config.py
Line: 4
Commit: 3f1c2a9...
Fingerprint: 3f1c2a9...:config.py:gitlab-pat:4
WRN leaks found: 1
Exit-Code: 1
Je nach gitleaks-Version meldet die Regel
generic-api-key zusätzlich das DB_PASSWORD.
Entscheidend ist: Der Fund steckt im ersten Commit. Der
Fix-Commit hat das Secret nur aus der aktuellen Version entfernt, nicht
aus der Historie. Jeder, der das Repo klont, hat es.
Für Berichte und Automatisierung nutzt du JSON und
--redact, damit der Wert nicht im CI-Log landet:
gitleaks git . --redact --report-format json --report-path gitleaks.json
jq -r '.[] | "\(.RuleID) \(.File):\(.StartLine) \(.Commit[0:7])"' gitleaks.jsonDer Exit-Code 1 bei Funden ist wichtig: Damit bricht ein CI-Job ab.
Schritt 4: Vault-Dev-Server starten
cd ~/seclab/kap06
docker run -d --name vault --network kind -p 8200:8200 \
--cap-add=IPC_LOCK \
-e VAULT_DEV_ROOT_TOKEN_ID=root \
-e VAULT_DEV_LISTEN_ADDRESS=0.0.0.0:8200 \
hashicorp/vault:1.18
export VAULT_ADDR=http://127.0.0.1:8200
export VAULT_TOKEN=root
vault statusErwartung: Sealed false,
Storage Type inmem. Der Container hängt im Netz
kind. Dadurch erreichen ihn später der Postgres-Container
und der kind-Cluster unter dem Namen vault.
Achtung: Der Dev-Modus hält alles im Arbeitsspeicher, ist automatisch entsiegelt, spricht unverschlüsseltes HTTP und hat das Root-Token
root. Ein Neustart löscht alle Daten. Das ist nur für das Lab gedacht.
OpenBao-Äquivalent:
docker run -d --name vault --network kind -p 8200:8200 openbao/openbao \
server -dev -dev-root-token-id=root -dev-listen-address=0.0.0.0:8200
export BAO_ADDR=http://127.0.0.1:8200 BAO_TOKEN=root
bao statusSchritt 5: KV v2 anlegen, Secret schreiben und lesen
Der Dev-Server bringt unter secret/ schon eine KV-Engine
mit. Du legst eine eigene an, so wie du es in der Produktion auch tun
würdest:
vault secrets enable -path=kv -version=2 kv
vault kv put kv/demo-app/db username=demo password='Lab-Start-1'
vault kv get kv/demo-app/dbErwartete Ausgabe (gekürzt):
==== Secret Path ====
kv/data/demo-app/db
======= Metadata =======
Key Value
--- -----
created_time 2026-10-08T09:12:44.1Z
version 1
====== Data ======
Key Value
--- -----
password Lab-Start-1
username demo
Achte auf kv/data/demo-app/db im Secret Path: Das ist
der echte API-Pfad. KV v2 speichert Versionen:
vault kv put kv/demo-app/db username=demo password='Lab-Start-2'
vault kv get -version=1 -field=password kv/demo-app/db
vault kv metadata get kv/demo-app/db | grep -E 'current_version|max_versions'Erwartung: Version 1 liefert Lab-Start-1,
current_version ist 2. Versionen sind nützlich, um eine
misslungene Rotation zurückzurollen
(vault kv rollback -version=1 kv/demo-app/db).
Schritt 6: Policy, eingeschränktes Token und Audit-Log
Aktiviere zuerst das Audit-Log, damit die folgenden Zugriffe protokolliert werden:
vault audit enable file file_path=/vault/logs/audit.logErwartung:
Success! Enabled the file audit device at: file/.
Nun eine Policy, die nur lesen darf:
cat > demo-app-read.hcl <<'EOF'
path "kv/data/demo-app/*" {
capabilities = ["read"]
}
EOF
vault policy write demo-app-read demo-app-read.hcl
APP_TOKEN=$(vault token create -policy=demo-app-read -ttl=15m -field=token)
VAULT_TOKEN=$APP_TOKEN vault kv get -field=username kv/demo-app/db
VAULT_TOKEN=$APP_TOKEN vault kv put kv/demo-app/db password=hackErwartung: Das Lesen liefert demo. Das Schreiben
scheitert mit Code: 403 und permission denied.
Sieh dir den letzten Eintrag im Audit-Log an:
docker exec vault tail -n 1 /vault/logs/audit.log | jq '{
type, path: .request.path, op: .request.operation,
policies: .auth.policies, error }'Erwartung: type ist response,
path ist kv/data/demo-app/db,
policies enthält demo-app-read und
error den Text permission denied. Das Token
selbst steht dort nur als HMAC-Hash.
Schritt 7: Postgres und die Database Secrets Engine
Starte eine Postgres-Datenbank im selben Docker-Netz:
docker run -d --name postgres --network kind -p 5432:5432 \
-e POSTGRES_PASSWORD=lab-postgres-pw -e POSTGRES_DB=demo postgres:16
sleep 5
docker exec postgres pg_isready -U postgresErwartung: accepting connections. Jetzt bekommt Vault
die Admin-Zugangsdaten und eine Rolle, die beschreibt, wie ein
Kurzzeit-User angelegt wird:
vault secrets enable database
vault write database/config/demo-postgres \
plugin_name=postgresql-database-plugin \
connection_url="postgresql://{{username}}:{{password}}@\
postgres:5432/demo?sslmode=disable" \
allowed_roles="demo-app-ro" \
username="postgres" password="lab-postgres-pw"
vault write database/roles/demo-app-ro \
db_name=demo-postgres \
default_ttl=5m max_ttl=1h \
creation_statements="CREATE ROLE \"{{name}}\" WITH LOGIN PASSWORD '{{password}}' \
VALID UNTIL '{{expiration}}'; \
GRANT SELECT ON ALL TABLES IN SCHEMA public TO \"{{name}}\";"Erwartung: jeweils Success! Data written to: .... Vault
erreicht die Datenbank unter postgres:5432, weil beide
Container im Netz kind hängen und Docker dort
Container-Namen auflöst.
Tipp: Das Passwort
lab-postgres-pwkennt jetzt noch jeder, der dieses Buch liest. Mitvault write -f database/rotate-root/demo-postgressetzt Vault ein neues Admin-Passwort, das nur Vault kennt. In der Produktion gehört das zur Einrichtung dazu. Im Lab lässt du es weg, damit du dich noch selbst anmelden kannst.
Schritt 8: Dynamische Credentials nutzen und widerrufen
vault read -format=json database/creds/demo-app-ro > creds.json
jq '{lease_id, lease_duration, user: .data.username}' creds.json
LEASE=$(jq -r .lease_id creds.json)
DBUSER=$(jq -r .data.username creds.json)
DBPASS=$(jq -r .data.password creds.json)Erwartete Ausgabe:
{
"lease_id": "database/creds/demo-app-ro/Xy7kP...",
"lease_duration": 300,
"user": "v-root-demo-app-ro-AbC1d2EfG3h4IjK5lM6n-1791451234"
}
300 Sekunden sind die 5 Minuten aus default_ttl. Teste
den Login von einem zweiten Container aus, damit wirklich eine
Passwort-Prüfung über das Netz stattfindet:
docker run --rm --network kind -e PGPASSWORD="$DBPASS" postgres:16 \
psql -h postgres -U "$DBUSER" -d demo -c 'select current_user;'
docker exec postgres psql -U postgres -c '\du' | grep v-rootErwartung: current_user zeigt den
v-root-...-Namen, und \du listet diese Rolle.
Nun widerrufst du die Lease, als wäre das Credential geleakt:
vault lease lookup "$LEASE" | grep ttl
vault lease revoke "$LEASE"
docker run --rm --network kind -e PGPASSWORD="$DBPASS" postgres:16 \
psql -h postgres -U "$DBUSER" -d demo -c 'select 1;'Erwartung: Nach dem Revoke schlägt der Login fehl
(password authentication failed oder
role ... does not exist). Vault hat den User in Postgres
gelöscht. Hättest du nichts getan, wäre dasselbe nach 5 Minuten
automatisch passiert. Alle Leases einer Rolle widerrufst du mit
vault lease revoke -prefix database/creds/demo-app-ro.
Schritt 9: External Secrets Operator per Helm installieren
helm repo add external-secrets https://charts.external-secrets.io
helm repo update
helm install external-secrets external-secrets/external-secrets \
-n external-secrets --create-namespace --wait
kubectl get pods -n external-secrets
kubectl api-resources --api-group=external-secrets.io | grep -i secretstoreErwartung: drei Pods Running (Controller, Webhook,
Cert-Controller). Die letzte Zeile zeigt die API-Version, etwa
external-secrets.io/v1. Ältere ESO-Versionen (vor 0.16)
kennen nur v1beta1. Passe dann apiVersion in
den YAML-Dateien unten an.
Schritt 10: Kubernetes-Auth in Vault konfigurieren
Hier steckt die Netzwerk-Besonderheit dieses Labs. Vault läuft nicht im Cluster, sondern als Container daneben. Beide Richtungen müssen funktionieren:
Docker-Netz "kind"
+-------------------------------------------------------------------+
| Container "vault" --- TokenReview ---> seclab-control-plane:6443 |
| ^ (K8s-API im kind-Node) |
| | http://vault:8200 |
| ESO-Pod im kind-Node (Pod-DNS -> Node -> Docker-DNS) |
+-------------------------------------------------------------------+
- ESO im Cluster muss Vault erreichen: über den Namen
vault, den Docker im Netzkindauflöst. - Vault muss die Kubernetes-API erreichen, um ServiceAccount-Tokens zu
prüfen: über den Namen des Control-Plane-Containers
seclab-control-planeauf Port 6443. Der Eintrag127.0.0.1:...aus deiner Kubeconfig funktioniert aus dem Vault-Container heraus nicht.
Prüfe zuerst die Richtung Cluster → Vault:
kubectl create namespace demo --dry-run=client -o yaml | kubectl apply -f -
kubectl run nettest -n demo --rm -i --restart=Never \
--image=curlimages/curl -- curl -s http://vault:8200/v1/sys/healthErwartung: JSON mit "initialized":true,"sealed":false.
Die interne API-Adresse zeigt dir kind selbst:
kind get kubeconfig --name seclab --internal | grep serverErwartung: server: https://seclab-control-plane:6443.
Nun legst du den ServiceAccount an, mit dem sich ESO bei Vault anmeldet.
Er darf zusätzlich TokenReviews durchführen
(system:auth-delegator), damit Vault sein Token zur Prüfung
verwenden kann:
kubectl create serviceaccount eso-vault -n demo
kubectl create clusterrolebinding eso-vault-tokenreview \
--clusterrole=system:auth-delegator --serviceaccount=demo:eso-vault
kubectl config view --raw --minify --flatten \
-o jsonpath='{.clusters[0].cluster.certificate-authority-data}' \
| base64 --decode > k8s-ca.crt
vault auth enable kubernetes
vault write auth/kubernetes/config \
kubernetes_host="https://seclab-control-plane:6443" \
[email protected]
vault write auth/kubernetes/role/demo-app \
bound_service_account_names=eso-vault \
bound_service_account_namespaces=demo \
token_policies=demo-app-read token_ttl=15mWeil du kein token_reviewer_jwt gesetzt hast und Vault
außerhalb des Clusters läuft, nimmt Vault das Token des sich anmeldenden
ServiceAccounts selbst für den TokenReview. Dafür ist die
ClusterRoleBinding nötig. Teste den Login von Hand, bevor ESO ins Spiel
kommt:
SA_JWT=$(kubectl create token eso-vault -n demo)
vault write auth/kubernetes/login role=demo-app jwt="$SA_JWT" | grep policiesErwartung: token_policies ["default" "demo-app-read"].
Klappt das nicht, liegt der Fehler in Vault oder Netz, nicht in ESO. Das
spart viel Suchzeit.
Schritt 11: SecretStore und ExternalSecret
cat > secretstore.yaml <<'EOF'
apiVersion: external-secrets.io/v1
kind: SecretStore
metadata:
name: vault-backend
namespace: demo
spec:
provider:
vault:
server: "http://vault:8200"
path: "kv"
version: "v2"
auth:
kubernetes:
mountPath: "kubernetes"
role: "demo-app"
serviceAccountRef:
name: "eso-vault"
EOF
cat > externalsecret.yaml <<'EOF'
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
name: demo-app-db
namespace: demo
spec:
refreshInterval: 15s
secretStoreRef:
name: vault-backend
kind: SecretStore
target:
name: demo-app-db
creationPolicy: Owner
data:
- secretKey: DB_USER
remoteRef:
key: demo-app/db
property: username
- secretKey: DB_PASSWORD
remoteRef:
key: demo-app/db
property: password
EOF
kubectl apply -f secretstore.yaml -f externalsecret.yaml
kubectl get secretstore,externalsecret -n demoErwartete Ausgabe:
NAME AGE STATUS CAPABILITIES READY
secretstore.external-secrets.io/vault-backend 10s Valid ReadWrite True
NAME STORE STATUS READY
externalsecret.external-secrets.io/demo-app-db vault-backend SecretSynced True
(Die Spalten sind hier gekürzt, je nach ESO-Version siehst du
zusätzlich REFRESH.)
Beachte: Im SecretStore steht path: "kv" und im
ExternalSecret key: demo-app/db, ohne data/.
Das ergänzt ESO selbst, weil version: "v2" gesetzt ist.
Prüfe den Inhalt:
kubectl get secret demo-app-db -n demo \
-o jsonpath='{.data.DB_PASSWORD}' | base64 --decode; echoErwartung: Lab-Start-2.
Merke:
refreshInterval: 15sist nur für die Vorführung so kurz. Jede Synchronisation ist ein Vault-Login plus Lesezugriff. In der Produktion sind 5 bis 60 Minuten üblich.
Schritt 12: Rotation demonstrieren
Ändere den Wert in Vault, so wie es ein Rotationsprozess tun würde:
vault kv put kv/demo-app/db username=demo password='Lab-Rotiert-3'
sleep 20
kubectl get secret demo-app-db -n demo \
-o jsonpath='{.data.DB_PASSWORD}' | base64 --decode; echo
kubectl get externalsecret demo-app-db -n demo \
-o jsonpath='{.status.refreshTime}'; echoErwartung: Lab-Rotiert-3 und ein frischer Zeitstempel.
Willst du nicht warten, erzwingst du eine Synchronisation:
kubectl annotate externalsecret demo-app-db -n demo \
force-sync="$(date +%s)" --overwriteAchtung: Das Kubernetes-Secret ist jetzt aktuell, der laufende Pod aber nicht unbedingt. Umgebungsvariablen werden nur beim Pod-Start gelesen. Als Datei gemountete Secrets aktualisiert das Kubelet nach einiger Zeit (nicht bei
subPath). Die Anwendung muss die Datei dann neu lesen. Üblich sind ein Rollout-Neustart (kubectl rollout restart) oder ein Werkzeug wie Stakater Reloader, das bei Secret-Änderungen automatisch neu startet.
Sieh im Audit-Log nach, dass ESO mit seiner eigenen Identität gelesen hat:
docker exec vault cat /vault/logs/audit.log \
| jq -r 'select(.type=="response" and .auth.metadata.role=="demo-app")
| .request.path' | sort | uniq -cErwartung: Zeilen für auth/kubernetes/login und
kv/data/demo-app/db. Die Zahlen wachsen mit jedem Refresh.
Die Rolle steht in den Metadaten im Klartext, die Secret-Werte
nicht.
Schritt 13: Ablösungsplan für das geleakte Credential
Zurück zum Leck aus Schritt 2. Die Reihenfolge ist entscheidend:
1. Eindämmen -> Credential widerrufen/rotieren (Minuten)
2. Bewerten -> Wurde es benutzt? Logs prüfen (Stunden)
3. Umstellen -> Code liest aus Secret-Quelle (Tage)
4. Bereinigen -> Historie umschreiben (optional) (geplant)
5. Verhindern -> Pre-commit + CI-Scan (dauerhaft)
1. Eindämmen. Das GitLab-Token widerrufst du in GitLab unter User Settings → Access Tokens → Revoke. Das DB-Passwort ersetzt du durch einen neuen Wert in Vault. Das hast du in Schritt 12 bereits geübt. Noch besser: dynamische Credentials wie in Schritt 8, dann gibt es kein langlebiges Passwort mehr.
2. Bewerten. Prüfe in den Logs des betroffenen Systems (GitLab-Audit-Events, DB-Logins), ob das Credential zwischen Commit und Widerruf benutzt wurde. Das bestimmt, ob es ein Sicherheitsvorfall mit Meldepflicht wird.
3. Umstellen. Der Code liest jetzt
os.environ["DB_PASSWORD"]. Das Kubernetes-Secret
demo-app-db aus ESO liefert genau diese Variable. Im
Deployment der demo-app sieht das so aus:
envFrom:
- secretRef:
name: demo-app-db4. Bereinigen. Erst jetzt, wenn das alte Credential wertlos ist, schreibst du die Historie um.
Achtung: Historie bereinigen ist kein Ersatz für Rotation. Das Secret steckt bereits in Klonen auf Laptops, in CI-Caches, in Forks, in Merge-Request-Diffs und eventuell in Backups. Du kannst das nicht zurückholen. Ein rotiertes Secret ist ungefährlich, auch wenn es noch irgendwo steht. Ein bereinigtes, aber nicht rotiertes Secret ist weiter gültig.
Schritt 14: Historie mit git filter-repo bereinigen
git filter-repo ist ein eigenständiges Werkzeug
(Installation z. B. per pip install git-filter-repo oder
Paketmanager). Es arbeitet aus Sicherheitsgründen nur auf einem frischen
Klon:
cd ~/seclab/kap06
git clone --no-local leak-demo leak-demo-clean
cd leak-demo-clean
cat > ../replacements.txt <<'EOF'
glpat-LabFake0000Abcd1234X==>***ENTFERNT***
Lab-9xQ2mZ7vK4pR8tW1==>***ENTFERNT***
EOF
git log --oneline
git filter-repo --replace-text ../replacements.txt
git log --oneline
gitleaks git . -vErwartung: Die Commit-IDs vor und nach filter-repo
unterscheiden sich, denn jeder betroffene Commit wurde neu geschrieben.
gitleaks meldet no leaks found. Mit
git show HEAD~1:config.py siehst du
***ENTFERNT*** an Stelle der Werte.
In einem echten Projekt folgen weitere Schritte:
filter-repoentfernt den Remoteorigin. Du fügst ihn wieder hinzu und pushst mitgit push --force --allundgit push --force --tags. Dafür muss der Branch-Schutz kurz gelockert werden.- Alle Beteiligten müssen neu klonen. Ein
git pullauf einem alten Klon bringt die alte Historie zurück. - GitLab hält alte Objekte noch in Merge-Request-Refs und Caches. Housekeeping im Projekt (Settings → General → Advanced → Housekeeping) und gegebenenfalls das Entfernen betroffener MRs gehören dazu.
Schritt 15: Pre-commit-Hook mit gitleaks
Damit es nicht wieder passiert, prüft ein Hook jeden Commit vor dem Speichern:
cd ~/seclab/kap06/leak-demo-clean
cat > .git/hooks/pre-commit <<'EOF'
#!/bin/sh
# gitleaks >= 8.19; aeltere Versionen: gitleaks protect --staged --redact -v
exec gitleaks git --pre-commit --staged --redact -v
EOF
chmod +x .git/hooks/pre-commit
echo 'TOKEN = "glpat-LabFake9999Wxyz5678Q"' > neu.py
git add neu.py
git commit -m "test: sollte blockiert werden"
echo "Exit-Code: $?"Erwartung: leaks found: 1, Exit-Code 1, kein neuer
Commit (git log --oneline zeigt ihn nicht). Räume die
Testdatei weg: git reset neu.py && rm neu.py.
Im Team verteilst du den Hook über das Framework
pre-commit mit einer .pre-commit-config.yaml
im Repo:
repos:
- repo: https://github.com/gitleaks/gitleaks
rev: v8.21.2
hooks:
- id: gitleaksLokale Hooks lassen sich mit git commit --no-verify
umgehen. Deshalb gehört derselbe Scan zusätzlich in die Pipeline. Dort
kann ihn niemand überspringen:
secret-scan:
stage: test
image:
name: zricethezav/gitleaks:v8.21.2
entrypoint: [""]
variables:
GIT_DEPTH: "0"
script:
- gitleaks git . --redact -v --report-format json --report-path gitleaks.json
artifacts:
when: always
paths: [gitleaks.json]GIT_DEPTH: "0" holt die volle Historie. Mit dem
Standard-Shallow-Clone sähe gitleaks nur die letzten Commits. In einer
abgeschotteten Umgebung beziehst du das Image aus deiner
Spiegel-Registry (siehe Kapitel 3).
Schritt 16: Aufräumen
kubectl delete -f ~/seclab/kap06/externalsecret.yaml -f ~/seclab/kap06/secretstore.yaml
kubectl delete clusterrolebinding eso-vault-tokenreview
kubectl delete serviceaccount eso-vault -n demo
helm uninstall external-secrets -n external-secrets
kubectl delete namespace external-secrets
docker rm -f vault postgresErwartung: Alle Befehle laufen ohne Fehler. docker ps
zeigt weder vault noch postgres. Den Namespace
demo lässt du stehen, er wird in späteren Kapiteln
gebraucht.
Fortschritt speichern? Kostenlos registrieren
Typische Stolperfallen
| Symptom | Ursache | Lösung |
|---|---|---|
permission denied trotz Policy |
Policy auf kv/demo-app/* statt
kv/data/... |
bei KV v2 data/ im Policy-Pfad |
| gitleaks findet nichts in CI | Shallow Clone | GIT_DEPTH: "0" setzen |
SecretStore InvalidProviderConfig |
Vault-Name nicht auflösbar | Netz kind prüfen; notfalls IP per
docker inspect |
Login: permission denied bei K8s-Auth |
SA oder Namespace passt nicht zur Rolle | bound_service_account_* prüfen |
Login: x509 oder connection refused |
kubernetes_host zeigt auf 127.0.0.1 |
https://seclab-control-plane:6443 |
TokenReview 403 |
SA fehlt system:auth-delegator |
ClusterRoleBinding anlegen |
| Secret aktualisiert, App nutzt alten Wert | Env-Variablen nur beim Start | Rollout-Neustart oder Reloader |
| Nach Neustart von Vault alles weg | Dev-Modus speichert im RAM | Lab-Schritte ab 4 wiederholen |
no matches for kind ExternalSecret |
falsche apiVersion |
kubectl api-resources prüfen |
Für die Namensauflösung als Notlösung ermittelst du die IP so:
docker inspect -f '{{.NetworkSettings.Networks.kind.IPAddress}}' vault.
Diese IP ändert sich aber beim Neustart des Containers.
Übung: Zweites Team, getrennte Tresorfächer
Ein zweites Team betreibt im Namespace team-b eine
Anwendung. Es soll ein eigenes Secret unter kv/team-b/api
mit dem Schlüssel apikey (Lab-Wert
Lab-TeamB-1) bekommen. Richte Vault und ESO so ein,
dass:
- im Namespace
team-bein Kubernetes-Secretteam-b-apimit dem Wert entsteht, - der SecretStore im Namespace
demodieses Secret nicht lesen kann (nachweisen!), - das Team-B-Secret höchstens alle 5 Minuten synchronisiert wird.
Starte vorher Vault und ESO neu, falls du schon aufgeräumt hast (Schritte 4, 5, 6, 9, 10, 11).
Hinweis 1
Du brauchst pro Team drei Dinge in Vault: eine Policy, eine Rolle in der Kubernetes-Auth-Methode und einen ServiceAccount im Cluster. Die Vault-Rolle verbindet ServiceAccount und Namespace mit der Policy. Denke an die ClusterRoleBinding für TokenReview.
Hinweis 2
Den Nachweis für Punkt 2 führst du am einfachsten mit einem zweiten
ExternalSecret im Namespace demo, das
key: team-b/api aus dem Store vault-backend
lesen will. Sein Status sollte nicht SecretSynced sein.
kubectl describe externalsecret zeigt dir die Fehlermeldung
von Vault.
Lösung
vault kv put kv/team-b/api apikey='Lab-TeamB-1'
cat > team-b-read.hcl <<'EOF'
path "kv/data/team-b/*" {
capabilities = ["read"]
}
EOF
vault policy write team-b-read team-b-read.hcl
kubectl create namespace team-b
kubectl create serviceaccount eso-vault -n team-b
kubectl create clusterrolebinding eso-vault-tokenreview-team-b \
--clusterrole=system:auth-delegator --serviceaccount=team-b:eso-vault
vault write auth/kubernetes/role/team-b \
bound_service_account_names=eso-vault \
bound_service_account_namespaces=team-b \
token_policies=team-b-read token_ttl=15mFür die Kubernetes-Objekte kopierst du secretstore.yaml
und externalsecret.yaml und änderst
namespace: team-b, role: "team-b",
refreshInterval: 5m, target.name: team-b-api
und den data-Block:
data:
- secretKey: APIKEY
remoteRef:
key: team-b/api
property: apikeyNach kubectl apply zeigt
kubectl get externalsecret -n team-b den Status
SecretSynced. Für den Negativtest legst du im Namespace
demo ein ExternalSecret klau-versuch mit
key: team-b/api an. Erwartung: READY False,
und kubectl describe externalsecret klau-versuch -n demo
zeigt einen Fehler mit permission denied bzw.
403. Der Grund: Der Store in demo meldet sich
mit der Rolle demo-app an, und deren Policy erlaubt nur
kv/data/demo-app/*.
Die Trennung entsteht also nicht durch ESO, sondern durch die
Kombination aus Vault-Rolle (wer bin ich?) und Policy (was darf ich?).
Ein gemeinsamer ClusterSecretStore mit einer einzigen
Vault-Rolle hätte diese Trennung aufgehoben.
Fortschritt speichern? Kostenlos registrieren
Aus der Praxis
Betrieb von Vault/OpenBao. In der Produktion läuft
Vault nicht im Dev-Modus, sondern als Cluster mit drei oder fünf Knoten
und integriertem Raft-Speicher, TLS auf allen Verbindungen und
Auto-Unseal über ein HSM oder einen KMS. In abgeschotteten Umgebungen
(air-gapped) ist das HSM oft die einzige Option, weil kein Cloud-KMS
erreichbar ist. Das Root-Token wird nach der Einrichtung widerrufen
(vault token revoke) und nur im Notfall über die Unseal-
bzw. Recovery-Key-Halter neu erzeugt (Vier-Augen-Prinzip mit
Shamir-Teilschlüsseln).
Wer verwaltet Vault selbst? Policies, Rollen und Auth-Methoden gehören in Git und werden per Terraform/OpenTofu oder einem eigenen Pipeline-Job ausgerollt. Dann sind Berechtigungsänderungen über Merge Requests prüfbar. Kein Mensch klickt Policies in der UI zusammen.
Audit und Monitoring. Das Audit-Log geht in das
zentrale SIEM. Sinnvolle Alarme: Root-Token benutzt, Policy geändert,
viele permission denied von einer Identität, Audit-Device
ausgefallen. Vault exportiert Metriken im Prometheus-Format
(/v1/sys/metrics). Dort lohnt der Blick auf Lease-Anzahl,
Seal-Status und Request-Latenz. Viele Leases ohne Revoke deuten auf
Anwendungen hin, die bei jedem Start neue Credentials ziehen und nie
aufräumen.
Behörden und KRITIS. Prüfer fragen meist: Wo liegen Secrets? Wer hat Zugriff? Wie oft wird rotiert? Wie schnell kann widerrufen werden? Gibt es einen Nachweis? Mit Vault beantwortest du das aus den Policies, den TTLs und dem Audit-Log. Im IT-Grundschutz des BSI findest du passende Anforderungen etwa im Baustein zur Kryptokonzept- und Schlüsselverwaltung und zum Identitäts- und Berechtigungsmanagement. Lizenzfragen (BSL vs. MPL) klärst du früh mit der Beschaffung. Mancher Auftraggeber verlangt ausdrücklich Open-Source-Lizenzen, dann ist OpenBao gesetzt.
Ablösung im Bestand. In gewachsenen Organisationen findet ein erster gitleaks-Lauf über alle Repos oft Hunderte Funde. Nicht alle auf einmal angehen. Bewährt hat sich:
- Funde nach Art klassifizieren (Cloud-Keys, DB-Passwörter, Test-Dummies).
- Echte, noch gültige Credentials sofort rotieren.
- Für Altlasten eine Baseline erstellen (
--baseline-pathin gitleaks), damit neue Funde sofort auffallen. - Mit den Teams Übergangsfristen für die Umstellung auf Vault vereinbaren (siehe Kapitel 10).
Kein Secret im Git, auch nicht verschlüsselt?
Werkzeuge wie SOPS oder Sealed Secrets legen verschlüsselte Secrets ins
Repo. Das ist besser als Klartext, löst aber Rotation, Widerruf und
Audit nicht. ESO mit Vault trennt Speicherung und Verteilung sauber und
ist deshalb in regulierten Umgebungen oft die bevorzugte Lösung. Argo CD
oder Flux (siehe Kapitel 1) rollen dann nur das
ExternalSecret aus, nie den Wert selbst.
Interviewfragen
F: Ein Kollege hat ein Produktions-Datenbankpasswort in ein internes Repo gepusht und es zehn Minuten später wieder gelöscht. Was tust du?
A: Zuerst das Passwort rotieren bzw. den Zugang
widerrufen, denn es steht weiter in der Historie und in allen Klonen.
Danach in den DB-Logs prüfen, ob es missbraucht wurde, und je nach
Ergebnis den Vorfallprozess starten. Dann den Code auf eine
Secret-Quelle umstellen, die Historie mit git filter-repo
bereinigen und gitleaks als Pre-commit-Hook und CI-Job einführen.
F: Was ist der Unterschied zwischen statischen und dynamischen Secrets?
A: Ein statisches Secret existiert unabhängig vom Tresor und wird dort nur gespeichert. Rotieren muss man es selbst. Ein dynamisches Secret erzeugt Vault erst bei Anfrage, individuell pro Abnehmer und mit einer Lease. Nach Ablauf der TTL oder bei Revoke löscht Vault es im Zielsystem wieder.
F: Wie authentifiziert sich ein GitLab-CI-Job bei Vault, ohne dass ein Token in CI-Variablen liegt?
A: Über id_tokens fordert der Job ein
von GitLab signiertes JWT mit passender Audience an. Vault prüft es per
JWT-Auth-Methode gegen den JWKS-Endpunkt von GitLab und vergleicht
Claims wie project_path, ref und
ref_protected mit bound_claims der Rolle. Der
Job bekommt ein kurzlebiges Vault-Token mit genau der Policy dieser
Rolle.
F: Warum braucht Vault Zugriff auf die Kubernetes-API, wenn es Kubernetes-Auth nutzt?
A: Vault prüft das ServiceAccount-Token des Pods über die TokenReview-API. Nur so weiß es, ob das Token gültig ist und zu welchem ServiceAccount und Namespace es gehört. Läuft Vault außerhalb des Clusters, braucht es dafür Netzwerkzugang zur API, das CA-Zertifikat und ein JWT mit Recht auf TokenReview.
F: Was ist der Unterschied zwischen
SecretStore und ClusterSecretStore im External
Secrets Operator?
A: Ein SecretStore gilt für einen
Namespace und kann nur von ExternalSecrets dort genutzt werden. Ein
ClusterSecretStore gilt clusterweit. Für Mandantentrennung
nimmt man SecretStores pro Namespace mit eigener Vault-Rolle und Policy,
sonst könnte jeder Namespace alles lesen, was die gemeinsame Rolle
darf.
F: Wie kommt eine Rotation in Vault bis zur laufenden Anwendung?
A: ESO prüft im refreshInterval und
aktualisiert das Kubernetes-Secret. Gemountete Secret-Dateien
aktualisiert das Kubelet danach, die Anwendung muss sie neu lesen.
Umgebungsvariablen bleiben bis zum Neustart alt. Deshalb braucht man
einen Rollout-Neustart oder einen Reloader. Bei Datenbanken lässt man
alte und neue Credentials kurz parallel gelten.
F: Vault oder OpenBao, wie entscheidest du?
A: Technisch sind beide für die Kernfunktionen weitgehend gleich und API-kompatibel. Entscheidend sind Lizenz (BSL bei Vault ab 1.15, MPL 2.0 bei OpenBao), Bedarf an Enterprise-Funktionen, Support-Anforderungen und Beschaffungsvorgaben. In Umgebungen mit Open-Source-Pflicht ist OpenBao naheliegend.
F: Warum ist eine Policy auf kv/myapp/*
bei KV v2 wirkungslos?
A: KV v2 legt die Daten unter
kv/data/myapp/... und Metadaten unter
kv/metadata/myapp/... ab. Die CLI versteckt das, Policies
arbeiten aber mit den echten API-Pfaden.
Zusammenfassung
Das hast du gelernt:
- Ein gelöschtes Secret ist nicht weg: gitleaks findet es in der Historie, und nur Rotation macht es wertlos.
- Ein Secret hat einen Lebenszyklus. Vault deckt Speichern, Verteilen, Rotieren, Widerrufen und Prüfen ab.
- Dynamische Secrets mit Lease und TTL sind pro Abnehmer eindeutig, verfallen von selbst und lassen sich gezielt widerrufen.
- Abnehmer melden sich mit Plattform-Identitäten an:
Kubernetes-ServiceAccounts, GitLab-
id_tokensper JWT, notfalls AppRole. - Policies arbeiten mit echten API-Pfaden und Default Deny. Das Audit-Log weist jeden Zugriff nach.
- ESO synchronisiert Secrets aus Vault in Kubernetes. Mit
refreshIntervalkommen Rotationen automatisch an, laufende Pods brauchen aber einen Neustart oder Reload. - Läuft Vault außerhalb des kind-Clusters, verbindet das Docker-Netz
kindbeide Seiten über die Namenvaultundseclab-control-plane. - OpenBao ist der MPL-lizenzierte Fork von Vault mit
bao-CLI und kompatibler API.