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

Ökosystem-Philosophie

Die Ökosystem-Philosophie

Die Architektur von Aggrega folgt grundlegenden Designprinzipien, die Flexibilität und Vorhersagbarkeit ausbalancieren. Durch klare Grenzen und standardisierte Verträge kann ein grundsätzlich generischer Compiler nahtlos alles orchestrieren, von standardmäßiger Cloud-nativer Infrastruktur bis hin zu hochspezialisierter KI-Intelligenz.

1. Kernmechanik: Die Physik der Architektur

  • Trennung der Zuständigkeiten (Conways Gesetz): Entwickler schreiben keinen physischen Infrastrukturcode, und Ops codiert keine Anwendungslogik fest. Die Leitlinien der Architektur unterteilen das Verfassen in Domain-Driven-Grenzen, eine Trennung, die der Compiler nicht erzwingt (siehe Invariante 7).
  • Späte Bindung (Dependency Inversion): Entwickler fordern abstrakte Schnittstellen an (z. B. type: enterprise-agent), keine konkreten Implementierungen (z. B. helm-chart-v2). Das Manifest löst die Schnittstelle zur Kompilierzeit in die richtige Implementierung auf und ermöglicht so echte Multi-Target-Deployments aus einer einzigen Quelldatei.
  • AOT-Reinheit (kein Abruf aus der Live-Cloud): Der Compiler ist agnostisch gegenüber der Live-Cloud. Er authentifiziert sich während der Kompilierung nie bei Infrastruktur-APIs und ruft keine Live-IP-Adressen ab. Er arbeitet vollständig nach dem Prinzip der Kontrollumkehr, bildet deterministische Zeiger ab und übergibt abstrakte Injektionsverträge im Voraus, sodass die Laufzeitumgebung die endgültigen physischen Verbindungen sicher auflösen kann.

2. Die Entwicklererfahrung: Absicht und Abstraktion

  • Semantische Entwicklererfahrung (der Standard der Map mit 5 Schlüsselwörtern): Um kognitive Reibung zu vermeiden, verwenden Entwickler innerhalb einer Map-basierten YAML-Topologie genau fünf allgemein verständliche Schlüsselwörter:
    1. parameters: Der globale Umgebungsvertrag (z. B. die Übergabe dynamischer Festplattengrößen).
    2. values: Die zentrale Nutzlast der kognitiven bzw. geschäftlichen Logik (im Besitz der Entwickler).
    3. uses: Die explizit deklarierten Netzwerkkanten und Abhängigkeiten (im Besitz der Entwickler).
    4. infra: Der physische Footprint und die mechanische Dimensionierung (im Besitz von Ops, im Aggregate verboten).
    5. inject: Der strikte Liefervertrag, der lokale Variablen auf Ziel- bzw. provides-Schlüssel abbildet (env, file, arg). Dieser Mechanismus ist erweiterbar.
  • Fähigkeitsunabhängige Terminologie: Damit die Gegebenheiten der zugrunde liegenden Infrastruktur (wie der Kubernetes-Begriff namespace) nicht in die Entwicklererfahrung durchsickern, verwendet die Plattform universelle Konzepte wie boundaries.
  • Explizite Absicht und die „laute Leitplanke“ (keine Geisterinfrastruktur): Der Compiler darf niemals Rechenressourcen oder Funktionen erfinden, die der Entwickler nicht explizit deklariert hat. Wenn eine Policy-Engine stillschweigend einen Sicherheits-Proxy injiziert, entsteht „Geisterinfrastruktur“: Fällt sie aus, debuggt der Entwickler am Ende einen Proxy, der in seinem YAML nicht existiert. Anstatt die Architektur stillschweigend zu verändern, wirken Wasm-Policy-Plugins strikt als laute Leitplanken. Verletzt eine Topologie die Sicherheit, bricht der Compiler den Build ab und gibt einen sehr spezifischen Fehler zurück (z. B. „Fehler: PII-Daten fließen über das KI-Gateway router zu einem Modellanbieter. Sie müssen die Funktion core/data-masking explizit daran anhängen“), wodurch der Entwickler gezwungen wird, seine eigene Single Source of Truth zu korrigieren.

