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

provides, inject, uses

Der Injection-Vertrag und die vorab aufgelöste Map

Da Aggrega ein statischer Compiler mit Vorabkompilierung (AOT) ist, fließen während der Kompilierung keine Daten aus der laufenden Infrastruktur zurück. Es ist mechanisch unmöglich, dass der Compiler aktiv eine physische Anmeldeinformation (etwa ein AWS-Secret) abruft und sie „zurück“ an die Container-Umgebung des Entwicklers übergibt.

Stattdessen stützt sich die Plattform auf echte Kontrollumkehr. Wenn ein Entwickler inject: { env: [{ in: ORACLE_PASSWORD, from: "password" }] } schreibt, löst er keinen Datenabruf aus; er diktiert der Infrastruktur einen strikten Vertrag.

  1. Die Absicht (Domäne 1): Der Entwickler deklariert eine abstrakte Schnittstelle: „Ich benötige ein Secret. Ich weiß nicht, wo es liegt. Injiziere es einfach als ORACLE_PASSWORD in meine Umgebung, abgebildet auf den Schlüssel password des Katalogs.“
  2. Die Übergabe durch den Compiler (beim Rendern): Der Go-Compiler nimmt den Eintrag { in: ORACLE_PASSWORD, from: "password" } und übergibt ihn an das Ops-Recipe. Es wird kein physisches Secret abgerufen.
  3. Die Plugin-Ausgabe (Domäne 3): Die Wasm-Pipeline des FeatureRecipe für Anmeldeinformationen erzeugt genau die ineinandergreifenden Artefakte, die die Zielinfrastruktur benötigt. In Kubernetes gibt sie zum Beispiel die CRD ExternalSecret aus (die den Cluster anweist, die Vault-Daten abzurufen) UND führt einen JSONPatch gegen den Ziel-Pod aus, um das resultierende lokale K8s-Secret gezielt auf die vom Entwickler angeforderte Umgebungsvariable "ORACLE_PASSWORD" abzubilden.
  4. Die Laufzeitrealität: Zur Laufzeit führt ein Operator im Cluster diese generierten Artefakte einfach aus—er ruft die Anmeldeinformation ab und bindet sie physisch in den Container ein—und entkoppelt so die physische Sicherheitsmechanik vollständig vom AOT-Compiler.

Um diese physische Realität an die Anwendung zu liefern, ohne die Trennung der Zuständigkeiten zu verletzen, nutzt Aggrega den Injection Contract. Dieser Vertrag unterscheidet jedoch strikt zwischen eigenem Anwendungscode und handelsüblicher Standardinfrastruktur (COTS):

  • White-Box (eigener Code): Die Komponente ist ein generischer Worker (z. B. ein eigener Python-Agent). Der Go-Compiler und das Ops-Recipe haben keine Ahnung, welche Variablen das eigene Skript des Entwicklers erwartet. Deshalb diktiert der Entwickler die Zustellung über den Block inject: überall dort, wo der Code Namen liest, die sein Recipe nicht standardmäßig zustellt — sowohl für komponentenübergreifende Abhängigkeiten (über uses[].inject mit from:, das auf die provides des Ziels verweist) als auch für die eigenen Werte der Komponente (über inject auf Komponentenebene mit Literalen value: oder from:, das auf die eigenen provides verweist). Welche Mechanismen erlaubt sind, wird pro Oberfläche deklariert, und die beiden Deklarationen sind getrennt: Die eigenen Werte der Komponente werden durch die Allowlist spec.inject geregelt (z. B. inject: ["env", "file"]), während eine Kante uses: durch die Allowlist des Sockets geregelt wird, über den sie verdrahtet ist, spec.usesSchema.<socket>.inject. Einen Mechanismus zu diktieren, den die maßgebliche Allowlist nicht nennt, bricht den Build auf beiden Oberflächen ab.
  • Black-Box (paketierte Rechenleistung): Die Komponente ist ein geschlossenes System (z. B. Redis, ein verwaltetes API Gateway). Das Ops-Recipe weiß bereits genau, wie das System seine Daten konsumiert. Deshalb verzichtet die Katalogentität der Component auf die Allowlist, was das Diktieren ganz verbietet, statt es einzuschränken — spec.inject wegzulassen verbietet den Self-Inject auf Komponentenebene, und ein Socket, der ohne Allowlist inject: deklariert ist, verbietet jeden Block inject: an einer Kante, die über ihn verdrahtet ist. Der Entwickler stellt einfach das Abhängigkeitsziel über uses bereit, und die Plattform übernimmt die interne Verdrahtung nativ über das valuesMapping des Recipe.

