Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 14: Praxis – ein OpenBao-Policy-Operator

Ziel: Du baust an einem Tag einen echten Operator, der OpenBao-Policies aus Kubernetes-Objekten verwaltet – mit CEL, Finalizer, Drift-Erkennung, Events, Metrik und einer envtest-Suite gegen einen echten bao server -dev · Dauer: ca. 180 min · Voraussetzung: Tag 13

Briefing

  • BaoPolicy beschreibt eine ACL-Policy: als HCL-Text (spec.policy) oder als Regeln (spec.rules[]). Die CEL-Regel erzwingt genau eins.
  • Der Operator schreibt die Policy als k8s.<namespace>.<name> nach OpenBao. Ein periodischer Resync erkennt Drift und stellt den Soll-Zustand wieder her.
  • Address und Token kommen aus dem Secret bao-operator-token im Operator-Namespace. Der Operator beobachtet dieses Secret.
  • Der Finalizer löscht die Policy in OpenBao, bevor das Objekt verschwindet.
  • Alles aus Tag 3–13 in einem Projekt: Marker, Status, Events, Watches, Metriken, Tests.
kubectl apply           Reconcile                          OpenBao (Dev, :18200)
BaoPolicy ----------->  1. Finalizer setzen
  spec.rules / policy   2. Secret bao-operator-token lesen
                        3. GetPolicy k8s.<ns>.<name>  <----  sys/policies/acl/...
                        4. fehlt/anders -> PutPolicy  ---->  (created/updated/drift)
                        5. Status + Event + Metrik
                        6. RequeueAfter resync-interval   (Drift-Erkennung)
kubectl delete  ----->  Finalizer: DeletePolicy  -------->  Policy weg

Drill 1: Projekt und OpenBao-Client

Der Operator ist eigenständig – ein neues Projekt neben dem site-operator.

export PATH=~/op-lab/bin:$PATH GOTOOLCHAIN=go1.26.9
kubebuilder version | head -1
bao version
mkdir -p ~/op-lab/tag14-bao-operator && cd ~/op-lab/tag14-bao-operator
kubebuilder init --domain lab.example --repo example.com/bao-operator
kubebuilder create api --group bao --version v1alpha1 --kind BaoPolicy \
  --resource --controller
go get github.com/openbao/openbao/api/[email protected]

Erwartet (gekürzt):

KubeBuilder:          v4.16.0
OpenBao v2.5.4 (4f6d47246a053375271a5fd8af85c3b75695aa46), built 2026-05-20T15:53:48Z
...
Next: define a resource with:
$ kubebuilder create api
...
Next: implement your new API and generate the manifests (e.g. CRDs,CRs) with:
$ make manifests
go: added github.com/openbao/openbao/api/v2 v2.7.1

Das Go-Modul des Clients heißt github.com/openbao/openbao/api/v2 – das Paket darin heißt einfach api. Die envtest-Assets kommen wie immer aus ~/op-lab/envtest:

make envtest
export KUBEBUILDER_ASSETS=$(bin/setup-envtest use 1.37.x \
  --bin-dir ~/op-lab/envtest -p path)
echo $KUBEBUILDER_ASSETS
grep -E "controller-runtime |openbao" go.mod

Erwartet:

/Users/<du>/op-lab/envtest/k8s/1.37.0-darwin-arm64
    github.com/openbao/openbao/api/v2 v2.7.1
    sigs.k8s.io/controller-runtime v0.25.0

Fortschritt speichern? Kostenlos registrieren

Drill 2: Die API mit CEL-Regel

has(self.policy) != has(self.rules) ist nur wahr, wenn genau eins der Felder gesetzt ist. Capability als Enum lässt Tippfehler wie lesen gar nicht erst in die API.

cat > api/v1alpha1/baopolicy_types.go <<'EOF'
package v1alpha1

import (
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/runtime"
)

// Capability ist eine OpenBao-Capability.
// +kubebuilder:validation:Enum=create;read;update;patch;delete;list;sudo;deny
type Capability string

// PolicyRule beschreibt einen path-Block der Policy.
type PolicyRule struct {
    // +kubebuilder:validation:MinLength=1
    // +kubebuilder:validation:MaxLength=512
    Path string `json:"path"`
    // +kubebuilder:validation:MinItems=1
    // +listType=set
    Capabilities []Capability `json:"capabilities"`
}

// BaoPolicySpec: genau eins von policy (HCL) oder rules.
// +kubebuilder:validation:XValidation:rule="has(self.policy) != has(self.rules)"
type BaoPolicySpec struct {
    // HCL-Text der Policy.
    // +optional
    // +kubebuilder:validation:MinLength=1
    // +kubebuilder:validation:MaxLength=65536
    Policy string `json:"policy,omitempty"`
    // Strukturierte Regeln; der Operator rendert daraus HCL.
    // +optional
    // +kubebuilder:validation:MinItems=1
    // +kubebuilder:validation:MaxItems=64
    // +listType=atomic
    Rules []PolicyRule `json:"rules,omitempty"`
}

// BaoPolicyStatus ist der beobachtete Zustand.
type BaoPolicyStatus struct {
    // Name der Policy in OpenBao: k8s.<namespace>.<name>
    // +optional
    PolicyName string `json:"policyName,omitempty"`
    // +optional
    ObservedGeneration int64 `json:"observedGeneration,omitempty"`
    // +listType=map
    // +listMapKey=type
    // +optional
    Conditions []metav1.Condition `json:"conditions,omitempty"`
}

// +kubebuilder:object:root=true
// +kubebuilder:subresource:status
// +kubebuilder:resource:shortName=bp
// +kubebuilder:printcolumn:name="Policy",type=string,JSONPath=`.status.policyName`
// +kubebuilder:printcolumn:name="Age",type=date,JSONPath=`.metadata.creationTimestamp`

// BaoPolicy verwaltet eine ACL-Policy in OpenBao.
type BaoPolicy struct {
    metav1.TypeMeta   `json:",inline"`
    metav1.ObjectMeta `json:"metadata,omitzero"`

    Spec   BaoPolicySpec   `json:"spec"`
    Status BaoPolicyStatus `json:"status,omitzero"`
}

// +kubebuilder:object:root=true

// BaoPolicyList enthält eine Liste von BaoPolicy.
type BaoPolicyList struct {
    metav1.TypeMeta `json:",inline"`
    metav1.ListMeta `json:"metadata,omitzero"`
    Items           []BaoPolicy `json:"items"`
}

