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

Vision und Positionierung

Dieses Kapitel legt den grundlegenden Problemraum fest, die strikten Nicht-Ziele der Plattform, ihr Verhältnis zum breiteren Ökosystem und die übergreifenden Philosophien, die das Aggrega-Ökosystem bestimmen.

Die semantische Lücke der Infrastruktur und wie Aggrega sie überbrückt

Die Cloud-Landschaft in Unternehmen wird derzeit durch eine hartnäckige semantische Lücke eingeschränkt: Herkömmliche Infrastructure-as-Code-Werkzeuge (IaC) verwalten den physischen Zustand, verfügen aber von Haus aus nicht über den Kontext der Anwendungsschicht.

Grundlegende Werkzeuge wie Terraform sind Zustandsverwalter. Sie stellen physische Rechenknoten bereit, modellieren aber nicht die logischen L7-Datenflüsse, die zwischen diesen Knoten stattfinden. Sie können eine Architektur nicht nativ analysieren, um die semantischen Firewalls bereitzustellen, die nötig sind, um KI-Prompt-Ketten nachzuverfolgen oder „Confused Deputy“-Angriffe zu stoppen. Umgekehrt arbeiten Kubernetes-native Werkzeuge (wie KubeVela) als aktive Laufzeit-Controller; die statischen, vorab (ahead-of-time) erzeugten Compliance-Artefakte, die Sicherheitsteams in Unternehmen benötigen, liegen außerhalb ihres Aufgabenbereichs.

Aggrega begegnet dem, indem es als topologischer Ahead-of-Time-Compiler (AOT) agiert, der auf die folgenden Engpässe des modernen Platform Engineering und von KI-Workloads abzielt:

1. Abstrakte Kapazität vs. physische Mechanik

  • Das Problem: Wenn Entwickler herkömmliches IaC verfassen, sickern physische Infrastrukturvorgaben (etwa fest codierte AWS-EBS-Volumes oder EC2-Instanzgrößen) häufig in die Anwendungslogik ein. Diese enge Kopplung verringert die Portabilität und bindet Workloads unbeabsichtigt an bestimmte Cloud-Anbieter.
  • Die Lösung: Aggrega überträgt die Grenze zwischen abstrakter Kapazität und physischer Mechanik strukturell an den Plattformkatalog. Statt sich auf fest codierte Compiler-Verbote zu verlassen, verfassen Platform Architects strikte Deklarationen in JSON Schema 2020-12 (typischerweise in kompakter Form — einer YAML-artigen Kurzschreibweise, die die Einschränkungen eines Felds in eine Zeile bringt), um genau festzulegen, was Entwickler anfordern können. Typischerweise sind Entwickler auf abstrakte Überlebensanforderungen beschränkt (z. B. storage_size: 100Gi oder hardware/accelerator: gpu) und daran gehindert, beliebige Cloud-Speicherklassen einzubringen, einfach weil das Schema der Komponente sie ablehnt. Wenn eine Anwendung wirklich einen bestimmten physischen EC2-Instanztyp benötigt, muss der Architect diesen Regler ausdrücklich in der Schnittstelle der Komponente freigeben, sodass Vendor-Lock-in eine bewusste, gesteuerte Entscheidung wird statt eines unbeabsichtigten Lecks.

