Aller au contenu
AggregaAggrega
Selectionner la langue: Français
Cette page a été traduite automatiquement. Lire l’original en anglais.

Philosophie de l’écosystème

La philosophie de l’écosystème

L’architecture d’Aggrega est guidée par des principes de conception fondamentaux qui équilibrent flexibilité et prévisibilité. En maintenant des frontières claires et des contrats standardisés, un compilateur fondamentalement générique peut orchestrer de manière transparente tout ce qui va de l’infrastructure cloud-native standard à l’intelligence IA hautement spécialisée.

1. Mécanique de base : la physique de l’architecture

  • Séparation des préoccupations (loi de Conway) : les développeurs n’écrivent pas de code d’infrastructure physique, et les Ops ne codent pas en dur la logique applicative. Les recommandations de l’architecture divisent la rédaction en frontières Domain-Driven, une séparation que le compilateur n’impose pas (voir Invariant 7).
  • Liaison tardive (inversion des dépendances) : les développeurs demandent des interfaces abstraites (par ex. type: enterprise-agent), et non des implémentations spécifiques (par ex. helm-chart-v2). Le Manifest résout l’interface vers la bonne implémentation au moment de la compilation, ce qui permet de véritables déploiements multi-cibles à partir d’un seul fichier source.
  • Pureté AOT (aucune récupération depuis le cloud en direct) : Le compilateur est agnostique vis-à-vis du cloud en direct. Il ne s’authentifie jamais auprès des API d’infrastructure et ne récupère jamais d’adresses IP en direct pendant la compilation. Il fonctionne entièrement selon l’inversion de contrôle, en mappant des pointeurs déterministes et en transmettant à l’avance des contrats d’injection abstraits afin que l’environnement d’exécution puisse résoudre en toute sécurité les connexions physiques finales.

2. L’expérience développeur : intention et abstraction

  • Expérience développeur sémantique (la norme de la map à 5 mots-clés) : pour éviter toute friction cognitive, les développeurs utilisent exactement cinq mots-clés universellement compris au sein d’une topologie YAML fondée sur des maps :
    1. parameters : le contrat d’environnement global (par ex. la transmission de tailles de disque dynamiques).
    2. values : la charge utile centrale de logique cognitive/métier (propriété des développeurs).
    3. uses : les arêtes réseau et les dépendances déclarées explicitement (propriété des développeurs).
    4. infra : l’empreinte physique et le dimensionnement mécanique (propriété des Ops, interdits dans l’Aggregate).
    5. inject : le contrat de livraison strict qui associe les variables locales aux clés cibles de provides (env, file, arg). Ce mécanisme est extensible.
  • Terminologie indépendante des capacités : pour éviter que les réalités de l’infrastructure sous-jacente (comme le terme Kubernetes namespace) ne débordent sur l’expérience développeur, la plateforme utilise des concepts universels comme boundaries.
  • Intention explicite et le « garde-fou bruyant » (aucune infrastructure fantôme) : le compilateur ne doit jamais inventer de ressources de calcul ou de fonctionnalités que le développeur n’a pas déclarées explicitement. Utiliser un moteur de politiques pour injecter silencieusement un proxy de sécurité crée une « infrastructure fantôme » : quand elle tombe en panne, le développeur finit par déboguer un proxy qui n’existe pas dans son YAML. Au lieu de modifier silencieusement l’architecture, les plugins de politiques Wasm agissent strictement comme des garde-fous bruyants. Si une topologie enfreint la sécurité, le compilateur interrompt le build et renvoie une erreur très précise (par ex. « Erreur : des données PII circulent vers un fournisseur de modèles via la passerelle IA router. Vous devez y attacher explicitement la fonctionnalité core/data-masking »), obligeant le développeur à corriger sa propre source unique de vérité.

