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 manifestsschreibtconfig/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 perAddHealthzCheck/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-80Erwartet (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.yamlErwartet:
- 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
EOFname: 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/basesTerminal 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=$SAErwartet:
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.kubeconfigErwartet:
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.kubeconfigliegt nebenenvtest.kubeconfigund ist nur für envtest gültig;envtest-uplöscht beim Beenden nur seine eigene Datei –sa.kubeconfigrä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.logErwartet:
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/readyzErwartet:
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
}
}
EOFIn 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-80Erwartet:
"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-systemErwartet:
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 +%TErwartet:
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/metricsErwartet:
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_depthundworkqueue_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)
}
EOFDrei 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/namesind 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.jsonErwartet (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.shErwartet:
✔ 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) }
EOFIn 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. Mitkubebuilder edit --namespaced(oderrbac.namespacedim 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 Rollemetrics-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.