2. Echte Kontrollumkehr und semantische Verdrahtung

  • Das Problem: IP-Adressen, Datenbank-Verbindungsstrings (DSNs) und Netzwerkports manuell über Microservices hinweg zu verketten, erzeugt fragile, an Umgebungen gebundene Architekturen. Zwar bewältigen Organisationen diese Wechsel derzeit mit komplexen Schichten aus Variablen-Overrides, Kustomize-Patches oder duplizierten Deploy-Skripten, doch die Pflege dieser manuellen Übersetzungslogik verursacht erhebliche betriebliche Reibung und kognitive Last, wenn Workloads von einem lokalen Laptop in eine Produktions-Cloud überführt werden.
  • Die Lösung: Aggrega ersetzt fest codierte Infrastrukturabhängigkeiten durch echte Kontrollumkehr (True Control Inversion) über einen expliziten Injection Contract. Entwickler deklarieren einfach eine semantische topologische Kante (z. B. „Agent A verwendet Datenbank B“) und legen fest, wie ihr Code die Verbindungsdaten empfangen soll (z. B. als Umgebungsvariable oder als eingebundene Datei). Der Compiler übernimmt die von Ops zugewiesenen deterministischen Zeiger des Ziels — ob interner Kubernetes-DNS-Name, Terraform-Interpolations-String oder Wasm-formatierter DSN — und leitet sie direkt in die Rendering-Templates, ohne sie aufzulösen. Das abstrahiert physisches Routing und Ports für moderne Workloads vom Entwickler weg. Der Compiler leitet deterministische Strings durch; eine stabile Verdrahtung von Abhängigkeiten über Umgebungen hinweg ist eine Eigenschaft der Disziplin beim Verfassen eines Recipe (Ops liefert umgebungsgerechte deterministische Zeiger), keine Garantie des Compiler-Kerns.

3. Brücke vom KI-Walled-Garden zur Cloud-nativen Realität

  • Das Problem: KI-Frameworks setzen voraus, dass Infrastruktur einfach existiert, und überlassen es Ops, Agenten, RAG-Pipelines und Datenbanken mit fragmentierten, fest codierten YAML-Dateien manuell zu verdrahten.
  • Die Lösung: Aggrega agiert als topologischer Übersetzer. Durch das Kompilieren der deklarativen DSL des Entwicklers erzeugt der Compiler die genauen Konfigurationen, die nötig sind, um komplexe Multi-Agenten-Reasoning-Schleifen direkt in Standard-Cloud-Infrastruktur einzubinden, ohne dass Entwickler Infrastrukturskripte schreiben.

4. Durch die Infrastruktur erzwungene Leitplanken und MCP-Abwehr

  • Das Problem: Leitplanken auf Softwareebene versagen, wenn eine Anwendung kompromittiert wird oder eine KI halluziniert, während sie über das Model Context Protocol (MCP) Zugriff auf interne Werkzeuge hat.
  • Die Lösung: Aggrega verlagert Vertrauensgrenzen aus dem Anwendungscode in die Netzwerkinfrastruktur, durch eine strikte Ausführungsübergabe (Execution Handoff). Nachdem der Compiler den statischen Anwendungsgraphen über den einsteckbaren WebAssembly-Governance-Socket validiert hat, führt er Rendering-Plugins aus, um die genauen Konfigurationen für L7-Abfangproxys zu erzeugen (etwa Datenmaskierung oder Webhooks zur menschlichen Freigabe). Anschließend übergibt er diese Artefakte an den Laufzeit-Orchestrator, der die Regeln physisch durchsetzt und nicht autorisierte Aktionen blockiert.

5. Zentralisierung des KI-Datenverkehrs und Gateway-Governance

  • Das Problem: Die Verwaltung des LLM-Datenverkehrs erfordert hochspezialisiertes Routing (Token-Budgets, semantisches Caching, Failover), das Standard-Gateways für Microservices fehlt.
  • Die Lösung: Da Aggrega fähigkeitsagnostisch ist, liegt die Grenze zwischen Anwendung und Infrastruktur ganz beim Benutzer. Aggrega kann für reine Infrastruktur-Aggregates auf der „grünen Wiese“ (greenfield) verwendet werden, oder es kann bei Bedarf Konfigurationen für Unternehmens-AI-Gateways erzeugen, wenn der Entwickler sie ausdrücklich als Teil seiner Anwendung anfordert. Auf Anforderung nutzt der Compiler WebAssembly-Rendering-Plugins und Ops Recipes, um die genauen Artefakte für diese Gateways auszugeben, sodass die Laufzeitinfrastruktur das semantische Caching und providerübergreifende Fallback-Ketten physisch ausführen kann.

