Zum Inhalt springen
Trainingslager IT-Trainingslager

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.CreateOrUpdate liest, 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-operator

Terminal 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/bases

Erwartet (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 crd

Erwartet:

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

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

Erwartet (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.log

Erwartet (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 9

Erwartet:

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 6

Erwartet:

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 extern

Erwartet:

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

In 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.go

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

Erwartet:

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

Erwartet:

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

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

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Den Operator nie mit --replicas von 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).
  • RequeueAfter ist 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 delete auf fremde Ressourcen hineinrutscht.
  • Logs mit operation sind Gold im Betrieb: Ein Dauer-updated ohne Spec-Änderung ist das erste Zeichen einer Idempotenz-Falle.