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

Governance und Compliance

Dieses Kapitel definiert, wie Plattformteams die Unternehmens-Compliance in jedem Build durchsetzen — über den Governance-Socket, die Baselines und Schemas des Katalogs und die Konventionen, denen Katalogautoren folgen —, ohne Policies fest in den Compiler zu codieren. Day-2-Lebenszyklusereignisse sind Gegenstand von Day-2-Lebenszyklen.

Muster für Governance und Compliance im Unternehmen

Eine zentrale Herausforderung im Platform Engineering besteht darin, unternehmensweite Governance (etwa SOC-2-Compliance, FinOps-Kostenstellenverfolgung und strikte Zuordnung von Zuständigkeiten) durchzusetzen, ohne den Open-Source-Katalog zu verunreinigen.

Würde Aggrega domänenspezifische Logik fest in seine offiziellen Komponenten codieren, wäre es kein meinungsloser Compiler mehr, sondern verkäme zu einem meinungsstarken Framework. Wird Compliance umgekehrt vollständig dem Entwickler überlassen, werden kritische Tags falsch geschrieben, vergessen oder umgangen.

Um dies zu lösen, stellt Aggrega die Wasm-Socket-Mechanismen für Compliance bereit, während das Unternehmen die Policy vorgibt. Unternehmen erreichen Zero-Trust-Governance, indem sie in ihrem Ökosystem zwei unterschiedliche Gesellschaftsverträge übernehmen.

1. „Bring Your Own Baseline“ (BYOB) + Wasm-Validierungsgate

Für statische, vom Entwickler bereitgestellte Daten (etwa Teamzuständigkeit oder Datenklassifizierung) sollten sich Unternehmen nie direkt auf den rohen Open-Source-Katalog verlassen. Stattdessen verfasst der Plattformarchitekt eine unternehmensweite Baseline — die Felder, die jede interne Komponente tragen muss, einmal in einem SchemaLibrary-Eintrag deklariert — und nutzt eine Governance-Verdict-Rolle, um ihre Verwendung zu erzwingen.

Der Katalogvertrag: Das Unternehmen erstellt eine Baseline, die bestimmte Tags verlangt, aber keine Infrastruktur bereitstellt.

apiVersion: aggrega.ai/v1beta1
kind: SchemaLibrary
metadata:
name: CorporateBaseline
version: 1.0.0
spec:
schemas:
Ownership:
type: object
properties:
owner: { type: string }
cost_center: { type: string }
# The developer MUST provide these, or the schema validator halts the build
required: [owner, cost_center]

Jede interne Komponente (z. B. acme/datastore/postgres) referenziert den Eintrag aus ihrem eigenen schema: und fügt die Werte hinzu, die ihr eigen sind, sodass die gemeinsamen Felder und die eigenen Felder der Komponente zusammen validiert werden:

apiVersion: aggrega.ai/v1beta1
kind: Component
metadata:
name: acme/datastore/postgres
version: 1.0.0
labels:
component.aggrega.ai/type: stateful-server
spec:
schema:
values:
$ref: "CorporateBaseline#/schemas/Ownership"
properties:
database: { type: string }
required: [database]

Die Baseline ist ein Bibliothekseintrag statt einer Basis-Component, weil eine Component, die extends: schreibt, das schema: ihrer Basis vollständig erhält und keine eigenen Werte deklariert (siehe Vererbung und Veröffentlichungsdisziplin).

Die Wasm-Validierungsabsicherung: Um zu verhindern, dass ein Entwickler den internen Katalog umgeht und eine nackte core/postgres-Komponente direkt aus dem öffentlichen Hub bezieht, registriert das Unternehmen ein Plugin zur topologischen Validierung. Es wird während der statischen Analyse ausgewertet — nachdem der Graph zusammengesetzt und bevor ein Artefakt gerendert wird —, weshalb es die gesamte Topologie sieht statt jeweils nur einer Komponente.

# Evaluated by the governance ir-verdict role over the assembled graph
package acme.governance
import rego.v1
deny contains msg if {
some id, _ in input.graph.spec.nodes
not input.graph.spec.values_mapping[id].owner
msg := sprintf("node %v declares no owner; use a component whose schema references 'CorporateBaseline#/schemas/Ownership'.", [id])
}

Eine Entscheidung, die die Policy unter ihrem Deny-Schlüssel sammelt, ist eine Ablehnung, und der Build hält daraufhin an.

Freie Verbindungen verbieten: Ein Entwickler kann eine Kante über einen Socket verdrahten, den der Katalog nicht deklariert hat — einen Ad-hoc-Socket (siehe dependency-resolution). Diese Offenheit ist gewollt, und ebenso die Tatsache, dass der Compiler dazu keine Meinung vertritt: Eine Organisation, die will, dass jede Verbindung über einen von ihren Architekten deklarierten Socket läuft, drückt dies als Policy aus, statt sich auf den Compiler zu verlassen. Jede Kante im Graph trägt socket_declaration mit dem Wert declared oder ad-hoc, sodass die Regel aus einer Zeile besteht:

# Evaluated by the governance ir-verdict role over the assembled graph
package acme.governance
import rego.v1
deny contains msg if {
some e in input.graph.spec.edges
e.socket_declaration == "ad-hoc"
msg := sprintf("%v connects to %v through the free-form socket %v; declare the socket in the component type's usesSchema.",
[e.source, e.target, e.socket])
}

Der Wert ist auf jeder Kante immer vorhanden, gleich auf welche Weise die Kante verfasst wurde, sodass eine Policy ein fehlendes Feld nie als „declared“ lesen muss. Und er bildet eine eigene Achse: Er sagt, woher der Socket stammt, nicht, wer die Kante gezogen hat, sodass er sich mit origin_feature und origin_release kombinieren lässt, statt sich mit ihnen zu überschneiden — eine Policy kann freie Verbindungen verbieten und dem Release dennoch erlauben, deklarierte zu verdrahten.

Zentralisierte Unternehmens-Governance (Bewertung der vollständigen Realität): Out-of-Band-Mechanismen (wie CODEOWNERS in einem Git-Repository) prüfen die Dateien, die sich ändern, nicht die Architektur, zu der sie kompiliert werden. Die Governance-Verdict-Rollen beurteilen die Architektur selbst. Da der AOT-Compiler den IR-Graph aufbaut, indem er sowohl das Aggregate des Entwicklers als auch das Release des Plattformbetreibers abflacht, bewertet eine Policy an der Rolle ir-verdict die vollständige Realität, bevor physische Artefakte erzeugt werden, und eine an der Rolle render-verdict die Artefakte selbst. Policies können den Build fatal anhalten, wenn ein Entwickler eine nicht genehmigte Component anfordert oder — anhand der auf jedes gerenderte Objekt gestempelten Provenienz aggrega.ai/recipe-uri — wenn das Manifest eine Komponente auf ein nicht genehmigtes Recipe abbildet.

