Tag 0: Das Trainingsgelände
Ziel: Werkzeuge prüfen, kind-Cluster
secrets-labmit OpenBao im Dev-Modus starten, Demo-Daten anlegen und den ersten Login als ServiceAccountshop-apischaffen. · Dauer: ca. 45 min · Voraussetzung: keine
Briefing
- Ein kind-Cluster
secrets-lab, single-node. OpenBao läuft darin per Helm im Dev-Modus: kein Unseal, Root-Tokenroot, alles im Speicher. - Vom Laptop sprichst du über einen Port-Forward mit OpenBao
(
127.0.0.1:8200), aus dem Cluster überhttp://openbao.openbao.svc:8200. seed.shlegt die Demo-Daten an,check.shprüft das Gelände mit ✔/✘.- Nach jedem Neustart des OpenBao-Pods ist alles weg: dann
seed.sherneut.
Laptop kind-Cluster "secrets-lab"
┌────────────────────┐ port-forward ┌──────────────────────────────────┐
│ bao, curl, kubectl │ ──── :8200 ───► │ ns openbao │
│ ~/secrets-lab/ │ │ openbao-0 (Dev-Modus, inmem) │
│ setup/ tag01/ … │ │ openbao-agent-injector │
└────────────────────┘ │ ns shop │
│ ServiceAccount shop-api │
└──────────────────────────────────┘
Drill 1: Werkzeuge prüfen
docker info --format '{{.ServerVersion}} {{.MemTotal}}'
kind version
kubectl version --client | head -1
helm version --short
bao version
jq --versionErwartet (gekürzt, kann je nach Version abweichen):
29.5.2 8307167232
kind v0.33.0 go1.27.0 darwin/arm64
Client Version: v1.37.1
v4.3.0+gbec5b06
OpenBao v2.7.1 (a5db72cef75c…), committed 2026-10-01T15:32:54Z
jq-1.8.2
Die bao-CLI holst du dir als Binary aus den
GitHub-Releases von openbao/openbao oder über deinen
Paketmanager. Die vault-CLI spricht zwar dieselbe API, im
Buch nutzen wir aber durchgehend bao.
Tipp: Gib Docker mindestens 4 GB RAM. kind plus OpenBao braucht etwa 1 GB, ab Teil B kommen ESO, CSI-Treiber und Postgres dazu.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Arbeitsverzeichnis und kind-Konfiguration
mkdir -p ~/secrets-lab/{setup,tag01,tag02}
cd ~/secrets-lab/setup
cat > kind.yaml <<'EOF'
kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
name: secrets-lab
nodes:
- role: control-plane
EOF
cat > openbao-values.yaml <<'EOF'
# Lab-Werte: OpenBao im Dev-Modus (In-Memory, Root-Token "root") – nie produktiv!
server:
dev:
enabled: true
devRootToken: "root"
dataStorage:
enabled: false
injector:
enabled: true
csi:
enabled: false # ab Tag 6: true
ui:
enabled: false
EOF
lsErwartet:
kind.yaml openbao-values.yaml
Warum dataStorage.enabled: false? Im Dev-Modus speichert
OpenBao nur im RAM, ein PersistentVolume wäre Ballast. Die UI bleibt
aus, du arbeitest mit CLI und curl. Den CSI-Provider schaltest du erst
an Tag 6 ein.
Den Begleitcode des Buchs holst du einmal von GitHub nach
~/secrets-lab/code. Ab Tag 5 holst du dir daraus die
Dateien des Tages, Tag 15 baut damit seinen Startzustand auf:
git clone https://github.com/thomaszachmann/openbao-secrets-zum-anfassen.git \
~/secrets-lab/code
ls ~/secrets-lab/code/setupErwartet:
Cloning into '…/secrets-lab/code'...
check.sh kind.yaml openbao-values.yaml seed.sh up.sh
~/secrets-lab/code/setup enthält genau die Dateien, die
du heute in ~/secrets-lab/setup anlegst. Tippen lohnt sich
trotzdem, die Kopie ist dein Abgleich
(diff -r ~/secrets-lab/code/setup ~/secrets-lab/setup nach
Drill 7).
Fortschritt speichern? Kostenlos registrieren
Drill 3: Cluster und OpenBao starten
up.sh ist idempotent: Es legt den Cluster nur an, wenn
er fehlt, und ruft sonst nur helm upgrade auf.
cat > up.sh <<'EOF'
#!/usr/bin/env bash
# Baut das Trainingsgelände: kind-Cluster secrets-lab + OpenBao (Dev-Modus) per Helm
set -euo pipefail
CLUSTER="${CLUSTER:-secrets-lab}"
DIR="$(cd "$(dirname "$0")" && pwd)"
kind get clusters | grep -qx "$CLUSTER" || kind create cluster --name "$CLUSTER" \
--config "$DIR/kind.yaml"
kubectl config use-context "kind-$CLUSTER" >/dev/null
helm repo add openbao https://openbao.github.io/openbao-helm >/dev/null 2>&1 || true
helm repo update openbao >/dev/null
# --server-side=false: der Injector patcht caBundle selbst; Server-Side-Apply (Helm-4-
# Standard) meldet sonst beim erneuten Lauf einen Konflikt
helm upgrade --install openbao openbao/openbao -n openbao --create-namespace \
--server-side=false -f "$DIR/openbao-values.yaml" --wait --timeout 5m
# Pod kann nach helm --wait noch fehlen (z. B. nach Neuinstallation)
kubectl -n openbao wait --for=create pod/openbao-0 --timeout=120s >/dev/null
kubectl -n openbao wait --for=condition=Ready pod/openbao-0 --timeout=180s
echo "✔ OpenBao läuft. Weiter: kubectl -n openbao port-forward svc/openbao 8200:8200"
EOF
chmod +x up.sh
./up.shErwartet (gekürzt, kann je nach Version abweichen):
Creating cluster "secrets-lab" ...
✓ Ensuring node image (kindest/node:v1.37.0) 🖼
...
Set kubectl context to "kind-secrets-lab"
Release "openbao" does not exist. Installing it now.
NAME: openbao
NAMESPACE: openbao
STATUS: deployed
...
pod/openbao-0 condition met
✔ OpenBao läuft. Weiter: kubectl -n openbao port-forward svc/openbao 8200:8200
helm list -n openbao
kubectl -n openbao get podsErwartet (gekürzt):
NAME NAMESPACE REVISION ... STATUS CHART APP VERSION
openbao openbao 1 ... deployed openbao-0.30.3 v2.7.1
NAME READY STATUS RESTARTS AGE
openbao-0 1/1 Running 0 60s
openbao-agent-injector-8cf8bbc95-kmgb5 1/1 Running 0 90s
Warum --server-side=false? Helm 4 nutzt standardmäßig
Server-Side Apply. Der Injector trägt sein CA-Bundle selbst in seine
MutatingWebhookConfiguration ein. Beim zweiten
helm upgrade meldet Helm dann einen Feldkonflikt mit dem
Feldmanager vault-k8s.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Port-Forward und erster Kontakt
Öffne ein zweites Terminal und lass den Port-Forward dort laufen:
kubectl -n openbao port-forward svc/openbao 8200:8200Erwartet:
Forwarding from 127.0.0.1:8200 -> 8200
Forwarding from [::1]:8200 -> 8200
Zurück im ersten Terminal:
export BAO_ADDR=http://127.0.0.1:8200
export BAO_TOKEN=root # Lab-Wert, nur im Dev-Modus!
bao statusErwartet (gekürzt):
Key Value
--- -----
Seal Type shamir
Initialized true
Sealed false
...
Version 2.7.1
Storage Type inmem
HA Enabled false
Storage Type inmem ist die wichtigste Zeile: Alles, was
du anlegst, lebt nur so lange wie der Pod openbao-0.
Tipp: Schreib die beiden
export-Zeilen in eine Datei~/secrets-lab/env.shund lade sie mitsource ~/secrets-lab/env.shin jedem neuen Terminal.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Demo-Daten anlegen
seed.sh legt alles an, was Teil A und B voraussetzen:
zwei KV-Secrets, die Policy shop-api-read, die
Kubernetes-Auth mit der Rolle shop-api und den Namespace
shop mit dem ServiceAccount shop-api.
cd ~/secrets-lab/setup
cat > seed.sh <<'EOF'
#!/usr/bin/env bash
# Legt die Demo-Daten an (Lab-Werte!). Voraussetzung: Port-Forward auf 8200 läuft.
set -euo pipefail
export BAO_ADDR="${BAO_ADDR:-http://127.0.0.1:8200}" BAO_TOKEN="${BAO_TOKEN:-root}"
bao kv put secret/shop/api db_user=shop db_password=lab-db-pw-123 \
api_key=lab-api-key-456 >/dev/null
bao kv put secret/shop/stripe token=lab-stripe-789 >/dev/null
bao policy write shop-api-read - <<'HCL'
path "secret/data/shop/*" {
capabilities = ["read"]
}
HCL
bao auth list -format=json | jq -e '."kubernetes/"' >/dev/null \
|| bao auth enable kubernetes
# OpenBao läuft im Cluster: CA und Reviewer-Token kommen aus dem eigenen Pod
bao write auth/kubernetes/config kubernetes_host="https://kubernetes.default.svc:443"
bao write auth/kubernetes/role/shop-api \
bound_service_account_names=shop-api \
bound_service_account_namespaces=shop \
audience=openbao \
token_policies=shop-api-read token_ttl=15m token_max_ttl=1h >/dev/null
kubectl create namespace shop --dry-run=client -o yaml | kubectl apply -f - >/dev/null
kubectl -n shop create serviceaccount shop-api --dry-run=client -o yaml \
| kubectl apply -f - >/dev/null
echo "✔ Demo-Daten, Policy shop-api-read, Rolle kubernetes/shop-api, NS shop angelegt"
EOF
chmod +x seed.sh
./seed.shErwartet:
Success! Uploaded policy: shop-api-read
Success! Enabled kubernetes auth method at: kubernetes/
Success! Data written to: auth/kubernetes/config
✔ Demo-Daten, Policy shop-api-read, Rolle kubernetes/shop-api, NS shop angelegt
bao kv get secret/shop/apiErwartet (gekürzt):
==== Secret Path ====
secret/data/shop/api
...
======= Data =======
Key Value
--- -----
api_key lab-api-key-456
db_password lab-db-pw-123
db_user shop
kubernetes_host zeigt auf den API-Server aus Sicht des
Pods. CA-Zertifikat und Reviewer-Token nimmt OpenBao aus seinem eigenen
ServiceAccount. Details folgen an Tag 2.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Erster Login als Maschine
Die eigentliche Frage des Buchs: Wie kommt ein Workload ohne gespeichertes Passwort an einen OpenBao-Token? Antwort: mit seinem ServiceAccount-Token.
JWT=$(kubectl -n shop create token shop-api --audience openbao)
bao write auth/kubernetes/login role=shop-api jwt="$JWT"Erwartet (gekürzt):
Key Value
--- -----
token s.9ya6Dbcx6f8SszcFg61AnReT
token_duration 15m
token_renewable true
token_policies ["default" "shop-api-read"]
token_meta_role shop-api
token_meta_service_account_name shop-api
token_meta_service_account_namespace shop
Kubernetes stellt einen kurzlebigen Token für shop-api
aus, OpenBao prüft ihn und gibt einen eigenen Token mit 15 Minuten
Laufzeit und der Policy shop-api-read zurück. Genau diesen
Ablauf machen ESO, Injector und CSI-Treiber später für dich.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Das Prüfskript check.sh
Dieses Skript nutzt du ab jetzt zu Beginn jedes Tages.
cd ~/secrets-lab/setup
cat > check.sh <<'EOF'
#!/usr/bin/env bash
# check.sh – prüft das Trainingsgelände (✔/✘). Exit-Code = Anzahl Fehler.
export BAO_ADDR="${BAO_ADDR:-http://127.0.0.1:8200}" BAO_TOKEN="${BAO_TOKEN:-root}"
fail=0
ok() { echo "✔ $1"; }
bad() { echo "✘ $1"; fail=$((fail + 1)); }
t() { if eval "$2" >/dev/null 2>&1; then ok "$1"; else bad "$1"; fi; }
t "kubectl-Kontext kind-${CLUSTER:-secrets-lab}" \
"[ \"\$(kubectl config current-context)\" = kind-${CLUSTER:-secrets-lab} ]"
t "Pod openbao-0 Ready" \
"kubectl -n openbao wait --for=condition=Ready pod/openbao-0 --timeout=5s"
t "OpenBao erreichbar unter $BAO_ADDR (Port-Forward?)" "bao status"
t "Demo-Secret secret/shop/api vorhanden (sonst: seed.sh)" \
"bao kv get -field=db_user secret/shop/api"
t "Policy shop-api-read vorhanden" "bao policy read shop-api-read"
t "Rolle auth/kubernetes/role/shop-api vorhanden" \
"bao read auth/kubernetes/role/shop-api"
t "ServiceAccount shop/shop-api vorhanden" "kubectl -n shop get sa shop-api"
t "Login als shop-api klappt" \
"bao write -field=token auth/kubernetes/login role=shop-api \
jwt=\"\$(kubectl -n shop create token shop-api --audience openbao)\""
exit "$fail"
EOF
chmod +x check.sh
./check.sh; echo "Fehler: $?"Erwartet:
✔ kubectl-Kontext kind-secrets-lab
✔ Pod openbao-0 Ready
✔ OpenBao erreichbar unter http://127.0.0.1:8200 (Port-Forward?)
✔ Demo-Secret secret/shop/api vorhanden (sonst: seed.sh)
✔ Policy shop-api-read vorhanden
✔ Rolle auth/kubernetes/role/shop-api vorhanden
✔ ServiceAccount shop/shop-api vorhanden
✔ Login als shop-api klappt
Fehler: 0
Fortschritt speichern? Kostenlos registrieren
Drill 8: Neustart, Datenverlust, Wiederaufbau
Dev-Modus heißt: Pod weg, Daten weg. Probier es aus, bevor es dich mitten in Tag 5 überrascht.
kubectl -n openbao delete pod openbao-0
kubectl -n openbao wait --for=condition=Ready pod/openbao-0 --timeout=180s
bao statusErwartet (gekürzt):
pod "openbao-0" deleted from openbao namespace
pod/openbao-0 condition met
Error checking seal status: Get "http://127.0.0.1:8200/v1/sys/seal-status": EOF
Der Port-Forward hing am alten Pod und ist tot. Starte ihn im zweiten Terminal neu, dann:
./check.sh | grep ✘
bao kv get secret/shop/apiErwartet:
✘ Demo-Secret secret/shop/api vorhanden (sonst: seed.sh)
✘ Policy shop-api-read vorhanden
✘ Rolle auth/kubernetes/role/shop-api vorhanden
✘ Login als shop-api klappt
No value found at secret/data/shop/api
Namespace und ServiceAccount leben in Kubernetes und haben überlebt, alles in OpenBao ist weg. Wiederaufbau:
./seed.sh && ./check.sh | grep -c ✔Erwartet:
Success! Uploaded policy: shop-api-read
Success! Enabled kubernetes auth method at: kubernetes/
Success! Data written to: auth/kubernetes/config
✔ Demo-Daten, Policy shop-api-read, Rolle kubernetes/shop-api, NS shop angelegt
8
Achtung: Dasselbe passiert nach einem Neustart von Docker oder des Laptops. Die Konfiguration aus späteren Tagen (Rollen, Mounts) legst du dann mit den Befehlen des jeweiligen Tages erneut an.
Aufräumen am Ende eines Tages oder für einen sauberen Neustart:
kind delete cluster --name secrets-lab
# Neustart: ./up.sh, Port-Forward, ./seed.sh, ./check.shFortschritt speichern? Kostenlos registrieren
Kontrollpunkt
cd ~/secrets-lab/setup
for f in kind.yaml openbao-values.yaml up.sh seed.sh check.sh; do
[ -s "$f" ] && echo "✔ $f vorhanden" || echo "✘ $f fehlt"
done
[ "$BAO_ADDR" = http://127.0.0.1:8200 ] && echo "✔ BAO_ADDR gesetzt" \
|| echo "✘ BAO_ADDR fehlt"
bao status -format=json 2>/dev/null | jq -e '.storage_type == "inmem"' >/dev/null \
&& echo "✔ OpenBao im Dev-Modus (inmem)" || echo "✘ OpenBao nicht erreichbar"
./check.sh >/dev/null && echo "✔ check.sh ohne Fehler" \
|| echo "✘ check.sh meldet Fehler"Challenge
Den Port-Forward nach jedem Pod-Neustart von Hand zu starten nervt.
Schreib ~/secrets-lab/setup/pf.sh: Läuft OpenBao auf
127.0.0.1:8200 schon, meldet es ✔. Sonst startet es den
Port-Forward im Hintergrund und wartet, bis bao status
antwortet.
Hinweis: bao status liefert Exit-Code
0, wenn OpenBao erreichbar und entsiegelt ist.
Lösung
cat > ~/secrets-lab/setup/pf.sh <<'EOF'
#!/usr/bin/env bash
# pf.sh – startet den Port-Forward zu OpenBao, falls er nicht schon läuft
export BAO_ADDR=http://127.0.0.1:8200
if bao status >/dev/null 2>&1; then echo "✔ Port-Forward läuft bereits"; exit 0; fi
kubectl -n openbao port-forward svc/openbao 8200:8200 >/tmp/bao-pf.log 2>&1 &
for _ in $(seq 1 20); do
if bao status >/dev/null 2>&1; then
echo "✔ Port-Forward gestartet (PID $!)"; exit 0
fi
sleep 0.5
done
echo "✘ kein Port-Forward – siehe /tmp/bao-pf.log"; exit 1
EOF
chmod +x ~/secrets-lab/setup/pf.sh
~/secrets-lab/setup/pf.sh; ~/secrets-lab/setup/pf.shErwartet (nach einem Pod-Neustart):
✔ Port-Forward gestartet (PID 30742)
✔ Port-Forward läuft bereits
Beenden mit pkill -f 'port-forward svc/openbao'.
Fortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Beim Kunden läuft OpenBao nicht im Dev-Modus, sondern mit TLS, Raft
und Auto-Unseal (siehe „OpenBao zum Anfassen”).
BAO_ADDRbeginnt dann mithttps://, dazu kommtBAO_CACERT. - Der Root-Token ist dort widerrufen. Admin-Arbeit läuft über
OIDC-Login von Menschen mit eigenen Policies, nicht über
BAO_TOKEN=root. - Statt Port-Forward erreichen Laptops und Pipelines OpenBao über Ingress, Route oder Load Balancer. Workloads im Cluster nutzen den internen Service.
seed.shentspricht in Produktion Terraform/OpenTofu oder einem GitOps-Repo für Mounts, Policies und Rollen (Tag 13). Secrets selbst gehören nie in dieses Repo.- Prüfskripte wie
check.shlohnen sich auch beim Kunden als Smoke-Test nach Upgrades.