> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

> Décrit la dépréciation de l’utilisation de jetons ID comme informations d’authentification pour la Management API et explique comment migrer votre configuration afin d’utiliser des jetons d’accès.

# Migrer vers les points de terminaison de la Management API au moyen de jetons d’accès

export const AuthCodeBlock = ({filename, icon, language, highlight, children}) => {
  const [displayText, setDisplayText] = useState(children);
  const [copyText, setCopyText] = useState(children);
  const wrapperRef = React.useRef(null);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      if (!window.autorun || !window.rootStore) {
        return;
      }
      unsubscribe = window.autorun(() => {
        let processedChildrenForDisplay = children;
        let processedChildrenForCopy = children;
        for (const [key, value] of window.rootStore.variableStore.values.entries()) {
          const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
          let displayValue = value;
          if (key === "{yourClientSecret}" && value !== "{yourClientSecret}") {
            displayValue = value.substring(0, 3) + "*****MASQUÉ*****";
          }
          processedChildrenForDisplay = processedChildrenForDisplay.replaceAll(new RegExp(escapedKey, "g"), displayValue);
          processedChildrenForCopy = processedChildrenForCopy.replaceAll(new RegExp(escapedKey, "g"), value);
        }
        setDisplayText(processedChildrenForDisplay);
        setCopyText(processedChildrenForCopy);
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  useEffect(() => {
    if (!wrapperRef.current) return;
    const originalWriteText = navigator.clipboard.writeText.bind(navigator.clipboard);
    let isOverriding = false;
    const handleClick = e => {
      const button = e.target.closest('[data-testid="copy-code-button"]');
      if (!button || !wrapperRef.current.contains(button)) return;
      isOverriding = true;
      navigator.clipboard.writeText = text => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
          return originalWriteText(copyText);
        }
        return originalWriteText(text);
      };
      setTimeout(() => {
        if (isOverriding) {
          isOverriding = false;
          navigator.clipboard.writeText = originalWriteText;
        }
      }, 100);
    };
    const wrapper = wrapperRef.current;
    wrapper.addEventListener('click', handleClick, true);
    return () => {
      wrapper.removeEventListener('click', handleClick, true);
      if (navigator.clipboard.writeText !== originalWriteText) {
        navigator.clipboard.writeText = originalWriteText;
      }
    };
  }, [copyText]);
  return <div ref={wrapperRef}>
      <CodeBlock filename={filename} icon={icon} language={language} lines highlight={highlight}>
        {displayText}
      </CodeBlock>
    </div>;
};

L’utilisation de <Tooltip tip="Jeton ID : information d’identification destinée au client lui-même, et non à l’accès à une ressource." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=ID+tokens">jetons ID</Tooltip> pour appeler les points de terminaison de <Tooltip tip="Jeton ID : information d’identification destinée au client lui-même, et non à l’accès à une ressource." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Management+API">Management API</Tooltip> est en cours d’abandon. Vous devez utiliser des <Tooltip tip="Management API : un produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=access+tokens">jetons d’accès</Tooltip>. La période de grâce pour cette migration a commencé le **31 mars 2018**.

Une fois votre migration vers les jetons d’accès terminée, désactivez la bascule **Allow ID Tokens for Management API v2 Authentication** dans le Dashboard.

Si vous utilisez des jetons ID pour appeler l’un des points de terminaison suivants, cette migration vous concerne. Ces points de terminaison acceptent maintenant des jetons d’accès standard. Rien d’autre ne change dans leur fonctionnement. Vous pouvez vous attendre aux mêmes schémas de requête et de réponse; vous n’avez qu’à mettre à jour le jeton utilisé pour l’autorisation.

<div id="endpoints-affected">
  ## Points de terminaison touchés
</div>

| Point de terminaison                                      | Cas d’utilisation                                                              |
| --------------------------------------------------------- | ------------------------------------------------------------------------------ |
| GET /api/v2/users/{id}                                    | Récupérer les renseignements d’un utilisateur                                  |
| GET /api/v2/users/{id}/enrollments                        | Récupérer toutes les inscriptions à Guardian MFA d’un utilisateur              |
| PATCH /api/v2/users/{id}                                  | Mettre à jour les renseignements d’un utilisateur                              |
| DELETE /api/v2/users/{id}/multifactor/{provider}          | Supprimer les paramètres du fournisseur MFA pour un utilisateur                |
| POST /api/v2/device-credentials                           | Créer une clé publique pour un appareil                                        |
| DELETE /api/v2/device-credentials/{id}                    | Supprimer les informations d’authentification d’un appareil                    |
| POST/api/v2/users/{id}/identities                         | Lier des comptes d’utilisateur provenant de différents fournisseurs d’identité |
| DELETE /api/v2/users/{id}/identities/{provider}/{user_id} | Dissocier des comptes d’utilisateur                                            |

