iamops.dev
Argo sur X Flux RSS
FRFrançais

Labs Technique 11 min de lecture

ID-JAG expliqué : comment les agents d'IA obtiennent un accès inter-applications sous contrôle de l'entreprise

Comment ID-JAG et Cross App Access laissent le fournisseur d'identité de l'entreprise approuver l'accès des agents d'IA à d'autres applications, avec captures.

Deux captures d'écran masquées de l'application d'exemple xaa.dev : le tableau de bord d'accueil avec son panneau Behind the scenes et l'ID-JAG décodé, identifiants cachés par des cadres noirs.
En brefID-JAG est un standard IETF proposé (brouillon -06) qui permet au…
  • ID-JAG est un standard IETF proposé (brouillon -06) qui permet au fournisseur d'identité d'une entreprise d'approuver l'accès d'un agent IA à une autre application.
  • Le fournisseur d'identité émet une assertion signée de courte durée ; l'autre application la vérifie et émet son propre jeton d'accès de courte durée.
  • Il remplace les fenêtres de consentement par application et les clés de longue durée par un point unique pour la politique et l'audit.
  • C'est encore un brouillon : la liaison de clés et le provisionnement à la volée pourraient passer dans des documents séparés, et plusieurs produits l'implémentent déjà.
  • Le lab sur l'exemple public xaa.dev montre le déroulement, avec des captures masquées et un enregistrement.
Refaire ce lab 6 étapes

J’ai écrit ce lab pour que vous puissiez le refaire vous-même. Chaque étape contient les commandes à copier et la sortie que j’ai obtenue, et vous pouvez la cocher une fois faite. Les coches restent uniquement dans ce navigateur.

Aller aux étapes

Comment ça marche

Copie un prompt prêt à l’emploi pour Claude Code, Cursor, Codex ou tout autre agent de code. Pour les environnements de test uniquement.

Afficher le prompt
I want to run a hands-on lab from iamops.dev, and I would like your help to do it safely.

Lab: ID-JAG expliqué : comment les agents d'IA obtiennent un accès inter-applications sous contrôle de l'entreprise
Read the whole lab here (Markdown): https://iamops.dev/fr/id-jag-explained.md

What the lab needs before the first step:
- A browser; xaa.dev is a public playground with throwaway data
- Values I have to set myself (the lab uses placeholders): <APP_CLIENT_ID>, <APP_CLIENT_SECRET>, <EXCHANGE_CLIENT_ID>, <EXCHANGE_CLIENT_SECRET>, <RESOURCE_CLIENT_ID>, <RESOURCE_CLIENT_SECRET>

How I want you to work:
1. Read the lab from start to finish first (each step lists its own prerequisites). Then check that the prerequisites are in place and that the tool versions match what the lab expects. Tell me what is missing before you run anything.
2. Run one step at a time. Before each command, show it to me and say in a sentence what it does.
3. Ask me before anything that costs money, creates cloud resources, touches a real tenant or account, or deletes anything. Wait for my answer.
4. Use the placeholders from the lab. Never paste real secrets, tokens or production identities into a command, a file or this chat. If a value is needed, tell me where to set it myself.
5. After each step, compare the output with the expected output in the lab. If it does not match, stop and tell me what differs. Do not carry on or invent a fix without asking me.
6. At the end, report what passed, what failed and which cleanup you did. Then offer to tick the steps off for me. The lab page keeps ticks only in my browser, so if you cannot do that, list the steps I should tick.

This lab is for test environments only. Do not run it against production, or against a tenant or account that holds real data or real users.

You may answer in my language.

De nombreux agents d’IA doivent accéder à plusieurs applications métier pour le compte d’un utilisateur. Aujourd’hui, chaque connexion déclenche généralement sa propre demande de consentement, ou repose sur une clé de longue durée enregistrée dans les paramètres de l’agent. Dans les deux cas, une organisation a du mal à voir et à contrôler ce qui se passe.

ID-JAG est une norme proposée qui déplace cette approbation de l’utilisateur individuel vers le fournisseur d’identité de l’organisation. Cet article explique son fonctionnement, l’état d’avancement de la spécification et ce que montre un essai en laboratoire avec une application d’exemple publique.

Le problème#

Les collaborateurs se connectent une seule fois, avec un seul compte, grâce à l’authentification unique (single sign-on). Le système qui la gère est le fournisseur d’identité de l’entreprise, appelé ici « connexion d’entreprise ».

