En clair
Dans un immeuble de bureaux, le salarié entre avec son badge nominatif. Le prestataire de nettoyage, lui, ne reçoit pas le badge d’un salarié : l’accueil lui remet un badge de prestataire, valable pour la soirée, qui n’ouvre que les étages concernés. Si quelque chose disparaît, on sait quel badge a ouvert quelle porte. L’authentification serveur-à-serveur applique ce principe aux logiciels qui travaillent seuls, la nuit, sans personne derrière l’écran.
Pendant longtemps, la solution de facilité a consisté à faire tourner ces programmes avec les identifiants d’un employé, ou avec un « compte de service » créé comme un faux salarié et doté d’un mot de passe qui ne change jamais. Le jour où l’employé quitte l’entreprise, tout s’arrête. Le jour où le mot de passe fuit, un intrus dispose d’un accès permanent et large.
L’approche moderne inverse la logique. Le programme possède une identité à lui, déclarée et rattachée à l’organisation. Quand il a besoin d’agir, il échange cette identité contre un laissez-passer temporaire, qui n’accorde que les droits nécessaires et expire de lui-même au bout de quelques minutes ou d’une heure. Avec la multiplication des agents IA qui agissent sans surveillance continue, cette discipline devient un fondement de la sécurité.
Un exemple
Une entreprise de logiciels fait tourner un agent IA dans sa chaîne d’intégration continue : à chaque modification de code, il relit les changements, propose des corrections et rédige un résumé. Au départ, l’agent utilisait le jeton personnel d’un développeur. Les frais apparaissaient sur le compte de cette personne, l’agent héritait de tous ses droits, et le départ du développeur aurait suffi à le mettre hors service.
L’équipe déclare désormais l’agent comme une application rattachée à l’organisation, installée sur les seuls dépôts concernés et autorisée en lecture seule à appeler le service d’IA. À chaque exécution, la chaîne d’intégration obtient un jeton valable une heure et le transmet à l’agent. La consommation est imputée à l’organisation, soumise à ses plafonds de dépense, et l’accès peut être retiré en désinstallant l’application.
Comment ça marche
Le cadre de référence est OAuth 2.0, publié par l’IETF en octobre 2012 sous la direction de Dick Hardt (RFC 6749) 1. Parmi ses modes d’obtention de jeton figure le flux « client credentials », prévu pour un client qui agit pour son propre compte et non pour celui d’un utilisateur : le service s’authentifie auprès d’un serveur d’autorisation avec ses propres identifiants et reçoit un jeton d’accès, qu’il présente ensuite à chaque requête 1. Le serveur qui reçoit la requête vérifie ce jeton avant de répondre.
- DéclarerLe service est enregistré comme application auprès de l’organisation, avec une clé ou un secret qui lui est propre.
- AutoriserUn administrateur installe l’application et lui accorde les seules permissions nécessaires, sur un périmètre précis.
- ÉchangerAu moment d’agir, le service prouve son identité et reçoit un jeton d’accès de courte durée.
- AppelerLe service présente ce jeton à chaque requête ; le système appelé le vérifie et applique les droits associés.
- RenouvelerÀ l’expiration, le jeton devient inutilisable et le service doit en demander un nouveau.
Les GitHub Apps illustrent la version actuelle de ce schéma. L’application s’authentifie d’abord avec sa propre clé, puis demande un jeton d’installation pour l’organisation ou le compte où elle est installée ; ce jeton ne porte que les permissions accordées à l’application et expire au bout d’une heure, ce qui oblige à le renouveler régulièrement 2. En octobre 2026, GitHub a étendu ce mécanisme, en préversion publique, aux services et agents construits avec le Copilot SDK : une application dotée de la permission organisationnelle en lecture seule « Copilot Requests » peut appeler Copilot au nom de l’organisation, qui est facturée et dont les politiques de modèles et les plafonds de dépense s’appliquent 3.
Une variante supprime même le secret stocké : la fédération d’identité. Depuis 2021, les flux de GitHub Actions peuvent présenter à un fournisseur de cloud un jeton OpenID Connect généré automatiquement, que ce dernier échange contre des droits temporaires, sans qu’aucun secret de longue durée ne soit conservé dans GitHub 4. L’authentification serveur-à-serveur établit qui appelle ; ce que l’appelant a le droit de faire relève des permissions et politiques IAM. Elle se distingue aussi de l’identité d’agent, notion plus large qui couvre le propriétaire, le cycle de vie et la traçabilité de chaque agent.
Ce que ça change pour une entreprise
Dès qu’une entreprise fait travailler des agents IA sans surveillance, dans l’intégration continue, des robots de support ou des orchestrateurs, la question « au nom de qui agit ce programme ? » doit avoir une réponse nette. L’authentification serveur-à-serveur y répond : chaque agent a sa propre identité, ses coûts sont imputés à l’organisation et non à un salarié 3, ses droits sont limités, et son accès survit aux départs et aux changements d’équipe. Les audits y gagnent, puisque chaque action est rattachée à une application identifiée.
Le coût est surtout organisationnel : inventorier les comptes de service et jetons personnels existants, déclarer une application par usage, définir des permissions minimales et prévoir le renouvellement automatique des jetons. Le risque ne disparaît pas pour autant : la clé privée de l’application devient un actif sensible à protéger, et un agent mal configuré peut causer des dégâts dans les limites de ses droits. Une identité bien gérée ne dispense ni des garde-fous, ni de la relecture humaine, ni d’un moyen de couper l’accès rapidement.
Idées reçues
- « Il suffit de donner à l’agent le jeton d’un développeur. »
L’agent hérite alors de tous les droits de cette personne, ses actions lui sont attribuées et il cesse de fonctionner si elle part. Une identité propre à l’application évite ces trois écueils.
- « Un compte de service avec un mot de passe fixe, c’est la même chose. »
Un secret permanent reste exploitable indéfiniment s’il fuit. Les jetons de courte durée limitent la fenêtre d’exposition, par exemple à une heure pour les jetons d’installation GitHub [2].
- « Si l’agent est bien authentifié, il est sûr. »
L’authentification dit qui agit, pas si l’action est appropriée. Il faut encore des permissions minimales, une surveillance et la possibilité de révoquer l’accès.