<div id="actions">
  ## Actions
</div>

<div id="scope-changes">
  ### Modifications des portées
</div>

Les actions que vous pouvez effectuer avec la Management API dépendent des portées incluses dans votre jeton d’accès. Avec cette migration, vous pouvez soit obtenir un jeton d’accès limité qui ne peut mettre à jour que les données de l’utilisateur connecté, soit un jeton d’accès qui peut mettre à jour les données de n’importe quel utilisateur. Dans la matrice suivante, vous pouvez voir les portées que votre jeton doit avoir dans chaque cas et pour chaque point de terminaison.

Par exemple, si vous obtenez un jeton d’accès qui contient la portée `read:users`, vous pouvez récupérer les données de n’importe quel utilisateur à l’aide du point de terminaison `GET /api/v2/users/{id}`. Cependant, si votre jeton contient la portée `read:current_user`, vous ne pouvez récupérer que les renseignements de l’utilisateur actuellement connecté (celui pour lequel le jeton a été émis).

| Point de terminaison                                      | Portée pour l’utilisateur actuel         | Portée pour n’importe quel utilisateur |
| --------------------------------------------------------- | ---------------------------------------- | -------------------------------------- |
| GET /api/v2/users/{id}                                    | `read:current_user`                      | `read:users`                           |
| GET /api/v2/users/{id}/enrollments                        | `read:current_user`                      | `read:users`                           |
| POST/api/v2/users/{id}/identities                         | `update:current_user_identities`         | `update:users`                         |
| DELETE /api/v2/users/{id}/identities/{provider}/{user_id} | `update:current_user_identities`         | `update:users`                         |
| PATCH /api/v2/users/{id}                                  | `update:current_user_metadata`           | `update:users`                         |
| PATCH /api/v2/users/{id}                                  | `create:current_user_metadata`           | `update:users`                         |
| DELETE /api/v2/users/{id}/multifactor/{provider}          | `delete:current_user_metadata`           | `update:users`                         |
| POST /api/v2/device-credentials                           | `create:current_user_device_credentials` | `create:device_credentials`            |
| DELETE /api/v2/device-credentials/{id}                    | `delete:current_user_device_credentials` | `delete:device_credentials`            |

<div id="get-access-tokens">
  ### Obtenir des jetons d’accès
</div>

Auth0 a changé la façon d’obtenir un jeton pour les points de terminaison mentionnés précédemment. Il existe plusieurs façons d’authentifier un utilisateur et d’obtenir des jetons, selon la technologie et le flux <Tooltip tip="OAuth 2.0 : framework d’autorisation qui définit les protocoles et les workflows d’autorisation." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=OAuth+2.0">OAuth 2.0</Tooltip> utilisé pour l’authentification :

* **SPA exécutée dans un navigateur** : utilisez le point de terminaison d’autorisation.
* **Application web exécutée sur un serveur, application mobile, processus côté serveur ou application hautement fiable** : utilisez le <Tooltip tip="Point de terminaison de jeton : point de terminaison sur le Authorization Server utilisé pour demander des jetons par programmation." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Token+endpoint">point de terminaison de jeton</Tooltip>.
* **Authentification croisée** : utilisez Lock intégré ou auth0.js pour authentifier les utilisateurs lorsque les requêtes proviennent de domaines différents.

<div id="authorization-endpoint">
  #### Point de terminaison d’autorisation
</div>

Dans cette section, nous utiliserons un exemple pour illustrer les différences dans la façon d’obtenir un token avec le point de terminaison d’autorisation. Gardez à l’esprit que, peu importe le point de terminaison que vous souhaitez migrer, les changements sont les mêmes; la seule chose qui diffère, ce sont les portées que vous précisez dans la requête.