Un agent d’IA doit ensuite lire des tâches dans une application, des fichiers dans une autre et un agenda dans une troisième. Chacune de ces applications exploite son propre serveur d’autorisation, qui ne sait rien de l’agent. En pratique, chaque connexion fonctionne de l’une de ces deux façons :

  • Une demande de consentement pour chaque application et chaque utilisateur. Les utilisateurs ont tendance à approuver sans lire, et l’organisation n’a aucun registre central.
  • Une clé de longue durée collée dans la configuration de l’agent. Elle n’expire pas, et quiconque l’obtient peut l’utiliser.

L’alternative est un point unique qui se porte garant de l’utilisateur et de l’agent, applique les règles de l’organisation et en garde une trace.

Ce que fait un ID-JAG#

Le nom complet est Identity Assertion JWT Authorization Grant. En pratique, c’est une assertion signée de courte durée émise par la connexion d’entreprise. Elle indique que l’organisation de cet utilisateur autorise cet agent à demander à cette application un accès précis.

Le schéma construit autour s’appelle informellement Cross App Access (XAA). La page d’oauth.net à son sujet dit qu’il « remplace l’étape d’approbation manuelle de l’utilisateur par un échange de jetons » (token exchange).

Les cinq étapes d'un flux ID-JAG, de la connexion unique à l'utilisation d'un jeton d'accès de courte durée par l'agent.

Le flux en cinq étapes :

  1. L’utilisateur se connecte une fois au travail, de la manière habituelle.
  2. L’agent demande à la connexion d’entreprise une assertion couvrant une application donnée.
  3. La connexion d’entreprise évalue sa politique. Si la connexion est autorisée, elle émet l’ID-JAG.
  4. L’agent présente l’ID-JAG au serveur d’autorisation de l’autre application. Ce serveur vérifie la signature, applique ses propres règles et émet un jeton d’accès de courte durée.
  5. L’agent utilise ce jeton pour appeler l’application.

Deux détails comptent. L’application destinataire décide toujours de ce qu’elle accorde : l’ID-JAG n’est donc pas un chèque en blanc. Et comme la connexion d’entreprise se trouve au milieu, il existe un seul endroit pour définir la politique et un seul endroit pour auditer ce qui s’est passé.

Sur le plan technique, il enchaîne deux normes existantes : le token exchange (RFC 8693) et le JWT bearer grant (RFC 7523).

Laboratoire : le flux dans l’exemple xaa.dev#

Le bac à sable gratuit xaa.dev, proposé par l’équipe développeurs d’Okta, rend le flux visible. Lors d’un essai en laboratoire le 7 novembre 2026, son application d’exemple a été exécutée en local dans un environnement de test. L’application dispose d’un panneau « Behind the scenes » qui marque chaque étape au fur et à mesure : connexion d’entreprise, ID-JAG, jeton d’accès et liste de contrôle récupérée auprès de la seconde application. Aucune demande de consentement n’est apparue à aucun moment.

L'application d'exemple xaa.dev avec la liste d'intégration à gauche et le panneau Behind the scenes à droite, montrant les quatre étapes terminées.
Vue d'ensemble. La liste (à gauche) a été récupérée auprès de la seconde application avec l'identité d'entreprise. Le panneau (à droite) énumère les quatre étapes : connexion d'entreprise, ID-JAG, jeton d'accès, liste via MCP. La revendication du sujet (sub) est masquée.

Étape 2 : l’assertion. Après la connexion d’entreprise, l’exemple échange le jeton d’identité (ID token) de l’utilisateur contre un ID-JAG (RFC 8693). En développant l’étape 2, on voit l’assertion décodée : l’émetteur, l’audience (le serveur d’autorisation de l’autre application), la ressource et le scope demandés, ainsi que les heures d’émission et d’expiration, ici séparées de cinq minutes. Les identifiants qui renvoient à une personne ou à un client sont masqués.

Étape 2 développée dans le panneau Behind the scenes : l'ID-JAG décodé, avec émetteur, audience, ressource, heures d'émission et d'expiration et scope visibles ; les identifiants sont recouverts de cadres noirs.
Étape 2, l'ID-JAG. L'émetteur, l'audience, la ressource, la durée de validité et le scope sont visibles. Le sujet, le client et les identifiants du jeton sont recouverts de cadres noirs, et le jeton encodé n'est pas affiché.

