Anhang B: Abschlussprüfung
Ziel: Nachweisen, dass du einen Operator allein von der leeren Mappe bis zum getesteten, lauffähigen Controller baust · Dauer: 150 min Praxis + 25 min Fragen · Voraussetzung: Tag 15
Regeln
- Gelände wie gewohnt:
source ~/op-lab/env.sh,envtest-upim zweiten Terminal, Kubebuilder v4.16.0, Go 1.26. - Erlaubt:
--help,go doc, Anhang A, book.kubebuilder.io, pkg.go.dev. Nicht erlaubt: Code aus~/op-lab/tag*kopieren – abtippen und anpassen schon. - Die Tests in Aufgabe 5 sind vorgegeben und werden nicht verändert. Sie sind die Spezifikation.
- Jede Aufgabe zählt nur, wenn ihr Prüfbefehl die erwartete Ausgabe liefert.
- Bestanden: mindestens 70 von 100 Punkten und Aufgabe 5 gelöst.
Der Auftrag
Plattform-Team, Ticket OPS-117: „Teams sollen ihre Quota selbst per
CR pflegen, ohne Rechte auf ResourceQuota.” Du baust den
quota-operator:
NamespaceQuota "standard" (ops.lab.example/v1alpha1, Namespace team-a)
spec: pods (1..100, Pflicht), cpu (Quantity, optional), memory (optional)
status: observedGeneration, conditions[Ready]
|
| ownerReference (controller: true)
+--> ResourceQuota "standard" spec.hard: pods, requests.cpu, requests.memory
Label app.kubernetes.io/managed-by: quota-operator
| Anforderung | Detail |
|---|---|
| Projekt | --domain lab.example --repo example.com/quota-operator,
Gruppe ops, Kind NamespaceQuota |
| Kurzname | nsq |
| Spalten | Pods (.spec.pods), Ready
(Status der Condition Ready) |
| Status | Ready=True, Reason QuotaApplied; bei
Fehler False, Reason ApplyFailed |
| Kinder | ResourceQuota gleichen Namens, Owner Reference, Drift wird zurückgedreht |
| Ruhe | Kein Write, wenn sich nichts geändert hat; Status per Patch |
mkdir -p ~/op-lab/pruefung/quota-operator && cd ~/op-lab/pruefung/quota-operatorTeil 1: Praktische Prüfung
Aufgabe 1: Projekt und API-Gerüst (5 Punkte)
Projekt anlegen, API mit Controller erzeugen.
grep -E '^(domain|repo):' PROJECT
grep -c 'kind: NamespaceQuota' PROJECTErwartet:
domain: lab.example
repo: example.com/quota-operator
1
Aufgabe 2: Der Typ (15 Punkte)
NamespaceQuotaSpec mit pods
(int32), cpu und memory
(*resource.Quantity), Status mit
observedGeneration und conditions (List-Map
nach type), Marker für Status-Subresource, Kurzname und
beide Spalten. Danach make manifests generate, dann in
Terminal 2 envtest-up -crds config/crd/bases.
kubectl get crd namespacequotas.ops.lab.example -o jsonpath=\
'{.spec.names.shortNames} {.spec.versions[0].additionalPrinterColumns[*].name}{"\n"}'
kubectl explain nsq.spec.pods | grep -E 'FIELD|integer'Erwartet:
["nsq"] Pods Ready
FIELD: pods <integer>
Aufgabe 3: Der Reconciler (20 Punkte)
ResourceQuota per CreateOrUpdate mit Label und
SetControllerReference, Status mit
meta.SetStatusCondition und Status().Patch,
nur bei Änderung. For mit
GenerationChangedPredicate,
Owns(&corev1.ResourceQuota{}). Pods-Wert:
resource.NewQuantity(int64(nq.Spec.Pods), resource.DecimalSI).
go build ./... && echo build-ok
grep -c 'SetControllerReference\|Status().Patch\|GenerationChangedPredicate' \
internal/controller/namespacequota_controller.goErwartet:
build-ok
3
Aufgabe 4: RBAC (10 Punkte)
Marker so knapp wie möglich: NamespaceQuotas lesen, Status patchen,
ResourceQuotas lesen und schreiben. Kein delete, kein
*.
make manifests >/dev/null
grep -cE -- "- (delete|'\*')$" config/rbac/role.yaml
grep -B2 -A10 ' - resourcequotas' config/rbac/role.yaml | grep -c -- ' - create'Erwartet:
0
1
Aufgabe 5: Die vorgegebenen Tests (20 Punkte, Pflicht)
Ersetze die beiden Test-Dateien des Gerüsts durch diese Spezifikation. Die Suite startet einen echten Manager mit deinem Reconciler gegen envtest:
cat > internal/controller/suite_test.go <<'EOF'
package controller
import (
"context"
"path/filepath"
"testing"
"time"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
"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"
opsv1alpha1 "example.com/quota-operator/api/v1alpha1"
)
var (
ctx context.Context
cancel context.CancelFunc
testEnv *envtest.Environment
k8sClient client.Client
)
func TestControllers(t *testing.T) {
RegisterFailHandler(Fail)
RunSpecs(t, "Prüfung Suite")
}
var _ = BeforeSuite(func() {
logf.SetLogger(zap.New(zap.WriteTo(GinkgoWriter), zap.UseDevMode(true)))
SetDefaultEventuallyTimeout(10 * time.Second)
SetDefaultEventuallyPollingInterval(100 * time.Millisecond)
ctx, cancel = context.WithCancel(context.Background())
Expect(opsv1alpha1.AddToScheme(scheme.Scheme)).To(Succeed())
testEnv = &envtest.Environment{
CRDDirectoryPaths: []string{
filepath.Join("..", "..", "config", "crd", "bases"),
},
ErrorIfCRDPathMissing: true,
}
cfg, err := testEnv.Start()
Expect(err).NotTo(HaveOccurred())
k8sClient, err = client.New(cfg, client.Options{Scheme: scheme.Scheme})
Expect(err).NotTo(HaveOccurred())
mgr, err := ctrl.NewManager(cfg, ctrl.Options{
Scheme: scheme.Scheme,
Metrics: metricsserver.Options{BindAddress: "0"},
})
Expect(err).NotTo(HaveOccurred())
Expect((&NamespaceQuotaReconciler{
Client: mgr.GetClient(),
Scheme: mgr.GetScheme(),
}).SetupWithManager(mgr)).To(Succeed())
go func() {
defer GinkgoRecover()
Expect(mgr.Start(ctx)).To(Succeed())
}()
})
var _ = AfterSuite(func() {
cancel()
Expect(testEnv.Stop()).To(Succeed())
})
EOFDie sechs Prüfungen A1 bis A6:
cat > internal/controller/namespacequota_controller_test.go <<'EOF'
package controller
import (
"time"
. "github.com/onsi/ginkgo/v2"
. "github.com/onsi/gomega"
corev1 "k8s.io/api/core/v1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
"k8s.io/apimachinery/pkg/api/meta"
"k8s.io/apimachinery/pkg/api/resource"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/utils/ptr"
"sigs.k8s.io/controller-runtime/pkg/client"
opsv1alpha1 "example.com/quota-operator/api/v1alpha1"
)
var _ = Describe("NamespaceQuota", func() {
var (
ns string
key client.ObjectKey
nq *opsv1alpha1.NamespaceQuota
)
BeforeEach(func(ctx SpecContext) {
n := &corev1.Namespace{ObjectMeta: metav1.ObjectMeta{GenerateName: "exam-"}}
Expect(k8sClient.Create(ctx, n)).To(Succeed())
ns = n.Name
key = client.ObjectKey{Namespace: ns, Name: "team"}
nq = &opsv1alpha1.NamespaceQuota{
ObjectMeta: metav1.ObjectMeta{Name: "team", Namespace: ns},
Spec: opsv1alpha1.NamespaceQuotaSpec{
Pods: 10, CPU: ptr.To(resource.MustParse("2")),
},
}
})
hard := func(ctx SpecContext) func() corev1.ResourceList {
return func() corev1.ResourceList {
rq := &corev1.ResourceQuota{}
if err := k8sClient.Get(ctx, key, rq); err != nil {
return nil
}
return rq.Spec.Hard
}
}
pods := func(l corev1.ResourceList) int64 { return l.Pods().Value() }
It("A1 erzeugt die ResourceQuota mit Owner", func(ctx SpecContext) {
Expect(k8sClient.Create(ctx, nq)).To(Succeed())
Eventually(hard(ctx)).WithContext(ctx).Should(HaveLen(2))
rq := &corev1.ResourceQuota{}
Expect(k8sClient.Get(ctx, key, rq)).To(Succeed())
Expect(pods(rq.Spec.Hard)).To(Equal(int64(10)))
Expect(rq.Spec.Hard.Name(corev1.ResourceRequestsCPU, resource.DecimalSI).
String()).To(Equal("2"))
Expect(metav1.IsControlledBy(rq, nq)).To(BeTrue())
})
It("A2 folgt Änderungen der Spec", func(ctx SpecContext) {
Expect(k8sClient.Create(ctx, nq)).To(Succeed())
Eventually(hard(ctx)).WithContext(ctx).ShouldNot(BeEmpty())
orig := nq.DeepCopy() // Patch statt Update: der Status ändert sich parallel
nq.Spec.Pods = 20
nq.Spec.Memory = ptr.To(resource.MustParse("4Gi"))
Expect(k8sClient.Patch(ctx, nq, client.MergeFrom(orig))).To(Succeed())
Eventually(func() int64 { return pods(hard(ctx)()) }).
WithContext(ctx).Should(Equal(int64(20)))
Expect(hard(ctx)()).To(HaveKey(corev1.ResourceRequestsMemory))
})
It("A3 dreht Drift zurück", func(ctx SpecContext) {
Expect(k8sClient.Create(ctx, nq)).To(Succeed())
Eventually(hard(ctx)).WithContext(ctx).ShouldNot(BeEmpty())
rq := &corev1.ResourceQuota{}
Expect(k8sClient.Get(ctx, key, rq)).To(Succeed())
rq.Spec.Hard[corev1.ResourcePods] = resource.MustParse("99")
Expect(k8sClient.Update(ctx, rq)).To(Succeed())
Eventually(func() int64 { return pods(hard(ctx)()) }).
WithContext(ctx).Should(Equal(int64(10)))
})
It("A4 meldet Ready mit observedGeneration", func(ctx SpecContext) {
Expect(k8sClient.Create(ctx, nq)).To(Succeed())
Eventually(func(g Gomega) {
got := &opsv1alpha1.NamespaceQuota{}
g.Expect(k8sClient.Get(ctx, key, got)).To(Succeed())
c := meta.FindStatusCondition(got.Status.Conditions, "Ready")
g.Expect(c).NotTo(BeNil())
g.Expect(c.Status).To(Equal(metav1.ConditionTrue))
g.Expect(got.Status.ObservedGeneration).To(Equal(got.Generation))
}).WithContext(ctx).Should(Succeed())
})
It("A5 lehnt pods außerhalb 1..100 ab", func(ctx SpecContext) {
for _, p := range []int32{0, 101} {
bad := nq.DeepCopy()
bad.Spec.Pods = p
err := k8sClient.Create(ctx, bad)
Expect(apierrors.IsInvalid(err)).To(BeTrue(), "pods=%d: %v", p, err)
}
})
It("A6 schreibt im Ruhezustand nichts mehr", func(ctx SpecContext) {
Expect(k8sClient.Create(ctx, nq)).To(Succeed())
Eventually(hard(ctx)).WithContext(ctx).ShouldNot(BeEmpty())
time.Sleep(time.Second)
versions := func() []string {
a, b := &opsv1alpha1.NamespaceQuota{}, &corev1.ResourceQuota{}
Expect(k8sClient.Get(ctx, key, a)).To(Succeed())
Expect(k8sClient.Get(ctx, key, b)).To(Succeed())
return []string{a.ResourceVersion, b.ResourceVersion}
}
before := versions()
Consistently(versions).WithContext(ctx).
WithTimeout(2 * time.Second).Should(Equal(before))
})
})
EOF
go test -count=1 ./internal/controller/Erwartet:
ok example.com/quota-operator/internal/controller 9.635s
Tipp: Schlägt A6 fehl, schreibt dein Reconciler im Ruhezustand – Status ohne Vergleich oder ohne Prädikat (Tag 15, Drill 1). Schlägt A3 fehl, fehlt
Ownsoder die Owner Reference (Drill 8).
Aufgabe 6: Live in envtest (15 Punkte)
envtest-up läuft mit deiner CRD, der Operator in Terminal 3
(go run ./cmd/main.go -health-probe-bind-address=0). Lege
eine Beispiel-Quota an:
kubectl create namespace team-a
kubectl apply -n team-a -f - <<'EOF'
apiVersion: ops.lab.example/v1alpha1
kind: NamespaceQuota
metadata:
name: standard
spec:
pods: 20
cpu: "4"
memory: 8Gi
EOF
kubectl -n team-a wait nsq/standard --for=condition=Ready --timeout=30s
kubectl -n team-a get nsq
kubectl -n team-a get resourcequota standard \
-o jsonpath='{.spec.hard} {.metadata.ownerReferences[0].kind}{"\n"}'Erwartet:
namespace/team-a created
namespacequota.ops.lab.example/standard created
namespacequota.ops.lab.example/standard condition met
NAME PODS READY
standard 20 True
{"pods":"20","requests.cpu":"4","requests.memory":"8Gi"} NamespaceQuota
Aufgabe 7: Validierung live (5 Punkte)
kubectl -n team-a patch nsq standard --type merge -p '{"spec":{"pods":0}}'Erwartet (umbrochen):
The NamespaceQuota "standard" is invalid: spec.pods: Invalid value: 0:
spec.pods in body should be greater than or equal to 1
Aufgabe 8: Das Prüfskript (10 Punkte)
mkdir -p lab
cat > lab/pruefung.sh <<'EOF'
# Prüfskript Abschlussprüfung (im Projektordner quota-operator ausführen)
ok() { echo "✔ $1"; }
nok() { echo "✘ $1"; }
chk() { if eval "$2" >/dev/null 2>&1; then ok "$1"; else nok "$1"; fi; }
CRD=config/crd/bases/ops.lab.example_namespacequotas.yaml
sum() { cat config/crd/bases/*.yaml config/rbac/role.yaml | shasum; }
s1=$(sum); make manifests generate >/dev/null 2>&1; s2=$(sum)
chk "Manifeste aktuell (make manifests ändert nichts)" '[ "$s1" = "$s2" ]'
chk "go vet sauber" 'go vet ./...'
chk "CRD: Spalte Pods" 'grep -q "name: Pods" $CRD'
chk "CRD: pods 1..100" 'grep -q "maximum: 100" $CRD && grep -q "minimum: 1" $CRD'
chk "CRD: Status-Subresource" 'grep -q "status: {}" $CRD'
chk "RBAC: resourcequotas anlegen" \
'grep -A12 " - resourcequotas" config/rbac/role.yaml | grep -q " - create"'
chk "Owns(ResourceQuota)" 'grep -rq "Owns(&corev1.ResourceQuota{})" internal/controller'
chk "kein Status().Update" '! grep -rq "Status().Update" internal/controller'
chk "envtest-Tests A1–A6 grün" 'go test -count=1 ./internal/controller/'
EOF
bash lab/pruefung.shErwartet:
✔ Manifeste aktuell (make manifests ändert nichts)
✔ go vet sauber
✔ CRD: Spalte Pods
✔ CRD: pods 1..100
✔ CRD: Status-Subresource
✔ RBAC: resourcequotas anlegen
✔ Owns(ResourceQuota)
✔ kein Status().Update
✔ envtest-Tests A1–A6 grün
Punkte
| Aufgabe | Punkte | erreicht |
|---|---|---|
| 1 Projekt und API-Gerüst | 5 | |
| 2 Der Typ | 15 | |
| 3 Der Reconciler | 20 | |
| 4 RBAC | 10 | |
| 5 Vorgegebene Tests (Pflicht) | 20 | |
| 6 Live in envtest | 15 | |
| 7 Validierung live | 5 | |
| 8 Prüfskript | 10 | |
| Summe | 100 |
Teil 2: Kurzfragen
Je 1 Punkt, Bestehensgrenze 18 von 25. Antworte in einem Satz.
- Was bedeutet „level-based” im Gegensatz zu „edge-based” beim Reconcile?
- Welche Aufgaben übernimmt die Workqueue zwischen Informer und Reconcile?
- Warum liest ein Controller über einen Lister bzw. Cache statt direkt vom API-Server?
- Was liefert
controllerutil.CreateOrUpdatezurück, und wann schreibt es? - Was bewirkt
SetControllerReferencezusammen mitOwns()? - Wann gibst du
RequeueAfterzurück, wann einen Fehler, wannreconcile.TerminalError? - Wozu dient
status.observedGeneration? - Warum ändert ein Status-Update
metadata.generationnicht? - Wann ändert
meta.SetStatusConditiondielastTransitionTime? - Was passiert beim Löschen eines Objekts mit Finalizer?
- Warum entfernt der Operator seinen Finalizer erst nach erfolgreichem externem Aufräumen?
- Welche Validierung gehört in OpenAPI-Marker oder CEL, welche in einen Webhook?
- Was prüft eine CEL-Transition-Rule mit
oldSelf, und wann wird sie ausgewertet? - Was bedeutet
failurePolicy: Failbei einem Webhook im Betrieb? - Was ist bei Conversion der Hub, was ein Spoke?
- Was legt
+kubebuilder:storageversionfest, und was steht instatus.storedVersions? - Wofür brauchst du einen Field-Index beim Watch auf referenzierte ConfigMaps?
- Was filtert
GenerationChangedPredicate, und was verpasst du damit? - Woher kommen die Regeln in
config/rbac/role.yaml? - Warum braucht ein Operator mit mehreren Replikas Leader Election?
- Nenne zwei eingebaute Metriken von controller-runtime, die einen Hotloop oder Fehler zeigen.
- Warum entsteht die Meldung „the object has been modified”, und wie vermeidest du sie bei Status-Writes?
- Was zeigt
kubectl get … --show-managed-fields, und wofür nutzt du es beim Debugging? - Was fehlt envtest im Vergleich zu einem echten Cluster, und was folgt daraus für Tests?
- Warum kann ein Label-Selektor in den Cache-Optionen ein
NotFoundfür existierende Objekte erzeugen?
Lösungsschlüssel
- Reconcile gleicht immer den ganzen Ist- mit dem Soll-Zustand ab, egal welches Ereignis ihn ausgelöst hat oder wie oft.
- Sie entdoppelt Keys, serialisiert die Arbeit pro Key und wiederholt Fehler mit Rate-Limiting/Backoff.
- Der Cache wird per Watch aktuell gehalten und entlastet den API-Server; Lesen kostet keinen Request.
- Die Operation (
created,updated,unchanged); geschrieben wird nur, wenn die Mutate-Funktion das Objekt verändert hat. - Das Kind bekommt eine Controller-Owner-Reference: Änderungen am Kind wecken den Besitzer, und der Garbage Collector löscht es mit dem Besitzer.
RequeueAfterfür erwartetes Warten (Polling, fehlende Abhängigkeit), Fehler für Wiederholung mit Backoff,TerminalErrorfür Fehler, die ein Retry nicht behebt.- Sie zeigt, welche Spec-Generation der Controller zuletzt verarbeitet
hat;
kubectl waitund Nutzer erkennen veraltete Status. - Weil
generationnur bei Änderungen an der Spec (nicht an Status oder Metadaten) erhöht wird, wenn der Status-Subresource aktiv ist. - Nur wenn sich der
statusder Condition wirklich ändert, nicht bei neuer Message oder Reason. - Der API-Server setzt nur
deletionTimestamp; das Objekt bleibt, bis alle Finalizer entfernt sind. - Sonst verschwindet das Objekt und mit ihm die einzige Erinnerung an die externe Ressource – sie bliebe als Leiche zurück.
- Feldregeln und Beziehungen innerhalb des Objekts in Marker/CEL; alles, was Nachbarobjekte, externe Daten oder Operator-Konfiguration braucht, in einen Webhook.
- Sie vergleicht neuen und alten Wert (z. B. unveränderlich, nur wachsend) und wird nur bei Updates ausgewertet, nicht beim Anlegen.
- Ist der Webhook nicht erreichbar, lehnt der API-Server alle passenden Requests ab – Operator weg heißt API weg.
- Der Hub ist die zentrale Version, in die und aus der jede andere Version (Spoke) konvertiert wird.
- Die Version, in der etcd das Objekt speichert;
storedVersionslistet alle Versionen, die jemals gespeichert wurden und für eine Migration relevant sind. - Um aus einer geänderten ConfigMap effizient alle StaticSites zu
finden, die auf sie zeigen (
client.MatchingFields). - Updates ohne Spec-Änderung, also auch reine Status-, Label- und Annotation-Änderungen der eigenen Ressource.
- Aus den
+kubebuilder:rbac-Markern, erzeugt vonmake manifests(controller-gen). - Damit nur eine Instanz reconciled und sich Replikas nicht gegenseitig überschreiben; die anderen stehen bereit.
controller_runtime_reconcile_total(Rate) undcontroller_runtime_reconcile_errors_total, dazuworkqueue_depth.- Ein
Updatemit veralteterresourceVersionscheitert am optimistischen Locking; für StatusStatus().PatchmitMergeFromoder SSA verwenden. - Welcher Manager welche Felder mit welcher Operation zuletzt geschrieben hat – so findest du konkurrierende Schreiber und Hotloops.
- Scheduler, Controller-Manager (Deployment-Controller, Garbage Collector, Namespace-Controller) und Nodes; Status und Aufräumen simulierst du im Test selbst.
- Der Cache enthält nur Objekte, die den Selektor erfüllen, und der Client liest aus dem Cache – alles andere existiert für ihn nicht.
Teil 3: Selbsteinschätzung
| Thema | kann ich | im Lab gemacht |
|---|---|---|
| Gelände: envtest-up, setup-envtest (Tag 0) | [ ] | [ ] |
| Informer, Lister, Workqueue mit client-go (Tag 1) | [ ] | [ ] |
| Manager, Builder, Watches ohne Kubebuilder (Tag 2) | [ ] | [ ] |
| Kubebuilder-Projekt, Marker, CRD (Tag 3) | [ ] | [ ] |
| Reconcile, Owner References, Idempotenz (Tag 4) | [ ] | [ ] |
| Status, Conditions, Events (Tag 5) | [ ] | [ ] |
| envtest-Tests mit Ginkgo (Tag 6) | [ ] | [ ] |
| Finalizer und externe Ressourcen (Tag 7) | [ ] | [ ] |
| CEL und Webhooks (Tag 8) | [ ] | [ ] |
| Versionen und Conversion (Tag 9) | [ ] | [ ] |
| Watches, Predicates, Indexer (Tag 10) | [ ] | [ ] |
| RBAC, Leader Election, Metriken (Tag 11) | [ ] | [ ] |
| Ausliefern: Image, Kustomize, Helm (Tag 12) | [ ] | [ ] |
| Skalierung und Robustheit (Tag 13) | [ ] | [ ] |
| bao-operator gegen OpenBao (Tag 14) | [ ] | [ ] |
| Debug-Drills unter Zeitdruck (Tag 15) | [ ] | [ ] |
Jede Zeile ohne zwei Kreuze: das Kapitel noch einmal durcharbeiten. Danach: Baue einen Operator für ein echtes Problem aus deinem Alltag – das ist die eigentliche Prüfung.