Dans l’exemple ci-dessous, vous utilisez le point de terminaison `GET User by ID` pour récupérer toutes les informations du profil de l’utilisateur connecté. Pour ce faire, nous commencerons par authentifier l’utilisateur au moyen de l’Implicit grant et récupérer le ou les tokens. Ci-dessous, vous pouvez voir une mise en œuvre de l’ancienne approche, qui obtient un jeton d’identité puis l’utilise pour effectuer une requête au point de terminaison.

export const codeExample1 = `https://{yourDomain}/authorize?
      scope=openid
      &response_type=id_token
      &client_id={yourClientId}
      &redirect_uri=https://{yourApp}/callback
      &nonce={nonce}
      &state={opaqueValue}`;

<AuthCodeBlock children={codeExample1} language="http" />

Dans l’exemple ci-dessous, vous pouvez voir la nouvelle approche pour obtenir un jeton d’accès.

export const codeExample2 = `https://{yourDomain}/authorize?
      audience=https://{yourDomain}/api/v2/
      &scope=read:current_user
      &response_type=token%20id_token
      &client_id={yourClientId}
      &redirect_uri=https://{yourApp}/callback
      &nonce={nonce}
      &state={opaqueValue}`;

<AuthCodeBlock children={codeExample2} language="http" />

Pour obtenir un jeton d’accès pour la Management API :

* Définissez `audience` sur `https://{yourDomain}/api/v2/`
* Demandez la portée `${scope}`
* Définissez `response_type` sur `id_token token` afin qu’Auth0 envoie à la fois un jeton d’identité et un jeton d’accès

Si vous décodez le jeton d’accès reçu et en examinez le contenu, vous verrez ce qui suit :

export const codeExample3 = `{
      "iss": "https://{yourDomain}/",
      "sub": "auth0|5a620d29a840170a9ef43672",
      "aud": "https://{yourDomain}/api/v2/",
      "iat": 1521031317,
      "exp": 1521038517,
      "azp": "{yourClientId}",
      "scope": "\${scope}"
    }`;

<AuthCodeBlock children={codeExample3} language="json" />

Notez que `aud` correspond à l’URI de l’API de votre tenant, `portée` à `${scope}` et `sub` à l’ID de l’utilisateur connecté.

Une fois que vous avez le jeton d’accès, vous pouvez l’utiliser pour envoyer une requête au point de terminaison. Cette partie reste la même : rien d’autre ne change dans la requête, sauf la valeur utilisée comme jeton `Bearer`. La réponse reste également la même.

<div id="token-endpoint">
  #### Point de terminaison de jeton
</div>

Dans cette section, nous utiliserons un exemple pour montrer les différences dans la façon d’obtenir un jeton au moyen du point de terminaison de jeton. Gardez toutefois à l’esprit que, peu importe le point de terminaison que vous souhaitez migrer, les changements sont les mêmes : seule la portée précisée dans la requête change.

Dans l’exemple ci-dessous, vous souhaitez utiliser le point de terminaison `GET User by ID` pour récupérer l’ensemble des renseignements de profil de l’utilisateur connecté. Commencez par authentifier l’utilisateur à l’aide du grant Password Exchange, puis récupérez le ou les jetons. Ci-dessous, vous pouvez voir une mise en œuvre de l’ancienne approche, qui obtient un jeton d’identité (puis l’utilise pour envoyer une requête au point de terminaison).

export const codeExample4 = `POST https://{yourDomain}/oauth/token
    Content-Type: application/x-www-form-urlencoded
    {
      "grant_type": "password",
      "username": "{yourUsername}",
      "password": "{yourPassword}",
      "scope": "openid",
      "client_id": "{yourClientId}",
      "client_secret": "{yourClientSecret}",
    }`;

<AuthCodeBlock children={codeExample4} language="json" />

Dans l’exemple ci-dessous, vous pouvez également voir la nouvelle approche qui permet d’obtenir un jeton d’accès.

export const codeExample5 = `POST https://{yourDomain}/oauth/token
    Content-Type: application/x-www-form-urlencoded
    {
      "grant_type": "password",
      "username": "{yourUsername}",
      "password": "{yourPassword}",
      "audience": "https://{yourDomain}/api/v2/",
      "scope": "read:current_user",
      "client_id": "{yourClientId}",
      "client_secret": "{yourClientSecret}",
    }`;

<AuthCodeBlock children={codeExample5} language="json" />

Pour obtenir un jeton d’accès qui permet d’accéder à la Management API :