3. Le compilateur sans parti pris : traitement et orchestration

  • Politiques programmables (le compilateur sans parti pris) : Le compilateur Go central est un mécanisme de calcul neutre vis-à-vis du contenu. Il analyse le YAML, parcourt des graphes et évalue des intersections de labels. La véritable « intelligence » (par exemple, imposer que le trafic vers les modèles transportant des données restreintes passe par une passerelle IA qui masque le texte sensible) est programmée dynamiquement par l’entreprise à l’aide de sockets WebAssembly (Wasm) enfichables pour les mutations de l’arbre syntaxique abstrait (AST)—qui modifient la représentation en mémoire de la configuration analysée—et pour la validation des politiques.
  • Agnosticisme vis-à-vis des schémas (dictionnaire open source) : Le compilateur central est agnostique vis-à-vis des couches d’exécution physiques. Il ne possède aucun schéma codé en dur pour Helm, Terraform ou Docker Compose. Le bloc source d’une Recipe Ops est plutôt un dictionnaire ouvert dont les clés sont définies par le provider et apparaissent dans les templates de la Recipe sous la forme .source.*. Le cœur résout une source récupérée au moyen d’une forme intégrée { kind, url, version } (kinds : helm-oci-chart, helm-https-chart, compose-https-fragment, git-repository), ce qui découple déjà le compilateur des langages cloud qu’il manipule. Consultez la référence source de la Recipe pour le modèle de récupération.
  • Orchestration explicite des Plugin : le compilateur Go central agit strictement comme un constructeur de graphes neutre et ne devine jamais comment traiter un nœud. Toute l’intelligence de domaine est au contraire orchestrée explicitement via des sockets WebAssembly (Wasm) dédiés, à deux niveaux distincts. 1. Sockets globaux : les politiques et la mise en forme de l’entreprise sont évaluées par des sockets du compilateur explicitement enregistrés (par ex. le rôle de gouvernance label-transform pour l’étiquetage automatique des métadonnées, un rôle de gouvernance de verdict pour la sécurité topologique et le socket du moteur de rendu pour la génération finale des artefacts). 2. Pipelines d’implémentation : la logique de mutation propre au Component est orchestrée par le Manifest ; lorsqu’il résout une interface abstraite vers une Recipe concrète, cette implémentation déclare explicitement un tableau séquentiel pipeline de plugins Wasm à exécuter. Le compilateur se contente d’alimenter ces sockets définis avec le graphe de représentation intermédiaire (IR), indépendant des capacités, ce qui garantit que toute la logique propre au domaine reste strictement versionnée dans l’écosystème au lieu d’être codée en dur dans le noyau du compilateur.
  • Compilation à plat et atomicité des Feature : Aggrega ne gère pas d’état, n’interroge pas de points de terminaison et n’attend pas la fin d’un déploiement progressif. Le compilateur évalue les modules imbriqués et les résout en un graphe de représentation intermédiaire (IR) plat et unidimensionnel avant de transmettre les données aux plugins de rendu Wasm. Point essentiel, bien que le graphe soit aplati, le compilateur préserve l’atomicité des Feature. Si une fonctionnalité de proxy déclare de manière autonome une arête réseau vers un coffre-fort sécurisé, le compilateur enregistre l’origine sémantique de cette arête, ce qui permet aux moteurs de politiques Wasm d’effectuer des recherches en $O(1)$ sans attribuer à tort la connexion au composant parent. Enfin, pour prendre en charge le séquencement temporel, chaque frontière de la Release porte une valeur syncWave: <integer> ; chaque plugin de rendu traduit la vague de chaque frontière dans le moyen par lequel sa propre cible exprime l’ordre — une annotation d’ordre d’exécution que lit le contrôleur GitOps en aval, ou une dépendance entre les services du fichier qu’il produit — tandis qu’une cible dépourvue de toute surface d’ordonnancement enregistre la vague sans s’en servir pour séquencer.

