Skip to content
Hands-on IT IT Drills

Day 4: Reconcile Done Right

Goal: The site-operator creates a ConfigMap, Deployment and Service from a StaticSite – idempotent, with owner references and clean requeueing · Duration: approx. 120 min · Prerequisite: Day 3

Briefing

  • Reconcile only gets namespace/name, never the event. You read the actual state and align it – completely, every time.
  • controllerutil.CreateOrUpdate reads, calls your mutate function and writes only if something has changed.
  • SetControllerReference + Owns(): changes to children wake up the owner, and deletion cleans up via the garbage collector.
  • Return values control the queue: err → backoff, RequeueAfter → try again later, Result{} → done.
StaticSite demo ──Reconcile──> ConfigMap demo-content  (index.html)
       ^                       Deployment demo         (nginx, port 8080, content-hash)
       |                       Service demo            (80 -> 8080)
       +---- Owns(): every change to a child puts "default/demo" into the queue

Drill 1: Working state and lab cluster

Each day works on a copy of the previous day. Terminal 1 is your working terminal:

source ~/op-lab/env.sh
cp -r ~/op-lab/tag03-site-operator ~/op-lab/tag04-site-operator
cd ~/op-lab/tag04-site-operator

Terminal 2 starts envtest and installs the CRD along with it (Day 3):

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

Expected (port varies):

envtest läuft: https://127.0.0.1:51745/
export KUBECONFIG=/Users/<du>/op-lab/envtest.kubeconfig
Beenden mit Ctrl+C

Back in Terminal 1:

kubectl config current-context
kubectl get crd

Expected:

envtest
NAME                          SCOPE        VERSIONS            CREATED AT
staticsites.web.lab.example   Namespaced   v1alpha1(storage)   2026-10-10T08:08:21Z

Warning: envtest is only etcd + kube-apiserver. There is no scheduler, no Deployment controller and no garbage collector – Pods never come into existence, and children stay behind after the owner is deleted. For today that’s actually handy: you see exactly what your controller does.

Save your progress? Sign up for free

Drill 2: Building blocks – labels, hash, mutate functions

The mutate functions set only the fields the operator owns. Everything else (server defaults, fields of other controllers) stays untouched – that is the foundation of idempotency.

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

Why the hash? A Deployment only rolls out again when the Pod template changes. A changed ConfigMap alone isn’t enough – the annotation web.lab.example/content-hash in the template is.

Save your progress? Sign up for free

Drill 3: The reconciler

The flow: read the StaticSite → resolve the content → align three children with CreateOrUpdate. Each function logs the result (created, updated, unchanged) – that’s how you recognize idempotency later. The RBAC markers are split into short lines; controller-gen merges them.

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

Expected (shortened):

build-ok
1

Why client.IgnoreNotFound? Deleting a StaticSite also triggers a Reconcile. The object is gone by then – not an error, nothing to do.

Save your progress? Sign up for free

Drill 4: First run

Terminal 3 starts the operator against envtest (as on Day 3) and additionally writes the log to 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.log

Expected (shortened):

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, the function ops shows the latest operations from the 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 9

Expected:

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

Why three runs? Creating the children produces watch events, and Owns() puts default/demo into the queue again. The second and third runs find nothing to do – idempotent. Pods never come into existence in envtest – the Deployment controller is missing.

Save your progress? Sign up for free

Drill 5: Owner references and drift

The operator is the source of truth. Manual changes to children get reverted.

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}'

Expected:

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 means: exactly this owner is in charge. SetControllerReference refuses a second controller owner with an error – protection against two operators fighting over one object.

Save your progress? Sign up for free

Drill 6: Change the content – rollout via 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 6

Expected:

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 a real cluster, the changed Pod template starts a rolling update – the Pods read the new content.

Save your progress? Sign up for free

Drill 7: Errors and requeue

What Reconcile returns decides the next attempt:

Return Effect When
Result{}, nil done, until the next event normal case
Result{}, err again with exponential backoff API errors, conflicts
Result{RequeueAfter: d}, nil again after d, no error log waiting for something external

A missing ConfigMap is not a program error but a state. That’s why you use RequeueAfter instead of err – otherwise the backoff floods the log with stack traces.

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 extern

Expected:

staticsite.web.lab.example/extern created
"error": "configmap extern-html: content source not found"
Error from server (NotFound): deployments.apps "extern" not found

Now supply the ConfigMap after the fact and measure how long it takes:

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)

Expected (time varies, 30 s at most):

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

Up to 30 seconds of latency, because the operator doesn’t watch the foreign ConfigMap. On Day 10, a watch with a field index replaces the polling.

Save your progress? Sign up for free

Drill 8: The idempotency trap

The API server fills in defaults. If your code doesn’t set a field that the server fills, CreateOrUpdate sees a difference on every run. Try it: remove DefaultMode and restart the operator in Terminal 3 (Ctrl+C, then the same go run command as in Drill 4).

sed -i.bak '/DefaultMode/d' internal/controller/resources.go

In Terminal 1, after the restart:

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'

Expected:

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

Every run sends an update even though nothing changes (generation stays 1, the server fills in 420 = 0o644 again). With many objects that costs API load – and with a field that really does change (timestamps!), it turns into a hot loop (Day 15). Revert it and restart the operator again:

mv internal/controller/resources.go.bak internal/controller/resources.go

After the restart, ops 3 shows unchanged three times again after another annotate.

Finally, you delete demo. In envtest the children stay behind – in a real cluster the garbage collector cleans them up via the owner references:

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=demo

Expected:

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

Save your progress? Sign up for free

Checkpoint

The operator is running in Terminal 3, extern exists. 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.sh

Expected:

✔ 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

Write the Service with Server-Side Apply instead of CreateOrUpdate: you describe the object completely as an apply configuration, the API server merges it and records in managedFields which fields belong to you.

Hint: Since controller-runtime v0.22, client.Client has an Apply method; the typed builders live in k8s.io/client-go/applyconfigurations/core/v1.

Solution

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-ok

Restart the operator in Terminal 3, then:

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"}'

Expected:

build-ok
staticsite.web.lab.example/ssa created
site-operator Apply
service/ssa patched
{"app.kubernetes.io/name":"ssa"}

ForceOwnership takes contested fields back. The advantage of SSA: no read before the write, no default trap as in Drill 8 – you send only your fields. The drawback: apply configurations are verbose. The code state in code/tag04-site-operator stays with CreateOrUpdate. For Day 5 you revert:

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

Save your progress? Sign up for free

Enterprise Note

  • Never let the operator “correct” --replicas by hand for something an HPA controls: fields owned by another controller don’t belong in the mutate function (or leave them to another field manager via SSA).
  • Owner references only work within the same namespace; for cluster-wide or cross-namespace children you need labels plus finalizers (Day 7).
  • RequeueAfter is polling: with thousands of objects the load distributes poorly. Prefer targeted watches (Day 10).
  • RBAC from the markers is the minimum the operator needs – check in review that no delete on foreign resources slips in.
  • Logs with operation are gold in operations: a constant updated without a spec change is the first sign of an idempotency trap.