Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 8: Validierung – Marker, CEL und Webhooks

Ziel: Ungültige StaticSites kommen gar nicht erst in den Cluster: OpenAPI-Marker und CEL-Regeln im API-Server, dazu ein Defaulting- und ein Validating-Webhook für alles, was CEL nicht kann – getestet in envtest · Dauer: ca. 150 min · Voraussetzung: Tag 7

Briefing

  • Je früher abgelehnt, desto besser: Ein Fehler beim kubectl apply ist billiger als ein Degraded im Status.
  • OpenAPI-Marker (Min/Max/Länge/Default) und CEL (x-kubernetes-validations) laufen im API-Server – ohne Code, ohne Zertifikate, ohne Ausfallrisiko.
  • Transition Rules (oldSelf) vergleichen alt und neu: unveränderliche Felder, nur wachsende Werte.
  • Webhooks nur für das, was CEL nicht kann: Nachbarobjekte lesen, Policy aus der Operator-Konfiguration, Normalisieren.
kubectl apply
  -> Mutating Webhook  (Default: path normalisieren)
  -> Schema + Defaults + CEL  (Typen, 1..10, genau eins, unveränderlich)
  -> Validating Webhook  (Registry-Policy, Warnung bei fehlender ConfigMap)
  -> etcd

Drill 1: Was die Marker schon leisten

source ~/op-lab/env.sh
cp -r ~/op-lab/tag07-site-operator ~/op-lab/tag08-site-operator
cd ~/op-lab/tag08-site-operator

Terminal 1: Control Plane mit dem CRD-Stand von heute starten (läuft bis zum Ende des Tages):

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

Terminal 2: Eine StaticSite mit gleich drei Fehlern:

cat > lab/kaputt.yaml <<'EOF'
apiVersion: web.lab.example/v1alpha1
kind: StaticSite
metadata:
  name: kaputt
spec:
  content: "<h1>Hallo</h1>"
  contentFrom:
    configMapRef:
      name: html
  replicas: 11
  image: nginx:latest
EOF
kubectl apply -f lab/kaputt.yaml

Erwartet (umbrochen):

The StaticSite "kaputt" is invalid: spec.replicas: Invalid value: 11:
  spec.replicas in body should be less than or equal to 10

Nur replicas fällt auf. Dass content und contentFrom gesetzt sind und :latest eingeschleust wird, lässt das Schema durch – das reparierst du jetzt.

Fortschritt speichern? Kostenlos registrieren

Drill 2: CEL – genau eins, kein latest

Zwei Marker in api/v1alpha1/staticsite_types.go. ExactlyOneOf (controller-tools ab v0.18) steht am Typ, die eigene CEL-Regel am Feld:

