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

extends und implements

Vererbung über extends

Katalogentitäten (Component, Feature) unterstützen Einfachvererbung über das Schlüsselwort extends, mit dem Plattformarchitekten spezialisierte Entitäten auf einer gemeinsamen Basis aufbauen können. Der Deep-Merge der YAML-Hülle ist beiden Arten gemeinsam: Metadaten, Labels und die deklarativen Strukturtabellen der erweiternden Entität überschreiben passende Schlüssel in der Basis, und verschachtelte Maps werden rekursiv zusammengeführt. Bei den Datensäulen gehen die beiden Arten getrennte Wege.

Diese Seite behandelt die Katalogarten, und sie sind nicht die einzigen Arten, die extends deklarieren. Ein Release und ein Manifest deklarieren es ebenfalls, und beide sind bereitstellungsseitige Dokumente, die nebeneinander verfasst werden, statt katalogindizierte Entitäten zu sein — daher nennen ihre Referenzen Dateien, keine Katalogentitäten, und was gefaltet wird, ist eine Authoring-Oberfläche statt eines Schemas. Für diese siehe entities/release.md und entities/manifest.md.

Das extends einer Component setzt die Struktur zusammen und erbt die Säulen als Ganzes

Bei einer Component setzt extends metadata.labels, metadata.annotations, spec.featuresSchema (Anbindungs-Slots), spec.usesSchema (Topologie-Sockets) und spec.inject (die Self-Inject-Allowlist, deren Einträge mit der Basis zuerst und ohne Duplikate verkettet werden) zusammen. Die drei Datensäulen — values, infra, provides — werden nicht zusammengesetzt. Eine erweiternde Component verfasst keinen Säuleninhalt: Sie schreibt die wörtliche Markierung schema: inherited und erhält den schema:-Block der Basis genau so, wie die Basis ihn verfasst hat, in jeder Tiefe einer Kette.

Das veröffentlichte Component-Schema macht diese Markierung sowohl verpflichtend als auch exklusiv und lehnt jede Abweichung davon beim Laden des Dokuments ab, mit einer eigenen Diagnose für jede: unter schema: verfasster Säuleninhalt bei einer Component, die extends: deklariert; schema:, das dort ganz fehlt; und schema: inherited bei einer Component, die kein extends: deklariert.

Daraus folgen zwei Konsequenzen, und sie ziehen in entgegengesetzte Richtungen:

  • Die Basis legt die Schlüsselmenge fest. Eine erweiternde Component deklariert keine Säulenschlüssel, daher kann sie keinen von der Basis deklarierten verbergen, entfernen oder umtypisieren, und sie fügt keine eigenen hinzu. Eine Instanz der Basis und eine Instanz von allem, was sie erweitert, werden gegen denselben Säulenvertrag validiert.
  • Verschärfung wandert zu assertions:. Eine Spezialisierung, die weniger zulassen muss als die geerbten Säulen, drückt das als Prädikat über sich selbst aus, nicht als eingeengtes Schema-Blatt. Wenn eine Basis core/base-server tls_enabled: { type: boolean, default: true } deklariert, schreibt eine Spezialisierung, die TLS bedingungslos verlangt:
apiVersion: aggrega.ai/v1beta1
kind: Component
metadata:
name: core/tls-only-server
version: 1.0.0
labels:
component.aggrega.ai/type: "server"
spec:
extends: core/base-server
schema: inherited # values, infra and provides are the base's, verbatim
assertions:
tls-is-mandatory: |
{{- if not .values.tls_enabled -}}
{{- fail "this component requires tls_enabled: true" -}}
{{- end -}}

Die Regel lehnt einen Wert ab, den der geerbte Säulenblock akzeptiert — genau das bedeutet Verschärfung hier. Die umgekehrte Richtung ist überhaupt nicht ausdrückbar: Eine Spezialisierung kann eine geerbte Einschränkung nicht lockern, weil sie das Blatt, das sie trägt, nicht neu formulieren kann. Siehe entities/component.md „Catalog Authoring: Extending Base Components (Katalog-Authoring: Erweitern von Basis-Components)“ für die vollständige Kompositionstabelle und das ausgearbeitete Paar aus Basis und Erweiterung.

Das extends eines Feature setzt seine Säulen zusammen

