Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 11: RBAC, Leader Election, Metriken, Health

Ziel: Der site-operator läuft mit genau den Rechten aus seinen RBAC-Markern, wählt einen Leader, liefert geschützte Prometheus-Metriken (eigene inklusive), meldet Health und Readiness und loggt strukturiert · Dauer: ca. 150 min · Voraussetzung: Tag 10

Briefing

  • RBAC entsteht aus +kubebuilder:rbac-Markern: make manifests schreibt config/rbac/role.yaml. Fehlt ein Marker, merkst du es erst mit echtem ServiceAccount.
  • Leader Election: Mehrere Replicas, aber nur einer reconciled. Wer die Lease hält, ist Leader.
  • Metriken liefert der Manager unter /metrics – per HTTPS, mit Token-Prüfung (TokenReview) und RBAC-Prüfung (SubjectAccessReview).
  • /healthz (Liveness) und /readyz (Readiness) auf Port 8081, eigene Checks per AddHealthzCheck/AddReadyzCheck.
  • Logs sind strukturiert (zap/logr): Schlüssel-Wert-Paare statt Fließtext, in Produktion als JSON.
           ServiceAccount site-operator-controller-manager
                    | ClusterRole manager-role (aus Markern)
envtest <-----------+ Role leader-election (Lease)
   ^  TokenReview/SAR          manager :8443 /metrics  <-- curl + Token
   '---------------------------        :8081 /healthz /readyz

Drill 1: RBAC aus Markern