Die Regel der deterministischen Adressierung (Physik des internen Netzwerks) Die Pipe .context.uses von Aggrega injiziert Ziel-Strings zur Compile-Zeit dynamisch in Container. Da der Go-Kern-Compiler vollständig agnostisch gegenüber physischer Vernetzung ist, hängt das, was als gültiger Adress-String gilt, ganz von einem Gesellschaftsvertrag ab, den Platform Ops aufrechterhält, nicht von einer Funktion des Compilers — der Compiler leitet jeden deterministischen Zeiger-String, den das Ops-Recipe erzeugt hat, ohne Interpretation in den nachgelagerten Template-Kontext weiter.

Die Regel: Das Ops-Recipe muss einen deterministischen, stabilen Adresszeiger exportieren. Der Provider berechnet keine IPs. Stattdessen sollte das Ops-Recipe des Ziels einen vorhersagbaren String formulieren und ihn über seinen Vertrag provides: bereitstellen (z. B. durch Veröffentlichen von provides.internal_host: "http://agent-b.namespace.svc.cluster.local" in Kubernetes oder eines Interpolations-Strings wie "${module.db.endpoint}" in Terraform, wo das Modul einen passenden output für den Wert deklariert).

Sich darauf zu verlassen, dass der Compiler dynamische IPs nach dem Provisioning abruft, verletzt unmittelbar das AOT-Ausführungsmodell. Da der Compiler die Topologie auswertet, bevor die Cloud tatsächliche Rechenleistung bereitstellt, kann er physisch keine Daten abrufen, die noch nicht existieren. Wenn ein Dienst eine zufällige IP benötigt, die erst nach dem Hochfahren der Rechenleistung erzeugt wird, kann der Compiler sie physisch nicht abrufen. Die einzige Aufgabe des Compilers besteht darin, den deterministischen Zeiger-String, den das Ops-Recipe liefert, wortgetreu in die Umgebungsvariablen des aufrufenden Containers weiterzuleiten und die endgültige Auflösung dem DNS des Clusters oder dem aktiven IaC-State-Manager zu überlassen.

Deterministische Adressierung nativ durchzusetzen, löst zyklische Abhängigkeiten (z. B. delegiert Agent A an Agent B, und Agent B delegiert zurück an Agent A). Da die stabile URL oder der IaC-Zeiger als String berechenbar ist, bevor einer der beiden Container tatsächlich startet, verdrahtet der Compiler beide Agenten sicher miteinander, ohne zeitliche Race Conditions einzuführen.

(Hinweis: Diese Regel gilt auch für externen Ingress. Wenn eine Architektur ein öffentliches API Gateway bereitstellt und verlangt, dass dessen URL zurück in einen internen Container injiziert wird, kann der Go-Compiler die zufällige, von der Cloud erzeugte URL (z. B. xyz123.execute-api.aws.com) nicht abrufen, weil sie zur Compile-Zeit nicht existiert. Ops muss sein Recipe so verfassen, dass es entweder eine deterministische eigene Domain (z. B. api.enterprise.com) abbildet oder den nativen IaC-Interpolations-String exportiert, damit der AOT-Compiler eine bekannte Referenz hat, die er sicher injizieren kann).