6. Zustandsbehaftetes kognitives Gedächtnis und lokales Modell-Hosting

  • Das Problem: Werden Vektordatenbanken und episodische Logs als generischer, flacher Speicher behandelt, können gekaperte Agenten kritische semantische Fakten leicht überschreiben.
  • Die Lösung: Aggrega behandelt Vektorspeicher und lokale Modelle als explizite Architekturknoten im Topologiegraphen. Streng auf Grundlage dessen, was der Benutzer anfordert und was das Ops-Team in seinen Recipes implementiert hat, nutzt der Compiler WebAssembly-Plugins, um die genauen Artefakte auszugeben, die zu ihrer Absicherung nötig sind. Dazu gehört das Erzeugen der strikten Netzwerkrichtlinien, die nötig sind, um autonome Agenten isolierten Speicherpartitionen zuzuordnen, und das Formatieren spezifischer Scheduling-Vorgaben (wie Kubernetes-nodeSelectors), damit der Laufzeit-Orchestrator lokale Modelle auf optimierter GPU-Hardware platziert.

7. Echte Cloud- und Fähigkeitsunabhängigkeit (Late Binding)

  • Das Problem: Eine komplexe Architektur aus einer lokalen Docker-Testumgebung in ein produktives Kubernetes zu übertragen, erfordert die Pflege völlig getrennter, duplizierter Deployment-Skripte.
  • Die Lösung: Aggrega setzt auf „Late Binding“. Entwickler schreiben einen einzigen abstrakten Bauplan. Der Platform Operator kann genau dieselbe Topologie dann auf Docker Compose für lokale Tests oder auf AWS/EKS für die Produktion abbilden, einfach indem die Manifest-Lockfile und der Release-Router ausgetauscht werden. Das entkoppelt die kognitive Logik der Anwendung sauber von der physischen Infrastruktur, bietet ein Write-once-run-anywhere-Erlebnis für die Kernarchitektur und macht Vendor-Lock-in zu einer gesteuerten, bewussten Entscheidung statt zu einem unbeabsichtigten Nebenprodukt.
graph TD
    A["Single Abstract Blueprint<br/>Aggregate.yaml"]

    subgraph LateBinding ["Late Binding Phase"]
        B{"Manifest Mapping"}
    end

    A --> B

    B -->|"Manifest: local-dev"| C["Local Provider<br/>Docker Compose"]
    B -->|"Manifest: aws-prod"| D["Cloud Provider<br/>EKS + AWS Bedrock"]
    B -->|"Manifest: azure-prod"| E["Cloud Provider<br/>AKS + Azure OpenAI"]

Grenzen der Plattform und Nicht-Ziele (was Aggrega nicht ist)

Um die architektonische Reinheit zu wahren und eine schleichende Ausweitung des Umfangs zu verhindern, arbeitet Aggrega innerhalb strikter, nicht verhandelbarer Grenzen. Die Plattform wählt die Probleme, die sie löst, bewusst aus und achtet ebenso darauf, was sie nicht tut.

1. Ein deterministischer Compiler, kein IaC-Generator

Aggrega ist kein KI-Agent, der „Terraform für Sie schreibt“. Es ist ein deterministischer Go-Compiler, der eine strikte domänenspezifische Sprache (DSL) parst, um reproduzierbare, prüfbare Deployment-Artefakte zu garantieren. Es halluziniert keine Infrastruktur.

2. Keine kognitive Logik und kein Anwendungscode

Die Aufteilung der Domänen in Aggrega folgt Conways Gesetz als Leitlinie, ohne es durchzusetzen, und Aggrega verlangt von Teams nicht, eine proprietäre Sprache einzuführen. Es zwingt Entwickler niemals, ihre KI-Reasoning-Logik, LangGraph-Knoten oder Python-Embeddings in eine plattformspezifische Cloud-Sprache umzuschreiben. Der Compiler behandelt die Anwendung als Blackbox. Er konfiguriert die sicheren Straßen und Mauern; die Anwendungsframeworks fahren die Autos.