2. Das Wasm-Mutator-Gate (Dynamische Compliance)

Entwickler sollten nicht gezwungen sein, umgebungsbezogene Compliance-Tags (z. B. environment: production oder soc2_in_scope: true) manuell in ihr Aggregate zu tippen, da sich diese je nach GitOps-Ziel ändern.

Für dynamische Metadaten nutzen Unternehmen das Mutation Gate — die Rolle label-transform des Governance-Sockets, die während der Topologiekonstruktion läuft. Nachdem der Graph expandiert wurde und bevor die statische Analyse ihn auswertet, führt der Compiler das Wasm-Plugin aus, das das Unternehmen angehängt hat. Dieses Plugin liest die Umgebung des Release, die Labels, die die Knoten bereits deklarieren, und die Werte, die die Instanz jedes Knotens deklariert, und benennt die Labels, die die Knoten des Builds tragen sollen — so erreichen die erforderlichen Metadaten die Komponente, ohne dass der Entwickler sie tippt (z. B. das Label compliance.aggrega.ai/data-class: restricted, abgeleitet aus der Umgebung des Release, oder datastore.aggrega.ai/engine: vector, abgeleitet aus den deklarierten Erweiterungen einer Datenbank). Die Werte sind schreibgeschützt: Das Plugin entscheidet über Labels und sonst nichts.

Eine Policy in dieser Rolle benennt das Label — den Knoten, den Schlüssel und den Wert, den es annimmt —, statt die Änderungsanweisung zu schreiben, die der Build anwendet. Der Grund ist für jeden wichtig, der eine solche Policy verfasst: Die Anweisung adressiert ein Label über einen Pfad, und ein Aggrega-Label-Schlüssel enthält regelmäßig ein /, das das Pfadtrennzeichen ist, sodass ein von Hand geschriebener Pfad eine verschachtelte Position statt eines einzelnen Labels adressieren würde. Der Build adressiert das Label, das die Entscheidung benennt, und die Projektion der Knoten, die diese Rolle erhält, legt sie eine Ebene flacher als ein Verdict über den gesamten Graph.

# Evaluated by the governance label-transform role, during topology construction
package acme.tagging
import rego.v1
labels contains {"node": id, "key": "acme.com/soc2-scope", "value": "true"} if {
input.compilation_context.environment == "production"
some id, node in input.graph.nodes
node.labels["component.aggrega.ai/type"] == "stateful-server"
}

Da diese Tags vor Beginn des Renderings im Speicher in das Standard-Metadatenwörterbuch injiziert werden, können Wasm-Rendering-Plugins sie lesen, um bedingt bestimmte physische Konfigurationen zu erzeugen — etwa gehärtete AWS- oder Kubernetes-Ressourcen —, während die Artefakte gerendert werden.

Eine Regel einmal festlegen: Governance-Attachments gelten für den gesamten Workspace. Die beiden obigen Muster werden pro Komponente und pro Feature verfasst, das Governance-Attachment, das sie durchsetzt, jedoch nicht. Ein Governance-Plugin wird am Schlüssel plugins.governance der Workspace-Konfiguration angehängt, und dieses Attachment bindet jeden Build im Workspace. Eine Unternehmensregel wird daher an genau einer Stelle festgelegt: Das Plattformteam hängt das Plugin einmal an, und keine Komponente, kein Aggregate und kein Release muss sich dafür anmelden, es erwähnen oder bearbeitet werden, damit es greift. Das macht die Validierungsabsicherung aus Muster 1 zu einer vollständigen Antwort statt zu einer projektbezogenen Konvention — ein Entwickler, der den internen Katalog umgeht und ein nacktes core/postgres anfordert, wird von derselben angehängten Policy bewertet wie alle anderen, denn die Policy ist eine Eigenschaft des Workspace und nicht der gewählten Komponente.

Eine Workspace-Regel lehnt ab; sie schreibt den Vertrag des Entwicklers nicht um. Der Geltungsbereich ist universell, und die Wirkung ist bewusst auf ein Verdict beschränkt. Eine Regel, die überall gilt, hält einen Build an, der gegen sie verstößt, und benennt, was zu beheben ist; sie kann die fehlerhafte Komponente nicht stattdessen so abändern, dass sie konform wird. Diese Grenze hält den Mechanismus in der Größenordnung des gesamten Bestands debugbar: Ein Build entspricht entweder den Regeln, die der Workspace deklariert, oder stoppt mit einer Meldung, die auf die verfasste Zeile zeigt, und die gerenderte Ausgabe enthält nie eine Einschränkung oder Ressource, die keine verfasste Datei verlangt hat. Wo ein Unternehmen den Graph tatsächlich geändert statt beurteilt haben will, hängt es eine Transform-Rolle an — Muster 2 oben —, und diese Änderung ist auf das beschränkt, wofür der Operator sie angehängt hat, weshalb sie ein expliziter Akt des Plattformteams ist und keine unsichtbare Umschreibung.

Die praktische Konsequenz für ein Plattformteam, das den Compliance-Kreis schließt: Drücken Sie die Form, die eine Nutzlast haben muss, als Schema-Einschränkungen auf einer Unternehmens-Baseline aus, drücken Sie die entitätsübergreifenden Regeln, die der Bestand verlangt, als angehängte Verdict-Rolle aus, und drücken Sie abgeleitete Metadaten, die der Entwickler nie tippen sollte, als angehängte Transform-Rolle aus. Alle drei werden einmal deklariert und gelten für jeden Build, und keine davon setzt voraus, dass der Entwickler von ihrer Existenz weiß.

3. Bewahrung der Domänenintelligenz (Die Konfigurationen und die Sicherheit)

Da der Aggrega-Compiler meinungslos ist, besitzt er keinerlei fest codiertes Wissen über KI-Frameworks, Token-Budgets oder Speicherpartitionierung. Stattdessen dienen die generischen Cloud-nativen Schemas als leeres Gefäß. Statt fest in den Compiler-Kern codiert zu sein, ist hochspezialisierte Domänenintelligenz über das gesamte erweiterbare Aggrega-Ökosystem verteilt. Sie ist im Plattformkatalog in spezialisierten components, features und recipes gekapselt. Entwickler bewahren ihre spezifische Anwendungsabsicht in ihren values- und uses-Blöcken — streng gesteuert durch die schema:-Deklarationen des Architekten (kompakte Form oder vollständiges JSON Schema 2020-12) und die usesSchema-Sockets —, während die physische Übersetzung dieser Intelligenz von zielspezifischen WebAssembly-Plugins ausgeführt wird.

