Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 0: Das Trainingsgelände

Ziel: Werkzeuge prüfen, kind-Cluster secrets-lab mit OpenBao im Dev-Modus starten, Demo-Daten anlegen und den ersten Login als ServiceAccount shop-api schaffen. · 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-Token root, alles im Speicher.
  • Vom Laptop sprichst du über einen Port-Forward mit OpenBao (127.0.0.1:8200), aus dem Cluster über http://openbao.openbao.svc:8200.
  • seed.sh legt die Demo-Daten an, check.sh prüft das Gelände mit ✔/✘.
  • Nach jedem Neustart des OpenBao-Pods ist alles weg: dann seed.sh erneut.
 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 --version

Erwartet (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
ls

Erwartet:

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/setup

Erwartet:

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

Erwartet (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 pods

Erwartet (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:8200

Erwartet:

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 status

Erwartet (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.sh und lade sie mit source ~/secrets-lab/env.sh in 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.sh

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
bao kv get secret/shop/api

Erwartet (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 status

Erwartet (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/api

Erwartet:

✘ 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.sh

Fortschritt 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.sh

Erwartet (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_ADDR beginnt dann mit https://, dazu kommt BAO_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.sh entspricht 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.sh lohnen sich auch beim Kunden als Smoke-Test nach Upgrades.