Tag 8: Direkt aus der Anwendung
Ziel: Eine Anwendung holt ihre Secrets selbst aus OpenBao und hält ihren Token am Leben, per SDK oder mit
bao agentals Helfer. · Dauer: ca. 120 min · Voraussetzung: Tag 2
Briefing
- Ohne Operator und Sidecar ist die App selbst zuständig: Login, Lesen, Token erneuern und bei Ablauf neu einloggen.
- Kein Kubernetes-Secret, kein etcd: Das Secret lebt nur im Speicher des Prozesses.
- Der projizierte ServiceAccount-Token rotiert. Lies die Datei bei jedem Login neu.
bao agentnimmt der App den Login ab: als Prozess-Supervisor mit Env-Variablen oder als lokaler Proxy, der Anfragen ohne Token mit dem eigenen Token anreichert.
App (hvac / Go-SDK) ──login(JWT)──► auth/kubernetes ──► Token (ttl 30s, max 2m)
│ renew-self, solange max_ttl nicht erreicht; danach neu einloggen
└──GET secret/data/shop/api──► Secret nur im Prozess-Speicher
bao agent ──auto_auth──► Token ──► env_template ──► exec: Kindprozess (Neustart
└─► api_proxy :8100 bei Secret-Änderung)
Drill 1: Kurzlebige Rolle und ein JWT für den Laptop
Für die Drills reicht eine Rolle mit absichtlich kurzer TTL, damit
Renewal und Re-Login in wenigen Minuten sichtbar werden. Den JWT
erzeugst du per kubectl, so funktioniert derselbe Code auf
dem Laptop und im Pod.
mkdir -p ~/secrets-lab/tag08 && cd ~/secrets-lab/tag08
export BAO_ADDR=http://127.0.0.1:8200 BAO_TOKEN=root
bao write auth/kubernetes/role/shop-api-short \
bound_service_account_names=shop-api bound_service_account_namespaces=shop \
audience=openbao token_policies=shop-api-read token_ttl=30s token_max_ttl=2m
kubectl -n shop create token shop-api --audience=openbao --duration=1h > sa.jwt
jq -R -c 'split(".")[1] | gsub("-";"+") | gsub("_";"/") | @base64d | fromjson
| {aud, sub}' sa.jwtErwartet:
Success! Data written to: auth/kubernetes/role/shop-api-short
{"aud":["openbao"],"sub":"system:serviceaccount:shop:shop-api"}
Ohne --audience=openbao lehnt die Rolle den Token
ab:
bao write auth/kubernetes/login role=shop-api-short \
jwt="$(kubectl -n shop create token shop-api)"Erwartet (gekürzt):
Code: 403. Errors:
* invalid audience (aud) claim: audience claim does not match any expected audience
Fortschritt speichern? Kostenlos registrieren
Drill 2: Python mit hvac
hvac ist der Python-Client für die Vault-API und
funktioniert unverändert mit OpenBao (getestet: hvac 2.4.0 gegen OpenBao
2.7.1).
python3 -m venv .venv && . .venv/bin/activate
pip install -q hvac==2.4.0
cat > shop_app.py <<'EOF'
"""Lab-App: liest secret/shop/api aus OpenBao und hält den Token am Leben."""
import os
import sys
import time
import hvac
from hvac.exceptions import Forbidden, InvalidRequest
ADDR = os.environ.get("BAO_ADDR", "http://127.0.0.1:8200")
ROLE = os.environ.get("BAO_ROLE", "shop-api")
JWT_FILE = os.environ.get("BAO_JWT_FILE", "/var/run/secrets/openbao/token")
INTERVAL = int(os.environ.get("CHECK_INTERVAL", "10"))
def login(client):
"""Kubernetes-Auth: JWT bei jedem Login neu lesen, kubelet rotiert ihn."""
with open(JWT_FILE) as f:
jwt = f.read().strip()
auth = client.auth.kubernetes.login(role=ROLE, jwt=jwt)["auth"]
print(f"login: ttl={auth['lease_duration']}s "
f"policies={auth['token_policies']}", flush=True)
def read_secret(client):
resp = client.secrets.kv.v2.read_secret_version(
path="shop/api", mount_point="secret", raise_on_deleted_version=True)
return resp["data"]["data"], resp["data"]["metadata"]["version"]
def keep_alive(client):
"""Erneuern, solange es geht; sonst neu einloggen."""
ttl = client.auth.token.lookup_self()["data"]["ttl"]
if ttl > 2 * INTERVAL:
return
try:
new = client.auth.token.renew_self()["auth"]["lease_duration"]
print(f"renew: ttl {ttl}s -> {new}s", flush=True)
if new > 2 * INTERVAL:
return
print("max_ttl erreicht -> re-login", flush=True)
except (Forbidden, InvalidRequest) as err:
print(f"renew fehlgeschlagen ({err.__class__.__name__}) -> re-login",
flush=True)
login(client)
def main():
client = hvac.Client(url=ADDR)
login(client)
while True:
try:
keep_alive(client)
data, version = read_secret(client)
print(f"v{version} db_user={data['db_user']} "
f"db_password=***{data['db_password'][-3:]}", flush=True)
except Forbidden:
print("403 -> re-login", flush=True)
login(client)
except Exception as err: # Lab: weiterlaufen, aber laut sein
print(f"Fehler: {err}", file=sys.stderr, flush=True)
time.sleep(INTERVAL)
if __name__ == "__main__":
main()
EOF
BAO_JWT_FILE=sa.jwt BAO_ROLE=shop-api-short python shop_app.pyNach etwa 20 s rotierst du in einem zweiten Terminal das Passwort. Nach gut zwei Minuten beendest du die App mit Strg+C.
BAO_ADDR=http://127.0.0.1:8200 BAO_TOKEN=root \
bao kv patch secret/shop/api db_password=lab-db-pw-125Erwartet (gekürzt):
login: ttl=30s policies=['default', 'shop-api-read']
v2 db_user=shop db_password=***124
renew: ttl 20s -> 30s
v3 db_user=shop db_password=***125
renew: ttl 19s -> 30s
...
renew: ttl 19s -> 20s
max_ttl erreicht -> re-login
login: ttl=30s policies=['default', 'shop-api-read']
v3 db_user=shop db_password=***125
Die Versionsnummer hängt davon ab, wie oft du
secret/shop/api schon geändert hast. Drei Fälle, drei
Reaktionen: Renewal verlängert bis token_max_ttl. Ist das
Maximum erreicht, liefert Renewal nur noch die Restzeit, also folgt ein
neuer Login. Ein 403 (Token widerrufen) führt ebenfalls zum Re-Login.
Die Rotation kommt ohne Neustart an, weil die App bei jedem Durchlauf
liest.
Tipp: Außerhalb von Kubernetes ersetzt du nur
login(), etwa durchclient.auth.approle.login(role_id=..., secret_id=...)(AppRole, Tag 10). Der Rest bleibt gleich.
Fortschritt speichern? Kostenlos registrieren
Drill 3: hvac im Pod mit projiziertem Token
Im Pod kommt der JWT aus einem projizierten Volume mit passender Audience. Den Standard-API-Token braucht die App nicht, also schaltest du ihn ab.
kubectl -n shop create configmap shop-app-code --from-file=shop_app.py \
--dry-run=client -o yaml | kubectl apply -f -
cat > shop-api-py.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: shop-api-py
namespace: shop
spec:
replicas: 1
selector:
matchLabels: {app: shop-api-py}
template:
metadata:
labels: {app: shop-api-py}
spec:
serviceAccountName: shop-api
automountServiceAccountToken: false # API-Token braucht die App nicht
containers:
- name: app
image: python:3.13-alpine
# Lab-Abkürzung: hvac beim Start installieren (produktiv: ins Image bauen)
command: ["sh", "-c"]
args:
- pip install -q --root-user-action=ignore hvac==2.4.0
&& python -u /app/shop_app.py
env:
- {name: BAO_ADDR, value: "http://openbao.openbao.svc:8200"}
- {name: BAO_ROLE, value: "shop-api-short"}
volumeMounts:
- {name: code, mountPath: /app}
- {name: bao-token, mountPath: /var/run/secrets/openbao, readOnly: true}
volumes:
- name: code
configMap: {name: shop-app-code}
- name: bao-token
projected:
sources:
- serviceAccountToken:
path: token
audience: openbao # muss zur Rolle passen
expirationSeconds: 600 # kubelet erneuert rechtzeitig
EOF
kubectl apply -f shop-api-py.yaml
kubectl -n shop rollout status deploy/shop-api-py --timeout=180s
sleep 20; kubectl -n shop logs deploy/shop-api-py | head -4
kubectl -n shop exec deploy/shop-api-py -- \
sh -c 'ls /var/run/secrets; env | grep -c PASS'Erwartet:
configmap/shop-app-code created
deployment.apps/shop-api-py created
deployment "shop-api-py" successfully rolled out
login: ttl=30s policies=['default', 'shop-api-read']
v3 db_user=shop db_password=***125
renew: ttl 20s -> 30s
v3 db_user=shop db_password=***125
openbao
0
command terminated with exit code 1
Im Pod liegt nur der OpenBao-JWT, kein Kubernetes-API-Token, und
keine Env-Variable enthält ein Passwort. Exit-Code 1 kommt von
grep -c bei null Treffern.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Go mit dem offiziellen OpenBao-Client
Der Go-Client heißt github.com/openbao/openbao/api/v2,
die Auth-Helfer liegen in eigenen Modulen. LifetimeWatcher
erneuert den Token im Hintergrund und meldet über DoneCh(),
wenn nichts mehr geht.
mkdir -p ~/secrets-lab/tag08/go && cd ~/secrets-lab/tag08/go
go mod init example.com/shop-api
go get github.com/openbao/openbao/api/[email protected] \
github.com/openbao/openbao/api/auth/kubernetes/[email protected]Erwartet:
go: creating new go.mod: module example.com/shop-api
go: added github.com/openbao/openbao/api/auth/kubernetes/v2 v2.7.0
go: added github.com/openbao/openbao/api/v2 v2.7.1
Die Versionen der Auth-Module laufen nicht synchron mit dem Server.
go list -m -versions github.com/openbao/openbao/api/auth/kubernetes/v2
zeigt die verfügbaren.
cat > main.go <<'EOF'
// Lab-App: liest secret/shop/api und erneuert den Token per LifetimeWatcher.
package main
import (
"context"
"log"
"os"
"time"
k8s "github.com/openbao/openbao/api/auth/kubernetes/v2"
bao "github.com/openbao/openbao/api/v2"
)
func env(key, def string) string {
if v := os.Getenv(key); v != "" {
return v
}
return def
}
// login: Kubernetes-Auth; der Helper liest die JWT-Datei bei jedem Aufruf neu.
func login(ctx context.Context, c *bao.Client) (*bao.Secret, error) {
m, err := k8s.NewKubernetesAuth(env("BAO_ROLE", "shop-api"),
k8s.WithServiceAccountTokenPath(
env("BAO_JWT_FILE", "/var/run/secrets/openbao/token")))
if err != nil {
return nil, err
}
s, err := c.Auth().Login(ctx, m) // setzt den Token im Client
if err != nil {
return nil, err
}
log.Printf("login: ttl=%ds policies=%v", s.Auth.LeaseDuration,
s.Auth.Policies)
return s, nil
}
func readSecret(ctx context.Context, c *bao.Client) {
kv, err := c.KVv2("secret").Get(ctx, "shop/api")
if err != nil {
log.Printf("read: %v", err)
return
}
pw, _ := kv.Data["db_password"].(string)
if len(pw) > 3 {
pw = pw[len(pw)-3:]
}
log.Printf("v%d db_user=%v db_password=***%s",
kv.VersionMetadata.Version, kv.Data["db_user"], pw)
}
func main() {
ctx := context.Background()
c, err := bao.NewClient(bao.DefaultConfig()) // liest BAO_ADDR
if err != nil {
log.Fatal(err)
}
tick := time.NewTicker(10 * time.Second)
for { // äußere Schleife: (re-)login
s, err := login(ctx, c)
if err != nil {
log.Printf("login: %v", err)
time.Sleep(5 * time.Second)
continue
}
w, err := c.NewLifetimeWatcher(&bao.LifetimeWatcherInput{Secret: s})
if err != nil {
log.Fatal(err)
}
go w.Start()
readSecret(ctx, c)
watch:
for {
select {
case err := <-w.DoneCh(): // max_ttl erreicht oder Fehler
log.Printf("watcher done (err=%v) -> re-login", err)
break watch
case r := <-w.RenewCh():
log.Printf("renewed: ttl=%ds", r.Secret.Auth.LeaseDuration)
case <-tick.C:
readSecret(ctx, c)
}
}
w.Stop()
}
}
EOF
go vet . && BAO_JWT_FILE=../sa.jwt BAO_ROLE=shop-api-short go run .Nach gut zwei Minuten mit Strg+C beenden.
Erwartet (gekürzt):
2026/10/12 08:48:48 login: ttl=30s policies=[default shop-api-read]
2026/10/12 08:48:48 v2 db_user=shop db_password=***124
2026/10/12 08:48:48 renewed: ttl=30s
2026/10/12 08:49:10 renewed: ttl=30s
2026/10/12 08:49:18 v3 db_user=shop db_password=***125
...
2026/10/12 08:50:36 renewed: ttl=11s
2026/10/12 08:50:36 watcher done (err=<nil>) -> re-login
2026/10/12 08:50:36 login: ttl=30s policies=[default shop-api-read]
Der Watcher erneuert nach etwa zwei Dritteln der TTL. Liegt die neue
TTL unter der Restlaufzeit, die er braucht, beendet er sich mit
err=<nil>. Das ist kein Fehler, sondern das Signal
für den neuen Login.
Fortschritt speichern? Kostenlos registrieren
Drill 5: bao agent als Prozess-Supervisor
Die App soll gar nichts von OpenBao wissen und nur Env-Variablen
lesen. bao agent loggt sich ein, rendert
env_template-Blöcke und startet die App per
exec als Kindprozess. Ändert sich ein Secret, startet er
sie neu.
cd ~/secrets-lab/tag08
cat > agent-exec.hcl <<'EOF'
# bao agent als Prozess-Supervisor (Lab: JWT-Datei vom Laptop)
auto_auth {
method "kubernetes" {
mount_path = "auth/kubernetes"
config = {
role = "shop-api-short"
token_path = "sa.jwt" # im Pod: /var/run/secrets/openbao/token
}
}
}
template_config {
static_secret_render_interval = "10s" # KV v2 alle 10 s neu prüfen
exit_on_retry_failure = true
}
env_template "DB_USER" {
contents = <<-EOT
{{- with secret "secret/data/shop/api" }}{{ .Data.data.db_user }}{{ end -}}
EOT
error_on_missing_key = true
}
env_template "DB_PASSWORD" {
contents = <<-EOT
{{- with secret "secret/data/shop/api" }}{{ .Data.data.db_password }}{{ end -}}
EOT
error_on_missing_key = true
}
exec {
command = ["./app.sh"]
restart_on_secret_changes = "always"
restart_stop_signal = "SIGTERM"
}
EOF
cat > app.sh <<'EOF'
#!/bin/sh
# Lab-App: zeigt, was sie per Env bekommt (Passwort maskiert)
TAIL=$(awk -v p="$DB_PASSWORD" 'BEGIN { print substr(p, length(p) - 2) }')
echo "app start pid=$$ DB_USER=$DB_USER DB_PASSWORD=***$TAIL"
trap 'echo "app pid=$$ bekommt SIGTERM"; exit 0' TERM
while true; do sleep 1; done
EOF
chmod +x app.sh
env -u BAO_TOKEN bao agent -config=agent-exec.hclNach dem Start rotierst du im zweiten Terminal und beendest den Agent danach mit Strg+C:
BAO_ADDR=http://127.0.0.1:8200 BAO_TOKEN=root \
bao kv patch secret/shop/api db_password=lab-db-pw-126Erwartet (gekürzt):
[INFO] agent.auth.handler: authentication successful, sending token to sinks
[INFO] agent: (runner) rendered "(dynamic)" => "DB_USER"
[INFO] agent: (runner) rendered "(dynamic)" => "DB_PASSWORD"
[INFO] agent.exec.server: [INFO] (child) spawning: ./app.sh
app start pid=44583 DB_USER=shop DB_PASSWORD=***125
[INFO] agent: (runner) rendered "(dynamic)" => "DB_PASSWORD"
[INFO] agent.exec.server: stopping process: process_id=44583
app pid=44583 bekommt SIGTERM
[INFO] agent.exec.server: [INFO] (child) spawning: ./app.sh
app start pid=44632 DB_USER=shop DB_PASSWORD=***126
Das - in {{- und -}} entfernt
die Zeilenumbrüche des Heredocs, sonst endet das Passwort mit
\n. Spätestens nach
static_secret_render_interval sieht der Agent die neue
KV-Version. Ein erneutes Rendern ohne Änderung löst keinen Neustart
aus.
Sicherheit: Der Kindprozess erbt die komplette Umgebung des Agents. Ohne
env -u BAO_TOKENsäheapp.shim Lab den Root-Token in$BAO_TOKEN.
Fortschritt speichern? Kostenlos registrieren
Drill 6: bao agent als lokaler Proxy
Als Proxy lauscht der Agent auf 127.0.0.1:8100. Mit
use_auto_auth_token = true bekommen Anfragen ohne Token den
Agent-Token. Die App braucht so weder JWT noch Login.
cat > agent-proxy.hcl <<'EOF'
# bao agent als lokaler Proxy mit Cache (Lab: JWT-Datei vom Laptop)
auto_auth {
method "kubernetes" {
mount_path = "auth/kubernetes"
config = {
role = "shop-api-short"
token_path = "sa.jwt" # im Pod: /var/run/secrets/openbao/token
}
}
}
api_proxy {
use_auto_auth_token = true # Anfragen ohne Token bekommen den Agent-Token
}
cache {}
listener "tcp" {
address = "127.0.0.1:8100"
tls_disable = true
}
EOF
env -u BAO_TOKEN bao agent -config=agent-proxy.hcl > proxy.log 2>&1 &
sleep 3
curl -s http://127.0.0.1:8100/v1/secret/data/shop/api | jq -c .data.data
env -u BAO_TOKEN BAO_ADDR=http://127.0.0.1:8100 bao token lookup -format=json \
| jq -c '.data | {display_name, policies}'
curl -s -X POST -d '{"data":{"x":"1"}}' \
http://127.0.0.1:8100/v1/secret/data/shop/api | jq -c .
curl -s -H "X-Vault-Token: root" http://127.0.0.1:8100/v1/sys/mounts \
| jq -r '.data | keys[]' | head -2
head -1 proxy.log | cut -c1-80Erwartet:
{"api_key":"lab-api-key-456","db_password":"lab-db-pw-126","db_user":"shop"}
{"display_name":"kubernetes-shop-shop-api","policies":["default","shop-api-read"]}
{"errors":["1 error occurred:\n\t* permission denied\n\n"]}
cubbyhole/
identity/
==> Note: OpenBao Agent will be deprecating API proxy functionality in a future
Drei Beobachtungen: Lesen klappt ohne Token, Schreiben scheitert an
der Policy, und eine Anfrage mit eigenem Token (hier root)
geht unverändert durch. Mit use_auto_auth_token = "force"
ersetzt der Agent auch mitgebrachte Tokens. Der Cache hält nur Tokens
und Leases (dynamische Secrets, Tag 7). KV-Lesezugriffe gehen jedes Mal
zum Server, im Log als forwarding request to OpenBao.
Achtung: Die Proxy-Funktion zieht laut Hinweis in einen eigenen Befehl um:
bao proxy -config=agent-proxy.hclläuft mit derselben Datei. Neue Setups starten gleich mitbao proxy.
kill %1Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
cd ~/secrets-lab/tag08
bao read auth/kubernetes/role/shop-api-short >/dev/null 2>&1 \
&& echo "✔ Rolle shop-api-short" || echo "✘ Rolle shop-api-short fehlt"
.venv/bin/python -c 'import hvac' 2>/dev/null \
&& echo "✔ hvac im venv" || echo "✘ hvac fehlt"
kubectl -n shop logs deploy/shop-api-py 2>/dev/null | grep -q '^login: ttl=' \
&& echo "✔ Pod loggt sich per Kubernetes-Auth ein" || echo "✘ Pod-Login fehlt"
(cd go && go build -o /dev/null .) \
&& echo "✔ Go-Programm baut" || echo "✘ Go-Build fehlgeschlagen"
grep -q 'restart_on_secret_changes' agent-exec.hcl \
&& echo "✔ agent-exec.hcl mit exec-Stanza" || echo "✘ agent-exec.hcl unvollständig"Challenge
Lass bao agent im Pod als Entrypoint laufen: Er loggt
sich mit dem projizierten Token ein und startet app.sh als
Kindprozess. Eine Rotation in OpenBao soll nur den Kindprozess neu
starten, nicht den Pod.
Hinweis: Das OpenBao-Image bringt bao
und sh mit; Config und Skript kommen per ConfigMap mit
defaultMode: 0555.
Lösung
cd ~/secrets-lab/tag08
sed 's#"sa.jwt"#"/var/run/secrets/openbao/token"#' agent-exec.hcl > agent-pod.hcl
kubectl -n shop create configmap shop-agent --from-file=agent-exec.hcl=agent-pod.hcl \
--from-file=app.sh --dry-run=client -o yaml | kubectl apply -f -
cat > shop-api-agent.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
name: shop-api-agent
namespace: shop
spec:
replicas: 1
selector:
matchLabels: {app: shop-api-agent}
template:
metadata:
labels: {app: shop-api-agent}
spec:
serviceAccountName: shop-api
automountServiceAccountToken: false
containers:
- name: app
image: quay.io/openbao/openbao:2.7.1 # Lab: bringt bao und sh mit
command: ["bao", "agent", "-config=/etc/agent/agent-exec.hcl"]
workingDir: /etc/agent
env:
- {name: BAO_ADDR, value: "http://openbao.openbao.svc:8200"}
volumeMounts:
- {name: agent, mountPath: /etc/agent}
- {name: bao-token, mountPath: /var/run/secrets/openbao, readOnly: true}
volumes:
- name: agent
configMap: {name: shop-agent, defaultMode: 0555}
- name: bao-token
projected:
sources:
- serviceAccountToken: {path: token, audience: openbao,
expirationSeconds: 600}
EOF
kubectl apply -f shop-api-agent.yaml
kubectl -n shop rollout status deploy/shop-api-agent --timeout=120s
sleep 15; bao kv patch secret/shop/api db_password=lab-db-pw-128 >/dev/null; sleep 15
kubectl -n shop logs deploy/shop-api-agent | grep -E 'spawning|app '
kubectl -n shop get pod -l app=shop-api-agentErwartet (gekürzt):
[INFO] agent.exec.server: [INFO] (child) spawning: ./app.sh
app start pid=23 DB_USER=shop DB_PASSWORD=***127
app pid=23 bekommt SIGTERM
[INFO] agent.exec.server: [INFO] (child) spawning: ./app.sh
app start pid=52 DB_USER=shop DB_PASSWORD=***128
NAME READY STATUS RESTARTS AGE
shop-api-agent-68b7cfcd67-t9v75 1/1 Running 0 44s
Der Pod bleibt bei RESTARTS 0, nur der Kindprozess
bekommt eine neue PID. In echten Images kopierst du das
bao-Binary in dein App-Image und setzt es als
Entrypoint.
Aufräumen für Tag 9:
kubectl -n shop delete deploy shop-api-py shop-api-agent
kubectl -n shop delete configmap shop-app-code shop-agentFortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Baue Abhängigkeiten (hvac, Go-Module) ins Image und pinne Versionen.
pip installbeim Start ist eine Lab-Abkürzung, keine Supply-Chain. - Setze
token_max_ttlan der Rolle bewusst kurz (Minuten bis Stunden). Code, der den Re-Login nicht beherrscht, fällt sonst erst nach Tagen in Produktion auf. - Nutze TLS zu OpenBao (
BAO_CACERTbzw.ca_certim Agent) und keinentls_disable-Listener außerhalb von127.0.0.1oder Unix-Sockets. - Logge nie Secret-Werte, auch nicht gekürzt in Produktion. Die Maskierung hier dient nur dazu, die Rotation sichtbar zu machen.
- Plane den Wechsel von
api_proxyim Agent zubao proxy, bevor die Funktion aus dem Agent entfernt wird.