A. Modellierung domänenspezifischer Implementierungen (Validiert über geteilte Schemas)

Plattformarchitekten können die Pipeline der geteilten Schemas nutzen, um jede komplexe Architektur zu modellieren, völlig unabhängig vom Compiler-Kern:

  • Opake Ausführungslogik (values): Wenn ein Unternehmen ein AI Gateway bereitstellt, konfiguriert der Entwickler das eigene Verhalten des Gateways — beim KI-Gateway der Standardbibliothek die models-Map, die jeden Alias veröffentlicht, den ein Aufrufer anfordern darf, und den Upstream, auf den jeder aufgelöst wird. Der Compiler-Kern parst diese Konzepte nicht. Sie liegen sicher in der opaken values-Nutzlast, streng validiert durch die schema:-Deklaration der Komponente. Der Compiler übergibt diese Nutzlast einfach an das Wasm-Plugin, um die Konfiguration des Gateways zu erzeugen. Steuerungen, die mehrere Gateway-Produkte gemeinsam haben, etwa eine Fallback-Kette, eine Wiederholungsanzahl oder die Wahl zwischen Einträgen, die denselben Alias veröffentlichen, sind an das Gateway angehängte Features statt Werte darauf, jedes für ein Gateway in dessen eigenen Begriffen realisiert.
  • Topologische Abhängigkeitsabbildung (uses): Wo ein KI-Framework einen Agenten mit seinen Tools oder mit einem Vektordatenspeicher verbindet, bestimmt diese Verbindung, wer mit wem spricht, daher wird sie in der uses-Säule deklariert; eine in values geführte Namensliste, etwa tools_allowed der Standardbibliothek, ist eine Konvention, die keine Kante zieht. Der Compiler zeichnet diese expliziten Kanten wortgetreu in den IR-Graph. So können nachgelagerte Wasm-Rendering-Plugins programmatisch die Netzwerkrichtlinien und physischen Grenzen erzeugen, die zur Absicherung der Verbindungen nötig sind, ohne dass der Compiler das zugrunde liegende KI-Framework versteht.
  • Komplexe Datenstrukturen (z. B. CoALA): Statt auf eine einzige flache Liste von Zielen beschränkt zu sein, deklarieren Architekten in usesSchema so viele Sockets, wie eine Struktur benötigt, jeden mit eigenem Selektor und eigenem valueSchema pro Kante. Um beispielsweise das CoALA-Framework umzusetzen, kann ein Architekt semantic_memory, episodic_memory und working_memory als getrennte Sockets deklarieren, sodass jeder Gedächtnisspeicher ein eigenes topologisches Ziel ist. Die generischen Policy-Engines werten diese strukturierten Kanten aus, um für jeden einzelnen kognitiven Lappen feingranulare Leitplanken der Zugriffskontrolle vorzuschreiben.

B. Zentrale Sicherheits- und Indirektionsmechanismen

Während die Nutzlast meinungslos ist, setzt das generische Schema strikte strukturelle Mechanismen durch, die eine sichere Artefakterzeugung unterstützen:

  • Das Muster „Attachment statt Wert“: Die Konvention der Standardbibliothek besagt, dass ein Credential als Attachment angefordert und nie in einen values-Block geschrieben wird, wo es ein Inline-Literal wäre, das der Compiler wortgetreu mitführt. Ein Credential-Attachment benennt einen Credential-Feature-type (ein Feature mit dem Label feature.aggrega.ai/kind: secret) und beschreibt mit seinen eigenen values die Abfrage an einen Secret Store. Das Routing von Credentials ist dann ein fähigkeitsunabhängiges Late Binding, und der Compiler-Kern löst das Material nie auf und legt es nie offen — er leitet den Zeiger weiter, den das Ops-Recipe geliefert hat. Dies ist eine Konvention, die der Katalog und die Schemas fördern, keine Prüfung des Compilers: Der Compiler interpretiert nicht, was ein values-Blatt bedeutet, sodass ein Autor, der Material inline einfügt, es eben inline einfügt. Was das Schema tatsächlich garantiert, ist, dass die Attachment-Oberfläche existiert und typisiert ist.
  • Abstrakte Vertrauensprüfung: Da der values-Block breit erweiterbar ist, können Architekten abstrakte Direktiven wie tls_pinning oder required_signatures: 2 (für Quorum-Konsens) vorschreiben. Der Compiler-Kern übergibt diese schemavalidierten Objekte wortgetreu in den flachen IR-Graph. Ein eigenes Wasm-Rendering-Plugin kann diese Werte dann lesen, um Artefakte für Human-in-the-Loop-(HITL)-Freigabegates auf Hardwareebene zu erzeugen. Versucht eine Anwendung, Konsensregeln zu umgehen, blockiert der physisch bereitgestellte Proxy die Ausführung, bis eine Webhook-Freigabe eingeht.

C. Erweiterte Betriebssicherheit (spec.interoperability)

Um empfindliche Workloads vor kollidierenden Infrastrukturmutationen zu schützen, definiert das generische Feature-Schema eine Interoperabilitätssteuerung:

  • spec.interoperability.conflictsWith — eine Liste der Features, die nicht dieselbe Komponente wie dieses erreichen dürfen. Der Compiler hält den Build vor dem Rendering an, wenn die Attachments, die eine Komponente am Ende trägt — gesammelt aus jedem Geltungsbereich, der sie erreicht: der Komponente selbst, einem Subsystem oder einer Boundary, die sie enthält, ihrem Komponenteneintrag im Release und der annotationsgesteuerten Expansion —, dieses Feature und eines der von ihm benannten enthalten. Es ist ein Vergleich der Namen, die der Feature-Autor deklariert hat, mit den Features, die die Komponente trägt, ohne dass in eines von beiden eine Bedeutung hineingelesen wird: Die Inkompatibilität ist das Urteil des Autors, und der Compiler hält einen Build daran fest. Eine Deklaration genügt, Namen werden unabhängig von ihren Versionen abgeglichen, und zwei Features, die an benachbarte Boundaries ohne gemeinsame Komponente angehängt sind, treffen nie aufeinander.

4. Governance von Netzwerkgrenzen (Konvention der standardmäßigen Ablehnung)

