Zum Inhalt springen
Trainingslager IT-Trainingslager

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 agent als 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 agent nimmt 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.jwt

Erwartet:

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

Nach 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-125

Erwartet (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 durch client.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.hcl

Nach 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-126

Erwartet (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_TOKEN sähe app.sh im 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-80

Erwartet:

{"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.hcl läuft mit derselben Datei. Neue Setups starten gleich mit bao proxy.

kill %1

Fortschritt 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-agent

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

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Baue Abhängigkeiten (hvac, Go-Module) ins Image und pinne Versionen. pip install beim Start ist eine Lab-Abkürzung, keine Supply-Chain.
  • Setze token_max_ttl an 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_CACERT bzw. ca_cert im Agent) und keinen tls_disable-Listener außerhalb von 127.0.0.1 oder 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_proxy im Agent zu bao proxy, bevor die Funktion aus dem Agent entfernt wird.