Tag 4: Reconcile richtig
Ziel: Der site-operator erzeugt aus einer StaticSite ConfigMap, Deployment und Service – idempotent, mit Owner References und sauberem Requeue · Dauer: ca. 120 min · Voraussetzung: Tag 3
Briefing
- Reconcile bekommt nur
namespace/name, nie das Ereignis. Du liest den Ist-Zustand und gleichst ihn an – jedes Mal komplett. controllerutil.CreateOrUpdateliest, ruft deine Mutate-Funktion und schreibt nur, wenn sich etwas geändert hat.SetControllerReference+Owns(): Änderungen an Kindern wecken den Besitzer, Löschen räumt per Garbage Collector auf.- Rückgabewerte steuern die Queue:
err→ Backoff,RequeueAfter→ später nochmal,Result{}→ fertig.
StaticSite demo ──Reconcile──> ConfigMap demo-content (index.html)
^ Deployment demo (nginx, Port 8080, content-hash)
| Service demo (80 -> 8080)
+---- Owns(): jede Änderung an einem Kind legt "default/demo" in die Queue
Drill 1: Arbeitsstand und Lab-Cluster
Jeder Tag arbeitet auf einer Kopie des Vortags. Terminal 1 ist dein Arbeitsterminal:
source ~/op-lab/env.sh
cp -r ~/op-lab/tag03-site-operator ~/op-lab/tag04-site-operator
cd ~/op-lab/tag04-site-operatorTerminal 2 startet envtest und installiert die CRD gleich mit (Tag 3):
source ~/op-lab/env.sh
cd ~/op-lab/tag04-site-operator
envtest-up -crds config/crd/basesErwartet (Port variiert):
envtest läuft: https://127.0.0.1:51745/
export KUBECONFIG=/Users/<du>/op-lab/envtest.kubeconfig
Beenden mit Ctrl+C
Zurück in Terminal 1:
kubectl config current-context
kubectl get crdErwartet:
envtest
NAME SCOPE VERSIONS CREATED AT
staticsites.web.lab.example Namespaced v1alpha1(storage) 2026-10-10T08:08:21Z
Achtung: envtest ist nur etcd + kube-apiserver. Es gibt keinen Scheduler, keinen Deployment-Controller und keinen Garbage Collector – Pods entstehen nie, und Kinder bleiben nach dem Löschen des Besitzers liegen. Das ist für heute sogar praktisch: Du siehst genau, was dein Controller tut.
Fortschritt speichern? Kostenlos registrieren
Drill 2: Bausteine – Labels, Hash, Mutate-Funktionen
Die Mutate-Funktionen setzen nur die Felder, die dem Operator gehören. Alles andere (Server-Defaults, Felder anderer Controller) bleibt unangetastet – das ist die Grundlage für Idempotenz.
cat > internal/controller/resources.go <<'EOF'
package controller
import (
"crypto/sha256"
"encoding/hex"
"maps"
"path"
appsv1 "k8s.io/api/apps/v1"
corev1 "k8s.io/api/core/v1"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/util/intstr"
"k8s.io/utils/ptr"
webv1alpha1 "example.com/site-operator/api/v1alpha1"
)
const (
contentHashAnnotation = "web.lab.example/content-hash"
contentKey = "index.html"
htmlRoot = "/usr/share/nginx/html"
containerPort = 8080
)
// selectorLabels sind unveränderlich: nur der Name, sonst bricht der Selector.
func selectorLabels(site *webv1alpha1.StaticSite) map[string]string {
return map[string]string{"app.kubernetes.io/name": site.Name}
}
// labelsFor hängt an alle erzeugten Objekte dieselben Labels.
func labelsFor(site *webv1alpha1.StaticSite) map[string]string {
l := selectorLabels(site)
l["app.kubernetes.io/managed-by"] = "site-operator"
return l
}
func contentConfigMapName(site *webv1alpha1.StaticSite) string {
return site.Name + "-content"
}
// contentHash ändert sich mit dem Inhalt und löst so einen Rollout aus.
func contentHash(content string) string {
sum := sha256.Sum256([]byte(content))
return hex.EncodeToString(sum[:8])
}
func setLabels(obj *metav1.ObjectMeta, site *webv1alpha1.StaticSite) {
if obj.Labels == nil {
obj.Labels = map[string]string{}
}
maps.Copy(obj.Labels, labelsFor(site))
}
// mutateConfigMap setzt nur die Felder, die dem Operator gehören.
func mutateConfigMap(cm *corev1.ConfigMap, site *webv1alpha1.StaticSite,
content string) {
setLabels(&cm.ObjectMeta, site)
cm.Data = map[string]string{contentKey: content}
}
func mutateDeployment(dep *appsv1.Deployment, site *webv1alpha1.StaticSite,
hash string) {
setLabels(&dep.ObjectMeta, site)
dep.Spec.Replicas = ptr.To(site.Spec.Replicas)
if dep.Spec.Selector == nil { // Selector ist nach dem Anlegen unveränderlich
dep.Spec.Selector = &metav1.LabelSelector{MatchLabels: selectorLabels(site)}
}
tpl := &dep.Spec.Template
setLabels(&tpl.ObjectMeta, site)
if tpl.Annotations == nil {
tpl.Annotations = map[string]string{}
}
tpl.Annotations[contentHashAnnotation] = hash
if len(tpl.Spec.Containers) == 0 {
tpl.Spec.Containers = []corev1.Container{{Name: "nginx"}}
}
c := &tpl.Spec.Containers[0] // nur Felder setzen, Server-Defaults behalten
c.Image = site.Spec.Image
c.Ports = []corev1.ContainerPort{{
Name: "http", ContainerPort: containerPort, Protocol: corev1.ProtocolTCP,
}}
c.VolumeMounts = []corev1.VolumeMount{{
Name: "content", MountPath: path.Join(htmlRoot, site.Spec.Path),
ReadOnly: true,
}}
tpl.Spec.Volumes = []corev1.Volume{{
Name: "content",
VolumeSource: corev1.VolumeSource{ConfigMap: &corev1.ConfigMapVolumeSource{
LocalObjectReference: corev1.LocalObjectReference{
Name: contentConfigMapName(site),
},
DefaultMode: ptr.To[int32](0o644), // sonst ergänzt der Server 420
}},
}}
}
func mutateService(svc *corev1.Service, site *webv1alpha1.StaticSite) {
setLabels(&svc.ObjectMeta, site)
svc.Spec.Selector = selectorLabels(site)
svc.Spec.Ports = []corev1.ServicePort{{
Name: "http", Port: 80, Protocol: corev1.ProtocolTCP,
TargetPort: intstr.FromInt32(containerPort),
}}
}
EOFWarum der Hash? Ein Deployment rollt nur neu aus, wenn sich das
Pod-Template ändert. Eine geänderte ConfigMap allein reicht nicht – die
Annotation web.lab.example/content-hash im Template
schon.
Fortschritt speichern? Kostenlos registrieren
Drill 3: Der Reconciler
Ablauf: StaticSite lesen → Inhalt auflösen → drei Kinder mit
CreateOrUpdate abgleichen. Jede Funktion loggt das Ergebnis
(created, updated, unchanged) –
daran erkennst du später Idempotenz. Die RBAC-Marker sind in kurze
Zeilen geteilt; controller-gen fasst sie zusammen.
cat > internal/controller/staticsite_controller.go <<'EOF'
package controller
import (
"context"
"errors"
"fmt"
"time"
appsv1 "k8s.io/api/apps/v1"
corev1 "k8s.io/api/core/v1"
apierrors "k8s.io/apimachinery/pkg/api/errors"
metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
"k8s.io/apimachinery/pkg/runtime"
ctrl "sigs.k8s.io/controller-runtime"
"sigs.k8s.io/controller-runtime/pkg/client"
"sigs.k8s.io/controller-runtime/pkg/controller/controllerutil"
logf "sigs.k8s.io/controller-runtime/pkg/log"
webv1alpha1 "example.com/site-operator/api/v1alpha1"
)
// errContentMissing: die referenzierte ConfigMap fehlt (noch).
var errContentMissing = errors.New("content source not found")
// StaticSiteReconciler gleicht StaticSites mit ConfigMap, Deployment und Service ab.
type StaticSiteReconciler struct {
client.Client
Scheme *runtime.Scheme
}
// +kubebuilder:rbac:groups=web.lab.example,resources=staticsites,verbs=get;list;watch
// +kubebuilder:rbac:groups=web.lab.example,resources=staticsites,verbs=update;patch
// +kubebuilder:rbac:groups=web.lab.example,resources=staticsites/status,verbs=get;patch
// +kubebuilder:rbac:groups=web.lab.example,resources=staticsites/status,verbs=update
// +kubebuilder:rbac:groups=web.lab.example,resources=staticsites/finalizers,verbs=update
// +kubebuilder:rbac:groups="",resources=configmaps;services,verbs=get;list;watch
// +kubebuilder:rbac:groups="",resources=configmaps;services,verbs=create;update;patch
// +kubebuilder:rbac:groups=apps,resources=deployments,verbs=get;list;watch
// +kubebuilder:rbac:groups=apps,resources=deployments,verbs=create;update;patch
func (r *StaticSiteReconciler) Reconcile(ctx context.Context,
req ctrl.Request) (ctrl.Result, error) {
log := logf.FromContext(ctx)
var site webv1alpha1.StaticSite
if err := r.Get(ctx, req.NamespacedName, &site); err != nil {
return ctrl.Result{}, client.IgnoreNotFound(err) // gelöscht: nichts zu tun
}
content, err := r.resolveContent(ctx, &site)
if errors.Is(err, errContentMissing) {
log.Info("Inhalt fehlt, neuer Versuch in 30s", "error", err.Error())
return ctrl.Result{RequeueAfter: 30 * time.Second}, nil
}
if err != nil {
return ctrl.Result{}, err // Backoff durch die Workqueue
}
hash, err := r.reconcileConfigMap(ctx, &site, content)
if err != nil {
return ctrl.Result{}, err
}
if _, err := r.reconcileDeployment(ctx, &site, hash); err != nil {
return ctrl.Result{}, err
}
if err := r.reconcileService(ctx, &site); err != nil {
return ctrl.Result{}, err
}
return ctrl.Result{}, nil
}
// resolveContent liefert spec.content oder index.html aus der referenzierten ConfigMap.
func (r *StaticSiteReconciler) resolveContent(ctx context.Context,
site *webv1alpha1.StaticSite) (string, error) {
src := site.Spec.ContentFrom
if src == nil || src.ConfigMapRef == nil {
return site.Spec.Content, nil
}
var cm corev1.ConfigMap
key := client.ObjectKey{Namespace: site.Namespace, Name: src.ConfigMapRef.Name}
if err := r.Get(ctx, key, &cm); err != nil {
if apierrors.IsNotFound(err) {
return "", fmt.Errorf("configmap %s: %w", key.Name, errContentMissing)
}
return "", err
}
html, ok := cm.Data[contentKey]
if !ok {
return "", fmt.Errorf("configmap %s ohne %s: %w", key.Name, contentKey,
errContentMissing)
}
return html, nil
}
func (r *StaticSiteReconciler) reconcileConfigMap(ctx context.Context,
site *webv1alpha1.StaticSite, content string) (string, error) {
cm := &corev1.ConfigMap{ObjectMeta: metav1.ObjectMeta{
Name: contentConfigMapName(site), Namespace: site.Namespace,
}}
op, err := controllerutil.CreateOrUpdate(ctx, r.Client, cm, func() error {
mutateConfigMap(cm, site, content)
return controllerutil.SetControllerReference(site, cm, r.Scheme)
})
if err != nil {
return "", fmt.Errorf("configmap: %w", err)
}
logf.FromContext(ctx).Info("ConfigMap abgeglichen", "operation", op)
return contentHash(content), nil
}
func (r *StaticSiteReconciler) reconcileDeployment(ctx context.Context,
site *webv1alpha1.StaticSite, hash string) (*appsv1.Deployment, error) {
dep := &appsv1.Deployment{ObjectMeta: metav1.ObjectMeta{
Name: site.Name, Namespace: site.Namespace,
}}
op, err := controllerutil.CreateOrUpdate(ctx, r.Client, dep, func() error {
mutateDeployment(dep, site, hash)
return controllerutil.SetControllerReference(site, dep, r.Scheme)
})
if err != nil {
return nil, fmt.Errorf("deployment: %w", err)
}
logf.FromContext(ctx).Info("Deployment abgeglichen", "operation", op)
return dep, nil
}
func (r *StaticSiteReconciler) reconcileService(ctx context.Context,
site *webv1alpha1.StaticSite) error {
svc := &corev1.Service{ObjectMeta: metav1.ObjectMeta{
Name: site.Name, Namespace: site.Namespace,
}}
op, err := controllerutil.CreateOrUpdate(ctx, r.Client, svc, func() error {
mutateService(svc, site)
return controllerutil.SetControllerReference(site, svc, r.Scheme)
})
if err != nil {
return fmt.Errorf("service: %w", err)
}
logf.FromContext(ctx).Info("Service abgeglichen", "operation", op)
return nil
}
// SetupWithManager: Owns() sorgt dafür, dass Änderungen an den Kindern
// den Besitzer (die StaticSite) erneut in die Queue legen.
func (r *StaticSiteReconciler) SetupWithManager(mgr ctrl.Manager) error {
return ctrl.NewControllerManagedBy(mgr).
For(&webv1alpha1.StaticSite{}).
Owns(&corev1.ConfigMap{}).
Owns(&appsv1.Deployment{}).
Owns(&corev1.Service{}).
Named("staticsite").
Complete(r)
}
EOF
make manifests generate
go build ./... && echo build-ok
grep -c -- '- deployments' config/rbac/role.yamlErwartet (gekürzt):
build-ok
1
Warum client.IgnoreNotFound? Auch das Löschen einer
StaticSite löst ein Reconcile aus. Das Objekt ist dann weg – kein
Fehler, nichts zu tun.
Fortschritt speichern? Kostenlos registrieren
Drill 4: Erster Lauf
Terminal 3 startet den Operator gegen envtest (wie
an Tag 3) und schreibt das Log zusätzlich nach run.log:
source ~/op-lab/env.sh
cd ~/op-lab/tag04-site-operator
go run ./cmd/main.go -health-probe-bind-address=0 2>&1 | tee run.logErwartet (gekürzt):
INFO setup Starting manager
INFO Starting EventSource {"controller": "staticsite", ...}
INFO Starting Controller {"controller": "staticsite", ...}
INFO Starting workers {"controller": "staticsite", ..., "worker count": 1}
In Terminal 1 zeigt die Funktion ops
die letzten Operationen aus dem Log:
ops() { grep abgeglichen run.log | tail -n "${1:-3}" | \
sed -E 's/.*INFO\t([^{]*)\t.*"operation": "([a-z]*)".*/\1 \2/'; }
mkdir -p lab
cat > lab/demo.yaml <<'EOF'
apiVersion: web.lab.example/v1alpha1
kind: StaticSite
metadata:
name: demo
spec:
content: "<h1>Hallo vom site-operator</h1>"
EOF
kubectl apply -f lab/demo.yaml
kubectl get cm,deploy,svc -l app.kubernetes.io/managed-by=site-operator -o name
ops 9Erwartet:
staticsite.web.lab.example/demo created
configmap/demo-content
deployment.apps/demo
service/demo
ConfigMap abgeglichen created
Deployment abgeglichen created
Service abgeglichen created
ConfigMap abgeglichen unchanged
Deployment abgeglichen unchanged
Service abgeglichen unchanged
ConfigMap abgeglichen unchanged
Deployment abgeglichen unchanged
Service abgeglichen unchanged
Warum drei Durchläufe? Das Anlegen der Kinder erzeugt
Watch-Ereignisse, Owns() legt default/demo
erneut in die Queue. Der zweite und dritte Lauf finden nichts zu tun –
idempotent. Pods entstehen in envtest nie – es fehlt
der Deployment-Controller.
Fortschritt speichern? Kostenlos registrieren
Drill 5: Owner References und Drift
Der Operator ist die Quelle der Wahrheit. Manuelle Änderungen an Kindern werden zurückgedreht.
kubectl scale deployment demo --replicas=3
sleep 2
kubectl get deployment demo -o jsonpath='{.spec.replicas}{"\n"}'
ops 6
kubectl delete service demo
sleep 2
kubectl get service demo
kubectl get deployment demo -o json | jq -c '.metadata.ownerReferences[0]
| {kind, name, controller}'Erwartet:
deployment.apps/demo scaled
1
ConfigMap abgeglichen unchanged
Deployment abgeglichen updated
Service abgeglichen unchanged
ConfigMap abgeglichen unchanged
Deployment abgeglichen unchanged
Service abgeglichen unchanged
service "demo" deleted from default namespace
NAME TYPE CLUSTER-IP EXTERNAL-IP PORT(S) AGE
demo ClusterIP 10.0.0.81 <none> 80/TCP 2s
{"kind":"StaticSite","name":"demo","controller":true}
controller: true heißt: genau dieser Besitzer ist
zuständig. SetControllerReference verweigert einen zweiten
Controller-Owner mit einem Fehler – Schutz gegen zwei Operatoren, die
sich um ein Objekt streiten.
Fortschritt speichern? Kostenlos registrieren
Drill 6: Inhalt ändern – Rollout per Hash
hash() { kubectl get deployment demo -o json | jq -r \
'.spec.template.metadata.annotations["web.lab.example/content-hash"]'; }
hash
kubectl patch staticsite demo --type=merge \
-p '{"spec":{"content":"<h1>Version 2</h1>"}}'
sleep 2
hash
kubectl get configmap demo-content -o jsonpath='{.data.index\.html}{"\n"}'
ops 6Erwartet:
76ebbddde9ec4fc3
staticsite.web.lab.example/demo patched
2c496b6782a30e1e
<h1>Version 2</h1>
ConfigMap abgeglichen updated
Deployment abgeglichen updated
Service abgeglichen unchanged
ConfigMap abgeglichen unchanged
Deployment abgeglichen unchanged
Service abgeglichen unchanged
In einem echten Cluster startet das geänderte Pod-Template einen Rolling Update – die Pods lesen den neuen Inhalt.
Fortschritt speichern? Kostenlos registrieren
Drill 7: Fehler und Requeue
Was Reconcile zurückgibt, entscheidet über den nächsten Versuch:
| Rückgabe | Wirkung | Wann |
|---|---|---|
Result{}, nil |
fertig, bis zum nächsten Ereignis | Normalfall |
Result{}, err |
erneut mit exponentiellem Backoff | API-Fehler, Konflikte |
Result{RequeueAfter: d}, nil |
erneut nach d, kein Fehler-Log |
Warten auf etwas Externes |
Eine fehlende ConfigMap ist kein Programmfehler, sondern ein Zustand.
Deshalb RequeueAfter statt err – sonst flutet
der Backoff das Log mit Stacktraces.
cat > lab/extern.yaml <<'EOF'
apiVersion: web.lab.example/v1alpha1
kind: StaticSite
metadata:
name: extern
spec:
contentFrom:
configMapRef:
name: extern-html
EOF
kubectl apply -f lab/extern.yaml
sleep 2
grep "Inhalt fehlt" run.log | tail -1 | grep -o '"error": "[^"]*"'
kubectl get deployment externErwartet:
staticsite.web.lab.example/extern created
"error": "configmap extern-html: content source not found"
Error from server (NotFound): deployments.apps "extern" not found
Jetzt die ConfigMap nachliefern und messen, wie lange es dauert:
kubectl create configmap extern-html \
--from-literal=index.html='<h1>Aus der ConfigMap</h1>'
time (until kubectl get deployment extern >/dev/null 2>&1; do sleep 1; done)Erwartet (Zeit variiert, höchstens 30 s):
configmap/extern-html created
( until kubectl get deployment extern > /dev/null 2>&1; do; sleep 1; done; )
0,78s user 0,58s system 4% cpu 28,405 total
Bis zu 30 Sekunden Latenz, weil der Operator die fremde ConfigMap nicht beobachtet. An Tag 10 ersetzt ein Watch mit Field-Index das Polling.
Fortschritt speichern? Kostenlos registrieren
Drill 8: Die Idempotenz-Falle
Der API-Server ergänzt Defaults. Setzt dein Code ein Feld nicht, das
der Server füllt, sieht CreateOrUpdate bei jedem Lauf einen
Unterschied. Probier es aus: Entferne DefaultMode und
starte den Operator in Terminal 3 neu (Ctrl+C, dann
denselben go run-Befehl wie in Drill 4).
sed -i.bak '/DefaultMode/d' internal/controller/resources.goIn Terminal 1, nach dem Neustart:
kubectl annotate staticsite extern lab.example/poke=1 --overwrite
sleep 2
kubectl annotate staticsite extern lab.example/poke=2 --overwrite
sleep 2
ops 6
kubectl get deployment extern -o json | \
jq '.metadata.generation, .spec.template.spec.volumes[0].configMap.defaultMode'Erwartet:
staticsite.web.lab.example/extern annotated
staticsite.web.lab.example/extern annotated
ConfigMap abgeglichen unchanged
Deployment abgeglichen updated
Service abgeglichen unchanged
ConfigMap abgeglichen unchanged
Deployment abgeglichen updated
Service abgeglichen unchanged
1
420
Jeder Lauf schickt ein Update, obwohl sich nichts ändert
(generation bleibt 1, der Server ergänzt wieder
420 = 0o644). Bei vielen Objekten kostet das
API-Last – und mit einem Feld, das sich wirklich ändert (Zeitstempel!),
wird daraus ein Hotloop (Tag 15). Zurückbauen und Operator wieder neu
starten:
mv internal/controller/resources.go.bak internal/controller/resources.goNach dem Neustart zeigt ops 3 nach einem weiteren
annotate wieder dreimal unchanged.
Zum Schluss löschst du demo. In envtest bleiben die
Kinder liegen – im echten Cluster räumt der Garbage Collector sie über
die Owner References ab:
kubectl delete staticsite demo
kubectl get deploy,svc,cm -l app.kubernetes.io/name=demo -o name
kubectl delete deploy,svc,cm -l app.kubernetes.io/name=demoErwartet:
staticsite.web.lab.example "demo" deleted from default namespace
deployment.apps/demo
service/demo
configmap/demo-content
deployment.apps "demo" deleted from default namespace
service "demo" deleted from default namespace
configmap "demo-content" deleted from default namespace
Fortschritt speichern? Kostenlos registrieren
Kontrollpunkt
Operator läuft in Terminal 3, extern existiert. In
Terminal 1:
cat > lab/check.sh <<'EOF'
ok() { echo "✔ $1"; }
nok() { echo "✘ $1"; }
chk() { if eval "$2" >/dev/null 2>&1; then ok "$1"; else nok "$1"; fi; }
j() { kubectl get "$1" extern -o jsonpath="$2"; }
chk "Deployment gehört StaticSite/extern" \
'[ "$(j deployment "{.metadata.ownerReferences[0].name}")" = extern ]'
ann='{.spec.template.metadata.annotations.web\.lab\.example/content-hash}'
chk "Pod-Template trägt content-hash" '[ -n "$(j deployment "$ann")" ]'
chk "Service 80 -> 8080" \
'[ "$(j service "{.spec.ports[0].port}->{.spec.ports[0].targetPort}")" = "80->8080" ]'
chk "ConfigMap extern-content hat index.html" \
'kubectl get configmap extern-content -o jsonpath="{.data.index\.html}" | grep -q h1'
kubectl scale deployment extern --replicas=5 >/dev/null; sleep 2
chk "Drift korrigiert (replicas=1)" '[ "$(j deployment "{.spec.replicas}")" = 1 ]'
EOF
bash lab/check.shErwartet:
✔ Deployment gehört StaticSite/extern
✔ Pod-Template trägt content-hash
✔ Service 80 -> 8080
✔ ConfigMap extern-content hat index.html
✔ Drift korrigiert (replicas=1)
Challenge
Schreibe den Service mit Server-Side Apply statt
CreateOrUpdate: Du beschreibst das Objekt vollständig als
Apply-Configuration, der API-Server führt zusammen und merkt sich in
managedFields, welche Felder dir gehören.
Hinweis: client.Client hat seit
controller-runtime v0.22 eine Methode Apply; die
typisierten Builder liegen in
k8s.io/client-go/applyconfigurations/core/v1.
Lösung
cat > internal/controller/service_apply.go <<'EOF'
package controller
import (
"context"
corev1 "k8s.io/api/core/v1"
"k8s.io/apimachinery/pkg/util/intstr"
corev1ac "k8s.io/client-go/applyconfigurations/core/v1"
metav1ac "k8s.io/client-go/applyconfigurations/meta/v1"
"sigs.k8s.io/controller-runtime/pkg/client"
webv1alpha1 "example.com/site-operator/api/v1alpha1"
)
const fieldOwner = client.FieldOwner("site-operator")
// applyService beschreibt den Service vollständig; der API-Server führt zusammen.
func (r *StaticSiteReconciler) applyService(ctx context.Context,
site *webv1alpha1.StaticSite) error {
owner := metav1ac.OwnerReference().
WithAPIVersion(webv1alpha1.GroupVersion.String()).
WithKind("StaticSite").WithName(site.Name).WithUID(site.UID).
WithController(true).WithBlockOwnerDeletion(true)
svc := corev1ac.Service(site.Name, site.Namespace).
WithLabels(labelsFor(site)).
WithOwnerReferences(owner).
WithSpec(corev1ac.ServiceSpec().
WithSelector(selectorLabels(site)).
WithPorts(corev1ac.ServicePort().
WithName("http").WithPort(80).WithProtocol(corev1.ProtocolTCP).
WithTargetPort(intstr.FromInt32(containerPort))))
return r.Apply(ctx, svc, fieldOwner, client.ForceOwnership)
}
EOF
sed -i.bak 's/r.reconcileService(ctx, &site)/r.applyService(ctx, \&site)/' \
internal/controller/staticsite_controller.go
rm internal/controller/staticsite_controller.go.bak
go build ./... && echo build-okOperator in Terminal 3 neu starten, dann:
cat > lab/ssa.yaml <<'EOF'
apiVersion: web.lab.example/v1alpha1
kind: StaticSite
metadata:
name: ssa
spec:
content: "<h1>SSA</h1>"
EOF
kubectl apply -f lab/ssa.yaml
sleep 2
kubectl get service ssa --show-managed-fields \
-o jsonpath='{range .metadata.managedFields[*]}{.manager} {.operation}{"\n"}{end}'
kubectl patch service ssa --type=merge \
-p '{"spec":{"selector":{"app.kubernetes.io/name":"falsch"}}}'
sleep 2
kubectl get service ssa -o jsonpath='{.spec.selector}{"\n"}'Erwartet:
build-ok
staticsite.web.lab.example/ssa created
site-operator Apply
service/ssa patched
{"app.kubernetes.io/name":"ssa"}
ForceOwnership holt sich umstrittene Felder zurück.
Vorteil von SSA: kein Lesen vor dem Schreiben, keine Default-Falle wie
in Drill 8 – du sendest nur deine Felder. Nachteil: Apply-Configurations
sind wortreich. Der Code-Stand in code/tag04-site-operator
bleibt bei CreateOrUpdate. Für Tag 5 baust du zurück:
rm internal/controller/service_apply.go
sed -i.bak 's/r.applyService(ctx, &site)/r.reconcileService(ctx, \&site)/' \
internal/controller/staticsite_controller.go
rm internal/controller/staticsite_controller.go.bakFortschritt speichern? Kostenlos registrieren
Enterprise-Notiz
- Den Operator nie mit
--replicasvon Hand „korrigieren” lassen, was ein HPA steuert: Felder, die ein anderer Controller besitzt, gehören nicht in die Mutate-Funktion (oder per SSA einem anderen Field-Manager überlassen). - Owner References funktionieren nur im selben Namespace; für clusterweite oder namespaceübergreifende Kinder brauchst du Labels plus Finalizer (Tag 7).
RequeueAfterist Polling: Bei tausenden Objekten verteilt sich Last schlecht. Lieber gezielte Watches (Tag 10).- RBAC aus den Markern ist das Minimum, das der Operator braucht – im
Review prüfen, dass kein
deleteauf fremde Ressourcen hineinrutscht. - Logs mit
operationsind Gold im Betrieb: Ein Dauer-updatedohne Spec-Änderung ist das erste Zeichen einer Idempotenz-Falle.