func init() {
    SchemeBuilder.Register(func(s *runtime.Scheme) error {
        s.AddKnownTypes(SchemeGroupVersion, &BaoPolicy{}, &BaoPolicyList{})
        return nil
    })
}
EOF
make manifests generate
grep -A1 "x-kubernetes-validations" config/crd/bases/bao.lab.example_baopolicies.yaml

Erwartet:

            x-kubernetes-validations:
            - rule: has(self.policy) != has(self.rules)

Warum keine message? Der Marker passt nur in eine Zeile; mit Meldung wird er unlesbar lang. Die API-Fehlermeldung zitiert dafür die Regel selbst (Drill 8).

Fortschritt speichern? Kostenlos registrieren

Drill 3: Von Regeln zu HCL – erst der Unit-Test

Das Rendern ist reine Logik ohne Cluster – also ein klassischer Tabellentest. strconv.Quote sorgt dafür, dass ein Pfad mit " kein zweites HCL-Statement einschleusen kann.

cat > internal/controller/render.go <<'EOF'
package controller

import (
    "fmt"
    "strconv"
    "strings"

    baov1alpha1 "example.com/bao-operator/api/v1alpha1"
)

// policyName ist eindeutig: Namespaces enthalten keine Punkte.
func policyName(bp *baov1alpha1.BaoPolicy) string {
    return "k8s." + bp.Namespace + "." + bp.Name
}

// desiredPolicy liefert das HCL, das in OpenBao stehen soll.
func desiredPolicy(spec baov1alpha1.BaoPolicySpec) string {
    if spec.Policy != "" {
        return spec.Policy
    }
    return renderRules(spec.Rules)
}

// renderRules erzeugt deterministisches HCL; Quote verhindert HCL-Injection.
func renderRules(rules []baov1alpha1.PolicyRule) string {
    var b strings.Builder
    for i, r := range rules {
        if i > 0 {
            b.WriteString("\n")
        }
        caps := make([]string, len(r.Capabilities))
        for j, c := range r.Capabilities {
            caps[j] = strconv.Quote(string(c))
        }
        fmt.Fprintf(&b, "path %s {\n  capabilities = [%s]\n}\n",
            strconv.Quote(r.Path), strings.Join(caps, ", "))
    }
    return b.String()
}
EOF
cat > internal/controller/render_test.go <<'EOF'
package controller

import (
    "testing"

    baov1alpha1 "example.com/bao-operator/api/v1alpha1"
)

const capRead baov1alpha1.Capability = "read"

func TestRenderRules(t *testing.T) {
    tests := []struct {
        name  string
        rules []baov1alpha1.PolicyRule
        want  string
    }{
        {"eine Regel", []baov1alpha1.PolicyRule{
            {Path: "secret/data/app/*", Capabilities: []baov1alpha1.Capability{
                capRead, "list"}},
        }, "path \"secret/data/app/*\" {\n  capabilities = [\"read\", \"list\"]\n}\n"},
        {"Anführungszeichen werden escaped", []baov1alpha1.PolicyRule{
            {Path: `a" {`, Capabilities: []baov1alpha1.Capability{"deny"}},
        }, "path \"a\\\" {\" {\n  capabilities = [\"deny\"]\n}\n"},
    }
    for _, tt := range tests {
        t.Run(tt.name, func(t *testing.T) {
            if got := renderRules(tt.rules); got != tt.want {
                t.Errorf("renderRules() =\n%q\nwant\n%q", got, tt.want)
            }
        })
    }
}
EOF
go test ./internal/controller/ -run TestRenderRules -v

Erwartet (gekürzt):

--- PASS: TestRenderRules (0.00s)
    --- PASS: TestRenderRules/eine_Regel (0.00s)
    --- PASS: TestRenderRules/Anführungszeichen_werden_escaped (0.00s)
PASS
ok      example.com/bao-operator/internal/controller    0.366s

Warum k8s.<ns>.<name>? Namespaces sind DNS-Labels ohne Punkt – der erste Punkt nach dem Namespace trennt eindeutig. Und das Präfix k8s. erlaubt dem Operator-Token eine eng geschnittene Policy (Drill 8).

Fortschritt speichern? Kostenlos registrieren

Drill 4: Token-Secret und Metrik

Der Client wird bei jedem Reconcile frisch aus dem Secret gebaut. Ein rotiertes Token wirkt damit sofort, ohne Neustart.

cat > internal/controller/bao.go <<'EOF'
package controller

import (
    "context"
    "fmt"
    "time"

    "github.com/openbao/openbao/api/v2"
    corev1 "k8s.io/api/core/v1"
    "k8s.io/apimachinery/pkg/types"
)

// TokenSecretName liegt im Operator-Namespace, Keys: address, token.
const TokenSecretName = "bao-operator-token"

// baoClient baut bei jedem Reconcile einen Client aus dem Secret –
// ein rotiertes Token wirkt so ohne Neustart.
func (r *BaoPolicyReconciler) baoClient(ctx context.Context) (*api.Client, error) {
    var s corev1.Secret
    key := types.NamespacedName{Namespace: r.OperatorNamespace, Name: TokenSecretName}
    if err := r.Get(ctx, key, &s); err != nil {
        return nil, fmt.Errorf("secret %s: %w", key, err)
    }
    addr, token := string(s.Data["address"]), string(s.Data["token"])
    if addr == "" || token == "" {
        return nil, fmt.Errorf("secret %s: address oder token fehlt", key)
    }
    cfg := api.DefaultConfig()
    cfg.Address = addr
    cfg.Timeout = 10 * time.Second
    c, err := api.NewClient(cfg)
    if err != nil {
        return nil, err
    }
    c.SetToken(token)
    return c, nil
}
EOF
cat > internal/controller/metrics.go <<'EOF'
package controller

import (
    "github.com/prometheus/client_golang/prometheus"
    "sigs.k8s.io/controller-runtime/pkg/metrics"
)

// resultError ist das Label für fehlgeschlagene Syncs.
const resultError = "error"

// policySyncTotal zählt Syncs nach Ergebnis:
// created, updated, drift, unchanged, deleted, error.
var policySyncTotal = prometheus.NewCounterVec(prometheus.CounterOpts{
    Name: "bao_operator_policy_sync_total",
    Help: "Anzahl der Policy-Syncs gegen OpenBao nach Ergebnis.",
}, []string{"result"})