Entwickler schreiben Netzwerk-Policies nicht direkt; die erforderlichen Netzwerkgrenzen werden durch den Graphen der Zwischendarstellung (IR) des Compilers abgebildet, der jede topologische Kante zwischen den im Aggregate deklarierten Komponenten trägt.

  • Interne Grenzen. Der Compiler zeichnet den flachen IR-Graphen und schränkt selbst nichts ein: Ohne eine Policy bleibt jede Verbindung erreichbar, die das Netzwerk des Clusters zulässt. Die Konvention lautet, dass eine für eine Komponente geschriebene Policy eine Verbindung nur dort zulässt, wo das Aggregate eine Kante für sie deklariert, neben dem, was die eigene Anbindung der Policy benennt, und jede andere Verbindung in der Richtung ablehnt, die die Policy regelt.
  • Die Umsetzung der Standardbibliothek. Der Katalog der Standardbibliothek setzt die Konvention als zwei Features um, die der Operator im Release an eine Komponente anbindet, eines für jede Richtung einer Verbindung: core/caller-allowlist lässt Verbindungen nur von den Komponenten zu, deren uses-Kanten auf sie zeigen, und core/egress-allowlist lässt die Komponente sich nur mit den Komponenten verbinden, auf die ihre eigenen Kanten zeigen, sowie mit dem DNS des Clusters. Auf dem helm-Ziel wird jedes durch ein FeatureRecipe umgesetzt, das aus den Kanten, die der Compiler ihm übergibt, eine Kubernetes-NetworkPolicy schreibt und die Pods jeder Komponente anhand dessen benennt, was das eigene Rendering dieser Komponente ausgegeben hat — die Selektoren und Labels, die ihre Arbeitslasten tragen, den Namespace, in den sie ausgegeben werden, und die Ports, die ihre Container deklarieren —, sodass kein Label und kein Port von Hand wiederholt wird. Jedes lässt außerdem die eigenen Pods der Komponente zu sowie das, was das Release an der Anbindung benennt: auf der eingehenden Seite Quellen außerhalb des Aggregate und auf der ausgehenden Seite Adressbereiche für ein Ziel, das der Cluster nicht ausführt, das keine auszuwählenden Pods rendert und nur über den Bereich zugelassen wird, auf jedem Port. Der Compiler kann den Cluster nicht inspizieren, daher hält jedes den Build an, bis das Release bestätigt, dass das Netzwerk-Plug-in des Clusters Netzwerk-Policies durchsetzt; compose hat keine Netzwerk-Policy, und ein Build, der dort eines der beiden anbindet, wird angehalten.
  • Öffentlicher Ingress (agnostische Perimeterkontrolle). Öffentlicher Ingress wird durch die eigenen Regeln des Unternehmens in einer Governance-Urteilsrolle geregelt. Ein Sicherheitsteam des Unternehmens kann eine Policy schreiben, die den Typ der Cloud-native-Ontologie eines Knotens auswertet und den Build ablehnt, wenn ein Entwickler versucht, eine Funktion public-ingress an einen Knoten worker oder task anzubinden. Der Compiler interpretiert nicht, was „öffentlich“ bedeutet; er setzt die boolesche Ausgabe des Wasm-Validierungsgates durch.

5. Provenienzstempel zur Kompilierzeit

Der Compiler erstellt während der Kompilierung einen Provenienzdatensatz, der die Compiler-Version und die Versionen des Aggregate, des Manifest und des Release erfasst, die er kompiliert hat — und keinen Zeitstempel, sodass der Datensatz die byteidentische Ausgabe nie bricht. Der Renderer helm gibt die Compiler-Version als Label aggrega.ai/compiler-version an den generierten Kubernetes-Manifesten aus, und der Renderer helm-chart an den Template-Dateien, die ein Recipe einem Chart hinzufügt, da er die eigenen Templates des Charts unverändert kopiert; Sicherheitsteams von Unternehmen nutzen dies, um festzustellen, welche gerenderten Artefakte von welcher Compiler-Version gebaut wurden — wichtig, wenn in einer bestimmten Compiler-Version eine Sicherheitslücke entdeckt wird und die betroffenen Artefakte geprüft werden müssen.

Der Provider compose stempelt dieselben Provenienzschlüssel als Service-Labels, der Provider terraform als Provenienzdatei in jedem Modul, das er zusammenstellt, und der Provider cloudformation unter Metadata jeder Ressource; der In-Memory-Provenienzdatensatz existiert für jede Kompilierung.

6. Metadaten und Annotationen als Erweiterungsfläche

Der Go-Compiler ist agnostisch gegenüber domänenspezifischen Konzepten — KI-Frameworks, Datenbank-Engines, Kubernetes-Idiomen — und arbeitet nur mit flachen Operationen auf Graphebene gegen die IR. Um das Ökosystem anzutreiben, ohne domänenspezifische Logik fest in die Go-Binärdatei zu codieren, verwendet die Plattform Standard-Metadaten-Labels und -Annotationen als Erweiterungsfläche für Domänenwissen.

Der Compiler liest keine domänenspezifischen Annotationen. Er bündelt alle von Entwicklern bereitgestellten Annotationen und Duck-Typing-Labels in den flachen IR-Graphen und übergibt diese Metadaten unverändert an die Governance- und Rendering-Plug-ins. Das WebAssembly-Ökosystem interpretiert die Metadaten und führt die erforderliche Logik aus — es wertet Compliance-Policies aus, fügt Tags in Cloud-native-Artefakte ein oder löst die Expansion von Funktionen aus — unabhängig vom Compiler-Kern.

Dadurch bleibt die Erweiterungsfläche breit (jeder kann ein Wasm-Plug-in schreiben, das ein neues Annotationspräfix liest), während der Compiler-Kern stabil bleibt: Es ist keine neue Kernversion erforderlich, damit das Ökosystem eine neue domänenspezifische Annotation hinzufügen kann.

Was eine Policy über eine Anbindung liest

Eine Urteilsrolle, die den IR-Graphen auswertet, erhält den Graphen vollständig — wobei jeder Wert, den ein Autor als sensibel deklariert hat, zurückgehalten wird, wie unten beschrieben —, und dazu gehört jede Anbindung, die jeder Knoten trägt, geschlüsselt nach dem Namen, den der Autor ihr gegeben hat — oder, bei einer Anbindung, die an einer der Verbindungen des Knotens geschrieben ist, nach dem Alias der Verbindung und dem Slot, verbunden durch einen Punkt. Der Grund, Details der Anbindung statt einer Zusammenfassung zu tragen, ist, dass Aggrega keine Meinung hat, die sich zusammenfassen ließe: Der Compiler leitet Anbindungen weiter, ohne zu beurteilen, was sie enthalten, daher sind die Fakten, die eine Policy zu ihrer Beurteilung braucht, die Fakten, die eine Policy erhält.