4. L’ontologie sémantique : identification et taxonomie

  • L’ontologie opérationnelle cloud-native : pour garantir que les plugins Wasm open source et les politiques d’entreprise puissent interopérer universellement, le label component.aggrega.ai/type correspond exclusivement à un ensemble fermé de primitives cloud universelles (server, worker, task, function, stateful-server, resource). Il s’agit de la clé propre d’Aggrega : le schéma publié du Component énumère les valeurs qu’elle prend, et un document qui porte toute autre valeur est refusé au chargement. Fixer ce vocabulaire de façon centrale est ce qui garantit que les moteurs de politiques autonomes et les plugins de rendu Wasm construits par la communauté lisent le même mot pour la même forme lorsqu’ils rencontrent un Component qu’aucun de leurs auteurs n’a écrit. Le compilateur n’infère pour autant rien de la chaîne : il compare la valeur à un sélecteur et ne provisionne rien de sa propre initiative ; ce que l’ensemble fermé apporte, c’est que le sélecteur de chacun compare le même vocabulaire.
  • Classer selon un axe qu’Aggrega ne définit pas : l’ensemble fermé couvre cette seule clé réservée. Un catalogue qui a besoin de sa propre classification (un niveau, une zone de données, une classe de service, une subdivision plus fine des primitives) définit sa propre clé de label à côté de la clé réservée, puisque le schéma du Component accepte toute clé de label supplémentaire avec une valeur de type chaîne et que toutes les surfaces de sélection la lisent de la même façon. L’extension se fait sur votre clé, pas à l’intérieur de celle d’Aggrega, et c’est ce qui permet à un vocabulaire d’entreprise de s’enrichir sans que le vocabulaire partagé dérive.
  • Duck typing (traits sémantiques via des labels) : si les types de base sont purement cloud-native, toute l’intelligence cognitive, opérationnelle et de conformité est superposée entièrement par duck typing sémantique. Les labels rédigés par le Platform Architect (par ex. model.aggrega.ai/capability: generative, compliance.aggrega.ai/data-class: restricted) constituent la véritable identité du nœud. Les Features se lient dynamiquement aux composants en fonction de ces sélecteurs de labels.