func init() {
    metrics.Registry.MustRegister(policySyncTotal)
}
EOF

Erwartet: keine Ausgabe. Gebaut wird erst am Ende von Drill 5 – bao.go braucht die Felder des Reconcilers.

Sicherheit: Der Token landet nie im Log, im Status oder in einem Event. Fehlermeldungen nennen nur den Secret-Namen.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Der Reconciler

Reconcile selbst bleibt kurz: Finalizer, Sync, Status, Requeue. RequeueAfter ist die Drift-Erkennung – OpenBao meldet keine Änderungen, also schauen wir regelmäßig nach.

cat > internal/controller/baopolicy_controller.go <<'EOF'
package controller

import (
    "context"
    "time"

    corev1 "k8s.io/api/core/v1"
    "k8s.io/apimachinery/pkg/api/equality"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/apimachinery/pkg/runtime"
    "k8s.io/client-go/tools/events"
    ctrl "sigs.k8s.io/controller-runtime"
    "sigs.k8s.io/controller-runtime/pkg/builder"
    "sigs.k8s.io/controller-runtime/pkg/client"
    "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
    "sigs.k8s.io/controller-runtime/pkg/handler"
    logf "sigs.k8s.io/controller-runtime/pkg/log"
    "sigs.k8s.io/controller-runtime/pkg/predicate"
    "sigs.k8s.io/controller-runtime/pkg/reconcile"

    baov1alpha1 "example.com/bao-operator/api/v1alpha1"
)

const finalizerName = "bao.lab.example/finalizer"

// BaoPolicyReconciler synchronisiert BaoPolicy-Objekte nach OpenBao.
type BaoPolicyReconciler struct {
    client.Client
    Scheme            *runtime.Scheme
    Recorder          events.EventRecorder
    OperatorNamespace string
    ResyncInterval    time.Duration
}

// +kubebuilder:rbac:groups=bao.lab.example,resources=baopolicies,verbs=get;list
// +kubebuilder:rbac:groups=bao.lab.example,resources=baopolicies,verbs=watch;update
// +kubebuilder:rbac:groups=bao.lab.example,resources=baopolicies/status,verbs=update
// +kubebuilder:rbac:groups="",resources=secrets,verbs=get;list;watch
// +kubebuilder:rbac:groups=events.k8s.io,resources=events,verbs=create;patch

func (r *BaoPolicyReconciler) Reconcile(
    ctx context.Context, req ctrl.Request,
) (ctrl.Result, error) {
    log := logf.FromContext(ctx)
    var bp baov1alpha1.BaoPolicy
    if err := r.Get(ctx, req.NamespacedName, &bp); err != nil {
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }
    name := policyName(&bp)

    if !bp.DeletionTimestamp.IsZero() {
        return ctrl.Result{}, r.finalize(ctx, &bp, name)
    }
    if controllerutil.AddFinalizer(&bp, finalizerName) {
        if err := r.Update(ctx, &bp); err != nil {
            return ctrl.Result{}, err
        }
    }

    before := bp.Status.DeepCopy()
    bp.Status.PolicyName = name
    result, reason, err := r.sync(ctx, &bp, name)
    policySyncTotal.WithLabelValues(result).Inc()
    if err != nil {
        log.Error(err, "Sync fehlgeschlagen", "policy", name)
        r.setConditions(&bp, metav1.ConditionFalse, reason, err.Error())
        r.Recorder.Eventf(&bp, nil, corev1.EventTypeWarning, reason,
            "SyncPolicy", "%v", err)
    } else {
        bp.Status.ObservedGeneration = bp.Generation
        r.setConditions(&bp, metav1.ConditionTrue, reason, "Policy "+name+" aktiv")
    }
    if !equality.Semantic.DeepEqual(before, &bp.Status) {
        if uerr := r.Status().Update(ctx, &bp); uerr != nil {
            return ctrl.Result{}, uerr
        }
    }
    if err != nil {
        return ctrl.Result{}, err
    }
    log.V(1).Info("Policy synchronisiert", "policy", name, "result", result)
    return ctrl.Result{RequeueAfter: r.ResyncInterval}, nil
}

// SetupWithManager: BaoPolicy plus das Token-Secret beobachten.
func (r *BaoPolicyReconciler) SetupWithManager(mgr ctrl.Manager) error {
    isToken := predicate.NewPredicateFuncs(func(o client.Object) bool {
        return o.GetNamespace() == r.OperatorNamespace &&
            o.GetName() == TokenSecretName
    })
    return ctrl.NewControllerManagedBy(mgr).
        For(&baov1alpha1.BaoPolicy{}).
        Watches(&corev1.Secret{},
            handler.EnqueueRequestsFromMapFunc(r.allPolicies),
            builder.WithPredicates(isToken)).
        Named("baopolicy").
        Complete(r)
}

// allPolicies: neues/rotiertes Token -> alle Policies neu abgleichen.
func (r *BaoPolicyReconciler) allPolicies(
    ctx context.Context, _ client.Object,
) []reconcile.Request {
    var list baov1alpha1.BaoPolicyList
    if err := r.List(ctx, &list); err != nil {
        logf.FromContext(ctx).Error(err, "BaoPolicies auflisten")
        return nil
    }
    reqs := make([]reconcile.Request, 0, len(list.Items))
    for _, bp := range list.Items {
        reqs = append(reqs, reconcile.Request{
            NamespacedName: client.ObjectKeyFromObject(&bp),
        })
    }
    return reqs
}
EOF

Die RBAC-Marker sind gegenüber dem Scaffold bewusst schmal: kein create/delete auf BaoPolicies, kein /finalizers (wir setzen keine OwnerReferences), dafür Secrets lesen und Events schreiben (events.k8s.io, die neue Events-API hinter GetEventRecorder, Tag 11).

Jetzt die eigentliche Arbeit: Soll gegen Ist vergleichen, nur bei Abweichung schreiben. Ob eine Abweichung ein Update oder Drift ist, verrät observedGeneration (Tag 5): Hat sich die Spec nicht geändert, hat jemand in OpenBao herumgeschrieben.

cat > internal/controller/sync.go <<'EOF'
package controller