Pro Anbindung trägt der Graph:

  • Den angeforderten Feature-Typ und die dafür aufgelöste Katalogversion. Der Typ ist die Zeichenkette, die der Autor geschrieben hat, unverändert — eine Referenz mit fixierter Version und eine ohne sind verschiedene Zeichenketten für denselben Referenten, daher sollte eine Policy, die Typen vergleicht, beide Schreibweisen erwarten.
  • Die Katalog-Labels des angebundenen Feature, unverändert. Ungefiltert, nicht normalisiert, in der Reihenfolge, in der die Katalogentität sie deklariert. Eine Policy liest genau das, was der Katalogautor geschrieben hat, einschließlich Labels eigener Erfindung des Autors, von denen Aggrega nichts weiß.
  • Die Katalog-Annotationen des angebundenen Feature, unverändert. Die eigenen metadata.annotations der Feature-Entität, getragen zu genau denselben Bedingungen wie ihre Labels — ungefiltert, nicht normalisiert, in der deklarierten Reihenfolge der Entität —, sodass ein Annotationsschlüssel im eigenen Namespace eines Autors so ankommt, wie er geschrieben wurde. Dies ist ein anderes Thema als die Annotation, durch die eine per Annotation expandierte Anbindung überhaupt erst entstanden ist: Der Graph meldet diesen Ursprung separat, und eine in einem features:-Block geschriebene Anbindung trägt die Annotationen der Entität, ohne überhaupt einen Expansionsursprung zu melden.
  • Welchen deklarierten Anbindungs-Slot sie füllt. Ein featuresSchema-Slot wird gefüllt, indem ein Feature unter dem Namen des Slots angebunden wird, daher meldet eine Anbindung, die einen von ihrer Component deklarierten Slot benennt, den Namen dieses Slots, und eine, die keinen füllt, meldet free. Eine an einer Verbindung geschriebene Anbindung füllt einen Slot, den der Socket der Verbindung deklariert, und meldet den Namen dieses Slots; da ein Socket keinen anderen Namen zulässt, meldet sie nie free. Der Wert ist der Name des Slots statt eines Flags, weil die Frage, welcher Bindungspunkt gefüllt wurde, meist die nützlichere Hälfte der Antwort ist.
  • An welcher Verbindung sie geschrieben wurde, falls an einer. Eine Anbindung, die an einer der Verbindungen der Komponente geschrieben ist, trägt den Socket und den Alias dieser Verbindung, die die Graphkante benennen, an der sie präsentiert wird — und über diese Kante die Komponente, der sie präsentiert wird. Eine Anbindung aus dem eigenen Block der Komponente trägt keines von beiden. Die Verbindung wird als Daten getragen, statt sie aus dem Namen der Anbindung herauslesen zu lassen, der den Alias und nicht den Socket enthält.
  • Ob sie Material verarbeitet, das ein Autor als sensibel deklariert hat, und welche ihrer Zustellungsschlüssel dieses Material tragen. Beides wird aus Deklarationen abgeleitet — einem sensitive-Blatt im Schema eines Feature, einem sensitive-Slot an der konsumierenden Component, sei es einer, den sie für ihre eigenen Anbindungen deklariert, oder einer am Socket, über den eine Verbindung verdrahtet ist —, niemals aus der Inspektion eines Werts.
  • Ihre values, ihr infra und ihre Zustellungszuordnung, sowie ob die Anbindung in einem features:-Block geschrieben oder durch annotationsgesteuerte Expansion beigetragen wurde — wobei jeder Wert, den ein Autor als sensibel deklariert hat, zurückgehalten wird, wie der nächste Absatz beschreibt.

Einer Policy wird mitgeteilt, wo sich als sensibel deklariertes Material befindet, und das Material wird ihr nie übergeben. Jedes Blatt, das der Graph als sensibel deklariert markiert — in den values oder dem infra einer beliebigen Anbindung, in welchem Geltungsbereich oder an welcher Verbindung sie auch geschrieben wurde, im infra einer Grenzanbindung, in den eigenen values und dem eigenen infra eines Knotens und in den eigenen values und dem eigenen infra einer Verbindung —, erreicht die Policy als Markierung mit einem einzigen Schlüssel, {"aggrega_withheld": "declared"}, anstelle des Werts. Der Schlüssel bleibt erhalten, sodass eine Policy weiterhin sieht, welche Blätter eine Nutzlast trägt; die Markierung, die diese Blätter benennt, bleibt erhalten, sodass eine Policy weiterhin sieht, welche davon deklariertes Material tragen; und jeder oben aufgeführte Fakt kommt wie zuvor an, zusammen mit jedem Wert, den keine Deklaration markiert. Keiner der Fakten, auf die sich eine Policy stützt — was eine Anbindung ist, was sie füllt, wem sie präsentiert wird, was ihre Katalogentität über sie sagt und wohin ihr geheimes Material wandert —, ist ein Wert, den ein Autor als sensibel deklarieren kann, und das Material selbst ist das Einzige, was eine Policy nicht braucht, um zu beurteilen, wohin es geht. Es ist dasselbe Zurückhalten, das die Befehlszeile anwendet, wenn sie den Graphen ausgibt, und das der Daemon anwendet, wenn er die Anfrage eines Editors danach beantwortet. Diese Oberflächen geben die Werte an eine Person zurück, die ausdrücklich danach fragt; die Kopie einer Policy bietet keine solche Anfrage. Es gilt nur für die Kopie der Policy: Der Graph, aus dem der Build rendert, bleibt unberührt, sodass sich kein gerendertes Byte ändert.

Die Labels einer Anbindung binden den Compiler an genau einer Stelle, und es ist keine Policy-Entscheidung: Ein Slot kann einen selector deklarieren, und eine Füllung, deren Labels ihn nicht erfüllen, hält den Build an. Jenseits dieser Prüfung steuern die Labels nichts — wie ein Wert weitergeleitet und zugestellt wird, ist dasselbe, welche Labels ein Feature auch trägt. Eine Policy, die ein Label liest, liest also Metadaten, die der Compiler ohne Interpretation weitergetragen hat, und stellt keine Verzweigung in ihm infrage.

Die Katalog-Annotationen eines Feature binden es an keiner Stelle: Kein Verhalten des Compilers verzweigt sich anhand ihrer, und ein Slot deklariert keine Einschränkung über sie, wie er es bei Labels kann. Sie werden getragen und sonst nichts.