3. Nicht-Ziele bei Betrieb und Lebenszyklus

  • Keine CI/CD-Pipeline: Aggrega baut keine Docker-Images, führt keine Unit-Tests aus und verwaltet keine Git-Repositorys. Entwickler müssen bestehende Werkzeuge verwenden, um ihren Anwendungscode zu bauen. Aggrega kompiliert ausschließlich den deklarativen Infrastruktur-Bauplan, der diese Builds begleitet.
  • Kein aktiver Cluster-Orchestrator (kein GitOps): Aggrega ist ein statischer Ahead-of-Time-Compiler (AOT), kein aktiver Cluster-Agent, der den Zustand fortlaufend abgleicht. Es gibt standardmäßige Kubernetes-Manifeste und Docker-Compose-Konfigurationen aus, die dedizierte GitOps-Werkzeuge (wie ArgoCD oder Flux) bereitstellen.
  • Kein Verwalter des kognitiven Zustands: Der Compiler nutzt Plugins, um die Konfigurationen für sichere Netzwerkgrenzen und physische Datenbanken zu erzeugen. Er überwacht jedoch nicht die interne Gedächtnisschleife eines KI-Agenten. Wenn eine KI halluziniert oder nicht in ihre Datenbank schreiben kann, ist das ein Problem des Anwendungsframeworks.
  • Kein „Day 0“-Provisioner: Aggrega setzt typischerweise voraus, dass bereits eine grundlegende Control Plane existiert (z. B. ein aktiver Kubernetes-Cluster oder ein AWS-Konto). Es kompiliert die „Day 1“-Anwendungsarchitektur auf dieser Grundlage; es führt nicht die initialen Skripte aus, um eine Cloud-Organisation des Unternehmens anzulegen.
  • Ausnahme (Plattform-Aggregates und gemischte Anwendungsfälle): Da Aggrega fähigkeitsagnostisch ist, unterstützt es nativ „Greenfield“-Szenarien. Wenn ein Platform Architect Day-0-Infrastruktur (etwa VPCs und Kubernetes-Cluster) in einem Plattform-Aggregate definiert, kompiliert und rendert Aggrega sie genau so, wie es das für eine Standardanwendung tut. Diese Unabhängigkeit unterstützt gemischte Umgebungen nahtlos: Ein schwergewichtiger Architekturknoten — etwa ein Enterprise AI Gateway — kann als bereits bestehende Infrastrukturressource modelliert werden (mit Formatter-Plugins, die nur den Datenverkehr durchreichen), oder er kann als standardmäßig bereitgestellte Komponente direkt neben der Anwendung deployt werden.

4. Nicht-Ziele bei Anwendungsparadigma und Infrastruktur

  • Keine dezentralen oder P2P-Netzwerke: Die erzeugten Konfigurationen setzen eine zentrale Control Plane des Unternehmens (Kubernetes/VPC) voraus, die L4/L7-Netzwerkgrenzen durchsetzen kann. Der Compiler kann kein sicheres Routing für Agenten erzeugen, die einander dynamisch auf dezentralen Blockchains oder öffentlichen P2P-Netzwerken entdecken.
  • Keine Zero-Copy- oder Shared-Memory-Systeme: Das Sicherheitsmodell von Aggrega beruht darauf, Konfigurationen für das Abfangen auf Netzwerkebene (etwa Envoy-Sidecars) zu generieren, um Richtlinien durchzusetzen. Kommuniziert ein Schwarm von Agenten ausschließlich über gemeinsam genutzten Systemspeicher innerhalb eines Knotens (z. B. Ray Core Actors), können die Netzwerk-Proxys diese Kommunikation nicht sehen und keine Guardrails durchsetzen.
  • Keine clientseitigen Agenten: Aggrega ist strikt ein Compiler für Backend-Infrastruktur. Es kann keine Konfigurationen für nicht verwaltete KI-Modelle erzeugen, die vollständig im Chrome-Browser eines Endbenutzers oder auf einem mobilen Edge-Gerät laufen.
  • Kein flüchtiges JIT-Sandboxing (Mikrosegmentierung pro Anfrage): Aggrega ist ein statischer AOT-Compiler, der dafür entworfen ist, Artefakte für langlebige Rechenressourcen (wie Kubernetes-Deployments) zu kompilieren. Er unterstützt nicht nativ flüchtiges Just-In-Time-Sandboxing (JIT), bei dem pro Anfrage ein ganzer Container gestartet und wieder zerstört wird, um den Schadensradius zu begrenzen.