Étapes 3 et 4 : le jeton d’accès. Le serveur d’autorisation de l’autre application vérifie l’ID-JAG (RFC 7523) et renvoie un jeton d’accès au scope limité. L’exemple l’utilise ensuite pour récupérer la liste via MCP. Les revendications du jeton indiquent qui l’a émis, pour quelle audience et avec quel scope.

La section du jeton d'accès développée, avec les revendications qui montrent l'émetteur, l'audience et les scopes todos.read et mcp.access ; le jeton encodé et le sujet sont masqués.
Étapes 3 et 4, le jeton d'accès. Les revendications du jeton (émetteur, audience, scope) sont réelles. Le jeton encodé et le sujet sont masqués.

J’ai enregistré tout le flux sur le playground public xaa.dev, avec l’application d’exemple dans un environnement de test local et un utilisateur synthétique. L’enregistrement commence sur la page de connexion : tu vois chaque étape se dérouler, puis son en-tête et son contenu décodés. Seul le bandeau de sous-titres en haut a été ajouté. Il est sans son et dure environ une minute 44 secondes.

Enregistrement d'écran (1 min 44 s, sans son, sous-titres disponibles): connexion chez l'IdP de l'entreprise, puis chaque étape avec son en-tête et son contenu décodés. Utilisateur synthétique et jetons de démonstration à courte durée de vie issus du playground public. Les chaînes de jetons encodés sont raccourcies pour la mise en page.

Ce que tu vois#

  1. 0:08 Connexion chez l’IdP de l’entreprise. L’utilisateur se connecte sur idp.xaa.dev, pas dans l’application de l’agent. L’application ne voit jamais de mot de passe, et c’est chez l’IdP que vivent la MFA et les règles de connexion. Le playground accepte six chiffres quelconques comme second facteur.
  2. 0:30 L’application de l’agent reçoit un jeton d’identité. Il prouve qui s’est connecté. Regarde iss (l’IdP), aud (l’identifiant client de l’application) et exp, une heure après iat. L’application a maintenant une identité de l’organisation, mais pas encore d’accès à l’application todo.
  3. 0:47 L’IdP l’échange contre un ID-JAG (RFC 8693). L’agent demande une assertion destinée à une seule cible. Le type d’en-tête est oauth-id-jag+jwt. Les claims désignent dans aud le serveur d’autorisation de l’application todo, plus resource, client_id et scope. Dans un vrai déploiement, c’est ici que la politique de l’administrateur décide. Le playground autorise simplement.
  4. 0:58 L’ID-JAG a une vie courte. exp tombe 300 secondes après iat. Un ID-JAG qui fuit est inutile au bout de cinq minutes, et il ne fonctionne que chez le serveur nommé dans aud.
  5. 1:07 Le serveur d’autorisation propre à l’application todo émet le jeton d’accès (RFC 7523). L’agent lui présente l’ID-JAG. Ce serveur vérifie la signature de l’IdP, puis applique ses propres règles. Dans le jeton, ce serveur est iss, le serveur MCP est aud, et seul le scope approuvé figure. L’utilisateur est identifié dans l’espace de noms de l’application todo.
  6. 1:30 L’agent appelle l’API. Avec le jeton d’accès, il lit la checklist via MCP. La partie gauche de la page est cette réponse. Aucun écran de consentement n’est apparu à aucun moment.

Le laboratoire utilise un exemple public avec des comptes jetables et des données d’exemple. Les captures ont été recadrées sur l’application et masquées avant publication. L’enregistrement montre les jetons de démonstration décodés en entier, car ils viennent du playground public, appartiennent à un utilisateur synthétique et expirent en moins d’une heure. Les chaînes de jetons encodés sont raccourcies pour la mise en page.

Où en est la spécification#

C’est toujours un brouillon, pas une norme achevée. Le document est draft-ietf-oauth-identity-assertion-authz-grant, désormais en version -06, datée du 31 octobre 2026. C’est un document du groupe de travail OAuth de l’IETF, rédigé par des auteurs d’Okta et de Ping Identity et par un auteur indépendant. L’objectif est un document Standards Track, mais les brouillons peuvent encore évoluer.