Regeln, die dadurch formulierbar werden und von denen der Compiler keine für Sie aufstellt:

  • Freie Anbindung verbieten. Eine IT-Landschaft, die verlangt, dass jede Anbindung einen deklarierten Bindungspunkt füllt, lehnt jede Anbindung ab, die free meldet. Dies ist das Gegenstück dazu, dass die Anbindungsfläche offen bleibt: Die Komposition ist standardmäßig frei, und ein Operator, der sie nicht frei haben möchte, sagt das.
  • Zustellung sensiblen Materials als Wert ablehnen. Aggrega warnt, wenn ein als sensibel deklariertes Datum als Literal durch einen Zustellungsschlüssel wandert, und hält nie an — die Familie der Credentials als Wert ist beabsichtigt. Ein Operator, der diese Warnung zu einer Ablehnung machen möchte, drückt das hier aus.
  • Selbst entscheiden, was als Credential gilt. Die Standardbibliothek markiert ihre Credential-Features mit einem Familien-Label, und dieses Label zu lesen ist eine Möglichkeit, über sie zu urteilen. Ein breiteres oder engeres Prädikat — ein internes Label, eine Benennungsregel, eine Menge genehmigter Typen — steht gleichermaßen zur Verfügung, weil die Labels ankommen und nicht ein Urteil über sie.
  • Prüfungen auf alles stützen, was Ihr Katalog in seinen eigenen Metadaten festhält. Eine IT-Landschaft, die Prüfstatus, Datenresidenz oder Zuständigkeit als Annotationen an ihren Feature-Entitäten führt, kann sie für jede Anbindung verlangen. Eine Regel, die auf einer Annotation beruht, von der Aggrega nie gehört hat, funktioniert genauso gut wie eine, die auf einem mitgelieferten Schlüssel beruht, weil die Annotationen so ankommen, wie sie geschrieben wurden — was auch bedeutet, dass ein Feature und eine Component auf derselben Grundlage beurteilt werden, jeweils anhand der Katalog-Metadaten, die ihre eigene Entität deklariert.
  • Regeln, was eine Komponente wem präsentiert. Ein an einer Verbindung geschriebenes Credential benennt diese Verbindung, und die Kante der Verbindung benennt ihr Ziel, sodass eine IT-Landschaft ein Credential ablehnen kann, das einer Komponente außerhalb einer Vertrauenszone präsentiert wird, die sie mit einem eigenen Label markiert — ein Urteil, das beide Enden der Verbindung braucht und das kein Fakt an der konsumierenden Komponente allein liefert.

Eine Urteilsrolle nimmt an oder lehnt ab; sie schreibt nie um. Der Build läuft entweder unverändert weiter oder hält mit der Meldung des Urteils an, sodass eine Policy einen nicht konformen Graphen nicht stillschweigend konform machen kann.

Details der Anbindung erreichen eine Policy, die den IR-Graphen auswertet. Eine Policy, die gerenderte Artefakte auswertet, erhält diese Artefakte und keinen Graphen, was eine Eigenschaft dieser Eingabe ist und keine ihr auferlegte Einschränkung: Die beiden Stufen beantworten unterschiedliche Fragen, und die Topologie der Anbindungen gehört nicht zu den Fragen, die man gerenderter Ausgabe stellen kann.

Die Regeln der IT-Landschaft in einer Policy-Sprache ausdrücken

Die obigen Muster beschreiben, was eine Governance-Anbindung tut; in diesem Abschnitt geht es darum, was ein Unternehmen schreibt, um sie zu erhalten. Ein Plattformteam mit fünfzig zu formulierenden Regeln will keine fünfzig Plug-ins. Es will seine Regeln als Inhalt — Dateien, die es prüft, versioniert und ausliefert wie jedes andere Artefakt — mit einer angebundenen Engine, die sie auswertet.

Genau das bietet eine an den Socket angebundene Engine für eine Policy-Sprache, und zwei davon werden genau zu diesem Zweck im Compiler mitgeliefert: eine Rego-Engine und eine CEL-Engine. Ein Operator bindet eine an, deklariert die Policy-Dateien, die sie laden soll, und die Regeln laufen: keine externe Toolchain, nichts wird zur Build-Zeit abgerufen und keine Policy-Logik im Compiler. Die Auswertung erfolgt im WebAssembly-Gast, wo das gesamte Domänenwissen liegt.

Dieselbe Engine bedient jede Governance-Rolle, sodass eine IT-Landschaft ihre gesamte Oberfläche mit einem angebundenen Plug-in und mehreren Anbindungen davon abdeckt:

  • Die Architektur beurteilen. Über dem Build-Graphen angebunden, liest eine Policy jeden Knoten, jede Kante und jede Anbindung, die der Compiler hält, sowie die daneben aufgezählten Routing-Pfade, und meldet, was den Build stoppen muss. Hier sind eine Topologie-Invariante, eine grenzüberschreitende Autorisierungsregel oder eine Regel zum Credential-Fluss angesiedelt.
  • Die Ausgabe beurteilen. Über den gerenderten Artefakten angebunden, liest eine Policy die Dateien, die der Build erzeugt hat — als Text und als geparste Dokumente, wo das Format vor der Policy geparst wurde — und berichtet über das konkrete Ergebnis.
  • Abgeleitete Metadaten liefern. Zum Formen von Labels angebunden, entscheidet eine Policy, welche Labels die Knoten des Builds tragen, anhand der Umgebung des Release und dessen, was die Knoten bereits deklarieren. Dies ist der Mechanismus, den Muster 2 oben beschreibt, wobei die Regel als Policy-Inhalt statt als eigens gebautes Plug-in ausgedrückt wird.
  • Eine Fähigkeit hinzufügen, die der Entwickler nicht geschrieben hat. Zum Einfügen von Annotationen angebunden, fügt eine Policy den Komponenten des Builds Annotationen hinzu; eine Annotation unter einem Schlüssel, für den das Manifest ein Binding registriert, expandiert zu einer Feature-Anbindung, sodass eine Unternehmensregel die Hülle liefern kann, die eine Komponente braucht, statt ihr Fehlen lediglich abzulehnen. Eine Entscheidung schreibt jeden Wert, den ein Betreiber in diese Annotation schreiben könnte — eine Zeichenkette oder ein Objekt aus Unterschlüsseln für ein Binding, das mehrere weiterleitet —, und der Build liest ihn genau so, wie er denselben im Release geschriebenen Wert liest. Sie darf nur hinzufügen: Ein Wert, der eine Annotation entfernen oder abwählen würde, wird abgelehnt, und ein eingefügter Wert, den der Build nicht weiterleiten kann oder den das gebundene Feature nicht zulässt, wird unter Nennung des Plugins abgelehnt, das ihn eingefügt hat.

Eine Regel liest, was die Nutzlast trägt, und meldet ihre Entscheidung unter einem benannten Schlüssel:

# Evaluated by a governance verdict role over the assembled graph
package acme.security
import rego.v1
deny contains msg if {
some id, node in input.graph.spec.nodes
node.labels["compliance.aggrega.ai/data-class"] == "restricted"
not node.labels["acme.com/owner"]
msg := sprintf("node %v holds restricted data and declares no owner.", [id])
}

Eine Regel, die Daten entlang des Graphen folgt, liest die Routen, die die Nutzlast aufzählt. language-reference/examples/policy-data-class-route/ ist eine solche, durchgängig: Sie hält einen Build an, in dem eine Komponente, die Daten einer Klasse hält, eine Komponente einer anderen Klasse über eine Route erreicht, an der kein deklassifizierendes Feature angebunden ist, und dasselbe Aggregate wird abgeschlossen, wenn ein Release diesen Datenverkehr durch ein Gateway leitet, das core/data-masking trägt. Der Compiler trägt das Klassen-Label als Zeichenkette und ordnet nichts — die Klassen, ihre Reihenfolge und die Features, die als deklassifizierend gelten, sind die Einstellungen der Anbindung. Die Regel ist für jede von drei Engines einmal geschrieben — die zwei in die CLI kompilierten und OPA hinter dem Referenz-Adapter-Gast —, jede Kopie für sich, sodass ein Build, bei dem zwei Engines uneins sind, die Uneinigkeit zeigt.

Das eigene Vokabular einer Policy bleibt erhalten. Die Schweregrade, auf die der Socket reagiert, sind eine geschlossene Menge, aber die Namen, unter denen eine Policy ihre Entscheidungen sammelt, gehören der Policy. Die Standardnamen sind die konventionellen, die ein Rego-Korpus bereits verwendet, und ein Operator, dessen Policies ihre Entscheidungen anders benennen, deklariert die Zuordnung in den Einstellungen der Anbindung — sodass eine IT-Landschaft, die bereits eine Policy-Bibliothek pflegt, den Socket übernimmt, ohne sie umzuschreiben. Die Zuordnung ist durch das Schema typisiert, das das Plug-in für seine Einstellungen deklariert, sodass eine fehlerhafte Zuordnung den Build anhält, bevor eine Policy läuft, statt ein Urteil falsch weiterzuleiten.

Eine ganze Policy-Bibliothek reist als eine Anbindung. Ein Policy-Satz kann Datei für Datei angebunden werden oder als ein einzelnes Archiv, das seine Policy-Dateien und seine Datendokumente zusammen enthält und das der Gast öffnet. Ein Archiv, das nicht gelesen werden kann, wird als solches gemeldet, unter Nennung der Datei — niemals als Policy-Satz, der zu keiner Entscheidung gelangt ist, denn „die Bibliothek war unlesbar“ darf nie ununterscheidbar sein von „die Bibliothek hat den Build zugelassen“.

Eine nicht auswertbare Policy stoppt den Build. Wenn eine Policy nicht ausgewertet werden kann, schlägt die Anbindung fehl und der Build hält mit einem Fehler an, der das Plug-in benennt, bewusst unterschieden von einem Urteil, das den Build stoppt. Die beiden Fälle dürfen nicht verwechselt werden, und keiner von beiden ist eine Zulassung.

Die vollständige Autorenoberfläche — die Nutzlast, die jede Rolle bereitstellt, die Entscheidungsschlüssel, die Zuordnung auf Schweregrade und wie ein Archiv angebunden wird — steht in language-reference/plugins/policy-socket.md.

Vererbung und Veröffentlichungsdisziplin

Vererbung über extends: ist der Katalogmechanismus, mit dem Plattformarchitekten spezialisierte Kindentitäten auf gemeinsamen Baselines aufbauen. Die beiden Katalogarten gehen bei ihren Datensäulen getrennte Wege. Die Eltern- und Kindschemata eines Feature werden beim Laden des Workspace zusammengesetzt und ergeben ein vereinheitlichtes Schema mit Provenienz pro Blatt. Eine erweiternde Component schreibt keinen Säuleninhalt: Sie schreibt die wörtliche Markierung schema: inherited und erhält den schema:-Block ihrer Basis genau so, wie die Basis ihn geschrieben hat, in jeder Tiefe einer Kette.

Damit ist die Governance-Frage geklärt, die eine gemeinsame Baseline aufwirft — welche Einschränkungen ein Kind relativ zu seiner Basis deklarieren darf. Für eine Component ist die Antwort strukturell statt überwacht: Der deklarierte Vertrag des Kindes ist einfach der der Basis, sodass eine Einschränkung der Basis von einem Kind nicht gelockert, entfernt oder umtypisiert werden kann, und keine Prüfung zur Veröffentlichungszeit nötig ist, um die Baseline intakt zu halten. Ein Kind, das legitimerweise eine strengere Regel braucht, als seine Basis deklariert, drückt dies als zusätzlichen Eintrag in seinem assertions:-Block aus, der neben den Regeln der Basis zusammengesetzt wird, statt sie zu ersetzen.

Was eine Kind-Component zusammensetzt, ist die Struktur: Ihre Anbindungs-Slots (featuresSchema), Topologie-Sockets (usesSchema), die Self-Inject-Allowlist (inject) und benannten assertions werden alle entlang der Kette zusammengeführt, wobei ein erneut deklarierter Eintrag den der Basis vollständig ersetzt.

Regelplatzierung: Welche Regeln im Policy-Plug-in und welche im Schema pro Component liegen

Das Plug-in für Veröffentlichungsdisziplin ist der Ort für übergreifende Regeln, die katalogweit gelten: Lieferkettenregeln (z. B. „jedes Recipe muss mit implements: eine Component implementieren, die im Katalog existiert“), Compliance-Regeln des Unternehmens (z. B. „jede Component mit compliance.aggrega.ai/scope: pci-dss muss mit extends: die unternehmensweite pci-Baseline erweitern“). Diese Regeln erstrecken sich über mehrere Entitäten, werten den Workspace als Einheit aus oder setzen Konventionen zur Veröffentlichungszeit statt zur Build-Zeit durch.

Die schema:-Deklaration pro Component / pro Feature ist der Ort für Einschränkungen pro Entität: Typen, Bereiche, Muster und Enums pro Feld; feldübergreifende Regeln, ausgedrückt im eigens dafür vorgesehenen assertions:-Block. Diese Einschränkungen sind lokal für eine Entität und wandern mit ihr durch den Katalog.