* Définissez `aud` sur `https://{yourDomain}/api/v2/`
* Demandez la portée `read:current_user`

Une fois que vous avez le jeton d’accès, vous pouvez l’utiliser pour envoyer une requête au point de terminaison. Cette partie reste la même : rien d’autre ne change dans la requête, sauf la valeur utilisée comme jeton `Bearer`. La réponse reste également la même.

<div id="embedded-lock-or-auth0js">
  #### Embedded Lock ou auth0.js
</div>

Si vous intégrez Lock ou auth0.js v9 à votre application, vous utilisez l’authentification inter-origines. Elle sert à authentifier les utilisateurs lorsque les requêtes proviennent de domaines différents.

Si vous utilisez auth0.js pour accéder à la Management API et gérer vos utilisateurs, votre script devra être mis à jour.

Dans l’exemple ci-dessous, vous pouvez voir l’ancienne méthode.

export const codeExample6 = `// récupérer un jeton d’identité
    var webAuth = new auth0.WebAuth({
      clientID: '{yourClientId}',
      domain: '{yourDomain}',
      redirectUri: 'https://{yourApp}/callback',
      scope: 'openid',
      responseType: 'id_token'
    });
    // créer une instance
    var auth0Manage = new auth0.Management({
      domain: '{yourDomain}',
      token: '{yourIdToken}'
    });`;

<AuthCodeBlock children={codeExample6} language="javascript" />

Cet exemple illustre la nouvelle approche.

export const codeExample7 = `// obtenir un jeton d’accès
    var webAuth = new auth0.WebAuth({
      clientID: '{yourClientId}',
      domain: '{yourDomain}',
      redirectUri: 'https://{yourApp}/callback',
      audience: 'https://{yourDomain}/api/v2/',
      scope: 'read:current_user',
      responseType: 'token id_token'
    });
    // créer une nouvelle instance
    var auth0Manage = new auth0.Management({
      domain: '{yourDomain}',
      token: '{yourMgmtApiAccessToken}'
    });`;

<AuthCodeBlock children={codeExample7} language="javascript" />

* Demandez à la fois un jeton d’identité et un jeton d’accès dans la réponse

  `responseType: 'token id_token'`
* Définissez la Management API comme l’<Tooltip tip="Audience : identifiant unique du destinataire d’un token émis. Appelée aud dans un token, sa valeur contient l’ID d’une application (Client ID) pour un ID token, ou d’une API (API identifier) pour un access token." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=audience">audience</Tooltip> du token

  `audience: 'https://YOUR_DOMAIN/api/v2/'`
* Demandez l’autorisation requise

  `scope: 'read:current_user'`
* Authentifiez-vous auprès de la Management API à l’aide du jeton d’accès

<div id="account-linking-changes">
  ### Modifications à la liaison de comptes
</div>

Les modifications apportées à cette fonctionnalité sont les suivantes :

* Vous ne pouvez plus utiliser un jeton d’identité dans l’en-tête `Authorization`
* Si vous utilisez un jeton d’accès dans l’en-tête `Authorization`, avec `update:users` comme permission accordée, vous pouvez envoyer dans le corps de la requête soit le `user_id`, soit le jeton d’identité du compte secondaire
* Si vous utilisez un jeton d’accès dans l’en-tête `Authorization`, avec `update:current_user_metadata` comme permission accordée, vous pouvez seulement envoyer le jeton d’identité du compte secondaire dans le corps de la requête. Les conditions suivantes doivent être respectées :

  * Le jeton d’identité doit être signé avec `RS256` (vous pouvez définir cette valeur dans **Dashboard > Applications > Paramètres de l’application > Paramètres avancés > OAuth**)
  * La claim `aud` du jeton d’identité doit identifier l’application et avoir la même valeur que la claim `azp` du jeton d’accès

<div id="restrictions">
  ## Restrictions
</div>

Les jetons d’accès utilisés pour accéder à la Management API ne doivent contenir qu’une seule valeur dans le claim `aud`. Si votre jeton contient plus d’une valeur, votre requête à la Management API échouera.

<div id="learn-more">
  ## En savoir plus
</div>

* [Migrer vers les jetons d’accès pour la liaison de comptes](/docs/fr-ca/troubleshoot/product-lifecycle/past-migrations/link-user-accounts-with-access-tokens-migration)