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.CreateOrUpdatereads, 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-operatorTerminal 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/basesExpected (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 crdExpected:
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),
}}
}
EOFWhy 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.yamlExpected (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.logExpected (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 9Expected:
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 6Expected:
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 externExpected:
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.goIn 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.goAfter 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=demoExpected:
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.shExpected:
✔ 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-okRestart 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.bakSave your progress? Sign up for free
Enterprise Note
- Never let the operator “correct”
--replicasby 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).
RequeueAfteris 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
deleteon foreign resources slips in. - Logs with
operationare gold in operations: a constantupdatedwithout a spec change is the first sign of an idempotency trap.