Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 4: External Secrets Operator – fortgeschritten

Ziel: Mit ESO Konfigdateien und Pull-Secrets rendern, Mandanten sauber trennen, Secrets nach OpenBao zurückschreiben, dynamische DB-Credentials erzeugen und die typischen Fehler am Event erkennen. · Dauer: ca. 120 min · Voraussetzung: Tag 3

Briefing

  • target.template (Engine v2, Go-Templates plus Sprig-Funktionen) baut aus mehreren Keys ein fertiges Secret: Konfigdatei, dockerconfigjson, Connection-String.
  • creationPolicy regelt, wem das Ziel-Secret gehört. deletionPolicy regelt, was passiert, wenn das Secret in OpenBao verschwindet.
  • Mandantentrennung: SecretStore pro Namespace mit eigener Rolle, oder ClusterSecretStore mit conditions.
  • PushSecret schreibt Kubernetes → OpenBao. Generatoren wie VaultDynamicSecret erzeugen bei jedem Refresh neue Werte.
OpenBao secret/shop/*  ──ExternalSecret──>  K8s-Secret (Template, Policies)
OpenBao database/creds ──Generator──────>  K8s-Secret (neue DB-User je Refresh)
OpenBao secret/shop/webhook <──PushSecret── K8s-Secret shop-webhook

Drill 1: Konfigdatei aus mehreren Keys rendern

Stand aus Tag 3: ESO läuft, SecretStore openbao in shop ist Valid.

mkdir -p ~/secrets-lab/tag04 && cd ~/secrets-lab/tag04
export BAO_ADDR=http://127.0.0.1:8200 BAO_TOKEN=root
cat > es-config.yaml <<'EOF'
# Tag 4: Konfigdatei aus mehreren Keys rendern (target.template, engineVersion v2)
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: shop-config
  namespace: shop
spec:
  refreshInterval: 1m
  secretStoreRef:
    kind: SecretStore
    name: openbao
  target:
    name: shop-config
    template:
      engineVersion: v2
      metadata:
        labels:
          app: shop-api
      data:
        application.properties: |
          db.url=jdbc:postgresql://postgres.shop.svc:5432/shop
          db.user={{ .db_user }}
          db.password={{ .db_password }}
          payment.token={{ .token }}
          api.key={{ .api_key | upper }}
  dataFrom:
    - extract:
        key: shop/api
    - extract:
        key: shop/stripe
EOF
kubectl apply -f es-config.yaml
sleep 3
kubectl -n shop get secret shop-config -o jsonpath='{.data.application\.properties}' \
  | base64 -d
kubectl -n shop get secret shop-config -o jsonpath='{.metadata.labels.app}{"\n"}'

Erwartet:

externalsecret.external-secrets.io/shop-config created
db.url=jdbc:postgresql://postgres.shop.svc:5432/shop
db.user=shop
db.password=lab-db-pw-123
payment.token=lab-stripe-789
api.key=LAB-API-KEY-456
shop-api

Beide extract-Einträge landen in einem gemeinsamen Datenraum, das Template greift per .key zu. Im Ziel-Secret steht nur noch application.properties, die Roh-Keys nicht. | upper ist eine Sprig-Funktion und zeigt, dass du Werte umformen kannst.

Tipp: Brauchst du Roh-Keys und die Datei, setz template.mergePolicy: Merge.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Image-Pull-Secret (dockerconfigjson)

Registry-Zugangsdaten liegen in OpenBao, Kubernetes braucht sie als kubernetes.io/dockerconfigjson.

bao kv put secret/shop/registry server=registry.lab.local username=shop-ci \
  password=lab-reg-pw-321
cat > es-pull-secret.yaml <<'EOF'
# Tag 4: Image-Pull-Secret (dockerconfigjson) aus OpenBao bauen
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: shop-registry
  namespace: shop
spec:
  refreshInterval: 1h
  secretStoreRef:
    kind: SecretStore
    name: openbao
  target:
    name: shop-registry
    template:
      engineVersion: v2
      type: kubernetes.io/dockerconfigjson
      data:
        .dockerconfigjson: |
          {"auths":{"{{ .server }}":{"username":"{{ .username }}",
          "password":"{{ .password }}",
          "auth":"{{ printf "%s:%s" .username .password | b64enc }}"}}}
  dataFrom:
    - extract:
        key: shop/registry
EOF
kubectl apply -f es-pull-secret.yaml
sleep 3
kubectl -n shop get secret shop-registry -o jsonpath='{.type}{"\n"}'
kubectl -n shop get secret shop-registry -o jsonpath='{.data.\.dockerconfigjson}' \
  | base64 -d | jq .

Erwartet:

Success! Data written to: secret/data/shop/registry
externalsecret.external-secrets.io/shop-registry created
kubernetes.io/dockerconfigjson
{
  "auths": {
    "registry.lab.local": {
      "username": "shop-ci",
      "password": "lab-reg-pw-321",
      "auth": "c2hvcC1jaTpsYWItcmVnLXB3LTMyMQ=="
    }
  }
}

Die Policy shop-api-read deckt secret/data/shop/* ab, also auch shop/registry. Im Deployment trägst du imagePullSecrets: [{name: shop-registry}] ein.

Fortschritt speichern? Kostenlos registrieren

Drill 3: creationPolicy und deletionPolicy

Owner (Standard): Das Secret gehört dem ExternalSecret und stirbt mit ihm. Orphan: Das Secret bleibt beim Löschen stehen.

kubectl -n shop delete es shop-api
sleep 5
kubectl -n shop get secret shop-api-db
perl -pe 's/^(    name: shop-api-db)$/$1\n    creationPolicy: Orphan/' \
  ~/secrets-lab/tag03/es-api.yaml | kubectl apply -f -
sleep 3
kubectl -n shop get secret shop-api-db -o jsonpath='{.metadata.ownerReferences}{"\n"}'
kubectl -n shop delete es shop-api
kubectl -n shop get secret shop-api-db

Erwartet:

externalsecret.external-secrets.io "shop-api" deleted from shop namespace
Error from server (NotFound): secrets "shop-api-db" not found
externalsecret.external-secrets.io/shop-api created

externalsecret.external-secrets.io "shop-api" deleted from shop namespace
NAME          TYPE     DATA   AGE
shop-api-db   Opaque   2      10s

Orphan setzt keine ownerReferences. Nützlich bei Migrationen, gefährlich als Dauerzustand: Niemand räumt die Kopie mehr weg. Stell den Stand aus Tag 3 wieder her:

kubectl -n shop delete secret shop-api-db
kubectl apply -f ~/secrets-lab/tag03/es-api.yaml

Erwartet:

secret "shop-api-db" deleted from shop namespace
externalsecret.external-secrets.io/shop-api created

Merge mischt Keys in ein vorhandenes Secret, legt aber keins an:

cat > es-merge.yaml <<'EOF'
# Tag 4: creationPolicy Merge – Keys in ein vorhandenes Secret einmischen
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: shop-settings
  namespace: shop
spec:
  refreshInterval: 1m
  secretStoreRef:
    kind: SecretStore
    name: openbao
  target:
    name: shop-settings
    creationPolicy: Merge
  data:
    - secretKey: STRIPE_TOKEN
      remoteRef:
        key: shop/stripe
        property: token
EOF
kubectl apply -f es-merge.yaml; sleep 3
kubectl -n shop get es shop-settings -o jsonpath='{.status.conditions[0].message}{"\n"}'
kubectl -n shop create secret generic shop-settings --from-literal=LOG_LEVEL=debug
kubectl -n shop annotate es shop-settings force-sync="$(date +%s)" --overwrite
sleep 3
kubectl -n shop get secret shop-settings -o json | jq -c '.data | map_values(@base64d)'

Erwartet:

externalsecret.external-secrets.io/shop-settings created
secret will not be created due to CreationPolicy=Merge
secret/shop-settings created
externalsecret.external-secrets.io/shop-settings annotated
{"LOG_LEVEL":"debug","STRIPE_TOKEN":"lab-stripe-789"}

Der Status dazu heißt SecretMissing. Weitere Werte: None (nichts schreiben) und CreateOrMerge (anlegen oder einmischen).

deletionPolicy greift, wenn das Secret in OpenBao verschwindet: Retain (Standard) behält das Kubernetes-Secret, Delete löscht es mit.

cat > es-feature.yaml <<'EOF'
# Tag 4: deletionPolicy Delete – K8s-Secret verschwindet mit dem OpenBao-Secret
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: shop-feature
  namespace: shop
spec:
  refreshInterval: 1m
  secretStoreRef:
    kind: SecretStore
    name: openbao
  target:
    name: shop-feature
    creationPolicy: Owner
    deletionPolicy: Delete
  dataFrom:
    - extract:
        key: shop/feature
EOF
bao kv put secret/shop/feature new_checkout=true >/dev/null
kubectl apply -f es-feature.yaml; sleep 3
kubectl -n shop get secret shop-feature
bao kv metadata delete secret/shop/feature
kubectl -n shop annotate es shop-feature force-sync="$(date +%s)" --overwrite
sleep 3
kubectl -n shop get secret shop-feature
kubectl -n shop get events --field-selector involvedObject.name=shop-feature \
  -o jsonpath='{range .items[*]}{.reason}: {.message}{"\n"}{end}'

Erwartet:

externalsecret.external-secrets.io/shop-feature created
NAME           TYPE     DATA   AGE
shop-feature   Opaque   1      3s
Success! Data deleted (if it existed) at: secret/metadata/shop/feature
externalsecret.external-secrets.io/shop-feature annotated
Error from server (NotFound): secrets "shop-feature" not found
Created: secret created
MissingProviderSecret: secret does not exist at provider using spec.dataFrom[0]
Deleted: secret deleted due to DeletionPolicy=Delete

Mit Retain bleibt das Secret stehen, das ExternalSecret meldet SecretSyncedError mit err: Secret does not exist. Die Apps laufen mit dem letzten Stand weiter. Das ist für Passwörter fast immer das, was du willst.

kubectl -n shop delete es shop-feature shop-settings
kubectl -n shop delete secret shop-settings

Erwartet:

externalsecret.external-secrets.io "shop-feature" deleted from shop namespace
externalsecret.external-secrets.io "shop-settings" deleted from shop namespace
secret "shop-settings" deleted from shop namespace

Fortschritt speichern? Kostenlos registrieren

Drill 4: Mehrmandanten – ClusterSecretStore absichern

Der ClusterSecretStore openbao-shop aus Tag 3 ist offen. Ein fremder Namespace probiert es:

kubectl create namespace fremd
cat > es-fremd.yaml <<'EOF'
# Tag 4: Versuch aus fremdem Namespace über den ClusterSecretStore
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: klau-stripe
  namespace: fremd
spec:
  refreshInterval: 1m
  secretStoreRef:
    kind: ClusterSecretStore
    name: openbao-shop
  target:
    name: klau-stripe
  data:
    - secretKey: STRIPE_TOKEN
      remoteRef:
        key: shop/stripe
        property: token
EOF
kubectl apply -f es-fremd.yaml; sleep 3
kubectl -n fremd get secret klau-stripe -o jsonpath='{.data.STRIPE_TOKEN}' | base64 -d
echo

Erwartet:

namespace/fremd created
externalsecret.external-secrets.io/klau-stripe created
lab-stripe-789

Treffer. Der Store meldet sich immer als shop-api an, egal wer fragt. Abhilfe: conditions mit namespaceSelector (alternativ namespaces oder namespaceRegexes).

cat > clustersecretstore-conditions.yaml <<'EOF'
# Tag 4: ClusterSecretStore nur für Namespaces mit Label team=shop
apiVersion: external-secrets.io/v1
kind: ClusterSecretStore
metadata:
  name: openbao-shop
spec:
  conditions:
    - namespaceSelector:
        matchLabels:
          team: shop
  provider:
    vault:
      server: http://openbao.openbao.svc:8200
      path: secret
      version: v2
      auth:
        kubernetes:
          mountPath: kubernetes
          role: shop-api
          serviceAccountRef:
            name: shop-api
            namespace: shop
            audiences:
              - openbao
EOF
kubectl label namespace shop team=shop
kubectl apply -f clustersecretstore-conditions.yaml
kubectl -n fremd annotate es klau-stripe force-sync="$(date +%s)" --overwrite
kubectl -n shop annotate es shop-stripe force-sync="$(date +%s)" --overwrite
sleep 3
C='NS:.metadata.namespace,NAME:.metadata.name,STATUS:.status.conditions[0].reason'
kubectl get es -A -o custom-columns="$C" | grep -E '^NS|stripe'
kubectl -n fremd get events --field-selector involvedObject.name=klau-stripe \
  -o jsonpath='{range .items[*]}{.reason}: {.message}{"\n"}{end}'
kubectl -n fremd get secret klau-stripe

Erwartet:

namespace/shop labeled
clustersecretstore.external-secrets.io/openbao-shop configured
externalsecret.external-secrets.io/klau-stripe annotated
externalsecret.external-secrets.io/shop-stripe annotated
NS      NAME          STATUS
fremd   klau-stripe   SecretSyncedError
shop    shop-stripe   SecretSynced
Created: secret created
UpdateFailed: error processing spec.data[0] (key: shop/stripe), err: using cluster
store "openbao-shop" is not allowed from namespace "fremd": denied by spec.condition
NAME          TYPE     DATA   AGE
klau-stripe   Opaque   1      11s

Gesperrt, aber die schon kopierte Kopie bleibt liegen. Aufräumen gehört zur Reaktion.

Achtung: Wer Namespaces labeln darf, kommt mit team=shop wieder rein. Der Label ist nur so stark wie das RBAC auf namespaces.

Das robustere Muster: ein SecretStore pro Namespace mit eigenem ServiceAccount. Die Grenze zieht dann OpenBao selbst.

cat > secretstore-fremd.yaml <<'EOF'
# Tag 4: SecretStore im NS fremd – eigener ServiceAccount, fremde Rolle shop-api
apiVersion: external-secrets.io/v1
kind: SecretStore
metadata:
  name: openbao
  namespace: fremd
spec:
  provider:
    vault:
      server: http://openbao.openbao.svc:8200
      path: secret
      version: v2
      auth:
        kubernetes:
          mountPath: kubernetes
          role: shop-api
          serviceAccountRef:
            name: default
            audiences:
              - openbao
EOF
kubectl apply -f secretstore-fremd.yaml; sleep 3
kubectl -n fremd get ss openbao
kubectl -n fremd get events --field-selector involvedObject.kind=SecretStore \
  -o jsonpath='{.items[0].message}'

Erwartet:

secretstore.external-secrets.io/openbao created
NAME      AGE   STATUS                  CAPABILITIES   READY
openbao   3s    InvalidProviderConfig                  False
unable to log in to auth method: unable to log in with Kubernetes auth: Error making
API request.

URL: PUT http://openbao.openbao.svc:8200/v1/auth/kubernetes/login
Code: 403. Errors:

* service account name not authorized

Die Rolle shop-api bindet nur SA shop-api in NS shop. Ein SecretStore kann nur ServiceAccounts aus seinem eigenen Namespace nutzen. serviceAccountRef.namespace wird dort ignoriert.

kubectl delete namespace fremd

Erwartet:

namespace "fremd" deleted

Fortschritt speichern? Kostenlos registrieren

Drill 5: PushSecret – Kubernetes nach OpenBao

Ein Webhook-Signing-Key entsteht im Cluster und soll nach OpenBao. Dafür bekommt ein eigener ServiceAccount eine Schreibrolle, eng auf einen Pfad. Erst der naheliegende Versuch:

cat > shop-pusher.hcl <<'EOF'
# Tag 4: erster Versuch – zu knapp, Metadaten dürfen nicht geschrieben werden
path "secret/data/shop/webhook" {
  capabilities = ["create", "update", "read", "delete"]
}
path "secret/metadata/shop/webhook" {
  capabilities = ["read", "delete"]
}
EOF
bao policy write shop-pusher shop-pusher.hcl
bao write auth/kubernetes/role/shop-pusher bound_service_account_names=shop-pusher \
  bound_service_account_namespaces=shop audience=openbao \
  token_policies=shop-pusher token_ttl=15m
kubectl -n shop create serviceaccount shop-pusher
kubectl -n shop create secret generic shop-webhook \
  --from-literal=signing_key=lab-whsec-555

Erwartet:

Success! Uploaded policy: shop-pusher
Success! Data written to: auth/kubernetes/role/shop-pusher
serviceaccount/shop-pusher created
secret/shop-webhook created
cat > secretstore-push.yaml <<'EOF'
# Tag 4: eigener SecretStore mit Schreibrolle für PushSecret
apiVersion: external-secrets.io/v1
kind: SecretStore
metadata:
  name: openbao-push
  namespace: shop
spec:
  provider:
    vault:
      server: http://openbao.openbao.svc:8200
      path: secret
      version: v2
      auth:
        kubernetes:
          mountPath: kubernetes
          role: shop-pusher
          serviceAccountRef:
            name: shop-pusher
            audiences:
              - openbao
EOF
cat > pushsecret.yaml <<'EOF'
# Tag 4: PushSecret – K8s-Secret shop-webhook nach OpenBao secret/shop/webhook
apiVersion: external-secrets.io/v1alpha1
kind: PushSecret
metadata:
  name: shop-webhook
  namespace: shop
spec:
  refreshInterval: 1m
  deletionPolicy: Delete
  secretStoreRefs:
    - kind: SecretStore
      name: openbao-push
  selector:
    secret:
      name: shop-webhook
  data:
    - match:
        secretKey: signing_key
        remoteRef:
          remoteKey: shop/webhook
          property: signing_key
EOF
kubectl apply -f secretstore-push.yaml -f pushsecret.yaml; sleep 4
kubectl -n shop get pushsecret
kubectl -n shop get events --field-selector involvedObject.kind=PushSecret \
  -o jsonpath='{.items[0].message}'

Erwartet:

secretstore.external-secrets.io/openbao-push created
pushsecret.external-secrets.io/shop-webhook created
NAME           AGE   STATUS    LAST SYNC
shop-webhook   4s    Errored
set secret failed: could not write remote ref signing_key to target secretstore
openbao-push: Error making API request.

URL: PUT http://openbao.openbao.svc:8200/v1/secret/metadata/shop/webhook
Code: 403. Errors:

* 1 error occurred:
    * permission denied

ESO markiert jedes Secret, das es schreibt, über custom_metadata (managed-by). Es überschreibt nie ein fremdes Secret. Dafür braucht es Schreibrechte auf metadata/.

cat > shop-pusher.hcl <<'EOF'
# Tag 4: Schreibrechte nur für secret/shop/webhook (PushSecret)
path "secret/data/shop/webhook" {
  capabilities = ["create", "update", "read", "delete"]
}
# ESO markiert das Secret per custom_metadata (managed-by) als seins
path "secret/metadata/shop/webhook" {
  capabilities = ["create", "update", "read", "delete"]
}
EOF
bao policy write shop-pusher shop-pusher.hcl
kubectl -n shop annotate pushsecret shop-webhook force-sync="$(date +%s)" --overwrite
sleep 4
kubectl -n shop get pushsecret
bao kv get secret/shop/webhook

Erwartet:

Success! Uploaded policy: shop-pusher
pushsecret.external-secrets.io/shop-webhook annotated
NAME           AGE   STATUS   LAST SYNC
shop-webhook   17s   Synced   4s
====== Secret Path ======
secret/data/shop/webhook

======= Metadata =======
Key                Value
---                -----
created_time       2026-10-12T07:25:24.44766Z
custom_metadata    map[managed-by:external-secrets]
...
======= Data =======
Key            Value
---            -----
signing_key    lab-whsec-555

Ändert sich das Kubernetes-Secret, schiebt ESO beim nächsten Refresh nach. Mit deletionPolicy: Delete verschwindet der Wert beim Löschen des PushSecret auch aus OpenBao:

kubectl -n shop create secret generic shop-webhook \
  --from-literal=signing_key=lab-whsec-556 --dry-run=client -o yaml \
  | kubectl replace -f -
date +%T
until [ "$(bao kv get -field=signing_key secret/shop/webhook)" = lab-whsec-556 ]; do
  sleep 5; done; date +%T
kubectl -n shop delete pushsecret shop-webhook
bao kv get secret/shop/webhook

Erwartet (Wartezeit bis zu einer Minute):

secret/shop-webhook replaced
12:16:14
12:17:05
pushsecret.external-secrets.io "shop-webhook" deleted from shop namespace
No value found at secret/data/shop/webhook

Sicherheit: PushSecret dreht die Richtung um: Wer im Namespace Secrets anlegen darf, schreibt nach OpenBao. Rolle und Policy daher pfadgenau halten wie hier.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Generator VaultDynamicSecret – dynamische DB-Credentials

Ein Generator ruft bei jedem Refresh einen OpenBao-Pfad auf und schreibt die Antwort ins Secret. Mit der Database-Engine heißt das: frischer Postgres-User je Refresh.

cat > postgres.yaml <<'EOF'
# Tag 4: Lab-Postgres im NS shop (Passwort lab-pg-pw – nur Lab!)
apiVersion: apps/v1
kind: Deployment
metadata:
  name: postgres
  namespace: shop
spec:
  replicas: 1
  selector:
    matchLabels:
      app: postgres
  template:
    metadata:
      labels:
        app: postgres
    spec:
      containers:
        - name: postgres
          image: postgres:16-alpine
          env:
            - name: POSTGRES_PASSWORD
              value: lab-pg-pw
            - name: POSTGRES_DB
              value: shop
          ports:
            - containerPort: 5432
          readinessProbe:
            exec:
              command: ["pg_isready", "-U", "postgres"]
            periodSeconds: 3
---
apiVersion: v1
kind: Service
metadata:
  name: postgres
  namespace: shop
spec:
  selector:
    app: postgres
  ports:
    - port: 5432
EOF
kubectl apply -f postgres.yaml
kubectl -n shop rollout status deploy/postgres --timeout=180s

Erwartet (gekürzt, kann je nach Version abweichen):

deployment.apps/postgres created
service/postgres created
Waiting for deployment "postgres" rollout to finish: 0 of 1 updated replicas are
available...
deployment "postgres" successfully rolled out

Jetzt die Database-Engine. OpenBao läuft im Cluster und erreicht Postgres über den Service-Namen.

bao secrets enable database
PGURL='postgresql://{{username}}:{{password}}@postgres.shop.svc:5432'
bao write database/config/shop-pg plugin_name=postgresql-database-plugin \
  connection_url="$PGURL/shop?sslmode=disable" \
  username=postgres password=lab-pg-pw allowed_roles=shop-ro
bao write database/roles/shop-ro db_name=shop-pg default_ttl=10m max_ttl=1h \
  creation_statements="CREATE ROLE \"{{name}}\" WITH LOGIN PASSWORD '{{password}}' \
VALID UNTIL '{{expiration}}'; GRANT pg_read_all_data TO \"{{name}}\";"
bao read database/creds/shop-ro

Erwartet:

Success! Enabled the database secrets engine at: database/
Success! Data written to: database/config/shop-pg
Success! Data written to: database/roles/shop-ro
Key                Value
---                -----
lease_id           database/creds/shop-ro/RBjsmRH6t8TfDBMnvYTgFton
lease_duration     10m
lease_renewable    true
password           -HN2otVWI1NvsfaLsTiZ
username           v-token-shop-ro-i6wacejBwTnbpAildeeN-1791790032

Eine eigene Rolle shop-db (gleicher ServiceAccount, eigene Policy) hält die Berechtigungen getrennt von shop-api-read:

cat > shop-db.hcl <<'EOF'
# Tag 4: dynamische DB-Credentials lesen
path "database/creds/shop-ro" {
  capabilities = ["read"]
}
EOF
bao policy write shop-db shop-db.hcl
bao write auth/kubernetes/role/shop-db bound_service_account_names=shop-api \
  bound_service_account_namespaces=shop audience=openbao \
  token_policies=shop-db token_ttl=15m
cat > generator-db.yaml <<'EOF'
# Tag 4: Generator VaultDynamicSecret – holt bei jedem Refresh neue DB-Credentials
apiVersion: generators.external-secrets.io/v1alpha1
kind: VaultDynamicSecret
metadata:
  name: shop-db-creds
  namespace: shop
spec:
  path: database/creds/shop-ro
  method: GET
  provider:
    server: http://openbao.openbao.svc:8200
    auth:
      kubernetes:
        mountPath: kubernetes
        role: shop-db
        serviceAccountRef:
          name: shop-api
          audiences:
            - openbao
---
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: shop-db-dynamic
  namespace: shop
spec:
  refreshInterval: 2m
  target:
    name: shop-db-dynamic
  dataFrom:
    - sourceRef:
        generatorRef:
          apiVersion: generators.external-secrets.io/v1alpha1
          kind: VaultDynamicSecret
          name: shop-db-creds
EOF
kubectl apply -f generator-db.yaml; sleep 5
kubectl -n shop get es shop-db-dynamic
kubectl -n shop get secret shop-db-dynamic -o json \
  | jq -r '.data | map_values(@base64d)'

Erwartet:

Success! Uploaded policy: shop-db
Success! Data written to: auth/kubernetes/role/shop-db
vaultdynamicsecret.generators.external-secrets.io/shop-db-creds created
externalsecret.external-secrets.io/shop-db-dynamic created
NAME              STORETYPE   STORE   REFRESH INTERVAL   STATUS         READY   ...
shop-db-dynamic                       2m                 SecretSynced   True    ...
{
  "password": "EaPIHvVbi-uNT9n2pkpW",
  "username": "v-kubernet-shop-ro-BoWH1I1SFCgh6wQ5Jh37-1791790038"
}

Kein secretStoreRef: Der Generator bringt seinen Provider selbst mit. resultType (Standard Data) nimmt den data-Teil der OpenBao-Antwort. Der Login klappt?

get() { kubectl -n shop get secret shop-db-dynamic -o jsonpath="{.data.$1}" \
  | base64 -d; }
U=$(get username); P=$(get password)
kubectl -n shop exec deploy/postgres -- env PGPASSWORD="$P" \
  psql -h 127.0.0.1 -U "$U" -d shop -tAc 'select current_user'

Erwartet:

v-kubernet-shop-ro-BoWH1I1SFCgh6wQ5Jh37-1791790038

Warte gut zwei Minuten und lies username erneut: Es ist ein neuer User. Die alten Leases räumt ESO nicht weg, sie laufen über default_ttl aus:

bao list sys/leases/lookup/database/creds/shop-ro | tail -n +3 | wc -l

Erwartet (wächst mit jedem Refresh, bis die ersten Leases ablaufen):

      5

Achtung: refreshInterval und default_ttl gehören zusammen. Ist der Refresh länger als die TTL, nutzt die App abgelaufene Credentials. Ist er viel kürzer, stapeln sich DB-User. Faustregel: Refresh bei etwa der Hälfte der TTL, Pods müssen neue Werte übernehmen (Tag 9). Lease-Renewal statt Neuerzeugung kann der Agent (Tag 7).

Fortschritt speichern? Kostenlos registrieren

Drill 7: Typische Fehler und ihre Meldungen

Drei Klassiker, jeweils mit echter Meldung. Erst die Audience:

cat > fehler-audience.yaml <<'EOF'
# Tag 4 (Fehler 1): SecretStore ohne passende Audience
apiVersion: external-secrets.io/v1
kind: SecretStore
metadata:
  name: kaputt-audience
  namespace: shop
spec:
  provider:
    vault:
      server: http://openbao.openbao.svc:8200
      path: secret
      version: v2
      auth:
        kubernetes:
          mountPath: kubernetes
          role: shop-api
          serviceAccountRef:
            name: shop-api
EOF
kubectl apply -f fehler-audience.yaml; sleep 4
kubectl -n shop get ss kaputt-audience
kubectl -n shop get events --field-selector involvedObject.name=kaputt-audience \
  -o jsonpath='{.items[0].message}'

Erwartet:

secretstore.external-secrets.io/kaputt-audience created
NAME              AGE   STATUS                  CAPABILITIES   READY
kaputt-audience   5s    InvalidProviderConfig                  False
unable to log in to auth method: unable to log in with Kubernetes auth: Error making
API request.

URL: PUT http://openbao.openbao.svc:8200/v1/auth/kubernetes/login
Code: 403. Errors:

* invalid audience (aud) claim: audience claim does not match any expected audience

Ohne audiences trägt das Token die Standard-Audience des API-Servers, die Rolle erwartet openbao.

Dann KV v1 gegen einen KV-v2-Mount und ein Pfad außerhalb der Policy:

cat > fehler-kv-version.yaml <<'EOF'
# Tag 4 (Fehler 2): KV-Version v1 gegen einen KV-v2-Mount
apiVersion: external-secrets.io/v1
kind: SecretStore
metadata:
  name: kaputt-kv1
  namespace: shop
spec:
  provider:
    vault:
      server: http://openbao.openbao.svc:8200
      path: secret
      version: v1
      auth:
        kubernetes:
          mountPath: kubernetes
          role: shop-api
          serviceAccountRef:
            name: shop-api
            audiences:
              - openbao
---
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: kaputt-kv1
  namespace: shop
spec:
  refreshInterval: 1m
  secretStoreRef:
    kind: SecretStore
    name: kaputt-kv1
  target:
    name: kaputt-kv1
  dataFrom:
    - extract:
        key: shop/api
EOF
cat > fehler-policy.yaml <<'EOF'
# Tag 4 (Fehler 3): Pfad außerhalb der Policy shop-api-read
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: kaputt-policy
  namespace: shop
spec:
  refreshInterval: 1m
  secretStoreRef:
    kind: SecretStore
    name: openbao
  target:
    name: kaputt-policy
  dataFrom:
    - extract:
        key: ci/deploy
EOF
bao kv put secret/ci/deploy registry_password=lab-reg-pw \
  kubeconfig_token=lab-kube-token >/dev/null
kubectl apply -f fehler-kv-version.yaml -f fehler-policy.yaml; sleep 5
kubectl -n shop get ss kaputt-kv1
kubectl -n shop get es kaputt-kv1 kaputt-policy
for es in kaputt-kv1 kaputt-policy; do
  kubectl -n shop get events \
    --field-selector involvedObject.name=$es,reason=UpdateFailed \
    -o jsonpath='{.items[-1:].message}' | grep -E 'URL|denied'
done

Erwartet:

secretstore.external-secrets.io/kaputt-kv1 created
externalsecret.external-secrets.io/kaputt-kv1 created
externalsecret.external-secrets.io/kaputt-policy created
NAME         AGE   STATUS   CAPABILITIES   READY
kaputt-kv1   5s    Valid    ReadWrite      True
NAME            STORETYPE     STORE        REFRESH INTERVAL   STATUS              READY
kaputt-kv1      SecretStore   kaputt-kv1   1m                 SecretSyncedError   False
kaputt-policy   SecretStore   openbao      1m                 SecretSyncedError   False
URL: GET http://openbao.openbao.svc:8200/v1/secret/shop/api
    * permission denied
URL: GET http://openbao.openbao.svc:8200/v1/secret/data/ci/deploy
    * permission denied

Beide enden in permission denied, die URL verrät den Unterschied: Bei v1 fehlt data/ im Pfad, der Store selbst ist trotzdem Valid. Lies bei 403 also immer zuerst die URL.

Symptom Ursache Fix
Store InvalidProviderConfig, invalid audience audiences fehlt/falsch audiences: [openbao]
Store InvalidProviderConfig, not authorized SA/NS passt nicht zur Rolle Rolle oder SA korrigieren
ES 403, URL ohne data/ version: v1 auf KV v2 version: v2
ES 403, URL mit data/ Policy deckt Pfad nicht Policy erweitern
kubectl delete -f fehler-audience.yaml -f fehler-kv-version.yaml -f fehler-policy.yaml

Erwartet:

secretstore.external-secrets.io "kaputt-audience" deleted from shop namespace
secretstore.external-secrets.io "kaputt-kv1" deleted from shop namespace
externalsecret.external-secrets.io "kaputt-kv1" deleted from shop namespace
externalsecret.external-secrets.io "kaputt-policy" deleted from shop namespace

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
for es in shop-config shop-registry shop-db-dynamic; do
  [ "$(kubectl -n shop get es $es -o jsonpath='{.status.conditions[0].reason}')" \
    = SecretSynced ] && ok "ExternalSecret $es synchron" || nok "$es nicht synchron"
done
[ "$(kubectl -n shop get secret shop-registry -o jsonpath='{.type}')" \
  = kubernetes.io/dockerconfigjson ] && ok "Pull-Secret-Typ" || nok "Pull-Secret-Typ"
kubectl get css openbao-shop -o jsonpath='{.spec.conditions}' | grep -q team \
  && ok "ClusterSecretStore mit conditions" || nok "ClusterSecretStore offen"
bao policy read shop-pusher | grep -A1 'metadata/shop/webhook' | grep -q create \
  && ok "Policy shop-pusher darf Metadaten schreiben" || nok "shop-pusher zu knapp"
U=$(kubectl -n shop get secret shop-db-dynamic -o jsonpath='{.data.username}' \
  | base64 -d)
case "$U" in v-*shop-ro-*) ok "dynamischer DB-User $U";; *) nok "kein DB-User";; esac

Challenge

Die App will statt username/password einen fertigen DATABASE_URL. Bau ein ExternalSecret shop-database-url, das aus dem Generator shop-db-creds die URL postgresql://<user>:<pass>@postgres.shop.svc:5432/shop?sslmode=disable rendert und alle 5 Minuten erneuert.

Hinweis: Generator (sourceRef.generatorRef) und target.template lassen sich kombinieren. Für Sonderzeichen im Passwort gibt es urlquery.

Lösung

cat > challenge-database-url.yaml <<'EOF'
# Tag 4 Challenge: DATABASE_URL aus dynamischen Credentials rendern
apiVersion: external-secrets.io/v1
kind: ExternalSecret
metadata:
  name: shop-database-url
  namespace: shop
spec:
  refreshInterval: 5m
  target:
    name: shop-database-url
    template:
      engineVersion: v2
      data:
        DATABASE_URL: |-
          postgresql://{{ .username }}:{{ .password | urlquery -}}
          @postgres.shop.svc:5432/shop?sslmode=disable
  dataFrom:
    - sourceRef:
        generatorRef:
          apiVersion: generators.external-secrets.io/v1alpha1
          kind: VaultDynamicSecret
          name: shop-db-creds
EOF
kubectl apply -f challenge-database-url.yaml; sleep 4
kubectl -n shop get secret shop-database-url -o jsonpath='{.data.DATABASE_URL}' \
  | base64 -d; echo

Erwartet (User und Passwort sind bei dir anders):

externalsecret.external-secrets.io/shop-database-url created
postgresql://v-kubernet-shop-ro-QSFe6pBtoFuRjmbhwzp1-1791799743:wBbYWkxBHIT-jFst8OeW@p
ostgres.shop.svc:5432/shop?sslmode=disable

Das -}} am Zeilenende frisst den Zeilenumbruch: So bleibt die YAML-Zeile kurz und die URL am Stück. Jede Spec-Änderung erzeugt übrigens sofort neue Credentials.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Mandanten: SecretStore pro Namespace mit eigener OpenBao-Rolle und eigenem SA. ClusterSecretStore nur mit conditions und RBAC, das Namespace-Labels schützt (z. B. per Kyverno).
  • PushSecret nur für klar definierte Pfade und mit eigener Rolle. Ohne managed-by-Check in der Policy kein Schreiben in fremde Bereiche.
  • Generatoren erzeugen bei jedem Refresh neue Credentials und räumen alte Leases nicht ab. TTLs und refreshInterval bewusst abstimmen, DB-User-Anzahl überwachen.
  • Templates sind Code: Reviews, Tests in Staging, Versionsstand von ESO pinnen. Die Template-Funktionen (Sprig) können sich zwischen Major-Versionen ändern.
  • Fehler zeigen sich als Events und Metriken (externalsecret_status_condition). Ohne Alarm merkt niemand, dass ein Secret seit Tagen nicht mehr synchronisiert.