import (
    "context"

    corev1 "k8s.io/api/core/v1"
    "k8s.io/apimachinery/pkg/api/meta"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"

    baov1alpha1 "example.com/bao-operator/api/v1alpha1"
)

// reasonBaoError: OpenBao hat einen Fehler gemeldet.
const reasonBaoError = "BaoError"

// sync schreibt die Policy, wenn sie fehlt oder abweicht (Drift).
func (r *BaoPolicyReconciler) sync(
    ctx context.Context, bp *baov1alpha1.BaoPolicy, name string,
) (result, reason string, err error) {
    bao, err := r.baoClient(ctx)
    if err != nil {
        return resultError, "TokenUnavailable", err
    }
    want := desiredPolicy(bp.Spec)
    got, err := bao.Sys().GetPolicyWithContext(ctx, name)
    if err != nil {
        return resultError, reasonBaoError, err
    }
    switch {
    case got == want:
        return "unchanged", "InSync", nil
    case got == "":
        result, reason = "created", "Created"
    case bp.Generation != bp.Status.ObservedGeneration:
        result, reason = "updated", "Updated"
    default:
        result, reason = "drift", "DriftCorrected"
    }
    if err := bao.Sys().PutPolicyWithContext(ctx, name, want); err != nil {
        return resultError, reasonBaoError, err
    }
    typ, note := corev1.EventTypeNormal, "Policy %s geschrieben"
    if result == "drift" {
        typ, note = corev1.EventTypeWarning, "Drift in %s korrigiert"
    }
    r.Recorder.Eventf(bp, nil, typ, reason, "PutPolicy", note, name)
    return result, reason, nil
}

func (r *BaoPolicyReconciler) setConditions(
    bp *baov1alpha1.BaoPolicy, s metav1.ConditionStatus, reason, msg string,
) {
    ready := "PolicyActive"
    if s == metav1.ConditionFalse {
        ready = "SyncFailed"
    }
    for _, c := range [][2]string{{"Synced", reason}, {"Ready", ready}} {
        meta.SetStatusCondition(&bp.Status.Conditions, metav1.Condition{
            Type: c[0], Status: s, Reason: c[1], Message: msg,
            ObservedGeneration: bp.Generation,
        })
    }
}

// finalize löscht die Policy in OpenBao, bevor das Objekt verschwindet.
func (r *BaoPolicyReconciler) finalize(
    ctx context.Context, bp *baov1alpha1.BaoPolicy, name string,
) error {
    if !controllerutil.ContainsFinalizer(bp, finalizerName) {
        return nil
    }
    bao, err := r.baoClient(ctx)
    if err != nil {
        return err
    }
    if err := bao.Sys().DeletePolicyWithContext(ctx, name); err != nil {
        policySyncTotal.WithLabelValues(resultError).Inc()
        return err
    }
    policySyncTotal.WithLabelValues("deleted").Inc()
    r.Recorder.Eventf(bp, nil, corev1.EventTypeNormal, "Deleted",
        "DeletePolicy", "Policy %s gelöscht", name)
    controllerutil.RemoveFinalizer(bp, finalizerName)
    return r.Update(ctx, bp)
}
EOF
go build ./... && echo build ok

Erwartet:

build ok

Fortschritt speichern? Kostenlos registrieren

Drill 6: main.go verdrahten

cmd/main.go bleibt das Scaffold. Ergänze vier Stellen. Importe:

    "time"
    corev1 "k8s.io/api/core/v1"
    "sigs.k8s.io/controller-runtime/pkg/cache"
    "sigs.k8s.io/controller-runtime/pkg/client"