IETF 127, 18 novembre 2026. Les auteurs ont présenté le brouillon à la session OAuth. Les diapositives citent trois thèmes ouverts :

  • Le provisionnement à la volée (just-in-time provisioning) : comment une application traite un utilisateur qu’elle n’a jamais vu, puisque son premier contact est un ID-JAG. Les diapositives recommandent de le traiter dans une future extension.
  • Le key binding : lier les jetons à une clé cryptographique pour qu’un jeton volé soit inutilisable. Les diapositives demandent s’il faut le déplacer dans une extension distincte, et les notes consignent une recommandation en faveur de plusieurs brouillons de suivi. Un participant a estimé que reporter des sujets dans d’autres documents donne au brouillon un air d’inachevé. L’auteur a répondu que le provisionnement est optionnel et que le key binding s’applique plus largement que ce brouillon.
  • Les passerelles et proxys, courants dans les déploiements d’IA où une passerelle se place entre l’agent et les applications. C’est un point ouvert. Un brouillon séparé est proposé, et les notes indiquent que les auteurs souhaiteraient des réunions supplémentaires (« interim ») sur les passerelles et le key binding.

Les notes les consignent comme des recommandations. Aucune décision définitive n’y figure. Les prochaines étapes des diapositives sont de trier les points restants, en les corrigeant dans une version -07 ou en les écartant délibérément, puis de demander un last call du groupe de travail.

Implémentations#

Plusieurs éditeurs l’implémentent déjà, bien que le brouillon ne soit pas final. D’après la liste des implémentations d’oauth.net, consultée le 19 novembre 2026 :

  • Les fournisseurs d’identité qui émettent des ID-JAG comprennent Okta, Oracle OCI IAM, Ping, Gravitee, Descope, Keycloak (indiqué « in progress ») et plusieurs autres.
  • Les serveurs d’autorisation qui les acceptent comprennent Okta, Oracle OCI IAM, Ping, Gravitee, Auth0 (accès anticipé), Stytch et WorkOS AuthKit (accès anticipé).
  • Les applications et outils d’IA jouant le rôle de clients comprennent Claude, OpenAI Codex CLI et Visual Studio Code (préversion).
  • Les applications côté réception comprennent Asana, Atlassian, Linear, Notion et Slack, certaines en bêta.

Quelques exemples datés :

  • Oracle : le 9 octobre 2026, Oracle a publié le token exchange ID-JAG dans OCI IAM.
  • Gravitee : Access Management 4.13, annoncé le 12 novembre 2026, peut jouer les deux rôles, émettre et accepter des ID-JAG.
  • Okta : le 13 novembre 2026, Okta a annoncé la disponibilité générale de la prise en charge de fournisseurs d’identité tiers, et cite Ping, Descope et Oracle comme fournisseurs compatibles XAA dont il peut gérer les utilisateurs et les agents.
  • MCP : le Model Context Protocol, une manière courante de connecter les outils d’IA aux applications, dispose d’une extension « Enterprise-Managed Authorization » qui utilise un ID-JAG. Le blog du projet l’a annoncée comme stable en juin 2026.

Microsoft Entra ne figurait pas dans la liste d’oauth.net au moment de la vérification.

Différences avec les écrans de consentement et l’on-behalf-of#

Demande de consentement On-behalf-of (OBO) ID-JAG / XAA
Qui approuve L’utilisateur, application par application Le consentement antérieur de l’utilisateur, transmis La connexion d’entreprise, selon des règles fixées par un administrateur
Ce que voit l’utilisateur Une demande par application En général rien après la première connexion Rien
Où cela fonctionne Partout où OAuth fonctionne Un service qui en appelle un autre, au sein d’un seul système d’identité Entre applications et organisations qui exploitent chacune leur serveur d’autorisation
Contrôle central Limité Partiel La raison d’être de la conception

Face aux écrans de consentement : une demande de consentement interroge l’utilisateur à chaque fois. Un ID-JAG applique une fois les règles de l’organisation, puis les fait respecter silencieusement.

Face à l’on-behalf-of : la documentation de Microsoft décrit l’OBO comme une API web qui utilise l’identité d’un utilisateur pour appeler une autre API, en transmettant l’identité et les autorisations de l’utilisateur le long de la chaîne. Cela se passe au sein de la plateforme d’identité Microsoft. L’ID-JAG traite un problème voisin au-delà des frontières : les deux applications ont des serveurs d’autorisation différents, et un tiers, la connexion d’entreprise, se porte garant de l’utilisateur. Les deux se ressemblent du point de vue de l’utilisateur, mais la confiance est organisée différemment.