source ~/op-lab/env.sh
cp -r ~/op-lab/tag10-site-operator ~/op-lab/tag11-site-operator
cd ~/op-lab/tag11-site-operator
grep -h 'kubebuilder:rbac' internal/controller/*.go | cut -c1-80

Erwartet (gekürzt):

// +kubebuilder:rbac:groups=web.lab.example,resources=staticsites,verbs=get;list;wa
// +kubebuilder:rbac:groups=web.lab.example,resources=staticsites/status,verbs=get;
// +kubebuilder:rbac:groups="",resources=configmaps;services,verbs=get;list;watch
// +kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch
// +kubebuilder:rbac:groups=events.k8s.io,resources=events,verbs=create;patch

controller-gen sammelt alle Marker im Paket und fasst sie zu einer ClusterRole manager-role zusammen:

make manifests
grep -A3 'apps' config/rbac/role.yaml

Erwartet:

  - apps
  resources:
  - deployments
  verbs:

Neben role.yaml liegen in config/rbac/ die Bindings, der ServiceAccount, die Rolle für die Leader-Lease und die Rollen für den Metrik-Schutz. config/default setzt Namespace site-operator-system und Präfix site-operator- davor. Für das Lab baust du ein kleines Overlay, das nur diese RBAC-Objekte erzeugt – mit genau den Namen, die später auch das echte Deployment nutzt:

mkdir -p config/lab-rbac
cat > config/lab-rbac/kustomization.yaml <<'EOF'
# Nur fürs Lab: RBAC aus config/rbac mit denselben Namen wie config/default
namespace: site-operator-system
namePrefix: site-operator-
resources:
- namespace.yaml
- ../rbac
EOF
cat > config/lab-rbac/namespace.yaml <<'EOF'
apiVersion: v1
kind: Namespace
metadata:
  name: system
EOF

name: system ist kein Tippfehler: Präfix und Namespace-Transformer machen daraus site-operator-system, genau wie in config/default.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Der Operator als ServiceAccount

Bisher lief der Manager mit deiner Admin-Kubeconfig (system:masters) – er durfte alles, ein fehlender Marker fiel nie auf. Jetzt bekommt er die Identität, die er im Cluster hätte.

Terminal 1: envtest mit der CRD starten (läuft bis zum Ende des Tages):

source ~/op-lab/env.sh
cd ~/op-lab/tag11-site-operator && envtest-up --crds config/crd/bases

Terminal 2 (Arbeitsterminal; den Operator startest du heute im Hintergrund, weil du ihn oft neu startest – Terminal 3 bleibt frei):

kubectl apply -k config/lab-rbac | grep -E 'namespace/|serviceaccount/|manager-role '
SA=system:serviceaccount:site-operator-system:site-operator-controller-manager
kubectl auth can-i list deployments --as=$SA
kubectl auth can-i delete deployments --as=$SA
kubectl auth can-i get secrets --as=$SA
kubectl auth can-i create leases -n site-operator-system --as=$SA

Erwartet:

namespace/site-operator-system created
serviceaccount/site-operator-controller-manager created
clusterrole.rbac.authorization.k8s.io/site-operator-manager-role created
yes
no
no
yes

delete fehlt mit Absicht: Kinder räumt der Garbage Collector über die Owner Reference ab, der Operator selbst löscht nichts. Die Lease-Rolle gilt nur im eigenen Namespace. Jetzt eine Kubeconfig mit dem Token des ServiceAccounts:

cp ~/op-lab/envtest.kubeconfig ~/op-lab/sa.kubeconfig
TOKEN=$(kubectl create token site-operator-controller-manager \
  -n site-operator-system --duration=4h)
export KUBECONFIG=~/op-lab/sa.kubeconfig
kubectl config set-credentials operator --token="$TOKEN" >/dev/null
kubectl config set-context operator --cluster=envtest --user=operator >/dev/null
kubectl config use-context operator
kubectl auth whoami | head -2 | cut -c1-80
kubectl get secrets 2>&1 | cut -c1-80
export KUBECONFIG=~/op-lab/envtest.kubeconfig

Erwartet:

Switched to context "operator".
ATTRIBUTE                                           VALUE
Username                                            system:serviceaccount:site-operat
Error from server (Forbidden): secrets is forbidden: User "system:serviceaccount

Sicherheit: Das Token ist ein echtes Lab-Credential mit 4 Stunden Laufzeit. sa.kubeconfig liegt neben envtest.kubeconfig und ist nur für envtest gültig; envtest-up löscht beim Beenden nur seine eigene Datei – sa.kubeconfig räumst du am Ende selbst weg.

Den Manager baust du heute als Binary – zwei Instanzen und kill funktionieren damit zuverlässiger als mit go run. Webhooks bleiben wie an Tag 10 aus:

export ENABLE_WEBHOOKS=false
make build
bin/manager --kubeconfig ~/op-lab/sa.kubeconfig -health-probe-bind-address=:8081 \
  > lab/run.log 2>&1 &
echo $! > lab/manager.pid
cat > lab/site.yaml <<'EOF'
apiVersion: web.lab.example/v1
kind: StaticSite
metadata:
  name: demo
spec:
  content: "<h1>Hallo vom site-operator</h1>"
EOF
kubectl apply -f lab/site.yaml
sleep 3; kubectl get site demo; grep -c ERROR lab/run.log

Erwartet:

staticsite.web.lab.example/demo created
NAME   READY   AVAILABLE   URL                       AGE
demo           False       http://demo.default.svc   3s
0

--kubeconfig registriert controller-runtime selbst; ctrl.GetConfigOrDie() liest das Flag vor KUBECONFIG. Mit den Rechten aus den Markern läuft alles – das ist der eigentliche Test deiner RBAC.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Ein fehlender Marker – und eine Readiness, die lügt

Nimm dem Operator das Recht, Services zu beobachten, und spiele die Rolle neu ein:

cp internal/controller/staticsite_controller.go lab/controller.go.bak
sed 's#configmaps;services,verbs=get;list;watch#configmaps,verbs=get;list;watch#' \
  lab/controller.go.bak > internal/controller/staticsite_controller.go
make manifests build >/dev/null && kubectl apply -k config/lab-rbac | grep configured
kill "$(cat lab/manager.pid)"
bin/manager --kubeconfig ~/op-lab/sa.kubeconfig -health-probe-bind-address=:8081 \
  > lab/run.log 2>&1 &
echo $! > lab/manager.pid
sleep 5; grep -m1 forbidden lab/run.log | grep -o 'failed to list[^:]*: [^:]*'
curl -s -w ' %{http_code}\n' localhost:8081/readyz

Erwartet:

clusterrole.rbac.authorization.k8s.io/site-operator-manager-role configured
failed to list *v1.Service: services is forbidden
ok 200

Der Informer für Services bekommt nie seine erste Liste, der Controller startet nie seine Worker – und /readyz meldet trotzdem ok. Der Kubebuilder-Standard prüft nur healthz.Ping: „Der HTTP-Server antwortet.” Nach CacheSyncTimeout (2 Minuten) beendet sich der Manager dann mit timed out waiting for cache to be synced, Kubernetes startet ihn neu – ein CrashLoop ohne klaren Hinweis.

Fortschritt speichern? Kostenlos registrieren

Drill 4: Readiness mit Aussage

Ein eigener Check fragt den Cache, ob alle Informer synchron sind. Er kommt in ein eigenes Paket, nicht nach cmd/: make build übersetzt nur die Datei cmd/main.go (go build -o bin/manager cmd/main.go), eine zweite Datei daneben fände der Compiler nicht.

mkdir -p internal/health
cat > internal/health/health.go <<'EOF'
// Package health enthält Readiness-Checks für den Manager.
package health

import (
    "context"
    "errors"
    "net/http"
    "time"

    "sigs.k8s.io/controller-runtime/pkg/cache"
    "sigs.k8s.io/controller-runtime/pkg/healthz"
)

// CacheSynced meldet "bereit" erst, wenn alle Informer ihre erste Liste haben.
// Fehlt z. B. RBAC für einen beobachteten Typ, bleibt der Pod NotReady.
func CacheSynced(c cache.Cache) healthz.Checker {
    return func(req *http.Request) error {
        ctx, cancel := context.WithTimeout(req.Context(), time.Second)
        defer cancel()
        if !c.WaitForCacheSync(ctx) {
            return errors.New("informer-cache nicht synchron")
        }
        return nil
    }
}
EOF

In cmd/main.go ersetzt der Check den Ping bei der Readiness (Liveness bleibt beim Ping – ein fehlendes Recht ist kein Grund für einen Neustart). Import "example.com/site-operator/internal/health":

    ready := health.CacheSynced(mgr.GetCache())
    if err := mgr.AddReadyzCheck("informers", ready); err != nil {
        setupLog.Error(err, "Failed to set up ready check")
        os.Exit(1)
    }
make build >/dev/null && kill "$(cat lab/manager.pid)"
bin/manager --kubeconfig ~/op-lab/sa.kubeconfig -health-probe-bind-address=:8081 \
  > lab/run.log 2>&1 &
echo $! > lab/manager.pid
sleep 5; curl -s -w ' %{http_code}\n' 'localhost:8081/readyz?verbose'

Erwartet:

[-]informers failed: reason withheld
healthz check failed
 500

„reason withheld” ist Absicht: Fehlerdetails stehen im Log des Managers, nicht in der HTTP-Antwort. Jetzt das Recht zurück:

cp lab/controller.go.bak internal/controller/staticsite_controller.go
make manifests build >/dev/null && kubectl apply -k config/lab-rbac | grep configured
kill "$(cat lab/manager.pid)"
bin/manager --kubeconfig ~/op-lab/sa.kubeconfig -health-probe-bind-address=:8081 \
  > lab/run.log 2>&1 &
echo $! > lab/manager.pid
sleep 4; curl -s -w ' %{http_code}\n' 'localhost:8081/readyz?verbose'

Erwartet:

clusterrole.rbac.authorization.k8s.io/site-operator-manager-role configured
[+]informers ok
healthz check passed
 200

Warum? Ein Pod, der NotReady bleibt, fällt im Rollout sofort auf (kubectl rollout status hängt, das alte ReplicaSet bleibt). Ein Pod, der „Ready” meldet und nichts tut, fällt erst auf, wenn sich Kunden beschweren.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Leader Election mit zwei Instanzen

Im Cluster läuft der Manager mit --leader-elect. Außerhalb des Clusters weiß er aber nicht, in welchem Namespace die Lease liegen soll:

bin/manager --kubeconfig ~/op-lab/sa.kubeconfig -health-probe-bind-address=0 \
  --leader-elect 2>&1 | grep -o '"error": "[^"]*"' | cut -c1-80

Erwartet:

"error": "unable to find leader election namespace: not running in-cluster, pl

Ein Flag schafft Abhilfe. In cmd/main.go bei den anderen Variablen und Flags:

    var leaderElectionNS string
    flag.StringVar(&leaderElectionNS, "leader-election-namespace", "",
        "Namespace der Leader-Lease (nötig außerhalb des Clusters)")

und in ctrl.Options direkt unter LeaderElectionID:

        LeaderElectionNamespace: leaderElectionNS,

Jetzt zwei Instanzen nebeneinander – unterschiedliche Probe-Ports, gleiche Lease:

make build >/dev/null && kill "$(cat lab/manager.pid)"
for n in 1 2; do
  bin/manager --kubeconfig ~/op-lab/sa.kubeconfig \
    -health-probe-bind-address=:808$n --leader-elect \
    --leader-election-namespace=site-operator-system > lab/le-$n.log 2>&1 &
  echo $! > lab/le-$n.pid
  sleep 3
done
grep -l 'Successfully acquired' lab/le-*.log
kubectl get lease -n site-operator-system

Erwartet:

lab/le-1.log
NAME                   HOLDER                                       AGE
b986d597.lab.example   mac_dc48cb4f-d75f-4f28-a27d-58727f08ae88       6s

Instanz 1 ist Leader (<hostname>_<uuid>), Instanz 2 wartet in Attempting to acquire leader lease.... Jetzt der Absturz des Leaders – kill -9, ohne Chance zum Aufräumen:

date +%T; kill -9 "$(cat lab/le-1.pid)"
until grep -q 'Successfully acquired' lab/le-2.log; do sleep 0.5; done; date +%T

Erwartet:

11:44:16
11:44:33

17 Sekunden ohne aktiven Controller: Die Lease gilt 15 Sekunden (LeaseDuration), danach versucht es Instanz 2 alle 2 Sekunden (RetryPeriod). Auch ein sauberes kill (SIGTERM) braucht ohne Zusatzoption so lange – das reparierst du an Tag 13.

kill "$(cat lab/le-2.pid)"

Achtung: Leader Election schützt nur Runnables, die sie verlangen. Controller tun das, der Webhook-Server und die Metrik- und Probe-Server laufen auf jeder Replica. Webhooks müssen deshalb ohne Leader funktionieren.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Metriken – geschützt per Token und RBAC

Der Metrik-Server ist im Gerüst abgeschaltet (--metrics-bind-address=0). config/default setzt im Cluster :8443 – mit HTTPS (selbstsigniert, wenn kein Zertifikat da ist) und dem Filter filters.WithAuthenticationAndAuthorization: Jeder Aufruf schickt ein Bearer-Token, der Manager prüft es per TokenReview und fragt per SubjectAccessReview, ob der Aufrufer get auf die Nicht-Ressource /metrics darf. Dafür braucht der Manager selbst die Rolle metrics-auth-role – die hat kubectl apply -k schon angelegt.

bin/manager --kubeconfig ~/op-lab/sa.kubeconfig -health-probe-bind-address=:8081 \
  --metrics-bind-address=:8443 > lab/run.log 2>&1 &
echo $! > lab/manager.pid
sleep 4
kubectl create serviceaccount prometheus
T=$(kubectl create token prometheus)
curl -sk -o /dev/null -w '%{http_code}\n' https://localhost:8443/metrics
curl -sk -w ' %{http_code}\n' -H "Authorization: Bearer $T" \
  https://localhost:8443/metrics

Erwartet:

serviceaccount/prometheus created
401
Authorization denied for user system:serviceaccount:default:prometheus
 403

401: kein Token. 403: Token gültig, aber kein Recht. Das Recht vergibt die vorbereitete ClusterRole metrics-reader:

kubectl create clusterrolebinding prometheus-metrics \
  --clusterrole=site-operator-metrics-reader --serviceaccount=default:prometheus
curl -sk -o /dev/null -w '%{http_code}\n' -H "Authorization: Bearer $T" \
  https://localhost:8443/metrics
sleep 30
curl -sk -H "Authorization: Bearer $T" https://localhost:8443/metrics \
  | grep -E '^controller_runtime_(reconcile_total|max_concurrent|active_workers)'

Erwartet:

clusterrolebinding.rbac.authorization.k8s.io/prometheus-metrics created
403
controller_runtime_active_workers{controller="staticsite"} 0
controller_runtime_max_concurrent_reconciles{controller="staticsite"} 1
controller_runtime_reconcile_total{controller="staticsite",result="error"} 0
controller_runtime_reconcile_total{controller="staticsite",result="requeue"} 0
controller_runtime_reconcile_total{controller="staticsite",result="requeue_after"} 0
controller_runtime_reconcile_total{controller="staticsite",result="success"} 1

Warum sleep 30? Der Filter merkt sich Entscheidungen: ein „Nein” 30 Sekunden, ein „Ja” 5 Minuten (DenyCacheTTL/AllowCacheTTL in pkg/metrics/filters). Direkt nach dem Binding kommt deshalb noch einmal 403 – eine beliebte Falle beim Einrichten von Prometheus.

Tipp: Weitere nützliche Standard-Metriken: controller_runtime_reconcile_time_seconds (Histogramm je Controller), workqueue_depth und workqueue_longest_running_processor_seconds (hängt ein Worker?), rest_client_requests_total (Last auf dem API-Server).

Fortschritt speichern? Kostenlos registrieren

Drill 7: Eigene Metriken

Zwei Fragen beantworten die Standard-Metriken nicht: „Schreibt der Operator ständig an seinen Kindobjekten herum?” und „Welche Sites sind gerade nicht verfügbar?”

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

import (
    "github.com/prometheus/client_golang/prometheus"
    "k8s.io/apimachinery/pkg/api/meta"
    "sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
    "sigs.k8s.io/controller-runtime/pkg/metrics"

    webv1 "example.com/site-operator/api/v1"
)

var (
    // childWrites zählt, was CreateOrUpdate mit den Kindobjekten gemacht hat.
    // Steigt "updated" ständig, kämpft jemand mit dem Operator (Tag 13).
    childWrites = prometheus.NewCounterVec(prometheus.CounterOpts{
        Name: "site_operator_child_writes_total",
        Help: "Abgleich der Kindobjekte nach Art und Ergebnis",
    }, []string{"kind", "operation"})

    // siteAvailable ist 1, wenn die Condition Available=True ist, sonst 0.
    siteAvailable = prometheus.NewGaugeVec(prometheus.GaugeOpts{
        Name: "site_operator_site_available",
        Help: "Available-Condition je StaticSite (1 = True)",
    }, []string{"namespace", "name"})
)

func init() {
    // Die Registry des Managers – alles darin erscheint unter /metrics.
    metrics.Registry.MustRegister(childWrites, siteAvailable)
}

func countWrite(kind string, op controllerutil.OperationResult) {
    childWrites.WithLabelValues(kind, string(op)).Inc()
}

func setAvailableMetric(site *webv1.StaticSite) {
    v := 0.0
    if meta.IsStatusConditionTrue(site.Status.Conditions,
        webv1.ConditionAvailable) {
        v = 1
    }
    siteAvailable.WithLabelValues(site.Namespace, site.Name).Set(v)
}
EOF

Drei kleine Einbauten. In reconcileConfigMap, reconcileDeployment und reconcileService jeweils direkt nach der Log-Zeile … abgeglichen (mit "ConfigMap", "Deployment", "Service"):

    countWrite("Deployment", op)

In updateStatus (status.go) vor dem Vergleich mit dem alten Status:

    setAvailableMetric(site)
    if equality.Semantic.DeepEqual(orig.Status, site.Status) {

Und in Reconcile: Ist die Site weg, muss auch ihre Zeitreihe weg – sonst meldet das Dashboard für immer eine gelöschte Site:

    if err := r.Get(ctx, req.NamespacedName, &site); err != nil {
        if apierrors.IsNotFound(err) { // gelöscht: Zeitreihe entfernen
            siteAvailable.DeleteLabelValues(req.Namespace, req.Name)
        }
        return ctrl.Result{}, client.IgnoreNotFound(err)
    }
make build >/dev/null && kill "$(cat lab/manager.pid)"
bin/manager --kubeconfig ~/op-lab/sa.kubeconfig -health-probe-bind-address=:8081 \
  --metrics-bind-address=:8443 > lab/run.log 2>&1 &
echo $! > lab/manager.pid
sleep 4
kubectl patch staticsite demo --type=merge -p '{"spec":{"replicas":2}}'
sleep 2
curl -sk -H "Authorization: Bearer $T" https://localhost:8443/metrics \
  | grep '^site_operator'

Erwartet:

staticsite.web.lab.example/demo patched
site_operator_child_writes_total{kind="ConfigMap",operation="unchanged"} 3
site_operator_child_writes_total{kind="Deployment",operation="unchanged"} 2
site_operator_child_writes_total{kind="Deployment",operation="updated"} 1
site_operator_child_writes_total{kind="Service",operation="unchanged"} 3
site_operator_site_available{name="demo",namespace="default"} 0

Genau ein updated für das Deployment (Replicas 1 → 2), alles andere unchanged. available bleibt 0 – in envtest startet kein Pod.

Achtung: Jede Label-Kombination ist eine eigene Zeitreihe. namespace/name sind bei ein paar hundert Sites in Ordnung, bei zehntausenden nicht. Niemals freie Texte (Fehlermeldungen, URLs) als Label verwenden.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Strukturierte Logs

Das Gerüst setzt zap.Options{Development: true}: lesbare Konsole, Level Debug. In Produktion willst du JSON – Loki, Elasticsearch oder jq können damit filtern. Die Flags dafür bringt opts.BindFlags schon mit:

kill "$(cat lab/manager.pid)"
bin/manager --kubeconfig ~/op-lab/sa.kubeconfig -health-probe-bind-address=:8081 \
  --zap-encoder=json --zap-log-level=info > lab/run.json 2>&1 &
echo $! > lab/manager.pid
sleep 3
kubectl patch staticsite demo --type=merge -p '{"spec":{"replicas":3}}'
sleep 2
jq -c 'select(.msg == "Deployment abgeglichen") | {name, operation, reconcileID}' \
  lab/run.json

Erwartet (IDs gekürzt):

staticsite.web.lab.example/demo patched
{"name":"demo","operation":"unchanged","reconcileID":"e9b645a8-3b59-40a1-b84e-..."}
{"name":"demo","operation":"updated","reconcileID":"d405209b-a0e4-475f-92f4-..."}
{"name":"demo","operation":"unchanged","reconcileID":"85afde9d-dc91-4d76-aa03-..."}

Jede Zeile trägt automatisch controller, namespace, name und eine reconcileID – controller-runtime hängt sie an den Logger im Kontext (logf.FromContext(ctx)). Alle Zeilen eines Reconcile-Laufs findest du über die ID. Eigene Schlüssel kommen als Paare dazu, nie per fmt.Sprintf in die Nachricht:

    log := logf.FromContext(ctx).WithValues("generation", site.Generation)
    log.Info("Deployment abgeglichen", "operation", op)  // gut: filterbar
    log.Info(fmt.Sprintf("Deployment %s: %s", site.Name, op)) // schlecht

--zap-log-level=info blendet log.V(1) aus; --zap-log-level=debug (oder 2, 3 …) zeigt mehr. Die Flags gehören in die args des Deployments.

Tracing-Ausblick: controller-runtime hat kein eingebautes Tracing für Reconcile. Mit OpenTelemetry (go.opentelemetry.io/otel) startest du in Reconcile einen Span, gibst den ctx weiter und instrumentierst den HTTP-Client des Registrars (otelhttp.NewTransport) – dann siehst du, ob ein langsamer Reconcile am API-Server oder am externen Dienst hängt. Der kube-apiserver kann selbst Spans exportieren (--tracing-config-file); beides zusammen ergibt durchgehende Traces.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Manager läuft mit dem ServiceAccount-Token, Metriken auf :8443, Probes auf :8081:

kill "$(cat lab/manager.pid)"
bin/manager --kubeconfig ~/op-lab/sa.kubeconfig -health-probe-bind-address=:8081 \
  --metrics-bind-address=:8443 > lab/run.log 2>&1 &
echo $! > lab/manager.pid
cat > lab/check.sh <<'EOF'
ok()  { echo "✔ $1"; }
nok() { echo "✘ $1"; }
SA=system:serviceaccount:site-operator-system:site-operator-controller-manager
sleep 4
[ "$(kubectl auth can-i watch services --as=$SA)" = yes ] \
  && ok "RBAC: Services beobachten" || nok "RBAC fehlt"
[ "$(kubectl auth can-i delete deployments --as=$SA)" = no ] \
  && ok "RBAC: kein delete" || nok "RBAC zu weit"
curl -s 'localhost:8081/readyz?verbose' | grep -q '\[+\]informers ok' \
  && ok "readyz mit Cache-Check" || nok "readyz"
T=$(kubectl create token prometheus)
curl -sk -H "Authorization: Bearer $T" https://localhost:8443/metrics \
  | grep -q '^site_operator_site_available' && ok "eigene Metriken" || nok "Metriken"
[ "$(curl -sk -o /dev/null -w '%{http_code}' https://localhost:8443/metrics)" = 401 ] \
  && ok "Metriken ohne Token gesperrt" || nok "Metriken offen"
grep -q 'leader-election-namespace' cmd/main.go && ok "Lease-Namespace-Flag" \
  || nok "Flag fehlt"
EOF
bash lab/check.sh

Erwartet:

✔ RBAC: Services beobachten
✔ RBAC: kein delete
✔ readyz mit Cache-Check
✔ eigene Metriken
✔ Metriken ohne Token gesperrt
✔ Lease-Namespace-Flag

Challenge

Miss die Aufrufe beim DNS-Registrar (Tag 7): ein Histogramm site_operator_registrar_request_duration_seconds mit den Labels method (PUT/DELETE) und result (ok/error). Prüfe es mit laufendem registrar und --registrar-url.

Hinweis: Alle Aufrufe laufen durch Client.do in internal/registrar/client.go – dort reicht ein defer mit time.Since.

Lösung

cat > internal/registrar/metrics.go <<'EOF'
package registrar

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

var requestDuration = prometheus.NewHistogramVec(prometheus.HistogramOpts{
    Name:    "site_operator_registrar_request_duration_seconds",
    Help:    "Dauer der Aufrufe beim DNS-Registrar",
    Buckets: []float64{.005, .025, .1, .5, 1, 5},
}, []string{"method", "result"})

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

In Client.do den Rückgabewert benennen und am Anfang messen:

func (c *Client) do(ctx context.Context, method, name string, body []byte,
    ok ...int) (err error) {
    defer func(start time.Time) {
        result := "ok"
        if err != nil {
            result = "error"
        }
        requestDuration.WithLabelValues(method, result).
            Observe(time.Since(start).Seconds())
    }(time.Now())
registrar 2> lab/registrar.log &   # Tag 7, Port 18090
echo $! > lab/registrar.pid
make build >/dev/null && kill "$(cat lab/manager.pid)"
bin/manager --kubeconfig ~/op-lab/sa.kubeconfig -health-probe-bind-address=:8081 \
  --metrics-bind-address=:8443 --registrar-url=http://127.0.0.1:18090 \
  > lab/run.log 2>&1 &
echo $! > lab/manager.pid
sleep 4
curl -sk -H "Authorization: Bearer $T" https://localhost:8443/metrics \
  | grep 'registrar_request_duration_seconds_count'

Erwartet:

site_operator_registrar_request_duration_seconds_count{method="PUT",result="ok"} 1

Der Code-Stand in code/tag11-site-operator enthält die Challenge nicht.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • RBAC-Marker sind Code und gehören ins Review: jedes neue Verb, besonders auf secrets, * oder clusterweite Ressourcen. Mit kubebuilder edit --namespaced (oder rbac.namespaced im Helm-Chart) wird aus der ClusterRole eine Role, wenn der Operator nur einen Namespace verwaltet.
  • Im Cluster liest Prometheus die Metriken per ServiceMonitor (config/prometheus) mit dem Token seines ServiceAccounts; dieser braucht die Rolle metrics-reader. Für Produktion statt selbstsignierter Zertifikate cert-manager (--metrics-cert-path).
  • Lease-Zeiten bestimmen die Ausfallzeit beim Leaderwechsel; auf überlasteten API-Servern können zu kurze Zeiten zu ständigem Leaderwechsel führen (Tag 13).
  • Readiness: nur prüfen, was der Pod selbst beheben kann bzw. was ihn nutzlos macht (Cache, Webhook-Server). Externe Dienste gehören in Conditions und Metriken, nicht in Liveness – sonst startet ein Ausfall des Registrars alle Operator-Pods neu.
  • Logs gehen bei vielen Kunden in ein zentrales SIEM: keine Tokens, Secrets oder vollständigen Spec-Inhalte loggen; JSON mit stabilen Schlüsseln (namespace, name, reconcileID) erleichtert Korrelation.