Zwei Flags direkt vor opts := zap.Options{:

    var operatorNamespace string
    var resyncInterval time.Duration
    flag.StringVar(&operatorNamespace, "operator-namespace", "bao-operator-system",
        "Namespace mit dem Secret bao-operator-token.")
    flag.DurationVar(&resyncInterval, "resync-interval", time.Minute,
        "Wie oft jede Policy gegen OpenBao geprüft wird (Drift).")

In ctrl.Options nach HealthProbeBindAddress – ohne diese Zeilen cacht der Manager alle Secrets des Clusters (Tag 13):

        // Secrets nur aus dem Operator-Namespace cachen (Tag 13).
        Cache: cache.Options{ByObject: map[client.Object]cache.ByObject{
            &corev1.Secret{}: {Namespaces: map[string]cache.Config{
                operatorNamespace: {},
            }},
        }},

Und beim Reconciler:

    if err := (&controller.BaoPolicyReconciler{
        Client:            mgr.GetClient(),
        Scheme:            mgr.GetScheme(),
        Recorder:          mgr.GetEventRecorder("bao-operator"),
        OperatorNamespace: operatorNamespace,
        ResyncInterval:    resyncInterval,
    }).SetupWithManager(mgr); err != nil {
make manifests generate fmt vet
go build -o bin/manager ./cmd && bin/manager --help 2>&1 \
  | grep -A1 -E "operator-namespace|resync-interval"

Erwartet:

  -operator-namespace string
        Namespace mit dem Secret bao-operator-token. (default "bao-operator-system")
  -resync-interval duration
        Wie oft jede Policy gegen OpenBao geprüft wird (Drift). (default 1m0s)

Fortschritt speichern? Kostenlos registrieren

Drill 7: envtest-Suite mit echtem OpenBao

Die Suite startet selbst einen bao server -dev auf 127.0.0.1:18200 (Lab-Token lab-root), dann envtest und den Manager mit 2 s Resync. Kein Mock: Die Tests sehen genau das, was OpenBao speichert.

cat > internal/controller/suite_test.go <<'EOF'
package controller

import (
    "context"
    "net/http"
    "os/exec"
    "path/filepath"
    "testing"
    "time"

    . "github.com/onsi/ginkgo/v2"
    . "github.com/onsi/gomega"
    "github.com/openbao/openbao/api/v2"
    corev1 "k8s.io/api/core/v1"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/kubernetes/scheme"
    ctrl "sigs.k8s.io/controller-runtime"
    "sigs.k8s.io/controller-runtime/pkg/client"
    "sigs.k8s.io/controller-runtime/pkg/envtest"
    logf "sigs.k8s.io/controller-runtime/pkg/log"
    "sigs.k8s.io/controller-runtime/pkg/log/zap"
    metricsserver "sigs.k8s.io/controller-runtime/pkg/metrics/server"

    baov1alpha1 "example.com/bao-operator/api/v1alpha1"
)

const (
    baoAddr = "http://127.0.0.1:18200"
    baoRoot = "lab-root" // Lab-Wert, nur für den Dev-Server
    opNS    = "bao-operator-system"
)

var (
    ctx       context.Context
    cancel    context.CancelFunc
    testEnv   *envtest.Environment
    k8sClient client.Client
    baoCmd    *exec.Cmd
    baoc      *api.Client
)

func TestControllers(t *testing.T) {
    RegisterFailHandler(Fail)
    RunSpecs(t, "Controller Suite")
}

var _ = BeforeSuite(func() {
    logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(true)))
    ctx, cancel = context.WithCancel(context.TODO())

    By("OpenBao-Dev-Server starten")
    if resp, err := http.Get(baoAddr + "/v1/sys/health"); err == nil {
        _ = resp.Body.Close()
        Fail("Port 18200 ist belegt – läuft noch ein bao server -dev?")
    }
    baoCmd = exec.Command("bao", "server", "-dev",
        "-dev-root-token-id="+baoRoot, "-dev-listen-address=127.0.0.1:18200")
    Expect(baoCmd.Start()).To(Succeed())
    Eventually(func() error {
        resp, err := http.Get(baoAddr + "/v1/sys/health")
        if err == nil {
            _ = resp.Body.Close()
        }
        return err
    }, 15*time.Second, 200*time.Millisecond).Should(Succeed())
    cfg := api.DefaultConfig()
    cfg.Address = baoAddr
    var err error
    baoc, err = api.NewClient(cfg)
    Expect(err).NotTo(HaveOccurred())
    baoc.SetToken(baoRoot)

    By("envtest starten")
    Expect(baov1alpha1.AddToScheme(scheme.Scheme)).To(Succeed())
    testEnv = &envtest.Environment{
        CRDDirectoryPaths:     []string{filepath.Join("..", "..", "config", "crd", "bases")},
        ErrorIfCRDPathMissing: true,
    }
    restCfg, err := testEnv.Start()
    Expect(err).NotTo(HaveOccurred())
    k8sClient, err = client.New(restCfg, client.Options{Scheme: scheme.Scheme})
    Expect(err).NotTo(HaveOccurred())
    Expect(k8sClient.Create(ctx, &corev1.Namespace{
        ObjectMeta: metav1.ObjectMeta{Name: opNS},
    })).To(Succeed())

    By("Manager mit dem Reconciler starten")
    mgr, err := ctrl.NewManager(restCfg, ctrl.Options{
        Scheme:  scheme.Scheme,
        Metrics: metricsserver.Options{BindAddress: "0"},
    })
    Expect(err).NotTo(HaveOccurred())
    Expect((&BaoPolicyReconciler{
        Client:            mgr.GetClient(),
        Scheme:            mgr.GetScheme(),
        Recorder:          mgr.GetEventRecorder("bao-operator"),
        OperatorNamespace: opNS,
        ResyncInterval:    2 * time.Second,
    }).SetupWithManager(mgr)).To(Succeed())
    go func() {
        defer GinkgoRecover()
        Expect(mgr.Start(ctx)).To(Succeed())
    }()
})

var _ = AfterSuite(func() {
    cancel()
    if testEnv != nil {
        Expect(testEnv.Stop()).To(Succeed())
    }
    if baoCmd != nil && baoCmd.Process != nil {
        _ = baoCmd.Process.Kill()
        _ = baoCmd.Wait()
    }
})
EOF

Die Specs laufen Ordered: Erst fehlt das Secret, dann kommt es – so testest du nebenbei den Secret-Watch.

cat > internal/controller/baopolicy_controller_test.go <<'EOF'
package controller

import (
    "time"

    . "github.com/onsi/ginkgo/v2"
    . "github.com/onsi/gomega"
    "github.com/prometheus/client_golang/prometheus/testutil"
    corev1 "k8s.io/api/core/v1"
    apierrors "k8s.io/apimachinery/pkg/api/errors"
    "k8s.io/apimachinery/pkg/api/meta"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "sigs.k8s.io/controller-runtime/pkg/client"

    baov1alpha1 "example.com/bao-operator/api/v1alpha1"
)