Die Implementierungsmechanik (der Katalog als API-Vertrag) Um dies umzusetzen, ohne Entwickler eng an Ops zu koppeln, verwendet Aggrega den Plattformkatalog (Domäne 2) als strikten API-Vertrag und nutzt dabei drei unterschiedliche Validierungsebenen:

  1. Das Feature-Schema für Anmeldeinformationen (mit dem Label feature.aggrega.ai/kind: secret): Validiert NUR die Vault-Abfrage (path, key). Es ist vollständig agnostisch gegenüber der Art, wie der Container die Daten konsumiert.
  2. Das Schema Component (Allowlist spec.inject): Setzt die Black-Box/White-Box-Regel über das Feld spec.inject durch. Ist spec.inject vorhanden (z. B. inject: ["env", "file"]), darf der Entwickler Self-Inject auf Komponentenebene mit diesen Zustellmechanismen verwenden. Fehlt spec.inject, verbietet der Compiler Self-Inject strukturell — Black-Box-Komponenten verlassen sich für die interne Verdrahtung vollständig auf das valuesMapping des Recipe. Der Build setzt dies durch, wenn er das Aggregate auflöst: Er lehnt den Block inject: der Komponente ab und nennt den Mechanismus, getrennt von der Inhaltsvalidierung pro Säule unter schema:.
  3. Die Map featuresSchema: Im Component-Katalog definiert, deklariert sie ausdrücklich die Slots für Anmeldeinformationen, die der Entwickler verwenden muss (oder kann). Jeder Eintrag gibt required (Standard false), die Allowlist inject ([] = Blackbox, [env, file] = transparent) und description an. Da diese Schlüssel stabil und vertraglich garantiert sind, kann sich der Ops-Ingenieur direkt auf sie verlassen, um in seinem Go-Template zuverlässig deterministische Ziele vorzugeben (z. B. existingSecret: "{{ .context.rendered_name }}-{{ .locals.secret_target_admin_password }}" auf dem Ziel helm), wobei er das Suffix des Namens ausdrücklich über .locals exportiert — ein Local kann .context.rendered_name nicht lesen —, sodass das nachgelagerte FeatureRecipe für Anmeldeinformationen dieselben zwei Teile zusammenfügt und die Anforderung erfüllt, ohne die AOT-Ausführungsreihenfolge zu verletzen. Siehe entities/component.md für das vollständige Design von featuresSchema.

Die strenge Platzierungsregel: Der Mechanismus inject: ist an drei Stellen im Aggregate des Entwicklers verfügbar:

  1. Self-Inject auf Component-Ebene: Als direktes Geschwister von values: auf einer Komponenteninstanz. Injiziert die eigenen Literalwerte der Komponente oder ihre eigenen Schlüssel aus provides in die Zustellungs-Pipe. Nur zulässig, wenn der Component-Katalog spec.inject mit den entsprechenden Mechanismen deklariert.
  2. Cross-Inject auf uses-Ebene: Innerhalb expliziter Zieldefinitionen im Block uses:. Injiziert die Schlüssel aus provides eines Abhängigkeitsziels in die Zustellungs-Pipe.
  3. Inject auf Feature-/Secret-Ebene: Als Geschwister von values: beim Anhängen von Funktionen und Secrets. Injiziert die eigenen aufgelösten Schlüssel aus provides des Anhangs — die aufgelöste Anmeldeinformation für ein Secret oder die bereitgestellten Werte einer Funktion — in die Zustellungs-Pipe.

Alle drei Formen befüllen dieselbe Pipe .context.inject. Das Recipe liest eine einzige, vereinheitlichte Pipe, unabhängig davon, wie viele Quellen dazu beigetragen haben.

Das Schema von inject definiert Standard-Enums (env, file, arg) für Werkzeuge, lässt additionalProperties aber offen, sodass ein eigener Mechanismus benannt werden kann (z. B. ssm_param für AWS Systems Manager Parameter Store). Ein Name ist vergeben: all ist die zusammengeführte Sicht auf alle Mechanismen, die ein Recipe unter .context.inject.all liest, daher hält ein inject-Block, der einen Mechanismus all nennt, den Build an der Dokumenthülle an und weist darauf hin.

Syntax der inject-Einträge: In einem Block inject ist jeder Zustellungsmechanismus — env, file, arg oder ein eigener — eine Liste von Einträgen, und jede Platzierung verwendet dieselbe Eintragsform. Das Schlüsselwort, das ein Eintrag trägt, und nicht die Platzierung, in der er steht, sagt, was sein String ist, sodass sich ein Eintrag überall gleich liest, wo er auch erscheint. Ein Mechanismus, der als Map statt als Liste geschrieben ist, oder ein Eintrag, der beide Schlüsselwörter trägt, bricht den Build an der Dokumenthülle des Aggregate ab und nennt den Pfad im Aggregate, an dem die Form falsch ist.

Schlüsselwörter der Einträge (from: und value:): Jeder Eintrag verwendet das Schlüsselwort in für den lokalen Bezeichner — einen Umgebungsvariablennamen, einen Dateipfad, ein Argument-Flag — sowie genau eines von from: (Referenz auf einen provides-Schlüssel) oder value: (Literal-String). Ein from: wird gegen die provides des Knotens aufgelöst, den seine Platzierung nennt: die eigenen der Komponente in component.inject, die des Ziels in uses[target].inject und die eigenen des Anhangs in features[<name>].inject:

SchlüsselwortBedeutungZulässig in component.injectZulässig in uses[].injectZulässig in features[<name>].inject
from:Wird gegen provides aufgelöst✅ provides des eigenen Knotens✅ provides des Zielknotens✅ Eigene provides des Attachments
value:Literal-String (unterstützt Go-Templates)✅❌ (value: ist in uses[].inject nicht gültig; verwenden Sie für Self-Inject inject auf Komponentenebene)❌ (value: hält den Build im inject eines Attachments an; verwenden Sie inject auf Komponentenebene für Self-Inject)

Beispiele:

# Component-level self-inject (White-Box custom code)
components:
my-worker:
type: core/python-worker:1.0.0
values:
app_token: "xyz"
inject:
env:
- in: MY_TOKEN
value: "xyz" # Literal value
- in: LOG_LEVEL
value: "debug" # Literal value
- in: CALLBACK_HOST
from: "host" # From own provides (already evaluated)
- in: APP_VERSION
value: '{{"{{"}} .values.app_token }}' # Go template expanding own values
uses:
databases:
my_db:
target: postgres-db
inject:
env:
- in: DB_HOST
from: "host" # Provides key from target
- in: DB_PORT
from: "port" # Provides key from target
- in: DB_URL
from: "dsn" # From target's provides

