Zum Inhalt springen
AggregaAggrega
Sprache wählen: Deutsch
Diese Seite wurde maschinell übersetzt. Das englische Original lesen.

Wann ein Pipeline-Schritt angebracht ist

Ein FeatureRecipe bietet Ihnen zwei Wege, die Ausgabe zu gestalten, die ein Feature beisteuert: ein templatebasiertes FeatureRecipe, das seine eigenen Dokumente erzeugt, und einen Pipeline-Schritt (pipeline:), der ein Wasm-Plugin über die gerenderte Ausgabe laufen lässt. Sie lösen unterschiedliche Probleme. Diese Seite ist die Entscheidungshilfe: Greifen Sie bei genau zwei Auslösern zu einem Pipeline-Schritt, und verwenden Sie für alles andere ein templatebasiertes FeatureRecipe.

Die beiden Werkzeuge

Ein templatebasiertes FeatureRecipe ist lokal und generativ. Es erzeugt seine eigenen Dokumente aus seinen eigenen Werten über ein Go-Template — die ConfigMap eines Sidecars, eine Richtlinien-CRD, ein Autoscaler-Objekt. Alles, was es ausgibt, ist eine Funktion von values: und infra: aus dem Feature und vom Render-Kontext, der seinen Templates übergeben wird. Es greift nie in die Ausgabe einer anderen Entität ein; es fügt eigene Dokumente hinzu. Wenn sich das, was Sie erzeugen müssen, aus dem schreiben lässt, was das Feature bereits weiß, ist ein templatebasiertes FeatureRecipe das richtige und einfachere Werkzeug — kein Plugin, keine Pipeline.

Ein Pipeline-Schritt ist global und transformierend. Er läuft nach dem Rendern, über die tatsächliche Dokumentmenge, die der Build bereits ausgegeben hat. Der Host übergibt dem Schritt diese nach Schlüsseln adressierte Dokumentmenge vollständig; der Schritt liest den tatsächlichen Inhalt, wählt die Dokumente aus, auf die er abzielt, und gibt gezielte RFC-6902-Patches für deren Struktur zurück — oder gibt neue Dokumente als Nebeneffekte aus. Ein Schritt urteilt über das, was gerendert wurde, nicht nur über das, was das Feature deklariert hat. Diese Reichweite ist sein ganzer Daseinszweck, und sie ist auch der Grund, warum Sie ihn sparsam einsetzen.

Die beiden Auslöser für einen Pipeline-Schritt

Greifen Sie nur dann zu einem Pipeline-Schritt, wenn einer dieser Fälle zutrifft. Trifft keiner zu, erzeugen Sie das Dokument stattdessen mit einem templatebasierten FeatureRecipe.

  1. Patch im Host-Bereich — Sie müssen in die Struktur einer anderen, bereits gerenderten Entität eingreifen. Der klassische Fall ist das Einfügen einer Umgebungsvariablen, eines Volume-Mounts oder eines Sidecar-Containers in die Arbeitslast der konsumierenden Komponente — ein Dokument, das das Feature selbst nicht verfasst hat. Ein templatebasiertes FeatureRecipe kann das nicht: Es erzeugt seine eigenen Dokumente, es bearbeitet nicht die eines anderen. Ein Pipeline-Schritt kann es, weil er auf der gerenderten Menge arbeitet und die Dokumente der Host-Komponente über ihren Schlüssel adressieren kann.

  2. Inhaltsabhängige Ausgabe oder inhaltsabhängiger Patch — die Ausgabe hängt davon ab, was die gerenderte Menge enthält. Wenn die Ressource, die Sie ausgeben, oder der Patch, den Sie anwenden, eine Funktion des Inhalts ist, den der Build erzeugt hat — die tatsächlichen Ports, die ein Deployment deklariert hat, die Container-Namen, die im Manifest gelandet sind, die Ressourcen, zu denen ein Chart expandiert ist —, braucht die Entscheidung den gerenderten Inhalt in der Hand. Ein templatebasiertes FeatureRecipe rendert aus den Werten, die das Feature selbst hat, und sieht die fertige Menge nie, sodass es keine inhaltsabhängige Entscheidung treffen kann; ein Pipeline-Schritt liest zuerst den Inhalt und handelt dann.

Beide Auslöser haben dieselbe Form: Sie brauchen Informationen, die erst nach dem Rendern existieren — die Struktur einer anderen Entität oder den ausgegebenen Inhalt selbst. Lokale Erzeugung braucht das nie, also braucht lokale Erzeugung nie einen Pipeline-Schritt.

Ein Schritt transformiert; eine Richtlinie validiert

Ein Pipeline-Schritt ist ein Transformator: Er ändert die gerenderte Menge. Er ist nicht der Ort, um zu prüfen, ob ein Ergebnis akzeptabel ist. Um einen Build zu validieren — um zuzusichern, dass eine gepatchte Arbeitslast den Sidecar hat, dass kein Klartext-Secret die Ausgabe erreicht hat, dass ein erforderliches Label vorhanden ist —, binden Sie eine Richtlinie der Render-Phase an: ein Governance-Plugin an der Rolle render-verdict, das nach dem Rendern über die ausgegebenen Artefakte läuft und ein Verdikt zurückgibt. Ein Verdikt halt stoppt den Build; ein Verdikt warn oder info weist hin, ohne zu blockieren.

Halten Sie beides getrennt. Bauen Sie keine Validierungslogik in einen Pipeline-Schritt ein, und greifen Sie nicht zu einer Richtlinie, um die Ausgabe zu verändern — ein Governance-Plugin, das an einer Verdikt-Rolle angebunden ist, gibt Verdikte zurück und patcht nie, und der Host liest die Ausgabe einer Verdikt-Rolle nur als Entscheidung. Ein Schritt gestaltet die Ausgabe; eine Richtlinie für render-verdict beurteilt sie. Die Seite zum Governance-Socket behandelt alle vier Governance-Rollen und die Schweregrade der Verdikte.

Schritte lassen sich zusammensetzen

Ein Pipeline-Schritt kann einen typisierten Eingabe- und Ausgabevertrag deklarieren, sodass seine Eingabe über with: und seine zurückgegebenen Ausgaben validierte Formen statt formloser Blobs sind. Ein Schritt gibt außerdem benannte outputs zurück, und ein später in derselben Pipeline deklarierter Schritt liest die Ausgaben eines vorangehenden Schritts aus seinem eigenen Template with: als .steps.<id>.outputs.<key>. So setzt sich ein zweiteiliges Muster ohne Kopplung zusammen: Ein Fetcher-Schritt gibt eine Credential-Ressource aus und veröffentlicht den Namen des resultierenden Secret als Ausgabe; ein Injector-Schritt liest diesen Namen und patcht die konsumierende Arbeitslast, um es einzuhängen. Jeder Schritt trägt ein einziges Anliegen, und die Pipeline reicht ihre Ausgaben in der deklarierten Reihenfolge weiter.

Querverweise