var _ = Describe("BaoPolicy", Ordered, func() {
    const timeout, tick = 10 * time.Second, 200 * time.Millisecond
    key := client.ObjectKey{Namespace: "default", Name: "app-read"}
    const name = "k8s.default.app-read"
    readPolicy := func() (string, error) { return baoc.Sys().GetPolicy(name) }

    It("lehnt policy und rules gleichzeitig ab (CEL)", func() {
        bp := &baov1alpha1.BaoPolicy{
            ObjectMeta: metav1.ObjectMeta{Name: "beides", Namespace: "default"},
            Spec: baov1alpha1.BaoPolicySpec{Policy: "x", Rules: []baov1alpha1.PolicyRule{
                {Path: "a", Capabilities: []baov1alpha1.Capability{capRead}},
            }},
        }
        err := k8sClient.Create(ctx, bp)
        Expect(apierrors.IsInvalid(err)).To(BeTrue())
        Expect(err.Error()).To(ContainSubstring("has(self.policy) != has(self.rules)"))
    })

    It("meldet TokenUnavailable ohne Secret", func() {
        bp := &baov1alpha1.BaoPolicy{
            ObjectMeta: metav1.ObjectMeta{Name: key.Name, Namespace: key.Namespace},
            Spec: baov1alpha1.BaoPolicySpec{Rules: []baov1alpha1.PolicyRule{{
                Path:         "secret/data/app/*",
                Capabilities: []baov1alpha1.Capability{capRead},
            }}},
        }
        Expect(k8sClient.Create(ctx, bp)).To(Succeed())
        Eventually(func(g Gomega) {
            g.Expect(k8sClient.Get(ctx, key, bp)).To(Succeed())
            c := meta.FindStatusCondition(bp.Status.Conditions, "Synced")
            g.Expect(c).NotTo(BeNil())
            g.Expect(c.Reason).To(Equal("TokenUnavailable"))
        }, timeout, tick).Should(Succeed())
    })

    It("schreibt die Policy, sobald das Secret da ist", func() {
        Expect(k8sClient.Create(ctx, &corev1.Secret{
            ObjectMeta: metav1.ObjectMeta{Name: TokenSecretName, Namespace: opNS},
            StringData: map[string]string{"address": baoAddr, "token": baoRoot},
        })).To(Succeed())
        Eventually(readPolicy, timeout, tick).Should(ContainSubstring(
            `path "secret/data/app/*"`))
        bp := &baov1alpha1.BaoPolicy{}
        Eventually(func(g Gomega) {
            g.Expect(k8sClient.Get(ctx, key, bp)).To(Succeed())
            g.Expect(meta.IsStatusConditionTrue(bp.Status.Conditions, "Ready")).
                To(BeTrue())
            g.Expect(bp.Status.PolicyName).To(Equal(name))
            g.Expect(bp.Status.ObservedGeneration).To(Equal(bp.Generation))
        }, timeout, tick).Should(Succeed())
        Expect(bp.Finalizers).To(ContainElement(finalizerName))
    })

    It("übernimmt Spec-Änderungen", func() {
        bp := &baov1alpha1.BaoPolicy{}
        Expect(k8sClient.Get(ctx, key, bp)).To(Succeed())
        bp.Spec.Rules[0].Capabilities = append(bp.Spec.Rules[0].Capabilities, "list")
        Expect(k8sClient.Update(ctx, bp)).To(Succeed())
        Eventually(readPolicy, timeout, tick).Should(ContainSubstring(`"read", "list"`))
    })

    It("repariert Drift beim Resync", func() {
        before := testutil.ToFloat64(policySyncTotal.WithLabelValues("drift"))
        Expect(baoc.Sys().PutPolicy(name, `path "*" { capabilities = ["sudo"] }`)).
            To(Succeed())
        Eventually(readPolicy, timeout, tick).Should(ContainSubstring(`"read", "list"`))
        Expect(testutil.ToFloat64(policySyncTotal.WithLabelValues("drift"))).
            To(BeNumerically(">", before))
    })

    It("löscht die Policy über den Finalizer", func() {
        bp := &baov1alpha1.BaoPolicy{}
        Expect(k8sClient.Get(ctx, key, bp)).To(Succeed())
        Expect(k8sClient.Delete(ctx, bp)).To(Succeed())
        Eventually(func() bool {
            return apierrors.IsNotFound(k8sClient.Get(ctx, key, bp))
        }, timeout, tick).Should(BeTrue())
        Expect(readPolicy()).To(BeEmpty())
    })
})
EOF
go mod tidy
go test ./internal/... -count=1 -v | grep -E "^(---|ok|PASS|FAIL)|Ran "

Erwartet (gekürzt):

--- PASS: TestRenderRules (0.00s)
Ran 6 of 6 Specs in 8.095 seconds
--- PASS: TestControllers (8.10s)
PASS
ok      example.com/bao-operator/internal/controller    8.466s

Achtung: Läuft schon ein Bao auf Port 18200 (etwa aus Drill 8), bricht die Suite sofort mit „Port 18200 ist belegt” ab – sonst würde sie mit dem fremden Server reden.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Live – kubectl apply, bao policy read

Für den Live-Lauf braucht der Manager einen API-Server. labenv startet envtest dauerhaft und schreibt eine Admin-Kubeconfig – dein echter Kontext bleibt unberührt.

mkdir -p hack/labenv
cat > hack/labenv/main.go <<'EOF'
// labenv startet envtest (etcd + kube-apiserver) mit unseren CRDs und
// schreibt eine Admin-Kubeconfig. Nur fürs Lab – Strg+C beendet alles.
package main

import (
    "fmt"
    "os"
    "os/signal"
    "syscall"

    "sigs.k8s.io/controller-runtime/pkg/envtest"
)

func main() {
    env := &envtest.Environment{
        CRDDirectoryPaths:     []string{"config/crd/bases"},
        ErrorIfCRDPathMissing: true,
    }
    if _, err := env.Start(); err != nil {
        fmt.Fprintln(os.Stderr, "envtest:", err)
        os.Exit(1)
    }
    defer func() { _ = env.Stop() }()

    user, err := env.AddUser(envtest.User{
        Name: "lab-admin", Groups: []string{"system:masters"},
    }, nil)
    if err == nil {
        var kc []byte
        if kc, err = user.KubeConfig(); err == nil {
            err = os.WriteFile("labenv.kubeconfig", kc, 0o600)
        }
    }
    if err != nil {
        fmt.Fprintln(os.Stderr, "kubeconfig:", err)
        return
    }
    fmt.Println("envtest läuft, KUBECONFIG=labenv.kubeconfig")
    sig := make(chan os.Signal, 1)
    signal.Notify(sig, os.Interrupt, syscall.SIGTERM)
    <-sig
}
EOF
echo labenv.kubeconfig >> .gitignore

Terminal 1 (OpenBao) und Terminal 2 (envtest):

bao server -dev -dev-root-token-id=lab-root -dev-listen-address=127.0.0.1:18200
cd ~/op-lab/tag14-bao-operator && go run ./hack/labenv

Erwartet in Terminal 2:

envtest läuft, KUBECONFIG=labenv.kubeconfig

Terminal 3: Der Operator bekommt nicht das Root-Token, sondern ein eigenes mit Least Privilege – nur Policies mit Präfix k8s..

cd ~/op-lab/tag14-bao-operator
export KUBECONFIG=$PWD/labenv.kubeconfig
export BAO_ADDR=http://127.0.0.1:18200 BAO_TOKEN=lab-root   # Lab-Wert
cat > operator-policy.hcl <<'EOF'
# Der Operator darf nur Policies mit Präfix k8s. verwalten.
path "sys/policies/acl/k8s.*" {
  capabilities = ["create", "read", "update", "delete"]
}
EOF
bao policy write bao-operator operator-policy.hcl
OP_TOKEN=$(bao token create -policy=bao-operator -period=24h -orphan -field=token)
kubectl create namespace bao-operator-system
kubectl -n bao-operator-system create secret generic bao-operator-token \
  --from-literal=address=$BAO_ADDR --from-literal=token=$OP_TOKEN
echo 'path "x" { capabilities = ["read"] }' \
  | BAO_TOKEN=$OP_TOKEN bao policy write admin - 2>&1 | grep -E "Code|denied"

Erwartet:

Success! Uploaded policy: bao-operator
namespace/bao-operator-system created
secret/bao-operator-token created
Code: 403. Errors:
    * permission denied