Une réserve#

Moins de demandes signifie plus de confort, mais aussi moins d’occasions pour une personne d’examiner la requête. C’est une appréciation, pas une affirmation de la norme : la conception n’aide que si les politiques de l’organisation sont solides et révisées régulièrement. L’ID-JAG rend possible de voir et de contrôler l’accès des agents en un seul endroit. Quelqu’un doit encore exercer ce contrôle.

Cet article sera mis à jour à mesure que le brouillon avance vers le last call du groupe de travail.

Refaire ce lab#

Il suffit de Node.js 20 ou plus récent, de git et d'un navigateur. Vous enregistrez une application gratuite sur xaa.dev, lancez en local l'exemple TypeScript d'Okta et lisez l'ID-JAG et le jeton d'accès dans le panneau Behind the scenes. Environ 20 minutes. Ouvrez chaque étape, copiez les blocs et comparez avec ce que j'ai vu.

Chaque valeur entre chevrons est un espace réservé pour votre environnement de test. Rien sur cette page n’est un identifiant ou un secret réel.

Définissez vos variables une seule fois

bash · env.sh
# Values from the xaa.dev registration dialog. Replace each <PLACEHOLDER>; the endpoints below are the public defaults.
export XAA_CLIENT_ID='<APP_CLIENT_ID>'
export XAA_CLIENT_SECRET='<APP_CLIENT_SECRET>'
export EXCHANGE_CLIENT_ID='<EXCHANGE_CLIENT_ID>'          # leave empty if the dialog shows the same pair as above
export EXCHANGE_CLIENT_SECRET='<EXCHANGE_CLIENT_SECRET>'
export MCP_CLIENT_ID='<RESOURCE_CLIENT_ID>'               # the id that ends in -at-todo0-mcp
export MCP_CLIENT_SECRET='<RESOURCE_CLIENT_SECRET>'
export IDP_BASE_URL='https://idp.xaa.dev'
export AUTH_SERVER_URL='https://auth.resource.xaa.dev'
export MCP_SERVER_URL='https://mcp.xaa.dev/mcp'
export PORT='3001'
export BASE_URL='http://localhost:3001'
export XAA_SCOPE='todos.read mcp.access'
Étape 1Enregistrer une requesting app sur xaa.dev

Objectif. Enregistrez l'exemple comme Requesting App avec l'URI de redirection locale exact et reliez-le à la ressource Todo MCP server.

Prérequis

  • Un navigateur ; xaa.dev est un bac à sable public avec des données jetables
text · xaa-registration.txt
1. Open https://xaa.dev/developer/register and enter any email address (it only filters which apps you see; no account is created).
2. Select + Register New App.
   Application Name:   Onboarding App - Local Dev
   Redirect URIs:      http://localhost:3001/callback      (exact match: scheme, host, port, path)
   Connect to Resource: Todo MCP server (todo0-mcp), keep the scopes todos.read and mcp.access
3. Save the credentials from the confirmation dialog. There are two OAuth clients:
   - main client (client_id / client_secret): sign-in and token exchange at the IdP
   - resource client (the id ends in -at-todo0-mcp): the JWT bearer grant at the resource's authorization server
4. Put them into env.sh. Do not mix the two pairs up: that is the most common mistake.

Résultat attendu

résultat
Credential dialog shows two pairs:
  client_id           <APP_CLIENT_ID>
  resource_client_id  <RESOURCE_CLIENT_ID>   (ends in -at-todo0-mcp)
Étape 2Récupérer l'exemple et l'installer

Objectif. Clonez l'exemple TypeScript d'Okta basé sur le SDK MCP et installez ses dépendances.

Prérequis

  • Node.js 20 ou plus récent et git
  • Port 3001 libre
bash · install.sh
node --version
git clone https://github.com/oktadev/okta-xaa-typescript-mcp-sdk-example.git
cd okta-xaa-typescript-mcp-sdk-example
npm install

Résultat attendu

résultat
v20.x.x
Cloning into 'okta-xaa-typescript-mcp-sdk-example'...
added <n> packages in <n>s
Étape 3Définir les identifiants