3. Der meinungslose Compiler: Verarbeitung und Orchestrierung

  • Programmierbare Policies (der meinungslose Compiler): Der Go-Kern-Compiler ist ein inhaltsneutraler, rechnender Mechanismus. Er parst YAML, durchläuft Graphen und wertet Label-Schnittmengen aus. Die eigentliche „Intelligenz“ (z. B. die Durchsetzung, dass Modell-Traffic mit eingeschränkten Daten ein KI-Gateway passiert, das sensiblen Text maskiert) wird vom Unternehmen dynamisch programmiert, über steckbare WebAssembly-Sockets (Wasm) für Mutationen des abstrakten Syntaxbaums (AST)—die die geparste In-Memory-Darstellung der Konfiguration verändern—und für die Policy-Validierung.
  • Schema-Agnostizismus (Open-Source-Wörterbuch): Der Kern-Compiler ist agnostisch gegenüber physischen Ausführungsschichten. Er besitzt keine fest codierten Schemas für Helm, Terraform oder Docker Compose. Stattdessen ist der source-Block eines Ops-Recipe ein offenes Wörterbuch, dessen Schlüssel vom Provider definiert werden und in den Templates des Recipe als .source.* erscheinen. Der Kern löst eine abgerufene Source über eine integrierte { kind, url, version }-Form auf (Arten: helm-oci-chart, helm-https-chart, compose-https-fragment, git-repository), was den Compiler bereits von den Cloud-Sprachen entkoppelt, die er manipuliert. Das Abrufmodell finden Sie in der Referenz zu source des Recipe.
  • Explizite Plugin-Orchestrierung: Der zentrale Go-Compiler agiert strikt als neutraler Graph-Builder und rät niemals, wie ein Knoten zu verarbeiten ist. Stattdessen wird die gesamte Domänenintelligenz explizit über dedizierte WebAssembly-(Wasm)-Sockets auf zwei unterschiedlichen Ebenen orchestriert. 1. Globale Sockets: Unternehmens-Policies und Formatierung werden von explizit registrierten Compiler-Sockets ausgewertet (z. B. der Governance-Rolle label-transform für das automatische Tagging von Metadaten, einer Governance-Rolle für Urteile zur topologischen Sicherheit und dem Renderer-Socket für die finale Artefakterzeugung). 2. Implementierungs-Pipelines: Component-spezifische Mutationslogik wird vom Manifest orchestriert; wenn es eine abstrakte Schnittstelle in ein konkretes Recipe auflöst, deklariert diese Implementierung explizit ein sequenzielles pipeline-Array von auszuführenden Wasm-Plugins. Der Compiler speist lediglich den fähigkeitsunabhängigen Graphen der Zwischendarstellung (IR) in diese definierten Sockets ein und stellt so sicher, dass die gesamte domänenspezifische Logik strikt versioniert im Ökosystem bleibt, statt im Compilerkern fest codiert zu sein.
  • Flache Kompilierung und Feature-Atomarität: Aggrega verwaltet keinen Zustand, pingt keine Endpunkte an und wartet nicht, bis ein Rollout abgeschlossen ist. Der Compiler wertet verschachtelte Module aus und löst sie zu einem flachen, eindimensionalen Graphen der Zwischendarstellung (IR) auf, bevor er die Daten an die Wasm-Rendering-Plugins übergibt. Entscheidend ist, dass der Compiler die Feature-Atomarität bewahrt, obwohl der Graph abgeflacht wird. Deklariert ein Proxy-Feature eigenständig eine Netzwerkkante zu einem sicheren Vault, zeichnet der Compiler den semantischen Ursprung dieser Kante auf, sodass Wasm-Policy-Engines $O(1)$-Lookups ausführen können, ohne die Verbindung fälschlich der übergeordneten Komponente zuzuschreiben. Zur Unterstützung der zeitlichen Sequenzierung trägt schließlich jede Grenze im Release einen Wert syncWave: <integer>; jedes Rendering-Plugin übersetzt die Welle pro Grenze in das, womit sein eigenes Ziel eine Reihenfolge ausdrückt — eine Annotation zur Ausführungsreihenfolge, die der nachgelagerte GitOps-Controller liest, oder eine Abhängigkeit zwischen den Diensten der Datei, die es rendert —, während ein Ziel ganz ohne Möglichkeit, eine Reihenfolge auszudrücken, die Welle aufzeichnet, ohne danach zu sequenzieren.

