Zum Inhalt springen
Trainingslager IT-Trainingslager

Tag 13: kro, Helm, Kustomize oder Operator?

Ziel: Dieselbe NotesApp aus Tag 4 einmal als Helm-Chart und einmal mit Kustomize. Danach weißt du, wann welches Werkzeug passt und ab wann sich ein eigener Operator lohnt. · Dauer: ca. 50 min · Voraussetzung: Tag 12

Briefing

  • Helm rendert Text-Templates zu YAML und spielt das Ergebnis einmal ein. Danach kümmert sich Helm erst beim nächsten helm upgrade wieder darum.
  • Kustomize setzt YAML-Dateien zusammen und flickt sie mit Patches. Es gibt keine Variablen, keine Logik und keinen laufenden Prozess.
  • kro läuft als Controller. Es prüft Ausdrücke vorab, kennt Abhängigkeiten und Readiness und hält den Zustand dauerhaft fest.
  • Ein eigener Operator in Go kann alles, auch Logik, die kein YAML ausdrücken kann. Er ist aber Software, die du schreiben, testen und betreiben musst.

Drill 1: notes als Helm-Chart

mkdir -p ~/kro-lab/tag13/helm/notes/templates
cd ~/kro-lab/tag13
cat > helm/notes/Chart.yaml <<'EOF'
apiVersion: v2
name: notes
version: 0.1.0
appVersion: "0.5.1"
EOF
cat > helm/notes/values.yaml <<'EOF'
image: ghcr.io/thomaszachmann/notes-api:0.5.1
replicas: 1
apiKey: ""
nodePort: 30090
EOF
cat > helm/notes/templates/secret.yaml <<'EOF'
apiVersion: v1
kind: Secret
metadata:
  name: {{ .Release.Name }}-api
stringData:
  apiKey: {{ required "apiKey fehlt" .Values.apiKey | quote }}
EOF
cat > helm/notes/templates/deployment.yaml <<'EOF'
apiVersion: apps/v1
kind: Deployment
metadata:
  name: {{ .Release.Name }}
spec:
  replicas: {{ .Values.replicas }}
  selector:
    matchLabels:
      app: {{ .Release.Name }}
  template:
    metadata:
      labels:
        app: {{ .Release.Name }}
    spec:
      containers:
        - name: api
          image: {{ .Values.image }}
          ports:
            - containerPort: 8080
          env:
            - name: NOTES_API_KEY
              valueFrom:
                secretKeyRef:
                  name: {{ .Release.Name }}-api
                  key: apiKey
EOF
cat > helm/notes/templates/service.yaml <<'EOF'
apiVersion: v1
kind: Service
metadata:
  name: {{ .Release.Name }}
spec:
  type: NodePort
  selector:
    app: {{ .Release.Name }}
  ports:
    - port: 80
      targetPort: 8080
      nodePort: {{ .Values.nodePort }}
EOF

{{ … }} ist Go-Template-Syntax. Helm ersetzt Text, ohne zu wissen, was ein Deployment ist. Ein {{ .Values.replica }} (Tippfehler) wird zu einem leeren Wert, und das merkst du erst, wenn der API-Server das fertige YAML ablehnt oder ein Default greift.

helm lint helm/notes --set apiKey=x
helm install notes helm/notes -n helm-demo --create-namespace \
  --set apiKey=lab-api-key-123
helm install notes2 helm/notes -n helm-demo

Erwartet (gekürzt):

1 chart(s) linted, 0 chart(s) failed
NAME: notes
NAMESPACE: helm-demo
STATUS: deployed
REVISION: 1
Error: INSTALLATION FAILED: execution error at (notes/templates/secret.yaml:6:13):
apiKey fehlt

required ist Helms Ersatz für ein Pflichtfeld. Grenzen wie minimum oder Muster gibt es nur mit einer zusätzlichen Datei values.schema.json.

curl -s localhost:30090/version

Erwartet: 0.5.1.