Der letzte Befehl ist die Gegenprobe: Mit dem Operator-Token kann niemand die Policy admin überschreiben.

Terminal 4 (Manager, 10 s Resync, Metriken ohne TLS nur auf localhost):

cd ~/op-lab/tag14-bao-operator && export KUBECONFIG=$PWD/labenv.kubeconfig
go run ./cmd/main.go --operator-namespace=bao-operator-system \
  --resync-interval=10s --metrics-bind-address=127.0.0.1:18080 \
  --metrics-secure=false --health-probe-bind-address=127.0.0.1:18081

Erwartet (gekürzt):

INFO    setup   Starting manager
INFO    Starting EventSource    {"controller": "baopolicy", ... "kind source: *v1.Secret"}
INFO    Starting workers    {"controller": "baopolicy", ... "worker count": 1}

Zurück in Terminal 3 – der eigentliche Moment:

kubectl create namespace shop
cat > config/samples/bao_v1alpha1_baopolicy.yaml <<'EOF'
apiVersion: bao.lab.example/v1alpha1
kind: BaoPolicy
metadata:
  name: webshop-read
  namespace: shop
spec:
  rules:
    - path: secret/data/webshop/*
      capabilities: [read, list]
    - path: secret/data/webshop/admin
      capabilities: [deny]
EOF
kubectl apply -f config/samples/bao_v1alpha1_baopolicy.yaml
kubectl wait -n shop bp/webshop-read --for=condition=Ready --timeout=30s
kubectl get bp -n shop
bao policy read k8s.shop.webshop-read

Erwartet:

baopolicy.bao.lab.example/webshop-read created
baopolicy.bao.lab.example/webshop-read condition met
NAME           POLICY                  AGE
webshop-read   k8s.shop.webshop-read   0s
path "secret/data/webshop/*" {
  capabilities = ["read", "list"]
}

path "secret/data/webshop/admin" {
  capabilities = ["deny"]
}

Jetzt spielst du Angreifer: Jemand mit Root-Token weicht die Policy direkt in OpenBao auf. Spätestens nach einem Resync-Intervall ist sie repariert.

echo 'path "*" { capabilities = ["sudo", "read"] }' \
  | bao policy write k8s.shop.webshop-read -
sleep 11
bao policy read k8s.shop.webshop-read | head -3
kubectl get events -n shop
curl -s 127.0.0.1:18080/metrics | grep '^bao_operator'

Erwartet (gekürzt):

Success! Uploaded policy: k8s.shop.webshop-read
path "secret/data/webshop/*" {
  capabilities = ["read", "list"]
}
LAST SEEN   TYPE      REASON           OBJECT                   MESSAGE
16s         Normal    Created          baopolicy/webshop-read   Policy k8s.shop.web...
2s          Warning   DriftCorrected   baopolicy/webshop-read   Drift in k8s.shop.w...
bao_operator_policy_sync_total{result="created"} 1
bao_operator_policy_sync_total{result="drift"} 1
bao_operator_policy_sync_total{result="unchanged"} 4

Ein Alarm auf increase(bao_operator_policy_sync_total{result="drift"}[1h]) > 0 ist ein echtes Sicherheitssignal: Jemand umgeht GitOps.

Die API lehnt Unsinn ab, bevor der Operator ihn sieht:

kubectl apply -f - <<'EOF'
apiVersion: bao.lab.example/v1alpha1
kind: BaoPolicy
metadata: {name: kaputt, namespace: shop}
spec:
  policy: 'path "x" { capabilities = ["read"] }'
  rules: [{path: x, capabilities: [read]}]
EOF
kubectl apply -f - <<'EOF'
apiVersion: bao.lab.example/v1alpha1
kind: BaoPolicy
metadata: {name: kaputt, namespace: shop}
spec:
  rules: [{path: x, capabilities: [lesen]}]
EOF

Erwartet (gekürzt):

The BaoPolicy "kaputt" is invalid: spec: Invalid value: failed rule:
  has(self.policy) != has(self.rules)
The BaoPolicy "kaputt" is invalid:
* spec.rules[0].capabilities[0]: Unsupported value: "lesen": supported values:
  "create", "read", "update", "patch", "delete", "list", "sudo", "deny"

Zum Schluss der Finalizer:

kubectl get bp -n shop webshop-read -o jsonpath='{.metadata.finalizers}{"\n"}'
kubectl delete bp -n shop webshop-read
bao policy read k8s.shop.webshop-read

Erwartet:

["bao.lab.example/finalizer"]
baopolicy.bao.lab.example "webshop-read" deleted from shop namespace
No policy named: k8s.shop.webshop-read

Tipp: Lösche testweise das Secret und lege eine neue BaoPolicy an: Sie bekommt Synced=False (TokenUnavailable). Sobald das Secret zurück ist, löst der Secret-Watch den Reconcile aus und kubectl wait --for=condition=Ready kehrt sofort zurück.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Lege webshop-read aus Drill 8 wieder an (kubectl apply -f config/samples/), dann:

cat > hack/kontrollpunkt.sh <<'EOF'
#!/usr/bin/env bash
# Kontrollpunkt Tag 14 – erwartet labenv, bao dev und laufenden Manager.
export KUBECONFIG=$PWD/labenv.kubeconfig BAO_ADDR=http://127.0.0.1:18200
export BAO_TOKEN=lab-root   # Lab-Wert
ok() { echo "✔ $1"; }
nok() { echo "✘ $1"; }
check() { if eval "$2" >/dev/null 2>&1; then ok "$1"; else nok "$1"; fi; }

check "OpenBao Dev-Server erreichbar" "bao status"
check "CRD baopolicies installiert" \
  "kubectl get crd baopolicies.bao.lab.example"
check "Token-Secret vorhanden" \
  "kubectl -n bao-operator-system get secret bao-operator-token"
check "webshop-read ist Ready" "kubectl wait -n shop bp/webshop-read \
  --for=condition=Ready --timeout=10s"
check "Policy steht in OpenBao" \
  "bao policy read k8s.shop.webshop-read | grep -q 'secret/data/webshop'"
check "Finalizer gesetzt" "kubectl get bp -n shop webshop-read \
  -o jsonpath='{.metadata.finalizers}' | grep -q bao.lab.example/finalizer"
check "Metrik bao_operator_policy_sync_total" \
  "curl -s 127.0.0.1:18080/metrics | grep -q bao_operator_policy_sync_total"
check "CEL lehnt policy+rules ab" "! kubectl apply --dry-run=server -f - <<'Y'
apiVersion: bao.lab.example/v1alpha1
kind: BaoPolicy
metadata: {name: x, namespace: shop}
spec: {policy: 'path \"x\" {}', rules: [{path: x, capabilities: [read]}]}
Y"
EOF
bash hack/kontrollpunkt.sh

Erwartet:

✔ OpenBao Dev-Server erreichbar
✔ CRD baopolicies installiert
✔ Token-Secret vorhanden
✔ webshop-read ist Ready
✔ Policy steht in OpenBao
✔ Finalizer gesetzt
✔ Metrik bao_operator_policy_sync_total
✔ CEL lehnt policy+rules ab

Challenge

Erweitere BaoPolicy um ein optionales Feld spec.authRole.serviceAccounts. Ist es gesetzt, legt der Operator zusätzlich die Kubernetes-Auth-Rolle auth/kubernetes/role/k8s.<ns>.<name> an, die genau diese ServiceAccounts im eigenen Namespace an die Policy bindet – und der Finalizer räumt sie mit ab.

Hinweis: bao.Logical().WriteWithContext mit bound_service_account_names, bound_service_account_namespaces und token_policies; das Operator-Token braucht dafür einen zweiten path-Block.

Lösung

In api/v1alpha1/baopolicy_types.go einen Typ und ein Feld in BaoPolicySpec ergänzen:

// AuthRole bindet die Policy an ServiceAccounts im eigenen Namespace.
type AuthRole struct {
    // +kubebuilder:validation:MinItems=1
    // +listType=set
    ServiceAccounts []string `json:"serviceAccounts"`
}

    // (in BaoPolicySpec, nach Rules)
    // Optional: Kubernetes-Auth-Rolle k8s.<ns>.<name> anlegen.
    // +optional
    AuthRole *AuthRole `json:"authRole,omitempty"`
cat > internal/controller/authrole.go <<'EOF'
package controller

import (
    "context"

    baov1alpha1 "example.com/bao-operator/api/v1alpha1"
)

const roleMount = "auth/kubernetes/role/"

// syncRole schreibt die Rolle idempotent; der Namespace ist fest der
// eigene – ein Team kann so keine fremden ServiceAccounts binden.
func (r *BaoPolicyReconciler) syncRole(
    ctx context.Context, bp *baov1alpha1.BaoPolicy, name string,
) error {
    if bp.Spec.AuthRole == nil {
        return nil
    }
    bao, err := r.baoClient(ctx)
    if err != nil {
        return err
    }
    _, err = bao.Logical().WriteWithContext(ctx, roleMount+name, map[string]any{
        "bound_service_account_names":      bp.Spec.AuthRole.ServiceAccounts,
        "bound_service_account_namespaces": []string{bp.Namespace},
        "token_policies":                   []string{name},
        "token_ttl":                        "1h",
    })
    return err
}
EOF

In Reconcile direkt nach r.sync(...), und in finalize vor DeletePolicyWithContext:

    if err == nil {
        if rerr := r.syncRole(ctx, &bp, name); rerr != nil {
            result, reason, err = resultError, reasonBaoError, rerr
        }
    }
    if bp.Spec.AuthRole != nil {
        if _, err := bao.Logical().DeleteWithContext(ctx, roleMount+name); err != nil {
            return err
        }
    }

Operator-Policy erweitern, Auth-Methode aktivieren, CRD neu einspielen, Manager neu starten (Terminal 4) und ausprobieren:

cat >> operator-policy.hcl <<'EOF'
path "auth/kubernetes/role/k8s.*" {
  capabilities = ["create", "update", "delete"]
}
EOF
bao policy write bao-operator operator-policy.hcl
bao auth enable kubernetes
make manifests generate && kubectl apply -f config/crd/bases/
kubectl apply -f - <<'EOF'
apiVersion: bao.lab.example/v1alpha1
kind: BaoPolicy
metadata: {name: webshop-read, namespace: shop}
spec:
  rules: [{path: secret/data/webshop/*, capabilities: [read, list]}]
  authRole: {serviceAccounts: [webshop]}
EOF
kubectl wait -n shop bp/webshop-read --for=condition=Ready --timeout=20s
bao read auth/kubernetes/role/k8s.shop.webshop-read \
  | grep -E "_names |_namespaces |token_policies|token_ttl"
kubectl delete bp -n shop webshop-read
bao read auth/kubernetes/role/k8s.shop.webshop-read

Erwartet (gekürzt):

Success! Enabled kubernetes auth method at: kubernetes/
baopolicy.bao.lab.example/webshop-read condition met
bound_service_account_names                 [webshop]
bound_service_account_namespaces            [shop]
token_policies                              [k8s.shop.webshop-read]
token_ttl                                   1h
baopolicy.bao.lab.example "webshop-read" deleted from shop namespace
No value found at auth/kubernetes/role/k8s.shop.webshop-read

Den Namespace setzt der Operator selbst – ein Team kann so keine ServiceAccounts fremder Namespaces an seine Policy binden. Offene Kante: Wird authRole später entfernt, bleibt die Rolle stehen, bis die BaoPolicy gelöscht wird.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Echtes OpenBao: TLS mit CA aus dem Secret (api.Config.ConfigureTLS), statt statischem Token besser Kubernetes-Auth des Operators selbst (eigener ServiceAccount, kurzlebige Tokens, Renewal).
  • Mandantenfähigkeit: Präfix k8s.<ns>. plus Operator-Policy nur auf sys/policies/acl/k8s.*; zusätzlich Admission (ValidatingAdmissionPolicy) gegen sudo/path "*" in Team-Namespaces.
  • Secrets-RBAC enger: statt ClusterRole eine Role im Operator-Namespace (Marker mit namespace=), passend zum Cache-Filter aus Drill 6.
  • Drift-Alarm auf bao_operator_policy_sync_total{result="drift"} und result="error"; Resync-Intervall gegen die Last auf OpenBao abwägen (Tag 13).
  • Hängender Finalizer, wenn OpenBao dauerhaft weg ist (Tag 7): Runbook mit bewusstem kubectl patch ... finalizers: null und manueller Policy-Bereinigung.