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

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ätDomäneRolle
1AggregateDomäne 1 — EntwicklerabsichtBauplan der Anwendungstopologie
2ComponentDomäne 2 — Platform CatalogAbstrakte Schnittstelle eines Rechenknotens
3FeatureDomäne 2 — Platform CatalogOperatives Merkmal (einschließlich Credential-Features)
4RecipeDomäne 3 — InfrastrukturbasisComponent-Implementierung, pro Provider
5FeatureRecipeDomäne 3 — InfrastrukturbasisFeature-Implementierung, pro Provider
6PluginDomäne 3 — InfrastrukturbasisInhaltsadressiertes WebAssembly-Plugin (Provider-Rendering, Pipeline-Schritte, Linting)
7ManifestDomäne 4 — Routing und PolicyAbhängigkeits-Lockfile, das Schnittstellen auf Recipes abbildet
8ReleaseDomäne 4 — Routing und PolicyDeployment-Router, der das Aggregate an das Manifest bindet
9SchemaLibraryStufe 3 — BibliothekenWiederverwendbare Definitionen in JSON Schema 2020-12
10MappingLibraryStufe 3 — BibliothekenWiederverwendbare Go-Template-Fragmente
11WorkloadLibraryStufe 3 — BibliothekenWiederverwendbare Workload-Template-Fragmente
12ArtifactLibraryStufe 3 — BibliothekenWiederverwendbare 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 components und hängt unter features die Features an, deren Verhalten Anwendungsabsicht ist, zusammen mit ihren values; 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äche features angefordert, mithilfe eines Credential-Feature; einen separaten Block dafür gibt es nicht. Es definiert abstrakte Kapazitätsanforderungen über parameters (typisierte Verträge im Vokabular der kompakten Form) und den Nutzlastzustand über values. Component-Instanzen unterstützen ein optionales Feld description fü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 über featuresSchema (erforderlich/optional, Blackbox/transparent) und verwendet schema: (JSON Schema 2020-12, üblicherweise in der Kurzschreibweise der kompakten Form verfasst), um den undurchsichtigen values-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 über featuresSchema, um die Bereitstellung von API-Schlüsseln durchzusetzen. Entscheidend ist, dass es metadata.annotations verwendet, 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: secret ist ein Credential-Feature; es definiert eine Abfrageschnittstelle zu einem Secret-Speicher (z. B. AWS Secrets Manager, HashiCorp Vault). Es wird wie jedes andere Feature unter features: 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 Liefervertrag inject (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 unter features.type abgebildet.

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 implements einen strikten 1:1-API-Vertrag mit der Katalogkomponente her. Das Recipe bildet die .values des Entwicklers auf das physische Format ab. Es codiert die physischen Netzwerkports fest (z. B. 5432) und liest die provides des 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üsselwort implements explizit auf eine konkrete Infrastrukturimplementierung ab. Es schreibt eine Fähigkeit des Ziel-Providers in capability vor (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:
    1. 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).
    2. source und valuesMapping, 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 neue HTTPRoute-CRD oder eine ExternalSecret-CRD zu erzeugen).
    3. 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.inject des 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: Die pipeline verkettet 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, in spec.provider.capabilities (z. B. helm), bietet einen render_node-Export an, an den der Compiler weiterleitet, und trägt die übrigen Metadaten seines Provider-Sockets (workloadSchema, wellKnownAnnotations) in demselben spec.provider-Block. Die anderen Socket-Typen, die ein Plugin deklarieren kann, sind pipeline-step, linter, governance, cli, parser und importer. 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.type bildet Komponententypen des Katalogs auf Recipe-URIs ab, und ein Wörterbuch features.type bildet 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 Feld spec.capability jedes 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üsselwort extends ein 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 aggregate an ein manifest und 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üsselwort extends, sodass umgebungsspezifische Releases sauber von einem globalen Basis-Release erben. Es erfüllt den abstrakten Aggregate-Vertrag, indem es physische Gegebenheiten strikt in den parameters-Block injiziert, und injiziert die physische Dimensionierung (etwa CPUs oder Ports) über den parallelen Namespace infra. Um das Aggregate als Single Source of Truth zu schützen, verbietet das Schema des Release mechanisch einen values:-Block: Ops kann aus einem Release heraus für keine Component und kein Feature values deklarieren. Umgebungsspezifische Variationen der entwicklerseitigen Werte laufen über Parameter Hoisting: Der Entwickler stellt im Aggregate ein typisiertes Feld parameters.* bereit, das values-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 eines aggregate vom Schema des Release abgelehnt, wenn ein Release extends verwendet (die Schemaeinschränkung verbietet die Deklaration von aggregate, wenn extends verwendet wird). Das abgeleitete Release muss genau derselben Entwicklerabsicht entsprechen wie sein übergeordnetes. Das manifest wird 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 features an einer Grenze oder an einer einzelnen Komponente. Ein Feature, dessen Eingaben alle operativ sind, hängt es direkt an, mit seinem type und infra; ein Feature, das das Aggregate angehängt hat, dimensioniert es, indem es das infra dieses Anhangs unter demselben Namen schreibt.

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 unter spec.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 wie PodResources, PersistenceSpec, NodePool und MetricsServiceMonitor wiederholen 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 über valuesMapping: { $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 über workload: { $import: <library>#/workloads/<entry> }, und der importierte Inhalt wird gegen das plattformeigene Workload-Schema genau so validiert wie ein Inline-Block workload:; 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 über artifacts.<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).