Après le chef d'orchestre, les artistes entrent sur scène
- Chacun garde son rythme
- L’agent n’est pas le bout de la chaîne
- L’agent, un sujet d’architecture à part entière
- Faire les bons choix pour les bons résultats
Nous l’avons vu dans notre précédent article, lorsque l’orchestrateur doit réajuster l’état de la plateforme avec la demande de l’utilisateur, il transmet les commandes via un bus de messagerie. Chaque agent (comme programme spécialisé de l’orchestrateur) opère ensuite selon les instructions reçues, puis communique sur l’état d’avancement de la plateforme… du moins, ce qu’il en sait.
Taillée pour supporter la charge des traitements dispersés sur des centres de données entiers, cette architecture doit également garantir des capacités de résolution des demandes clients suffisamment élevées pour que leur satisfaction soit au rendez-vous.
Nous allons donc voir ce qu’il se passe en coulisses, et comment l’infrastructure de l’orchestrateur permet d’y arriver, avec l’exemple de la gestion des machines virtuelles (ou « VM ») dans le Cloud. En parallèle, nous continuerons de voir – comme dans notre précédent article – comment cela peut nous inspirer dans la gestion de services d’IA.
Chacun garde son rythme
De l’orchestrateur à l’agent : flux asynchrone, mais pas que
Le Control Plane et les agents ne travaillent pas au même rythme. Le premier prend des décisions, les seconds exécutent des actions concrètes qui peuvent prendre du temps : créer une machine, attacher un volume, démarrer un service… Si le Control Plane devait attendre la fin de chaque action avant de continuer, il serait rapidement bloqué.
La communication asynchrone résout ce problème. Le Control Plane dépose ses commandes dans un bus de messages et poursuit son travail. Chaque agent récupère les ordres qui le concernent quand il est prêt, les traite, puis signale le résultat. Cette séparation permet de répartir la charge et d’éviter qu’un seul composant ne devienne un point unique de défaillance (un « SPOF » dans le jargon : un composant dont la panne suffirait à paralyser tout le système).
Dans la pratique, nous utilisons le plus souvent un système de files d’attente, via des outils comme RabbitMQ. Les messages y sont traités dans l’ordre d’arrivée. Nous trouvons généralement deux types de files : des files génériques par type d’agent (par exemple « tous les agents de calcul ») et des files spécifiques à un hôte précis (par exemple « l’agent de la machine n°42 »). Selon le besoin, le Control Plane peut s’adresser à n’importe quel agent disponible ou à un agent en particulier.
Dans ce système de files, deux modes de communication coexistent. Dans le premier, l’émetteur envoie un ordre et attend une réponse. Dans le second, il envoie l’ordre sans attendre de réponse immédiate. Ce second mode est particulièrement utile pour les actions longues.
Avec l’intelligence artificielle, le principal défi vient du volume du contexte, alors que les messages qui circulent dans le bus restent volontairement légers (pour éviter de ralentir les communications). Lorsqu’une information est trop volumineuse, nous la stockons dans une base de données partagée et nous ne faisons transiter dans le bus qu’une référence. Pour des besoins d’IA, cette base de données peut être vectorielle. Cette approche préserve les performances du système de messagerie.
De l’agent à l’orchestrateur : même tandem
Dans l’autre sens, les mêmes moyens sont mis en œuvre. L’agent fournit un retour via le même système de bus de messagerie, de sorte que le Control Plane soit informé au plus vite des résultats du traitement. Les informations détaillées sont en revanche stockées dans une base de données — potentiellement la même — pour s’assurer que tout le contexte est bien conservé.
L’agent n’est pas le bout de la chaîne
Qui est aux commandes, dans le nuage ?
Le cas de la machine virtuelle (ou « VM ») est un bon exemple, à plus d’un titre. L’agent ne crée pas la machine tout seul. Il s’adresse à un hyperviseur, qui est lui-même une brique logicielle complexe. Sous Linux, nous utilisons souvent QEMU/KVM. C’est ce que nous appelons un hyperviseur, et sa spécialité est justement de créer et superviser les ressources virtuelles qui vont constituer notre VM.
L’agent joue donc le rôle d’intermédiaire : il reçoit les ordres du Control Plane, les traduit en actions compréhensibles par l’hyperviseur, surveille le résultat et remonte l’état. Le même schéma se retrouve pour le stockage, le réseau ou d’autres ressources.
Dans le cas de l’IA, le schéma reste proche. Un service d’inférence ou un agent spécialisé tourne le plus souvent à l’intérieur d’une machine virtuelle (ou d’un conteneur) équipée de processeurs graphiques. L’agent d’orchestration pilote alors cette infrastructure sous-jacente, même si le traitement sémantique lui-même est réalisé par le modèle.
Les agents effectuent également des tâches périodiques : synchronisation d’état, nettoyage, et reporting de la capacité disponible (processeurs, mémoire, cartes graphiques…). Ces informations permettent au Control Plane de savoir où il peut encore placer de nouvelles ressources.
Halloween dans le cimetière des agents
Deux situations pathologiques méritent d’être nommées. Parfois, l’agent reste actif alors que la ressource qu’il gérait a disparu : la machine virtuelle est « morte » mais l’agent croit qu’elle existe encore, ce qui nous amène à parler de « ghost » (de fantôme). Parfois, l’inverse se produit : la ressource existe encore, mais l’agent chargé de la piloter a disparu. Nous parlons alors de « zombie ».
Pour limiter ces écarts, plusieurs mécanismes existent. Déjà, l’agent envoie périodiquement des signaux de vie afin de prouver qu’il est toujours présent. Le Control Plane peut ainsi détecter un agent silencieux – comme une mort prématurée – et enclencher une procédure de récupération. Lorsqu’un agent doit s’arrêter, nous privilégions un arrêt propre : il termine d’abord les opérations en cours avant de se retirer. Enfin, des mécanismes de revendication de ressources évitent que deux agents tentent de gérer la même machine en même temps.
L’agent passe à l’acte
Côté agent, l’idempotence est aussi importante que côté Control Plane. Une commande doit pouvoir être reçue plusieurs fois sans produire d’effets indésirables. Créer une ressource qui existe déjà ne doit pas en créer une seconde ; démarrer une instance déjà démarrée ne doit rien changer.
L’agent doit également s’assurer qu’il n’exécute que les opérations autorisées pour le locataire concerné. Cette isolation garantit que les actions d’un utilisateur ou d’un projet ne peuvent pas interférer avec celles d’un autre.
Pour un agent classique (pas un agent IA), la sémantique est également importante, car c’est le moyen le plus sûr d’éviter ces effets indésirables : nous ne dirons pas « ajoute 50 Gio de stockage à cette VM » mais plutôt « le stockage doit être à 500 Gio » à la fin de ton opération.
Tâches complexes et arbitrages
Certaines demandes utilisateurs sont trop complexes pour être traitées par un seul agent. Demander un service de type plateforme peut, par exemple, entraîner la création de plusieurs machines virtuelles, le montage de volumes, la configuration réseau, puis le déploiement d’applications. Dans ce cas, le Control Plane orchestre une séquence d’actions qui mobilise plusieurs agents, éventuellement de types différents. Le même besoin apparaît avec les systèmes multi-agents d’intelligence artificielle. Un agent peut avoir à en solliciter un autre pour une sous-tâche.
Deux approches coexistent alors. Soit toute la chaîne reste confinée à l’intérieur d’un ensemble de ressources gérées localement, ce qui réduit la latence et améliore l’isolation. Soit les services sont plus dispersés dans l’infrastructure, ce qui facilite le placement des ressources mais complexifie le suivi et peut dégrader les performances. Dans le cas des machines virtuelles, ces choix se retrouvent déjà dans les offres cloud classiques, notamment sous la forme d’hôtes dédiés ou partagés. Par exemple, une instance dédiée ne donne pas de visibilité sur le placement de la VM, tandis qu’un hôte dédié réserve le serveur physique au client, ce qui permet de contrôler ce genre d’information (très utile pour optimiser ses applications selon le matériel dont elles dépendent).
Des agents pour orchestrer des agents
Transposée à l’IA, la problématique change quelque peu. L’agent d’orchestration est un programme déterministe exécutant les tâches soumises par l’orchestrateur, qu’il ne faut pas confondre avec l’agent IA, capable de raisonner et de solliciter des outils. Lorsque plusieurs agents IA sont impliqués, plusieurs approches peuvent être imaginées, mais un maître mot demeure : seul l’agent d’orchestration devrait communiquer avec l’orchestrateur. Ceci permet d’éviter des comportements qui échapperaient au contrôle.
Une première approche consisterait à avoir systématiquement un seul agent IA pour chaque agent d’orchestration. La communication entre agents IA remonterait ainsi systématiquement à l’orchestrateur, et l’ensemble du traitement se reposerait sur ses compétences. Une seconde approche pourrait associer l’ensemble des agents IA du traitement à un seul agent d’orchestration, qui porterait alors la logique pour coordonner les tâches entre les agents IA. Une dernière approche, plus en phase avec l’existant lorsque nous industrialisons des services d’IA, consiste à avoir un agent IA coordonnant les autres. Ce coordinateur serait alors le seul agent IA en contact avec l’agent d’orchestration.
Chaque approche mérite d’être explorée à la conception de la plateforme, car le choix repose en grande partie sur les contraintes et besoins d’architecture. Dans l’absolu – et si les moyens le permettent – il serait intéressant de proposer plusieurs alternatives aux clients, car eux aussi peuvent avoir un intérêt à préférer l’une des options aux autres.
Enfin, lorsque l’agent doit dialoguer avec un service externe (un outil, une base de connaissances, un protocole comme MCP), nous nous appuyons généralement sur des adaptateurs. Ceux-ci traduisent les ordres de l’agent dans le langage compris par le service distant, tout en isolant le reste du système des spécificités de chaque outil.
L’agent, un sujet d’architecture à part entière
Pour rester évolutif, un agent est rarement conçu comme un bloc monolithique. Nous pouvons distinguer trois concepts d’architecture logicielle.
L’interface
Elle permet de définir un contrat déterminant comment l’orchestrateur va communiquer avec les agents. De la sorte, quels que soient le type d’agent ou son degré de complexité interne, l’orchestrateur pourra toujours se reposer sur un modèle standard pour formaliser les paramètres avec de nouveaux agents, sans risque de rupture avec l’existant.
Par exemple, des actions de création, mise à jour et suppression peuvent avoir un format standardisé dans une certaine mesure, avec renvoi d’un identifiant unique de la ressource à la création, qui sera ensuite requis pour toute modification ou en vue de la suppression de la ressource.
L’héritage
Il permet de décrire des fonctionnalités et comportements communs à tous les agents, ce qui évite des surprises sur la façon de traiter certaines informations, ou d’avoir à réinventer la roue à chaque nouvel agent.
S’enregistrer sur un bus de messagerie, envoyer régulièrement un signal pour montrer qu’il est vivant (ce qu’on appelle un « heartbeat »), gérer les erreurs… ce type d’action doit être standardisé précisément pour que ce soit réutilisable par n’importe quel agent, que les ressources manipulées derrière soient des ressources cloud ou IA.
La modularité
En architecture logicielle, nous pouvons définir des fonctions ou classes « Factory » qui servent littéralement à fabriquer des modules (que nous appelons souvent « pilotes » ou « drivers »). Ici, « fabriquer » signifie « sélectionner » et « créer » à la volée (au démarrage ou au besoin) une instance du module dont l’agent a besoin.
Dans notre exemple de la VM, un « driver » décrira comment dialoguer avec l’hyperviseur dont nous parlions plus tôt. Un driver dédié pourra contenir la logique spécifique pour communiquer avec un serveur MCP, ou pour transmettre des données d’un agent IA à un autre.
Cette organisation permet d’ajouter de nouveaux types de ressources sans réécrire tout l’agent, garantissant des gains de temps importants. Et cette architecture se transpose naturellement aux besoins de l’IA, comme vu avec nos derniers exemples.
Faire les bons choix pour les bons résultats
L’agent de gestion des machines virtuelles permet de se faire une idée de la complexité de ce système, mais il est loin d’être le seul. Nous trouvons des agents pour les volumes de stockage, pour le réseau, parfois pour gérer les serveurs physiques et l’hyperviseur, ou d’autres tâches d’administration plus discrètes et néanmoins essentielles.
Le flux de communication asynchrone repose sur un stockage persistant et un bus de messagerie conçu pour rester léger. Les choix d’architecture permettent ensuite de privilégier soit la performance et la sécurité, soit des coûts plus abordables, selon les besoins des clients. Plusieurs offres permettent ainsi de couvrir des cas d’usage variés.
L’agent lui-même constitue un vrai sujet d’architecture logicielle. Il doit à la fois disposer d’une interface standard et offrir la souplesse nécessaire pour anticiper de nouvelles connexions et de nouveaux types d’outils que l’orchestrateur pourrait être amené à… orchestrer.
C’est ainsi que l’orchestration de services d’intelligence artificielle via des agents – au sens de l’orchestrateur – pourrait être une évolution logique des techniques d’industrialisation de l’IA telles que nous les employons aujourd’hui.
Write a comment