Bei einem Feature setzt sich das schema: des Kindes nach der Kompositionssemantik von JSON Schema 2020-12 mit dem der Basis zusammen und ergibt ein einziges zusammengeführtes Schema, gegen das eine verfasste Instanz validiert wird. Credential-Features — die mit dem Label feature.aggrega.ai/kind: secret — nutzen dies, um auf einer gemeinsamen Basis aufzubauen: Ein Credential-Feature als Kind erweitert einen Elternteil, um dessen Vault-Abfrageschema zu erben und dabei Einschränkungen zu verengen.

Der Compiler bezieht keine Position zur Richtung dieser Änderung. Komposition ist strukturell, daher wird eine Einschränkung des Kindes, die die der Basis ausweitet, zusammengesetzt, ohne den Build anzuhalten, und erscheint als Meldung. Nichts lehnt sie ab: Die Einschränkung einer Feature-Basis ist eine gemeinsame Erwartung, die die Autoren des Katalogs durch Review aufrechterhalten, kein Vertrag, den die Plattform durchsetzt.

Schnittstellenbindung über implements

Recipes und FeatureRecipes binden sich über das Schlüsselwort implements: am Anfang ihres spec an eine Component- oder Feature-Schnittstelle. Die Bindung deklariert, von welcher Katalogschnittstelle dieses Recipe / FeatureRecipe die konkrete Implementierung ist, und unterstützt drei Formen des Versionsabgleichs:

  • Exakt — implements: core/api-server:1.0.0 — passt auf genau eine bestimmte Version des Component-Typs.
  • Major-kompatibler Bereich — implements: core/api-server:^1.0.0 — passt auf jede Version, die >=1.0.0, <2.0.0 erfüllt (SemVer-major-kompatibel). Wird verwendet, wenn ein Recipe einen kompatiblen Bereich statt einer einzelnen festgelegten Version unterstützt.
  • Unversioniert — implements: core/api-server — passt auf jede Version des Component-Typs. Wird verwendet, wenn ein Recipe jede Version des Typs bedient.

implements: wählt nie ein Recipe aus: Das tut das Mapping des Manifest. Was die Deklaration steuert, ist die Konsistenzprüfung für jeden Mapping-Eintrag — die Version des gemappten Typs muss das implements: des gemappten Recipe in einer der drei Formen erfüllen, oder das Recipe muss eine Basis implementieren, die dieser Typ erweitert — sowie die Kandidatenliste, die die Diagnose bei fehlendem Mapping und die Editor-Vervollständigung anbieten. Ein Mapping-Eintrag, dessen Recipe ein implements: hat, das weder zum gemappten Typ noch zu einer seiner Basen passt, bricht den Build ab und nennt das Mapping, das Recipe und dessen implements:-Wert. Wo ein components.type-Schlüssel eine Komponenteninstanz in einer Version erreicht, die der Schlüssel nicht nennt — jede Instanz, bei einem ohne Version geschriebenen Schlüssel —, wird die Prüfung erneut mit dem eigenen Typ dieser Instanz gestellt, in der Version, als die der Build sie kompiliert, und ein Recipe, das sie nicht erfüllt, bricht den Build auf dieselbe Weise ab und nennt die Instanz.

Die implements:-Bindung ist der Mechanismus, der „derselbe Component-Typ, verschiedene Recipes für verschiedene Provider“ möglich macht: Eine core/postgres-Component kann ein Recipe haben, das sie für den helm-Provider implementiert, und ein anderes Recipe, das sie für den compose-Provider implementiert. Jedes Recipe deklariert denselben implements:-Wert, und das Manifest, mit dem ein Release baut, mappt den Typ auf dasjenige, das es möchte.

Ein gegen eine Basis geschriebenes Recipe bedient alles, was sie erweitert

implements: nennt eine Basis, und ein Recipe, das eine nennt, ist die konkrete Implementierung für jede Component, die diese Basis erweitert, in jeder Tiefe der Kette. Eine mit extends gebaute Spezialisierung braucht daher kein eigenes Recipe — und genau das macht einen veröffentlichten Wrapper günstig zu konsumieren: Das Team, das ihn veröffentlicht, verfasst eine Component, und die Teams, die ihn bereitstellen, verwenden die Recipes der Basis auf jedem Ziel wieder.

