Datensäulen
Die konzeptionelle Einordnung der fünf strukturellen DSL-Schlüsselwörter — parameters, values, uses, infra, inject — findet sich in architecture/06-data-taxonomy-and-composition.md. Diese Seite behandelt die kanonische Liste der Datensäulen, die Authoring-Semantik pro Säule, die säulenübergreifende Mechanik und das Vokabular der Standardwerte, dem Autoren über die Säulen hinweg begegnen. Die ergänzende Topologie-Triade (provides, inject, uses — Schlüsselwörter, die Graphkanten verdrahten) ist unter topology-triad.md dokumentiert; das von den Datensäulen getrennte Metadatenvokabular (Labels, Annotationen, Felder der Veröffentlichungsoberfläche) findet sich unter labels-and-annotations.md und publishing-surface.md.
Kanonische Säulenliste
Aggrega-Entitäten tragen sieben benannte Datensäulen. Fünf nehmen als lebendiger Zustand bis zum Rendering am IR-Datenfluss teil; zwei sind transient oder privat und existieren nur in bestimmten Kompilierungsphasen.
| Säule | Befindet sich auf | Lebenszyklus | Rolle |
|---|---|---|---|
values | Komponenten-/Anbindungsinstanzen des Aggregate | Lebendig bis zum Rendering | Vom Entwickler verfasster kognitiver Payload |
infra | Komponenten-, Anbindungs- und Verbindungseinträge des Release | Lebendig bis zum Rendering | Vom Operator verfasste physische Dimensionierung |
provides | provides:-Block des Recipe | Lebendig bis zum Rendering (abgeleitete Säule — siehe unten) | Vom Recipe berechnete öffentliche Ausgabezeichenketten, die die Topologie-Pipe konsumiert |
uses | Komponenten-/Funktionsinstanzen des Aggregate | Lebendig bis zum Rendering | Topologische Kanten zu anderen Komponenten / Funktionen |
features | Komponenteninstanzen von Aggregate + Release; Slots, die im featuresSchema einer Katalogentität deklariert sind — siehe „Features pillar (Features-Säule)“ unten | Lebendig bis zum Rendering | Anbindungssäule — eine Form für jede Anbindungsfamilie |
parameters | Wurzeln von Aggregate + Release | Lesbar bis zum Ende der Pipeline, bis jede Render-Phase abgeschlossen ist; während des Renderings über die asymmetrische Freigabe für Pfad-Templates zugänglich; Wert-Template-Kontexte konsumieren die Literale nach der Interpolation statt .parameters direkt | Slots pro Umgebung, die das Release erfüllt |
locals | locals:-Block des Recipe | Recipe-privat — nur innerhalb der eigenen Templates des Recipe sichtbar | Berechneter Zeichenkettenzustand, den Recipes in der Locals-Präambel ableiten |
values / infra / provides / uses / features sind die fünf lebendigen Säulen, die der Template-Kontext zur Laufzeit jeweils über .values, .infra, .provides, .context.uses und .features bereitstellt. parameters und locals stehen nicht auf der Liste der lebendigen Säulen — parameters, weil es die Auflösung nicht überdauert; locals, weil es Recipe-privat ist und nie Entitätsgrenzen überschreitet.
Säulen sind Wegweiser, keine Mauern: Die Template-Engine erlaubt säulenübergreifende Lesezugriffe an jeder Stelle, sofern Self-Containment-Regeln sie nicht ausdrücklich verbieten (ein provides:-Block des Recipe und ein source:-Block des Recipe, die .context.inject / .context.uses lesen; dokumentiert unter templates/expansion-matrix.md). Säulengrenzen sind Authoring-Disziplin, keine Durchsetzung durch die Sprache.
Säulengrenzen und Authoring-Disziplin
Säulenübergreifende Lesezugriffe aus einem Recipe-Template sind an jeder Stelle, die den vollständigen Template-Kontext erlaubt, uneingeschränkt. Die Authoring-Disziplin erwartet, dass Autoren:
.valuesfür den kognitiven Payload lesen (vom Entwickler verfasste Absicht)..infrafür die physische Dimensionierung lesen (vom Operator verfasste Dimensionierung)..context.uses[].provides.<key>für komponentenübergreifende Zeigerzeichenketten lesen (der Datenfluss der Topologie-Triade)..context.injectfür die Zustell-Pipe nach der Hydratisierung lesen (zusammengesetzt aus Inject-Quellen übercomponent.inject,uses[].injectundinjectMapping-Abfangungen eines FeatureRecipe).
Die Disziplin besteht aus Wegweisern, nicht aus Mauern. Ein Recipe-Template, das .infra.replicas liest, um ein values:-Feld zu steuern, funktioniert; die Template-Engine sperrt den Lesezugriff nicht. Die Architektur fasst Säulengrenzen so auf, dass sie die Authoring-Absicht beschreiben — wem die Daten gehören — statt einer Laufzeitbeschränkung. Die Konventionen entsprechen der Aufteilung in vier Domänen: Vom Entwickler verfasste Werte kommen aus .values; vom Operator verfasste Dimensionierung kommt aus .infra; komponentenübergreifende Koordinaten kommen aus der Topologie-Pipe.
Wenn eine bewusste säulenübergreifende Brücke nötig ist — z. B. stellt das schema: einer Component einen entwicklerseitigen Regler bereit, den das valuesMapping:-Template des Recipe in eine Ops-seitige Ausgabe in infra:-Form leitet, gemäß vocabulary/inheritance-and-interface.md —, behandelt die Architektur die Brücke als ausgeschilderte Ausnahme. Siehe „Cross-pillar mechanics (Säulenübergreifende Mechanik)“ unten.
Values
Die values:-Säule trägt den vom Entwickler verfassten kognitiven Payload — die Parameter für die Form der Anwendung, die der Entwickler pro Komponenteninstanz vorgibt. Das schema: der Component deklariert die Form der Werte; das Aggregate des Entwicklers befüllt konkrete Werte pro Instanz. Dies ist die Domäne des Entwicklers.
Verfasst in:
- Aggregate
components.<id>.values:— kognitiver Payload pro Komponenteninstanz. - Aggregate
subsystems.<name>.components.<id>.values:— dasselbe, innerhalb von in Subsystemen gruppierten Komponenten. - Aggregate
components.<id>.features.<name>.values:undfeatures.<name>.values:eines Subsystems — Werte-Payload der Anbindung, unabhängig davon, zu welcher Familie das angebundene Feature gehört (die Vault-Abfrageparameter einer Credential-Anbindung werden hier wie alle anderen verfasst).
Verboten in:
- Release-Entität (das Release-Schema verbietet einen
values:-Block auf jeder Verschachtelungsebene — Parameter Hoisting ist der unterstützte Weg für umgebungsspezifische Variation; siehe Parameters unten).
Validiert durch: den values:-Block des schema der Component (und den values:-Block des schema des Feature für Feature-Anbindungen), aufgelöst zu JSON Schema 2020-12 beim Laden der Component / des Feature gemäß vocabulary/validation-surface.md, Ebene 2.
Konsumiert von: valuesMapping:-Templates des Recipe über .values. Der vollständige Template-Kontext stellt das Wörterbuch der aufgelösten Werte an jeder Template-Stelle des Basis-Renderings bereit.
Infra
Die infra:-Säule trägt die vom Operator verfasste physische Dimensionierung — Replikas, Ressourcenanforderungen, IOPS-Limits, Regionsbindung, Maschinenklasse. Sie drückt das Wo und wie groß aus und ergänzt das Was und wie es sich verhält der values. Dies ist die Domäne des Operators.
Vier Authoring-Oberflächen
Autoren begegnen infra: an vier unterschiedlichen Oberflächen, jede mit anderem Geltungsbereich und anderem Kaskadenverhalten:
| # | Oberfläche | Geltungsbereich | Merge-Vorrang |
|---|---|---|---|
| 1 | Release-Boundary components.<id>.infra: (spec.components.<id>.infra: in einem Release ohne Boundaries) | Eine Komponenteninstanz | Die eigene Dimensionierung der Komponente; keine andere Oberfläche schreibt sie |
| 2 | Release-Boundary features.<name>.infra: | Eine Anbindung mit Boundary-Geltungsbereich, an jeder Komponente in der Boundary | Niedrigster Vorrang für diese Anbindung — Oberfläche 3 überschreibt sie Feld für Feld |
| 3 | Release-Boundary components.<id>.features.<name>.infra: | Eine Anbindung an einer Komponente | Überschreibt Oberfläche 2 für diese Anbindung, Feld für Feld |
| 4 | Release components.<id>.uses.<socket>.<alias>.infra: | Eine Verbindung | Gegen das infraSchema des Sockets validiert; erreicht nur das Rendering der konsumierenden Komponente |
Oberfläche 1 wird am häufigsten verfasst: Ein Operator dimensioniert jede Komponente, die das Release platziert. Eine Boundary trägt kein eigenes infra: — das Release-Schema lehnt eines ab —, daher wird eine Dimensionierung, die mehrere Komponenten teilen, an jeder einzelnen geschrieben oder über extends: von einem übergeordneten Release geerbt (siehe unten). Die Oberflächen 2 und 3 decken die Dimensionierung von Feature-Anbindungen ab — Features tragen ihren eigenen infra-Payload, den das FeatureRecipe beim Synthetisieren von Sidecars oder Ressourcen pro Feature konsumiert: Eine Anbindung mit Boundary-Geltungsbereich wird einmal dimensioniert, und eine Komponente passt ein einzelnes Feld davon an.
„Infra primär lokalisiert“ — die Regel mit Ausnahmen
Das architektonische Ziel für infra: ist komponentenlokal: Die Dimensionierung einer Komponente gilt für diese Komponenteninstanz und greift nicht auf andere Komponenten über. Das ist der Mechanismus, mit dem Ops die IOPS der Datenbank erhöhen kann, ohne die CPU-Anforderung des API-Servers zu beeinflussen.
Die Regel: infra: ist primär lokalisiert auf der Oberfläche, die es verfasst hat. Kaskadenausnahmen existieren absichtlich:
- Annotationskaskade der Boundary.
annotations:einer Boundary kaskadieren durch verschachtelte Boundaries bis zu inneren Komponenten (Oberfläche 5 der Annotationsmatrix in labels-and-annotations.md). Annotationen, die Recipes als Routing-Eingabe konsumieren, werden zu indirekterinfra-Reichweite — die Annotation auf Boundary-Ebene fließt über.context.annotations.releasein die gerenderte Ausgabe des Recipe pro Knoten. - Release-Vererbung über
extends:. Ein Release, das mitextends:ein übergeordnetes Release erweitert, erbt dieinfra-Deklarationen des übergeordneten an jeder Oberfläche, die sie trägt, sofern das untergeordnete sie nicht pro Schlüssel überschreibt. Der Wert des untergeordneten gewinnt Schlüssel für Schlüssel, bis hinunter zum ersten unteilbaren Wert — einem Skalar, einer Liste, einem Template —, der als Ganzes ersetzt wird, und ein Schlüssel, den das untergeordnete alsnullschreibt, wird entfernt statt auf nichts gesetzt. Die Vererbung überschreitet bewusst die Boundary pro Release; zur vollständigen Faltungsregel und zu dem, was sonst noch mitgeht, sieheentities/release.md. - Säulenübergreifende Weiterleitung über eine Schema-Brücke. Das
schema:einer Component kann einen entwicklerseitigenvalues:-Regler bereitstellen, den dasvaluesMapping:-Template des Recipe in die Provider-Ausgabe ininfra:-Form leitet (siehe „Cross-pillar mechanics — Schema-bridge cross-pillar piping (Säulenübergreifende Mechanik — Säulenübergreifende Weiterleitung über eine Schema-Brücke)“ unten). Genau genommen entsteht der Wert invalues:und fließt in die gerenderte Ausgabe; die Kaskade ist instanzintern, aber säulenübergreifend.
Lokalisierung ist die Entwurfsabsicht, keine Mauer, die die Engine durchsetzt: Die obigen Kaskaden sind bewusste Ausnahmen, jede an der Oberfläche dokumentiert, die sie trägt.
Aufteilung nach Seite und Säule für die annotationsgesteuerte Feature-Expansion. Die Invariante des Aggregate als Authoring-Oberfläche setzt sich im Pfad der annotationsgesteuerten Feature-Expansion fort: Annotationen auf Aggregate-Seite (Geltungsbereich Subsystem und Komponenteninstanz) dürfen nur maps.values-Unterschlüssel auslösen; Annotationen auf Release-Seite (Geltungsbereich Boundary und Komponenteninstanz) dürfen nur maps.infra-Unterschlüssel auslösen. Ein Manifest-Binding kann Pfade in beiden Säulen deklarieren; jede Seite löst nur ihre kompatible Teilmenge aus, und die seitenübergreifende Komposition führt die Beiträge zur Build-Zeit der IR pro Feld zusammen. Die Aufteilung bewahrt die Authoring-Trennung values-Entwickler / infra-Operator auf der Annotationsoberfläche — dieselbe Trennung, die values: und infra: auf den Oberflächen expliziter Anbindung durchsetzen. Siehe providers/well-known-annotations.md §„Side-vs-pillar partition per subkey (Aufteilung nach Seite und Säule pro Unterschlüssel)“ für die Erläuterung pro Unterschlüssel und das Muster der seitenübergreifenden Komposition.
Provides
Die provides:-Säule ist abgeleitet — ein Recipe deklariert sie, aber anders als bei values / infra verfasst der Entwickler sie nicht direkt. Recipes berechnen die öffentlichen Ausgabezeichenketten, die die Topologie-Pipe konsumieren wird.
Der provides:-Block eines Recipe ist eine Map aus <key>: <template>-Paaren. Jedes Template wird während der Provides-Auswertung gegen die eigene, in sich geschlossene Oberfläche des Recipe ausgewertet (.values, .infra, .context.instance_id, .context.rendered_name, sofern der Provider des Knotens einen meldet, und die aufgelösten .locals des Knotens). Die resultierenden Zeichenketten werden über .provides bereitgestellt und von den uses[].inject-Blöcken der Aufrufer über from: "<key>"-Referenzen konsumiert. .locals ist verfügbar, weil die Locals des Knotens in der Präambel dieser Phase aufgelöst werden, vor ihren Provides (siehe Locals unten); einen Schlüssel zu nennen, den der Locals-Block nicht deklariert, führt zum Abbruch.
Self-Containment-Invariante. provides:-Templates eines Recipe dürfen nicht auf .context.inject oder .context.uses verweisen. Die Provides-Auswertung führt diese Templates in beliebiger Reihenfolge aus — sie schließen nur über die eigenen Daten des Knotens, daher spielt die Reihenfolge keine Rolle. Knotenübergreifende Referenzen würden diese Auswertung an die topologische Iterationsreihenfolge koppeln, was der Entwurf bewusst vermeidet. Siehe templates/expansion-matrix.md, Zeile 6, für die Regel und ihre Begründung.
Warum provides: eine Säule ist. Die Ausgabezeichenketten sind die kanonische öffentliche Oberfläche jedes Recipe; nachgelagerte Konsumenten (uses[].inject des Aufrufers, injectMapping-Blöcke eines FeatureRecipe, die die aufgelösten Provides des Ziels über .context.uses lesen) behandeln das Wörterbuch als typisierten Vertrag. provides: als Säule zu bezeichnen, erkennt ihren erstklassigen Status neben values / infra / uses / features an. Sie als „nur ein internes Detail des Recipe“ zu behandeln, unterschätzt ihre Rolle als primäre Datenquelle der Topologie-Pipe.
Uses
Die uses:-Säule ist die Deklaration der topologischen Kanten. Der uses:-Block einer Komponenteninstanz benennt die Kanten, an denen die Komponente beteiligt ist — die Sockets, über die sie Ziele konsumiert. Die vollständige Grammatik ist unter topology-triad.md dokumentiert; dieser Abschnitt nennt uses: der Vollständigkeit halber als Säule.
uses: befindet sich auf Komponenteninstanzen des Aggregate + Funktionsanbindungen; der Template-Kontext zur Laufzeit stellt pro ausgehender Verbindung einen Eintrag bereit, nach ihrem Alias geschlüsselt, als .context.uses. Die Projektion trägt die aufgelösten Ziel-Metadaten jeder Kante (die provides des Ziels, Labels, Annotationen), sodass die Recipes der Aufrufer bei der Template-Auswertung des Basis-Renderings komponentenübergreifende Zeigerzeichenketten lesen können, und die auf dieser Verbindung geschriebenen Anbindungen unter .context.uses.<alias>.features.<slot>.
Features-Säule
features: ist die Anbindungssäule: ein Schlüsselwort, eine Form, jede Anbindung. Ein operatives Feature, ein Credential-Feature und ein Identitäts-Feature werden alle hier unter dem Instanznamen deklariert, den der Autor wählt. Der Template-Kontext zur Laufzeit stellt die Anbindungen des Knotens als .features.<name> bereit, jede mit type, values, infra und den aufgelösten provides der Anbindung. Eine Anbindung, die auf einer der Verbindungen der Komponente geschrieben ist, wird stattdessen in derselben Form unter der Verbindung bereitgestellt, unter .context.uses.<alias>.features.<slot>, und nie unter .features — daher trifft ein Recipe, das über .features iteriert, nur auf die eigenen Anbindungen der Komponente (siehe der Vertrag des Template-Kontexts).
Eine Anbindung, deren Instanzname einem Slot entspricht, den die Entität in featuresSchema deklariert, füllt diesen Slot; jeder andere Instanzname ist eine freie Anbindung. Das Füllen eines Slots verbindet die vier Oberflächen, die ein slotbasiertes Credential durchläuft:
| Oberfläche | Wo verfasst | Rolle |
|---|---|---|
Component / Feature featuresSchema: | Katalogentität | Deklariert die Slots, die die Entität erwartet; steuert pro Slot die Zustell-Allowlist (env / file / blackbox) und optional einen Label-Selektor, den die Füllung erfüllen muss |
Aggregate components.<id>.features.<slot>: | Komponenteninstanz des Aggregate | Füllt den Slot mit einer Anbindung; liefert das eigene values: der Anbindung und, für einen transparenten Slot, ihr inject:-Mapping |
Workload containers.<name>.attachments.<KEY>.from/as: | Workload-Body des Recipe | Verweist auf einen deklarierten Slot — oder, neben connection: <alias>, auf einen Slot, den der Socket dieser Verbindung deklariert — und gibt die Zustellung pro Container für das vor, was ihn gefüllt hat |
FeatureRecipe (source / workload / artifacts / valuesMapping, injectMapping, pipeline:) | das gebundene FeatureRecipe | Erzeugt die Ausgabe der Anbindung — eine emittierte Ressource, eine Neufassung der Zustellung oder beides |
Der Slotname ist der tragende Bezeichner über alle vier hinweg: Oberfläche 1 deklariert ihn, die Oberflächen 2–4 verweisen auf ihn, und der Datenfluss verläuft in eine Richtung (deklarieren → füllen → verweisen → erzeugen).
Zur Authoring-Checkliste siehe examples/04-secrets.md „The secret-delivery checklist (Die Checkliste für die Secret-Zustellung)“.
Locals
Die locals:-Säule ist Recipe-privater Zustand. Der gesamte Block wird in der Locals-Präambel aufgelöst, vor dem provides: dieses Knotens; die resultierenden Zeichenketten sind für jedes der späteren eigenen Templates des Recipe sichtbar — provides:, source:, valuesMapping:, workload:, artifacts:, assertions:, pipeline[].with. Ein provides:-Template, das einen Schlüssel nennt, den der Block nicht deklariert, führt zum Abbruch.
Verfasst in: spec.locals:-Block des Recipe — eine Map aus <key>: <template>-Paaren, die gegen eine in sich geschlossene knotenlokale Oberfläche ausgewertet werden: .context.instance_id, .values, .infra und die bereits aufgelösten Einträge desselben Blocks. Sonst steht nichts darauf: .provides, .metadata und der Rest von .context.* nicht, und ein Verweis auf eines davon führt zum Abbruch.
Die Reihenfolge ist tragend. Einträge werden in der geschriebenen Reihenfolge aufgelöst, und ein Eintrag kann ein Geschwister lesen, das über ihm definiert ist, und erhält dessen aufgelösten Wert. Verkettung läuft nur abwärts — wo ein Eintrag einen anderen liest, wird das Verschieben der Definition unter ihren Leser abgelehnt, und der Compiler ordnet den Block nie um, damit der Verweis aufgelöst wird. Ein Verweis auf einen späteren Eintrag bricht ab und nennt den Reihenfolgefehler; ein Verweis auf einen nicht deklarierten Schlüssel bricht ab und nennt den Schlüssel. Bei einem Recipe, dessen source: ein strukturierter Block ist, werden beide Fehler auch abgelehnt, während das darin genannte Artefakt gepinnt wird, sodass aggrega pull sie meldet, bevor ein Build Ausgabe rendert. Die Prüfung liest den Pfad, zu dem ein Verweis aufgelöst wird, statt der Tastenanschläge, und erreicht daher gleichermaßen die direkte Form, einen with .locals-Block, eine an .locals gebundene Variable und den Block in Klammern, (.locals).<key> oder ($.locals).<key>. Eine Schreibweise deckt sie nicht ab: einen Schlüssel, der über eine Funktion erreicht wird, etwa index .locals oder (default dict .locals).<key>. Ein fehlender Schlüssel, der so erreicht wird, bricht nicht ab und rendert den wörtlichen Text <no value> statt gar nichts — außer über index selbst, das auf jeder Template-Oberfläche abbricht und den Schlüssel nennt, wenn die gelesene Map ihn nicht enthält.
Sichtbarkeit: Recipe-privat. Es gibt kein Feld .context.uses[].locals — ein Aufrufer kann die Locals seines Ziels nicht über die Kante lesen. Was ein Aufrufer lesen darf, ist das provides: des Ziels.
Anwendungsfälle:
- Berechnung Recipe-interner Zeigerzeichenketten (z. B.
secret_target_admin_password: "redis-auth", das Suffix des Namens eines Secret), die sowohlvaluesMapping:als auchprovides:des Recipe konsumieren und die ein an dieselbe Komponente angebundenes Credential-FeatureRecipe als.locals.secret_target_admin_passwordliest — die Templates einer Anbindung sehen die aufgelösten Locals des Host-Recipe, zusammengeführt mit den eigenen der Anbindung. Auf dem Zielhelmschreibt jedes von ihnen den vollständigen Namen als{{ .context.rendered_name }}-{{ .locals.secret_target_admin_password }}: Der gerenderte Name ist der Name der Komponente, geschrieben in den Zeichen, die ein Kubernetes-Name erlaubt, und ein Local kann ihn nicht lesen, daher trägt das Local das Suffix und jeder Leser fügt beides zusammen. - DRY-Zusammenfassung wiederholter berechneter Werte innerhalb eines Recipe (ein einmal berechneter Hostname, auf den mehrere
valuesMapping:-Felder verweisen). - Zwischenwerte für komplexe Template-Logik, die inline unlesbar wäre.
provides: und locals: — öffentliches Gesicht vs. privates Gesicht
Die beiden Recipe-seitigen Säulen tragen eine bewusste Sichtbarkeitstrennung, die Autoren im Blick behalten sollten:
provides:ist das öffentliche Gesicht. Jeder Schlüssel ist die kanonische Oberfläche der Topologie-Pipe — dieuses[].inject-Blöcke nachgelagerter Aufrufer konsumieren sie überfrom: "<key>"-Referenzen. Dasprovides:-Wörterbuch ist ein typisierter Vertrag, von dem Aufrufer abhängen; einen Schlüssel umzubenennen oder zu entfernen, ist eine inkompatible Änderung für jedes Recipe, dessenuses[].inject-Deklarationen darauf verweisen.locals:ist das private Gesicht. Jeder Schlüssel ist Recipe-interner Zustand, der nur innerhalb der nachfolgenden eigenen Templates des Recipe sichtbar ist. Kein Aufrufer kann die Locals eines Recipe lesen; die Namen inlocals:gehören zu keiner veröffentlichten Schnittstelle, und sie umzubenennen ist ein Recipe-internes Refactoring ohne nachgelagerte Wirkung.
Die beiden sind außerdem geordnet: locals: wird zuerst aufgelöst, daher darf provides: .locals lesen, locals: aber nicht .provides. Den Wert eines Local über provides: zu veröffentlichen, heißt daher, einen provides-Eintrag hinzuzufügen, der das Local liest — der Ausdruck bleibt an einer Stelle.
Die Trennung ist bewusst, gemäß der architektonischen Trennung der Recipe-Interna (privat) von der Recipe-Schnittstelle (öffentlich). Autoren, die provides: und locals: als einen Namensraum behandeln, verlieren die Sichtbarkeitsunterscheidung und riskieren, internen Zustand über die Topologie-Pipe offenzulegen — jeder in provides: deklarierte Schlüssel wird Teil der Vertragsoberfläche des Recipe, ob der Autor es beabsichtigt hat oder nicht. Das Ziel der Disziplin: einen Schlüssel zuerst in locals: deklarieren; erst dann zu provides: befördern, wenn ein nachgelagerter Aufrufer ihn tatsächlich braucht.
Die Sichtbarkeit wird durch die Säule bestimmt, in der ein Schlüssel deklariert ist: Es gibt keinen Sichtbarkeitsmarker pro Schlüssel, daher ist ein Wert, der zugleich privat und veröffentlicht ist, ein locals:-Eintrag und ein provides:-Eintrag, der ihn liest.
Parameters
Sowohl das Aggregate- als auch das Release-Schema tragen an ihrer Wurzel ein parameters-Wörterbuch. Entwickler deklarieren die Schlüssel, die das Aggregate erwartet; Ops befüllt die Werte aus umgebungsspezifischen Release-Dateien. Diese Entkopplung ist der Mechanismus für die GitOps-Promotion: Ein einziges unveränderliches Aggregate.yaml durchläuft die Umgebungen Dev, Staging und Production, wobei das Release jeder Umgebung seine eigenen Parameterwerte liefert.
spec: parameters: corp_db_name: type: string required: true env_workers: type: integer required: true region: type: string required: true enable_debug: type: boolean required: true components: my-backend: type: core/python-worker:1.0.0 values: workers: {{ .parameters.env_workers }} region: "{{ .parameters.region }}"# release-prod.yaml — inline parameter valuesspec: aggregate: my-app manifest: prod-manifest parameters: corp_db_name: "enterprise_data" env_workers: 10 region: "eu-west-1" enable_debug: falseFür CI/CD-Abläufe, die die Parameterwerte in einer separaten Datei halten (z. B. eine umgebungsspezifische .yaml, die neben dem Release eingecheckt ist), verwendet das Release die $import:-Form: parameters: { $import: ./prod-values.yaml }. Der Inhalt der Datei ersetzt die Inline-Map an der Release-Oberfläche. Der Pfad wird vom Verzeichnis aus aufgelöst, das das Release enthält, gleich von wo ein Befehl ausgeführt wird, und muss zu einer Datei innerhalb des Workspace führen — oder, für ein außerhalb des Workspace angegebenes Release, innerhalb des Verzeichnisses, das es enthält. Mehrdateien-Schichtung (die Kombination einer Basisdatei mit einem umgebungsspezifischen Overlay) wird durch extends:-Ketten eines Release ausgedrückt — das übergeordnete Release liefert Basisparameter; das untergeordnete Release erweitert und überschreibt pro Schlüssel.
Parameter-Lebenszyklus. Der Compiler löst Parameter in drei Phasen auf. (1) Default-Befüllung — Slots mit definiertem default: und ohne Release-Wert erhalten ihren Default. (2) Validierung des Parametervertrags — der typisierte parameters:-Vertrag validiert jeden Wert gegen seine deklarierten type / enum / min / max / pattern-Einschränkungen, einen eingesetzten Default eingeschlossen, sodass ein Default, der seinen eigenen Vertrag verletzt, den Build abbricht. (3) Interpolation — der Compiler wertet den gesamten Text des Aggregate als Template aus und ersetzt jede {{ .parameters.<slot> }}-Referenz durch den aufgelösten Wert. Die zusammengeführte Map bleibt danach während des Renderings lesbar, sodass Pfad-Templates (Release-Boundary directory: / subDirectory:) .parameters.<slot> direkt lesen können, gegen die geschlossene Allowlist, die unter ../path-template-variables.md dokumentiert ist. Wert-Template-Oberflächen (Recipe valuesMapping, FeatureRecipe injectMapping / provides / pipeline.with, Workload-Bodies) erhalten .parameters NICHT in ihrem Template-Kontext — sie konsumieren die aufgelösten Werte, die durch die Interpolation (3) in die umgebenden values:-Zeichenketten geschrieben wurden.
Die Checkliste zum Hochziehen von Parametern
Jeder umgebungsübergreifende Wert fließt nacheinander durch vier Authoring-Berührungspunkte. Das mentale Modell, das Autoren mitnehmen: Bei jedem Wert, der zwischen Dev / Staging / Production variiert, rechnen Sie damit, das Aggregate (deklarieren), das values-Template (verweisen), das Release (erfüllen) und das Recipe-Template (konsumieren) anzufassen.
| Schritt | Oberfläche | Aktion |
|---|---|---|
| 1 | Aggregate spec.parameters.<name> | Deklarieren Sie den Parameter als Teil des typisierten Authoring-Vertrags des Aggregate. Jeder Parameter-Slot trägt einen deklarierten type (string, integer, number, boolean, array, object), eine optionale description, einen optionalen default, optionale Einschränkungen des Wertebereichs (enum, min, max, pattern, minLength, maxLength) und eine optionale verschachtelte Struktur für objekttypisierte Slots. Der Vertrag validiert jeden vom Release gelieferten Wert vor der Interpolation. |
| 2 | values:-Template der Component innerhalb desselben Aggregate | Verweisen Sie auf den Parameter über {{ .parameters.<name> }} aus dem values:-Block jeder Komponente (oder Funktion oder jedes Sub-Aggregats), die ihn konsumiert. Der Verweis ist ein Go-Template-Ausdruck — der Compiler wertet ihn während der Interpolationsphase der Auflösung aus. |
| 3 | Release spec.parameters.<name> (inline oder parameters: { $import: ./path.yaml }) | Erfüllen Sie den Parameter mit dem umgebungsspezifischen Wert an der Release-Oberfläche. Release-Dateien pro Umgebung liefern unterschiedliche Werte für denselben Parameterschlüssel, ohne das Aggregate zu ändern. |
| 4 | valuesMapping:-Template des Recipe | Konsumieren Sie den aufgelösten Wert über {{ .values.<key> }} — das Recipe ist eine Wert-Template-Oberfläche; sein Template-Kontext trägt .parameters nicht direkt. Umgebungsspezifische Variation erreicht das Recipe über das values:-Wörterbuch nach der Interpolation, das die oben beschriebene Interpolationsphase schreibt. (Pfad-Templates auf Release-Boundaries sind die Ausnahme: Sie lesen .parameters.<slot> während des Renderings direkt, gemäß der asymmetrischen Freigabe.) |
Die vier Berührungspunkte sind sequenziell und tragend: Wird die Deklaration im Aggregate übersprungen, hat das Release keinen Slot zu erfüllen; wird der Verweis in den values übersprungen, hat das Recipe keinen Wert zu konsumieren; wird die Erfüllung im Release übersprungen, bleibt der Parameter leer. Der Compiler validiert die Kette während der Auflösung (Validierung des Parametervertrags gegen die typisierte parameters:-Deklaration, dann Interpolation in die umgebenden values:-Zeichenketten, dann JSON-Schema-Validierung des resultierenden values:-Wörterbuchs gegen das schema: der Component oder des Feature); Abweichungen zeigen sich entweder als Verletzung des Parametervertrags (gegen die typisierte parameters:-Deklaration erkannt), als Fehler wegen eines nicht befüllten Templates (bei der Interpolation erkannt) oder als Verletzung einer JSON-Schema-Einschränkung gegen das values:-Schema (bei der Schemavalidierung erkannt).
Das Muster ist der kanonische Mechanismus für die GitOps-Promotion: Ein einziges unveränderliches Aggregate durchläuft die Umgebungen, wobei das Release jeder Umgebung seine eigenen Parameterwerte liefert. Jeder umgebungsspezifische Wert, den ein Autor variieren möchte, gehört in die Parameterkette, statt direkt im Aggregate eingebettet zu sein.
Merge-Semantik von extends: pro Säule
Wenn eine Katalogentität extends: deklariert und der Compiler die Vererbungskette durchläuft, wird der Inhalt jeder Säule nach säulenspezifischen Regeln zusammengeführt. Die Semantik unterscheidet sich zwischen den Säulen; die folgende Tabelle ist die kanonische Referenz pro Säule.
| Säule | Merge-Verhalten in der extends:-Kette |
|---|---|
values (JSON Schema 2020-12) | In einer Feature-Kette werden Schemas über die Komposition von JSON Schema 2020-12 zusammengesetzt. Eine erweiternde Component verfasst keinen Säuleninhalt und erhält den Block ihrer Basis genau so, wie die Basis ihn verfasst hat, in jeder Tiefe einer Kette. |
infra (JSON-Schema-2020-12-Fragment) | Wie values — in einer Feature-Kette zusammengesetzt, von einer erweiternden Component als Ganzes geerbt. |
provides (Template-Map des Recipe) | Flache Ersetzung auf oberster Ebene: Ein Schlüssel des Kindes ersetzt den gleichnamigen Schlüssel des Elternteils vollständig; Geschwisterschlüssel bleiben vom Elternteil erhalten. Templates werden nicht zusammengesetzt; das Template des Kindes besitzt seinen Slot vollständig. |
uses (usesSchema) | Überlagerung ganzer Einträge pro Socket nach Socket-Name. Ein Kind fügt Sockets hinzu, die seine Basis nicht deklariert, und ein Socket, den es unter einem bestehenden Namen neu deklariert, ersetzt diesen Eintrag vollständig — seine Werte- und Infra-Schemas und seinen selector zusammen. Socket-Einträge werden nicht zusammengesetzt, und nichts vergleicht einen neu deklarierten selector mit dem der Basis. |
features (Schema pro Slot in featuresSchema) | Überlagerung ganzer Einträge pro Slot nach Slot-Name, zu denselben Bedingungen wie usesSchema. Ein Kind fügt Slots frei hinzu; ein Slot, den es neu deklariert, ersetzt den Eintrag der Basis vollständig, statt sich mit ihm zusammenzusetzen. |
locals (Template-Map des Recipe) | Flache Ersetzung auf oberster Ebene — wie provides. |
parameters (Wurzel-Map des Aggregate) | Ein Aggregate hat kein extends:-Feld, daher führt keine Aggregate-Kette Parameter zusammen. In einer extends:-Kette eines Release wird ein Parameter mit Map-Wert tief zusammengeführt, wobei der Schlüssel des Kindes gewinnt, ein Parameter mit Skalarwert wird vom Kind ersetzt, und ein Schlüssel, den das Kind als null schreibt, wird entfernt. |
Das allgemeine Muster hängt von der Art und von der Oberfläche ab. Die schemavalidierten Säulen eines Feature setzen sich zusammen gemäß JSON Schema 2020-12. Die Säulen einer erweiternden Component werden als Ganzes geerbt — sie verfasst keine, daher ist ihr Vertrag genau der ihrer Basis, und eine Einschränkung der Basis kann deshalb konstruktionsbedingt nicht gelockert werden. Die Oberflächen mit fester Form — usesSchema und featuresSchema — überlagern nach Name bei beiden Arten: Ein Kind fügt Einträge hinzu, und ein Eintrag, den es neu deklariert, ersetzt den der Basis vollständig. Template-verfasste Säulen verwenden flache Ersetzung pro Schlüssel, was dem Kind die volle Eigentümerschaft an jedem Template-Slot gibt, den es deklariert.
Eine erweiternde Component verschärft eine Einschränkung über assertions: statt über eine Säule — ein Prädikat, das sie hinzufügt und das neben den geerbten ausgewertet wird. Siehe inheritance-and-interface.md für diesen Mechanismus.
Zum Vererbungsmechanismus selbst siehe inheritance-and-interface.md „Inheritance via extends (Vererbung über extends)“, das die Katalogarten abdeckt. Ein Release ist keine Katalogentität und wird nach seiner eigenen Regel gefaltet; diese Regel steht in entities/release.md „Composite Release and extends: inheritance (Zusammengesetztes Release und Vererbung über extends:)“.
Säulenübergreifende Mechanik
Die Auffassung als Wegweiser erlaubt säulenübergreifende Lesezugriffe überall außer an den dokumentierten Self-Containment-Oberflächen. Die folgenden Muster formalisieren gängige säulenübergreifende Mechanik; ein Symptom problematischen Authorings ist dokumentiert, damit Autoren den Zielkonflikt erkennen.
Säulenübergreifende Weiterleitung über eine Schema-Brücke — ausgeschildert, nicht ummauert
Die Säulengrenzen sind Authoring-Disziplin: Die Architektur schildert aus, was wohin gehört (values: für die kognitive Absicht des Entwicklers, infra: für die physische Dimensionierung durch Ops, provides: für vom Recipe ausgegebene Zeichenketten usw.), und der Katalog-Reviewer setzt die Konvention durch. Die Template-Engine selbst erlaubt säulenübergreifende Lesezugriffe, sofern die dokumentierten Self-Containment-Regeln sie nicht verbieten (provides: eines Recipe sieht .context.inject nicht; provides: eines FeatureRecipe mit Boundary-Geltungsbereich sieht keine Felder pro Konsument). Die Säulenmauern sind Wegweiser, keine Durchsetzung.
Eine kanonische ausgeschilderte Ausnahme: Das schema: einer Component kann einen entwicklerseitigen values:-Regler deklarieren, den das valuesMapping:-Template des Recipe in die gerenderte Ausgabe in infra:-Form leitet. Der Entwickler gibt die Absicht über ein typisiertes values:-Feld vor; das Template des Recipe leitet den resultierenden Wert in die Provider-Infrastrukturschicht, ohne dass der Entwickler Infrastrukturcode verfasst. Ein ausgearbeitetes Beispiel:
# Component schema declares a developer-facing dial in valuesspec: schema: values: required_iops: { type: integer, min: 100 }# Recipe valuesMapping pipes the developer's intent into the provider's infra-side knobvaluesMapping: iops_limit: "{{ .values.required_iops }}"Die Brücke ist unter inheritance-and-interface.md mit ausgearbeiteten Beispielen dokumentiert. Die architektonische Absicht (ein deklarierter säulenübergreifender Regler, den das Recipe durchleitet) hat eine einzige Richtung — entwicklerseitige values:, die in die Ops-seitige gerenderte Ausgabe fließen — und landet in den Mapping-Templates des Recipe, nicht im Component-Schema selbst. Die Säulengrenze bleibt ausgeschildert: Der Entwickler sieht values:, das Recipe sieht sowohl values: als auch infra:, die gerenderte Ausgabe kombiniert sie.
Säulenübergreifender inject-Akkumulator
Die .context.inject-Pipe ist der Zusammenführungspunkt von drei säulenübergreifenden Quellen:
- Self-Inject auf Component-Ebene (
component.inject) — bezieht Zeichenketten aus den eigenenvaluesund den eigenenprovidesder Komponente. - Uses-Inject (
uses[].inject) — bezieht Zeichenketten aus denprovidesdes Ziels. injectMapping:-Abfangungen eines FeatureRecipe — beziehen Zeichenketten aus einer der obigen Quellen sowie aus dem eigeneninfra:-Payload des FeatureRecipe.
Wenn das Basis-Rendering läuft, hat .context.inject.<mechanism>.<key> Einträge aus allen drei Quellen angesammelt. Der Akkumulator ist konstruktionsbedingt säulenübergreifend — Einträge, die aus values, provides und infra stammen, fließen alle in dieselbe .context.inject-Map. Recipes, die .context.inject konsumieren, sehen den Zustand nach dem Merge, ohne wissen zu müssen, welche Säule welchen Eintrag beigetragen hat.
Zur Inject-Grammatik und zu den Kollisionsregeln siehe topology-triad.md.
Säulenübergreifende Duplizierung von Einschränkungen
Ein Feld, das in zwei Säulen mit unterschiedlichen Validierungsebenen lebt, kann doppelte Einschränkungen tragen. Das kanonische Beispiel: eine Portnummer, die im usesSchema einer Component deklariert ist (per JSON Schema validiert, Bereich min: 1, max: 65535), und dieselbe Portnummer, die im Feld services.<name>.ports.<port> einer Workload konsumiert wird, für welches das Provider-Rendering-Plugin in seinem spec.provider.workloadSchema eine min: 1024-Regel für nicht privilegierte Ports hinzufügen kann. Bei einem Plugin, das für den Provider rendert, dokumentiert das spec.provider.workloadSchema, wie der Provider eine Workload übersetzt, und kennzeichnet den Provider als fähig, eine zu synthetisieren; es validiert nichts. Jeder Workload-Rumpf wird unabhängig vom Provider gegen das Workload-Schema der Plattform validiert, daher wird eine Einschränkung, die nur in einem workloadSchema steht — etwa eine min: 1024-Portregel —, nicht durchgesetzt; um einen solchen Wert abzulehnen, schreiben Sie die Einschränkung in das Schema der Component oder in eine Assertion.
Feature-Anbindung / Säulenisolation der Component
Eine Feature-Anbindung schreibt nicht in die Säulen der übergeordneten Component. Jedes angebundene Feature trägt seinen eigenen Säulen-Payload (seinen eigenen values:-Block und seinen eigenen infra:-Block). Das FeatureRecipe, das die Ressourcen des Feature synthetisiert, liest seinen eigenen Säulen-Payload unabhängig von dem der Component. Die Isolation betrifft die Eingaben: Was eine Anbindung liest, gehört ihr, unabhängig davon, was aus dem wird, was sie schreibt. Wo der Provider des Ziels separate Dokumente schreibt, liegt die gerenderte Ausgabe der Anbindung neben der der Component in einem eigenen Verzeichnis; wo der Provider die Beitragenden einer Boundary in ein einziges Dokument zusammenführt, trägt die Anbindung zu diesem Dokument bei wie die Component, und jede Ressource trägt weiterhin die eigene Identität der Anbindung, sodass lesbar bleibt, was woher stammt.
Zwei Konsequenzen für Autoren:
- Eine
values:-Einstellung an einer Feature-Anbindung erscheint nicht in.valuesdesvaluesMapping:-Templates der Component. Die Component sieht nur ihre eigenen Werte. - Der
infra:-Payload eines Feature fließt nicht in dasinfra:der Component. Jedes angebundene Feature hat seine eigene physische Dimensionierung, beschränkt auf die Ressourcen des Feature.
Die Isolation ist gemäß der Trennung der Zuständigkeiten in der Architektur explizit: Features sind unabhängige Beitragende, die über das 5-stufige Zwiebelmodell auf Components geschichtet werden. Zu den Anbindungsoberflächen und ihrer Reihenfolge siehe labels-and-annotations.md „Feature attachment — five surfaces (Feature-Anbindung — fünf Oberflächen)“.
Derselbe Eigenschaftsname in beiden Säulen
Eine Component oder ein Feature, deren spec.schema.values: und spec.schema.infra: denselben Eigenschaftsnamen deklarieren — an der Wurzel, in beliebiger Verschachtelungstiefe oder beides —, ist ein häufiges Symptom problematischen Authorings. Die beiden Säulen sind absichtlich getrennte Namensräume (der Compiler akzeptiert die Überschneidung), daher wird das Schema validiert und die gerenderte Ausgabe ist wohlgeformt. Das Symptom ist kognitiv: Leser und Template-Autoren stoßen jedes Mal auf die Reibung „Welche Säule enthält das foo, das ich gerade lese?“, wenn sie das Schema überfliegen oder ein Template dagegen schreiben.
# Smell — both pillars declare `mode`. A reader of the schema or a# template against the Feature has to disambiguate every reference.spec: schema: values: mode: { type: string } infra: mode: { type: string }Autoren mit absichtlicher Überschneidung haben einen echten Grund, beide beizubehalten — z. B. ein mode, das unter values „Betriebsmodus der Anwendung“ bedeutet ("debug" / "production") und unter infra „Topologiemodus der Bereitstellung“ ("standalone" / "clustered"): Beide tragen unterschiedliche Semantik, und die Namen fallen zufällig zusammen. Autoren mit versehentlicher Überschneidung (der häufigere Fall) benennen einen Eintrag um.
Eine zweite absichtliche Form ist ein einzelnes Datum, das jeder der beiden Autoren liefern kann. Die Credential-Features der Standardbibliothek, die den Locator eines Aufrufers tragen — core/referenced-secret, core/referenced-secret-set, core/secret-value und core/secret-provided —, deklarieren es in beiden Säulen unter einem Namen und in einer Form, sodass der Entwickler es in values oder der Operator in infra schreibt, und die eigene Assertion jedes Feature lehnt eine Anbindung ab, die es in beide oder in keine schreibt. Die unten beschriebene Meldung nennt diese vier bei jedem Laden, das sie erreicht; für sie meldet sie den Vertrag, keinen Fehlgriff.
Das Laden des Katalogs gibt für jede gleichnamige Eigenschaft, deren Überschneidung auf mindestens einer Seite zu einem terminalen Blatt aufgelöst wird, eine Meldung notice: LINT: <kind> "<name>" at <path> declares property "<property>" in both values: and infra: pillars (path: <dotted-path>) aus. Gleichnamige Eigenschaften, die als gemeinsame organisatorische Namensräume existieren (beide Säulen tragen ein Objekt namens ingress mit disjunkten Untereigenschaften), lösen keine Warnung aus; gemeldet wird nur die Blattüberschneidung. Die Warnung ist eine Meldung — der Build läuft weiter.
Validierungsstufen der Säulen
Die Säulen tragen Validierung über drei Stufen. Jede Stufe deckt ein anderes Anliegen ab; dasselbe Feld kann von mehr als einer Stufe validiert werden (siehe „Cross-pillar constraint duplication (Säulenübergreifende Duplizierung von Einschränkungen)“ oben).
| Stufe | Was sie validiert | Wo es läuft |
|---|---|---|
| 1 — JSON-Schema-Hülle | Strukturelle Form (welche Schlüssel vorhanden sind, ob die Typen den Felddeklarationen entsprechen) | Auflösung, pro Laden einer Datei |
2 — Schema pro Säule (schema / featuresSchema / usesSchema) | Typisierter Inhalt pro Säule, validiert als JSON Schema 2020-12 | Auflösung, nachdem die Hülle bestanden ist |
| 3 — Prüfung der Provider-Fähigkeiten | Workload-Inhalt, freigegeben durch die Fähigkeit zum synthetisierten Modus, die der gebundene Provider hat, dokumentiert im spec.provider.workloadSchema des Provider-Rendering-Plugins | Basis-Rendering, nachdem valuesMapping aufgelöst ist |
Zur Tabelle der Fehlerformen auf vier Ebenen und zu den Fehlerpräfixen pro Ebene siehe validation-surface.md.
Mechanismen für Standardwerte
Standardwerte treten im Korpus über mehrere unterschiedliche Mechanismen auf. Autoren begegnen dem Wort „default“ in mehr als fünf Kontexten; die folgende Tabelle ist die kanonische Referenz dafür, welcher Mechanismus einen Wert erzeugt, wenn der Autor ein Feld leer lässt.
| # | Mechanismus | Wo verfasst | Auslöser |
|---|---|---|---|
| 1 | JSON Schema default: (Kompaktform { default: <value> }) | schema: von Component / Feature, parameters: des Aggregate | Das Feld wird mit dem Standardwert validiert, wenn der Entwickler den Schlüssel weglässt. Bei Aggregate-Parametern füllt der Parameter-Merge den deklarierten Standardwert ein, bevor die Vertragsvalidierung läuft (siehe templates/parameters-context.md). |
| 2 | Go-Template optional .X `Y` <fallback> | valuesMapping: des Recipe, Workload-Rumpf, FeatureRecipe-Templates, der Assertion-Evaluator | Fallback, der das Vorhandensein berücksichtigt — gibt <fallback> nur zurück, wenn der Schlüssel in der Map fehlt; eine verfasste Null / ein leerer Wert / false am Schlüssel gibt diesen verfassten Wert zurück. Die kanonische Aggrega-seitige Form des Fallbacks für fehlende Felder. Siehe templates/sprig-functions.md. |
| 3 | Go-Template | default <expr> | valuesMapping: des Recipe, Workload-Rumpf, FeatureRecipe-Templates | Inline-Pipeline, die bei „leer“ greift (Sprigs Leerheitsprüfung — Null, leere Zeichenkette, false, nil). Vermengt das Fehlen in der Map mit vorhanden-aber-null/leer/false. Geeignet für Override-Semantik pro Aufrufstelle (der Fallback des Bindings weicht vom Standardwert des Felds auf Schemaebene ab), wo die Vermengung akzeptabel ist. Nicht geeignet als Fallback für fehlende Felder, wenn eine verfasste Null / ein leerer Wert / false eine legitime Absicht ist — verwenden Sie für diesen Fall optional (Mechanismus 2). |
| 4 | Sprig-Funktion default ({{ default <expr> .field }}) | Wie 3 | Funktionsform von Mechanismus 3 mit derselben Vermengung bei Leerheit. |
| 5 | locals:-Fallback des Recipe | locals:-Template des Recipe | Ein locals-Eintrag berechnet eine Zeichenkette mit Standardwert, die der Rest des Recipe konsumiert |
Empfohlene Platzierung. Wenn ein Standardwert tatsächlich Teil des Typvertrags ist (z. B. „dieser Port ist standardmäßig 5432, sofern der Entwickler ihn nicht überschreibt“), ist das JSON Schema default: (Mechanismus 1) kanonisch — die IDE-Autovervollständigung zeigt den Standardwert an; Validierungswerkzeuge berücksichtigen ihn; der Vertrag reist mit der Katalogentität Component / Feature ODER mit der Parameterdeklaration des Aggregate. Wenn ein Recipe-Template einen Fallback für einen optionalen Map-Schlüssel braucht, ist der Helper optional (Mechanismus 2) die kanonische Form des Fallbacks für fehlende Felder — er unterscheidet eine verfasste Null / einen leeren Wert / false vom Fehlen. Das | default des Go-Templates (Mechanismus 3) ist dem Override-Fall pro Aufrufstelle vorbehalten, in dem die Vermengung von fehlenden und falsy Werten akzeptabel ist; greifen Sie nur dann darauf zurück, wenn die Override-Semantik die ausdrückliche Absicht ist.
Querverweise
inheritance-and-interface.md—extends:-Mechanismus,implements:-Schnittstellenbindung, säulenübergreifende Weiterleitung über eine Schema-Brücke.topology-triad.md— topologische Mechanik vonprovides,inject,uses.labels-and-annotations.md— inhaltsseitiges Metadatenvokabular, getrennt von den Datensäulen (die kanonische Säulenliste oben enthält keine Labels / Annotationen / Veröffentlichungsfelder — diese sind Metadatenvokabular).publishing-surface.md— veröffentlichungsseitiges Metadatenvokabular, getrennt von den Datensäulen.validation-surface.md— vier Ebenen der Schemavalidierung, einschließlich der drei Validierungsstufen der Säulen oben.templates/expansion-matrix.md— Verfügbarkeit säulenübergreifender Lesezugriffe pro Template-Stelle + Self-Containment-Regeln beiprovides:undsource:des Recipe.examples/04-secrets.md— die Checkliste zur Secret-Zustellung mit sechs Berührungspunkten.architecture/06-data-taxonomy-and-composition.md— kanonische konzeptionelle Einordnung der fünf strukturellen DSL-Schlüsselwörter.