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
BaoPolicybeschreibt 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-tokenim 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.modErwartet:
/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.yamlErwartet:
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 -vErwartet (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)
}
EOFErwartet: 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
}
EOFDie 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 okErwartet:
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()
}
})
EOFDie 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 >> .gitignoreTerminal 1 (OpenBao) und Terminal 2 (envtest):
bao server -dev -dev-root-token-id=lab-root -dev-listen-address=127.0.0.1:18200cd ~/op-lab/tag14-bao-operator && go run ./hack/labenvErwartet 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:18081Erwartet (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-readErwartet:
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]}]
EOFErwartet (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-readErwartet:
["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 undkubectl wait --for=condition=Readykehrt 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.shErwartet:
✔ 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
}
EOFIn 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-readErwartet (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 aufsys/policies/acl/k8s.*; zusätzlich Admission (ValidatingAdmissionPolicy) gegensudo/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"}undresult="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: nullund manueller Policy-Bereinigung.