4. Die semantische Ontologie: Identifikation und Taxonomie

  • Die operative Cloud-native Ontologie: Damit Open-Source-Wasm-Plugins und Unternehmens-Policies universell zusammenarbeiten können, bildet das Label component.aggrega.ai/type ausschließlich auf eine geschlossene Menge universeller Cloud-Primitive ab (server, worker, task, function, stateful-server, resource). Dies ist der eigene Schlüssel von Aggrega: Das veröffentlichte Component-Schema zählt die zulässigen Werte auf, und ein Dokument mit einem anderen Wert wird beim Laden abgelehnt. Die zentrale Festlegung dieses Vokabulars stellt sicher, dass autonome Policy-Engines und von der Community erstellte Wasm-Rendering-Plugins dasselbe Wort für dieselbe Form lesen, wenn sie auf eine Component treffen, die keiner ihrer Autoren geschrieben hat. Der Compiler leitet dennoch nichts aus der Zeichenkette ab: Er gleicht den Wert mit einem Selektor ab und stellt nichts aus eigenem Antrieb bereit; die geschlossene Menge bewirkt, dass die Selektoren aller dasselbe Vokabular abgleichen.
  • Klassifizierung entlang einer Achse, die Aggrega nicht definiert: Die geschlossene Menge gilt für diesen einen reservierten Schlüssel. Ein Katalog, der eine eigene Klassifizierung benötigt (eine Stufe, eine Datenzone, eine Serviceklasse, eine feinere Unterteilung der Primitive), definiert seinen eigenen Label-Schlüssel neben dem reservierten, da das Component-Schema jeden weiteren Label-Schlüssel mit einem Zeichenkettenwert akzeptiert und jede Selektorfläche ihn gleich liest. Die Erweiterung erfolgt auf Ihrem Schlüssel, nicht innerhalb des Schlüssels von Aggrega; deshalb kann ein Unternehmensvokabular wachsen, ohne dass das gemeinsame abdriftet.
  • Duck Typing (semantische Merkmale über Labels): Wenn die Basistypen rein Cloud-nativ sind, wird die gesamte kognitive, operative und Compliance-Intelligenz vollständig über semantisches Duck Typing geschichtet. Vom Platform Architect verfasste Labels (z. B. model.aggrega.ai/capability: generative, compliance.aggrega.ai/data-class: restricted) bilden die eigentliche Identität des Knotens. Features binden sich anhand dieser Label-Selektoren dynamisch an Komponenten.

