Zum Inhalt springen
Trainingslager IT-Trainingslager

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-up im 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-operator

Teil 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' PROJECT

Erwartet:

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.go

Erwartet:

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())
})
EOF

Die 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 Owns oder 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.sh

Erwartet:

✔ 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.

  1. Was bedeutet „level-based” im Gegensatz zu „edge-based” beim Reconcile?
  2. Welche Aufgaben übernimmt die Workqueue zwischen Informer und Reconcile?
  3. Warum liest ein Controller über einen Lister bzw. Cache statt direkt vom API-Server?
  4. Was liefert controllerutil.CreateOrUpdate zurück, und wann schreibt es?
  5. Was bewirkt SetControllerReference zusammen mit Owns()?
  6. Wann gibst du RequeueAfter zurück, wann einen Fehler, wann reconcile.TerminalError?
  7. Wozu dient status.observedGeneration?
  8. Warum ändert ein Status-Update metadata.generation nicht?
  9. Wann ändert meta.SetStatusCondition die lastTransitionTime?
  10. Was passiert beim Löschen eines Objekts mit Finalizer?
  11. Warum entfernt der Operator seinen Finalizer erst nach erfolgreichem externem Aufräumen?
  12. Welche Validierung gehört in OpenAPI-Marker oder CEL, welche in einen Webhook?
  13. Was prüft eine CEL-Transition-Rule mit oldSelf, und wann wird sie ausgewertet?
  14. Was bedeutet failurePolicy: Fail bei einem Webhook im Betrieb?
  15. Was ist bei Conversion der Hub, was ein Spoke?
  16. Was legt +kubebuilder:storageversion fest, und was steht in status.storedVersions?
  17. Wofür brauchst du einen Field-Index beim Watch auf referenzierte ConfigMaps?
  18. Was filtert GenerationChangedPredicate, und was verpasst du damit?
  19. Woher kommen die Regeln in config/rbac/role.yaml?
  20. Warum braucht ein Operator mit mehreren Replikas Leader Election?
  21. Nenne zwei eingebaute Metriken von controller-runtime, die einen Hotloop oder Fehler zeigen.
  22. Warum entsteht die Meldung „the object has been modified”, und wie vermeidest du sie bei Status-Writes?
  23. Was zeigt kubectl get … --show-managed-fields, und wofür nutzt du es beim Debugging?
  24. Was fehlt envtest im Vergleich zu einem echten Cluster, und was folgt daraus für Tests?
  25. Warum kann ein Label-Selektor in den Cache-Optionen ein NotFound für existierende Objekte erzeugen?

Lösungsschlüssel

  1. Reconcile gleicht immer den ganzen Ist- mit dem Soll-Zustand ab, egal welches Ereignis ihn ausgelöst hat oder wie oft.
  2. Sie entdoppelt Keys, serialisiert die Arbeit pro Key und wiederholt Fehler mit Rate-Limiting/Backoff.
  3. Der Cache wird per Watch aktuell gehalten und entlastet den API-Server; Lesen kostet keinen Request.
  4. Die Operation (created, updated, unchanged); geschrieben wird nur, wenn die Mutate-Funktion das Objekt verändert hat.
  5. Das Kind bekommt eine Controller-Owner-Reference: Änderungen am Kind wecken den Besitzer, und der Garbage Collector löscht es mit dem Besitzer.
  6. RequeueAfter für erwartetes Warten (Polling, fehlende Abhängigkeit), Fehler für Wiederholung mit Backoff, TerminalError für Fehler, die ein Retry nicht behebt.
  7. Sie zeigt, welche Spec-Generation der Controller zuletzt verarbeitet hat; kubectl wait und Nutzer erkennen veraltete Status.
  8. Weil generation nur bei Änderungen an der Spec (nicht an Status oder Metadaten) erhöht wird, wenn der Status-Subresource aktiv ist.
  9. Nur wenn sich der status der Condition wirklich ändert, nicht bei neuer Message oder Reason.
  10. Der API-Server setzt nur deletionTimestamp; das Objekt bleibt, bis alle Finalizer entfernt sind.
  11. Sonst verschwindet das Objekt und mit ihm die einzige Erinnerung an die externe Ressource – sie bliebe als Leiche zurück.
  12. Feldregeln und Beziehungen innerhalb des Objekts in Marker/CEL; alles, was Nachbarobjekte, externe Daten oder Operator-Konfiguration braucht, in einen Webhook.
  13. Sie vergleicht neuen und alten Wert (z. B. unveränderlich, nur wachsend) und wird nur bei Updates ausgewertet, nicht beim Anlegen.
  14. Ist der Webhook nicht erreichbar, lehnt der API-Server alle passenden Requests ab – Operator weg heißt API weg.
  15. Der Hub ist die zentrale Version, in die und aus der jede andere Version (Spoke) konvertiert wird.
  16. Die Version, in der etcd das Objekt speichert; storedVersions listet alle Versionen, die jemals gespeichert wurden und für eine Migration relevant sind.
  17. Um aus einer geänderten ConfigMap effizient alle StaticSites zu finden, die auf sie zeigen (client.MatchingFields).
  18. Updates ohne Spec-Änderung, also auch reine Status-, Label- und Annotation-Änderungen der eigenen Ressource.
  19. Aus den +kubebuilder:rbac-Markern, erzeugt von make manifests (controller-gen).
  20. Damit nur eine Instanz reconciled und sich Replikas nicht gegenseitig überschreiben; die anderen stehen bereit.
  21. controller_runtime_reconcile_total (Rate) und controller_runtime_reconcile_errors_total, dazu workqueue_depth.
  22. Ein Update mit veralteter resourceVersion scheitert am optimistischen Locking; für Status Status().Patch mit MergeFrom oder SSA verwenden.
  23. Welcher Manager welche Felder mit welcher Operation zuletzt geschrieben hat – so findest du konkurrierende Schreiber und Hotloops.
  24. Scheduler, Controller-Manager (Deployment-Controller, Garbage Collector, Namespace-Controller) und Nodes; Status und Aufräumen simulierst du im Test selbst.
  25. 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.