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 applyist billiger als einDegradedim 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-operatorTerminal 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/basesTerminal 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.yamlErwartet (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-Serverfailed 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.yamlErwartet (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.yamlErwartet (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-operatorDer 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 okErwartet:
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
contentFromauf 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: Failist 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.yamlErwartet (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.keyist 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.yamlErwartet (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.logTerminal 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
EOFErwartet (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>"
EOFErwartet (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/certmanagerund die[CERTMANAGER]-Abschnitte inconfig/default/kustomization.yaml) inkl. CA-Injection inscaBundle; Rotation ohne Neustart über den Cert-Watcher incmd/main.go. failurePolicy: Fail+ nur ein Replica = Ausfall der API für deine CRs. Mindestens zwei Replicas, PodDisruptionBudget,timeoutSecondskurz (2–5 s),namespaceSelectorgegen 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.