Hier gelten zwei Tatsachen zugleich, und sie sind voneinander getrennt. Ein Leser, der sie zu „die Spezialisierung braucht nichts“ zusammenfasst, schreibt ein Manifest, das fehlschlägt, aus einem Grund, den er in der falschen Datei suchen wird:

  • Das Recipe passt. Die Konsistenzprüfung zwischen dem Typschlüssel eines Manifest-Mappings und dem implements: des gemappten Recipe akzeptiert das Mapping, wenn das Recipe den gemappten Typ selbst oder eine beliebige Basis implementiert, die dieser Typ erweitert. Die drei obigen Versionsformen gelten für eine Basis genauso wie für den Typ selbst: Ein Recipe, das implements: core/base-server:^1.0.0 deklariert, erfüllt eine Spezialisierung, deren Basis die Version 1.4.0 hat, und erfüllt keine, deren Basis 2.0.0 ist.
  • Das Manifest mappt trotzdem den eigenen Typ der Spezialisierung. Die Recipe-Auswahl erfolgt über den exakten Mapping-Schlüssel. Eine Instanz von enterprise/labelled-server braucht einen eigenen mappings.components.type-Eintrag; sie erbt nicht den Eintrag, der für core/base-server geschrieben wurde. Eine Spezialisierung ohne eigenen Eintrag bricht mit der Diagnose für nicht gemappte Instanzen ab, auch wenn ihre Basis gemappt ist.

Die Authoring-Kosten einer Spezialisierung sind daher eine Manifest-Zeile und kein neues Recipe:

# The wrapper extends core/base-server and authors no pillars.
# core/helm/base-server declares: implements: core/base-server
spec:
mappings:
components:
type:
enterprise/labelled-server:1.0.0: core/helm/base-server:1.0.0

Wenn die extends-Kette des gemappten Typs nicht durchlaufen werden kann — sie bildet eine Schleife, oder eine Basis, die sie nennt, fehlt im Katalog —, bricht der Build bei diesem Kettenfehler ab statt beim Mapping, weil ein Mapping nicht beurteilt werden kann, bevor die Kette, von der es abhängt, aufgelöst ist. Die Prüfung durchläuft die Kette nur über die Components, die bereits auf diesem Rechner liegen — die in einem Katalogverzeichnis und die, die der lokale Artefakt-Cache unter einem Lockfile-Pin hält —, und fragt nie eine Registry ab, daher gilt eine Basis, die nur eine Registry hält, hier als fehlend. Sie abzurufen ist die Aufgabe von aggrega pull: Eine Basis ist eine Abhängigkeit von allem, was sie erweitert, daher folgt ein Pull jeder extends:-Kette, die das Release erreicht, ruft jede Basis ab, die kein Katalogverzeichnis hält, und pinnt sie im Lockfile, wo der nachfolgende Build sie findet. Das Manifest benötigt keine Zeile für die Basis selbst, es sei denn, ein Aggregate deklariert auch eine Instanz der Basis.

Recipe-Vorschläge bleiben enger als diese Abgleichsregel. Die Kandidatenliste, die eine Diagnose bei fehlendem Mapping ausgibt, und die Reihenfolge, die die Editor-Vervollständigung auf einen Mapping-Wert anwendet, nennen die Rezepte, die den angefragten Typ selbst implementieren; sie erweitern sich nicht auf Rezepte, die eine seiner Basen implementieren.

Für eine ausführbare End-to-End-Anleitung — ein veröffentlichter Wrapper im Katalog, die eine Manifest-Zeile, die ihn konsumiert, das Recipe der Basis, das seine gerenderte Ausgabe formt, und der Abbruch, den eine Wrapper-Instanz ohne eigenes Mapping erzeugt — siehe das ausgearbeitete Beispiel examples/extends-wrapper/.

Entitätsübergreifende Nutzung von Versionen

Jede Aggrega-Entitätsart — Component, Feature, Aggregate, Recipe, FeatureRecipe, Manifest, Release, Plugin, SchemaLibrary, MappingLibrary, WorkloadLibrary, ArtifactLibrary — trägt ein verpflichtendes Feld metadata.version, das gegen denselben SemVer-Regex validiert wird (MAJOR.MINOR.PATCH gemäß architecture/02-ecosystem-philosophy.md). Versionen sind in ihrer Form einheitlich; die Nutzung von Versionen variiert je nach Entitätsart. Manche Versionen nehmen aktiv an der Auflösung teil; andere sind beschreibende Provenienz, gegen die der Compiler nicht abgleicht. Die folgende Tabelle deckt die Arten ab, die keine Bibliotheken sind, nennt, was der Compiler mit dem Versionsfeld jeder Entität tut, und verwendet die Status-Taxonomie mit vier Labels aus 10-status.md, um jedes Nutzungsregime einzuordnen. Die vier Bibliotheksarten liegen außerhalb der Tabelle, weil ihr Regime einheitlich und anders ist: Ein Konsument referenziert eine Bibliothek über den bloßen Namen, kann eine optionale Mindestversion :<version> angeben, und die Lockfile pro Release besitzt die aufgelöste Version und ihren Inhalts-Digest.

