Vision et positionnement
Ce chapitre pose l’espace de problèmes fondamental, les anti-objectifs stricts de la plateforme, sa relation avec l’écosystème plus large et les philosophies d’ensemble qui gouvernent l’écosystème Aggrega.
Le fossé sémantique de l’infrastructure et comment Aggrega le comble
Le paysage du cloud d’entreprise est aujourd’hui limité par un fossé sémantique persistant : les outils traditionnels d’Infrastructure-as-Code (IaC) gèrent l’état physique, mais n’ont pas nativement le contexte de la couche applicative.
Les outils fondamentaux comme Terraform sont des gestionnaires d’état. Ils provisionnent des nœuds de calcul physiques, mais ne modélisent pas les flux de données logiques L7 qui circulent entre ces nœuds. Ils ne peuvent pas analyser nativement une architecture pour provisionner les pare-feu sémantiques nécessaires pour tracer les chaînes de prompts d’IA ou stopper les attaques « Confused Deputy ». À l’inverse, les outils natifs de Kubernetes (comme KubeVela) fonctionnent comme des contrôleurs d’exécution actifs ; les artefacts de conformité statiques, produits à l’avance (ahead-of-time), qu’exigent les équipes de sécurité des entreprises sortent de leur périmètre.
Aggrega répond à ce problème en agissant comme un compilateur topologique Ahead-of-Time (AOT), qui vise les goulets d’étranglement suivants du platform engineering moderne et des workloads d’IA :
1. Capacité abstraite et mécanique physique
- Le problème : quand les développeurs rédigent de l’IaC traditionnel, les contraintes de l’infrastructure physique (comme coder en dur des volumes AWS EBS ou des tailles d’instances EC2) s’infiltrent souvent dans la logique applicative. Ce couplage étroit réduit la portabilité et lie involontairement les workloads à des fournisseurs cloud précis.
- La solution : Aggrega délègue structurellement au catalogue de la plateforme la frontière entre capacité abstraite et mécanique physique. Plutôt que de s’appuyer sur des interdictions codées en dur dans le compilateur, les Platform Architects rédigent des déclarations strictes en JSON Schema 2020-12 (généralement sous forme compacte — une notation abrégée d’allure YAML qui place les contraintes de chaque champ sur une seule ligne) pour régir exactement ce que les développeurs peuvent demander. En général, les développeurs sont limités à des exigences abstraites de survie (par exemple
storage_size: 100Giouhardware/accelerator: gpu) et ne peuvent pas injecter de classes de stockage cloud arbitraires, simplement parce que le schéma du composant les rejettera. Si une application a réellement besoin d’un type d’instance EC2 physique précis, l’Architect doit exposer explicitement ce réglage dans l’interface du composant, ce qui fait du verrouillage fournisseur un choix conscient et gouverné plutôt qu’une fuite accidentelle.
2. Véritable inversion de contrôle et câblage sémantique
- Le problème : enchaîner à la main des adresses IP, des chaînes de connexion aux bases de données (DSN) et des ports réseau entre microservices crée des architectures fragiles et liées à leur environnement. Si les organisations gèrent aujourd’hui ces changements avec des couches complexes de surcharges de variables, de correctifs Kustomize ou de scripts de déploiement dupliqués, maintenir cette logique de traduction manuelle introduit une friction opérationnelle et une charge cognitive importantes lorsqu’on fait passer des workloads d’un ordinateur portable local à un cloud de production.
- La solution : Aggrega remplace les dépendances d’infrastructure codées en dur par la véritable inversion de contrôle (True Control Inversion), au moyen d’un Injection Contract explicite. Les développeurs déclarent simplement une arête topologique sémantique (par exemple « l’agent A utilise la base de données B ») et dictent la façon dont leur code s’attend à recevoir les données de connexion (par exemple sous forme de variable d’environnement ou de fichier monté). Le compilateur prend les pointeurs déterministes que les Ops ont attribués à la cible — qu’il s’agisse d’un nom DNS interne Kubernetes, d’une chaîne d’interpolation Terraform ou d’un DSN formaté par Wasm — et les achemine directement dans les modèles de rendu sans les résoudre. Pour les workloads modernes, cela soustrait au développeur le routage physique et les ports en les rendant abstraits. Le compilateur transmet des chaînes déterministes ; un câblage stable des dépendances d’un environnement à l’autre est une propriété de la discipline de rédaction de la Recipe (les Ops fournissent des pointeurs déterministes adaptés à chaque environnement), et non une garantie du cœur du compilateur.
3. Relier le jardin clos de l’IA à la réalité cloud-native
- Le problème : les frameworks d’IA supposent que l’infrastructure existe d’elle-même, et laissent aux Ops le soin de câbler à la main agents, pipelines RAG et bases de données au moyen de fichiers YAML fragmentés et codés en dur.
- La solution : Aggrega agit comme un traducteur topologique. En compilant le DSL déclaratif du développeur, le compilateur génère les configurations précises nécessaires pour câbler des boucles de raisonnement multi-agents complexes directement dans une infrastructure cloud standard, sans que les développeurs écrivent de scripts d’infrastructure.
4. Garde-fous imposés par l’infrastructure et défense MCP
- Le problème : les garde-fous logiciels échouent si une application est compromise ou si une IA hallucine alors qu’elle a accès à des outils internes via le Model Context Protocol (MCP).
- La solution : Aggrega déplace les frontières de confiance hors du code applicatif et dans l’infrastructure réseau grâce à un strict transfert d’exécution (Execution Handoff). Après avoir validé le graphe statique de l’application via le socket de gouvernance WebAssembly enfichable, le compilateur exécute des plugins de rendu pour générer les configurations exactes requises par les proxys d’interception L7 (comme le masquage de données ou les webhooks d’approbation humaine). Il remet ensuite ces artefacts à l’orchestrateur d’exécution, qui applique physiquement les règles et bloque les actions non autorisées.
5. Centraliser le trafic d’IA et la gouvernance des passerelles
- Le problème : gérer le trafic des LLM exige un routage très spécialisé (budgets de jetons, mise en cache sémantique, basculements) dont les passerelles de microservices standard sont dépourvues.
- La solution : comme Aggrega est agnostique vis-à-vis des capacités, la frontière entre application et infrastructure dépend entièrement de l’utilisateur. Aggrega peut servir à des Aggregates « greenfield » de pure infrastructure, ou générer à la demande des configurations pour des AI Gateways d’entreprise si le développeur les demande explicitement dans le cadre de son application. Sur demande, le compilateur utilise des plugins de rendu WebAssembly et des Ops Recipes pour produire les artefacts précis de ces passerelles, ce qui permet à l’infrastructure d’exécution d’exécuter physiquement la mise en cache sémantique et les chaînes de repli entre fournisseurs.
6. Mémoire cognitive avec état et hébergement de modèles locaux
- Le problème : traiter les bases de données vectorielles et les journaux épisodiques comme un stockage générique et plat permet à des agents détournés d’écraser facilement des faits sémantiques critiques.
- La solution : Aggrega traite les bases vectorielles et les modèles locaux comme des nœuds architecturaux explicites du graphe de topologie. En se fondant strictement sur ce que l’utilisateur demande et sur ce que l’équipe Ops a implémenté dans ses
Recipes, le compilateur utilise des plugins WebAssembly pour produire les artefacts précis nécessaires à leur sécurisation. Cela comprend la génération des politiques réseau strictes nécessaires pour associer les agents autonomes à des partitions de mémoire isolées, et la mise en forme de contraintes d’ordonnancement précises (comme lesnodeSelectorsde Kubernetes) afin que l’orchestrateur d’exécution place les modèles locaux sur du matériel GPU optimisé.
7. Véritable agnosticisme vis-à-vis du cloud et des capacités (liaison tardive)
- Le problème : transposer une architecture complexe d’un environnement de test Docker local vers Kubernetes en production exige de maintenir des scripts de déploiement entièrement séparés et dupliqués.
- La solution : Aggrega s’appuie sur la « liaison tardive » (late binding). Les développeurs écrivent un seul plan abstrait. Le Platform Operator peut ensuite projeter exactement la même topologie sur Docker Compose pour les tests locaux, ou sur AWS/EKS pour la production, simplement en remplaçant le fichier de verrouillage
Manifestet le routeurRelease. Cela découple proprement la logique cognitive de l’application de l’infrastructure physique, offre une expérience « écrire une fois, exécuter partout » pour l’architecture de base, et fait du verrouillage fournisseur un choix gouverné et intentionnel plutôt qu’un sous-produit accidentel.
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"]
Limites de la plateforme et anti-objectifs (ce qu’Aggrega n’est pas)
Pour préserver la pureté architecturale et éviter la dérive du périmètre, Aggrega fonctionne dans des limites strictes et non négociables. La plateforme choisit délibérément les problèmes qu’elle résout, et elle veille tout autant à ce qu’elle ne fait pas.
1. Un compilateur déterministe, pas un générateur d’IaC
Aggrega n’est pas un agent d’IA qui « écrit du Terraform à votre place ». C’est un compilateur Go déterministe qui analyse un langage dédié (DSL) strict pour garantir des artefacts de déploiement reproductibles et auditables. Il n’hallucine pas d’infrastructure.
2. Ni logique cognitive ni code applicatif
Le découpage des domaines d’Aggrega suit la loi de Conway comme une recommandation, sans l’imposer, et Aggrega ne demande pas aux équipes d’adopter un langage propriétaire. Il n’oblige jamais les développeurs à réécrire leur logique de raisonnement d’IA, leurs nœuds LangGraph ou leurs embeddings Python dans un langage cloud propre à la plateforme. Le compilateur traite l’application comme une boîte noire. Il configure les routes et les murs sécurisés ; ce sont les frameworks applicatifs qui conduisent les voitures.
3. Anti-objectifs opérationnels et de cycle de vie
- Pas un pipeline CI/CD : Aggrega ne construit pas d’images Docker, n’exécute pas de tests unitaires et ne gère pas de dépôts Git. Les développeurs doivent utiliser les outils existants pour construire le code de leurs applications. Aggrega compile uniquement le plan d’infrastructure déclaratif qui accompagne ces builds.
- Pas un orchestrateur de cluster actif (pas de GitOps) : Aggrega est un compilateur statique Ahead-of-Time (AOT), et non un agent de cluster actif qui réconcilie l’état en continu. Il produit des manifestes Kubernetes standard et des configurations Docker Compose que des outils GitOps dédiés (comme ArgoCD ou Flux) déploient.
- Pas un gestionnaire d’état cognitif : le compilateur utilise des plugins pour générer les configurations de frontières réseau sécurisées et de bases de données physiques. En revanche, il ne surveille pas la boucle de mémoire interne d’un agent d’IA. Si une IA hallucine ou n’arrive pas à écrire dans sa base de données, c’est le problème du framework applicatif.
- Pas un outil de provisionnement « Day 0 » : Aggrega suppose généralement qu’un plan de contrôle de base existe déjà (par exemple un cluster Kubernetes actif ou un compte AWS). Il compile l’architecture applicative « Day 1 » par-dessus cette base ; il n’exécute pas les scripts initiaux de création d’une organisation cloud d’entreprise.
- Exception (Aggregates de plateforme et cas d’usage mixtes) : comme Aggrega est agnostique vis-à-vis des capacités, il prend en charge nativement les scénarios « greenfield ». Si un Platform Architect définit une infrastructure Day-0 (comme des VPC et des clusters Kubernetes) dans un
Aggregatede plateforme, Aggrega la compile et la rend exactement comme pour une application standard. Cet agnosticisme prend en charge sans heurt les environnements mixtes : un nœud architectural lourd — comme une AI Gateway d’entreprise — peut être modélisé comme une ressource d’infrastructure préexistante (avec des plugins de mise en forme qui ne font que laisser passer le trafic), ou être déployé directement à côté de l’application comme un composant provisionné standard.
4. Anti-objectifs liés au paradigme applicatif et à l’infrastructure
- Pas de réseaux décentralisés ou P2P : les configurations générées reposent sur un plan de contrôle d’entreprise centralisé (Kubernetes/VPC) capable d’imposer des frontières réseau L4/L7. Le compilateur ne peut pas générer de routage sécurisé pour des agents qui se découvrent dynamiquement sur des blockchains décentralisées ou des réseaux P2P publics.
- Pas de systèmes zero-copy ni à mémoire partagée : Le modèle de sécurité d’Aggrega repose sur la génération de configurations d’interception au niveau du réseau (comme les sidecars Envoy) pour appliquer les politiques. Si un essaim d’agents communique uniquement par la mémoire système partagée au sein d’un nœud (par exemple, Ray Core Actors), les proxys réseau ne peuvent pas voir cette communication et ne peuvent pas appliquer de garde-fous.
- Pas d’agents côté client : Aggrega est strictement un compilateur d’infrastructure backend. Il ne peut pas générer de configurations pour des modèles d’IA non gérés qui s’exécutent entièrement dans le navigateur Chrome d’un utilisateur final ou sur un appareil mobile en périphérie.
- Pas de sandboxing éphémère JIT (micro-segmentation par requête) : Aggrega est un compilateur statique AOT conçu pour compiler des artefacts destinés à des ressources de calcul de longue durée (comme les Deployments Kubernetes). Il ne prend pas en charge nativement le sandboxing éphémère Just-In-Time (JIT), où un conteneur entier est démarré puis détruit à chaque requête pour limiter le rayon d’impact.
5. Relation avec les outils voisins
Le socket de rendu WebAssembly (Wasm) enfichable d’Aggrega permet à la communauté de rédiger un plugin de rendu pour n’importe quel outil cible. Le projet principal fournit des plugins de rendu pour Helm, Helm-chart, Compose, Terraform et CloudFormation — couvrant le GitOps Kubernetes, la distribution de charts redistribuables, le développement local et les ressources cloud déclaratives — tandis que le socket ouvert permet aux équipes de cibler d’autres surfaces d’artefacts statiques sans toucher au cœur. Les équipes qui évaluent Aggrega viennent souvent d’écosystèmes construits autour d’outils situés dans des parties voisines mais distinctes de la pile. Les outils ci-dessous sont regroupés selon leur relation avec Aggrega : les formats d’artefacts vers lesquels il effectue le rendu, l’espace des compilateurs AOT qu’il partage, les plans de contrôle qui consomment sa sortie, et le domaine voisin de la gestion de configuration qu’il ne cible pas.
Formats d’artefacts vers lesquels Aggrega effectue le rendu. Ce sont les sorties Kubernetes et de développement local que produisent les plugins de rendu fournis ; les moteurs de rendu Terraform et CloudFormation fournis figurent à côté de ces outils dans le groupe suivant.
- Helm est le format standard d’empaquetage et de modèles pour les logiciels Kubernetes. Aggrega émet à la fois du YAML Helm rendu et des umbrella charts comme cibles de sortie à part entière, de sorte que les workflows fondés sur Helm consomment directement la sortie d’Aggrega.
- Docker Compose est la norme pour le développement local multi-conteneurs. Le moteur de rendu Compose d’Aggrega le cible directement, de sorte qu’un seul plan s’exécute en local sans surface de rédaction séparée.
L’espace des compilateurs AOT. Ces outils compilent eux aussi une intention abstraite ou au niveau du code en artefacts statiques et s’arrêtent avant de les déployer. Aggrega cible plusieurs des mêmes artefacts finaux via son socket de rendu ouvert ; là où aucun plugin de rendu n’est fourni pour une cible, celle-ci est accessible en en rédigeant un plutôt qu’en modifiant le cœur.
- Terraform / OpenTofu provisionnent des ressources cloud à partir de HCL déclaratif et gèrent l’état au moyen d’un moteur CLI. Aggrega compile vers des artefacts statiques et laisse l’exécution de l’état à l’environnement d’exécution ; son moteur de rendu Terraform fourni émet une configuration que Terraform ou OpenTofu applique, et n’exécute jamais ni l’un ni l’autre.
- AWS CloudFormation, Azure Resource Manager (ARM) / Bicep et Google Cloud Deployment Manager sont les formats natifs de provisionnement déclaratif de leurs clouds respectifs. Aggrega fournit un moteur de rendu CloudFormation qui émet des modèles de stack ; ARM / Bicep et Deployment Manager sont des cibles d’artefacts statiques vers lesquelles un auteur peut effectuer le rendu via le socket ouvert.
- AWS CDK et CDKTF sont des compilateurs AOT statiques qui traduisent du code généraliste respectivement en JSON CloudFormation et en JSON Terraform. Aggrega cible les mêmes types d’artefacts statiques finaux via son socket de rendu, si bien que les deux atteignent un même artefact par des chemins différents : CDK et CDKTF à partir de code généraliste, Aggrega à partir d’un plan topologique déclaratif.
- Pulumi permet aux développeurs de rédiger l’infrastructure dans des langages généralistes (TypeScript, Python, Go) ; sa valeur centrale consiste à traiter l’infrastructure comme du code exécutable. La surface de rédaction d’Aggrega est un plan YAML déclaratif — c’est l’abstraction, et non la surface d’API, que les développeurs ciblent en écrivant. Chacun reflète une philosophie différente quant à l’endroit où réside le contrat du développeur avec l’infrastructure.
- AWS SAM et le Serverless Framework traduisent statiquement une spécification YAML en ressources de fonctions serverless et de passerelles d’API — un sous-ensemble ciblé de l’espace d’artefacts que le socket d’Aggrega peut cibler.
- Nitric, Klotho et Winglang sont des modèles de programmation conscients du cloud dont les compilateurs AOT émettent des fichiers d’infrastructure standard à partir du code applicatif, plutôt qu’à partir d’un plan de topologie déclaratif.
- Score.dev est une abstraction déclarative de la capacité de base des workloads — CPU, mémoire, ports — rendue en Docker Compose ou en Helm. Il traite un sous-ensemble ciblé de ce que couvre Aggrega : la topologie entre composants, un socket de gouvernance pour les politiques, les adaptateurs Wasm et les capacités propres à l’IA sont hors du périmètre de Score.
Plans de contrôle qui consomment la sortie d’Aggrega. Ils fonctionnent à l’intérieur d’un cluster en cours d’exécution et appliquent des artefacts déclaratifs. Aggrega est strictement ahead-of-time — il produit les manifestes que ces systèmes réconcilient.
- ArgoCD et Flux sont des contrôleurs GitOps qui réconcilient dans un cluster des manifestes stockés dans Git. Ils appliquent la sortie Kubernetes d’Aggrega comme n’importe quel autre YAML déclaratif.
- Crossplane et KubeVela sont des opérateurs actifs du plan de contrôle Kubernetes qui réconcilient l’état souhaité depuis l’intérieur d’un cluster. Un cluster Crossplane ou KubeVela peut consommer la sortie Kubernetes d’Aggrega comme n’importe quel autre YAML déclaratif ; les deux couches se complètent.
- Microsoft Radius est un plan de contrôle de l’application à l’infrastructure qui réconcilie l’état souhaité depuis l’intérieur d’un cluster, en consommant des artefacts déclaratifs du type de ceux que produit Aggrega.
- Spinnaker est un moteur de livraison continue qui déploie des artefacts vers des cibles VM et Kubernetes, en aval de l’étape de génération d’artefacts qu’occupe Aggrega.
Gestion de configuration voisine. Ces outils traitent des problèmes d’état des serveurs et de modification de YAML distincts de la compilation de topologie, et Aggrega ne cible pas leur domaine.
- Ansible est un outil impératif de gestion de configuration pour des playbooks séquentiels sur des VM de longue durée et des parcs sur site. Aggrega émet des artefacts de topologie déclaratifs pour des cibles conteneurs et API cloud. Les équipes qui utilisent Ansible pour gérer l’état des serveurs à côté de workloads conteneurisés le conservent généralement pour ce rôle et utilisent Aggrega pour la topologie applicative.
- Chef, Puppet et SaltStack sont des systèmes de gestion de configuration à base d’agents qui font converger l’état des serveurs à l’échelle des parcs — un domaine de problèmes différent de la compilation statique de topologie.
- Kustomize modifie le YAML Kubernetes sans modèles et est intégré à
kubectl. Il transforme des manifestes existants au lieu d’y compiler un plan de topologie.