Das Template im value: von APP_VERSION beginnt mit {{"{{"}} statt mit {{: Der gesamte Text des Aggregate wird einmal als Template gelesen, zur Parameterinterpolation, bevor die Self-Inject-Auflösung läuft, und .values existiert zu diesem Zeitpunkt nicht, sodass das Escape {{ wieder einsetzt, damit die Self-Inject-Auflösung es auswertet. Siehe Text mit eigenen doppelten geschweiften Klammern.

Provider-spezifischer Hinweis (compose). Wenn Kanten uses: zwischen auf compose ausgerichteten Knoten aufgelöst werden, leitet der compose-Provider aus diesen Kanten Einträge depends_on ab. Diese Einträge verwenden immer die Semantik service_started, unabhängig vom Block health: eines Ziels; sie an die Gesundheit des Ziels zu knüpfen, ist nicht implementiert. Siehe providers/compose.md für die vollständigen Inferenzregeln.

Die Kollisionsregel für inject-Schlüssel: Fordert ein Entwickler denselben Zustellungsschlüssel (z. B. denselben Namen einer Umgebungsvariable) aus zwei verschiedenen Quellen an, ist das ein fataler Fehler, keine Zusammenführung. Der Compiler erkennt die Kollision und bricht den Build ab:

Quelle AQuelle BErgebnis
component.injectuses[].inject❌ fataler Abbruch — doppelter Zustellungsschlüssel
uses[target_A].injectuses[target_B].inject❌ fataler Abbruch — doppelter Zustellungsschlüssel
component.injectfeatures[<name>].inject❌ fataler Abbruch — doppelter Zustellungsschlüssel
uses[].injectfeatures[<name>].inject❌ fataler Abbruch — doppelter Zustellungsschlüssel
features[A].injectfeatures[B].inject❌ fataler Abbruch — doppelter Zustellungsschlüssel
component.inject (derselbe Schlüssel zweimal)—❌ fataler Abbruch — doppelter Zustellungsschlüssel
injectMapping des FeatureRecipe von features[A]injectMapping des FeatureRecipe von features[B]❌ fataler Abbruch — doppelter Zustellungsschlüssel über zwei Anhänge hinweg
features[A].injectinjectMapping des FeatureRecipe von features[B]❌ fataler Abbruch — doppelter Zustellungsschlüssel über zwei Anhänge hinweg
component.inject oder uses[].injectinjectMapping des FeatureRecipe✅ Zulässig — Abfangen ist so vorgesehen: Der Wert des Mappings ersetzt diesen Eintrag

Die Tabelle gilt für jedes angehängte Feature gleichermaßen, wo auch immer es angehängt wurde — an der Komponente, an einem Subsystem oder einer Release-Boundary, durch die Expansion einer Annotation oder an einer Verbindung. Das injectMapping eines FeatureRecipe rendert, nachdem jeder Block inject: zugestellt hat, und ist daher immer der spätere zweier Ansprüche: Es darf umschreiben, was die Komponente oder eine ihrer Verbindungen zugestellt hat, und es darf umschreiben, was der Block inject: seines eigenen Anhangs zugestellt hat, aber ein Schlüssel, den ein anderes angehängtes Feature bereits zugestellt hat, bricht den Build ab und nennt beide.

Ein an eine Release-Boundary angehängtes Feature, dessen FeatureRecipe einmal für die Boundary rendert (executionScope: boundary), erreicht die Komponenten, die die Boundary enthält, auf demselben Weg: Sein injectMapping läuft einmal für jede von ihnen, im Kontext dieser Komponente, und unterliegt den obigen Zeilen wie jedes andere Mapping. Die compose-Bridge, die die Host-Variable eines Konsumenten umschreibt, damit er sein Ziel über sein Gateway erreicht, ist ein solches Mapping, sodass ein anderes angehängtes Feature, das dieselbe Variable zugestellt hat, den Build abbricht und beide nennt.

Um Go-Template-Boilerplate in Recipes zu vermeiden, stellt der Compiler beides bereit:

  • .context.uses: Die angereicherte Map der topologischen Kanten (für komplexe Logik, Secret-Referenzen und Herkunftsverfolgung).
  • .context.inject: Ein vorab aufgelöstes, abgeflachtes Dictionary, in dem der Compiler bereits alle inject-Quellen (Self-Inject-Literale, Self-Inject-Referenzen auf provides und komponentenübergreifende Referenzen auf provides) in endgültige String-Werte aufgelöst und anschließend die FeatureRecipe-Abfangungen über injectMapping angewendet hat.

Der Injektionskontext mit doppeltem Zustand (Null-Sicherheit vs. Reinheit der Absicht) Beim Erzeugen von Konfigurationen für Modifikatoren (das FeatureRecipe, das an einen beliebigen Anhang gebunden ist, ob für Anmeldeinformationen oder nicht) muss der Compiler die Nullzeiger-Sicherheit für Go-Templates, das dynamische Netzwerk-Routing und die Bewahrung eines fähigkeitsagnostischen Graphen ausbalancieren. Dazu stellt der Compiler dem Template einen Kontext mit doppeltem Zustand bereit:

  • .inject_raw (die unveränderliche Absicht): Stellt den eigenen Block inject: der Komponente genau so dar, wie der Entwickler ihn in Domäne 1 verfasst hat. Er ist unveränderlich. Hat der Entwickler den Block weggelassen, ergibt dies null. Ops verwendet dies gezielt für logische Prüfungen (z. B. {{ if not .inject_raw }}, um Fallback-Verhalten anzuwenden). Da er unveränderlich ist, schützt er Ops-Templates vor falsch positiven Ergebnissen, wenn Routing-Funktionen die physische Zustellungs-Pipe abfangen und verändern.
  • .context.inject (die vorab hydrierte und abgefangene Pipe): Ein paralleles, vom Compiler erzeugtes Struct, das die physische Zustellungsrealität darstellt. Es beginnt als vorab hydrierte Map (z. B. wird API_HOST auf den Basis-String des Ziels "backend-instance" abgebildet). Entscheidend ist, dass diese Pipe dafür ausgelegt ist, von Features (z. B. Netzwerk-Routing) über den Block injectMapping abgefangen und tief zusammengeführt zu werden. Bis das Basis-Recipe rendert, enthält diese Pipe die vollständig formatierten, physisch korrekten Strings (z. B. einen korrekten vollständigen Netzwerknamen wie "backend-instance.backend-zone.svc.cluster.local"). Ihr Inhalt ist als env, file, arg strukturiert (plus alle eigenen Zustellungsmechanismen, die die inject-Allowlists der Component zulassen), mit einem vorab zusammengeführten Dictionary .all, das alle Mechanismen für eine bequeme Serialisierung der gesamten Pipe kombiniert.
  • .context.self_inject (Welchen eigenen Wert jeder Name liefert): Wird aus demselben inject:-Block auf Komponentenebene gelesen wie .inject_raw, in der Form, in der .context.uses.<alias>.inject die Namen einer Verbindung angibt: Pro Mechanismus wird jeder Name, den der Entwickler geschrieben hat, dem eigenen Schlüssel der Komponente zugeordnet, den sein Eintrag liefert — provides.<key> für einen from:-Eintrag, values.<key> für ein value:-Template, das genau einen der eigenen Werte der Komponente liest und sonst nichts, und eine leere Zeichenkette für alles andere (ein Literal, zwei Werte, ein Lesen von etwas anderem als den Werten). Damit kann ein Recipe, das das eigene Image des Entwicklers ausführt, die eigenen Variablennamen als Standardwerte behandeln — es liefert einen eigenen Wert nur dann unter seinem Standardnamen, wenn noch kein Eintrag auf values.<key> abgebildet ist, sodass ein Entwickler, der einen Wert umbenennt, alle anderen Standardwerte behält. Das ist die Konvention des Standardbibliothekskatalogs, keine Compiler-Regel; ein Unternehmenskatalog kann die eigenen Werte seiner Komponenten liefern, wie er es wählt.

Ops verwendet das Struct .context.inject ausschließlich für sichere Serialisierung (z. B. {{ toJson .context.inject.all }}) und die Erzeugung des Routings, sodass die physische Infrastruktur die vollständig aufgelösten Koordinaten erhält, während die ursprüngliche Absicht des Entwicklers in .inject_raw vollkommen unverändert bleibt.

YAML-Beispiel des Entwicklers (granulare Map):

uses:
databases:
my-postgres-cluster:
target: db-main
inject:
ssm_param: # Agnostic injection paradigm (AWS Systems Manager)
- in: MY_DB_HOST # Local identifier
from: "host" # Target provides key

Der Compiler löst dies zur Kompilierzeit auf (Abbildung auf statische Strings oder interne DNS-Namen) und übergibt die beiden Objekte an das Recipe:

"context": {
"uses": { ... raw graph ... },
"inject": {
"all": { "MY_DB_HOST": "db-main.internal" },
"ssm_param": { "MY_DB_HOST": "db-main.internal" }
}
}

Verbindungsbezogene Konfiguration (values und infra). Über die Zustellung der provides eines Ziels über inject hinaus kann eine Kante ihre eigene Konfiguration tragen — Einstellungen pro Verbindung, die das konsumierende Recipe aus der angereicherten Topologie-Pipe liest:

  • .context.uses.<alias>.values — vom Entwickler verfasst, im ausführlichen Eintrag uses des Aggregate deklariert, gegen das valueSchema des Sockets validiert.
  • .context.uses.<alias>.infra — vom Operator verfasst, im Release deklariert, gegen das infraSchema des Sockets validiert.

Der Socket (usesSchema[<socket>]) ist der Vertrag des Architekten darüber, welche Verbindungen möglich sind und welche Konfiguration sie tragen dürfen; values und infra teilen diese Konfiguration nach Authoring-Domäne auf, analog zur Aufteilung values/infra bei Komponenten. Eine Kante hat also zwei Autoren: Der Entwickler verdrahtet die Topologie und stimmt sie mit values im Aggregate ab, während der Operator infra pro Verbindung im Release festlegt, innerhalb der Sockets, die der Architekt deklariert hat. Das Release darf außerdem eine Kante in einen deklarierten, aber ungebundenen Socket zu einer bestehenden Komponente verdrahten; es darf eine vom Entwickler deklarierte Kante nicht auf ein anderes Ziel umlenken — siehe entities/release.md §„Per-edge connection configuration (Verbindungskonfiguration pro Kante)“.

Die Konfiguration pro Kante ist konsumentenbezogen: Sie erscheint nur im Kontext des Knotens, der die Kante verfasst hat (der Quelle der Verbindung), nie im Kontext des Ziels. Die eigene gerenderte Ausgabe eines Ziels ist daher invariant gegenüber den Konsumenten, die sich mit ihm verbinden. Ein an das Ziel angehängtes Feature ist der einzige Ort, an dem die Verbindungen sichtbar sind: Sein FeatureRecipe liest unter .context.used_by, welche Komponenten das Ziel verwenden — für jede ihre Identität, ihren Socket, ihre veröffentlichten provides, den Namespace und die Boundary, in denen sie platziert ist, und, für ein FeatureRecipe, das deklariert, dass es sie liest, die Render-Fakten, die ihre Provider gemeldet haben — nie die eigenen values oder infra der Verbindung. Ein an den Konsumenten angehängtes Feature liest auf dieselbe Weise, was die Renderings jedes seiner Ziele gemeldet haben, im Eintrag dieser Verbindung unter .context.uses.<alias>.render_facts, sofern sein FeatureRecipe deklariert, dass es sie liest.

Anhänge einer Verbindung (features). Eine Verbindung kann auch eigene Anhänge tragen — etwa eine Anmeldeinformation, die der Konsument der Komponente vorlegt, die diese Verbindung erreicht — unter features: in ihrem Eintrag, mit einem Slot als Schlüssel, den der Socket in seinem featuresSchema deklariert. Dieselben zwei Autoren teilen sie auf: Der Entwickler hängt im Verbindungseintrag des Aggregate mit type und values an, und der Operator dimensioniert diesen Anhang mit infra oder hängt einen eigenen mit type und infra an, im Eintrag des Release. Ein Anhang an einer Verbindung trägt keinen eigenen Block inject, weshalb er in der obigen Platzierungsregel fehlt: Er ist keiner der Orte, an denen ein Entwickler die Zustellung vorgibt.

Jeder wird zu einem Anhang der konsumierenden Komponente mit dem Namen <alias>.<slot> und ist damit genau so konsumentenbezogen wie die Konfiguration pro Kante: Sein FeatureRecipe rendert auf der Seite des Konsumenten, und die Ausgabe des Ziels ändert sich dadurch nicht. Er wird aus den .features des konsumierenden Recipe herausgehalten, die nur die Anhänge enthalten, die der eigene Block der Komponente deklariert; das Recipe liest ihn stattdessen unter seiner Verbindung, unter .context.uses.<alias>.features.<slot>. Eine Verbindung, die ein Feature-Anhang zieht, trägt keine Anhänge. Siehe entities/aggregate.md §„A connection’s own attachments (Die eigenen Anhänge einer Verbindung)“ und entities/component.md §„Topology Sockets (Topologie-Sockets)“.

A. Umgebungsvariablen (env) und dynamische Zielauflösung Der Standard-Zustellungsmechanismus für moderne Cloud-native Anwendungen. Für explizite topologische Kanten (z. B. ein Agent, der mit einer Datenbank kommuniziert) verwendet Aggrega .context.uses, um die Zuordnung der Umgebungsvariablen zu injizieren.

  • Anwendungsfall: Empfangen deterministischer interner DNS-Namen, Infrastructure-as-Code-Interpolationsstrings (z. B. ${module.db.endpoint}) oder statischer Vault-Zeiger. Der Compiler verdrahtet diese statischen Referenzen AOT, damit die Laufzeitinfrastruktur oder der GitOps-Controller die Live-Werte auflösen kann.

B. Datei-Mounts (file) Viele KI-Frameworks für Unternehmen erwarten, dass eine strukturierte config.json oder ein Zertifikat .pem an einem bestimmten Pfad auf dem Datenträger existiert, statt sich auf Umgebungsvariablen zu stützen.

  • Anwendungsfall: Komplexe JSON-Konfigurationen injizieren oder Legacy-SDKs bedienen, die vom Datenträger lesen.

  • Absicht des Entwicklers:

    features:
    openai_key:
    type: core/aws-secrets-manager
    values:
    path: /prod/ai/openai
    key: "api_token"
    inject:
    file:
    - in: "/etc/secrets/openai.json" # Local path
    from: "api_token" # The attachment's provides key
  • Realität bei Ops: Das Ops-Recipe erzeugt dynamisch die Kubernetes-Ressourcen Volume, VolumeMount und ExternalSecret, die nötig sind, um die Vault-Daten sicher abzurufen und unter /etc/secrets/openai.json einzuhängen.

C. Kommandozeilenargumente (arg) Vorkompilierte Binärdateien (etwa Worker-Knoten in Rust oder Go) umgehen Umgebungsvariablen oft vollständig und erwarten, dass Werte als Laufzeit-Flags in ihrem Ausführungsbefehl übergeben werden.

  • Anwendungsfall: Physische Gegebenheiten an den Startbefehl des Containers anhängen.

  • Absicht des Entwicklers:

    features:
    public-ingress:
    type: core/external-ingress
    inject:
    arg:
    - in: "--callback-url=" # Local flag
    from: "hostname" # The attachment's provides key
  • Realität bei Ops: Der Hostname ist der Name, den die Umgebung der Komponente gibt, daher schreibt der Operator ihn, api.enterprise.com, in das infra dieses Anhangs im Eintrag des Release für die Komponente. Das Wasm-Plugin des Feature empfängt die aufgelöste öffentliche URL über den Injection Contract und gibt einen JSONPatch aus, um das Kubernetes-Array args dynamisch zu ergänzen: ["/app/binary", "--callback-url=https://api.enterprise.com"], wobei das Basis-Recipe der Component vollständig umgangen wird.