// StaticSiteSpec ist der Wunschzustand einer StaticSite.
// +kubebuilder:validation:ExactlyOneOf=content;contentFrom
type StaticSiteSpec struct {
    // ...
    // image ist das Webserver-Image.
    // +kubebuilder:default="nginxinc/nginx-unprivileged:1.31-alpine"
    // +kubebuilder:validation:XValidation:rule="!self.endsWith(':latest')"
    // +optional
    Image string `json:"image,omitempty"`

Achtung: Marker-Zeilen lassen sich nicht umbrechen. Ein message="…" ist optional – ohne ihn meldet der API-Server failed rule: <Regel>. Bei kurzen Regeln reicht das völlig.

CRD neu erzeugen und die erzeugte Regel ansehen:

make manifests
grep -A3 'x-kubernetes-validations' \
  config/crd/bases/web.lab.example_staticsites.yaml

Erwartet (gekürzt):

                x-kubernetes-validations:
                - rule: '!self.endsWith('':latest'')'
--
            x-kubernetes-validations:
            - message: exactly one of the fields in [content contentFrom] must be
                set
              rule: (has(self.content)?1:0)+(has(self.contentFrom)?1:0) == 1

Die laufende Control Plane bekommt die neue CRD ohne Neustart, dann derselbe Versuch:

kubectl replace -f config/crd/bases/
kubectl apply -f lab/kaputt.yaml

Erwartet (umbrochen):

customresourcedefinition.apiextensions.k8s.io/staticsites.web.lab.example replaced
The StaticSite "kaputt" is invalid:
* spec.replicas: Invalid value: 11:
  spec.replicas in body should be less than or equal to 10
* spec: Invalid value: exactly one of the fields in [content contentFrom] must be set
* spec.image: Invalid value: "nginx:latest": failed rule: !self.endsWith(':latest')

Warum has()? Für optionale Felder heißt „nicht gesetzt” in CEL „nicht vorhanden”. Ein Zugriff auf ein fehlendes Feld wäre ein Laufzeitfehler der Regel.

Fortschritt speichern? Kostenlos registrieren

Drill 3: Transition Rule – path bleibt, wie er ist

Der Pfad bestimmt das Mount-Verzeichnis im Pod (Tag 4). Ändert ihn jemand im laufenden Betrieb, zeigen alte Links ins Leere – also unveränderlich machen:

    // path ist der URL-Pfad, unter dem die Seite ausgeliefert wird.
    // +kubebuilder:default="/"
    // +kubebuilder:validation:XValidation:rule="self == oldSelf"
    // +optional
    Path string `json:"path,omitempty"`

oldSelf gibt es nur bei Updates – beim Anlegen wird die Regel übersprungen. Ausprobieren:

make manifests && kubectl replace -f config/crd/bases/
kubectl apply -f - <<'EOF'
apiVersion: web.lab.example/v1alpha1
kind: StaticSite
metadata:
  name: demo
spec:
  content: "<h1>Hallo</h1>"
  path: /docs/
EOF
kubectl patch staticsite demo --type merge -p '{"spec":{"path":"/neu/"}}'
kubectl patch staticsite demo --type merge -p '{"spec":{"replicas":3}}'

Erwartet (umbrochen):

staticsite.web.lab.example/demo created
The StaticSite "demo" is invalid: spec.path: Invalid value: "/neu/":
  failed rule: self == oldSelf
staticsite.web.lab.example/demo patched

Fortschritt speichern? Kostenlos registrieren

Drill 4: CEL-Regeln in envtest festnageln

Die Regeln laufen im echten kube-apiserver von envtest – also gehören sie in die Controller-Suite. newStaticSite, newNamespace und siteMutator stammen aus Tag 6.

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

import (
    . "github.com/onsi/ginkgo/v2"
    . "github.com/onsi/gomega"
    "sigs.k8s.io/controller-runtime/pkg/client"

    webv1alpha1 "example.com/site-operator/api/v1alpha1"
)

var _ = DescribeTable("CEL-Regeln im API-Server",
    func(ctx SpecContext, mutate siteMutator, msg string) {
        site := newStaticSite(newNamespace(ctx), "cel", mutate)
        Expect(k8sClient.Create(ctx, site)).To(MatchError(ContainSubstring(msg)))
    },
    Entry("content und contentFrom", func(s *webv1alpha1.StaticSite) {
        s.Spec.ContentFrom = &webv1alpha1.ContentSource{
            ConfigMapRef: &webv1alpha1.ConfigMapReference{Name: "html"}}
    }, "exactly one of the fields"),
    Entry("weder noch", func(s *webv1alpha1.StaticSite) { s.Spec.Content = "" },
        "exactly one of the fields"),
    Entry(":latest", func(s *webv1alpha1.StaticSite) { s.Spec.Image = "nginx:latest" },
        "failed rule: !self.endsWith(':latest')"),
)

var _ = It("verbietet, path nachträglich zu ändern", func(ctx SpecContext) {
    site := newStaticSite(newNamespace(ctx), "pfad")
    Expect(k8sClient.Create(ctx, site)).To(Succeed())
    patch := client.MergeFrom(site.DeepCopy()) // Patch statt Update: kein Konflikt
    site.Spec.Path = "/neu/"
    Expect(k8sClient.Patch(ctx, site, patch)).
        To(MatchError(ContainSubstring("failed rule: self == oldSelf")))
})
EOF
go test ./internal/controller/ -count=1 -v -ginkgo.no-color -ginkgo.focus='CEL|path' \
  2>&1 | grep -E '^(Ran|SUCCESS|FAIL|ok)'

Erwartet:

Ran 4 of 21 Specs in 5.163 seconds
SUCCESS! -- 4 Passed | 0 Failed | 0 Pending | 17 Skipped
ok      example.com/site-operator/internal/controller   5.601s

Warum Patch statt Update? Dein Controller schreibt parallel Finalizer und Status. Ein Update mit veraltetem resourceVersion scheitert dann mit Conflict – und der Test prüfte den falschen Fehler.

Fortschritt speichern? Kostenlos registrieren

Drill 5: Webhooks erzeugen, Defaulter schreiben

kubebuilder create webhook --group web --version v1alpha1 --kind StaticSite \
  --defaulting --programmatic-validation
ls internal/webhook/v1alpha1/

Erwartet:

staticsite_webhook.go  staticsite_webhook_test.go  webhook_suite_test.go

Kubebuilder hat außerdem cmd/main.go erweitert (Block ENABLE_WEBHOOKS), config/webhook/ angelegt und PROJECT aktualisiert. Die zwei +kubebuilder:webhook-Marker in staticsite_webhook.go sind über 250 Zeichen lang – du rettest sie in eine eigene Datei und schreibst den Rest neu:

cd internal/webhook/v1alpha1
{ echo '// Marker für controller-gen: erzeugen config/webhook/manifests.yaml.'
  echo 'package v1alpha1'; echo
  grep '+kubebuilder:webhook:' staticsite_webhook.go; } > markers.go
cd ~/op-lab/tag08-site-operator

Der Defaulter normalisiert spec.path: Aus docs, /docs oder docs/ wird /docs/. Das kann kein Schema-Default, der setzt nur fehlende Werte. Der Validator kommt in Drill 6 dazu, hier schon die ganze Datei:

cat > internal/webhook/v1alpha1/staticsite_webhook.go <<'EOF'
package v1alpha1

import (
    "context"
    "fmt"
    "strings"

    corev1 "k8s.io/api/core/v1"
    apierrors "k8s.io/apimachinery/pkg/api/errors"
    "k8s.io/apimachinery/pkg/util/validation/field"
    ctrl "sigs.k8s.io/controller-runtime"
    "sigs.k8s.io/controller-runtime/pkg/client"
    "sigs.k8s.io/controller-runtime/pkg/webhook/admission"

    webv1alpha1 "example.com/site-operator/api/v1alpha1"
)

// AllowedImagePrefixes ist die Registry-Policy des Lab-Clusters.
var AllowedImagePrefixes = []string{"nginxinc/", "registry.lab.example/"}

var siteGK = webv1alpha1.GroupVersion.WithKind("StaticSite").GroupKind()

// SetupStaticSiteWebhookWithManager registriert Defaulter und Validator.
func SetupStaticSiteWebhookWithManager(mgr ctrl.Manager) error {
    return ctrl.NewWebhookManagedBy(mgr, &webv1alpha1.StaticSite{}).
        WithDefaulter(&StaticSiteDefaulter{}).
        WithValidator(&StaticSiteValidator{Reader: mgr.GetAPIReader()}).
        Complete()
}

// StaticSiteDefaulter normalisiert spec.path.
// +kubebuilder:object:generate=false
type StaticSiteDefaulter struct{}

// Default macht aus "docs" oder "/docs" den Pfad "/docs/".
func (d *StaticSiteDefaulter) Default(_ context.Context,
    site *webv1alpha1.StaticSite) error {
    p := strings.Trim(site.Spec.Path, "/")
    if p == "" {
        site.Spec.Path = "/"
        return nil
    }
    site.Spec.Path = "/" + p + "/"
    return nil
}

// StaticSiteValidator prüft, was CEL nicht kann: Policy und Nachbarobjekte.
// +kubebuilder:object:generate=false
type StaticSiteValidator struct {
    Reader client.Reader // liest direkt vom API-Server, ohne Cache
}

func (v *StaticSiteValidator) ValidateCreate(ctx context.Context,
    site *webv1alpha1.StaticSite) (admission.Warnings, error) {
    return v.validate(ctx, site)
}

func (v *StaticSiteValidator) ValidateUpdate(ctx context.Context,
    _, site *webv1alpha1.StaticSite) (admission.Warnings, error) {
    return v.validate(ctx, site)
}

func (v *StaticSiteValidator) ValidateDelete(context.Context,
    *webv1alpha1.StaticSite) (admission.Warnings, error) {
    return nil, nil
}

// validate: Registry-Policy hart durchsetzen, fehlende ConfigMap nur melden.
func (v *StaticSiteValidator) validate(ctx context.Context,
    site *webv1alpha1.StaticSite) (admission.Warnings, error) {
    if !allowedImage(site.Spec.Image) {
        return nil, apierrors.NewInvalid(siteGK, site.Name, field.ErrorList{
            field.Forbidden(field.NewPath("spec", "image"),
                fmt.Sprintf("erlaubt sind nur %v", AllowedImagePrefixes)),
        })
    }
    src := site.Spec.ContentFrom
    if src == nil || src.ConfigMapRef == nil {
        return nil, nil
    }
    key := client.ObjectKey{Namespace: site.Namespace, Name: src.ConfigMapRef.Name}
    err := v.Reader.Get(ctx, key, &corev1.ConfigMap{})
    if apierrors.IsNotFound(err) { // GitOps: Die ConfigMap kommt evtl. später
        return admission.Warnings{"ConfigMap " + key.Name + " fehlt (noch)"}, nil
    }
    return nil, nil // andere Fehler blockieren nicht, der Controller meldet sie
}

func allowedImage(image string) bool {
    for _, p := range AllowedImagePrefixes {
        if strings.HasPrefix(image, p) {
            return true
        }
    }
    return false
}
EOF
make manifests && go build ./... && echo ok

Erwartet:

ok

In controller-runtime v0.25 sind Defaulter und Validator generisch: Default(ctx, *StaticSite) statt runtime.Object mit Type-Assertion. Der Builder ctrl.NewWebhookManagedBy(mgr, &StaticSite{}) verdrahtet Pfad und Typ.

Fortschritt speichern? Kostenlos registrieren

Drill 6: Der Validator – was CEL nicht kann

Zwei Prüfungen aus validate oben:

  • Registry-Policy: Images nur aus AllowedImagePrefixes. Die Liste ist Go-Code (oder Flag, siehe Challenge) – CEL im CRD wäre für jeden Cluster gleich.
  • Nachbarobjekt: Zeigt contentFrom auf eine fehlende ConfigMap, gibt es eine Warnung, keinen Fehler. Bei GitOps kommt die ConfigMap oft Sekunden nach der Site.

Warum mgr.GetAPIReader()? Der normale Client liest aus dem Cache und würde dafür einen Informer auf alle ConfigMaps des Clusters starten. Der API-Reader fragt einmal direkt – für seltene Lookups im Webhook genau richtig.

Achtung: Ein Webhook mit failurePolicy: Fail ist ein harter Abhängigkeitspfad: Läuft dein Operator nicht, kann niemand mehr StaticSites anlegen oder ändern (Drill 8). Halte den Validator schnell und ohne externe Aufrufe.

Fortschritt speichern? Kostenlos registrieren

Drill 7: Webhook-Tests in envtest

Die Suite webhook_suite_test.go hat Kubebuilder schon geschrieben: Sie startet envtest mit WebhookInstallOptions – envtest erzeugt ein Zertifikat, startet den Webhook-Server auf einem freien Port und trägt die Konfiguration aus config/webhook/ mit dieser Adresse im API-Server ein. Du ersetzt nur die Specs: eine Tabelle für den Defaulter (reiner Go-Aufruf) und drei Specs durch den echten API-Server.

cat > internal/webhook/v1alpha1/staticsite_webhook_test.go <<'EOF'
package v1alpha1

import (
    "context"

    . "github.com/onsi/ginkgo/v2"
    . "github.com/onsi/gomega"
    apierrors "k8s.io/apimachinery/pkg/api/errors"
    metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
    "k8s.io/client-go/rest"
    "sigs.k8s.io/controller-runtime/pkg/client"

    webv1alpha1 "example.com/site-operator/api/v1alpha1"
)

func site(name string) *webv1alpha1.StaticSite {
    return &webv1alpha1.StaticSite{
        ObjectMeta: metav1.ObjectMeta{Name: name, Namespace: "default"},
        Spec:       webv1alpha1.StaticSiteSpec{Content: "<h1>Hallo</h1>"},
    }
}

var _ = Describe("Defaulter (Unit)", func() {
    DescribeTable("normalisiert spec.path",
        func(in, want string) {
            s := site("x")
            s.Spec.Path = in
            Expect((&StaticSiteDefaulter{}).Default(ctx, s)).To(Succeed())
            Expect(s.Spec.Path).To(Equal(want))
        },
        Entry("leer", "", "/"),
        Entry("ohne Slashes", "docs", "/docs/"),
        Entry("schon normal", "/docs/", "/docs/"),
        Entry("verschachtelt", "a/b", "/a/b/"),
    )
})

var _ = Describe("Webhooks im API-Server (envtest)", func() {
    It("normalisiert den Pfad beim Anlegen", func() {
        s := site("mutate")
        s.Spec.Path = "docs"
        Expect(k8sClient.Create(ctx, s)).To(Succeed())
        Expect(s.Spec.Path).To(Equal("/docs/")) // Antwort enthält den Patch
    })

    It("lehnt fremde Registries ab", func() {
        s := site("evil")
        s.Spec.Image = "evil.example/nginx:1.0"
        err := k8sClient.Create(ctx, s)
        Expect(apierrors.IsInvalid(err)).To(BeTrue())
        Expect(err.Error()).To(ContainSubstring("spec.image"))
    })

    It("warnt bei fehlender ConfigMap, lehnt aber nicht ab", func() {
        var got warnings
        cfgW := rest.CopyConfig(cfg)
        cfgW.WarningHandlerWithContext = &got
        c, err := client.New(cfgW, client.Options{Scheme: k8sClient.Scheme()})
        Expect(err).NotTo(HaveOccurred())

        s := site("later")
        s.Spec.Content = ""
        s.Spec.ContentFrom = &webv1alpha1.ContentSource{
            ConfigMapRef: &webv1alpha1.ConfigMapReference{Name: "kommt-noch"}}
        Expect(c.Create(ctx, s)).To(Succeed())
        Expect(got).To(ContainElement(ContainSubstring("kommt-noch fehlt")))
    })
})

// warnings sammelt Warning-Header des API-Servers.
type warnings []string

func (w *warnings) HandleWarningHeaderWithContext(_ context.Context, _ int,
    _ string, text string) {
    *w = append(*w, text)
}
EOF
go test ./internal/webhook/... -count=1 -v -ginkgo.no-color \
  2>&1 | grep -E '^(Ran|SUCCESS|FAIL|ok)'

Erwartet:

Ran 7 of 7 Specs in 5.800 seconds
SUCCESS! -- 7 Passed | 0 Failed | 0 Pending | 0 Skipped
ok      example.com/site-operator/internal/webhook/v1alpha1 6.168s

Warum ein eigener WarningHandler? Warnungen kommen als HTTP-Header Warning: zurück. Der Standard-Client loggt sie nur; zum Prüfen sammelst du sie selbst ein.

Fortschritt speichern? Kostenlos registrieren

Drill 8: Webhooks live gegen envtest-up

envtest-up kennt keine Webhooks – du trägst sie von Hand ein. Der API-Server muss deinem Webhook-Server per TLS vertrauen, also: Zertifikat für 127.0.0.1, CA-Bundle in die Konfiguration, url statt service.

mkdir -p lab/certs
openssl req -x509 -newkey rsa:2048 -nodes -days 30 \
  -keyout lab/certs/tls.key -out lab/certs/tls.crt \
  -subj /CN=127.0.0.1 -addext subjectAltName=IP:127.0.0.1 2>/dev/null
CA=$(base64 < lab/certs/tls.crt | tr -d '\n')
perl -0pe "s|service:\n\s+name: webhook-service\n\s+namespace: system\n\s+path: (\S+)\
|caBundle: $CA\n    url: https://127.0.0.1:9443\$1|g" \
  config/webhook/manifests.yaml > lab/webhooks-local.yaml
grep 'url:' lab/webhooks-local.yaml
kubectl apply -f lab/webhooks-local.yaml

Erwartet (gekürzt):

    url: https://127.0.0.1:9443/mutate-web-lab-example-v1alpha1-staticsite
    url: https://127.0.0.1:9443/validate-web-lab-example-v1alpha1-staticsite
mutatingwebhookconfiguration.admissionregistration.k8s.io/mutating-webhook-... created
validatingwebhookconfiguration.admissionregistration.k8s.io/validating-webh... created

Sicherheit: lab/certs/tls.key ist ein Lab-Schlüssel mit einem Tag Laufzeit. Nicht einchecken (echo 'lab/certs/' >> .gitignore); im Cluster erledigt das cert-manager.

Noch läuft kein Operator. Was passiert jetzt mit failurePolicy: Fail?

kubectl delete site demo --ignore-not-found
kubectl apply -f lab/demo.yaml

Erwartet (umbrochen):

Error from server (InternalError): error when creating "lab/demo.yaml": Internal error
occurred: failed calling webhook "mstaticsite-v1alpha1.kb.io": failed to call webhook:
Post "https://127.0.0.1:9443/mutate-web-lab-example-v1alpha1-staticsite?timeout=10s":
dial tcp 127.0.0.1:9443: connect: connection refused

Terminal 3: Operator mit Zertifikat starten. Ohne --webhook-cert-path bricht er ab (open …/k8s-webhook-server/serving-certs/tls.crt: no such file or directory); wer keine Webhooks braucht, startet mit ENABLE_WEBHOOKS=false.

cd ~/op-lab/tag08-site-operator
go run ./cmd/main.go -health-probe-bind-address=0 --webhook-cert-path=lab/certs \
  2>&1 | tee run.log

Terminal 2: Defaulter, Validator und Warnung nacheinander:

kubectl apply -f lab/demo.yaml
kubectl apply -f - <<'EOF'
apiVersion: web.lab.example/v1alpha1
kind: StaticSite
metadata:
  name: docs
spec:
  content: "<h1>Doku</h1>"
  path: docs
EOF
kubectl get site docs -o jsonpath='{.spec.path}{"\n"}'
kubectl apply -f - <<'EOF'
apiVersion: web.lab.example/v1alpha1
kind: StaticSite
metadata:
  name: fremd
spec:
  content: "<h1>x</h1>"
  image: docker.io/library/nginx:1.29
EOF
kubectl apply -f - <<'EOF'
apiVersion: web.lab.example/v1alpha1
kind: StaticSite
metadata:
  name: spaeter
spec:
  contentFrom:
    configMapRef:
      name: html
EOF

Erwartet (umbrochen):

staticsite.web.lab.example/demo created
staticsite.web.lab.example/docs created
/docs/
The StaticSite "fremd" is invalid: spec.image: Forbidden:
  erlaubt sind nur [nginxinc/ registry.lab.example/]
Warning: ConfigMap html fehlt (noch)
staticsite.web.lab.example/spaeter created

Die ganze Kette arbeitet: Defaulter (docs → /docs/), Schema und CEL, Validator mit Fehler und Warnung, dann Reconcile. Operator (Terminal 3) mit Ctrl+C beenden.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

Operator in Terminal 3 noch einmal starten (Befehl aus Drill 8), dann:

cd ~/op-lab/tag08-site-operator
ok() { echo "✔ $1"; }; nok() { echo "✘ $1"; }
CRD=config/crd/bases/web.lab.example_staticsites.yaml
go test ./internal/... -count=1 >/dev/null 2>&1 && ok "Tests grün" || nok "Tests"
grep -q 'has(self.contentFrom)' $CRD && ok "CEL: genau eins" || nok "ExactlyOneOf"
grep -q 'self == oldSelf' $CRD && ok "Transition Rule" || nok "Transition Rule"
kubectl apply -f lab/kaputt.yaml 2>&1 | grep -q 'exactly one' \
  && ok "API-Server lehnt kaputt.yaml ab" || nok "kaputt.yaml"
kubectl get site docs -o jsonpath='{.spec.path}' | grep -qx '/docs/' \
  && ok "Defaulter normalisiert path" || nok "Defaulter"
kubectl apply --dry-run=server -f lab/demo.yaml >/dev/null 2>&1 \
  && ok "Webhook erreichbar" || nok "Webhook (läuft der Operator?)"

Erwartet:

✔ Tests grün
✔ CEL: genau eins
✔ Transition Rule
✔ API-Server lehnt kaputt.yaml ab
✔ Defaulter normalisiert path
✔ Webhook erreichbar

Danach Operator und envtest-up mit Ctrl+C beenden.

Challenge

Die Registry-Policy ist im Code fest verdrahtet. Mache sie per Flag --allowed-image-prefixes (kommagetrennt) konfigurierbar und probiere docker.io/library/ aus.

Hinweis: Setze webhookv1alpha1.AllowedImagePrefixes in cmd/main.go, bevor SetupStaticSiteWebhookWithManager läuft.

Lösung

In cmd/main.go (Import "strings" ergänzen):

    var registrarURL, allowedImages string
    flag.StringVar(&allowedImages, "allowed-image-prefixes",
        "nginxinc/,registry.lab.example/", "erlaubte Image-Präfixe, kommagetrennt")
    // ...
    if os.Getenv("ENABLE_WEBHOOKS") != "false" {
        webhookv1alpha1.AllowedImagePrefixes = strings.Split(allowedImages, ",")

Operator in Terminal 3 mit --allowed-image-prefixes=docker.io/library/ neu starten, dann:

kubectl apply -f - <<'EOF'
apiVersion: web.lab.example/v1alpha1
kind: StaticSite
metadata:
  name: fremd
spec:
  content: "<h1>x</h1>"
  image: docker.io/library/nginx:1.29
EOF
kubectl apply -f - <<'EOF'
apiVersion: web.lab.example/v1alpha1
kind: StaticSite
metadata:
  name: standard
spec:
  content: "<h1>x</h1>"
EOF

Erwartet (umbrochen):

staticsite.web.lab.example/fremd created
The StaticSite "standard" is invalid: spec.image: Forbidden:
  erlaubt sind nur [docker.io/library/]

Lehrreich: Der Schema-Default nginxinc/nginx-unprivileged:… fällt jetzt selbst durch die Policy. Defaults und Policy gehören zusammen getestet – sonst kann niemand mehr eine minimale StaticSite anlegen.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Erst CEL, dann Webhook: CEL hat keinen Ausfallpfad, kein Zertifikat, keine Latenz. Webhooks nur für Lookups und Konfiguration.
  • Zertifikate im Cluster: cert-manager (config/certmanager und die [CERTMANAGER]-Abschnitte in config/default/kustomization.yaml) inkl. CA-Injection ins caBundle; Rotation ohne Neustart über den Cert-Watcher in cmd/main.go.
  • failurePolicy: Fail + nur ein Replica = Ausfall der API für deine CRs. Mindestens zwei Replicas, PodDisruptionBudget, timeoutSeconds kurz (2–5 s), namespaceSelector gegen System-Namespaces.
  • Mutating Webhooks müssen idempotent sein – der API-Server ruft sie bei Bedarf mehrfach (reinvocationPolicy).
  • Cluster-weite Policies (Registries, Labels) gehören eher in Kyverno, Gatekeeper oder ValidatingAdmissionPolicy (CEL, ohne eigenen Server) – der Operator-Webhook prüft nur, was seine eigene API betrifft.