Features d’IA
L’ensemble de Feature d’IA d’Aggrega
Pour répondre aux exigences propres, à la volatilité et aux menaces de sécurité des systèmes d’IA modernes, Aggrega intègre une intelligence spécialisée directement dans sa bibliothèque standard d’IA (le Catalogue) open source. Elle garantit que l’échafaudage cloud-native générique et les moteurs de raisonnement nativement IA hautement spécialisés coexistent en toute sécurité.
Le compilateur Go central est un routeur universel neutre vis-à-vis du contenu ; toute l’intelligence propre à l’IA réside dans des politiques WebAssembly (Wasm) enfichables et dans les déclarations JSON Schema 2020-12 que les architectes de plateforme rédigent sur les entités du Catalogue.
1. L’ontologie cloud opérationnelle et le duck typing de l’IA
Pour relier l’Open Application Model (OAM) générique aux réalités strictes de l’infrastructure moderne, le label component.aggrega.ai/type correspond exclusivement à un ensemble fermé de primitives cloud-native universelles. Cette identité sémantique est ce que lisent un sélecteur de socket, l’appliesTo d’une Feature et une politique de gouvernance pour savoir comment un composant traite l’état, l’entrée réseau et les cycles de vie ; le compilateur la compare comme une chaîne opaque et ne se branche pas sur elle, et la façon dont un composant est rendu est décidée par la Recipe que le Manifest lui associe.
Les types cloud-native (la base d’infrastructure) :
server: calcul sans état de longue durée qui attend du trafic applicatif entrant (par ex. un AI Gateway ou une interface de chat).worker: calcul sans état de longue durée qui consomme des files d’attente ou exécute des boucles en arrière-plan sans aucun port applicatif entrant (par ex. un agent LangGraph ou un worker Celery).task: calcul éphémère qui s’exécute jusqu’à son terme puis s’arrête (par ex. des scripts de migration de base de données).function: calcul piloté par les événements qui se réduit à zéro (par ex. AWS Lambda).stateful-server: calcul dans le cluster qui exige des identités réseau stables et des disques permanents (par ex. une base de données vectorielle Qdrant, un broker Kafka).resource: infrastructure externe, gérée par la plateforme (par ex. AWS RDS PostgreSQL, des buckets S3, un bus d’événements hébergé).
L’ensemble est propre à Aggrega et il est fermé. Le schéma de Component publié énumère ces valeurs, et un document portant toute autre valeur est refusé au chargement — E0215 nomme le label et liste ce qu’il accepte. C’est ce que l’axe apporte : une Feature ou un sélecteur de socket écrit par rapport à stateful-server signifie la même chose dans tous les catalogues qu’il rencontre.
Ce qu’un composant est dans votre propre vocabulaire va sur votre propre clé. Un niveau, une zone de données, une classe de service, une subdivision plus fine des primitives — chacun est une clé de label que vous rédigez à côté de la clé réservée, puisque le schéma de Component accepte toute autre clé de label à valeur chaîne et que chaque surface de sélection la lit de manière identique. C’est le même mécanisme qu’utilisent déjà les labels de duck typing d’IA décrits plus bas ; la clé réservée est le socle commun, et tout ce qui est au-dessus vous appartient.
Le type opérationnel n’est pas la catégorie de navigation, et ce sont des axes séparés à dessein. Un broker Kafka se trouve dans la catégorie messaging — là où un utilisateur le cherche — et porte stateful-server comme type, parce que c’est ce que l’infrastructure doit faire pour lui. Un sélecteur écrit par rapport à un axe ne correspond jamais sur l’autre.
Voir entities/component pour les tableaux de la taxonomie des labels sémantiques — les labels Generic Cloud Layer, Specialized AI Layer, Cross-Cutters et Dynamic Business Context que les architectes utilisent pour superposer une identité cognitive aux types de base.
1.1 Le standard du catalogue open source : « Base nue, bords spécialisés »
Lors de l’application de ces labels, il existe une distinction essentielle entre le Catalogue open source officiel d’Aggrega (core/*) et un Catalogue d’entreprise privé (acme/*).
Pour que le catalogue open source officiel reste universellement utilisable, il doit distinguer strictement la physique technique immuable de l’intention cognitive subjective. Si le core/datastore/postgres à usage général est codé en dur avec engine: relational, un plugin de verdict de gouvernance configuré pour imposer la correspondance des types de datastore arrêtera le build lorsqu’un développeur active l’extension pgvector dans ses values et tente de connecter un agent d’IA qui exige un datastore vector.
Pour conserver un catalogue central sans parti pris, les composants officiels suivent ce standard : garder la base nue et spécialiser les bords.
- La base nue : le
Componentopen source de niveau racine ne code en dur que ce qui est objectivement vrai du produit et ne peut être modifié par rien de ce qu’un auteur configure — d’abord et toujours la primitive opérationnelle (component.aggrega.ai/type). Une base de données Postgres est objectivement unstateful-server; ce fait ne peut pas changer. Le même critère admet un label de capacité lorsque l’identité du produit est cette capacité :core/datastore/qdrantetcore/datastore/weaviatesont des moteurs de recherche vectorielle et rien de ce qu’un auteur écrit n’en fait autre chose, de sorte que chacun portedatastore.aggrega.ai/engine: vectorsur la base, exactement commecore/datastore/redisportekv. Ce que la base nue refuse, c’est le cas inverse — un trait qui dépend de la façon dont un composant est configuré ou utilisé, et pour lequel existe le troisième mécanisme ci-dessous. - Les interfaces spécialisées (héritage de schéma) : un Component peut déclarer
extends, en nommant un autre Component comme base, et ce que cela compose, c’est la structure : labels, annotations, slots d’attachement, la liste d’autorisation d’auto-injection, les sockets de topologie et lesassertionsnommées. Les trois piliers de données ne se composent pas — un Component qui étend écrit le marqueur littéralschema: inheritedet ne rédige aucun contenuvalues,infraouprovidespropre, de sorte que son contrat est identique à celui de sa base. C’est pourquoi le mécanisme restreint au lieu de varier : comme le contrat est inchangé, toute Recipe écrite pour la base sert déjà la spécialisation, et la spécialisation coûte une entité de catalogue et une ligne de mapping dans le Manifest. Ce qu’une spécialisation ajoute est donc une identité que lit un sélecteur ou une politique — un niveau d’audit, une zone de données, un contact de gouvernance, ou un socket dont le sélecteur admet moins que celui de la base. Elle ne peut pas ajouter un contrat différent, car elle n’a aucune surface sur laquelle en rédiger un. Une conséquence passe facilement inaperçue : la ligne de mapping reste obligatoire. La sélection de la Recipe se fait par clé de mapping exacte, de sorte qu’une spécialisation a besoin de sa propre entréemappings.components.typemême si elle n’a pas besoin de sa propre Recipe. Voir examples/extends-wrapper pour un wrapper publié qui ajoute un label de niveau revu et restreint un socket sur ce label, ainsi que le build qui s’arrête lorsqu’une arête câblée dans ce socket quitte le niveau. Un trait qui dépend de la façon dont un composant est configuré n’est pas l’objet de ce mécanisme : une spécialisation épingle l’artefact de sa base et hérite de son contrat, donc un trait vrai de la spécialisation est déjà vrai de la base, où la règle de la base nue le place. Un tel trait relève du mutateur dynamique ci-dessous. - Le mutateur dynamique (promotion Wasm) : si un trait est dicté par la charge utile du développeur (par ex.
enable_vector: true), l’entreprise utilise le rôlelabel-transformdu socket de gouvernance lors de la construction de la topologie pour lire dynamiquement lesvaluesopaques et injecter automatiquement le labeldatastore.aggrega.ai/engine: vectordans le graphe IR avant l’exécution des politiques. C’est ici qu’un trait dépendant de la configuration devient disponible pour une évaluation stricte des politiques — ce sont lesvaluesdéclarées par le développeur qui le promeuvent, et la transformation s’exécute avant qu’une politique ne lise un label.
L’exception d’entreprise : parce que le compilateur est sans parti pris, les entreprises qui rédigent leurs propres catalogues internes sont libres d’enfreindre cette règle. Si une politique de sécurité d’entreprise stipule que toutes les bases de données internes sont hautement sensibles, l’architecte de plateforme peut et doit coder en dur compliance.aggrega.ai/data-class: restricted (ou un label similaire imposé par l’entreprise) directement sur son composant de base acme/postgres, de sorte que chacune de ses instances porte la classe et qu’une politique attachée par l’entreprise la lise sur chacune. Le label lui-même n’impose rien : le compilateur le transporte sous forme de chaîne, et c’est la politique attachée qui arrête un build. Lorsque seuls certains usages d’un produit au sein d’un parc détiennent ces données, c’est plutôt une spécialisation via extends qui porte la classe — voir examples/policy-data-class-route, dont l’assistant de sinistres est l’agent LangGraph de la bibliothèque standard plus un label de classe, à côté de la politique qui le lit.
1.2 Comment les labels sémantiques alimentent le pipeline du compilateur
Pour garder les labels dans le domaine de l’architecte de plateforme, les développeurs ne peuvent pas écrire de labels sur leurs instances de Component à l’intérieur de l’Aggregate : le schéma de l’Aggregate ne donne à une instance de composant aucune clé labels. Les labels d’un nœud sont ceux de son entité de catalogue, ainsi que tous ceux qu’un attachement de gouvernance label-transform configuré par l’opérateur ajoute lors de la construction de la topologie. Voici exactement comment ces labels pilotent le pipeline de compilation sans nécessiter de code Go personnalisé :
1. component.aggrega.ai/type (la primitive de base)
- Qui l’écrit ? L’architecte de plateforme (domaine 2). Il est obligatoire pour chaque composant du catalogue.
- Qui le consomme ? L’analyseur statique et les Plugins de rendu Wasm.
- Cas d’usage dans le compilateur : c’est l’ontologie cloud opérationnelle centrale. L’analyseur statique évalue nativement en Go les chaînes de sélecteur
usesSchemapour garantir qu’un développeur ne peut pas attacher un agent à une base de données standard si le socket exige une capacité d’IA spécifique. En outre, l’équipe DevOps utilise ce label pour router explicitement les primitives avec état (stateful-server,resource) vers des frontières physiques de cluster qui prennent en charge des disques persistants, tandis qu’un rôle de verdict de gouvernance peut imposer que les composants avec état ne soient jamais placés dans des frontières uniquement éphémères.
2. model.aggrega.ai/capability
- Qui l’écrit ? L’architecte de plateforme.
- Qui le consomme ? L’analyseur statique (via les sélecteurs de labels de style Kubernetes des sockets
usesSchema). - Cas d’usage dans le compilateur : lorsqu’un architecte rédige un sélecteur
usesSchemanommant le label de capacité requis, le moteur natif de correspondance de labels du compilateur rejette tout câblage qui ne satisfait pas le sélecteur avant que les artefacts soient générés. Le compilateur traite ces labels comme des chaînes opaques ; la signification sémantique de « text-generation » par rapport à « embedding » réside dans la rédaction du sélecteur par l’architecte.
3. component.aggrega.ai/hosting
- Qui l’écrit ? L’architecte de plateforme.
- Qui le consomme ? Le moteur de politiques (un rôle de verdict de gouvernance), les Plugins de rendu Wasm et les appelants d’un modèle ou d’un agent propres à la bibliothèque standard : ses agents, dont l’assertion le lit sur chaque connexion
model,core/ai-tool/agent-invocation, dont l’assertion le lit sur sa connexiontarget_agent, tout comme sa réalisation Kubernetes, qui refuse un identifiant à un agentexternalatteint viahttp, la passerelle d’IA, dont l’assertion le lit sur chaque connexion à ses socketsmodelsetcache_store, etcore/gateway/kong,core/gateway/kong-enterprise,core/gateway/apisix,core/gateway/envoy-gateway,core/gateway/traefik-hub,core/gateway/agentgatewayetcore/gateway/higress, dont les assertions le lisent sur chaque connexion à leurs socketsmodels, ainsi qu’aubackenddes deux Kong, aux socketscache_stored’APISIX et de Traefik Hub et aux socketscached’Envoy Gateway, de Higress et de Traefik Hub — voir « La clé que présente un appelant » ci-dessous. - Cas d’usage dans le compilateur : il enregistre qui exploite la ressource sous-jacente du composant, ce qui permet à une politique attachée par un opérateur d’évaluer le risque d’exfiltration de données ; le compilateur lit la valeur comme une chaîne et ne juge rien. Lorsqu’un agent dont le label de classe indique qu’il détient des données
internalse connecte à un modèle étiquetémanaged— un service exploité hors de la frontière propre de la Release — une telle politique peut lire que les données quittent cette frontière, et arrêter le build à moins que la connexion ne soit routée via une passerelle d’IA portantcore/data-masking, qui masque le texte de chat et de complétion que la passerelle transmet. Le socketmodeld’un agent accepte une telle passerelle à la place du modèle, de sorte que cette route est une arête du graphe que lit la politique, et un modèle que la passerelle sert depuis son socketmodelsest une arête à part entière, de la passerelle au composant du modèle, dont la politique lit les labels — ainsi le chemin d’un agent à travers la passerelle jusqu’à un modèlemanagedfigure dans le graphe de bout en bout. Un upstream saisi à la main dans la map des modèles de la passerelle ne l’est pas : c’est une chaîne que le compilateur ne résout pas, donc une politique qui lit le graphe voit la passerelle et rien derrière. examples/policy-data-class-route est une telle politique : ses paramètres classent un modèlemanagedcommepublic, et elle arrête un build dans lequel un assistant détenant des donnéesrestricteden atteint un sans passerelle de masquage sur la route. C’est un trait transversal : les mêmes valeursself-hosted | managed | externaldécrivent une base de données gérée ou un serveur d’inférence auto-exploité tout comme elles décrivent un modèle, c’est pourquoi le label se trouve sous l’espace de noms partagécomponent.aggrega.ai/plutôt que sous celui propre aux modèles.
4. agent.aggrega.ai/autonomy
- Qui l’écrit ? L’architecte de plateforme.
- Qui le consomme ? Le moteur de politiques (un rôle de verdict de gouvernance).
- Cas d’usage dans le compilateur : il identifie le risque d’exécution de la boucle cognitive. Si un agent est étiqueté
autonomous(c’est-à-dire qu’il exécute des boucles en arrière-plan sans invites de l’utilisateur) et se connecte à une base de données hautement sensible, le moteur de politiques peut arrêter le build à moins qu’un auteur n’attache la Feature d’approbation ou de confinement qu’exigent les règles propres de l’entreprise, de sorte qu’une boucle sans surveillance ne puisse pas atteindre ces données sans revue. - Ce que signifie un composant sans label sur cet axe, car l’absence est délibérée. Le label décrit le risque d’exécution d’une boucle cognitive, donc un composant qui ne détient aucune boucle propre ne porte ici aucune valeur plutôt que la plus basse des deux. Bon nombre de composants de la catégorie des agents sont sans label précisément pour cette raison : les éléments de support qu’une plateforme d’agents livre à côté de son serveur — une console dans le navigateur, une exécution de migration de schéma, un task worker, un bac à sable de code, un proxy de sortie — se trouvent dans cette catégorie parce que c’est là que vous les cherchez, tandis que la boucle qu’ils soutiennent vit dans le serveur de la plateforme, qui est l’endroit où se trouve le label. Le cas le plus clair est un même produit réparti entre les deux traitements : le serveur d’une plateforme porte
copilot, et le bac à sable de code livré à côté ne porte rien. Le critère est l’endroit où vit la boucle et non la forme que prend l’élément, de sorte qu’un runtime qui héberge du code d’agent que vous fournissez est lui aussi sans label — la boucle y est ce que vous y déployez, et non quelque chose que le produit affirme. Un sélecteur nommant l’une ou l’autre valeur correspond donc aux composants qui détiennent une boucle et à aucun autre, et un sélecteur écrit pour correspondre à n’importe quelle posture d’autonomie ignore les éléments de support au lieu de les traiter comme ce qu’il y a de moins autonome dans le déploiement.
5. gateway.aggrega.ai/intelligence
- Qui l’écrit ? L’architecte de plateforme.
- Qui le consomme ? L’analyseur statique, et les plugins Wasm de linting rédigés par l’entreprise.
- Cas d’usage dans le compilateur : il détermine les fonctionnalités qu’un routeur peut physiquement prendre en charge. La Feature d’IA
fallback-chaindéclareappliesTo: gateway.aggrega.ai/intelligence=semantic, et l’analyseur statique évalue ce sélecteur par rapport aux labels du composant cible avant qu’aucun artefact ne soit rendu. Si un développeur l’attache à une passerellel4-meshstandard, le build s’arrête sur une violation de sélecteur qui nomme la Feature et le sélecteur non satisfait, parce que l’architecte a rédigé ce sélecteur en sachant qu’un maillage TCP standard ne peut pas analyser les charges utiles JSON des LLM pour lire le modèle qu’une requête nomme. Le refus repose sur l’absence desemanticplutôt que sur la présence del4-mesh, il vaut donc également pour un routeur qui ne porte aucun label d’intelligence. Le compilateur traite le label comme une chaîne opaque, exactement comme ci-dessus : ce que signifiesemanticréside dans la rédaction du sélecteur par l’architecte. Sur un routeur qui porte biensemantic, l’attachement satisfait le sélecteur, et ce qui se passe ensuite relève de sa réalisation : la réalisation de la bibliothèque standard écrit la chaîne dans la configuration de routage de la passerelle d’IA. - Ce que porte la bibliothèque standard. Ces composants portent
semantic:core/gateway/litellm, dont la réalisation rend la table de routage du proxy : une map de modèles sur plusieurs fournisseurs upstream ;core/gateway/cloudflare-ai-gateway, la passerelle hébergée de Cloudflare, qui lit chaque requête de modèle qu’elle transmet — le modèle qu’elle nomme, les tokens qui lui sont facturés et, lorsque les vérifications propres de la passerelle sont activées, son contenu ;core/gateway/azure-api-management, la passerelle d’IA d’Azure API Management, un service hébergé, qui lit chaque requête de modèle sur une API servant un modèle — le prompt que compare son cache sémantique, les tokens qu’indique une réponse et le contenu que sa vérification de sécurité envoie pour inspection ;core/gateway/apisix, dont le proxy d’IA lit le corps de chaque requête sur une route servant un modèle et les tokens qu’indique la réponse du modèle ;core/gateway/envoy-gateway, dont l’extension Envoy AI Gateway lit le corps de chaque requête sur la route servant les modèles qui lui sont câblés, pour trouver le modèle qu’elle nomme, ainsi que les tokens qu’indique chaque réponse ;core/gateway/kong-enterprise, Kong Gateway Enterprise, dont le proxy d’IA lit le corps de chaque requête sur une route servant un modèle câblé — le modèle qu’elle nomme et les messages qu’elle transporte — ainsi que les tokens qu’indique chaque réponse ;core/gateway/traefik-hub, Traefik Hub, dont le middleware Chat Completion lit le corps de chaque requête sur la route servant un modèle câblé, le vérifie par rapport au schéma de chat completion et lit les tokens qu’indique chaque réponse ;core/gateway/agentgateway, agentgateway, qui lit le corps de chaque requête sur ses chemins de service de modèles pour trouver le modèle qu’elle nomme, ce qui est sa façon de choisir le modèle câblé auquel une requête est envoyée, ainsi que les tokens qu’indique chaque réponse ; etcore/gateway/higress, Higress, dont le proxy d’IA lit le corps de chaque requête sur une route servant un modèle câblé — le modèle qu’elle nomme et si elle est en streaming — et dont les plugins lisent les tokens qu’indique chaque réponse — de sorte que les Features d’IA qui exigent cette valeur se résolvent par rapport à chacun d’eux, et que chaque réalisation indique ce que sa passerelle respecte, ou arrête le build là où sa passerelle n’en respecte rien ; une Feature sans réalisation pour une passerelle y arrête le build, en nommant son type. Aucun composant ne portel4-mesh, et les autres composants de passerelle de la bibliothèque standard ne portent aucun label d’intelligence : ceux qui routent du trafic terminent HTTP et routent en couche 7, et l’un d’eux est un plan de contrôle qui ne route rien du tout, de sorte qu’aucune des deux valeurs ne le décrit. Un maillage TCP de couche 4 est encore une autre classe de produit. Le refus ci-dessus reste donc pleinement en vigueur, car il repose sur l’absence desemantic: un attachement exigeant cette valeur s’arrête sur n’importe lequel d’entre eux. Un architecte dont le catalogue exécute réellement un maillage de couche 4 apposel4-meshsur ce composant, ce qui rend la distinction sélectionnable dans les deux sens. - Cet axe nomme un niveau de produit, ce qui est une question différente de ce qu’un composant peut faire au trafic, et le lire dans ce second sens est l’erreur à laquelle il invite.
semanticindique que le routeur analyse le corps de la requête, ce dont a besoin un contrôle qui agit sur le modèle nommé par une requête — c’est donc le bon axe pour cela. Il ne dit rien de la capacité d’un routeur à copier le trafic, à transmettre l’identité d’un appelant, à vérifier le certificat d’un upstream, à refuser un prompt qui correspond à une liste de motifs ou à tenir un budget sur une période, et une Feature qui a besoin de l’une de celles-ci n’a aucune raison d’interroger le niveau : la plupart des composants qui les offrent sont des proxys de couche 7 ordinaires sans aucune valeur d’intelligence, et lorsqu’un routeursemanticen offre une, il l’offre pour des raisons que le niveau n’enregistre pas. Le niveau atteint donc le mauvais ensemble dans les deux sens — il exclut entièrement les proxys simples et ne dit rien des capacités dont dispose réellement la passerelle d’IA qu’il atteint. Cette question relève de l’axe du chemin des données décrit plus bas, et les deux se combinent — une Feature peut exiger un routeursemanticqui effectue aussi la mise en miroir, en nommant les deux.
6. tool.aggrega.ai/impact
- Qui l’écrit ? L’architecte de plateforme.
- Qui la consomme ? Le moteur de politiques et les Plugins Wasm de rendu.
- Cas d’usage du compilateur : En sortant cette information du bloc
valuesmodifiable du développeur pour la placer dans l’identité immuable des labels, il permet au moteur de politiques d’évaluer des configurations strictes de moindre privilège. Un plugin de rendu peut générer des permissionsinvokestandard pour un outil de recherche webread-only, mais exiger des configurations strictes de signature cryptographique pour invoquer un outilmutatingde suppression SQL.
7. compliance.aggrega.ai/data-class
- Qui l’écrit ? L’architecte de plateforme du catalogue propre à un parc informatique (ou injectée dynamiquement via le rôle de gouvernance
label-transform). - Qui le consomme ? Le moteur de politiques (un rôle de verdict de gouvernance).
- Cas d’usage du compilateur : Il donne aux données que détient un composant une identité de gouvernance qu’une politique peut suivre le long du graphe. Le compilateur transmet le label au graphe IR comme une chaîne et ne classe rien : il ne sait pas que
restrictedest plus sensible quepublic, ni que l’un ou l’autre mot signifie quoi que ce soit. Une politique attachée au rôleir-verdictfournit ce sens dans ses propres paramètres — quelles classes existent et comment elles se classent — et lit le label sur les composants des routes que le compilateur énumère le long des arêtesuses, de sorte qu’elle peut arrêter un build dans lequel un composant détenant des donnéesrestrictedatteint un composant d’une autre classe par une route sur laquelle n’est attachée aucune Feature que la politique considère comme déclassifiante, telle quecore/data-maskingsur la passerelle d’IA que traverse la route. L’énumération est bornée pour chaque composant de départ et ne liste rien au-delà de la borne, de sorte qu’une route que la politique lit est réelle, tandis que l’absence d’une route ne prouve pas qu’il n’en existe aucune. examples/policy-data-class-route est cette politique, écrite pour les moteurs Rego et CEL compilés dans la CLI et pour OPA, avec les builds qui s’arrêtent et celui qui aboutit côte à côte. - Ce que la bibliothèque standard fournit. Aucun Component
core/ne porte ce label. La classe des données d’un composant est une affirmation sur la façon dont un parc informatique utilise le composant, et non une propriété du produit vraie dans chaque Release ; selon la règle Naked Base, elle reste donc hors de la base : un parc informatique la porte sur son propre Component — une spécialisation viaextends, comme l’est l’assistant de sinistres de l’exemple détaillé, ou une base qui lui est propre au titre de l’Enterprise Exception décrite plus haut.
8. hardware.aggrega.ai/accelerator
- Qui l’écrit ? L’architecte de plateforme. Lorsqu’il empaquette un composant de modèle local, il sait que celui-ci a fondamentalement besoin d’un GPU pour fonctionner.
- Qui la consomme ? Le DevOps (domaine 4).
- Cas d’usage du compilateur : Le DevOps achemine explicitement les composants étiquetés GPU vers les frontières de pools de matériel physique dans la
Releasevia la mapcomponents: {}. Le développeur demande simplement le modèle cognitif dans sonAggregate, et le DevOps le place dans la frontière du coûteux cluster GPU, ce qui préserve entièrement la séparation des préoccupations. Un rôle de verdict de gouvernance peut en outre imposer qu’aucun composant portant ce label ne soit jamais placé dans une frontière dépourvue d’infrastructure GPU.
9. datastore.aggrega.ai/engine
- Qui l’écrit ? L’architecte de plateforme, sur les composants de la catégorie datastore (de manière statique, sur une spécialisation flavored, ou injectée par le rôle
label-transformlorsque lesvaluesdu développeur promeuvent le rôle). Les valeurs utilisées dans le catalogue sont :relational,document,kv,vector,graph,semantic-memory,search. Chaque valeur nomme un moteur de stockage qu’un produit est —searchnomme un moteur de recherche et d’analyse qui indexe aussi des vecteurs — de sorte qu’un trait qui réside dans le schéma et le mode d’accès propres à une application plutôt que dans un stockage déployable n’est pas une valeur de cet axe. - Qui la consomme ? L’analyseur statique (via des chaînes de sélecteur) et le moteur de politiques.
- Cas d’usage du compilateur : Les sélecteurs ciblent la sémantique de stockage plutôt que des produits — le socket de base de connaissances d’un agent sélectionne
datastore.aggrega.ai/engine in (vector, semantic-memory, search), et un moteur de politiques peut refuser l’acheminement de charges utiles SQL vers un moteur vectoriel. La pertinence pour l’IA des datastores à double usage est dérivée de ce label, et jamais stockée comme un booléen distinct. - Ce que la bibliothèque standard fournit.
core/datastore/qdrant,core/datastore/weaviate,core/datastore/chroma,core/datastore/pgvectoretcore/datastore/milvusportentvector,core/datastore/cogneeportesemantic-memory, etcore/datastore/opensearchetcore/datastore/elasticsearchportentsearch, de sorte que le sélecteur de base de connaissances ci-dessus se résout sur chacun d’eux.core/datastore/redis,core/datastore/valkeyetcore/datastore/memcachedportentkv. Chacun de ces labels se trouve sur la base propre du composant, car l’identité du produit est ce moteur. Pourcore/datastore/pgvector, cette identité est l’artefact qu’il épingle : il exécute l’image PostgreSQL du projet pgvector, qui contient l’extension, et chaque Recipe active l’extension dans la base de données que crée le composant — son trait vectoriel ne dépend donc d’aucun paramètre, et c’est ce qui le distingue du cas configuré décrit plus haut sous « Naked Base, Flavored Edges », où un PostgreSQL généraliste n’acquiert le trait que lorsqu’un développeur active une extension.relational,documentetgraphn’ont aucun composant dans la bibliothèque standard ; un sélecteur ne nommant que des valeurs parmi celles-ci ne correspond donc à rien ici et est satisfait par un catalogue qui en contient un.
10. pipeline.aggrega.ai/mode
- Qui l’écrit ? L’architecte de plateforme, sur les composants de la catégorie pipeline. Chaque valeur nomme la façon dont un produit exécute un job en plusieurs étapes, et les valeurs suivent les composants qui les portent plutôt qu’une liste fixée à l’avance. La bibliothèque standard en fournit deux :
durablesurcore/ai-pipeline/temporal, dont le moteur enregistre le résultat de chaque étape sous forme d’historique d’événements et le rejoue, de sorte qu’un job dont le worker plante reprend là où il s’était arrêté ; etreconciledsurcore/ai-pipeline/argo-workflows, dont le contrôleur exécute chaque étape comme un pod à partir d’une ressource de workflow conservée dans l’API propre du cluster. - Qui la consomme ? Le moteur de politiques et les Plugins Wasm de rendu.
- Cas d’usage du compilateur : Permet aux politiques et aux moteurs de rendu de distinguer les moteurs de pipeline selon la manière dont une exécution survit à une défaillance — un historique d’événements rejoué ou une ressource de cluster réconciliée — plutôt que selon le nom du produit.
11. dataplane.aggrega.ai/* (Les capacités du chemin des données)
- Qui l’écrit ? L’architecte de plateforme, sur tout composant qui se trouve sur le chemin du trafic — un proxy inverse, une passerelle d’entrée, un service mesh, une passerelle d’IA.
- Qui la consomme ? L’analyseur statique, via le
appliesTod’une Feature et le sélecteurusesSchemad’un socket. - Cas d’usage du compilateur : Il répond à la question de ce que ce composant peut faire au trafic, ce qu’un contrôle d’exécution a réellement besoin de savoir et ce qu’un label de niveau de produit ne peut pas dire.
core/traffic-shadowing, qui copie les requêtes en direct vers un second service à des fins d’évaluation, déclareappliesTo: dataplane.aggrega.ai/request-mirroring— la clé seule — et l’analyseur statique l’évalue par rapport aux labels de la cible avant tout rendu, de sorte que l’attacher à un composant qui ne peut pas du tout faire de mise en miroir arrête le build avec une violation de sélecteur nommant la Feature et le sélecteur non satisfait. Le compilateur traite chacune de ces chaînes comme opaque, exactement comme il traite les autres. - Pourquoi le préfixe nomme le chemin du trafic plutôt qu’un type de composant. La mise en miroir, l’identité de l’appelant et la vérification de l’upstream ne sont pas des propriétés de passerelle — ce sont des propriétés de tout ce qui se trouve sur le chemin de la requête, et un service mesh ajouté à un catalogue possède les trois. Nommer la famille d’après le type de composant qui les a portées en premier obligerait chaque type ultérieur à reformuler le même vocabulaire sous son propre préfixe, laissant une même capacité avec plusieurs noms et aucun sélecteur capable de les couvrir tous.
- Pourquoi la fidélité se trouve dans la valeur. Deux composants peuvent tous deux mettre en miroir des requêtes et différer pourtant sur ce qui importe à une Feature : l’un copie chaque requête correspondante, l’autre en copie une part paramétrable. Une clé qui dirait seulement si un composant met en miroir les admettrait tous les deux et laisserait la différence se découvrir après le rendu. Placer la fidélité dans la valeur permet de la demander de celle des deux façons qui convient à la Feature. Une Feature qui ne peut pas fonctionner du tout sans une fidélité donnée nomme cette valeur dans son sélecteur. Une Feature qui fonctionne encore avec la fidélité inférieure sélectionne sur la clé seule, et sa réalisation refuse le paramètre que le composant ne peut pas honorer : copier l’intégralité du flux fonctionne sur tout composant qui met en miroir, de sorte que
core/traffic-shadowings’attache à tous, et la réalisation pour un composant déclarantfull-raterefuse une part inférieure à 100 par un message nommant la part demandée et la fidélité déclarée par le composant — deux choses que la violation de sélecteur ne dit pas. Les valeurs sont donc dérivées de ce qu’implémentent les produits disponibles sur le marché plutôt que composées comme une taxonomie :request-mirroringportefull-rateetsampledparce que les proxys réels se répartissent exactement ainsi, l’un offrant un paramètre de taux de copie et un autre n’en offrant aucun. - Une valeur affirme une capacité, jamais un état configuré. Les deux se lisent de manière identique pour un développeur, et un seul est une propriété du composant. Un proxy capable de vérifier le certificat d’un upstream porte
upstream-tls: trust-anchor, qu’un déploiement active ou non la vérification — le label est ce sur quoi une Feature sélectionne avant que quoi que ce soit ne soit configuré, et le charger de configuration le rendrait illisible au moment même où il est utilisé. - Ce que la bibliothèque standard fournit.
core/gateway/nginxporterequest-mirroring: full-rate,upstream-tls: trust-anchoretconcurrency-cap: total, une limite unique sur chaque requête qu’il transmet.core/gateway/contourporterequest-mirroring: sampled,caller-identity: client-certificateetupstream-tls: trust-anchor.core/gateway/envoy-gatewayporte les trois mêmes valeurs quecore/gateway/contour, ainsi queperiod-budget: tokens, qui compte les tokens que signale chaque réponse d’un modèle qu’il sert via Envoy AI Gateway, etconcurrency-cap: per-target, une limite sur les requêtes en cours vers chaque modèle qu’il sert.core/gateway/kongporteupstream-tls: trust-anchoretprompt-guard: pattern-list, son AI Prompt Guard comparant les messages d’une requête de modèle aux listes que contiennent ses routes.core/gateway/tykporteupstream-pinning: public-key, que sélectionnecore/upstream-key-pinning.core/gateway/litellmportecaller-identity: injected-header,content-masking: entity-recognition,period-budget: cost,prompt-guard: pattern-list,upstream-tls: trust-anchoretconcurrency-cap: per-target, une limite sur les requêtes en cours vers chaque entrée de sa table de modèles.core/gateway/cloudflare-ai-gatewayporteperiod-budget: cost.core/gateway/apisixporteperiod-budget: tokens, qui compte les tokens que signale la réponse de chaque modèle sans rien tarifer, etprompt-guard: pattern-list.core/gateway/kong-enterpriseporteperiod-budget: tokens, qui compte les tokens que signale la réponse de chaque modèle, etcontent-masking: entity-recognition.core/gateway/traefik-hubportecontent-masking: entity-recognitionetprompt-guard: pattern-list, son middleware Content Guard masquant les correspondances des motifs que contient sa configuration ou les types d’entités que détecte un analyseur Presidio qu’il appelle, ou refusant une requête à laquelle correspond un motif, ainsi queperiod-budget: cost, tarifé à partir de la grille de prix par modèle fournie avec son middleware de quota, qui peut à la place compter les tokens que signale chaque réponse.core/gateway/agentgatewayportecontent-masking: pattern-listetprompt-guard: pattern-list, sa garde à base d’expressions régulières masquant ou refusant les correspondances des motifs que contient sa configuration sans reconnaître aucun type d’entité, ainsi queperiod-budget: cost, les budgets qu’il tient par clé d’API en dollars américains, tarifés à partir de son catalogue de coûts des modèles, ou en tokens.core/gateway/higressportecontent-masking: pattern-list, son pluginai-data-maskingmasquant les correspondances des motifs que contient sa configuration dans le texte des messages d’une requête de chat sans reconnaître aucun type d’entité, ainsi queperiod-budget: tokens, qui compte ensemble les tokens de prompt et de complétion que signale chaque réponse sans rien tarifer.core/gateway/azure-api-managementporteperiod-budget: tokens, qui compte ensemble les tokens de prompt et de complétion que signale chaque réponse, avec un décompte distinct sur chaque passerelle de l’instance, sans rien tarifer.core/security/nemo-guardrailsetcore/security/trustyai-guardrails-gateway, deux gardes qui se placent sur le chemin d’un modèle et jugent une requête au moyen d’un classifieur entraîné, portentprompt-guard: classifier, que sélectionnent les socketsguardde la passerelle d’IA et de la passerelle NGINX. Les passerelles d’IA parmi eux —core/gateway/litellm,core/gateway/cloudflare-ai-gateway,core/gateway/apisix,core/gateway/envoy-gateway,core/gateway/kong-enterprise,core/gateway/traefik-hub,core/gateway/agentgateway,core/gateway/higressetcore/gateway/azure-api-management— portentsemanticet les autres ne portent aucune valeurgateway.aggrega.ai/intelligence, ce qui est la séparation qui fonctionne et non une exception à celle-ci : une Feature qui a besoin d’un miroir atteint les trois composants qui en ont un, alors qu’un sélecteur de niveau de produit n’atteindrait parmi eux qu’Envoy Gateway, pour une raison qui ne dit rien de la mise en miroir, et une Feature qui a besoin d’une garde de prompt, d’un masquage de contenu ou d’un budget par période atteint une passerelle d’IA d’après ce qu’elle peut faire plutôt que d’après le niveau où elle se situe, tandis qu’une Feature qui limite les requêtes en cours atteint la passerelle NGINX, qui ne porte aucune valeur de niveau, comme elle atteint Envoy Gateway et la passerelle d’IA, et qu’une Feature qui refuse une requête d’après une liste de motifs atteint Kong open source, qui n’en porte aucune non plus, comme elle atteint APISIX. Un composant qui n’a rien à décrire sur l’un de ces axes n’y porte aucune valeur plutôt que la plus faible, de sorte qu’un sélecteur nommant une valeur quelconque sur cet axe ne s’y attache pas, à juste titre.
12. security.aggrega.ai/text-anonymization
- Qui l’écrit ? L’architecte de plateforme, sur un service qui participe au masquage de texte sensible. Lorsque ce travail est réparti entre deux services,
analyzerva sur celui qui trouve les segments sensibles d’un texte et les signale, etanonymizersur celui qui réécrit les segments qui lui sont remis ;sanitizerva sur un service qui fait les deux en un seul appel, en trouvant les segments sensibles dans le texte qui lui est envoyé et en les réécrivant lui-même, puis en répondant avec le texte réécrit. - Qui la consomme ? L’analyseur statique, via le sélecteur
usesSchemad’un socket. - Cas d’usage du compilateur : c’est ainsi qu’un consommateur reçoit la bonne adresse.
core/gateway/litellmdéclare un socketpii_analyzerqui sélectionnesecurity.aggrega.ai/text-anonymization=analyzeret un socketpii_anonymizerqui sélectionne la valeuranonymizer, de sorte que câbler l’un des deux services sur le socket de l’autre arrête le build sur une violation de sélecteur qui nomme le socket.core/gateway/kong-enterprisedéclare un seul socket,pii_sanitizer, qui sélectionne la valeursanitizer, etcore/gateway/traefik-hubun seul,pii_analyzer, qui sélectionne la seule valeuranalyzer, car le Content Guard que sa Recipe de chart écrit pourcore/data-maskingremplace lui-même ce que l’analyseur trouve. Le compilateur achemine l’adresse que publie le composant sélectionné et ne vérifie rien de ce qui y répond. - Ce que la bibliothèque standard contient.
core/security/presidio-analyzerporteanalyzeretcore/security/presidio-anonymizerporteanonymizer. Tous deux parlent l’API HTTP de Presidio que la passerelle IA appelle lorsqu’un rattachement decore/data-masking, ou levalues.log_maskingpropre à la passerelle, liste des types d’entités, et le Content Guard de Traefik Hub n’appelle que l’analyseur lorsqu’un rattachement decore/data-maskingsur cette passerelle les liste.core/security/kong-ai-pii-serviceportesanitizeret parle l’API du service AI PII de Kong, que l’AI PII Sanitizer de Kong Gateway Enterprise appelle avec chaque texte qu’il masque, ses expressions régulières comprises, tant qu’un rattachement decore/data-maskingest présent sur cette passerelle. Le sanitizer ne lui présente aucun identifiant et chaque texte lui parvient non masqué, de sorte que son adresse est interne au cluster et n’est pas destinée à être exposée au-delà du cluster.
13. model.aggrega.ai/api
- Qui l’écrit ? Le Platform Architect, sur chaque composant de la catégorie model et sur une passerelle qui sert une API de modèles. La valeur indique quelle API de modèles répond à l’adresse que publie le composant :
openailorsqu’il s’agit de l’API OpenAI — celle du fournisseur lui-même ou l’implémentation qu’en fait un serveur —,anthropiclorsqu’il s’agit de la Messages API d’Anthropic,geminilorsqu’il s’agit de la Gemini API de Google, etnativelorsqu’il s’agit de l’API propre du produit et d’aucune de celles-ci, qu’un consommateur atteint via le client de ce produit. Chaque valeur est lue dans la référence propre du produit, et un composant la porte quoi que configure une Release donnée. - Qui le consomme ? Le Static Analyzer, via le sélecteur
usesSchemad’un socket, et les assertions de la passerelle IA, decore/gateway/kong, decore/gateway/kong-enterprise, decore/gateway/apisix, decore/gateway/envoy-gateway, decore/gateway/traefik-hub, decore/gateway/agentgatewayet decore/gateway/higress, sur chaque connexion à leurs socketsmodels. - Cas d’usage du compilateur : c’est ce qui permet à un même socket d’accepter soit un modèle, soit une passerelle qui sert des modèles. Le socket
modelde chaque agent sauf les cinq runtimes nommés plus bas, le sockettarget_modeldecore/ai-tool/model-invocationet les deux sockets de modèle decore/datastore/cogneesélectionnentcomponent.aggrega.ai/category in (ai-model, gateway), model.aggrega.ai/api: l’exigence de catégorie admet les deux catégories, et l’exigence de clé n’admet parmi leurs composants que ceux qui portent le label, de sorte que câbler un tel socket sur une passerelle qui ne sert aucune API de modèles arrête le build sur une violation de sélecteur qui nomme le socket. Les exigences d’un sélecteur doivent toutes être satisfaites et ses alternatives se trouvent dans l’ensemble d’une seule clé, si bien que l’unique clé à laquelle répondent les deux sortes de composants doit figurer sur chaque composant de modèle aussi bien que sur la passerelle — c’est pourquoi le label nomme une API au lieu de marquer les seules passerelles. Une passerelle qui le porte publie les clésendpointetmodelque publie un modèle, de sorte que la Recipe d’un consommateur lit l’une ou l’autre de la même manière. Un agent dont les Recipes fournissent les variables d’une seule API de modèles en nomme plutôt la valeur : les socketsmodeldecore/ai-agent/openai-agents-sdk,core/ai-agent/agent-frameworketcore/ai-agent/mastrasélectionnentmodel.aggrega.ai/api=openai, celui decore/ai-agent/claude-agent-sdksélectionnemodel.aggrega.ai/api=anthropicet celui decore/ai-agent/google-adksélectionnemodel.aggrega.ai/api=gemini, de sorte que câbler l’un d’eux sur un modèle ou une passerelle servant une autre API arrête le build sur une violation de sélecteur qui nomme le socket. Le socket decore/ai-agent/google-adkrestreint en outre la catégorie àai-model, refusant toute passerelle, car le client d’ADK ne lit aucune adresse et enverrait l’identifiant d’une passerelle à l’adresse propre de Google. La passerelle IA lit la valeur au lieu de sélectionner sur elle : son socketmodelssélectionnecomponent.aggrega.ai/category=ai-model, admettant tout modèle, et comme la passerelle décrit à son proxy un modèle qui y est câblé via la seule API OpenAI, l’assertion de son Component arrête le build sur une connexion dont la cible porte toute valeur autre queopenai, en nommant la connexion et en indiquant de saisir plutôt cet upstream dans la table de modèles saisie à la main de la passerelle.core/gateway/kong,core/gateway/kong-enterprise,core/gateway/apisix,core/gateway/envoy-gateway,core/gateway/traefik-hub,core/gateway/agentgatewayetcore/gateway/higressla lisent de la même manière sur leurs propres socketsmodels, car chacun écrit la route d’un modèle câblé, ou sur agentgateway son entrée de modèle, pour la seule API OpenAI. Le compilateur traite la valeur comme une chaîne opaque et ne vérifie rien de ce qui répond à l’adresse. - Ce que la bibliothèque standard contient.
core/gateway/litellm,core/gateway/kong,core/gateway/kong-enterprise,core/gateway/apisix,core/gateway/envoy-gateway,core/gateway/traefik-hub,core/gateway/agentgatewayetcore/gateway/higressportentopenai, de même que les serveurs auto-hébergéscore/ai-model/vllm,ollama,docker-model-runner,tgi,tei,nvidia-nimetlitellm, les API géréescore/ai-model/openai,openai-embeddingetnvidia-api, et le brokercore/ai-model/openai-compatible, que l’on pointe vers un service parlant cette API.core/ai-model/anthropicporteanthropic, etcore/ai-model/geminiportegemini. Tout autre composant de modèle portenative.
14. tool.aggrega.ai/transport
- Qui l’écrit ? Le Platform Architect, sur un outil qu’un consommateur atteint via un transport qu’il doit parler. La valeur nomme ce transport.
- Qui le consomme ? Le Static Analyzer, via le socket d’outils d’un consommateur.
- Cas d’usage du compilateur : c’est ainsi qu’un consommateur ne reçoit que les outils avec lesquels il sait communiquer. Un socket d’outils sélectionne
component.aggrega.ai/category=ai-tool, tool.aggrega.ai/transport=http: l’exigence de catégorie admet les outils et rien d’autre, et l’exigence de transport n’admet que les outils atteints via HTTP, de sorte que câbler un tel socket sur un outil qui ne porte pas ce label arrête le build sur une violation de sélecteur qui nomme le socket. La manière dont on atteint un outil doit être un label plutôt qu’une valeur publiée, car un sélecteur lit les labels et jamais le contenu d’une valeur. Le compilateur traite la valeur comme une chaîne opaque et ne vérifie rien de ce qui répond à l’adresse. - Ce que la bibliothèque standard contient.
core/ai-tool/mcpportehttp. Il rattache un serveur Model Context Protocol à un agent, et le Manifest choisit la manière dont ce serveur est réalisé :helm/mcpetcompose/mcpexécutent une image servant le protocole via HTTP ;helm/mcp-stdio-bridgeetcompose/mcp-stdio-bridgeexécutent un paquet qui ne parle que stdio derrière un pont épinglé qui le sert via HTTP ;helm/mcp-remoteetcompose/mcp-remoteatteignent un serveur exploité par quelqu’un d’autre et n’exécutent rien. Chaque réalisation publie les mêmeshost,port,endpoint,protocoletcredential_header, de sorte que le câblage d’un consommateur ne change pas avec la réalisation. Les identifiants propres d’un serveur sont des variables d’environnement, conservées dans le slotserver_envde l’outil : livrées au pont par référence sur Kubernetes et, sur Docker Compose, écrites dans l’environnement du service telles qu’elles sont livrées, où une référence de variable Compose maintient l’identifiant hors du fichier ; l’identifiant d’un serveur distant est conservé par le consommateur sur sa propre connexion à l’outil et présenté sous l’en-tête que nommecredential_header,Authorizationà moins que la Release n’en nomme un autre. Lorsqu’un serveur distant lit sa clé dans sa propre adresse, le consommateur conserve aussi l’adresse entière sur cette connexion, dans un slotendpointrempli sur Kubernetes par une référence à un Secret et sur Docker Compose par une référence de variable Compose, de sorte que la clé n’atteint aucun fichier rendu, tandis que l’infra.endpointde l’outil contient l’adresse sans la partie qui porte la clé ; examples/mcp-address-from-secret construit les deux.core/ai-agent/openai-agents-sdk,core/ai-agent/claude-agent-sdk,core/ai-agent/agent-framework,core/ai-agent/google-adketcore/ai-agent/mastra, ainsi que les plateformes de fluxcore/ai-agent/flowiseetcore/ai-agent/n8n, déclarent un socket d’outils de cette forme,tools, et livrent l’adresse de chaque outil câblé, et l’identifiant de la connexion par référence, sous des variables nommées d’après l’alias de la connexion, tandis qu’une connexion qui écrit un blocinject:reçoit ce que ce bloc dicte à la place des variables dérivées de ce que publie l’outil, le contenu de ses slotscredentialetendpointrestant sous le nom de l’alias ; un consommateur maison en déclare un de la même manière. Chacune des trois plateformes de flux apporte dans la plateforme, au déploiement, un flux écrit dans l’Aggregate, sur les deux cibles : Langflow charge la définition transportée depuis son répertoire de flux à chaque démarrage, le chatflow de Flowise est amorcé par une étape ponctuelle connectée en tant que compte propriétaire que nomme la Release, et le workflow de n8n est importé par une étape d’init avant le démarrage de la plateforme.core/ai-agent/langflowdéclare un sockettoolsde la même forme, qui n’admet aucun blocinject:, et livre plutôt chaque connexion à travers ce flux, car le composant MCP Tools de Langflow ne prend l’adresse d’un serveur que dans les paramètres propres de Langflow ou dans le flux, jamais dans une variable : ses Recipes écrivent l’adresse de l’outil dans le nœud MCP Tools dont le serveur porte le nom de l’alias de la connexion, livrent l’identifiant de la connexion par référence sous la forme d’une variable que nomme l’en-tête de ce nœud — sousAuthorization, une variable contenantBeareret l’identifiant — et laissent passer les hôtes des outils et des stores câblés à travers la protection de Langflow contre les adresses privées. Les trois plateformes déclarent aussi un socketvector_storequi sélectionnedatastore.aggrega.ai/engine in (vector, semantic-memory, search)et qui livre de la même manière l’adresse de chaque store câblé — l’endpointqu’il publie, pourcore/datastore/pgvectorune URI de connexion ne contenant aucun mot de passe, ou une adresse composée de son protocole, de son hôte et de son port — et l’identifiant de la connexion par référence ; un store qui publie aussi sa base de données et son utilisateur, comme le faitcore/datastore/pgvector, parvient à Flowise et à n8n également sous ces parties, puisque le nœud vectoriel PostgreSQL d’aucune des deux plateformes n’accepte de chaîne de connexion ; Langflow, dont le composant PGVector accepte une seule chaîne, reçoit un tel store sous la formeAGGREGA_VECTOR_STORE_<ALIAS>_CONNECTION_STRING, l’identifiant de la connexion servant de mot de passe, par référence sur Kubernetes et tel qu’il est livré sur Docker Compose. Un chatflow Flowise lit une variable livrée via une variable Runtime du même nom créée sur la page Variables de Flowise, et un workflow n8n en lit une via$envuniquement lorsque l’Aggregate définit la valeurallow_env_access_in_nodesde la plateforme, puisque par défaut ses Recipes conservent le blocage par n8n de l’accès à l’environnement dans les nœuds.
2. Abstraction des ports (la convention zéro port)
Le catalogue open source de la bibliothèque standard d’Aggrega recommande d’omettre les déclarations de ports physiques de la couche cognitive des Components, en acheminant plutôt le choix du port via la Recipe Ops. Les auteurs qui suivent cette recommandation évitent les collisions de ports entre cibles de déploiement, empêchent les API dérobées qui contournent l’Injection Contract et conservent une topographie réseau flexible d’un fournisseur à l’autre. Le compilateur lui-même est agnostique vis-à-vis des ports — il transmet toutes les valeurs que le JSON Schema résolu autorise. La convention fonctionne avec une porte de sortie explicite pour les systèmes hérités dont les ports physiques ne peuvent pas changer.
- Le comportement par défaut cloud-native (injection dynamique) : pour les charges de travail modernes, les Components omettent entièrement les ports physiques (aucun tableau
portsouexpose) de leur déclarationschema:. Les Recipes de Platform Ops choisissent le port TCP/UDP interne et le publient sous forme de cléprovidesnommée, que les consommateurs en aval lisent via l’Injection Contract.context.uses. - La porte de sortie héritée (déclaration explicite) : lorsqu’un composant hérité possède un port codé en dur et non modifiable, le Platform Architect expose explicitement un champ
portdans la déclarationschema:du Component. Cela donne au Developer un moyen validé de déclarer la contrainte physique. Le compilateur transporte la valeur à travers le pipeline sans la modifier ; la Recipe la consomme via{{ .values.port }}. - Ports opérationnels (hors bande) : les ports utilisés strictement par l’infrastructure du cluster (par ex. le scraping Prometheus, les métriques des sidecars Envoy) restent cachés de la couche cognitive du Developer. Ils sont injectés hors bande par Platform Ops via des Features (par ex. en rattachant la Feature
core/prometheus-exporter, dont le port de scraping relève de l’infrade l’opérateur).
3. Schémas propres au domaine (intelligence de configuration)
Les blocs values du développeur (opaques pour le compilateur Go mais strictement typés par la déclaration schema: du Component) sont validés pour prendre en charge des workflows d’IA explicites :
- Liens entre agents (tableaux de dépendances) : le schéma de paramètres d’agent partagé de la bibliothèque standard porte
tools_allowedetagents_allowedsous forme de tableauxvaluesnommant les Components du catalogue qu’un agent peut invoquer ou auxquels il peut déléguer — une convention documentée que le compilateur n’évalue pas. Un lien que le compilateur câble comme arête topologique est un socketusesque le Component de l’agent déclare dans sonusesSchema, et c’est le sélecteur de ce socket que le build vérifie. - Partitionnement profond de la mémoire cognitive (CoALA) : plutôt qu’un unique compartiment de mémoire plat, un architecte peut déclarer un socket
cognitive_memorydont les connexions associent les mémoires sémantique, épisodique et procédurale à des cibles d’infrastructure distinctes sous forme d’arêtes topologiques explicites, de sorte que les moteurs de politiques peuvent évaluer et imposer des garde-fous d’accès granulaires (par ex. garantir qu’un agent peut lire la mémoire sémantique mais ne peut pas l’écraser s’il est détourné). La bibliothèque standard ne déclare aucun socket de ce type. - Pipelines multimodaux : le
schema:d’un Component peut déclarer des étapes d’exécution explicites telles quedocument_chunking,embedding_generationetstorage_routingsous forme devaluestypées, de sorte qu’un flux de données déclaratif est validé avant que quoi que ce soit ne soit rendu. La bibliothèque standard ne déclare aucune étape de ce type.
4. Intelligence des passerelles et routage
Les passerelles IA de la bibliothèque standard portent les contrôles permettant de router les requêtes vers les API de LLM : core/gateway/litellm, qui s’exécute dans le cluster, et deux services hébergés — core/gateway/cloudflare-ai-gateway, la passerelle hébergée de Cloudflare, que sa Recipe terraform crée dans un compte Cloudflare, et core/gateway/azure-api-management, la passerelle IA d’Azure API Management, dont la Recipe terraform ajoute une API servant un modèle, avec son backend et sa politique, à une instance API Management qui existe déjà. Les Recipes helm et compose de chaque passerelle hébergée la référencent là où elle est déjà configurée. Certains contrôles sont des valeurs sur la passerelle elle-même et d’autres sont des Features qui lui sont rattachées, et chaque Feature ci-dessous indique sur quelle passerelle la bibliothèque standard la réalise. Sur une passerelle hébergée, chaque contrôle est écrit dans la configuration propre de la passerelle — un paramètre de la ressource de la passerelle Cloudflare, un élément de la politique de l’API sur Azure API Management —, de sorte que seule sa Recipe terraform peut en porter un, et ses Recipes helm et compose arrêtent le build sur tout rattachement. Ci-dessous, « la passerelle IA » désigne core/gateway/litellm, « la passerelle hébergée » désigne core/gateway/cloudflare-ai-gateway, et la passerelle d’Azure API Management est nommée en toutes lettres.
Hors d’Aggrega, à l’exécution
agent
son socket model, relié à la passerelle
passerelle d’IA
avec les contrôles qui y sont attachés
budget de jetons
cache sémantique
bouclier contre l’injection de prompts
modèle
un fournisseur derrière la passerelle
Les requêtes d’un agent passent par la passerelle à laquelle son socket model est relié, de sorte que chaque contrôle attaché à la passerelle se place entre l’agent et le modèle. Les trois dessinés ici sont les Features core/period-budget, core/semantic-caching et core/prompt-injection-shield, montrées côte à côte pour l’endroit où elles se placent et non comme la configuration d’une seule passerelle : les entrées ci-dessous indiquent quelle passerelle réalise chaque contrôle et ce qui arrête la compilation.
-
Les modèles derrière elle : la table de modèles de la passerelle IA — les alias qu’elle sert, chacun avec l’upstream vers lequel une requête qui le vise est envoyée — comporte deux parties. Un composant de modèle câblé au socket
modelsde la passerelle, géré ou auto-hébergé, est servi sous l’alias de la connexion, son entrée étant écrite à partir de l’endpointet dumodelque publie le modèle, des chaînes que le compilateur transmet dans la configuration de la passerelle sans jamais les résoudre ; le modèle est donc un composant du graphe, atteint par une arête qui lui est propre. La passerelle décrit un tel modèle à son proxy via la seule API OpenAI, de sorte qu’une connexion atteignant un modèle dont lemodel.aggrega.ai/apin’est pasopenaiarrête le build en nommant la connexion. L’autre partie est levalues.modelsde la passerelle, des entrées saisies à la main dans la notation fournisseur/modèle propre au proxy : pour un upstream que le catalogue ne modélise pas, pour un fournisseur dont l’API propre n’est pas l’API OpenAI, et pour plusieurs entrées partageant un même alias, ce que les modèles câblés ne peuvent pas faire, puisque chacun est servi sous l’alias de sa propre connexion. Une entrée câblée présente l’identifiant que porte sa propre connexion, comme le décrit « La clé qu’un appelant présente » ci-dessous, et jamais leprovider_keyde la passerelle ; chaque entrée saisie à la main présente l’unique identifiant de ce slot. Un alias que publient les deux parties arrête le build en le nommant, tout comme une passerelle à laquelle aucune des deux parties ne donne de modèle. -
Sur le chemin d’un agent : la passerelle publie un
endpointet unmodel, les clés que publie un composant de modèle, et portemodel.aggrega.ai/api: openai, de sorte que le socketmodeld’un agent accepte directement la passerelle et que chaque contrôle qui y est rattaché se tient entre cet agent et les fournisseurs qui se trouvent derrière. Lemodelqu’elle publie est l’alias que nomme sonvalues.model, sur lequel le build s’arrête quand aucune des deux parties de la table ne le publie ; il ne peut être omis que lorsque la passerelle sert un seul alias et qu’une entrée devalues.modelsle publie, celui-ci étant alors celui qui est publié. Un appelant qui veut un autre alias publié par la table le demande par son nom au même endpoint.core/gateway/cloudflare-ai-gatewaypublie les deux mêmes clés — l’adresse de l’un des endpoints de la passerelle, composée à partir du compte Cloudflare et de l’id de la passerelle, et le modèle que demande un appelant, que la passerelle transmet sans vérification — mais ne porte aucunmodel.aggrega.ai/api, de sorte que le socketmodeld’un agent ne l’accepte pas.core/gateway/azure-api-managementles publie aussi — l’adresse de son API, composée à partir de l’hôte de l’instance et du chemin de l’API, et le modèle que demande un appelant, transmis sans vérification — et ne porte pas non plus demodel.aggrega.ai/api: l’API répond à la requête chat completions d’OpenAI, mais par défaut un appelant présente une clé d’abonnement API Management dans son propre en-tête au lieu du bearer token d’OpenAI, de sorte qu’un simple client OpenAI ne suffit pas pour l’appeler. -
Kong devant des modèles :
core/gateway/kong, la passerelle Kong open source, sert les modèles câblés à son propre socketmodelsvia l’AI Proxy de Kong et, parmi les contrôles ci-dessous, ne réalise que les motifs de refus de prompts, sous la forme de l’AI Prompt Guard de Kong sur chaque route de chaque modèle câblé. Chaque modèle câblé reçoit une route chat et une route completion sous/<alias>/v1, écrites à partir de l’endpointet dumodelque publie le modèle, et ses Recipes importent ces routes dans le backend PostgreSQL de la passerelle avant son démarrage. La route choisit le modèle, de sorte qu’une requête est envoyée au modèle que nomme son chemin, quel que soit le nom de modèle qu’elle porte. La passerelle présente l’identifiant propre à chaque connexion sous forme de bearer token que sa configuration lit par son nom dans l’environnement de la passerelle, et une connexion atteignant un modèle dont lemodel.aggrega.ai/apin’est pasopenaiarrête le build. Elle publie la route de l’alias que nomme sonvalues.modelcomme sonendpointet cet alias comme sonmodel, et portemodel.aggrega.ai/api: openai, de sorte que le socketmodeld’un agent l’accepte comme il accepte la passerelle IA. Si rien n’est câblé à ce socket, la passerelle ne sert aucun modèle et publie les deux clés vides, et un agent qui y est câblé ne lit alors aucune adresse ni aucun nom de modèle. L’import ajoute et met à jour des routes sans en supprimer aucune, de sorte qu’une route dont la connexion est supprimée continue de répondre, et que le prompt guard écrit par un rattachement decore/prompt-deny-patternscontinue de refuser une fois le rattachement supprimé, jusqu’à ce que chacun soit effacé via l’Admin API de Kong. Pour la même raison, la passerelle ne déclare aucun appelant et ses routes de modèle ne vérifient la clé d’aucun appelant : Kong ne distingue les appelants qu’en tant que consumers nommés par un plugin d’authentification, et un consumer et sa clé, une fois importés, resteraient capables de s’authentifier après la suppression de l’appelant de la Release, une clé renouvelée laissant l’ancienne fonctionner ; une clé key-auth ne peut pas non plus être conservée par référence, de sorte que la clé d’un appelant ne pourrait atteindre Kong que sous forme de littéral dans un fichier rendu. -
Kong Gateway Enterprise devant les modèles :
core/gateway/kong-enterprise, l’édition payante de Kong de la même passerelle adossée à une base de données, sert les modèles reliés à son propre socketmodelssur les routes que sertcore/gateway/kong, écrites à partir de la même configuration et importées dans son backend PostgreSQL par une étape exécutée dans le propre pod de la passerelle avant que celle-ci ne démarre, et publie sonendpointet sonmodelcomme le fait Kong. Sa seule réalisation est une Recipe chart sur le chart Helm officiel de Kong ; il n’existe pas de réalisation compose. Elle exécute l’image que la Release nomme dansinfra.image, tag de version compris, car Kong distribue l’image enterprise selon ses propres conditions et le catalogue n’en nomme donc aucune ; la compilation s’interrompt tant que cette clé n’est pas définie ou que son tag ne porte aucune version. La licence parvient à la passerelle par référence au Secret lié à son slot obligatoirelicense, jamais comme valeur, et la compilation s’interrompt tant que rien ne lie ce slot. Le compilateur ne valide aucune licence et ne contacte aucun éditeur, si bien qu’une Release qui se compile sans erreur ne dit rien d’une licence : Kong lit la licence au démarrage d’un nœud, et un nœud sans licence valide se comporte comme avec une licence expirée, sa configuration des entités étant en lecture seule et son trafic de proxy servi avec la configuration déjà en place. Kong vend ses plugins d’IA sous son offre AI Gateway Enterprise, un droit d’usage inclus dans la licence qu’aucune compilation ne peut voir, et ignore un tel plugin plutôt que de le refuser là où la licence ne comporte pas ce droit ; rattachercore/semantic-caching,core/period-budget,core/data-masking,core/fallback-chain,core/retry-policyoucore/target-selectioninterrompt donc la compilation jusqu’à ce que la Release définisseinfra.ai_gateway_entitledàtrue, affirmant que la licence comporte ce droit. Parmi les contrôles ci-dessous, elle réalise le budget de période et la chaîne de repli, chacun écrit dans les routes que la passerelle importe, et elle réalisecore/data-maskingcomme le décrit « Exfiltration de données et interception des payloads » ci-dessous ; ses réalisations du cache sémantique, de la politique de nouvelle tentative et de la sélection de cible interrompent tout rattachement, chacune en indiquant la raison, et la limite de concurrence, la journalisation d’audit, le filtrage de l’injection de prompt, la validation des réponses et les motifs de refus de prompt n’y ont aucune réalisation, si bien qu’un rattachement de l’un d’eux interrompt la compilation. Un ensemble de routes modifié entraîne un redéploiement progressif de la passerelle, et l’importation ajoute et met à jour des routes sans en supprimer aucune, si bien qu’une route dont la connexion est supprimée, ainsi qu’un plugin écrit par une Feature d’IA une fois la Feature supprimée, restent dans la base de données jusqu’à leur suppression via l’Admin API de Kong ; pour les raisons qu’indique le point précédent, elle ne déclare pas non plus d’appelants, et ses routes de modèles ne vérifient la clé d’aucun appelant. Qu’une passerelle en cours d’exécution applique l’un de ces contrôles n’est observé par aucune compilation. -
APISIX devant les modèles :
core/gateway/apisix, la passerelle open source Apache APISIX, sert les modèles reliés à son propre socketmodelsvia le proxy d’IA d’APISIX là où le Manifest lie sa Recipe chart, qui exécute APISIX 3.18.0. Chaque modèle relié reçoit une route chat et une route completion sous/<alias>/v1— la seule route chat tant qu’un budget de période ou des motifs de refus de prompt sont rattachés, car APISIX ne compte aucun jeton sur une requête de completion et son prompt guard n’en lit aucune — écrites à partir de l’endpointet dumodelque le modèle publie dans un fichier de routes rendu avec la passerelle, qu’elle lit au démarrage puis de nouveau chaque fois que le fichier change. Une passerelle qui lit ses routes depuis ce fichier ne lit aucun etcd et n’exécute aucune Admin API ; avec un modèle relié, une connexionetcdou un rattachementadmin_keyinterrompt donc la compilation, et sans rien de relié les deux sont obligatoires. La route choisit le modèle. La passerelle présente l’identifiant propre à chaque connexion comme un jeton bearer que ses routes lisent par son nom dans l’environnement de la passerelle, et une connexion atteignant un modèle dontmodel.aggrega.ai/apin’est pasopenaiinterrompt la compilation. Elle publie la route de l’alias que nomme sonvalues.modelcomme sonendpointet cet alias comme sonmodel, et portemodel.aggrega.ai/api: openai, si bien que le socketmodeld’un agent l’accepte comme il accepte la passerelle IA ; sans rien de relié, elle publie les deux clés vides. Une route dont la connexion est supprimée disparaît du rendu suivant. Une Release peut nommer les appelants de la passerelle dansinfra.callerset leurs clés via le slotcaller_keys, un Secret contenant une clé de données par nom d’appelant : chaque appelant est alors un consumer du fichier de routes dont la clé est lue par son nom dans ce Secret, et chaque route refuse avec HTTP 401 une requête ne présentant aucune clé déclarée sous la formeAuthorization: Bearer <key>— la façon dont un client OpenAI en présente une — et retire la clé de la requête qu’elle transmet. Sans appelants, les routes sont ouvertes. Sa Recipe workload, avec APISIX 3.17.0, conserve ses routes dans etcd, n’en rend aucune et interrompt la compilation sur une connexion à ce socket et surinfra.callers. Parmi les contrôles ci-dessous, elle réalise le budget de période, un cache sémantique pour les appelants qu’elle déclare et les motifs de refus de prompt. -
Envoy Gateway devant les modèles :
core/gateway/envoy-gateway, la passerelle open source Envoy Gateway, sert les modèles reliés à son propre socketmodelsvia Envoy AI Gateway, dont le contrôleur,core/gateway/envoy-ai-gateway-operator, est appelé par la passerelle comme son serveur d’extension via son socketextension. Un modèle relié sans rien sur ce socket interrompt la compilation, et avec le contrôleur relié, la Release place la passerelle dansenvoy-gateway-system, faute de quoi la compilation s’interrompt. Chaque modèle relié devient une règle d’une seule route d’IA rattachée à la passerelle, choisie selon le nom de modèle que porte une requête, avec un backend écrit à partir de l’endpointet dumodelque le modèle publie, si bien que chaque modèle relié est servi sous/v1à l’adresse propre de la passerelle. La passerelle présente l’identifiant propre à chaque connexion comme un jeton bearer, que le contrôleur d’Envoy AI Gateway lit dans le Secret que nomme l’identifiant, et une connexion atteignant un modèle dontmodel.aggrega.ai/apin’est pasopenaiinterrompt la compilation. Tant qu’un modèle est relié, chaque route de la passerelle prend le tampon de requête de 50Mi par connexion que configure Envoy AI Gateway. Elle publie son adresse, qualifiée avecenvoy-gateway-systemafin qu’elle se résolve depuis n’importe quel namespace, comme sonendpointet l’alias que nomme sonvalues.modelcomme sonmodel, et portemodel.aggrega.ai/api: openai, si bien que le socketmodeld’un agent l’accepte comme il accepte la passerelle IA ; sans rien de relié, elle publie les deux clés vides. Le webhook du contrôleur sert un certificat émis par cert-manager, si bien que cert-manager doit déjà tourner dans le cluster, à moins que la Release ne nomme, dans l’infra.webhook_tls_secretdu contrôleur, un Secret contenant un certificat fourni par l’opérateur, que le webhook sert alors. Parmi les contrôles ci-dessous, elle réalise le budget de période, la politique de nouvelle tentative et la limite de concurrence, chacun écrit sur l’unique politique de trafic de la route qui sert ses modèles. Elle ne réalise ni le cache sémantique ni la validation des réponses, car Envoy AI Gateway ne conserve aucune réponse pour répondre à une requête ultérieure et ne vérifie aucune réponse par rapport à un schéma, ni la chaîne de repli : Envoy AI Gateway se replie en réessayant sur d’autres backends de la règle d’un modèle, et la passerelle écrit le nombre de tentatives de son unique politique de trafic sur chaque règle de la route qui sert ses modèles, si bien qu’une liste de repli n’obtiendrait exactement ses envois que là où la liste de chaque modèle relié a la même longueur. Elle réalisecore/audit-loggingsous forme de son journal d’accès, comme le décrit « Journalisation d’audit » ci-dessous, et refuse nommément ce que ce journal ne peut pas conserver : ce qu’a coûté une requête, car le coût par requête qu’Envoy AI Gateway peut calculer n’a pas d’unité et la passerelle ne conserve aucun prix ; un appelant vérifié par la passerelle, car rien sur ce chemin ne vérifie l’appelant ; et une durée de conservation, car ce journal n’a ni stockage ni réglage de conservation. examples/envoy-ai-gateway-token-budget construit le chemin complet, avec un agent qui atteint le modèle géré d’OpenAI via la passerelle. -
agentgateway devant les modèles :
core/gateway/agentgateway, la passerelle open source agentgateway, sert les modèles reliés à son propre socketmodelsà partir d’un unique fichier de configuration que rendent ses Recipes. Chaque modèle relié est une entrée de ce fichier, nommée d’après l’alias de la connexion et écrite à partir de l’endpointet dumodelque le modèle publie comme fournisseur de chat completions compatible OpenAI, si bien que chaque modèle relié est servi sous/v1à l’adresse propre de la passerelle et que c’est le nom de modèle que porte une requête qui le choisit : la requête atteint le modèle en demandant le nom de modèle que le modèle publie, et un nom qu’aucune connexion ne porte reçoit une réponse HTTP 404. La passerelle présente l’identifiant propre à chaque connexion comme un jeton bearer, que le fichier nomme comme une variable que la passerelle lit dans son environnement lorsqu’elle lit le fichier, une variable absente de celui-ci l’empêchant de démarrer, et une connexion atteignant un modèle dontmodel.aggrega.ai/apin’est pasopenaiinterrompt la compilation. Elle publie cette URL de base/v1comme sonendpointet l’alias que nomme sonvalues.modelcomme sonmodel, et portemodel.aggrega.ai/api: openai, si bien que le socketmodeld’un agent l’accepte comme il accepte la passerelle IA ; sans rien de relié, elle publie les deux clés vides. Deux Recipes exécutent la même image, épinglée par digest :agentgateway-chartrend le chart Helm autonome du projet, récupéré depuis le registre du projet, et réalise les contrôles ci-dessous, etagentgatewayexécute l’image comme un unique service Docker Compose et n’en réalise aucun, ni les appelants, si bien qu’un rattachement y interrompt la compilation en nommant son type ; sur Kubernetes, où la compilation peut atteindre ce registre, tournez-vous vers le chart. Sur le chart, une Release peut nommer les appelants de la passerelle dansinfra.callerset leurs clés via le slotcaller_keys, comme sur APISIX : chaque appelant est une clé d’API du fichier, vérifiée en mode strict et lue par son nom dans ce Secret, si bien qu’une requête de modèle ne présentant aucune clé déclarée sous la formeAuthorization: Bearer <key>est refusée avec HTTP 401, et la clé est retirée de la requête transmise ; sans appelants, les routes de modèles sont ouvertes. agentgateway insère chaque clé que le fichier nomme de cette façon, celle d’un modèle relié avec l’une ou l’autre Recipe et celle d’un appelant sur le chart, dans le texte du fichier avant de lire le fichier comme YAML ; une clé doit donc être un jeton simple — lettres, chiffres et-,.,_,~,+,/et=— et d’autres caractères peuvent être chargés comme une clé différente ou arrêter la passerelle. La passerelle relit son fichier lorsqu’il change, si bien qu’un appelant retiré de la Release est refusé dès que le fichier monté est mis à jour. Tant quecore/audit-logging, oucore/period-budgetavec la portéecaller, est rattaché, la Recipe chart donne à la passerelle un stockage, un fichier SQLite sur un volume qui lui est propre, et exécute une seule réplique. Parmi les contrôles ci-dessous, elle réalise le masquage des données, les motifs de refus de prompt, le budget de période, la journalisation d’audit et la politique de nouvelle tentative, chacun écrit dans le fichier, et refuse nommément chaque valeur qu’elle ne peut pas respecter. Le masquage des données remplace chaque correspondance des motifs que liste le rattachement par<masked>, ou, sousrefuse, répond à la requête ou à la réponse avec HTTP 403, dans les prompts système et développeur d’une requête, ses autres messages et les arguments et résultats de ses appels d’outils, ainsi que dans le texte du message d’une réponse qui arrive entière ; il ne reconnaît aucun type d’entité et ne restaure rien. agentgateway ne masque pas une réponse en streaming ; tant que les réponses sont masquées, une requête de modèle demandant une réponse en streaming est donc refusée avec HTTP 403 avant d’être transmise, de même que toute requête de modèle dont le corps dépasse les 2 MiB que la passerelle lit pour cette vérification, en streaming ou non. Un refus par une garde, y compris celui d’un motif de refus, est un HTTP 403 avec le corps « The request was rejected due to inappropriate content » (La requête a été rejetée en raison d’un contenu inapproprié). Le budget, les enregistrements et les nouvelles tentatives sont décrits sous « Budget de période », « Journalisation d’audit » et « Résilience » ci-dessous. Ses réalisations de la chaîne de repli, de la sélection de cible, du cache sémantique, de la validation des réponses et du filtrage de l’injection de prompt interrompent tout rattachement, chacune en indiquant la raison, et la limite de concurrence ne s’y rattache pas, car elle ne porte aucune valeurdataplane.aggrega.ai/concurrency-cap. -
Traefik Hub devant les modèles :
core/gateway/traefik-hub, la passerelle payante de Traefik, sert les modèles reliés à son propre socketmodelsvia le middleware Chat Completion de Traefik Hub. Sa seule réalisation est une Recipe chart sur le propre chart Helm de Traefik ; il n’existe pas de réalisation compose. Elle exécute l’image que la Release nomme dansinfra.image, tag compris, car Traefik distribue Traefik Hub selon ses propres conditions et le catalogue n’en nomme donc aucune ; la compilation s’interrompt tant que cette clé n’est pas définie ou ne nomme aucun tag. Le jeton de licence parvient à la passerelle par référence au Secret lié à son slot obligatoirelicense, sous la clé de donnéestoken, jamais comme valeur, et la compilation s’interrompt tant que rien ne lie ce slot ou qu’il publie une autre clé de données. Traefik exige un accès HTTPS sortant versapi.traefik.io, où la passerelle valide son jeton ; depuis Traefik Hub v3.21, la passerelle continue de servir tant que cet hôte est injoignable, en réessayant en arrière-plan, et un jeton dure un an par défaut, la passerelle s’arrêtant une fois qu’il expire. La Recipe chart désactive l’export, par le chart, des journaux d’erreurs de la passerelle vers la plateforme de Traefik ainsi que sa vérification d’une version plus récente. Le compilateur ne valide aucun jeton et ne contacte aucun éditeur, si bien qu’une Release qui se compile sans erreur ne dit rien du démarrage de la passerelle. Chaque modèle relié reçoit une route sur/<alias>/v1/chat/completions, envoyée à l’endpointque le modèle publie via un Service de type ExternalName et demandant lemodelqu’il publie, quel que soit le nom de modèle que porte une requête, si bien que c’est le chemin qui choisit le modèle ; elle ne sert que les chat completions. La passerelle présente l’identifiant propre à chaque connexion comme un jeton bearer, que Traefik Hub lit dans le Secret que nomme le middleware Chat Completion de la connexion, et une connexion atteignant un modèle dontmodel.aggrega.ai/apin’est pasopenai, ou dont le point de terminaison nomme une adresse plutôt qu’un hôte, interrompt la compilation. Elle publie la route de l’alias que nomme sonvalues.modelcomme sonendpointet cet alias comme sonmodel, et portemodel.aggrega.ai/api: openai, si bien que le socketmodeld’un agent l’accepte comme il accepte la passerelle IA ; sans rien de relié, elle publie les deux clés vides. Une Release peut nommer les appelants de la passerelle dansinfra.callerset les hachages htpasswd de leurs clés via le slotcaller_keys: le middleware API Key de Traefik Hub précède alors chaque route de modèle et refuse une requête ne présentant aucune clé déclarée sous la formeAuthorization: Bearer <key>, et la clé est retirée de la requête transmise ; sans appelants, les routes sont ouvertes. Ce que fait Traefik Hub de l’entrée d’un appelant nommant un Secret ou une clé de données qui n’existe pas n’est pas indiqué dans sa référence ; dans le pire des cas, les routes sont donc aussi ouvertes que sans appelants. Parmi les contrôles ci-dessous, elle réalise le budget de période, le cache sémantique pour les appelants qu’elle déclare, les motifs de refus de prompt et le masquage des données, via des middlewares de la passerelle d’IA de Traefik Hub, ainsi que la chaîne de repli et la politique de nouvelle tentative, via le basculement et les nouvelles tentatives propres à Traefik, chacun écrit dans les routes que rend sa Recipe chart. La passerelle d’IA est un droit d’usage inclus dans la licence, qu’aucune compilation ne peut voir, et ce que fait Traefik Hub d’un jeton valide dont la licence ne le comporte pas n’est pas documenté ; rattacher l’un des quatre premiers interrompt donc la compilation jusqu’à ce que la Release définisseinfra.ai_gateway_entitledàtrue. Ses réalisations du filtrage de l’injection de prompt, de la journalisation d’audit, de la sélection de cible et de la validation des réponses interrompent tout rattachement, chacune en indiquant la raison, et la limite de concurrence ne s’y rattache pas, car elle ne porte aucune valeurdataplane.aggrega.ai/concurrency-cap. Qu’une passerelle en cours d’exécution applique l’un de ces contrôles n’est observé par aucune compilation. -
Higress devant les modèles :
core/gateway/higress, la passerelle open source Higress, construite sur Envoy et configurée au moyen de ressources Kubernetes, sert les modèles raccordés à son propre socketmodelspar l’intermédiaire de l’AI proxy de Higress. Sa seule réalisation est une Recipe chart sur le chart Helmhigress-coredu projet lui-même, qui exécute le contrôleur de Higress, avec son service de découverte, et la passerelle ; il n’existe pas de réalisation compose, car le projet destine sa distribution compose principalement aux tests en local et cette distribution exécute plusieurs services coopérants configurés au moyen d’un store qui leur est propre. La Recipe épingle le chart, les images et chaque module de plugin qu’elle écrit, et n’accepte dansinfra.source_versionque les versions du chart pour lesquelles sa configuration est éprouvée ; la passerelle récupère ces modules depuis le registre de plugins de Higress à l’exécution, que le cluster doit pouvoir atteindre et que le build ne peut pas vérifier. Le contrôleur ne surveille que le namespace de la Release, sous une IngressClass nommée d’après la passerelle et ce namespace, de sorte que deux passerelles Higress dans un même namespace entrent en collision. Chaque alias reçoit une route à/<alias>/v1, envoyée vers l’endpointque publie le modèle de l’alias au moyen d’une entrée du registre propre à la passerelle et demandant lemodelqu’il publie, quel que soit le nom de modèle que porte une requête, de sorte que c’est le chemin qui choisit le modèle ; les connexions qui nomment un même alias dans leur valeurservesse partagent ses requêtes à parts égales. La passerelle présente l’identifiant propre à chaque connexion sous forme de bearer token, que le contrôleur de Higress lit dans le Secret nommé par la configuration de l’AI proxy, dans le namespace de la passerelle, et transmet à la passerelle, de sorte que la clé ne figure dans aucun fichier rendu ; un nom de Secret contenant un point arrête le build, car Higress lit le nom jusqu’à son premier point, et une connexion ne portant aucun identifiant transmet la clé que présente la requête. L’AI proxy de Higress copie en outre l’en-têteAuthorizationqu’envoie un client dans un en-têteX-HI-ORIGINAL-AUTH, et chaque route de modèle supprime cette copie avant que la requête n’atteigne le modèle, de sorte qu’une clé présentée par un client ne voyage jamais aux côtés de l’identifiant propre à une connexion. En https, la passerelle vérifie que le certificat d’un modèle remonte aux ancres de confiance du système et nomme l’hôte du modèle, quel que soit l’hôte envoyé par le client, et n’envoie rien au modèle dans le cas contraire : la Recipe marque la route de chaque alias dont les connexions sont toutes en https avec l’annotationhigress.io/backend-protocol: HTTPSde Higress, de sorte que la passerelle prend le nom de serveur dans l’hôte que l’AI proxy écrit dans chaque requête — celui du modèle, qualifié par le namespace du modèle lorsqu’il ne contient aucun point — et vérifie le certificat par rapport à celui-ci. Cette annotation s’applique à chaque connexion d’un alias, de sorte qu’un alias mêlant des connexions http et https arrête le build en les nommant toutes deux ; les servir sous deux alias lève l’arrêt. Une connexion atteignant un modèle dont lemodel.aggrega.ai/apin’est pasopenai, ou dont l’endpoint désigne une adresse plutôt qu’un hôte, arrête le build. Elle publie la route de l’alias que nomme sonvalues.modelcomme sonendpointet cet alias comme sonmodel, et portemodel.aggrega.ai/api: openai, de sorte que le socketmodeld’un agent l’accepte comme il accepte l’AI gateway ; sans rien de raccordé, elle publie les deux clés vides. Elle ne déclare aucun appelant, de sorte que ses routes de modèle ne vérifient la clé d’aucun appelant, et une valeur exigeant un appelant vérifié par la passerelle est refusée nommément. Parmi les contrôles décrits ci-dessous, elle réalise le budget de période, la journalisation d’audit et la politique de nouvelle tentative, chacun écrit sur les routes de modèle, et elle réalisecore/data-maskingcomme le décrit « Exfiltration de données et interception des payloads » ci-dessous. Ses réalisations de la validation des réponses, de la chaîne de repli, du cache sémantique, du filtrage des injections de prompt et de la sélection de cible arrêtent chaque rattachement, chacune en indiquant la raison, et ni les motifs d’interdiction de prompt ni la limite de concurrence ne s’y rattachent, car elle ne porte aucune valeurdataplane.aggrega.ai/prompt-guardoudataplane.aggrega.ai/concurrency-cap. Qu’une passerelle en cours d’exécution applique l’un de ces contrôles n’est observé par aucun build. -
Azure API Management devant un modèle :
core/gateway/azure-api-management, l’AI gateway d’Azure API Management, un service hébergé, sert une API de modèle au moyen d’une API sur une instance API Management qui existe déjà. Sa Recipe terraform lit l’instance et ajoute l’API, son opération de chat completions, le backend vers lequel elle transfère et la politique de l’API, qui retire la clé d’abonnement de l’appelant de ce qu’elle transfère et s’authentifie auprès de l’API du modèle comme l’indiqueinfra.backend_authentication: avec l’identité managée de l’instance, avec une clé de fournisseur conservée dans Key Vault, ou sans rien. Ses Recipes helm et compose référencent une API configurée en dehors de la Release et arrêtent le build à tout rattachement. Parmi les contrôles décrits ci-dessous, sa Recipe terraform réalise le cache sémantique, le budget de période, le filtrage des injections de prompt et la politique de nouvelle tentative, chacun écrit dans la politique de l’API. Elle ne réalise pas la limite de concurrence, puisque Microsoft qualifie le plafond qu’applique sa politique de concurrence de jamais tout à fait exact, et de plus bas lorsque plusieurs unités de capacité s’exécutent dans une région, ni la chaîne de repli, puisque l’API transfère vers un seul backend et que le repli propre à Azure, les groupes de priorité d’un pool de backends, écarte les requêtes ultérieures d’un backend dont le disjoncteur s’est déclenché plutôt que d’envoyer une requête en échec vers un autre modèle. Sa réalisation decore/audit-loggingarrête chaque rattachement en nommant ce qui est hors de sa portée : le journal lui-même, qu’active un paramètre de diagnostic sur l’instance ; le coût d’une requête, tant querequire_costest activé, puisque le journal des requêtes de modèle d’Azure enregistre les nombres de tokens et le modèle, mais aucun prix ; et une durée de conservation, lorsqueretention_daysest indiqué, puisqu’une ligne dure aussi longtemps que l’espace de travail Log Analytics où elle aboutit la conserve. Que les politiques s’appliquent et soient appliquées comme le documente Microsoft n’est observé par aucun build. -
La clé que présente un appelant : Un serveur qui vérifie la clé que présentent ses appelants conserve cette clé dans un slot qui lui est propre, nommé
api_keysur chaque cible servant des modèles qui en vérifie une —core/ai-model/vllm,teiettgi, le modèle LiteLLM et l’AI gateway, où il s’agit de la clé que LiteLLM appelle sa clé maîtresse — et chacune de ses Recipes fournit la clé sous la forme de la variable que lit le serveur.core/gateway/apisixetcore/gateway/agentgatewayconservent chacun une clé pour chaque appelant que leur Release nomme dansinfra.callers, dans leur slotcaller_keys: un seul Secret, qui contient la clé de chaque appelant sous le nom de cet appelant.core/gateway/traefik-hubconserve ses appelants de la même manière, à ceci près que son Secret contient le hachage htpasswd de la clé de chaque appelant, auquel sa vérification de clé compare une clé présentée, de sorte que ce n’est pas le Secret à partir duquel l’appelant présente sa clé. Un appelant conserve la clé qu’il présente de son propre côté, sur la connexion sur laquelle il la présente, dans un slot que déclare son socket : les agents de la bibliothèque standard en déclarent un sur leur socketmodel,credential, l’AI gateway sur son socketmodelset sur son socketcache_store, où il s’agit du mot de passe que le cache sémantique de la passerelle présente à son store,core/gateway/kongetcore/gateway/kong-enterprisesur leurs socketsmodels,core/gateway/apisixsur son socketmodelset sur son socketcache_store, où il s’agit de même du mot de passe que son cache sémantique présente à son store,core/gateway/agentgatewaysur son socketmodels,core/gateway/envoy-gatewaysur son socketmodelset sur son socketcache, où il s’agit du mot de passe que le service de limitation de débit de la passerelle présente au store qui tient le décompte d’un budget de période,core/gateway/higresssur son socketmodelset sur son socketcache, où il s’agit du mot de passe que sa limite de tokens présente au store qui tient le décompte d’un budget de période, etcore/gateway/traefik-hubsur son socketmodels, sur son socketcache, où il s’agit du mot de passe que son quota présente au store qui tient le décompte d’un budget de période, et sur son socketcache_store, où il s’agit du mot de passe que son cache sémantique présente à son store — de sorte qu’un agent atteignant un modèle, ou une passerelle atteignant un modèle qu’elle sert, y conserve la clé de cette connexion. L’AI gateway, les deux Kong, APISIX et agentgateway fournissent la clé de chaque modèle raccordé sous une variable qui lui est propre, que nomme l’entrée ou la route de ce modèle dans leur configuration ; Envoy Gateway nomme le Secret dans la politique de sécurité du backend du modèle, et le contrôleur d’Envoy AI Gateway y lit la clé ; Traefik Hub nomme le Secret et la clé de données dans le middleware Chat Completion de la route du modèle, et y lit la clé. Une connexion atteignant un modèle étiquetécomponent.aggrega.ai/hosting: manageden porte une, ou indique dans ses propresvaluesque le modèle n’en accepte aucune,unauthenticated: true; sans l’un ni l’autre, l’assertion de l’appelant arrête le build en nommant la connexion et sa cible, et un modèle étiqueté autrement ne provoque pas un tel arrêt. Une clé que le Component d’un appelant déclare plutôt dans un slot qui lui est propre est une seule clé pour toutes les connexions qu’il établit. Aucune des deux extrémités ne voit les rattachements de l’autre, de sorte que le serveur ne sait rien de la clé d’un appelant, et les deux concordent parce que l’Aggregate les alimente toutes deux à partir d’un seul paramètre : là où les deux extrémités résolvent les secrets dans une même portée — un même namespace Kubernetes, un même projet Compose — elles référencent un seul secret, et sinon chacune détient le sien, réalisé à partir de la même entrée du store. vLLM, TEI et TGI vérifient chacun une seule clé, de sorte que chaque appelant présente la même clé et que le serveur ne peut pas distinguer ses appelants, et TGI compare sa clé sans tenir compte de la casse ; APISIX, agentgateway et Traefik Hub vérifient chacun la clé de chaque appelant déclaré et distinguent leurs appelants grâce à elle ; les deux Kong ne déclarent aucun appelant et ne vérifient la clé d’aucun appelant, pour les raisons qu’indique « Kong devant les modèles » ci-dessus ; le modèle LiteLLM et l’AI gateway acceptent aussi les clés qu’ils émettent, tant que leur base de données de comptabilité est rattachée. Modèle d’identifiants développe cette forme dans un Aggregate. -
Choisir entre des cibles :
core/target-selectiondéclare la manière dont une passerelle choisit entre plusieurs cibles capables de servir la même requête, avec unestrategydelatency(la cible observée comme répondant le plus vite) oucost(la cible la moins chère à appeler). La stratégie fait partie de ce que l’application demande à sa passerelle, c’est donc le développeur qui la rattache dans l’Aggregate. Sur l’AI gateway, les cibles sont les entrées de sonvalues.modelsqui publient le même alias — un modèle raccordé est servi sous l’alias de sa connexion, qu’aucune autre entrée ne peut publier — et la bibliothèque standard réaliselatencyen écrivant lelatency-based-routingdu proxy dans la configuration de routage que rend la Recipe de la passerelle : le proxy envoie chaque requête à l’entrée dont les dix dernières réponses ont pris le moins de temps en moyenne, par token de sortie lorsqu’une réponse indique ses tokens, ou jusqu’à son premier token pour une requête en streaming, et une entrée pas encore essayée compte comme la plus rapide. Sans le rattachement, la configuration ne nomme aucune stratégie, et le proxy choisit au hasard parmi ces entrées.costy est refusé nommément : le proxy évalue le prix d’une entrée en cherchant sa cible, exactement telle qu’elle est écrite, dans une table de prix qui nomme les modèles d’OpenAI et d’Anthropic sans le préfixe de fournisseur que portent les cibles de la passerelle, et attribue à une entrée qu’il ne trouve pas un prix de repli fixe, de sorte que les entrées partageant un alias auraient le même prix et seraient choisies selon leur ordre. Surcore/gateway/kong-enterprise, chaque rattachement s’arrête, car chaque modèle qui y est raccordé est servi sur des routes qui lui sont propres et ne portent que ce modèle, ce qui ne laisse rien entre quoi choisir. Surcore/gateway/agentgateway, chaque rattachement s’arrête également, en indiquant la raison : agentgateway tire au hasard deux des cibles d’un nom de modèle et prend celle dont la santé, divisée par le temps qu’elle a mis à répondre, obtient le meilleur score, de sorte que la cible la plus rapide n’est prise que lorsqu’elle est tirée, et il ne choisit aucune cible selon le coût. Surcore/gateway/higress, chaque rattachement s’arrête également, en indiquant la raison : Higress peut mesurer la latence d’un service, mais son plugin d’équilibrage de charge s’exécute après l’AI proxy — qui a déjà fixé le modèle, l’adresse et l’identifiant de la requête pour le candidat que la route a résolu — et écrit son choix dans un en-tête de requête selon lequel rien ne route sans un filtre Envoy que ce catalogue ne rend pas, de sorte que le choix ne prend pas effet, et il ne choisit aucune cible selon le coût. Surcore/gateway/traefik-hub, chaque rattachement s’arrête également, en indiquant la raison : Traefik choisit selon le temps de réponse le plus bas uniquement parmi les serveurs d’un Service, que couvrent un seul nom de modèle et un seul identifiant, et équilibre entre Services selon un poids ou un hachage de l’adresse du client, jamais selon la latence, et aucune de ses stratégies ne choisit une cible selon le coût ; et chaque modèle raccordé à la passerelle est servi sur une route qui lui est propre et ne porte que ce modèle, ce qui ne laisse rien entre quoi choisir. Sur toute autre passerelle, un rattachement arrête le build. -
Résilience :
core/fallback-chaintransmet à d’autres modèles une requête dont le modèle échoue :chainsindique, pour chaque alias de modèle qui se replie, les alias à essayer dans l’ordre jusqu’à ce que l’un réponde, un repli qui échoue suivant à son tour sa propre entrée, etmax_hopslimite jusqu’où, le long de cette chaîne, une requête est transmise. La bibliothèque standard le réalise sur la passerelle IA en écrivant les deux dans la configuration de routage que rend la Recipe de la passerelle, et interrompt le build sur un nom que la table des modèles de la passerelle ne publie pas. Une requête ne se replie qu’une fois que la passerelle a renoncé à l’alias demandé : là où un alias est publié plus d’une fois, un appel échoué passe d’abord à une autre de ses entrées en tant que nouvelle tentative, dans la limite du nombre de tentatives de la passerelle.core/retry-policyfixe ce nombre — combien de fois la passerelle peut envoyer une requête, premier envoi compris (max_attempts), pour un échec qui se résout par un nouvel envoi, comme une connexion refusée, une limite de débit ou un délai dépassé — et la bibliothèque standard le réalise sur la passerelle IA en l’écrivant dans la configuration de routage que rend la Recipe de la passerelle. Surcore/gateway/envoy-gateway, il est réalisé comme le retry de la traffic policy sur la route qui sert les modèles câblés, la même policy qui porte la limite de débit d’un budget de période, car Envoy Gateway attache une seule traffic policy à une route : une requête est renvoyée après une connexion ou un flux refusé, une réinitialisation ou une réponse 429, 503 ou 504, jusqu’àmax_attemptsenvois, et un modèle qui ne répond rien dans le délai de requête de la route ne reçoit pas de nouvel envoi, car ce délai couvre tous les envois. Surcore/gateway/azure-api-management, il est réalisé comme le retry d’Azure autour du transfert, dans la section backend de la policy de l’API : une requête à laquelle il est répondu par HTTP 429 ou un statut 5xx est renvoyée, son corps étant conservé pour pouvoir être renvoyé, une seconde après l’envoi précédent, jusqu’àmax_attemptsenvois. Une connexion refusée ou interrompue, et un modèle qui ne répond rien dans le délai du transfert, ne donnent pas lieu à un nouvel envoi, car Azure met fin au retry sur une telle erreur et la transmet à la section on-error de la policy. Azure effectue de 1 à 50 nouvelles tentatives après le premier envoi, donc unmax_attemptsde 1 n’écrit aucun retry et une valeur supérieure à 51 est refusée nommément. Le retry remplace le transfert dont l’API hériterait, donc tant qu’il est attaché, un paramètre de transfert défini à une portée plus large de l’instance, comme un délai, ne s’applique pas à l’API, qui transfère avec les valeurs par défaut d’Azure. Sur la passerelle hébergée,core/retry-policyest réalisé en écrivant dans la ressource de la passerelle son nombre de tentatives, qui désigne les envois après le premier, de 1 à 5, doncmax_attemptsde 2 à 6 est respecté et toute autre valeur refusée ;core/fallback-chainn’y est pas réalisé, car cette passerelle ne se replie entre modèles qu’à l’intérieur d’une route qu’une requête nomme à la place d’un modèle, donc une requête pour un modèle ne se replie jamais. Surcore/gateway/kong-enterprise,core/fallback-chainest réalisé sur sa Recipe chart : les routes de chat et de completion de chaque alias auquelchainsdonne une entrée portent l’AI Proxy Advanced de Kong à la place de son AI proxy, avec le modèle de l’alias et les modèles sur lesquels son parcours se replie comme cibles par ordre de priorité — l’alias, puis les replis de son entrée dans l’ordre, l’entrée propre d’un repli n’étant suivie à son tour que tant que moins demax_hopsont été comptés. Le balancer envoie une requête une fois à chaque cible du parcours, dans l’ordre, jusqu’à ce que l’une réponde, passant à la suivante après une erreur ou un délai de connexion, un en-tête de réponse invalide ou une réponse 429, 500, 502, 503 ou 504, et renvoie toute autre réponse telle qu’elle est arrivée. Le build s’interrompt sur un nom que le socketmodelsne porte pas, sur un parcours atteignant deux fois un alias, à côté decore/retry-policy, puisque Kong garde un seul nombre de tentatives pour tout le parcours et ne peut pas renvoyer à un modèle avant de se replier, et sur une image de passerelle antérieure à 3.12.core/retry-policyn’y est pas réalisé, et sa réalisation interrompt chaque attachement en indiquant pourquoi : chaque modèle câblé est servi sur des routes qui lui sont propres et ne portent que ce modèle, donc un retry doit renvoyer la requête à cette même cible, et la référence de Kong se prête aux deux lectures quant à savoir si son balancer le fait. Surcore/gateway/agentgateway,core/retry-policyest réalisé sur la Recipe chart comme une policy de retry de la configuration propre de la passerelle, attachée au listener sur lequel arrivent ses requêtes de modèle : une requête est renvoyée, immédiatement et au même modèle, après une réponse 429, 500, 502, 503 ou 504, une connexion refusée ou réinitialisée, une connexion qui met plus de 11 secondes à s’ouvrir ou une résolution de nom échouée, jusqu’àmax_attemptsenvois. agentgateway envoie une requête une fois de plus que les tentatives de sa policy, donc la policy est écrite commemax_attemptsmoins un,max_attemptsà 1 n’en écrit aucune, et une valeur supérieure à 256 est refusée nommément. Une requête dont le corps dépasse 64 KiB est envoyée une seule fois, et la configuration ne fixe aucun délai, donc un modèle qui accepte la connexion et ne répond rien est attendu plutôt que sollicité à nouveau.core/fallback-chainn’y est pas réalisé, et sa réalisation interrompt chaque attachement en indiquant pourquoi : agentgateway bascule entre modèles en écartant un modèle défaillant pour les requêtes suivantes, tandis que la requête qui a échoué reçoit son échec en réponse, donc aucune requête ne parcourt une chaîne. Surcore/gateway/higress,core/retry-policyest réalisé comme le retry propre de la route, écrit sous forme d’annotations Ingress sur chaque route de modèle : une requête est renvoyée après une connexion refusée ou réinitialisée, une réponse 5xx ou un 429, y compris un POST, jusqu’àmax_attemptsenvois ;max_attemptsà 1 désactive le retry, en remplaçant le retry que le plan de contrôle de Higress donne à une route sans annotation, et une valeur supérieure à 2147483648 est refusée nommément. Un modèle qui accepte la connexion puis ne répond rien ou répond lentement n’est pas sollicité à nouveau, puisque la route ne fixe aucune échéance par tentative, et une requête en streaming n’est renvoyée qu’avant le début de sa réponse.core/fallback-chainn’y est pas réalisé non plus, et sa réalisation interrompt chaque attachement en indiquant pourquoi : Higress transmet une requête échouée au plus une fois, à une seule autre destination — le backend par défaut d’une route, ou l’unique route de repli que sa console écrit pour une route IA — donc aucune requête ne parcourt une chaîne. Surcore/gateway/traefik-hub, les deux sont réalisés sur la Recipe chart, et chacun interrompt le build sur une image Traefik Hub antérieure à v3.20, dont le failover n’accepte pas de middlewares sur les services qu’il essaie et dont le retry ne peut pas renvoyer un POST selon le statut d’une réponse — sauf une policy de retry d’un seul envoi.core/fallback-chainfait passer la route de chaque alias auquelchainsdonne une entrée par des failovers imbriqués propres à Traefik, en essayant dans l’ordre les modèles du parcours de l’alias — l’alias, puis les replis de son entrée dans l’ordre, l’entrée propre d’un repli n’étant suivie à son tour que tant que moins demax_hopsont été comptés — chacun avec son propre nom de modèle, ses identifiants, ses quotas et son retry. Une réponse 429 ou de 500 à 504 d’un modèle, après un éventuel retry de ce modèle, fait passer la requête au suivant ; toute autre réponse est renvoyée telle qu’elle est arrivée, celle du dernier modèle quelle qu’elle soit, et un corps de requête de plus de 1 MiB est refusé avec HTTP 413 au lieu d’être envoyé. Le build s’interrompt sur un nom que le socketmodelsne porte pas et sur un parcours atteignant deux fois un alias.core/retry-policyest le middleware de retry de Traefik, placé en dernier sur chaque route de modèle, ou sur chaque modèle qu’un parcours essaie : une requête est renvoyée immédiatement après une connexion qui n’a rien transmis au modèle et après une réponse 429 ou de 500 à 504, y compris un POST, jusqu’àmax_attemptsenvois, premier compris, etmax_attemptsà 1 n’écrit rien. Une réponse que la passerelle forme elle-même — un refus de sa vérification de clé, une garde, le masquage ou un quota — ne donne jamais lieu à un nouvel envoi, pas plus qu’une réponse en streaming une fois commencée. -
Budget par période :
core/period-budgetborne ce que le trafic traversant une passerelle peut consommer sur une période : unelimit, laperiodqu’elle couvre, unscope— tout ce que la passerelle sert, chaque appelant ou chaque modèle — et uneunit— un coût en dollars américains ou en tokens —, et une fois que ce que la passerelle a compté sur la période dépasse la limite, les requêtes suivantes aux modèles sont refusées. Il s’attache à tout composant déclarantdataplane.aggrega.ai/period-budget. La bibliothèque standard le réalise sur la passerelle d’IA, dont le budget couvre tout ce que la passerelle sert, est compté en dollars américains et repart au début de chaque période — un nombre de jours à partir de minuit UTC, ou un mois calendaire à partir de son premier jour : la réalisation écrit la limite et la période dans la configuration que la Recipe de la passerelle produit, refuse nommément toute autre unité, portée ou période — dont30d, que la passerelle compte comme un mois calendaire — et s’arrête à moins que les emplacements d’identifiantsdatabase_urletapi_keyde la passerelle soient tous deux attachés, car sans sa base de données comptable la passerelle ne tient aucun compte et sans clé d’administration elle ne vérifie aucun appelant par rapport au budget. Une fois que le compte dépasse la limite, la passerelle refuse les requêtes aux modèles de la clé d’administration ainsi que celles de chaque appelant ; sa liste des modèles et sa gestion des clés répondent toujours à cette clé. Sur la passerelle hébergée, il est réalisé comme une règle de plafond de dépenses sur la ressource de la passerelle, comptée en dollars américains sur une fenêtre qui avance avec le temps — la dernièreperiod, pour les modèles dont la passerelle connaît la tarification — pour tout ce que la passerelle sert : un budget par appelant ou par modèle, les tokens et un mois calendaire sont refusés nommément. Surcore/gateway/apisix, il est réalisé sur la Recipe chart, écrit sur les routes des modèles câblés sous la forme de la limitation de débit par tokens d’APISIX : compté en tokens que la réponse de chaque modèle rapporte —total_tokens,prompt_tokensoucompletion_tokens— sur une fenêtre fixe deperiodqui s’ouvre avec la première requête à un modèle après la fermeture de la fenêtre précédente plutôt que selon l’horloge, pour tout ce que la passerelle sert, pour chaque modèle câblé séparément, ou pour chaque appelant que sa Release déclare dansinfra.callersséparément, la passerelle les distinguant par la clé que chacun présente. Une fois que le compte atteint la limite, la passerelle répond aux requêtes aux modèles par HTTP 503 jusqu’à la fermeture de la fenêtre ; les tokens d’une requête sont ajoutés une fois sa réponse terminée, de sorte que la requête qui atteint la limite est servie, et une réponse servie par son cache sémantique ne compte rien et est servie au-delà de la limite. APISIX ne compte aucun token sur une requête de complétion, donc tant que le budget est attaché chaque modèle câblé n’obtient que sa route de chat, et il conserve le compte dans la mémoire du processus de la passerelle, donc le chart exécute une seule réplique et un redémarrage ouvre une nouvelle fenêtre. Un budget en dollars américains, un par appelant tant queinfra.callersn’en déclare aucun, un mois calendaire et un second budget sur une même passerelle sont refusés nommément, de même qu’un attachement sur sa Recipe workload, qui ne produit aucune route. Surcore/gateway/envoy-gateway, il est réalisé comme la limitation de débit fondée sur l’usage d’Envoy Gateway, sur la route d’IA qui sert les modèles câblés à la passerelle : la route déclare le compte de tokens queunitnomme —total_tokens,prompt_tokensoucompletion_tokens— comme un coût qu’Envoy AI Gateway lit sur chaque réponse, et une traffic policy sur cette route l’impute lorsque la réponse se termine, surlimittokens par unité de la limitation de débit d’Envoy Gateway, pour tout ce que la passerelle sert ou pour chaque modèle câblé séparément. Chaque fenêtre est fixée sur l’horloge UTC — une seconde, une minute, une heure, un jour à partir de minuit, une semaine à partir d’un jeudi, ou 30 ou 365 jours comptés à partir du 1er janvier 1970 — et1moest un mois calendaire, selon un paramètre du service de limitation de débit d’Envoy Gateway qui vaut alors pour toute limitation de débit mensuelle que tient cette installation. Le compte est tenu par le service de limitation de débit que le plan de contrôle d’Envoy Gateway crée et active pour chaque passerelle qu’il sert, dans le stockage au protocole Redis câblé au socketcachede la passerelle. Une fois que le compte dépasse la limite, la passerelle répond aux requêtes aux modèles par HTTP 429 jusqu’à la fin de la fenêtre ; les tokens d’une requête sont ajoutés une fois sa réponse terminée, de sorte que la requête qui franchit la limite est servie. Tant que le stockage ou le service de limitation de débit est injoignable, ou qu’une vérification dure plus longtemps que le délai d’expiration de limitation de débit d’Envoy, les requêtes aux modèles sont refusées par HTTP 500, selon un paramètre du plan de contrôle d’Envoy Gateway qui vaut alors pour toute limitation de débit que tient cette installation, de sorte qu’une limitation de débit qui y est appliquée à la main échoue elle aussi en mode fermé ; une requête admise juste avant une panne est tout de même servie et non comptée, car ses tokens sont imputés après la réponse, et un stockage qui conserve le compte en mémoire recommence chaque fenêtre lorsqu’il redémarre. Un budget en dollars américains, un par appelant — la passerelle ne distingue les appelants que par un en-tête que l’appelant écrit lui-même, et rien sur ce chemin ne le vérifie —, toute autre période et un second budget sur une même passerelle sont refusés nommément, de même qu’un attachement sans rien de câblé au socketmodelsou au socketcache. Surcore/gateway/azure-api-management, il est réalisé comme la limite de tokens d’Azure, écrite dans la stratégie de l’API : comptée en tokens de prompt et de complétion que chaque réponse rapporte, ensemble, pour tout ce que l’API sert ou pour chaque abonnement API Management, dont la passerelle vérifie la clé — soit un quota sur une fenêtre fixe selon l’horloge UTC, une heure, un jour, une semaine, un mois calendaire ou une année calendaire (1h,1d,7d,1moou12mo; Microsoft ne dit pas quel jour commence une semaine), auquel il est répondu par HTTP 403 une fois dépassé, soit un débit sur une minute (1m), auquel il est répondu par HTTP 429 et qui est compté sur une fenêtre glissante sur les niveaux classiques et comme un seau à jetons sur les niveaux v2. Le compte est l’usage que chaque réponse rapporte, de sorte que des requêtes simultanées peuvent dépasser la limite, et chaque passerelle de l’instance tient son propre compte. Un budget en dollars américains ou en tokens de prompt ou de complétion seuls, un par modèle — le modèle qu’une requête nomme est écrit par l’appelant, et plusieurs noms peuvent atteindre un même modèle —, un par abonnement sur une API qui n’exige aucune clé d’abonnement, toute autre période et une limite qui n’est pas un nombre entier sont refusés nommément. Le niveau Consumption n’exécute aucune limite de tokens. Surcore/gateway/kong-enterprise, il est réalisé sur la Recipe chart, écrit dans les routes que la passerelle importe sous la forme de l’AI Rate Limiting Advanced de Kong : compté en tokens que la réponse de chaque modèle rapporte —total_tokens,prompt_tokensoucompletion_tokens— dans des fenêtres fixes deperiod, un nombre de secondes, de minutes, d’heures ou de jours, chaque requête étant comptée dans l’unique fenêtre où tombe son instant, pour tout ce que la passerelle sert ou pour chaque modèle câblé séparément, une requête sous la portéemodelétant comptée sur l’alias qu’elle a nommé, quel que soit le modèle qui lui a répondu. Une fois que le compte atteint la limite, la requête suivante à un modèle reçoit HTTP 429 jusqu’à la fin de la fenêtre, de sorte que la requête qui franchit la limite est servie ; Kong peut aussi refuser une requête par anticipation, sur sa propre estimation des tokens de prompt qu’elle contient. Le compte est tenu dans le backend PostgreSQL de la passerelle, partagé par chaque réplique et conservé après un redémarrage. Un budget en dollars américains — Kong ne compte le coût qu’à partir d’un prix que sa configuration donne à chaque modèle, et le catalogue n’en fournit aucun —, un par appelant — Kong ne distingue les appelants qu’en tant que consumers qu’un plugin d’authentification nomme, et la passerelle ne déclare aucun appelant, pour les raisons que donne « Kong devant les modèles » ci-dessus —, un mois calendaire, un second budget sur une même passerelle et une image de passerelle antérieure à 3.15 sont refusés nommément, de même qu’un attachement sans rien de câblé au socketmodels. Surcore/gateway/agentgateway, il est réalisé sur la Recipe chart, écrit dans la configuration de la passerelle et compté en tokens totaux que chaque réponse rapporte : sous la portéecallercomme un budget sur la clé d’API de chaque appelant que sa Release déclare dansinfra.callers, sur des fenêtres fixes deperiodalignées sur l’epoch Unix, un jour commençant à minuit UTC, conservé dans un stockage SQLite sur un volume que la Recipe produit, avec une seule réplique ; sous la portéegatewayoumodelcomme un seau à jetons pour tout ce que la passerelle sert ou pour chaque nom de modèle qu’une requête demande, rempli jusqu’à la limite à chaqueperiodà partir du moment où la passerelle a lu sa configuration et conservé dans sa mémoire, de sorte qu’un redémarrage ou une configuration modifiée le remplit à nouveau. Une fois que ce qui a été compté atteint la limite, il est répondu aux requêtes aux modèles par HTTP 429 jusqu’à la fin de la fenêtre ou jusqu’au remplissage du seau ; la requête qui l’atteint est servie. Un budget en dollars américains — le catalogue des coûts de modèles de la passerelle ne tarifie aucun des modèles qui y sont câblés, de sorte que le budget ne compterait rien —, en tokens de prompt ou de complétion seuls, un par appelant tant queinfra.callersn’en déclare aucun, un mois calendaire, une limite qui n’est pas un nombre entier et un second budget sur une même passerelle sont refusés nommément, de même qu’un attachement sans rien de câblé au socketmodels; sa Recipe compose n’en a aucune réalisation. Surcore/gateway/traefik-hub, il est réalisé sur la Recipe chart comme le middleware de quota de Traefik Hub sur la route de chaque modèle câblé, qui tient son compte dans le stockage au protocole Redis câblé au socketcachede la passerelle : il compte les tokens que chaque réponse rapporte —total_tokens,prompt_tokensoucompletion_tokens— ou, soususd, leur coût en dollars américains, tarifé d’après une liste de modèles livrée avec le middleware, un modèle pour lequel il n’a pas de prix étant refusé par HTTP 422, sur une fenêtre qui glisse avec le temps, ce qui a été compté à un moment se libérant à nouveau une période plus tard, pour chaque modèle câblé séparément, ou pour tout ce que la passerelle sert tant qu’un seul modèle est câblé. Une fois que le compte atteint la limite, les requêtes aux modèles sont refusées par HTTP 429 ; le compte d’une requête est ajouté une fois sa réponse terminée, de sorte que la requête qui franchit la limite, et toute requête servie à côté d’elle, est servie, et une réponse servie par le cache sémantique ne compte rien. La référence de Traefik indique que le quota sert les requêtes sans les compter tant que le stockage est injoignable. Un budget par appelant — le quota distingue les requêtes par l’adresse du client, un en-tête de requête ou l’hôte de la requête, et aucun d’eux n’est l’appelant que la vérification de clé de la passerelle a vérifié —, un pour toute la passerelle tant que plusieurs modèles sont câblés, puisque la référence de Traefik ne dit pas si des routes nommant un même quota en partagent le compte, un mois calendaire et toute période autre qu’en heures ou en jours, ou en minutes ou secondes formant des heures entières, sont refusés nommément, de même qu’une limite qui n’est pas un nombre entier de tokens et un attachement sans rien de câblé au socketmodelsou au socketcache. Surcore/gateway/higress, il est réalisé sur la Recipe chart comme le plugin de limite de tokens de Higress sur la route de chaque modèle câblé, qui tient son compte dans le stockage au protocole Redis câblé au socketcachede la passerelle : il additionne les tokens de prompt et de complétion que chaque réponse rapporte, ensemble, une fois la réponse terminée, sur une fenêtre fixe deperiod— une seconde, une minute, une heure ou un jour — qui s’ouvre lorsque la première réponse qu’elle contient est comptée, pour tout ce que la passerelle sert ou pour chaque alias séparément. Tant que le compte dépasse la limite, il est répondu aux requêtes aux modèles par HTTP 429 jusqu’à la fin de la fenêtre, de sorte que la requête qui franchit la limite est servie. Une réponse ne rapportant aucun usage ne compte rien, donc la Recipe demande au modèle d’une requête en streaming de rapporter son usage et refuse par HTTP 403 une requête en streaming qui désactive ce rapport, une requête dont le type de contenu ni ne contientapplication/jsonni ne commence parmultipart/form-data, que le proxy d’IA transmet sans demander le rapport, et une requête dont les plugins de la passerelle ne lisent pas le corps — un corps compressé, un type de contenu contenantoctet-streamougrpc, un upgrade ; un client envoyant délibérément un corps que la validation de la passerelle ne peut pas décoder passe outre ces refus, et une telle requête en streaming n’est pas comptée. Sans masquage attaché, une requête dont le corps dépasse le tampon de 32 KiB de la passerelle peut être refusée par HTTP 413, selon le moment où le stockage répond. Tant que le stockage est injoignable, les requêtes aux modèles sont servies et non comptées : le plugin n’a aucun paramètre qui les refuse dans ce cas. Un budget en dollars américains ou en tokens de prompt ou de complétion seuls, un par appelant — la passerelle ne déclare aucun appelant, elle n’en vérifie donc aucun —, toute autre période, une limite qui n’est pas un nombre entier et un second budget sur une même passerelle sont refusés nommément, de même qu’un attachement sans rien de câblé au socketmodelsou au socketcache. -
Concurrence :
core/concurrency-limitplafonne le nombre de requêtes qu’une passerelle transporte à la fois (max_in_flight), ce qui empêche un afflux d’appelants de devenir une file d’attente devant le modèle situé derrière elle.scopeindique ce que compte un plafond :gateway, la valeur par défaut, compte ensemble chaque requête que la passerelle transmet ;modeldonne à chaque cible à laquelle la passerelle envoie des requêtes un compte qui lui est propre, une cible étant chaque entrée upstream vers laquelle la passerelle route, de sorte que là où un nom de modèle a plusieurs entrées, chacune est comptée séparément. Le plafond et sa portée relèvent d’un dimensionnement de capacité que l’opérateur décide, défini dans l’infrade l’attachement, donc l’opérateur l’attache dans la Release. Le plafond est compté par proxy en cours d’exécution, de sorte que là où plusieurs répliques s’exécutent, chacune d’elles en admet autant. Il s’attache à tout composant déclarantdataplane.aggrega.ai/concurrency-cap, et une réalisation refuse nommément la portée que sa passerelle ne compte pas. Surcore/gateway/nginx, la portéegatewayest réalisée comme lelimit_connde NGINX, avec pour clé un mot identique pour chaque requête, de sorte que NGINX compte chaque requête qu’il traite comme un seul total, conservé dans une mémoire que partagent ses processus worker, et répond par HTTP 503 à une requête au-delà du plafond ; la portéemodelest refusée, puisque NGINX ne tient aucun compte par cible upstream, de même qu’unmax_in_flightsupérieur à 65535, le maximum qu’acceptelimit_conn. Surcore/gateway/envoy-gateway, la portéemodelest réalisée comme le disjoncteur de la traffic policy sur la route qui sert les modèles câblés, la policy qui porte aussi la limitation de débit d’un budget par période et la nouvelle tentative de la politique de nouvelles tentatives : Envoy Gateway l’applique au backend de chaque règle de cette route, et chaque modèle câblé a sa propre règle, de sorte qu’au plusmax_in_flightrequêtes sont envoyées à la fois à chaque modèle câblé, et une requête au-delà du plafond reçoit HTTP 503 et n’est pas renvoyée ; un envoi que la politique de nouvelles tentatives répète compte dans le plafond comme le premier. Les threads worker d’Envoy vérifient le compte puis l’incrémentent, de sorte que des requêtes arrivant ensemble peuvent le porter brièvement au-dessus du plafond. La portéegatewayest refusée, puisqu’Envoy Gateway tient un plafond pour chaque backend et aucun sur leur total, de même qu’un attachement sans rien de câblé au socketmodels. Sur la passerelle d’IA, la portéemodelest réalisée comme lemax_parallel_requestsde chaque entrée de sa table des modèles, saisie à la main comme câblée : au plusmax_in_flightrequêtes sont en cours vers chaque entrée à la fois, et une requête trouvant son entrée pleine reçoit HTTP 429 — après les nouvelles tentatives de la passerelle là où son alias a une seule entrée, et immédiatement là où il en a plusieurs, même si une autre d’entre elles a de la place, puisque le proxy choisit l’entrée avant de compter — à moins quecore/fallback-chainne liste des replis pour son alias, vers lesquels elle est alors envoyée. Le proxy conserve chaque compte en mémoire, où par défaut un enregistrement expire dix minutes après sa création et un nouveau compte repart alors de zéro, donc l’attachement fixe aussi cette durée de vie à un siècle, conservant chaque compte tant que le proxy s’exécute. En raison de cette durée de vie, la passerelle refuse une requête portantprioritytant que le plafond est attaché, même là où la Release admet le champ, puisque le proxy conserve une entrée de file d’attente pour chaque requête de ce type jusqu’à l’expiration de son enregistrement ; et la compilation s’arrête sur une table des modèles de plus de 100 entrées, au-delà desquelles le stockage où sont conservés les comptes, qui contient 200 enregistrements et en supprime un chaque fois qu’il est plein, pourrait supprimer un compte. La portéegatewayy est refusée, puisque l’unique total du proxy n’est lu que par un limiteur de requêtes qu’une variable d’environnement active, lequel compte une requête pendant sa première seconde. La passerelle hébergée ne le réalise pas non plus : la limite de requêtes que sa Recipe terraform écrit dans la ressource de la passerelle est un débit, un nombre de requêtes sur un intervalle, plutôt qu’un plafond sur les requêtes en cours. -
Journalisation d’audit :
core/audit-loggingfait conserver par une passerelle un enregistrement de chaque requête au modèle qu’elle sert, indiquant le modèle qui a répondu et les tokens que la réponse déclare, et chaque réalisation indique où l’enregistrement aboutit. Elle s’attache à tout composant portantgateway.aggrega.ai/intelligence: semantic, et ses trois valeurs appartiennent à l’opérateur, définies dans soninfra, de sorte que c’est l’opérateur qui l’attache dans la Release.require_cost, activé par défaut, fait aussi indiquer par l’enregistrement ce que chaque requête a coûté, dans une devise que la réalisation précise.require_verified_caller, activé par défaut, lui fait indiquer l’appelant que la passerelle a vérifié, par une clé que la passerelle a émise ou contrôlée.retention_days, non défini par défaut, fait supprimer par la passerelle un enregistrement une fois qu’il a ce nombre de jours ; sans cette valeur, la passerelle elle-même ne supprime aucun enregistrement, et un enregistrement dure aussi longtemps que l’endroit où il aboutit le conserve. Une passerelle qui ne peut pas respecter une valeur refuse l’attachement au build, en indiquant la valeur, de sorte qu’un attachement qui laisserequire_costetrequire_verified_callerà leurs valeurs par défaut obtient le coût et l’appelant vérifié, ou un arrêt. Désactiverrequire_verified_callerrevient à accepter un enregistrement dont l’appelant est celui que la requête elle-même prétend, ou aucun appelant : n’importe qui envoyant une requête peut alors la faire enregistrer au nom d’un autre appelant, de sorte qu’un tel enregistrement ne montre pas qui a envoyé une requête. Sur la passerelle IA, l’enregistrement est une ligne dans la base de données comptable de la passerelle, et chaque valeur est respectée : la ligne indique ce que la requête a coûté en dollars américains, tarifé d’après la table que la passerelle tient par modèle — un modèle que la table ne tarife pas est enregistré comme ne coûtant rien — et indique la clé que la passerelle a vérifiée, avec l’utilisateur et l’équipe auxquels la clé appartient, tandis que l’utilisateur final qu’indique une ligne est celui que la requête écrit, sans contrôle. Sans sa base de données comptable, la passerelle n’écrit aucune ligne, et sans clé d’administration elle ne contrôle aucun appelant et n’écrit aucune ligne pour une requête qui ne présente aucune clé et n’indique aucun utilisateur final, de sorte que le build s’arrête à moins que les emplacements d’identifiantsdatabase_urletapi_keyde la passerelle soient tous deux attachés ; tant quevalues.log_maskingde la passerelle liste ce qu’il faut masquer, elle n’enregistre que les requêtes ayant reçu une réponse. Surcore/gateway/envoy-gateway, l’enregistrement est une ligne du journal d’accès de la passerelle, que sa Recipe écrit tant que l’attachement est présent : une ligne JSON par requête sur la sortie standard du data plane, portant les champs qu’Envoy Gateway écrit par défaut, le modèle que la requête a nommé, le modèle qui a répondu et les tokens de prompt, de complétion et totaux que la réponse déclare, la route qui sert les modèles déclarant ces comptages afin qu’Envoy AI Gateway les enregistre. Une requête à laquelle le modèle n’a pas répondu ne porte aucun modèle ayant répondu ni aucun token, et le journal d’accès ne conserve rien lui-même, de sorte que la durée de vie d’une ligne dépend de ce qui collecte cette sortie. Aucun champ n’indique un appelant vérifié par la passerelle : l’adresse du client et les en-têtes qu’il envoie sont écrits tels qu’ils arrivent. La passerelle ne tient aucun prix, rien sur la route que sa Recipe produit ne vérifie l’appelant, et le journal d’accès ne conserve aucun enregistrement qu’il puisse supprimer, de sorte que sa réalisation construit un attachement qui désactiverequire_costetrequire_verified_calleret ne donne aucunretention_days, et sinon s’arrête en indiquant chaque valeur qu’elle ne peut pas respecter, toutes dans un seul échec ; elle s’arrête aussi lorsque rien n’est relié au socketmodels. Surcore/gateway/agentgateway, l’enregistrement est une ligne que la passerelle écrit dans un stockage SQLite sur un volume que sa Recipe chart produit tant que l’attachement est présent, avec un seul réplica, pour chaque requête au modèle qui passe ses contrôles de clé, de budget et d’autorisation, le refus d’un garde compris : le modèle que la passerelle a demandé au serveur de modèles — le nom que publie le modèle relié, et non l’alias envoyé par l’appelant — et le modèle qui a répondu, les tokens d’entrée, de sortie et totaux que la réponse déclare, son statut et sa durée, et, pour chaque appelant que sa Release déclare dansinfra.callers, le nom de cet appelant, tiré de la clé d’API que la passerelle a vérifiée. Une requête refusée pour sa clé, par une règle d’autorisation ou par le budget d’un appelant ne laisse aucune ligne. Aucun texte de prompt ou de réponse n’est conservé, et les lignes se lisent par l’interface d’administration de la passerelle, qui écoute à l’intérieur de son pod.require_verified_callerest respecté tant que des appelants sont déclarés ;require_costest refusé nommément, puisque le catalogue de coûts des modèles de la passerelle ne tarife aucun des modèles qui lui sont reliés, et le sont aussirequire_verified_callersans appelant déclaré etretention_days, puisque la passerelle ne supprime aucun enregistrement ; sa Recipe compose n’en a aucune réalisation. Surcore/gateway/higress, l’enregistrement est le champai_logde la ligne du journal d’accès de la passerelle, que le plugin de statistiques de Higress remplit tant que l’attachement est présent : le modèle qui a répondu et les tokens d’entrée, de sortie et totaux que la réponse déclare, sur la sortie standard de la passerelle, sans texte de prompt ni de réponse. La passerelle ne déclare aucun appelant, ne tarife rien et ne conserve aucun enregistrement qu’elle pourrait supprimer, de sorte que sa réalisation construit un attachement qui désactiverequire_costetrequire_verified_calleret ne donne aucunretention_days, et sinon s’arrête en indiquant chaque valeur qu’elle ne peut pas respecter, toutes dans un seul échec ; elle s’arrête aussi lorsque rien n’est relié au socketmodels. Surcore/gateway/traefik-hub, tout attachement s’arrête, en indiquant pourquoi : Traefik Hub ne conserve un enregistrement d’une requête au modèle que sous forme de span OpenTelemetry que ses middlewares IA exportent vers un backend de traçage — indiquant le modèle et, à son niveau détaillé, les tokens et leur coût en dollars américains — et sa réalisation ne relie aucun backend de traçage, de sorte que l’enregistrement n’aboutirait nulle part ; le span n’indique pas non plus d’appelant, de sorte qu’il ne peut pas indiquer celui que le contrôle de clé de la passerelle a vérifié. Surcore/gateway/azure-api-management, tout attachement s’arrête, comme le dit le point consacré à cette passerelle plus haut, et aucune autre passerelle de la bibliothèque standard ne la réalise, de sorte qu’un attachement sur toute autre passerelle s’arrête en indiquant le type. -
Mise en cache sémantique :
core/semantic-cachingdéclare un cache qui répond à un prompt avec la réponse stockée pour un prompt antérieur suffisamment proche par le sens, plutôt que d’appeler à nouveau le modèle.embedding_modelnomme le modèle qui transforme chaque prompt en vecteur, tel que la passerelle le publie ; une réponse stockée est servie lorsque les deux prompts sont similaires au moins à hauteur desimilarity_threshold, et elle reste utilisable pendantttl_seconds.scopedétermine qui partage un cache :end_user, la valeur par défaut, tient à part chaque utilisateur final que la passerelle identifie, tandis quekeysert depuis un seul cache tout appelant présentant une même clé, de sorte qu’un utilisateur final derrière cette clé peut se voir servir une réponse générée pour un autre.core/data-maskingdéclare un conflit avec elle, de sorte que le build s’arrête sur un composant qui porte les deux. La bibliothèque standard la réalise sur la passerelle IA, qui garde les réponses dans uncore/datastore/redisrelié à son socketcache_store, en présentant au stockage le mot de passe que contient l’identifiant de cette connexion lorsque le stockage en exige un, le stockage supprimant chaque réponse une foisttl_secondsécoulées, et met en cache les requêtes chat, responses et messages, pas les completions ni les embeddings. La réalisation arrête le build à moins que l’emplacementapi_keyde la passerelle soit attaché, car sans clé d’administration la passerelle ne contrôle aucun appelant, sur unembedding_modelque la table des modèles de la passerelle ne publie pas, et lorsque rien n’est relié àcache_store. Une réponse stockée n’est servie qu’à une requête qui correspond à ce sous quoi elle a été stockée : la clé que présente la requête, que la passerelle vérifie, avec l’équipe et l’organisation de cette clé ; avecend_user, l’utilisateur final que nomme la requête ; et le modèle que demande la requête avec ses autres paramètres. La passerelle écrit la clé, l’équipe, l’organisation et l’utilisateur final dans la requête elle-même, par-dessus toute valeur qu’un appelant a envoyée pour eux dans une requête chat ; dans une requête responses ou messages, elle retire un champ d’équipe, d’organisation ou d’utilisateur final des métadonnées propres de la requête et en refuse un qui y nomme la clé, de sorte qu’aucune requête ne peut, en la nommant, accéder aux réponses d’une autre clé. Les métadonnées propres d’une requête peuvent toutefois la déplacer parmi les réponses de la clé qu’elle présente : dans une requête responses,model_groupremplace le modèle qu’elle demande dans ce sous quoi sa réponse est stockée ; dans une requête responses ou messages,caching_groupspermet aux requêtes nommant le même groupe d’alias de modèles de partager les réponses entre eux ; et dans une requête responses ou chat,redis_namespacetient à part les requêtes nommant un namespace de celles qui n’en nomment aucun. La passerelle lit un utilisateur final dans un en-tête ou un champ du corps que la requête elle-même désigne, et n’en vérifie aucun : avecend_user, un appelant nommant un autre utilisateur final se voit servir les réponses de cet utilisateur final, et les requêtes ne nommant aucun utilisateur final partagent un seul cache avec toutes les autres requêtes de ce type sous la clé qu’elles présentent. La passerelle hébergée ne la réalise pas : son cache ne répond qu’à une requête identique à une requête antérieure. Surcore/gateway/azure-api-management, elle est réalisée comme la recherche et le stockage du cache sémantique d’Azure, écrits dans la politique de l’API :embedding_modelnomme un backend que l’instance API Management possède déjà pour un modèle d’embeddings, que l’instance atteint avec son identité managée, et l’instance a besoin d’un cache Redis avec RediSearch configuré comme son cache externe, deux choses que le build ne peut pas voir, de sorte que le build s’arrête tant que l’opérateur n’affirme pas que le cache sert RediSearch en définissantinfra.cache_serves_vector_searchde la passerelle ; le stockage conserve une réponse pendantttl_seconds; etsimilarity_thresholdest écrit comme le seuil de score d’Azure, un moins le seuil, en lisant ce score comme une distance cosinus, puisque Microsoft en donne la plage et le sens — plus bas exige des prompts plus proches — mais pas la mesure. Une réponse est stockée et servie séparément par API et par abonnement API Management, dont la passerelle vérifie la clé, de sorte que la réalisation gardekey, la refuse sur une API qui n’exige aucune clé d’abonnement, et refuseend_user: l’API que produit sa Recipe ne valide le jeton d’aucun utilisateur final, de sorte que la passerelle n’a aucun utilisateur final vérifié à tenir à part.core/gateway/contouretcore/gateway/nginxne la réalisent pas non plus, car ils n’offrent aucun cache sémantique. Surcore/gateway/agentgateway, sa réalisation arrête tout attachement, en indiquant pourquoi : agentgateway ne garde aucun cache de réponses, et sa mise en cache de prompts indique seulement où un fournisseur qui met lui-même les prompts en cache peut le faire. Surcore/gateway/kong-enterprise, sa réalisation arrête tout attachement, en indiquant la portée demandée : l’AI Semantic Cache de Kong n’a aucun paramètre qui tienne les réponses stockées d’un appelant à part de celles d’un autre, et la passerelle ne distingue les appelants que comme les consumers qu’un plugin d’authentification nomme et ne déclare aucun appelant, pour les raisons que donne « Kong devant les modèles » plus haut, de sorte qu’avecend_usercomme aveckeytoutes les requêtes partageraient un seul cache. Surcore/gateway/higress, sa réalisation arrête tout attachement, en indiquant la portée demandée : le cache sémantique de Higress stocke chaque réponse sous un unique préfixe de clé suivi du texte du prompt, et rien dans cette clé ne nomme un appelant ou un utilisateur final, tandis que la passerelle ne déclare aucun appelant, de sorte que toutes les requêtes partageraient un seul cache. Surcore/gateway/apisix, elle est réalisée sur la Recipe chart, écrite sur la route chat de chaque modèle relié comme le cache sémantique d’APISIX 3.18.0, pour les appelants que sa Release déclare dansinfra.callers: une réponse est stockée par route et par appelant, sous la clé que l’appelant a présentée, que la passerelle vérifie, de sorte qu’aucun appelant ne se voit servir une réponse stockée pour un autre ; la réalisation gardekeyet refuseend_usernommément, car la passerelle ne peut pas distinguer les utilisateurs finaux derrière une même clé.embedding_modelnomme une connexion sur le socketmodelsde la passerelle, avec le point de terminaison, le modèle et l’identifiant de laquelle le cache calcule les embeddings. Le cache calcule l’embedding du dernier message utilisateur d’une requête et sert une réponse stockée dont le message est similaire au moins à hauteur desimilarity_thresholdet dont les messages antérieurs — un prompt système, des tours antérieurs — sont les mêmes. Les réponses restent pendantttl_secondsdans uncore/datastore/redisrelié au socketcache_storede la passerelle, auquel le cache présente le mot de passe que contient l’identifiant de cette connexion, et une réponse servie par le sens est de nouveau stockée sous cette requête pourttl_secondsde plus. Les requêtes de complétion ne sont pas mises en cache, et une défaillance du stockage ou de l’embedding est un échec de cache : la requête reçoit tout de même une réponse. La réalisation s’arrête lorsqu’aucun appelant n’est déclaré, lorsque rien n’est relié àcache_storeou au socketmodels, et sur unembedding_modelqu’aucune connexion n’y porte. APISIX indexe une réponse stockée par route et par appelant plutôt que par passerelle, de sorte que deux passerelles APISIX reliées à un même stockage, ou deux Releases d’un même Aggregate pointant leur passerelle vers un même stockage externe, peuvent servir une réponse en cache à un appelant du même nom sur le même alias et le même modèle. Sa Recipe workload, à APISIX 3.17.0, ne porte aucun cache sémantique. Surcore/gateway/traefik-hub, elle est réalisée sur la Recipe chart comme le cache sémantique de Traefik Hub sur la route de chaque modèle relié, pour les appelants que sa Release déclare dansinfra.callers: une réponse est stockée par modèle relié et par appelant, sous l’appelant que le contrôle de clé de la passerelle a vérifié, chacun par sa propre clé, de sorte qu’aucun appelant ne se voit servir une réponse stockée pour un autre ; la réalisation gardekeyet refuseend_usernommément, car la passerelle ne peut pas distinguer les utilisateurs finaux derrière une même clé.embedding_modelnomme une connexion sur le socketmodelsde la passerelle, avec le point de terminaison, le modèle et l’identifiant de laquelle le cache calcule l’embedding du texte d’une requête.similarity_thresholdest écrit comme la borne de distance du cache, un moins le seuil, lue comme une distance cosinus, puisque la référence de Traefik donne le sens de la borne mais pas sa mesure. Une réponse est conservée pendantttl_secondsdans uncore/datastore/redisrelié au socketcache_storede la passerelle, et une requête trop volumineuse pour en calculer l’embedding reçoit une réponse sans cache. La réalisation s’arrête lorsqu’aucun appelant n’est déclaré, lorsque rien n’est relié àcache_storeou au socketmodels, sur unembedding_modelqu’aucune connexion n’y porte, et sur une image Traefik Hub dont le tag ne nomme aucune version à partir de v3.19.11 au sein de la 3.19 ou à partir de v3.20.6, puisqu’une version antérieure partage un seul cache entre tous les appelants d’une route. -
Filtrage de l’injection de prompt :
core/prompt-injection-shielddéclare que les requêtes de modèle qu’un gateway transmet sont vérifiées, avant l’appel du modèle, à la recherche d’une tentative de passer outre les instructions données au modèle, avec unesensitivitydestandardoustrict— strict refusant davantage de telles tentatives, et davantage de requêtes légitimes avec elles. La vérification est le verdict d’un classifieur probabiliste : elle laisse passer certaines attaques — dont des attaques reformulées, encodées ou orthographiées autrement —, refuse certaines requêtes légitimes et est notoirement contournable ; c’est donc un contrôle parmi d’autres, et elle ne juge ni la réponse du modèle, ni les arguments des appels d’outils, ni les images. Elle s’attache à tout gateway, et une réalisation soit fait passer les requêtes du gateway par une garde raccordée à son socketguard, ce qui n’exige du gateway rien d’autre que de transmettre à une adresse configurée, soit active une vérification que le gateway exécute lui-même. Avec une garde, la garde vérifie chaque requête et transmet au modèle ce qu’elle admet, et attacher la Feature sans rien sur ce socket arrête le build en le signalant. La bibliothèque standard la réalise sur le gateway IA et sur le gateway NGINX, chacun aveccore/security/nemo-guardrailscomme garde : un service parlant l’API chat-completions d’OpenAI, dont le rail envoie le dernier message utilisateur d’une requête au classifieur ducore/security/trustyai-huggingface-detectorqui lui est raccordé et refuse la requête lorsque le score de ce classifieur atteint le seuil de la garde. Une requête refusée reçoit la réponse de la garde elle-même, sous forme de complétion ordinaire, et rien d’elle n’atteint le modèle ; lorsque la garde ou son détecteur est injoignable, la requête est également refusée. Chacun des deux arrête le build à moins que la garde soit celle-ci, avec le seuil que nomme la sensibilité — 0.5 pourstandardet 0.001 pourstrict, les deux valeurs mesurées pour le classifieur par défaut du détecteur, dont le gateway, qui voit la garde et non le détecteur derrière elle, ne peut pas vérifier le modèle. Sur le gateway IA, chaque alias de la table des modèles est envoyé à la garde, chaque cible étant écriteopenai/<model>, de sorte que la table est celle saisie à la main : un modèle raccordé au socketmodelsdu gateway serait envoyé à son propre endpoint avec l’identifiant de sa propre connexion, en contournant la garde, et la réalisation arrête le build tant que ce socket contient une connexion, en la nommant. Le gateway IA refuse toute requête autre qu’une complétion de chat, le seul type que la garde vérifie ; sur le gateway NGINX, son unique location transmet à la garde au lieu de l’upstream, et la garde ne répond à aucune autre route de modèle. Surcore/gateway/azure-api-management, elle est réalisée par le prompt shield propre à Azure, activé dans la policy de l’API via le backend Azure AI Content Safety de l’instance que nommeinfra.content_safety_backend_id, et le build s’arrête tant que cette clé n’est pas définie : Azure AI Content Safety vérifie chaque requête à la recherche d’une attaque utilisateur avant l’appel du modèle, avant la recherche dans un cache sémantique, et le gateway répond par HTTP 403 à une requête où il en détecte une, comme il répond à une requête plus longue que ce que le service accepte. Le shield est activé ou désactivé, doncstandardest conservé etstrictest refusé nommément, et il fonctionne à la sensibilité propre de Microsoft, non mesurée par rapport au seuil questandardnomme sur les gardes. L’instance atteint ce backend avec son identité managée, qui requiert le rôle Cognitive Services User sur le service ; le build ne voit ni l’un ni l’autre. Aucun gateway de la bibliothèque standard autre que ces trois ne la réalise, et l’attacher à un autre arrête le build en nommant le type : la plupart ne produisent aucune route qu’une réalisation pourrait faire passer par une garde — ils conservent leurs routes dans un stockage qui leur est propre, les tirent des services situés derrière eux, ou sont un service hébergé sur lequel la bibliothèque standard n’active aucune vérification de ce type —, etcore/gateway/apisix, dont la Recipe de chart produit les routes des modèles qui lui sont raccordés, etcore/gateway/envoy-gateway, dont la Recipe produit la route IA des modèles qui lui sont raccordés, n’en ont aucune réalisation. Surcore/gateway/agentgateway, dont les Recipes produisent une entrée pour chaque modèle qui lui est raccordé, la réalisation arrête chaque attachement en indiquant pourquoi : agentgateway ne juge une requête à la recherche d’une telle tentative qu’au moyen d’un service qu’il appelle — un webhook que l’opérateur exploite, ou Azure AI Content Safety, Google Model Armor ou AWS Bedrock Guardrails —, et la réalisation n’en raccorde aucun. Surcore/gateway/higress, la réalisation arrête aussi chaque attachement en indiquant pourquoi : Higress ne juge une telle tentative qu’au moyen d’un service qu’il appelle — le service de sécurité des contenus d’Alibaba Cloud ou, via un plugin que contient son code source mais que sa version de plugins 2.2.5 ne publie pas, un service de modèle Qwen3Guard que l’opérateur exploite —, chacun laissant passer la requête lorsque cet appel échoue, et la réalisation ne raccorde ni l’un ni l’autre. Surcore/gateway/traefik-hub, la réalisation arrête de même chaque attachement en indiquant pourquoi : Traefik Hub ne juge une telle tentative qu’au moyen d’un service qu’il appelle — ses middlewares LLM Guard et Parallel LLM Guard, qui appellent un service de garde ou un modèle avec une requête et des conditions que la réalisation devrait écrire, et dont le fonctionnement avec un détecteur d’attaques de prompt n’est pas mesuré, si bien qu’aucune sensibilité n’y correspond à une vérification ; ou ses middlewares Azure Prompt Shield, Amazon Bedrock Guardrails et GCP Model Armor, qui appellent des services hébergés que la réalisation ne raccorde pas. La garde ne lit que le dernier message utilisateur, de sorte qu’un message système, un tour précédent ou un résultat d’outil atteint le modèle sans être lu, et seul le trafic qui traverse le gateway est filtré : une charge de travail qui appelle directement l’adresse du modèle le contourne. -
Validation des réponses et évaluations :
core/response-validationdéclare une vérification de la réponse d’un modèle par rapport à un JSON Schema avant qu’elle n’atteigne l’appelant :schemaporte le schéma lui-même, et une réponse qui ne s’y conforme pas est refusée au lieu d’être transmise — ou, avecinvertactivé, une réponse qui s’y conforme. Le schéma appartient à l’attachement et est le même pour chaque requête ; ce n’est pas un schéma que l’appelant envoie avec sa propre requête, donc le développeur l’attache dans l’Aggregate, en écrivant le schéma dans sesvalues. Aucune réalisation de la bibliothèque standard ne l’applique : surcore/gateway/agentgateway, sa réalisation arrête chaque attachement en indiquant pourquoi — les gardes de réponse d’agentgateway comparent des motifs ou appellent un service de content safety ou un webhook, et aucune d’elles n’accepte de schéma —, de même que sa réalisation surcore/gateway/higress, dont la vérification des réponses répond à une réponse qui la passe avec le JSON brut qu’elle trouve dans le message de la réponse au lieu de la complétion de chat que renvoie sa route OpenAI, est ignorée par tout client envoyant l’en-tête de requêteX-HIGRESS-AI-JSON-RESP: true, et laisse non vérifié un schéma imbriqué sur plus de six niveaux ; et de même sa réalisation surcore/gateway/traefik-hub, puisqu’aucun middleware de la référence de Traefik Hub ne vérifie une réponse par rapport à un schéma — son middleware Chat Completion vérifie les requêtes par rapport au schéma de complétion de chat, sa gestion d’API vérifie les corps de requête par rapport à un document OpenAPI, et son LLM Guard envoie une réponse à un service extérieur, que la réalisation ne raccorde pas ; sur tout autre gateway, un attachement arrête le build en nommant le type.core/traffic-shadowingcopie les requêtes réelles vers un second service et rejette les réponses de ce service, de sorte qu’un modèle ou un service candidat peut être évalué sous trafic réel sans qu’aucun appelant ne voie sa sortie. Elle s’attache à tout composant déclarantdataplane.aggrega.ai/request-mirroring, ce que le gateway IA ne fait pas ; la bibliothèque standard la réalise sur le gateway NGINX, qui copie l’intégralité du flux plutôt qu’une part de celui-ci, et s’arrête nommément sur une part plus petite.
5. Exécution asynchrone et infrastructure HITL
Aggrega traite les frameworks à interaction humaine (comme AutoGen et LangGraph) comme des nœuds workers. Pour prendre en charge des agents « endormis » qui attendent une entrée humaine sans perdre leur état, les architectes de plateforme peuvent déclarer des sockets usesSchema sur les Components de ces agents qui imposent strictement la liaison explicite de composants de catégorie datastore à ceux-ci, sélectionnés par le label de moteur du datastore — datastore.aggrega.ai/engine in (vector, semantic-memory, search) pour un stockage dans lequel l’agent récupère par similarité, ou datastore.aggrega.ai/engine=kv pour un stockage dans lequel il enregistre des points de contrôle de son état d’exécution. Le socket se lie au label de moteur plutôt qu’à un nom de produit, de sorte qu’un auteur choisit quel stockage arrive et que la déclaration reste valable. En outre, pour les boucles de rétroaction de l’humain vers l’agent (p. ex. les intégrations Slack), il est possible de configurer un rôle de verdict de gouvernance qui rejette l’architecture à moins qu’un composant gateway explicitement déclaré ne soit attaché, de sorte que les webhooks de rappel entrent par une frontière d’entrée déclarée.
Les agents construits sur un framework ou un SDK autour duquel une application est écrite, plutôt que livrés comme un produit à part entière, prennent une seule forme dans la bibliothèque standard. La Release nomme l’image de l’application, que le catalogue ne fixe pas. Un socket model transmet ce que le framework lit du modèle raccordé — son adresse et son nom de modèle là où le framework les lit, et l’identifiant de la connexion, par référence — aux variables que ce framework lit. Là où le framework ne définit pas de serveur propre, le composant est un worker et n’ouvre aucun port : core/ai-agent/crewai et core/ai-agent/langgraph prennent cette forme, de même que core/ai-agent/openai-agents-sdk, dont le socket model n’accepte qu’un modèle ou un gateway portant model.aggrega.ai/api: openai, core/ai-agent/claude-agent-sdk, dont le socket n’accepte qu’un élément portant model.aggrega.ai/api: anthropic, et core/ai-agent/agent-framework, pour une application construite sur Microsoft Agent Framework, qui ne sert rien lui-même, dont le socket n’accepte qu’un élément portant model.aggrega.ai/api: openai et fournit les variables que lisent les clients OpenAI Python d’Agent Framework ; ces trois-là arrêtent le build, en nommant infra.image, jusqu’à ce que la Release le définisse. L’OpenAI Agents SDK téléverse par défaut une trace de chaque exécution vers OpenAI, donc core/ai-agent/openai-agents-sdk désactive ce téléversement à moins que l’Aggregate ne définisse sa valeur upload_traces_to_openai à true. Là où le framework sert lui-même du HTTP, le composant est un server sur le port propre du framework et publie l’adresse qu’atteint un appelant sous la forme host, port, endpoint et protocol, et il arrête lui aussi le build, en nommant infra.image, jusqu’à ce que la Release le définisse : core/ai-agent/google-adk sert l’API REST d’ADK sur le port 8000 et fournit la clé que le client Gemini d’ADK envoie à l’API Gemini, son socket model n’acceptant qu’un modèle portant model.aggrega.ai/api: gemini, tel que core/ai-model/gemini, et jamais un gateway, dont le client d’ADK ne lirait pas l’adresse ; core/ai-agent/mastra sert le serveur que Mastra construit sur le port 4111, prêt sur Kubernetes dès que sa route /health répond, accepte un modèle ou un gateway portant model.aggrega.ai/api: openai et, là où l’Aggregate nomme l’un des agents de l’application dans sa valeur agent_id, publie l’adresse de la carte Agent2Agent de cet agent, afin que core/ai-tool/agent-invocation puisse lui déléguer. Les routes des deux serveurs répondent à tout appelant à moins que l’application ne les authentifie, donc un attachement core/public-ingress ou core/http-route sur l’un ou l’autre arrête le build jusqu’à ce que la Release définisse son infra.routes_authenticated à true, affirmant que l’application authentifie chaque requête que reçoivent ses routes. Les runtimes SDK et serveur et core/ai-agent/agent-framework déclarent aussi un socket tools facultatif, qui fournit l’adresse de chaque outil raccordé, et l’identifiant de la connexion par référence, sous des variables nommées d’après l’alias de la connexion. Comme l’application est le code propre de la Release, les variables que ces agents fournissent pour que ce code les lise sont des valeurs par défaut : chacun de leurs sockets admet un bloc inject:, par lequel l’Aggregate nomme les variables, ou les fichiers, que l’application lit à la place, tandis qu’une variable que le framework lit de lui-même et ce que fournit un attachement sur la connexion demeurent. Il en va de même pour les valeurs propres de l’agent : chaque composant admet sur lui-même un bloc inject: d’entrées env et file, et une entrée dont le template lit l’une de ses valeurs propres et rien d’autre du composant — ni une autre valeur, ni son infra, ses métadonnées ou son identité — remplace le nom par défaut sous lequel une Recipe fournit cette valeur, comme CREWAI_ROLE pour le role d’un agent CrewAI. Une importation des déclarations d’agents d’un projet CrewAI, du langgraph.json d’une application LangGraph, des configurations d’agents d’une application Google ADK ou d’un agent déclaratif d’Agent Framework produit un brouillon de ces agents — core/ai-agent/crewai, core/ai-agent/langgraph, core/ai-agent/google-adk et core/ai-agent/agent-framework — raccordés au datastore que nomme la configuration, et au modèle qu’elle nomme là où le socket model de l’agent l’accepte, à côté d’un brouillon de Release qui laisse à l’opérateur le soin de nommer l’image dans laquelle s’exécute le programme, et ne lit que la configuration, jamais le programme, comme le décrit Plugins d’importation.
6. Validation topologique de la sécurité et application à l’exécution
Comme les charges de travail d’IA introduisent de nouveaux vecteurs d’attaque (comme l’injection de prompt et l’exfiltration autonome de données), les sécuriser exige de relier la gouvernance architecturale statique à une application active à l’exécution. En tant que compilateur anticipé (Ahead-of-Time, AOT), Aggrega n’intercepte pas le trafic réseau en direct et n’évalue pas les prompts d’IA. Il répond plutôt à des exigences de sécurité complexes par une poignée de main architecturale en deux parties : la compilation statique de l’architecture (à la compilation) et la passation à l’exécution (au déploiement).
A. À la compilation : validation des policies et génération des artefacts
Le compilateur construit un graphe plat de représentation intermédiaire (IR) contenant tous les nœuds, toutes les arêtes et toutes les Features attachées. Avant que la moindre infrastructure physique ne soit générée, la posture de sécurité de l’entreprise est appliquée en évaluant ce graphe JSON statique avec des moteurs de policy standard du secteur, dans un rôle de verdict de gouvernance.
Comme le socket évalue des données JSON génériques, il n’est pas lié à un langage de policy unique. Les entreprises peuvent compiler et appliquer leurs règles architecturales avec le standard qui convient le mieux à leur écosystème :
- Open Policy Agent (OPA/Rego) : un langage largement utilisé pour évaluer des relations de graphe complexes à plusieurs sauts et calculer l’accès au moindre privilège à travers des topologies distribuées. Le moteur Rego compilé dans la CLI exécute les fichiers
.regotels quels ; une policy qui a besoin de toute la surface de builtins d’OPA est compilée avec la propre chaîne d’outils d’OPA et s’exécute derrière un guest adaptateur. - Common Expression Language (CEL) : le moteur CEL compilé dans la CLI exécute des règles écrites comme des expressions uniques portant sur un document, à la manière dont s’écrit une validating admission policy de Kubernetes.
- Kyverno : évalue des manifestes JSON/YAML statiques, ce qui permet aux équipes d’écrire des policies en YAML natif plutôt que d’apprendre Rego. Aucun guest Kyverno n’est livré avec le compilateur, qui n’exécute les policies que comme des guests WebAssembly et n’invoque jamais la CLI Kyverno, de sorte que les règles Kyverno s’exécutent derrière un guest qui encapsule le moteur.
- Validation personnalisée en Rust/TypeScript : les équipes de sécurité peuvent écrire des policies organisationnelles sur mesure dans des langages standard et les compiler en Wasm pour qu’elles servent de point de contrôle de validation.
Une fois que le moteur de policy a validé le graphe, le compilateur traduit ces exigences de sécurité abstraites en configuration physique. Lorsqu’un développeur attache une Feature de sécurité — core/data-masking sur le gateway IA, par exemple —, le compilateur exécute l’étape de pipeline que nomme sa réalisation, un plugin WebAssembly (Wasm) isolé, et cette étape écrit le paramètre dont le contrôle a besoin dans la configuration que produit déjà la Recipe propre au gateway. Une réalisation peut au contraire laisser l’écriture à la Recipe propre au gateway, qui lit l’attachement et écrit elle-même le paramètre, comme le fait core/data-masking sur core/gateway/kong-enterprise, et une réalisation pour un autre type de contrôle peut émettre une ressource qui lui est propre ; dans tous les cas, la sortie est un artefact statique écrit à partir de ce que le développeur a attaché.
B. Au déploiement et à l’exécution : passation à l’exécution et application
La responsabilité d’Aggrega prend fin au moment exact où il termine de traiter l’entrée et écrit les artefacts statiques configurés dans le répertoire de sortie. C’est un compilateur pur : il écrit la configuration, puis le contrôle revient entièrement au système qui l’a invoqué.
La manière dont ces configurations sont exécutées est très flexible et dépend entièrement de l’entreprise :
- La passation des artefacts (au déploiement) : des contrôleurs de déploiement externes prennent le relais pour concrétiser les artefacts. Il pourrait s’agir d’un contrôleur GitOps strict (comme ArgoCD ou Flux) synchronisant des fichiers dans un cluster Kubernetes, mais tout aussi bien d’un pipeline CI/CD standard exécutant
terraform apply, ou d’un développeur exécutant un script shell local avec Docker Compose. - Application à l’exécution : une fois les configurations appliquées à l’environnement cible, l’infrastructure physique prend le relais. Les outils spécialisés configurés par Aggrega (comme un sidecar de garde-fous, un service mesh actif ou des pare-feu cloud natifs) démarrent et commencent leur travail actif : intercepter physiquement les charges utiles, vérifier les JWT ou écarter les injections de prompt malveillantes.
7. Comment Aggrega répond aux défis de sécurité de l’IA
En découplant la validation architecturale de l’exécution, les équipes de plateforme peuvent utiliser Aggrega pour modéliser, valider et générer explicitement des solutions de configuration face aux vulnérabilités d’IA décrites ci-dessous.
A. Exfiltration de données et interception des charges utiles
- Le problème : un agent autonome pourrait tenter de divulguer des données d’entreprise restreintes vers une API externe non autorisée.
- La solution d’Aggrega :
- À la compilation (validation et génération) : l’équipe de plateforme écrit une policy (p. ex. Rego) évaluée dans un rôle de verdict de gouvernance qui énonce : « Tout chemin qui passe par un gateway IA doit porter
core/data-masking. » S’il manque, le compilateur s’arrête. S’il est présent, la réalisation que lie le Manifest écrit le masquage dans la configuration que le gateway produit déjà : surcore/gateway/litellm, des entrées de garde-fous qui correspondent aux expressions régulières que liste l’attachement et qui envoient le texte, pour les types d’entités qu’il liste, à un analyzer et à un anonymizer Presidio raccordés aux socketspii_analyzeretpii_anonymizerdu gateway ; surcore/gateway/kong-enterprise, l’AI PII Sanitizer de Kong sur les routes de chat et de complétion de chaque modèle raccordé, écrit par la Recipe de chart du gateway, qui envoie le texte qu’il masque, avec les expressions régulières et les types d’entités que liste l’attachement, au service Kong AI PII raccordé au socketpii_sanitizerdu gateway ; surcore/gateway/agentgateway, les gardes par expressions régulières propres au gateway, écrites dans sa configuration par sa Recipe de chart, qui remplacent chaque correspondance des motifs listés par l’attachement par<masked>, ou, sousrefuse, répondent à la requête ou à la réponse par HTTP 403, et ne reconnaissent aucun type d’entité ; ces gardes ne masquent pas une réponse en streaming, donc tant que les réponses sont masquées, la même Recipe écrit une règle qui refuse par HTTP 403, avant sa transmission, une requête qui en demande une, ainsi que toute requête dont le corps dépasse les 2 MiB que le gateway lit pour cette règle, en streaming ou non ; surcore/gateway/traefik-hub, un Content Guard du gateway IA de Traefik Hub sur la route de chaque modèle raccordé, écrit par sa Recipe de chart, qui masque les correspondances des motifs listés par l’attachement au moyen de son moteur d’expressions régulières, ou celles des types d’entités qu’il liste au moyen de l’analyzer Presidio raccordé au socketpii_analyzerdu gateway, un moteur par attachement ; surcore/gateway/higress, le pluginai-data-maskingde Higress sur la route de chaque modèle raccordé, écrit par sa Recipe de chart, qui remplace chaque correspondance des motifs listés par l’attachement dans les messages d’une requête de chat par le nom du motif entre crochets, et ne reconnaît aucun type d’entité. Une policy peut aussi poser la question plus étroite — le masquage se trouve-t-il entre les données restreintes et le fournisseur ? — en lisant les attachements de chaque composant le long de la route plutôt que les attachements de la route dans son ensemble, comme le fait examples/policy-data-class-route. - Exécution (application physique) : Une fois que l’orchestrateur a déployé les artefacts générés, la passerelle remplace chaque correspondance dans le texte de requête qu’elle masque par un espace réservé avant de la transférer, de sorte que le fournisseur du modèle reçoit l’espace réservé ; avec
action: refuse, le rattachement ne transfère rien d’une requête contenant une correspondance et y répond à la place par une erreur. Un détecteur injoignable ou en erreur fait échouer la requête, de sorte que son texte n’est pas transmis. Ce que le masquage n’atteint pas est déterminé par deux valeurs dont les valeurs par défaut constituent la protection. Sur la passerelle IA, lorsque le rattachement masque aussi les réponses, la passerelle masque le texte de la réponse et les parties qu’un modèle ou son fournisseur ajoute à côté — un refus, des citations et annotations, la requête et les résultats d’une recherche web, des champs portant des noms propres au fournisseur — ou, avecrefuse, n’envoie rien d’une réponse contenant une correspondance ; une réponse en streaming qu’elle masque par motif parvient à l’appelant entière, à la fin. Par défaut, ce que son masquage n’atteint pas dans une requête — une route telle que la génération d’images, un champ tel quesafety_identifier, une image ou un fichier dans la conversation, un outil que le fournisseur exécute lui-même — la passerelle IA le refuse avec HTTP 400 avant d’en transférer quoi que ce soit ; un opérateur qui accepte que ce texte parvienne au fournisseur non masqué définitallow_unmasked_textsur le rattachement dans la Release, la réalisation listant exactement ce qui passe alors, et le contenu qui n’est pas du texte reste régi parallow_non_text_content. Par défaut, ce qu’une réponse masquée contient et que son masquage ne peut pas lire — de l’audio parlé et sa transcription, une image, les probabilités des tokens choisis par le modèle — est retenu, et un appel ayant échoué parvient à l’appelant avec un message fixe à la place de celui renvoyé par le fournisseur ;allow_unmasked_reply_partslaisse ces parties parvenir à l’appelant non masquées. Le texte propre d’une réponse n’est jamais laissé passer par cette valeur, mais les parties qu’elle laisse passer peuvent contenir les mots de la réponse : la transcription d’une réponse parlée, les tokens derrière les probabilités des tokens, le message d’erreur d’un fournisseur citant la réponse. Surcore/gateway/kong-enterprise, chaque correspondance est remplacée par un espace réservé numéroté, de sorte qu’un rattachement listant des motifs sousredactdéfinitplaceholder_shows_name: false;refusen’atteint que les requêtes, à partir de Kong 3.12, qui répond à une requête contenant une correspondance par HTTP 400 ; et les réponses sont masquées à partir de 3.12, une requête demandant une réponse en streaming étant alors refusée avant d’être transférée, etallow_streamed_repliesrefusé. Le sanitizer de Kong lit le texte des tours de l’utilisateur, le prompt d’une completion et le texte du message d’une réponse, et la référence de Kong ne nomme aucun paramètre qui refuse une requête pour ce que le sanitizer ne lit pas ou qui retient le reste d’une réponse, de sorte que sur cette passerelle chaque protection est refusée nommément au moment du build tant qu’elle garde sa valeur par défaut, et qu’un rattachement se construit une fois que la Release les assouplit —allow_unmasked_textetallow_non_text_contentlà où les requêtes sont masquées,allow_unmasked_reply_partsetmask_reasoning: falselà où les réponses le sont —,data-masking-kong-enterpriselistant ce que chacune laisse alors passer. Là, une réponse dont le texte n’arrive pas sous la forme de la chaîne unique que renvoie l’API OpenAI passe sans être lue, son propre texte parvenant à l’appelant non masqué ; la protection contre cela est la vérification que le build effectue sur chaque modèle relié à cette passerelle, qui s’arrête sur un modèle dont lemodel.aggrega.ai/apin’est pasopenai. Surcore/gateway/traefik-hub, chaque correspondance est remplacée par une suite de*aussi longue que la correspondance, de sorte qu’un rattachement listant des motifs sousredactdéfinitplaceholder_shows_name: false;refuserépond HTTP 403 à la place de la requête ou de la réponse ; et une réponse masquée est retenue entière et envoyée à la fin, y compris en streaming, de sorte qu’un rattachement masquant des types d’entités dans les réponses définitallow_streamed_replies. La référence de Traefik ne dit pas quels champs d’une requête ou d’une réponse de chat Content Guard lit, et ne nomme aucun paramètre qui refuse une requête, ou retient une partie d’une réponse, pour ce qu’il ne lit pas, de sorte que sur cette passerelle chaque protection est refusée nommément au moment du build tant qu’elle garde sa valeur par défaut, et qu’un rattachement se construit une fois que la Release les assouplit —allow_unmasked_textetallow_non_text_contentlà où les requêtes sont masquées,allow_unmasked_reply_partsetmask_reasoning: falselà où les réponses le sont —,data-masking-traefik-hublistant ce que chacune laisse alors passer. Un rattachement listant à la fois des motifs et des types d’entités, et un second rattachement de masquage sur une même passerelle, sont refusés, car la référence de Traefik ne dit pas si un second Content Guard sur une route lit le texte masqué par le premier ou la requête telle que l’appelant l’a envoyée. Surcore/gateway/higress, le pluginai-data-maskingde Higress remplace chaque correspondance des motifs listés par le rattachement, dans le contenu et le raisonnement de chaque message d’une requête de chat, par le nom du motif entre crochets ; il ne masque que les requêtes, doncscoperesponseetbothsont refusés, et il ne reconnaît aucun type d’entité. Le plugin ne lit rien d’autre d’une requête, donc, tant que les protections gardent leurs valeurs par défaut, la Recipe de chart de la passerelle écrit aussi le plugin de validation des requêtes de Higress pour refuser avec HTTP 403, avant que quoi que ce soit ne soit transféré, une requête contenant ce que le masquage ne lit pas — un corps non envoyé en JSON ou qui n’est pas une chat completion, un message dont le contenu est une liste ou null, un appel d’outil ou un tour d’outil, le nom d’un message, tout paramètre autre que les paramètres non textuels d’une chat completion et les outils, le format de réponse et les séquences d’arrêt propres au développeur — et, quoi que le rattachement assouplisse, une requête dont les plugins de Higress ignorent le corps — un corps compressé, un content type contenantoctet-streamougrpc, un upgrade — ainsi qu’un corps contenant le caractère de remplacement Unicode U+FFFD, qui est la façon dont cette validation lit un octet qui n’est pas de l’UTF-8 valide, puisque le plugin de masquage transfère non masqué un corps qui n’est pas de l’UTF-8 valide. Une requête dont le corps dépasse le tampon de 32 KiB de la passerelle est refusée avec HTTP 413. La validation ne lit qu’un corps que son décodeur JSON accepte, de sorte qu’un client qui envoie délibérément du JSON valide que le décodeur refuse — un nombre au-delà de ce que peut contenir un double, par exemple — franchit chaque refus portant sur son corps : le plugin de masquage ne masque alors que le contenu simple et le raisonnement de chaque message, de sorte qu’une valeur listée n’importe où ailleurs dans le corps — les arguments d’un appel d’outil, un nom, tout autre champ — est transférée non masquée, tout comme le contenu écrit avec des séquences d’échappement JSON, et si un tel corps n’est pas non plus de l’UTF-8 valide, il est transféré entièrement non masqué. Un client qui imbrique délibérément un corps sur plus de 127 niveaux de profondeur, à l’intérieur d’un champ que la validation admet, tel quetools, envoie du JSON valide que la validation décode et admet, mais le lecteur JSON du plugin de masquage s’arrête à cette profondeur, de sorte que le contenu écrit avec des séquences d’échappement JSON dans ce corps est lui aussi transféré non masqué. Le masquage ne suffit pas à lui seul : le texte qu’aucun motif ne reconnaît et qu’aucun détecteur ne détecte passe inchangé ; sur la passerelle IA, les arguments des appels d’outils et les résultats des outils sont masqués valeur par valeur, mais pas les noms de leurs clés ; les définitions d’outils, les formats de réponse et les séquences d’arrêt propres au développeur passent tels qu’envoyés ; la passerelle et les services de détection voient le texte original ; ce que la passerelle enregistre d’un appel — dans son propre journal, ou dans ce qu’elle transmet à une intégration de journalisation — peut encore contenir ce texte ; et le trafic qui ne traverse pas la passerelle n’est pas touché.
- À la compilation (validation et génération) : l’équipe de plateforme écrit une policy (p. ex. Rego) évaluée dans un rôle de verdict de gouvernance qui énonce : « Tout chemin qui passe par un gateway IA doit porter
B. Se défendre contre l’empoisonnement MCP (confiance et isolation)
- Le problème : Si un agent est compromis via un outil Model Context Protocol (MCP) empoisonné, il peut exécuter de manière autonome des actions destructrices (comme supprimer une base de données ou autoriser un virement).
- La solution d’Aggrega :
- Compilation (validation et génération) : Le développeur rattache une Feature d’approbation à l’outil sensible dans son
Aggregate.yaml. La bibliothèque standard ne fournit aucune Feature de ce type, celle-ci est donc rédigée dans le catalogue propre de l’entreprise, avec la FeatureRecipe qui la rend. Le compilateur valide le graphe et traduit le rattachement en configuration pour un proxy L7 ou une passerelle webhook. - Exécution (application physique) : Lorsque l’agent détourné tente d’invoquer l’outil, le proxy déployé met la requête en pause et bloque physiquement l’exécution jusqu’à ce qu’une approbation signée cryptographiquement soit reçue d’un opérateur humain.
- Compilation (validation et génération) : Le développeur rattache une Feature d’approbation à l’outil sensible dans son
C. Résoudre le « Confused Deputy » (propagation du contexte)
- Le problème : Dans les chaînes multi-agents, un agent exposé au public pourrait être détourné et ordonner à un agent interne hautement privilégié de récupérer des données sensibles. Les pare-feu standard voient seulement que « l’agent A parle à l’agent B » et autorisent le trafic, perdant complètement le contexte de l’utilisateur malveillant d’origine.
- La solution Aggrega : Les entreprises peuvent combiner deux patterns spécifiques :
- Propagation de l’identité de l’appelant, sur deux sauts : L’identité de l’appelant d’origine doit survivre à deux sauts différents, et chacun est protégé à un endroit différent. Au saut de la passerelle, le développeur rattache
core/context-propagation, qui sélectionne surdataplane.aggrega.ai/caller-identity, à la passerelle par laquelle une requête entre. À la compilation, le rattachement est réalisé dans la configuration propre de cette passerelle — sur Envoy Gateway, une client traffic policy qui vérifie le certificat de chaque client auprès d’une autorité que nomme la Release et transfère les détails du certificat ; sur la passerelle IA LiteLLM, un hook de requête qui supprime tout en-tête d’identité fourni par un appelant et ajoute l’utilisateur et l’équipe de la clé virtuelle vérifiée par la passerelle, ainsi que son organisation lorsque la clé en nomme une, sur les requêtes vers les alias de modèles que le rattachement liste dansdestinations. À l’exécution, le service derrière la passerelle reçoit qui a appelé plutôt que seulement le fait que la passerelle a appelé. Au saut entre charges de travail, une requête qu’un agent adresse directement à un autre ne traverse jamais cette passerelle, elle est donc vérifiée à l’entrée propre de l’agent destinataire, où un service mesh rejette toute requête dépourvue d’un jeton signé prouvant l’intention de l’utilisateur d’origine (par exemple uneAuthorizationPolicyJWT d’Istio). La bibliothèque standard fournit la Feature du saut de passerelle et aucune Feature du saut entre charges de travail, de sorte que rattachercore/context-propagationprotège le trafic qui passe par une passerelle et laisse les appels d’agent à agent à la configuration du mesh que l’entreprise fournit elle-même. Un agent qu’exploite une autre partie, quecore/ai-tool/agent-invocationatteint via A2A en tant quecore/ai-agent/a2a-remote, se trouve entièrement hors de la Release : cette partie vérifie chaque appel selon le schéma de sécurité que déclare l’Agent Card de l’agent, et l’outil présente l’identifiant détenu sur sa connexion, lu par référence depuis un Secret, sous l’en-tête de requête que l’agent publie. Lorsque la card exige les client credentials OAuth 2.0 ou OpenID Connect, la connexion détient un client secret à la place, ou en plus, avec le client id que l’opérateur y inscrit, et l’agent publie l’adresse du token ou de découverte et les scopes que sa card déclare ; le conteneur propre de l’outil obtient le token avec eux, le renouvelle et le présente à chaque appel ; le catalogue ne fournit que ces entrées, et aucun build ne peut vérifier ce que le conteneur en fait. Lorsque la card exige le TLS mutuel, la connexion détient un certificat client et, lorsqu’une autorité à laquelle l’image ne fait pas déjà confiance signe le certificat serveur de l’agent, cette autorité aussi ; chacun est monté dans le conteneur de l’outil sous forme de fichiers depuis un Secret que nomme la connexion, et le conteneur présente lui-même le certificat lors de la négociation TLS. L’outil atteint donc un agent dont la card déclare une clé d’API dans un en-tête ou un cookie, un schéma d’authentification HTTP à valeur fixe, comme Bearer ou Basic, le Secret contenant la valeur entière de l’en-tête, OAuth 2.0 ou OpenID Connect avec le grant client-credentials, ou le TLS mutuel. Il n’atteint pas un agent dont la card exige une clé dans la query string, un schéma HTTP répondant à un défi de l’agent, comme Digest, ou un flux OAuth 2.0 autre que client credentials. Il ne présente pas non plus d’identifiant à un agent qu’une autre partie exploite en HTTP simple : lorsque l’adresse de cet agent esthttp, un identifiant ou un client secret sur la connexion arrête le build, en nommant la connexion, car l’identifiant, ou le token obtenu avec le secret, lui parviendrait non chiffré. Un agent qui s’exécute à l’intérieur de la Release reste joignable enhttpavec l’un ou l’autre, et l’identifiant traverse alors le réseau du cluster non chiffré. - Inspection du payload entre agents : Une requête qu’un agent envoie directement à un autre ne traverse jamais la passerelle IA, elle est donc inspectée à l’entrée propre de l’agent destinataire, par un moteur de garde-fous s’exécutant à côté de cet agent (par exemple NeMo Guardrails). À la compilation, la FeatureRecipe qui réalise une Feature rattachée à l’agent destinataire rend la configuration du moteur. À l’exécution, le moteur évalue chaque requête selon des règles que l’entreprise écrit et refuse celle que ces règles rejettent ; sa capacité à distinguer une requête détournée d’une requête légitime relève du moteur et des règles, car Aggrega compile de la configuration et n’évalue jamais un prompt. La bibliothèque standard ne fournit aucune Feature qui place un tel moteur, ce pattern est donc rédigé dans le catalogue propre de l’entreprise. La garde par motifs propre à une passerelle,
dataplane.aggrega.ai/prompt-guard: pattern-list, est plus étroite, etcore/prompt-deny-patternsl’active — sur la passerelle IA, chaque message d’une requête étant lu et la casse ignorée, surcore/gateway/apisixetcore/gateway/kong, chaque message de chaque rôle étant lu comme un seul texte, la casse comptant et une liste de motifs auxquels une requête doit aussi correspondre étant respectée, surcore/gateway/agentgateway, chaque message, argument d’appel d’outil et résultat d’outil étant lu séparément, la casse comptant, et surcore/gateway/traefik-hub, la requête étant lue comme une chat completion, dont la référence de Traefik ne liste pas les champs lus, la casse comptant : elle refuse une requête au modèle dont le texte correspond littéralement à l’une des expressions que liste le rattachement — une paraphrase, une autre langue ou un encodage la franchissent — et seulement sur le trafic passant par la passerelle, de sorte qu’une requête envoyée directement entre agents ne la rencontre jamais.core/prompt-injection-shielden est le pendant fondé sur un classifieur sur le même saut, envoyant chaque requête au modèle qu’une passerelle transfère à travers une garde NeMo Guardrails reliée au socketguardde cette passerelle, ou à travers le prompt shield d’Azure AI Content Safety sur Azure API Management, et il ne couvre lui aussi que le trafic qui traverse la passerelle.
- Propagation de l’identité de l’appelant, sur deux sauts : L’identité de l’appelant d’origine doit survivre à deux sauts différents, et chacun est protégé à un endroit différent. Au saut de la passerelle, le développeur rattache
D. Analyse topologique des risques
- Le problème : Les architectures d’IA complexes comportant des dizaines de modèles, de vecteurs et d’outils interconnectés sont trop vastes pour qu’un humain puisse les auditer manuellement à la recherche de vulnérabilités transitives (par exemple « L’agent A peut-il parler à l’outil B, qui parle à l’agent C, qui a accès à la base de données D ? »).
- La solution Aggrega : Cette vérification s’exécute à l’avance. Comme Aggrega construit en mémoire un graphe IR complet de la topologie prévue, un rôle de verdict de gouvernance peut exécuter des règles avancées de recherche de chemins sur l’ensemble de l’architecture. Si la politique détecte une chaîne continue et transitive d’arêtes partant d’un nœud public et aboutissant à une base de données hautement sensible sans qu’aucun des contrôles exigés par l’entreprise ne soit rattaché nulle part le long de celle-ci, elle arrête immédiatement le build. L’architecture non sécurisée est bloquée avant qu’une seule ligne de code d’infrastructure ne soit jamais générée.
8. Observabilité et conformité
Pour satisfaire à des exigences réglementaires strictes (par exemple, l’AI Act de l’UE), les architectes de plateforme peuvent utiliser le système de fonctionnalités d’Aggrega pour imposer l’observabilité de l’IA comme une exigence structurelle de l’infrastructure plutôt que de s’appuyer sur le code applicatif :
- Journalisation d’audit : des plugins Wasm écrits par l’entreprise peuvent configurer les sidecars de passerelle pour diffuser de manière asynchrone les prompts et les réponses bruts, non expurgés, vers un bucket de stockage WORM (Write Once, Read Many) sécurisé, en contournant les journaux applicatifs standard.
- Traçage des LLM : des fonctionnalités de proxy peuvent configurer le plan de données pour extraire et transmettre les en-têtes de span OpenTelemetry propres à l’IA, ce qui garantit que les boucles de raisonnement complexes des agents peuvent être visualisées dans des outils externes.
9. Compatibilité de Feature et sûreté topologique
Comme le compilateur central est agnostique vis-à-vis des mécanismes de l’infrastructure physique, il s’appuie entièrement sur des déclarations explicites dans le catalogue pour empêcher la génération de configurations incompatibles.
conflictsWith: une liste, déclarée sur l’entité de catalogue d’une Feature sousinteroperability, des Features à côté desquelles elle ne peut pas être attachée. Le compilateur la compare aux Features que porte chaque composant une fois que chaque portée a contribué — les attachements propres du composant, ceux écrits sur un sous-système ou une frontière qui le contient, ceux de l’entrée du composant dans sa Release et ceux qu’a produits l’expansion pilotée par annotations — et s’arrête avant de produire le moindre artefact physique lorsqu’un composant porte les deux (c’est-à-dire lorsqu’un auteur attache, directement ou par une portée, deux Features que l’auteur de l’une d’elles a explicitement déclarées incompatibles). Une seule déclaration suffit, et les Features sont mises en correspondance par nom, quelles que soient leurs versions. Le compilateur n’interprète pas les noms : l’incompatibilité est la déclaration de l’auteur, et la vérification est une comparaison de noms. L’atomicité et la pureté des Features restent elles-mêmes un contrat social — rien ne vérifie qu’une Feature ne fait qu’une seule chose.
10. Cartographie dynamique de la topologie (résolution des dépendances)
Pour construire le graphe IR sans règles codées en dur, le compilateur le lit à partir de trois déclarations explicites :
- Arêtes
uses: les développeurs relient les composants dans le blocusesde chaque instance, en nommant le composant cible dans un socket, et chaque arête du graphe provient d’un tel bloc. Une entrée devaluesqui se trouve nommer un autre composant ne trace aucune arête : le compilateur n’attribue aucun sens à une valeur. - Cibles des arêtes : chaque cible de
usesdoit nommer un composant que contient le build ; une cible qui n’existe pas arrête le build, en nommant le socket auquel elle était raccordée. - Sûreté de typage entre nœuds : les chaînes de sélecteur
usesSchemaagissent comme des instructions explicites hors bande, évaluées nativement par le moteur de correspondance de labels du compilateur Go pendant l’analyse statique. Elles garantissent que les développeurs ne peuvent pas brancher par inadvertance des composants standard sur un socket déclaré qui exige une capacité native IA ou un label de conformité spécifique. La garantie est limitée par construction aux sockets déclarés : un sélecteur se trouve dans une entréeusesSchema, si bien qu’un socket ad hoc n’en a aucun à évaluer. Chaque arête enregistre si son socket a été déclaré dans le catalogue, de sorte qu’un opérateur qui a besoin que la garantie soit totale peut l’exiger sous forme de verdict de gouvernance.
11. Conception automatisée de systèmes agentiques (ADAS)
Les systèmes d’IA avancés comportent des méta-agents qui écrivent du code pour inventer et déployer de nouveaux agents à la volée. Comme Aggrega exige une architecture statique compilée à l’avance (AOT), il traite l’évolution de l’infrastructure à l’exécution au moyen de deux frontières explicites :
- La frontière du bac à sable préprovisionné : pour les outils éphémères inventés à l’exécution, l’architecte définit une fonctionnalité (par exemple,
dynamic-execution-environment). Une fois celle-ci attachée, le plugin de rendu Wasm génère la configuration qui provisionne un pool de calcul verrouillé (comme un runtime WebAssembly). Le méta-agent injecte du nouveau code dans ce bac à sable, mais son rayon d’impact est borné par les politiques réseau statiques générées. - Le méta-agent dans le rôle de « développeur » (la boucle GitOps) : si le méta-agent a besoin d’une véritable nouvelle infrastructure physique, il agit en tant que développeur. Il écrit un nouveau
Aggregate.yamlet le commite dans Git. Cela déclenche le pipeline CI/CD standard. Un rôle de verdict de gouvernance analyse statiquement la topologie demandée par l’IA et arrête le build en toute sécurité si l’IA a halluciné une vulnérabilité.
12. Sérialisation des modèles et sécurité de la chaîne d’approvisionnement
Déployer un modèle open source implique souvent de télécharger des fichiers .pkl ou .gguf opaques qui peuvent contenir des charges utiles de code malveillant. Les entreprises peuvent traiter la sécurité de la chaîne d’approvisionnement des modèles comme un problème de configuration de la plateforme cible. En définissant une fonctionnalité model_provenance dans le catalogue, le plugin de rendu Wasm d’une entreprise peut évaluer la configuration et la traduire en artefacts d’exécution (comme des politiques Kyverno pour Kubernetes), de sorte que le cluster cible soit configuré pour empêcher l’orchestrateur de récupérer des poids de modèle non signés ou non vérifiés.