5. Unternehmens-Governance: Schemas und Vererbung

  • Strikte API-Partitionierung und Auffindbarkeit im Unternehmen: Gemäß den Kubernetes-Standards befinden sich alle Nutzlastdefinitionen einheitlich in einem spec:-Block. Ressourcenidentität, charakterisierende Labels und explizite Compiler-Anweisungen befinden sich strikt im metadata:-Block. Um eine strikte Auflösung zu garantieren, schreibt jedes teilbare YAML-Artefakt zwingend eine per Regex geprüfte SemVer-Zeichenkette version vor. Zur Unterstützung der Auffindbarkeit in OCI-Registries und der Lebenszyklus-Governance unterstützt der metadata-Block außerdem eine optionale Enterprise-Metadaten-Suite. Diese Suite umfasst description, ein strukturiertes Objekt-Array maintainers (Name, E-Mail, URL), license, repository, home (Dokumentations-URL) und keywords (für die Suchindizierung). Das Lebensende wird außerhalb des Dokuments verwaltet: aggrega deprecate hängt an ein bereits veröffentlichtes Artefakt eine signierte Deprecation-Markierung — einen Schweregrad, einen Grund und einen optionalen Ersatz — an, ohne dessen veröffentlichte Bytes zu ändern.

  • Schema-Erweiterbarkeit (das Kubernetes-CRD-Muster): Um das Schema des zentralen Compilers nicht für jede neue KI- oder Infrastrukturfunktion aktualisieren zu müssen, verwendet die Plattform JSON Schema 2020-12 zur Validierung von Konfigurationen. Platform Architects schreiben strikte Typen, Validierungslogik und Standardwerte direkt in den schema:-Block der Katalogkomponenten, üblicherweise in kompakter Form, einer YAML-artigen Kurzschreibweise, die die Einschränkungen eines Felds in eine Zeile bringt (port: { type: integer, min: 1, max: 65535, default: 8080 }) und vor der Validierung zu JSON Schema 2020-12 kompiliert wird. Vollständiges JSON-Schema-YAML bleibt eine gleichwertige Option für Schemas, die dessen vollständiges Vokabular benötigen. Kataloge, die groß genug werden, um von der Component-übergreifenden Wiederverwendung von Schemas zu profitieren, lagern gemeinsame Formen (Probe-Blöcke, Ressourcenlimits, Formen benannter Ports) in eine dedizierte SchemaLibrary-Entität aus und referenzieren sie über das JSON-Schema-Schlüsselwort $ref:.

  • Schema-Vererbung (Nutzlast-Baselines): Damit eine Baseline nur einmal verfasst wird, teilt die Plattform die Vererbung in zwei getrennte Stufen. Standard-YAML-Metadaten (einschließlich semantischer Labels), Manifest-Zuordnungen und Release-Konfigurationen verwenden traditionelle Merge-Strategien, um notwendige Überschreibungen pro Umgebung zu ermöglichen. Die Nutzlastschemas (schema:) werden nicht auf diese Weise zusammengeführt, und die beiden Katalogarten gehen getrennte Wege: Das schema: eines Feature wird mit dem seiner Basis nach der Kompositionssemantik von JSON Schema 2020-12 zusammengesetzt, beim Laden des Workspace von einem Merger durchlaufen, der die Herkunft nach Quellposition kennzeichnet, sodass jedes Blatt im zusammengeführten Schema seine Ursprungsdatei trägt; eine erweiternde Component verfasst überhaupt keinen Nutzlastinhalt: Sie schreibt die wörtliche Markierung schema: inherited und erhält den Block ihrer Basis genau so, wie die Basis ihn verfasst hat, auf jeder Tiefe einer Kette. Die Baseline einer Component ist daher durch Konstruktion statt durch Policy garantiert: Der Vertrag des Kindes ist schlicht der der Basis, sodass das Kind nichts lockern kann. Was eine solche Component stattdessen zusammensetzt, ist Struktur (ihre Anhangsslots, Topologie-Sockets, die Self-Inject-Allowlist und benannte assertions), und ein Kind, das eine strengere Regel braucht, als seine Basis deklariert, drückt sie als zusätzlichen assertions:-Eintrag aus, den die Regeln der Basis daneben behalten, statt ihn zu ersetzen. Die umfassendere topologische Sicherheit und die Label-Governance bleiben ordnungsgemäß an den Wasm-Governance-Socket delegiert.

  • Schnittstellenparität und automatische Implementierung: Damit Ops keine Recipe-YAMLs duplizieren muss, wenn ein Architect eine leicht abgewandelte Variante einer Basis-Component erzeugt, bedient ein gegen eine Basis geschriebenes Recipe jede Component, die sie erweitert, in jeder Tiefe der Kette. Die erweiternde Component schreibt schema: inherited und fügt daher values/infra/provides keinen Wurzelschlüssel hinzu, den das Recipe der Basis nicht verarbeiten könnte. Das Manifest bildet den erweiternden Typ dennoch mit einem eigenen Eintrag ab, und die Mapping-Prüfung akzeptiert diesen Eintrag, wenn implements des zugeordneten Recipe den Typ oder eine beliebige Basis nennt, die er erweitert (siehe Ein gegen eine Basis geschriebenes Recipe bedient alles, was sie erweitert). Der Ghost-Infrastructure-Tracker (der Warnungen ausgibt, wenn kein vom gebundenen Recipe deklariertes Template einen verfassten Schlüssel liest, um „Geisterinfrastruktur“ zu verhindern) ist die entsprechende Leitplanke der Rendering-Phase.

  • Versionsabgleich bei implements: Das Feld implements von Recipes und FeatureRecipes unterstützt drei Formen, um Strenge und Flexibilität des Ökosystems auszubalancieren:

    1. Exakte Version: implements: "core/api-server:1.0.0" — passt nur auf 1.0.0. Für Recipes, die eng an eine bestimmte Schemaversion gekoppelt sind.
    2. Major-kompatibel (SemVer-Bereich): implements: "core/api-server:^1.0.0" — passt auf >=1.0.0, <2.0.0. Gedacht für Recipes, die sich auf die SemVer-Kompatibilitätsgarantien der Component stützen: Minor- und Patch-Erhöhungen gelten gemäß SemVer als abwärtskompatibel, und der Compiler prüft, dass die Version der Component den Bereich erfüllt.
    3. Versionslos: implements: "core/api-server" — passt auf jede Version. Für Recipes, die wirklich versionsunabhängig sind (z. B. ein generisches Worker-Recipe, das nur .context.inject.env und keine versionsspezifischen values-Felder verwendet).

    implements wählt nie ein Recipe aus: Das Manifest nennt das Recipe für jeden Komponententyp, und der Compiler prüft, dass implements des zugeordneten Recipe diesen Typ in einer der drei Formen akzeptiert, und bricht bei einer Abweichung ab. Über dieselbe Deklaration schlägt der Compiler Kandidaten-Recipes vor, wenn ein Komponententyp keine Zuordnung hat.

    Das Muster mit drei Formen lässt Recipes den Versionsvertrag deklarieren, der zu ihrer tatsächlichen Kopplung an das Schema der Component passt. Recipes, die eng an eine bestimmte Schemaversion gebunden sind, pinnen exakt; Recipes, die sich auf die SemVer-Kompatibilitätsgarantien der Component stützen, verwenden einen Major-kompatiblen Bereich; Recipes, deren Verhalten überhaupt nicht von der Component-Version abhängt, bleiben versionslos. Das Ergebnis ist, dass Minor-Erhöhungen der Component-Version Ops weder zwingen, Component-Versionen zu pinnen, noch parallele Recipes pro Version zu pflegen.