Fortschritt speichern? Kostenlos registrieren

Drill 2: Drift unter Helm

kubectl -n helm-demo scale deploy notes --replicas=3
kubectl -n helm-demo get deploy notes

Erwartet (nach ein paar Sekunden):

deployment.apps/notes scaled
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
notes   3/3     3            3           4m

Drei Replikas bleiben drei: Helm läuft nicht im Cluster und sieht die Änderung nicht. Beim nächsten Upgrade:

helm upgrade notes helm/notes -n helm-demo --set apiKey=lab-api-key-123

Erwartet (gekürzt):

Error: UPGRADE FAILED: conflict occurred while applying object helm-demo/notes
apps/v1, Kind=Deployment: Apply failed with 1 conflict: conflict with "kubectl" with
subresource "scale" using apps/v1: .spec.replicas

Helm 4 wendet per Server-Side Apply an, und replicas gehört seit dem scale dem Feldbesitzer kubectl. Erst mit --force-conflicts holt sich Helm das Feld zurück:

helm upgrade notes helm/notes -n helm-demo --set apiKey=lab-api-key-123 --force-conflicts
kubectl -n helm-demo get deploy notes

Erwartet (gekürzt):

STATUS: deployed
REVISION: 3
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
notes   1/1     1            1           5m

kro hat in Tag 11 denselben Eingriff in einer Sekunde zurückgesetzt, ohne dass jemand etwas tun musste.

Fortschritt speichern? Kostenlos registrieren

Drill 3: notes mit Kustomize

mkdir -p kustomize/base kustomize/prod
cat > kustomize/base/kustomization.yaml <<'EOF'
resources:
  - deployment.yaml
  - service.yaml
secretGenerator:
  - name: notes-api
    literals:
      - apiKey=lab-api-key-123
EOF
cp helm/notes/templates/deployment.yaml kustomize/base/
cp helm/notes/templates/service.yaml kustomize/base/

Ersetze in beiden kopierten Dateien jedes {{ … }} durch einen festen Wert: {{ .Release.Name }} durch notes, {{ .Values.replicas }} durch 1, {{ .Values.image }} durch ghcr.io/thomaszachmann/notes-api:0.5.1, {{ .Release.Name }}-api durch notes-api und {{ .Values.nodePort }} durch 30091. Kustomize kennt keine Platzhalter. Dann die Variante für prod:

cat > kustomize/prod/kustomization.yaml <<'EOF'
namespace: kust-demo
resources:
  - ../base
patches:
  - target:
      kind: Deployment
      name: notes
    patch: |-
      - op: replace
        path: /spec/replicas
        value: 2
EOF
kubectl create namespace kust-demo
kubectl kustomize kustomize/prod | head -9

Erwartet:

namespace/kust-demo created
apiVersion: v1
data:
  apiKey: bGFiLWFwaS1rZXktMTIz
kind: Secret
metadata:
  name: notes-api-mhd7mgtg64
  namespace: kust-demo
type: Opaque
---

Der secretGenerator hängt einen Hash an den Namen. Ändert sich der Inhalt, ändert sich der Name, und Kustomize trägt den neuen Namen im Deployment ein. Das erzwingt einen Rollout.

kubectl apply -k kustomize/prod
kubectl -n kust-demo get deploy
curl -s localhost:30091/version

Erwartet:

secret/notes-api-mhd7mgtg64 created
service/notes created
deployment.apps/notes created
NAME    READY   UP-TO-DATE   AVAILABLE   AGE
notes   2/2     2            2           21s
0.5.1

Fortschritt speichern? Kostenlos registrieren

Drill 4: Nebeneinander

find helm -type f | xargs wc -l | tail -1
find kustomize -type f | xargs wc -l | tail -1
wc -l ../tag04/notesapp-rgd.yaml ../tag04/notes.yaml | tail -1

Erwartet:

  51 total
  55 total
  71 total

Gleich viel YAML. Der Unterschied liegt darin, was danach passiert:

Helm Kustomize kro Go-Operator
Läuft im Cluster nein nein ja ja
Prüfung vorab Lint, optional JSON-Schema nein Typen, Felder, Kreise Compiler, Tests
Pflichtfelder, Grenzen required, Schema-Datei nein im Schema der CRD im Schema der CRD
Reihenfolge, Readiness Hooks, --wait nein aus Ausdrücken, readyWhen im Code
Drift-Korrektur beim nächsten Upgrade beim nächsten Apply sofort sofort
Eigene API für Teams nein nein ja ja
Logik (Schleifen, API-Aufrufe) Templates nein CEL, forEach alles
Was du betreibst ein CLI ein CLI einen Controller deine Software

Fortschritt speichern? Kostenlos registrieren

Drill 5: Wann ein Operator?

kro deckt ab, was sich als Graph aus Kubernetes-Objekten beschreiben lässt. Einen eigenen Operator brauchst du, sobald eins davon zutrifft:

  • Du musst externe Systeme ansprechen, für die es keinen Controller gibt, etwa eine Firmen-API, die Benutzer anlegt.
  • Du brauchst Abläufe über die Zeit: erst Backup, dann Upgrade, bei Fehler zurück. kro kennt nur „so soll es aussehen“, keine Schritte.
  • Du brauchst echte Logik, die CEL nicht ausdrücken kann, oder Leistung für tausende Instanzen mit eigenem Caching.

Oft ist die Kombination am besten: Ein Operator (selbst geschrieben oder fertig, wie CloudNativePG oder der AWS Controller for Kubernetes) liefert einzelne Bausteine, und kro setzt sie zu einer API für die Teams zusammen. Wie man einen Operator schreibt, zeigt „Kubernetes-Operatoren zum Anfassen“.

Fortschritt speichern? Kostenlos registrieren

Kontrollpunkt

helm list -n helm-demo

Erwartet: notes mit STATUS deployed.

kubectl -n kust-demo get deploy notes

Erwartet: READY 2/2.

diff -r kustomize ~/kro-lab/code/loesung/tag13/kustomize

Erwartet: keine Ausgabe.

Challenge

Räume beide Varianten ab. Welcher Befehl löscht bei Helm alles, und was bleibt bei Kustomize übrig, wenn du nur kubectl delete -k aufrufst?

Hinweis: Wer hat den Namespace kust-demo angelegt?

Lösung

helm uninstall notes -n helm-demo
kubectl delete -k kustomize/prod
kubectl delete namespace helm-demo kust-demo

Erwartet:

release "notes" uninstalled
secret "notes-api-mhd7mgtg64" deleted from kust-demo namespace
service "notes" deleted from kust-demo namespace
deployment.apps "notes" deleted from kust-demo namespace
namespace "helm-demo" deleted
namespace "kust-demo" deleted

helm uninstall löscht alles aus dem Release, delete -k alles, was die Kustomization erzeugt. Die Namespaces bleiben in beiden Fällen stehen: Helm hat helm-demo mit --create-namespace angelegt, aber nicht ins Release aufgenommen, und kust-demo hast du von Hand angelegt.

Fortschritt speichern? Kostenlos registrieren

Enterprise-Notiz

  • Kein Entweder-oder: kro selbst kommt als Helm-Chart. Viele Plattformen verteilen RGDs und die zugehörigen ClusterRoles mit Helm oder Kustomize und die Instanzen über GitOps.
  • Bestehende Charts: Ein vorhandenes Helm-Chart musst du nicht nach kro umbauen. Mit dem Helm-Controller von Flux (HelmRelease) als Objekt in einer RGD bekommt das Chart trotzdem eine einfache API.
  • Entscheiden nach Betrieb, nicht nach Zeilen: Die Menge YAML ist überall gleich. Die Frage ist, wer dafür sorgt, dass der Zustand im Cluster stimmt, wenn niemand hinsieht.