5. Verhältnis zu benachbarten Werkzeugen

Der einsteckbare WebAssembly-Rendering-Socket (Wasm) von Aggrega bedeutet, dass die Community für jedes Zielwerkzeug ein Renderer-Plugin verfassen kann. Das Kernprojekt liefert Rendering-Plugins für Helm, Helm-chart, Compose, Terraform und CloudFormation — sie decken Kubernetes-GitOps, die Verteilung weiterverteilbarer Charts, die lokale Entwicklung und deklarative Cloud-Ressourcen ab —, während der offene Socket es Teams erlaubt, andere Oberflächen für statische Artefakte anzusteuern, ohne den Kern anzufassen. Teams, die Aggrega evaluieren, kommen oft aus Ökosystemen, die um Werkzeuge herum aufgebaut sind, die in benachbarten, aber unterschiedlichen Teilen des Stacks angesiedelt sind. Die folgenden Werkzeuge sind danach gruppiert, wie sie sich zu Aggrega verhalten: die Artefaktformate, in die es rendert, der AOT-Compiler-Bereich, den es teilt, die Control Planes, die seine Ausgabe konsumieren, und der benachbarte Bereich des Konfigurationsmanagements, den es nicht anvisiert.

Artefaktformate, in die Aggrega rendert. Das sind die Kubernetes- und Lokalentwicklungs-Ausgaben, die die mitgelieferten Renderer-Plugins erzeugen; die mitgelieferten Terraform- und CloudFormation-Renderer erscheinen in der nächsten Gruppe neben diesen Werkzeugen.

  • Helm ist das Standardformat für Packaging und Templating von Kubernetes-Software. Aggrega gibt sowohl gerendertes Helm-YAML als auch Umbrella-Charts als vollwertige Ausgabeziele aus, sodass Helm-basierte Workflows die Ausgabe von Aggrega direkt konsumieren.
  • Docker Compose ist der Standard für lokale Multi-Container-Entwicklung. Der Compose-Renderer von Aggrega zielt direkt darauf, sodass ein einziger Bauplan lokal läuft, ohne eine separate Autorenoberfläche.

Der AOT-Compiler-Bereich. Auch diese Werkzeuge kompilieren abstrakte oder codeseitige Absichten in statische Artefakte und halten an, bevor sie diese ausrollen. Aggrega zielt über seinen offenen Renderer-Socket auf mehrere derselben Endartefakte; wo für ein Ziel kein Renderer-Plugin mitgeliefert wird, ist es erreichbar, indem man eines verfasst, statt den Kern zu ändern.

  • Terraform / OpenTofu stellen Cloud-Ressourcen aus deklarativem HCL bereit und verwalten den Zustand über eine CLI-Engine. Aggrega kompiliert in statische Artefakte und überlässt die Zustandsausführung der Laufzeit; sein mitgelieferter Terraform-Renderer gibt Konfiguration aus, die Terraform oder OpenTofu anwendet, und führt keines von beiden je aus.
  • AWS CloudFormation, Azure Resource Manager (ARM) / Bicep und Google Cloud Deployment Manager sind die nativen deklarativen Bereitstellungsformate ihrer jeweiligen Clouds. Aggrega liefert einen CloudFormation-Renderer mit, der Stack-Templates ausgibt; ARM / Bicep und Deployment Manager sind Ziele für statische Artefakte, in die ein Autor über den offenen Socket rendern kann.
  • AWS CDK und CDKTF sind statische AOT-Compiler, die Code in Allzwecksprachen in CloudFormation-JSON bzw. Terraform-JSON übersetzen. Aggrega zielt über seinen Renderer-Socket auf dieselben Arten statischer Endartefakte, sodass beide auf verschiedenen Wegen zu einem Artefakt gelangen: CDK und CDKTF aus Code in Allzwecksprachen, Aggrega aus einem deklarativen topologischen Bauplan.
  • Pulumi lässt Entwickler Infrastruktur in Allzwecksprachen (TypeScript, Python, Go) verfassen; sein Kernwert besteht darin, Infrastruktur als ausführbaren Code zu behandeln. Die Autorenoberfläche von Aggrega ist ein deklarativer YAML-Bauplan — Entwickler schreiben gegen die Abstraktion, nicht gegen die API-Oberfläche. Beide spiegeln eine unterschiedliche Philosophie darüber wider, wo der Vertrag des Entwicklers mit der Infrastruktur liegt.
  • AWS SAM und das Serverless Framework übersetzen eine YAML-Spezifikation statisch in Ressourcen für Serverless-Funktionen und API-Gateways — eine fokussierte Teilmenge des Artefaktraums, den der Socket von Aggrega ansteuern kann.
  • Nitric, Klotho und Winglang sind cloudbewusste Programmiermodelle, deren AOT-Compiler Standard-Infrastrukturdateien aus Anwendungscode erzeugen statt aus einem deklarativen Topologie-Bauplan.
  • Score.dev ist eine deklarative Abstraktion für grundlegende Workload-Kapazität — CPU, Speicher, Ports —, die in Docker Compose oder Helm gerendert wird. Es behandelt eine fokussierte Teilmenge dessen, was Aggrega abdeckt: komponentenübergreifende Topologie, ein Governance-Socket für Richtlinien, Wasm-Adapter und KI-spezifische Fähigkeiten liegen außerhalb des Umfangs von Score.