EntitätNutzungsregimeStatus
ComponentAuflösung von Typreferenzen; implements:-Abgleich des Recipeavailable — exakte, Caret-Bereichs- (^MAJOR.MINOR.PATCH) und unversionierte Formen in beiden (siehe Versionsauflösung und Status der Sprache → Versionsabgleich)
FeatureAuflösung von Anbindungsreferenzen; implements:-Abgleich des FeatureRecipeWie bei Component
RecipeAuflösung der Mapping-Stufen des Manifestavailable — exakte, Caret-Bereichs- und unversionierte Formen in einem Mapping-Wert, die jeweils die höchste passende Version auswählen
FeatureRecipeAuflösung der Mapping-Stufen des ManifestWie bei Recipe
AggregateAuflösung der übergeordneten aggregates[].type-Referenzavailable — exakte, Caret-Bereichs- und unversionierte Formen, die jeweils die höchste passende Version auswählen (siehe Versionsauflösung)
PluginProvider-Dispatch über recipe.spec.capability → spec.provider.capabilitiesavailable — die bloße Fähigkeit wählt den Provider aus, und ein Pin darauf (helm:<version>, helm:^<version>) wählt aus, welche Version dieses Plugins rendert; die Identität des Plugins ist die digestfreie oci://<repository>-Referenz plus metadata.version, und der Inhalts-Digest wird in der Lockfile festgehalten, gegen die der Build die abgerufenen Bytes prüft
ManifestProvenienz des IR-Graphen (manifest_version)available (nur für die Provenienz gelesen; keine Rolle beim Auflösungs-Dispatch)
ReleaseProvenienz des IR-Graphen (release_version) + Template-Metadaten (.metadata.release_version)Wie bei Manifest

Katalog-Auflösungsregime (Component, Feature, Aggregate, Plugin). Eine Referenz auf eine dieser Arten — der type einer Komponente, der type einer Funktionsanbindung, der aggregates[].type eines Sub-Aggregat-Imports, das plugin eines Pipeline-Schritts — wird nach der Regel aufgelöst, die Versionsauflösung lehrt: Eine exakte, Caret-Bereichs- oder unversionierte Referenz wählt die höchste passende Version unter denen aus, die der Katalog hält, und der Pull, der Build, eine Validierung, der Editor und die an den Assistenten gerichteten Werkzeuge wenden diese eine Regel gleichermaßen an. Bei einer Component oder einem Feature liest der implements:-Abgleich dieselben drei Formen aus der anderen Richtung — eine konkrete Typversion gegen die Form, die ein Recipe oder FeatureRecipe deklariert — als die unten beschriebene Konsistenzprüfung, nicht als Auswahl. Der Dispatch an das Provider-Rendering-Plugin verwendet eine einfachere Form: Er sucht die bloße recipe.spec.capability per Namen in den spec.provider.capabilities des Provider-Rendering-Plugins, und ein auf die Fähigkeit geschriebener Versions-Pin wählt aus, welche Version dieses Plugins rendert, und bricht ab, wenn keine Version ihn erfüllt.

Auflösung der Mapping-Stufen des Manifest. Der flache Auflösungsmechanismus mappings.{components,features} des Manifest (mit den Stufen name und type, Name vor Typ, und versionierter Typ vor unversioniertem Typ) ist unter entities/manifest.md dokumentiert. Der Resolver konsumiert diese Mappings: Die Auswahl von Recipe und FeatureRecipe ist ein direkter Abgleich des Mapping-Werts mit der Lockfile und dem Katalog, und eine Komponente oder Anbindung, deren Typ kein Mapping hat, bricht den Build ab. spec.implements wählt kein Recipe aus — es ist die Konsistenzprüfung beim Laden für ein Mapping, das der Autor bereits geschrieben hat, und die Quelle der Kandidatenliste, die die Diagnose bei fehlendem Mapping und die Editor-Vervollständigung anbieten. Der Fähigkeits-Dispatch geht dann vom Feld spec.capability des aufgelösten Recipe aus, nicht von der strukturellen Form des Manifest.