Die Aufteilung ist nicht willkürlich. Eine Regel wie „jedes Pflichtfeld muss vorhanden sein“ ist eine Einschränkung pro Entität, die in required:-Arrays gehört. Eine Regel wie „jede Kindentität, die einen pci-dss-Elternteil erweitert, muss ein Governance-Label auf Workspace-Ebene deklarieren“ ist eine entitätsübergreifende Regel, die das Policy-Plug-in durchsetzt. Die beiden Regelklassen überschneiden sich nie, weil sie unterschiedliche Fragen beantworten: Das Schema prüft „entspricht diese Instanz ihrem Vertrag“; das Policy-Plug-in prüft „erfüllt dieser Katalog die übergreifenden Regeln, die der Workspace verlangt“.

Beim Schreiben einer neuen Governance-Regel lautet die Platzierungsfrage: Hängt die Regel nur vom Inhalt einer einzelnen Entität ab (→ Schema- oder assertions-Block), oder hängt sie von der Beziehung zwischen mehreren Entitäten oder von einer Konfiguration auf Workspace-Ebene ab (→ Policy-Plug-in). Das Wasm-Linter-Muster ist der kanonische Mechanismus für den übergreifenden Fall; Unternehmenskataloge können eigene Policy-Plug-ins verteilen, die dieselbe Schnittstelle des Plug-in-Vertrags nutzen wie das Standard-Plug-in für Veröffentlichungsdisziplin.

Disziplin bei Annotationspräfixen

Der Annotations-Namespace trägt eine Herkunftssemantik — unterschiedliche Präfixe signalisieren unterschiedliche Zielgruppen und unterschiedliche Governance-Instanzen. Katalogautoren, Plattformteams in Unternehmen und die Aggrega-Plattform selbst schreiben Annotationen alle in dasselbe flache Wörterbuch; erst das Präfix hält die Zielgruppen auseinander.

PräfixHerkunftZielgruppeVeränderbarkeit
aggrega.ai/ (ohne Subdomain)Reserviert: wird ausschließlich vom Aggrega-Compiler ausgegebenInternes Tooling, HerkunftsstempelNicht vom Benutzer schreibbar; Annotationen mit dem Präfix ohne Subdomain, die in Benutzerinhalten deklariert werden, werden zum Veröffentlichungszeitpunkt abgelehnt
<sub-domain>.aggrega.ai/ (z. B. component.aggrega.ai/, feature.aggrega.ai/, compliance.aggrega.ai/)KatalogkonventionArchitekten, die Katalogentitäten schreiben; Wasm-Policy-Plugins, die die Labels konsumierenKatalogherausgeber schreiben; Konsumenten lesen
<enterprise-domain>/ (z. B. acme.com/, my-org.io/)Unternehmens-OverlayPlattformteams in Unternehmen; Wasm-Plugins von UnternehmenUnternehmensautoren schreiben; der Plattform-Compiler ignoriert sie als opake Metadaten
<community-domain>/ (z. B. cncf.io/, kubernetes.io/)Externes ÖkosystemÖkosystemübergreifendes Tooling, das bekannte Labels liestVon der Community verwaltet

Das Präfix aggrega.ai/ ohne Subdomain unterliegt der strengsten Disziplin: Es ist ausschließlich für von der Plattform ausgegebene Annotationen reserviert. Der Compiler gibt aggrega.ai/compiler-version, aggrega.ai/component-id, aggrega.ai/recipe-uri, aggrega.ai/boundary-path und verwandte Herkunftsschlüssel in der gerenderten Ausgabe aus; Benutzerinhalte, die eine aggrega.ai/<key>-Annotation direkt deklarieren, werden zum Veröffentlichungszeitpunkt abgelehnt. Die Disziplin verhindert, dass vom Benutzer geschriebene Annotationen mit von der Plattform ausgegebenen Herkunftsangaben kollidieren.

Subdomain-Präfixe unter <sub-domain>.aggrega.ai/ bilden den Raum der Katalogkonventionen. Die Standardbibliothek verwendet component.aggrega.ai/type (das Label der Cloud-native-Ontologie), feature.aggrega.ai/kind (die Aufteilung der Feature in operativ und Credential), compliance.aggrega.ai/* (die Labels der Compliance-Achse) und ähnliche abgegrenzte Sub-Namespaces. Jede Subdomain wird von einer bestimmten Katalog-Zielgruppe verwaltet: component.aggrega.ai/* von den Autoren der Component-Entitäten, feature.aggrega.ai/* von den Autoren der Feature-Entitäten, compliance.aggrega.ai/* von der Zielgruppe der Compliance-Policies. Subdomain-übergreifende Lesezugriffe (ein Wasm-Plugin, das aus mehreren Sub-Namespaces liest) sind erlaubt, aber selten; jedes Plugin beschränkt sich typischerweise auf einen Sub-Namespace.

Präfixe von Unternehmensdomains (acme.com/..., my-org.io/...) bilden die Erweiterungsfläche der Plattform. Der Aggrega-Compiler behandelt sie als opake Metadaten; Wasm-Plugins von Unternehmen konsumieren sie. Unternehmen schreiben jede Präfixstruktur, die zu ihrer Governance passt — flach (acme.com/owner: team-payments), als Subdomain (security.acme.com/scope: pii) oder hierarchisch (org.acme.com/billing-center: finance). Die Plattform schränkt den Aufbau von Unternehmenspräfixen nicht ein; die einzige Regel ist, dass Unternehmenspräfixe nicht mit aggrega.ai/ oder dessen Subdomains kollidieren.

Die Disziplin ist wichtig, weil Annotationen kaskadieren — Annotationen, die am Subsystem eines Aggregate geschrieben werden, werden an jede Komponente des Subsystems weitergegeben, die eigenen Annotationen einer Komponenteninstanz haben Vorrang vor denen ihres Subsystems, und die Annotationen eines Moduls erreichen die eigenen Komponenten des Moduls; Annotationen an einer Boundary eines Release werden an jede Komponente der Boundary weitergegeben. Eine Provider-Annotation erreicht die gerenderte Ausgabe von beiden Seiten aus, und wo beide denselben Schlüssel schreiben, wird der Wert des Release angewendet. Ohne Präfixdisziplin könnte eine Annotation auf Seiten des Aggregate stillschweigend einen von der Plattform ausgegebenen Herkunftsschlüssel überschreiben, oder eine Unternehmensannotation könnte mit einem Schlüssel einer Katalogkonvention kollidieren. Die Präfixtabelle macht die Zielgruppen explizit und die Regel zur Kollisionsvermeidung zum Veröffentlichungszeitpunkt durchsetzbar.

Siehe language-reference/vocabulary/labels-and-annotations.md für die Aufzählung der Annotationsflächen je Entität und die Kaskadensemantik der drei Buckets (.context.annotations.release / .context.annotations.catalog / .context.annotations.aggregate).