Control Planes, die die Ausgabe von Aggrega konsumieren. Sie arbeiten innerhalb eines laufenden Clusters und wenden deklarative Artefakte an. Aggrega arbeitet strikt ahead-of-time — es erzeugt die Manifeste, die diese Systeme abgleichen.

  • ArgoCD und Flux sind GitOps-Controller, die in Git gespeicherte Manifeste mit einem Cluster abgleichen. Sie wenden die Kubernetes-Ausgabe von Aggrega wie jedes andere deklarative YAML an.
  • Crossplane und KubeVela sind aktive Operatoren der Kubernetes-Control-Plane, die den Sollzustand von innerhalb eines Clusters abgleichen. Ein Crossplane- oder KubeVela-Cluster kann die Kubernetes-Ausgabe von Aggrega wie jedes andere deklarative YAML konsumieren; die beiden Schichten ergänzen einander.
  • Microsoft Radius ist eine Control Plane von der Anwendung zur Infrastruktur, die den Sollzustand von innerhalb eines Clusters abgleicht und deklarative Artefakte der Art konsumiert, die Aggrega erzeugt.
  • Spinnaker ist eine Continuous-Delivery-Engine, die Artefakte auf VM- und Kubernetes-Ziele bereitstellt, nachgelagert zu dem Schritt der Artefakterzeugung, den Aggrega einnimmt.

Benachbartes Konfigurationsmanagement. Diese Werkzeuge behandeln Probleme des Serverzustands und des YAML-Patchings, die sich von der Topologiekompilierung unterscheiden, und Aggrega zielt nicht auf ihren Bereich.

  • Ansible ist ein imperatives Konfigurationsmanagement-Werkzeug für sequenzielle Playbooks auf langlebigen VMs und On-Premise-Flotten. Aggrega gibt deklarative Topologie-Artefakte für Container- und Cloud-API-Ziele aus. Teams, die Ansible neben containerisierten Workloads für die Verwaltung des Serverzustands einsetzen, behalten es typischerweise für diese Rolle und nutzen Aggrega für die Anwendungstopologie.
  • Chef, Puppet und SaltStack sind agentenbasierte Konfigurationsmanagement-Systeme, die den Serverzustand über Flotten hinweg konvergieren lassen — ein anderer Problembereich als die statische Topologiekompilierung.
  • Kustomize patcht Kubernetes-YAML ohne Templating und ist in kubectl integriert. Es transformiert bestehende Manifeste, statt einen Topologie-Bauplan in sie zu kompilieren.