Regime beschreibender Provenienz (Manifest, Release). metadata.version des Manifest und metadata.version des Release werden gelesen, wenn der Compiler die Provenienz befüllt, und erscheinen im Provenienzblock des IR-Graphen als manifest_version und release_version; kein Label in der gerenderten Ausgabe trägt eine der beiden. Templates sehen außerdem die Release-Version als .metadata.release_version bereitgestellt. Keine der beiden Versionen wird für den Auflösungs-Dispatch mit der Version einer anderen Entität abgeglichen; es handelt sich um reine Provenienz.

Die Tabelle lesen. Die Einordnung mit vier Labels unterscheidet „das Versionsfeld wird vom Schema akzeptiert und existiert auf der Entität“ (immer wahr — einheitlicher SemVer-Regex) von „der Compiler gleicht während der Auflösung gegen diese Version ab“ (variiert je nach Entität).

Säulenübergreifende Weiterleitung über eine Schema-Brücke: Absicht mit Infrastruktur verbinden

Aggrega drückt eine starke Trennung der Zuständigkeiten zwischen Domäne 1 und Domäne 4 aus: Der Entwickler schreibt kognitive Logik in den values-Block, während der Operator die physische Dimensionierung im infra-Block vorgibt. Das Aggregate.yaml-Schema erzwingt eine konkrete Folgerung: Das Schlüsselwort infra fehlt in den Komponenteninstanzen des Aggregate und in ihren features-Anbindungen und wird, kombiniert mit additionalProperties: false, von der Schemavalidierung abgelehnt. Entwickler sollten innerhalb der Entwicklerabsicht keine physische Dimensionierung vorgeben; wenn ein bestimmter Wert zum Fall der Anwendung passt (z. B. ein fest codierter Port oder eine bestimmte CPU-Zahl), kann der Architekt ihn explizit in der schema:-Deklaration der Component offenlegen, und der Wert fließt über values.

Für Fälle, in denen eine bestimmte Infrastruktur-Einschränkung ein intrinsischer Teil des Vertrags einer Komponente ist — eine Handelsdatenbank mit hohem Durchsatz, die 10.000 bereitgestellte IOPS haben muss, eine ML-Arbeitslast, die auf genau 4 GPUs laufen muss —, legen Plattformarchitekten die Einschränkung über eine eigens dafür gebaute Component offen und verwenden dabei das Muster der säulenübergreifenden Weiterleitung über eine Schema-Brücke.

Das Schema-Brücken-Muster für infrastrukturbewusste Komponenten. Die Component legt den spezifischen Infrastruktur-Regler über ihre schema:-Deklaration im values-Block des Entwicklers offen, und das valuesMapping:-Template des gebundenen Recipe leitet den Wert in die gerenderte Ausgabe in infra:-Form. Das Ergebnis ist eine typisierte Brücke zwischen kognitiver Absicht und physischer Dimensionierung: Der Entwickler gibt die Hardware-Einschränkung über ein validiertes Feld vor, und die Einschränkung fließt zu Ops, ohne dass eine der beiden Seiten rohen Infrastrukturcode schreibt. Der Regler ist ein Säulenschlüssel, daher wird er an der Component deklariert, deren Vertrag ihn besitzt — eine Component, die mit extends: eine Basis erweitert, deklariert keine Säulenschlüssel und kann daher keinen einführen.

