Seminar Crossplane Composition Functions mit Go

Inhaltsverzeichnis

1. Seminarüberblick
2. Einordnung und Praxisbezug
3. Schrittweise Seminarinhalte
4. Praxisübungen
5. Zielgruppe und Voraussetzungen

Seminarüberblick

Composition Functions sind der zentrale Erweiterungspunkt moderner Crossplane-Compositions. Im Seminar entsteht eine Go-basierte Function, die beobachtete Ressourcen auswertet, gewünschte Ressourcen erzeugt, Statusinformationen setzt und robuste Fehlermeldungen liefert.

Neben der Implementierung werden Protokoll, SDK-Strukturen, Idempotenz, Tests, Paketmetadaten, OCI-Veröffentlichung, lokale Entwicklungs-Control-Planes und sichere Laufzeitkonfiguration behandelt. Der Code wird wie ein langlebiges Plattformprodukt entwickelt.

Einordnung und Praxisbezug

• Sicherer Umgang mit Function Request, Response, Kontext und gewünschten Ressourcen.
• Testbare, deterministische und idempotente Logik für komplexe Compositions.
• Reproduzierbares Packaging und lokale End-to-End-Tests.
• Betriebsfähige Functions mit klaren Fehlern, Metriken und Versionsstrategie.

Schrittweise Seminarinhalte

Schritt 1: Function-Pipelines technisch verstehen

• Aufrufreihenfolge, beobachteten Zustand und gewünschten Zustand unterscheiden.
• Composition- und Operation-Fähigkeiten im Paketmodell abgrenzen.

Schritt 2: Go-Projekt und SDK einrichten

• Projektstruktur, Abhängigkeiten und Entwicklungswerkzeuge vorbereiten.
• Lokalen gRPC-Dienst und Function-Metadaten initialisieren.

Schritt 3: Requests sicher auswerten

• Composite Resource, composed resources, Eingaben und Kontext lesen.
• Fehlende, optionale und unbekannte Felder defensiv behandeln.

Schritt 4: Gewünschte Ressourcen erzeugen

• Unstrukturierte Kubernetes-Objekte deterministisch aufbauen.
• Stabile Ressourcennamen, Ownership und Aktualisierung berücksichtigen.

Schritt 5: Daten durch die Pipeline transportieren

• Context, Environment-Daten und zusätzliche Ressourcen verwenden.
• Werte zwischen Pipeline-Schritten ohne verdeckte Seiteneffekte übergeben.

Schritt 6: Readiness und Status modellieren

• Bereitschaft komponierter Ressourcen beurteilen.
• Conditions, Ergebnisse, Warnungen und fachliche Statusfelder setzen.

Schritt 7: Referenzen und Verbindungsdaten verarbeiten

• Abhängige Ressourcen über beobachtete Felder und Selektoren verbinden.
• Secret-Ressourcen für aggregierte Verbindungsdaten generieren.

Schritt 8: Fehlerbehandlung und Idempotenz absichern

• Temporäre und dauerhafte Fehler unterscheiden.
• Wiederholte Aufrufe ohne Drift, Duplikate oder zufällige Änderungen gewährleisten.

Schritt 9: Unit-Tests aufbauen

• Request-Fixtures, gewünschte Ressourcen und Fehlerpfade testen.
• Golden Files nur dort einsetzen, wo semantische Vergleiche nicht ausreichen.

Schritt 10: Rendering und End-to-End-Tests durchführen

• Compositions lokal rendern und Ergebnisse gegen Erwartungen prüfen.
• Function in einer lokalen Entwicklungs-Control-Plane ausführen.

Schritt 11: Function-Paket erstellen

• Paketmetadaten, Runtime-Image und Abhängigkeiten definieren.
• Versioniertes xpkg-Artefakt bauen und in eine OCI-Registry übertragen.

Schritt 12: Sicherheit und Laufzeit konfigurieren

• Containerrechte, Ressourcenlimits, Netzwerkzugriffe und Secrets minimieren.
• DeploymentRuntimeConfig und Paketvertrauen in den Betrieb integrieren.

Schritt 13: Performance und Diagnose verbessern

• Große Ressourcenmengen, Serialisierung und unnötige Berechnungen optimieren.
• Strukturierte Logs und aussagekräftige Results für Supportfälle bereitstellen.

Schritt 14: Release- und Kompatibilitätsstrategie festlegen

• Semantische Versionierung mit Composition-Abhängigkeiten verbinden.
• Breaking Changes, Migration und parallele Function-Versionen planen.

Praxisübungen

1. Initialisierung einer Go-basierten Composition Function.
2. Erzeugung mehrerer Cloud- und Kubernetes-Ressourcen aus einer XR.
3. Implementierung von Readiness, Status und Fehlerpfaden.
4. Aufbau von Unit-, Render- und End-to-End-Tests.
5. Packaging und Installation der Function in einer lokalen Control Plane.

Zielgruppe und Voraussetzungen

Zielgruppe: Go-Entwickler, Platform Engineers, Kubernetes-Entwickler und Crossplane-Verantwortliche mit Bedarf an eigener Composition-Logik.

Voraussetzungen: Gute Go-Kenntnisse, sichere Kubernetes- und YAML-Kenntnisse sowie praktische Erfahrung mit XRDs und Pipeline-Compositions.