Die Entitätstaxonomie
Die Architektur von Aggrega ist in vier Domänen gegliedert, die jeweils einer anderen Persona gehören und bestimmte Entitätsarten enthalten, sowie in eine Bibliotheksschicht der Stufe 3 — die dritte Stufe des Entitätsstufenmodells der Sprachreferenz —, die wiederverwendbare Schema-, Mapping-, Workload- und Artefaktinhalte enthält. Die folgende Übersicht zeigt, wie die vier Domänen und die Bibliotheken der Stufe 3 zueinander in Beziehung stehen; jeder folgende Abschnitt beginnt mit einem Diagramm seiner eigenen Entitäten, in dem eine Entität aus einer anderen Domäne mit gestricheltem Umriss gezeichnet ist. Die ausführlichen Autorenoberflächen (Felder, Schemas, Beispiele) jeder Entität befinden sich im Entitätskatalog der Sprachreferenz.
graph TD
Intent["<b>Domain 1: Developer Intent</b><br/><i>Developer</i>"]
Catalog["<b>Domain 2: Platform Catalog</b><br/><i>Platform Architect</i>"]
Routing["<b>Domain 4: Routing & Policy</b><br/><i>Platform Operator / DevOps</i>"]
Infra["<b>Domain 3: Infrastructure Base</b><br/><i>Infrastructure Engineer / Ops</i>"]
Libs["<b>Tier 3: Libraries</b>"]
Intent -->|"requests, attaches"| Catalog
Intent -->|"binds via"| Routing
Routing -->|"attaches"| Catalog
Catalog -->|"resolved to"| Infra
Routing -->|"resolves, renders via"| Infra
Catalog -.->|"$ref"| Libs
Infra -.->|"$import"| Libs
Der Korpus umfasst vier Domänen sowie die Bibliotheksschicht der Stufe 3:
| # | Entität | Domäne | Rolle |
|---|---|---|---|
| 1 | Aggregate | Domäne 1 — Entwicklerabsicht | Bauplan der Anwendungstopologie |
| 2 | Component | Domäne 2 — Platform Catalog | Abstrakte Schnittstelle eines Rechenknotens |
| 3 | Feature | Domäne 2 — Platform Catalog | Operatives Merkmal (einschließlich Credential-Features) |
| 4 | Recipe | Domäne 3 — Infrastrukturbasis | Component-Implementierung, pro Provider |
| 5 | FeatureRecipe | Domäne 3 — Infrastrukturbasis | Feature-Implementierung, pro Provider |
| 6 | Plugin | Domäne 3 — Infrastrukturbasis | Inhaltsadressiertes WebAssembly-Plugin (Provider-Rendering, Pipeline-Schritte, Linting) |
| 7 | Manifest | Domäne 4 — Routing und Policy | Abhängigkeits-Lockfile, das Schnittstellen auf Recipes abbildet |
| 8 | Release | Domäne 4 — Routing und Policy | Deployment-Router, der das Aggregate an das Manifest bindet |
| 9 | SchemaLibrary | Stufe 3 — Bibliotheken | Wiederverwendbare Definitionen in JSON Schema 2020-12 |
| 10 | MappingLibrary | Stufe 3 — Bibliotheken | Wiederverwendbare Go-Template-Fragmente |
| 11 | WorkloadLibrary | Stufe 3 — Bibliotheken | Wiederverwendbare Workload-Template-Fragmente |
| 12 | ArtifactLibrary | Stufe 3 — Bibliotheken | Wiederverwendbare benannte Artefaktbündel |
Diese Tabelle umfasst die gesamte Menge der Entitätsarten für Autoren, also die Arten, die ein Autor in einem kind:-Feld deklariert. Die Art Workload ist plattformeigener Inhalt, der in die synthetisierte Eingabe eines Recipe eingebettet ist, statt eine eigenständige Katalogentität zu sein (siehe Kapitel 16), und fehlt deshalb bewusst in der obigen Tabelle.
Das Plugin ist eine vollwertige Authoring-Entität — mit eigenem Kind, eigenem JSON Schema und eigenem Katalogverzeichnis —, die Platform Ops in Domäne 3 gehört. Ein Plugin ist eine inhaltsadressierte Referenz auf ein WebAssembly-Artefakt und deklariert den einen Socket-Typ, den es implementiert. Die Taxonomie hat sieben Mitglieder: provider (rendert IR-Knoten in providernative Artefakte), linter (meldet Diagnosen zu verfassten Inhalten), pipeline-step (ein Schritt einer feature-recipe-pipeline), governance (erfüllt eine Governance-Rolle — transformiert Labels oder Annotationen oder liefert ein Urteil über Annahme oder Ablehnung zum IR-Graphen oder zu den gerenderten Artefakten), cli (steuert einen aggrega-Unterbefehl bei, den ein Operator auf der Kommandozeile aufruft), parser (wandelt einen fremden Quelltext in einen kanonischen strukturierten Baum um) und importer (wandelt eine fremde Infrastruktur- oder Agentendefinitionsquelle in Entwürfe von Aggrega-Authoring-Dateien um). Ein Plugin für das Provider-Rendering (pluginType: provider) ist die Einheit, die das Provider-Rendering bedient: Es deklariert in spec.provider.capabilities den oder die Provider-Namen, die es rendert, und führt die übrigen Metadaten seines Provider-Sockets im selben spec.provider-Block. Der Compiler pinnt und routet die Referenz; die WebAssembly-Laufzeit führt die Bytes aus; der Compiler interpretiert nicht, was das Plugin tut — das Plugin ist das Transportmittel für die domänenspezifische Intelligenz, die in WebAssembly lebt. Seine Authoring- und Metadatenoberfläche ist unter language-reference/entities/plugin.md dokumentiert.
Domäne 1: Entwicklerabsicht (das „Was“)
graph LR
classDef ext stroke-dasharray:5 4;
A["Aggregate<br/>The 'What'"]
CC["Component"]:::ext
CapC["Feature"]:::ext
EB["Release"]:::ext
A -.->|"Requests"| CC
A -.->|"Attaches"| CapC
A -->|"Binds via"| EB
- Rolle: Der Entwickler. Konzentriert sich ausschließlich auf KI-Architektur, kognitive Schleifen und die Überlebensanforderungen der Anwendung. Er braucht keine Kenntnisse über CEL, OPA oder physische Ports.
- 1. Aggregate: Der Map-basierte deklarative Bauplan der Anwendungstopologie. Ob als Stamm-Aggregate, das ein Release baut, oder als parametrisiertes, wiederverwendbares Modul, definiert es logische
componentsund hängt unterfeaturesdie Features an, deren Verhalten Anwendungsabsicht ist, zusammen mit ihrenvalues; ein Feature, dessen Eingaben alle operativ sind, wird stattdessen vom Operator im Release angehängt (siehe Domäne 4). Ein Credential wird über dieselbe Anhangsflächefeaturesangefordert, mithilfe eines Credential-Feature; einen separaten Block dafür gibt es nicht. Es definiert abstrakte Kapazitätsanforderungen überparameters(typisierte Verträge im Vokabular der kompakten Form) und den Nutzlastzustand übervalues. Component-Instanzen unterstützen ein optionales Felddescriptionfür Dokumentation und Darstellung im Studio. Es fördert die „Zero-Port“-Konvention (Netzwerkports werden abstrahiert, sofern bestehender Code sie nicht ausdrücklich erfordert), ohne fest codierte Zielplattform oder Namespace.
Domäne 2: Platform Catalog (die „Schnittstellen und Intelligenz“)
graph TD
classDef ext stroke-dasharray:5 4;
A["Aggregate"]:::ext
EB["Release"]:::ext
CC["Component<br/>The Compute Interface"]
CapC["Feature<br/>The Operational Trait"]
CD["Recipe"]:::ext
CapD["FeatureRecipe"]:::ext
A -.->|"Requests"| CC
A -.->|"Attaches"| CapC
EB -.->|"Attaches"| CapC
CC -.->|"Resolved to"| CD
CapC -.->|"Resolved to"| CapD
- Rolle: Der Platform Architect. Der „Programmierer“ der Plattform. Er ordnet jede Komponente in die operative Ontologie ein, verfasst die programmierbaren Policies (Wasm-Mutatoren und -Validatoren) und legt die semantischen Duck-Typing-Labels fest.
- 2. Component: Die abstrakte Schnittstelle für einen Rechenknoten. Sie deklariert ihre Grundform über die operative Cloud-Ontologie (z. B.
component.aggrega.ai/type: server) und schichtet ihre kognitive Identität über Duck-Typing-Labels (z. B.model.aggrega.ai/capability: generative). Sie deklariert Credential-Slots überfeaturesSchema(erforderlich/optional, Blackbox/transparent) und verwendetschema:(JSON Schema 2020-12, üblicherweise in der Kurzschreibweise der kompakten Form verfasst), um den undurchsichtigenvalues-Block des Entwicklers strikt zu validieren. - 3. Feature: Ein modulares operatives Merkmal (z. B. Datenmaskierung, DNS-Routing, Secret-Verwaltung). Es verwendet
appliesTo-Label-Selektoren, um sich dynamisch an bestimmte semantische Labels zu binden. Wie Components deklariert es Credential-Slots überfeaturesSchema, um die Bereitstellung von API-Schlüsseln durchzusetzen. Entscheidend ist, dass esmetadata.annotationsverwendet, um Elemente im flachen IR-Graphen explizit zu kennzeichnen; dies teilt nachgelagerten Wasm-Policy-Validatoren und Rendering-Plugins mit, wie sie mit der Konfigurationsnutzlast des Feature umgehen sollen.- Credential-Features: Die Plattform vereinheitlicht die Credential-Verwaltung in der Entität Feature: Ein Feature mit dem Label
feature.aggrega.ai/kind: secretist ein Credential-Feature; es definiert eine Abfrageschnittstelle zu einem Secret-Speicher (z. B. AWS Secrets Manager, HashiCorp Vault). Es wird wie jedes andere Feature unterfeatures:angehängt, auf derselben Fläche und in derselben Form; das Label ist ein Metadatum, das der Katalog mitführt, um zu beschreiben, was der Anhang erzeugt, und kein Compiler-Zweig liest es. Es gibt keine separate Art für Secret-Speicher oder Secret-Recipes: Ein Credential-FeatureRecipe hat dieselbe Form wie jedes andere FeatureRecipe, die Pipeline aus Abrufen und Ausliefern ist für beide dieselbe, und der Liefervertraginject(env,file,arg) wird geteilt. Eine Entität, ein Anhangsschlüsselwort, ein Ausführungspfad für Modifikatoren durch das Rendering; und Credentials werden im Manifest unterfeatures.typeabgebildet.
- Credential-Features: Die Plattform vereinheitlicht die Credential-Verwaltung in der Entität Feature: Ein Feature mit dem Label
Ontologie als Label. Die operative Cloud-Ontologie wird in metadata.labels["component.aggrega.ai/type"] deklariert statt als spec.type-Feld auf oberster Ebene. Diese Wahl ermöglicht es der Label-Selektor-Engine des Compilers, Ontologiewerte direkt anzusteuern: Ein Feature deklariert appliesTo: "component.aggrega.ai/type in (server, worker)", um sich dynamisch an jede Server- oder Worker-Komponente anzuhängen, ohne neue Go-Logik im zentralen Compiler. Dieselbe Selektormechanik gilt für jedes Aggrega-Label, sodass ein Feature, ein Socket-Selektor oder eine Grenzzuordnung in einem Release den eigenen Label-Schlüssel eines Katalogs genau so liest wie diesen.
component.aggrega.ai/type ist der Schlüssel von Aggrega, und seine Wertemenge ist geschlossen: Das veröffentlichte Component-Schema zählt die Primitive auf, und ein Dokument mit einem anderen Wert wird beim Laden abgelehnt, wobei E0215 das Label nennt und auflistet, was es akzeptiert. Ein Katalog, der eine Klassifizierung benötigt, die Aggrega nicht definiert, fügt daneben seinen eigenen Label-Schlüssel hinzu (das Component-Schema akzeptiert jeden weiteren Label-Schlüssel mit einem Zeichenkettenwert), sodass eine neue Achse einen eigenen Schlüssel und kein neues Compiler-Release kostet, während der reservierte Schlüssel überall eine einzige Bedeutung behält. Genau das lässt ein Feature, das gegen component.aggrega.ai/type in (stateful-server) geschrieben wurde, mit Components von Autoren funktionieren, die sich nie begegnet sind.
Domäne 3: Infrastrukturbasis (die „Implementierungen“)
graph LR
classDef ext stroke-dasharray:5 4;
CC["Component"]:::ext
CapC["Feature"]:::ext
ENV["Manifest"]:::ext
EB["Release"]:::ext
CD["Recipe<br/>The Implementation"]
CapD["FeatureRecipe<br/>The Binding"]
T["Plugin<br/>The Wasm Plugin"]
CC -.->|"Resolved to"| CD
CapC -.->|"Resolved to"| CapD
ENV -->|"Resolves Interfaces to"| CD
ENV -->|"Resolves Interfaces to"| CapD
EB -->|"Renders via"| T
- Rolle: Der Infrastrukturingenieur / Ops. Verantwortet die physische Realität, die Zuweisung der Netzwerkports und die Templating-Logik.
- 4. Recipe: Das Multi-Provider-Übersetzungs-Template (z. B. Helm oder Docker Compose). Es stellt über das Schlüsselwort
implementseinen strikten 1:1-API-Vertrag mit der Katalogkomponente her. Das Recipe bildet die.valuesdes Entwicklers auf das physische Format ab. Es codiert die physischen Netzwerkports fest (z. B.5432) und liest dieprovidesdes Ziels über die Pipe.context.uses, wodurch der Injektionsvertrag erfüllt wird, ohne Datenbanknamen fest zu codieren. - 5. FeatureRecipe: Bildet ein
Featureüber das Schlüsselwortimplementsexplizit auf eine konkrete Infrastrukturimplementierung ab. Es schreibt eine Fähigkeit des Ziel-Providers incapabilityvor (z. B.helm,compose). Da die Plattform die Credential-Verwaltung in der Entität Feature vereinheitlicht, behandeln FeatureRecipes sowohl operative Features (Datenmaskierung, DNS-Routing, Sidecar-Injektion) als auch Credential-Features (Erzeugung von Vault-CRDs, Einhängen von Secret-Volumes). Um dieses gesamte Spektrum abzudecken, unterstützt es drei getrennte Ausführungsblöcke:pipeline: Ein sequenzielles Array von WebAssembly-(Wasm)-Plugins für die Workload-Mutation nach dem Rendering (z. B. Injizieren eines Envoy-Sidecars per JSONPatch oder Einhängen eines Secret-Volumes).sourceundvaluesMapping,workload,artifacts: Dieselben drei Eingabearten, die ein Recipe trägt; sie werden zur Ressourcenerzeugung verwendet und ermöglichen es Ops, statische Templates nativ neben der Basiskomponente zu rendern (z. B. eine neueHTTPRoute-CRD oder eineExternalSecret-CRD zu erzeugen).injectMapping(Abfangen vor dem Rendering): Ein nativer Go-Template-Block, der vor dem Rendering des Basis-Recipe ausgeführt wird. Er gibt ein JSON-Wörterbuch aus, das der Compiler nativ per Deep-Merge über die Speicher-Pipe.context.injectdes Aufrufers legt, was eine Wasm-freie, aufruferseitige Mutation von Umgebungsvariablen und Verbindungszeichenfolgen ermöglicht.
- Das Credential-FeatureRecipe-Muster: Wenn ein FeatureRecipe ein Credential-Feature implementiert (mit dem Label
feature.aggrega.ai/kind: secret), gilt das übliche zweiteilige Plugin-Prinzip: Diepipelineverkettet ein Fetcher-Plugin (das die vault-spezifische CRD erzeugt), gefolgt von einem Injector-Plugin (das das Secret in den Zielcontainer einhängt). Die Aufteilung in Fetcher und Injector maximiert die Wiederverwendbarkeit: Der Wechsel von AWS Secrets Manager zu HashiCorp Vault erfordert nur den Austausch des Fetcher-Plugins; der Injector bleibt identisch.
- 6. Plugin: Das inhaltsadressierte WebAssembly-Plugin. Ein Provider-Rendering-Plugin (
pluginType: provider) ist die Einheit, die die Eingabearten eines Recipe in das endgültige, als Zeichenkette serialisierte Dateiformat umwandelt: Es deklariert den oder die Providernamen, die es bedient, inspec.provider.capabilities(z. B.helm), bietet einenrender_node-Export an, an den der Compiler weiterleitet, und trägt die übrigen Metadaten seines Provider-Sockets (workloadSchema,wellKnownAnnotations) in demselbenspec.provider-Block. Die anderen Socket-Typen, die ein Plugin deklarieren kann, sindpipeline-step,linter,governance,cli,parserundimporter. Der Compiler routet die gepinnte Referenz; die WebAssembly-Laufzeit führt die Bytes aus.
Domäne 4: Routing und Policy (der „Klebstoff“)
graph TD
classDef ext stroke-dasharray:5 4;
A["Aggregate"]:::ext
EB["Release<br/>The Deployment Router"]
ENV["Manifest<br/>The Dependency Lockfile"]
CapC["Feature"]:::ext
T["Plugin"]:::ext
CD["Recipe"]:::ext
CapD["FeatureRecipe"]:::ext
A -->|"Binds via"| EB
EB -.->|"Attaches"| CapC
EB -->|"Uses"| ENV
EB -->|"Renders via"| T
ENV -->|"Resolves Interfaces to"| CD
ENV -->|"Resolves Interfaces to"| CapD
- Rolle: Der Platform Operator / DevOps.
- 7. Manifest: Das Abhängigkeits-Lockfile. Es verwendet eine flache URI-Zuordnung: Ein Wörterbuch
components.typebildet Komponententypen des Katalogs auf Recipe-URIs ab, und ein Wörterbuchfeatures.typebildet Feature-Typen auf FeatureRecipe-URIs ab. Die Auflösung ist ein direkter URI-Lookup gegen Lockfile und Katalog; die Bestimmung der Fähigkeit ergibt sich zur Build-Zeit aus dem Feldspec.capabilityjedes aufgelösten Recipe. Nach der Auflösung muss jede Entität eine Zuordnung haben, sonst bricht der Compiler ab. Um ein DRY-Ökosystem zu wahren, unterstützen Manifests über das Schlüsselwortextendsein Kompositionsmuster im Stil von Kustomize, sodass umgebungsspezifische Manifeste (etwa lokal oder Staging) sauber von einem globalen Basismanifest erben und nur ihre spezifischen Überschreibungen deklarieren. - 8. Release: Der Router. Es bindet ein
aggregatean einmanifestund bildet Komponenten auf physische Grenzen ab (z. B.aws-eks-production). Um einen DRY-Workflow zu wahren, unterstützen Releases die Vererbung über das Schlüsselwortextends, sodass umgebungsspezifische Releases sauber von einem globalen Basis-Release erben. Es erfüllt den abstrakten Aggregate-Vertrag, indem es physische Gegebenheiten strikt in denparameters-Block injiziert, und injiziert die physische Dimensionierung (etwa CPUs oder Ports) über den parallelen Namespaceinfra. Um das Aggregate als Single Source of Truth zu schützen, verbietet das Schema des Release mechanisch einenvalues:-Block: Ops kann aus einem Release heraus für keine Component und kein Featurevaluesdeklarieren. Umgebungsspezifische Variationen der entwicklerseitigen Werte laufen über Parameter Hoisting: Der Entwickler stellt im Aggregate ein typisiertes Feldparameters.*bereit, dasvalues-Template der Component referenziert es, und das Release erfüllt den Parameter für seine Umgebung. Die gerenderten Werte unterscheiden sich zwischen den Umgebungen, während das Aggregate, die Autorenoberfläche dafür, welche Werte existieren und wie sie fließen, die Single Source of Truth bleibt. Das explizit formulierte Verbot auf Schemaebene finden Sie unter Einschränkung 4, „Release kann Entwicklerwerte nicht überschreiben“, in Architektonische Einschränkungen und empfohlene Muster. Entscheidend ist: Um nicht nachvollziehbare, „das Aggregate verändernde“ Releases zu verhindern, wird die Deklaration einesaggregatevom Schema des Release abgelehnt, wenn ein Releaseextendsverwendet (die Schemaeinschränkung verbietet die Deklaration vonaggregate, wennextendsverwendet wird). Das abgeleitete Release muss genau derselben Entwicklerabsicht entsprechen wie sein übergeordnetes. Dasmanifestwird hingegen optional und ermöglicht so „späte Bindung“: Ops kann die gesamte physische Topologie erben, aber das Abhängigkeits-Lockfile gezielt austauschen.- Feature-Anhang: Auch das Release hängt Features an, unter
featuresan einer Grenze oder an einer einzelnen Komponente. Ein Feature, dessen Eingaben alle operativ sind, hängt es direkt an, mit seinemtypeundinfra; ein Feature, das das Aggregate angehängt hat, dimensioniert es, indem es dasinfradieses Anhangs unter demselben Namen schreibt.
- Feature-Anhang: Auch das Release hängt Features an, unter
Warum das Manifest vom Release getrennt ist. Die Trennung des Software-Lockfiles (Manifest) vom Deployment-Router (Release) ermöglicht eine Form, die keine der beiden Entitäten allein erzeugen könnte: DevOps stellt eine einzige Anwendung auf mehreren regionalen Deployment-Routern bereit (verschiedene Releases, die verschiedene Cloud-Regionen ansteuern und alle dasselbe Manifest referenzieren), ohne Recipe-Bindungen über Umgebungen hinweg zu duplizieren. Jedes regionale Release trägt sein Grenzlayout und seine umgebungsspezifischen Parameter und nutzt dabei dasselbe Software-Lockfile, das das Manifest bereitstellt. Die Skalierung über mehrere Regionen ergibt sich aus der Domänentrennung, nicht aus der Duplizierung des Manifest.
Stufe 3: Bibliotheken (Wiederverwendung im Katalog)
graph LR
classDef ext stroke-dasharray:5 4;
CC["Component"]:::ext
CapC["Feature"]:::ext
CD["Recipe"]:::ext
CapD["FeatureRecipe"]:::ext
SL["SchemaLibrary<br/>JSON Schema definitions"]
ML["MappingLibrary<br/>Go template fragments"]
WL["WorkloadLibrary<br/>Workload template fragments"]
AL["ArtifactLibrary<br/>Named artifact bundles"]
CC -.->|"$ref"| SL
CapC -.->|"$ref"| SL
CD -.->|"valuesMapping $import"| ML
CapD -.->|"$import"| ML
CD -.->|"workload $import"| WL
CD -.->|"artifacts $import"| AL
CapD -.->|"$import"| AL
- Rolle: Der Platform Architect (dieselbe Persona wie in Domäne 2), doch die Rolle greift erst, wenn der Kataloginhalt so groß wird, dass er von der Component-übergreifenden Wiederverwendung von Schemas oder der Recipe-übergreifenden Wiederverwendung von Templates, Workload-Formen oder Artefaktbündeln profitiert. Einzelautoren und kleine Kataloge kommen ganz ohne Entitäten der Stufe 3 aus.
- 9. SchemaLibrary: Wiederverwendbare Definitionen in JSON Schema 2020-12. Eine Bibliothek deklariert benannte Schemas unter
spec.schemas:und optionale parametrisierte Helfer unterspec.templates:(mit$params:-Deklarationen und$instantiate:-Referenzen für parametrische Wiederverwendung). Katalogentitäten nutzen Bibliothekseinträge über das standardmäßige JSON-Schema-Schlüsselwort$ref:, das per Identität auf den Bibliothekseintrag verweist, in der hostlosen Form<library>#/schemas/<name>(die Version stammt aus dem Lockfile, nicht aus der Referenz). PascalCase-Benennung, Verteilung über OCI, im Lockfile gepinnt. Optional für Kataloge, die Component-übergreifende Schema-Wiederverwendung benötigen: Gemeinsame Formen wiePodResources,PersistenceSpec,NodePoolundMetricsServiceMonitorwiederholen sich in jeder Datastore-Component und jeder Workload-Component, und Einträge einer SchemaLibrary lagern diese Wiederholung aus dem Verfassen der einzelnen Component aus. - 10. MappingLibrary: Wiederverwendbare Go-Template-Fragmente. Eine Bibliothek deklariert benannte Templates unter
spec.mappings:. Recipes und FeatureRecipes nutzen Bibliothekseinträge per Identität übervaluesMapping: { $import: <library>#/mappings/<name> }. Ein einziger Autorenmodus (nur Go-Templates); kein paralleler Jsonnet-Autorenpfad. Optional für Kataloge, die Recipe-übergreifende Wiederverwendung von Mappings benötigen: Gemeinsame Muster wie die Helper-Logik von Bitnami-Charts oder geteilte Pod-Template-Muster wiederholen sich in jedem Datastore-Recipe, das denselben Provider ansteuert, und Einträge einer MappingLibrary lagern diese Wiederholung aus dem Verfassen des einzelnen Recipe aus. - 11. WorkloadLibrary: Wiederverwendbare Workload-Template-Fragmente. Eine Bibliothek deklariert benannte Workload-Einträge unter
spec.workloads:. Ein Recipe nutzt einen Eintrag per Identität überworkload: { $import: <library>#/workloads/<entry> }, und der importierte Inhalt wird gegen das plattformeigene Workload-Schema genau so validiert wie ein Inline-Blockworkload:; ein aus einer Bibliothek importierter Workload wird daher identisch zum entsprechenden Inline-Workload gerendert. Ein einziger Autorenmodus (nur Go-Templates). Optional für Kataloge, die Recipe-übergreifende Wiederverwendung von Workloads benötigen, wenn mehrere Recipes eine Deployment-Form teilen und sich nur in ihren Werten unterscheiden. - 12. ArtifactLibrary: Wiederverwendbare benannte Artefaktbündel. Eine Bibliothek deklariert benannte Bündel unter
spec.artifacts:; jedes Bündel gruppiert die zusammengehörigen Ausgabedateien (etwa eine CRD, ihr RBAC und eine ConfigMap) und wird als eine Einheit importiert. Recipes und FeatureRecipes nutzen ein Bündel per Identität überartifacts.<name>: { $import: <library>#/artifacts/<name> }. Ein einziger Autorenmodus (nur Go-Templates). Optional für Kataloge, die Recipe-übergreifende Wiederverwendung von Artefakten benötigen, wenn dieselbe Menge an Hilfsressourcen viele Recipes begleitet.
Jede Bibliothek wird über OCI veröffentlicht, im Lockfile gepinnt (in den Abschnitten schema_libraries:, mapping_libraries:, workload_libraries: und artifact_libraries:) und erscheint in der Hub-Oberfläche mit Kenntnis der Nutzer (welche Components welche Bibliothekseinträge referenzieren; welche Recipes welche Bibliothekseinträge nutzen).