# Domain 2: The Platform Catalog (the schema-bridge Component)
apiVersion: aggrega.ai/v1beta1
kind: Component
metadata:
name: core/high-perf-postgres
version: 1.0.0
labels:
component.aggrega.ai/type: "stateful-server"
spec:
schema:
values:
# Expose the dial safely to the Developer with a typed contract.
required_iops: { type: integer, min: 1000, max: 100000, required: true }
infra:
# Operator-owned sizing the Recipe below reads alongside the dial.
storage: { size: { type: string, default: 100Gi } }
compute: { instance_class: { type: string, default: db.m5.large } }
# Domain 2: The Platform Catalog (the Recipe pipes the dial into provider infra)
apiVersion: aggrega.ai/v1beta1
kind: Recipe
metadata:
name: aws-rds-high-perf-postgres
version: 1.0.0
spec:
implements: core/high-perf-postgres:^1.0.0
capability: terraform
source: ./modules/rds
valuesMapping: |
# The Recipe pipes the developer's values.required_iops into the provider's infra-side knob.
iops: {{ .values.required_iops }}
allocated_storage: "{{ .infra.storage.size }}"
instance_class: "{{ .infra.compute.instance_class }}"
# Domain 1: The Developer Intent (remains capability-agnostic)
components:
trading-db:
type: core/high-perf-postgres:1.0.0
values:
required_iops: 10000 # Developer dictates the hardware constraint safely

Skalierung über mehrere Umgebungen (die Anforderung des Hochziehens von Parametern). Um diese Hardware-Einschränkung über GitOps-Umgebungen (Dev vs. Prod) zu skalieren, ohne das Aggregate.yaml des Entwicklers zu verändern, zieht der Entwickler den Wert in den typisierten parameters-Vertrag hoch. Ops erfüllt die konkrete IOPS-Anforderung über umgebungsspezifische Release-Dateien. Die Ausführungsreihenfolge des Compilers schützt den Ablauf: Die Validierung des Parametervertrags läuft bei der Auflösung; die Interpolation löst den Parameter in die umgebende values:-Zeichenkette auf; das valuesMapping:-Template des Recipe leitet den aufgelösten Wert in die gerenderte Ausgabe.

1. Die Entwicklerabsicht (den Regler abstrahieren). Der Entwickler weiß, dass er die IOPS steuern muss, abstrahiert die explizite Zahl aber über den typisierten parameters-Vertrag auf die Umgebungsebene.

spec:
parameters:
env_iops:
type: integer
min: 1000
max: 100000
description: Provisioned IOPS for the trading-db instance
components:
trading-db:
type: core/high-perf-postgres:1.0.0
values:
required_iops: {{ .parameters.env_iops }} # Hoisted to the environment

2. Die GitOps-Releases (Erfüllung durch Ops). Ops erfüllt den parameters-Vertrag in umgebungsspezifischen Release-Dateien. Der typisierte Vertrag validiert jeden vom Release gelieferten Wert, bevor die Interpolation läuft.

  • Dev-Umgebung (release-dev.yaml): env_iops: 1000
  • Prod-Umgebung (release-prod.yaml): env_iops: 25000

Die Kompilierungsreihenfolge. Dieser Mechanismus wird durch die strikte Ausführungsreihenfolge des Compilers bei der Auflösung geschützt:

  1. Validierung des Parametervertrags. Jeder vom Release gelieferte Parameterwert wird gegen die typisierte parameters:-Deklaration des Aggregate validiert. Ein Prod-Wert von 25000 ist gültig (innerhalb von min: 1000, max: 100000); ein Wert von 500 würde mit einem klaren Fehler abbrechen.
  2. Interpolation. Der Compiler liest die Parameterwerte des Prod-Release und interpoliert 25000 in die YAML-Zeichenkette des Aggregate bei values.required_iops. Die zusammengeführte Parameter-Map bleibt während des Renderings erhalten, sodass Pfad-Template-Oberflächen .parameters.<slot> direkt lesen können; Wert-Template-Oberflächen konsumieren das Literal nach der Interpolation, das bereits in den values:-Block des Aggregate geschrieben ist. Die Map bleibt lesbar, bis jede Rendering-Phase abgeschlossen ist, und ist nur von der Kompilierung aus erreichbar, für die sie aufgelöst wurde.
  3. Schemavalidierung. Die schema:-Deklaration der Component validiert das resultierende values:-Wörterbuch; values.required_iops: 25000 erfüllt das min: 1000, max: 100000 des Schemas.
  4. Rendering von valuesMapping des Recipe. Das valuesMapping:-Template des gebundenen Recipe leitet values.required_iops in die infra-förmige Ausgabe des Provider (iops: 25000). Das Wasm-Provider-Plugin erzeugt die korrekte physische Datenbankkonfiguration. Der Entwickler erhält seine explizite Hardware-Kontrolle, Ops erhält seine umgebungsspezifische Skalierung, und das Aggregate bleibt agnostisch gegenüber Fähigkeiten.