Objectif. Chargez env.sh et vérifiez qu'aucune valeur requise n'est vide. L'application les lit dans l'environnement, il n'y a donc pas de fichier .env à commiter par erreur.

Prérequis

  • Les identifiants de l'étape d'enregistrement dans env.sh
  • Le terminal est dans le dossier cloné
bash · check-env.sh
. ./env.sh   # adjust the path if you saved env.sh elsewhere
for v in XAA_CLIENT_ID XAA_CLIENT_SECRET MCP_CLIENT_ID MCP_CLIENT_SECRET IDP_BASE_URL AUTH_SERVER_URL MCP_SERVER_URL BASE_URL XAA_SCOPE; do
  [ -n "${!v}" ] && echo "ok       $v" || echo "MISSING  $v"
done

Résultat attendu

résultat
ok       XAA_CLIENT_ID
ok       XAA_CLIENT_SECRET
ok       MCP_CLIENT_ID
ok       MCP_CLIENT_SECRET
ok       IDP_BASE_URL
ok       AUTH_SERVER_URL
ok       MCP_SERVER_URL
ok       BASE_URL
ok       XAA_SCOPE
Étape 4Lancer l'application et se connecter

Objectif. Lancez l'application et connectez-vous avec le company SSO. Le fournisseur d'identité de démo accepte n'importe quelle adresse e-mail, aucun identifiant réel n'est donc nécessaire.

Prérequis

  • Les variables de env.sh sont définies dans ce terminal
bash · start.sh
npm start   # keep it running, then open http://localhost:3001 and select "Sign in with company SSO"
bash · check-port.sh
curl -s -o /dev/null -w "%{http_code}\n" http://localhost:3001/   # from a second terminal

Résultat attendu

résultat
╔════════════════════════════════════════════════════╗
║     Employee Onboarding (XAA · xaa.dev demo)        ║
╚════════════════════════════════════════════════════╝
  App:          http://localhost:3001
  IdP:          https://idp.xaa.dev
  Auth server:  https://auth.resource.xaa.dev
  MCP server:   https://mcp.xaa.dev/mcp
[login] logged in as <your-demo-email>
200
Étape 5Lire l'ID-JAG et le jeton d'accès

Objectif. Dépliez chaque carte du panneau Behind the scenes et vérifiez trois choses dans les jetons décodés.

Prérequis

  • Le tableau de bord montre les quatre étapes comme terminées
text · checks.txt
Stage 2, ID-JAG:
  header typ  = oauth-id-jag+jwt
  aud         = https://auth.resource.xaa.dev     (the resource's authorization server)
  resource    = https://mcp.xaa.dev/mcp
  scope       = todos.read mcp.access
  exp - iat   = 300 seconds

Stage 3, access token:
  scope       contains todos.read and mcp.access
  aud         = the ID-JAG's resource, byte for byte

Résultat attendu

résultat
ID-JAG aud is the authorization server:           yes
ID-JAG resource is the MCP server:                yes
access token scope has todos.read and mcp.access: yes
access token aud equals ID-JAG resource:          yes
Étape 6Nettoyage

Objectif. Arrêtez l'application, supprimez le clone et les variables, et supprimez l'application enregistrée sur xaa.dev.

Prérequis

  • Rien d'autre n'utilise le port 3001
bash · cleanup.sh
# Stop the app: Ctrl+C in its terminal, or:
pkill -f "tsx.*src/server.ts" || true
cd .. && rm -rf okta-xaa-typescript-mcp-sdk-example
unset XAA_CLIENT_ID XAA_CLIENT_SECRET EXCHANGE_CLIENT_ID EXCHANGE_CLIENT_SECRET MCP_CLIENT_ID MCP_CLIENT_SECRET
# Then delete the app on https://xaa.dev/developer/register (select it, then delete).
# check: nothing listens on port 3001 any more
curl -s -o /dev/null -w "%{http_code}\n" http://localhost:3001/

Résultat attendu

résultat
000

Sources#

Discuter de cet article#

La discussion a lieu là où je l'ai partagé. Participez, ou dites-moi où je me suis trompé.

Suivre sur X

Les nouveaux articles par e-mail

Un e-mail par semaine avec les nouveaux articles et labs. Désinscription à tout moment.

Votre adresse est conservée chez Kit, le service qui envoie les e-mails. Détails

Articles et labs liés