5. Gouvernance d’entreprise : schémas et héritage

  • Partitionnement strict des API et découvrabilité en entreprise : conformément aux standards Kubernetes, toutes les définitions de charge utile résident uniformément dans un bloc spec:. L’identité de la ressource, les labels caractéristiques et les instructions explicites au compilateur résident strictement dans le bloc metadata:. Pour garantir une résolution stricte, tout artefact YAML partageable impose strictement une chaîne SemVer version contrôlée par expression régulière. En outre, pour prendre en charge la découvrabilité dans les registres OCI et la gouvernance du cycle de vie, le bloc metadata accepte une suite de métadonnées d’entreprise facultative. Cette suite comprend description, un tableau d’objets structuré maintainers (nom, e-mail, url), license, repository, home (URL de la documentation) et keywords (pour l’indexation de la recherche). La fin de vie se gère en dehors du document : aggrega deprecate attache un marqueur de dépréciation signé — une gravité, une raison et un remplacement facultatif — à un artefact déjà publié sans modifier ses octets publiés.

  • Extensibilité des schémas (le modèle CRD de Kubernetes) : pour éviter de mettre à jour le schéma du compilateur central pour chaque nouvelle fonctionnalité IA ou d’infrastructure, la plateforme utilise JSON Schema 2020-12 pour valider les configurations. Les Platform Architects écrivent des types stricts, une logique de validation et des valeurs par défaut directement dans le bloc schema: des composants du catalogue, généralement sous forme compacte, une notation abrégée à l’allure YAML qui place les contraintes de chaque champ sur une ligne (port: { type: integer, min: 1, max: 65535, default: 8080 }) et se compile en JSON Schema 2020-12 avant l’exécution de la validation. Le YAML JSON Schema complet reste une option de rédaction de même rang pour les schémas qui ont besoin de son vocabulaire complet. Les catalogues qui deviennent assez grands pour tirer parti de la réutilisation des schémas d’un Component à l’autre regroupent les formes communes (blocs de sonde, limites de ressources, formes de ports nommés) dans une entité dédiée SchemaLibrary et y font référence via le mot-clé JSON Schema $ref:.

  • Héritage des schémas (références de base de la charge utile) : pour qu’une référence de base ne soit rédigée qu’une seule fois, la plateforme divise l’héritage en deux niveaux distincts. Les métadonnées YAML standard (labels sémantiques compris), les mappages du Manifest et les configurations de la Release utilisent des stratégies de fusion traditionnelles pour permettre les surcharges d’environnement nécessaires. Les schémas de charge utile (schema:) ne fusionnent pas de cette façon, et les deux types de catalogue suivent des voies différentes : le schema: d’une Feature se compose avec celui de sa base selon la sémantique de composition de JSON Schema 2020-12, parcouru au chargement de l’espace de travail par un outil de fusion qui marque la provenance par position dans la source, de sorte que chaque feuille du schéma fusionné porte son fichier d’origine ; un Component qui en étend un autre ne rédige aucun contenu de charge utile : il écrit le marqueur littéral schema: inherited et reçoit le bloc de sa base exactement tel que la base l’a rédigé, à chaque profondeur d’une chaîne. La référence de base d’un Component est donc garantie par construction plutôt que par politique : le contrat de l’enfant est tout simplement celui de la base, de sorte que l’enfant n’a rien à assouplir. Ce qu’un tel Component compose à la place, c’est la structure (ses emplacements de rattachement, ses sockets de topologie, sa liste d’autorisation d’auto-injection et ses assertions nommées), et un enfant qui a besoin d’une règle plus stricte que celle que déclare sa base l’exprime sous la forme d’une entrée assertions: supplémentaire, que les règles de la base conservent à leurs côtés au lieu d’être remplacées. La sécurité topologique plus large et la gouvernance des labels restent dûment déléguées au socket de gouvernance Wasm.

  • Parité d’interface et implémentation automatique : pour éviter que les Ops dupliquent des YAML de Recipe lorsqu’un Architect crée une variante légèrement modifiée d’un Component de base, une Recipe écrite pour une base sert chaque Component qui l’étend, à n’importe quelle profondeur de la chaîne. Le Component qui étend écrit schema: inherited ; il n’ajoute donc à values/infra/provides aucune clé racine que la Recipe de la base serait incapable de consommer. Le Manifest mappe tout de même le type qui étend avec une entrée qui lui est propre, et la vérification du mapping accepte cette entrée lorsque l’implements de la Recipe mappée nomme le type ou n’importe quelle base qu’il étend (voir Une Recipe écrite pour une base sert tout ce qui l’étend). Le traqueur d’infrastructure fantôme (qui émet des avertissements lorsqu’aucun template déclaré par la Recipe liée ne lit une clé rédigée, afin d’éviter l’« infrastructure fantôme ») est le garde-fou correspondant de la phase de rendu.

  • Correspondance de version de implements : le champ implements des Recipes et des FeatureRecipes prend en charge trois formes pour équilibrer rigueur et flexibilité de l’écosystème :

    1. Version exacte : implements: "core/api-server:1.0.0" — correspond uniquement à 1.0.0. Pour les Recipes étroitement couplées à une version de schéma précise.
    2. Compatible majeure (plage SemVer) : implements: "core/api-server:^1.0.0" — correspond à >=1.0.0, <2.0.0. Conçue pour les Recipes qui s’appuient sur les garanties de compatibilité SemVer du Component : les incréments mineurs et de correctif sont supposés rétrocompatibles selon SemVer, et le compilateur vérifie que la version du Component satisfait la plage.
    3. Sans version : implements: "core/api-server" — correspond à n’importe quelle version. Pour les Recipes réellement indépendantes de la version (par ex. une Recipe de worker générique qui n’utilise que .context.inject.env et aucun champ values propre à une version).

    implements ne sélectionne jamais une Recipe : le Manifest nomme la Recipe de chaque type de composant, et le compilateur vérifie que l’implements de la Recipe mappée accepte ce type sous l’une des trois formes, et s’arrête en cas de non-correspondance. C’est par cette même déclaration que le compilateur suggère des Recipes candidates lorsqu’un type de composant n’a pas de mapping.

    Le modèle à trois formes permet aux Recipes de déclarer le contrat de version adapté à leur couplage réel avec le schéma du Component. Les Recipes étroitement liées à une version de schéma précise l’épinglent exactement ; les Recipes qui s’appuient sur les garanties de compatibilité SemVer du Component utilisent une plage compatible majeure ; les Recipes dont le comportement ne dépend pas du tout de la version du Component restent sans version. Il en résulte que les incréments mineurs de version du Component n’obligent les Ops ni à épingler les versions des Component, ni à maintenir des Recipes parallèles pour chaque version.