> ## 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 comment démarrer avec un cas d’utilisation M2M.

# Machine à machine en libre-service

export const AuthCodeGroup = ({children, dropdown}) => {
  const [processedChildren, setProcessedChildren] = useState(children);
  useEffect(() => {
    let unsubscribe = null;
    function init() {
      unsubscribe = window.autorun(() => {
        const processChildren = node => {
          if (typeof node === "string") {
            let processedNode = node;
            for (const [key, value] of window.rootStore.variableStore.values.entries()) {
              const escapedKey = key.replaceAll(/[.*+?^${}()|[\]\\]/g, (String.raw)`\$&`);
              processedNode = processedNode.replaceAll(new RegExp(escapedKey, "g"), value);
            }
            return processedNode;
          } else if (Array.isArray(node)) {
            return node.map(processChildren);
          } else if (node && node.props && node.props.children) {
            return {
              ...node,
              props: {
                ...node.props,
                children: processChildren(node.props.children)
              }
            };
          }
          return node;
        };
        setProcessedChildren(processChildren(children));
      });
    }
    if (window.rootStore) {
      init();
    } else {
      window.addEventListener("adu:storeReady", init);
    }
    return () => {
      window.removeEventListener("adu:storeReady", init);
      unsubscribe?.();
    };
  }, [children]);
  return <CodeGroup dropdown={dropdown}>{processedChildren}</CodeGroup>;
};

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) + "*****MASKED*****";
          }
          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>;
};

Si votre cas d’utilisation vise une <Tooltip tip="Audience : identifiant unique de l’audience d’un jeton émis. Nommée aud dans un jeton, sa valeur contient l’ID d’une application (ID client) pour un ID Token ou d’une API (identifiant d’API) pour un Jeton d’accès." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=audience">audience</Tooltip> non interactive, comme des API ou des serveurs d’arrière-plan, vous utiliserez une configuration machine à machine (M2M).

<div id="use-cases">
  ## Cas d’utilisation
</div>

Utilisez le processus d’intégration M2M si vous :

* prenez en charge des communications de service à service
* exécutez des tâches planifiées ou des tâches cron sur des serveurs qui doivent accéder à des ressources protégées ou à des API
* permettez à des appareils IoT de communiquer avec des services backend ou des API
* avez une couche d’API qui doit communiquer avec d’autres couches d’API sans intervention de l’utilisateur ou après l’expiration d’un jeton utilisateur
* avez une API privilégiée qui peut devoir être appelée avant qu’un utilisateur soit authentifié (c.-à-d. à partir d’une Action ou d’un script de base de données personnalisé dans votre locataire Auth0)
* utilisez une passerelle API pour gérer les services backend
* utilisez ou prenez en charge des applications non interactives ou d’autres outils ne nécessitant aucune interaction humaine, comme des démons ou des services backend

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Ces services auront tout de même besoin d’un jeton d’accès M2M pour l’authentification.
</Callout>

<div id="how-to-use-this-guide">
  ## Comment utiliser ce guide
</div>

Ce guide vous propose un parcours pour créer votre implémentation M2M dans Auth0. Nous y présentons des points à considérer, des pratiques exemplaires et des concepts à passer en revue.

* Dans Architecture, nous vous recommandons de configurer Auth0 de manière à prendre en charge votre cycle de vie du développement logiciel et votre infrastructure existante.
* Dans Créer un compte, nous fournissons des instructions pour créer votre instance d’API dans Auth0, ainsi qu’une application prenant en charge le flux d’authentification (ou grant) requis pour l’authentification machine à machine.
* Dans Authentification, nous vous expliquons le grant à utiliser pour l’authentification, ainsi que les <Tooltip tip="Jeton d’accès : Information d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisée pour accéder à une API." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=access+tokens">jetons d’accès</Tooltip> et les permissions (ou scopes) que vous pouvez définir.
* Dans Image de marque, nous vous indiquons où trouver de l’information sur la façon de configurer les <Tooltip tip="Custom Domain : Domaine tiers avec un nom spécialisé ou personnalisé." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Custom+Domains">domaines personnalisés</Tooltip> selon la façon dont vous prévoyez gérer les certificats.
* Dans Automatisations de déploiement, vous pouvez en apprendre davantage sur nos outils conçus pour faciliter le déploiement.
* Dans Assurance qualité, vous pouvez en apprendre davantage sur les tests unitaires et les vérifications de préparation offertes dans <Tooltip tip="Auth0 Dashboard : Principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip>.

<div id="architecture">
  ## Architecture
</div>

Avant de configurer votre compte Auth0 et votre locataire, ou les groupes et les structures de vos services Auth0, dressez une cartographie de votre infrastructure existante afin de tirer le meilleur parti des fonctionnalités d’Auth0 dans votre écosystème actuel.

Comme il est mentionné dans les scénarios courants, il se peut que vous ayez d’autres technologies non interactives dans votre domaine applicatif, votre domaine réseau ou votre domaine d’appareils M2M à prendre en compte avant de configurer Auth0. Pour voir un exemple de scénario M2M, consultez [Server + API](/fr-CA/docs/get-started/architecture-scenarios/server-application-api/part-1). Pour faire un labo pratique avec Node et tester le déploiement d’API, consultez notre [dépôt GitHub](https://www.google.com/url?q=https://github.com/auth0-training/labs-node-working-with-apis\&sa=D\&source=docs\&ust=1723578190947730\&usg=AOvVaw3IXRQG9ogH4pW6LEY047T6).

Vous pouvez aussi créer une représentation visuelle de votre pile technologique actuelle et planifier la façon dont Auth0 s’intègre à votre cycle de développement logiciel (SDLC). Cela peut vous aider à déterminer de combien de locataires vous pourriez avoir besoin.

<div id="considerations">
  ### Considérations
</div>

Avant de créer un nouveau compte ou de configurer votre premier locataire, vous voudrez peut-être tenir compte des éléments suivants :

* La façon dont vous répartissez ou regroupez vos API afin d’appeler des points de terminaison précis.

  * Cela peut déterminer l’audience et d’autres claims dans les jetons d’accès.
* Les consommateurs tiers de votre ressource peuvent demander un jeton d’accès pour chaque appel. Un nombre excessif d’appels pourrait avoir une incidence sur votre [limite de débit](/fr-CA/docs/troubleshoot/customer-support/operational-policies/rate-limit-policy/rate-limit-configurations/essentials-professional-b2b).

  * Vous pouvez utiliser une passerelle API pour limiter le nombre de jetons d’accès qu’un tiers peut demander. Pour en savoir plus sur les passerelles API et Auth0, consultez [Configurer un fournisseur d’identité dans Access Gateway](/fr-CA/docs/get-started/auth0-overview/create-applications/configure-an-identity-provider-in-access-gateway).

<div id="create-an-account">
  ## Créer un compte
</div>

Maintenant que vous avez défini l’architecture, vous allez configurer votre compte Auth0 et vos locataires. Lorsque vous vous inscrivez aux services Auth0, vous créez votre premier [locataire](/fr-CA/docs/get-started/auth0-overview/create-tenants). C’est à cet endroit que vous configurez les composants, les services et les ressources Auth0. [Inscrivez-vous](https://auth0.com/signup) pour commencer.

<Card title="Avant de commencer">
  Dans Auth0 Dashboard ou à l’aide de Auth0 Management API, créez :

  * Une API pour représenter votre API
  * Une application M2M pour utiliser le flux Client Credentials

  Il peut être utile de planifier certains détails de configuration avant de créer un compte.

  * Le nom de votre locataire joue un rôle dans votre domaine Auth0. Avant d’en choisir un, consultez les [caractéristiques du locataire](/fr-CA/docs/get-started/auth0-overview/create-tenants#create-a-tenant-and-domain).
  * Les fonctionnalités Auth0 dont vous avez besoin pour votre cas d’utilisation. Certaines fonctionnalités sont offertes uniquement avec les forfaits Professional et Enterprise.
  * Déterminez si vous devez prendre en charge plusieurs environnements, comme le développement, la préproduction et la production. Pour en savoir plus, consultez [Configurer plusieurs environnements](/fr-CA/docs/get-started/auth0-overview/create-tenants/set-up-multiple-environments).
  * Si votre cas d’utilisation comprend des applications tierces que vous souhaitez enregistrer dans un locataire, vous pouvez utiliser [Dynamic Application Registration](/fr-CA/docs/get-started/applications/dynamic-client-registration) selon la spécification [OIDC Client Registration](https://openid.net/specs/openid-connect-registration-1_0.html).
</Card>

<div id="provision-a-tenant">
  ### Créer un locataire
</div>

Maintenant que l’architecture est définie, vous allez configurer votre compte Auth0 et votre <Tooltip tip="Locataire : chez Auth0, groupe d’utilisateurs logiquement isolé qui partagent un accès commun avec des privilèges précis à une même instance logicielle. Aucun locataire ne peut accéder aux données d’un autre locataire, même si plusieurs locataires peuvent s’exécuter sur la même machine." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Tenant">Locataire</Tooltip>.

<Warning>
  Lorsque vous créez une API dans Auth0 Dashboard, une application de test pour l’API est automatiquement générée. Si vous créez une API de façon programmatique dans la [Management API](https://auth0.com/docs/api/management/v2/), vous devrez peut-être créer une application de test dans un appel séparé.
</Warning>

<div id="register-an-api">
  #### Enregistrer une API
</div>

Dans cette section, créez votre API dans Auth0.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Vous pouvez toujours mettre à jour votre API dans Auth0 Dashboard ou en appelant le point de terminaison de la Management API [Mettre à jour un serveur de ressources](https://auth0.com/docs/api/management/v2/resource-servers/patch-resource-servers-by-id).
</Callout>

<Tabs>
  <Tab title="Auth0 Dashboard">
    Commencez par créer votre API dans Auth0 Dashboard.

    1. Suivez les instructions pour [enregistrer votre API](/fr-CA/docs/get-started/auth0-overview/set-up-apis).

    Dans la section [Authentification](/fr-CA/docs/get-started/onboarding/self-service-m2m#authentication), configurez les paramètres de votre API pour l’authentification M2M.
  </Tab>

  <Tab title="Management API">
    Pour enregistrer une API par programmation, utilisez la Management API. Vous aurez besoin d’un jeton d’accès pour utiliser la Management API. Pour savoir comment faire, consultez [Jetons de la Management API](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens).

    Utilisez l’exemple fourni dans Management API Explorer pour appeler le point de terminaison de la Management API [Créer un serveur de ressources](https://auth0.com/docs/api/management/v2/resource-servers/post-resource-servers) et incluez les paramètres suivants dans le corps de la requête :

    | Champ                                            | Description                                                                                                                                                                                                                                                                                                                                                                     | Exemple                |
    | ------------------------------------------------ | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | ---------------------- |
    | **Nom**                                          | Un nom convivial pour l’API. N’affecte aucune fonctionnalité.                                                                                                                                                                                                                                                                                                                   | `yourDomain`           |
    | **Identifiant**                                  | Un identifiant unique pour l’API. Auth0 recommande d’utiliser une URL. Auth0 distingue les URL qui incluent la barre oblique finale. Par exemple, `https://example.com` et `https://example.com/` sont deux identifiants différents. L’URL n’a pas besoin d’être accessible publiquement. Auth0 n’appellera pas votre API. Cette valeur ne peut pas être modifiée par la suite. | `https://{yourDomain}` |
    | **Profil JSON Web Token (JWT)**                  | Le profil détermine le format des jetons d’accès émis pour l’API. Les valeurs possibles sont `Auth0` et `RFC 9068`. Pour en savoir plus, consultez [Profils de jeton d’accès](/fr-CA/docs/secure/tokens/access-tokens/access-token-profiles).                                                                                                                                   | `access_token`         |
    | **Algorithme de signature JSON Web Token (JWT)** | L’algorithme utilisé pour signer les jetons d’accès. Les valeurs possibles sont `HS256`, `PS256`, `RS256`. Si vous sélectionnez `RS256`, le jeton sera signé avec la clé privée du locataire.                                                                                                                                                                                   | `HS256`                |
  </Tab>
</Tabs>

<div id="associate-an-application">
  ### Associer une application
</div>

Vous devez établir une association entre votre application et votre API pour que votre application puisse lui demander des jetons d’accès. Vous en apprendrez davantage sur les autorisations d’application dans la section Authentification.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  L’API d’Auth0 comporte plusieurs paramètres que vous devrez peut-être passer en revue avant de la configurer. Pour en savoir plus, consultez [Paramètres de l’API](/fr-CA/docs/get-started/apis/api-settings).
</Callout>

<Tabs>
  <Tab title="Auth0 Dashboard">
    Si vous créez votre API dans Auth0 Dashboard, Auth0 génère automatiquement une application de test et l’associe à votre API.

    1. Accédez à [Auth0 Dashboard > Applications](https://manage.auth0.com/#/applications).
    2. Sélectionnez l’application de test M2M créée lorsque vous avez créé votre API.

           <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
             Vous pourrez créer plus tard une autre application pour le développement ou la production en suivant les instructions de [Register Machine-to-Machine Applications](/fr-CA/docs/get-started/auth0-overview/create-applications/machine-to-machine-apps).
           </Callout>
    3. Passez à la vue **API**, puis repérez l’API que vous souhaitez activer pour cette application.
    4. Activez le bouton bascule **Authorize**, puis sélectionnez le bouton fléché à droite pour développer la carte.
    5. Sélectionnez **Update**.

           <Frame>
             <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=5dcceb517182aeb823127810b9d37eeb" alt="Dashboard > Applications > APIs" data-og-width="1002" width="1002" data-og-height="979" height="979" data-path="docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?w=280&fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=5bdacc9d22696263d397995f3e290bc7 280w, https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?w=560&fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=88c60c9895adeabea77c680acd91ace3 560w, https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?w=840&fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=fed5de9446f4d1e1031cb01f579915fe 840w, https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?w=1100&fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=1cb844cebe0c5e46915e034f0536893e 1100w, https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?w=1650&fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=654deb2045141c2e7ab907c33593e5e2 1650w, https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/6L2R46XVdYw1kifRfMifRz/87e3b9f75039d55af6028be0eb0598ac/Timesheets_API_-_English.png?w=2500&fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=84feca666adfd7e9fb5e153bfba1b504 2500w" />
           </Frame>

           <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
             Dans cette vue, vous pouvez utiliser la liste déroulante pour choisir les scopes à ajouter. Vous en apprendrez davantage sur les scopes lorsque nous aborderons les jetons d’accès dans la section Authentification.
           </Callout>
  </Tab>

  <Tab title="Management API">
    Créez une application à associer à votre API. Utilisez l’exemple fourni dans Management API Explorer pour :

    1. Appeler le point de terminaison [Create a Client](https://auth0.com/docs/api/management/v2/clients/post-clients). Vous devez définir `app_type` sur `non-interactive`.
    2. Appeler le point de terminaison [Create Client Grant](https://auth0.com/docs/api/management/v2/client-grants/post-client-grants) pour associer votre application à votre API.

    Pour en savoir plus sur les paramètres de l’application et du locataire, consultez [Paramètres du locataire](/fr-CA/docs/get-started/tenant-settings).
  </Tab>
</Tabs>

<div id="authentication">
  ## Authentification
</div>

Lorsque vous appelez une API à partir d’une autre API, ou dans toute situation où il n’existe aucun contexte d’utilisateur authentifié, vous devez disposer d’un moyen d’autoriser l’application plutôt qu’un utilisateur. Il s’agit d’un processus en une seule étape au cours duquel l’application est authentifiée (à l’aide d’un `client_id` et d’un `client_secret`), puis autorisée en un seul appel.

Pour authentifier des applications ou des services non interactifs, vous devez sélectionner une autorisation d’application, c’est-à-dire un flux d’authentification. Le <Tooltip tip="OAuth 2.0 : Cadre d’autorisation qui définit les protocoles et les flux de travail d’autorisation." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=OAuth+2.0">OAuth 2.0</Tooltip> [flux d’identification du client](https://tools.ietf.org/html/rfc6749#section-4.4) ne nécessite aucune interaction humaine et convient le mieux aux applications M2M.

<Card title="Avant de commencer">
  Dans Auth0 Dashboard ou Management API, vous allez :

  * Configurer votre application pour utiliser le flux d’identification du client
  * Mettre à jour les scopes de vos jetons d’accès M2M

  Avant de configurer votre méthode d’authentification :

  * Consultez le [flux d’identification du client](/fr-CA/docs/get-started/authentication-and-authorization-flow/client-credentials-flow) pour l’authentification machine à machine. Il s’agit du flux de travail utilisé pour l’authentification et l’autorisation non interactives.
  * Déterminez le niveau d’accès requis pour vos API. Cela vous aidera à déterminer quels [scopes](/fr-CA/docs/get-started/apis/scopes/api-scopes), ou autorisations, vous configurerez lorsque vous créerez votre API.
</Card>

<div id="configure-the-client-credential-flow">
  ### Configurer le flux Client Credentials
</div>

Vous pouvez utiliser Auth0 Dashboard ou <Tooltip tip="Management API : un produit qui permet aux clients d’effectuer des tâches administratives." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Management+API">Management API</Tooltip> pour configurer le flux d’authentification afin d’échanger les identifiants de l’application contre un jeton d’accès.

Suivez les instructions de [Mise à jour des types d’octroi](/fr-CA/docs/get-started/applications/update-grant-types) pour utiliser Auth0 Dashboard ou Management API.

<div id="m2m-access-tokens">
  ### Jetons d’accès M2M
</div>

Dans l’authentification basée sur des jetons, les applications non interactives fournissent `client_id` et `client_secret` lors d’un appel au [point de terminaison des jetons de l’Authentication API](/fr-CA/docs/customize/actions/explore-triggers/machine-to-machine-trigger) pour obtenir un [jeton d’accès](/fr-CA/docs/secure/tokens/access-tokens). Ce jeton d’accès permet d’accéder à votre API protégée.

Le profil, ou format, par défaut est le profil de jeton Auth0, qui est l’un des deux profils de jeton offerts. Vous pouvez choisir de le remplacer par le profil RFC 9068. Pour en savoir plus, consultez [Profils de jeton d’accès](/fr-CA/docs/secure/tokens/access-tokens/access-token-profiles). Pour vérifier que le jeton est valide, votre API vérifie les [algorithmes de signature](/fr-CA/docs/get-started/applications/signing-algorithms). L’<Tooltip tip="Algorithme de signature : algorithme utilisé pour signer numériquement les jetons afin de garantir qu’ils n’ont pas été altérés." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=signing+algorithm">algorithme de signature</Tooltip> par défaut est RSA256, un algorithme à clé.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Auth0 prend en charge d’autres méthodes d’authentification d’application que la fourniture de l’ID client et du Secret client comme identifiants. Ces méthodes, y compris notre recommandation d’utiliser [Private Key JWT](/fr-CA/docs/get-started/authentication-and-authorization-flow/authenticate-with-private-key-jwt) pour les configurations M2M, sont offertes avec un forfait Enterprise. Pour en savoir plus, consultez [Identifiants d’application](/fr-CA/docs/secure/application-credentials).
</Callout>

<div id="example">
  #### Exemple
</div>

Une requête envoyée au point de terminaison `/oauth/token` devrait ressembler à l’exemple ci-dessous :

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request POST \
    --url 'https://{yourDomain}/oauth/token' \
    --header 'content-type: application/x-www-form-urlencoded' \
    --data grant_type=client_credentials \
    --data client_id={yourClientId} \
    --data client_secret={yourClientSecret} \
    --data audience=YOUR_API_IDENTIFIER
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/oauth/token");
  var request = new RestRequest(Method.POST);
  request.AddHeader("content-type", "application/x-www-form-urlencoded");
  request.AddParameter("application/x-www-form-urlencoded", "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER", ParameterType.RequestBody);
  IRestResponse response = client.Execute(request);
  ```

  ```go Go theme={null}
  package main

  import (
  	"fmt"
  	"strings"
  	"net/http"
  	"io/ioutil"
  )

  func main() {

  	url := "https://{yourDomain}/oauth/token"

  	payload := strings.NewReader("grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER")

  	req, _ := http.NewRequest("POST", url, payload)

  	req.Header.Add("content-type", "application/x-www-form-urlencoded")

  	res, _ := http.DefaultClient.Do(req)

  	defer res.Body.Close()
  	body, _ := ioutil.ReadAll(res.Body)

  	fmt.Println(res)
  	fmt.Println(string(body))

  }
  ```

  ```java Java theme={null}
  HttpResponse response = Unirest.post("https://{yourDomain}/oauth/token")
    .header("content-type", "application/x-www-form-urlencoded")
    .body("grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER")
    .asString();
  ```

  ```javascript Node.JS theme={null}
  var axios = require("axios").default;

  var options = {
    method: 'POST',
    url: 'https://{yourDomain}/oauth/token',
    headers: {'content-type': 'application/x-www-form-urlencoded'},
    data: new URLSearchParams({
      grant_type: 'client_credentials',
      client_id: '{yourClientId}',
      client_secret: '{yourClientSecret}',
      audience: 'YOUR_API_IDENTIFIER'
    })
  };

  axios.request(options).then(function (response) {
    console.log(response.data);
  }).catch(function (error) {
    console.error(error);
  });
  ```

  ```php PHP theme={null}
  $curl = curl_init();

  curl_setopt_array($curl, [
    CURLOPT_URL => "https://{yourDomain}/oauth/token",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "POST",
    CURLOPT_POSTFIELDS => "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER",
    CURLOPT_HTTPHEADER => [
      "content-type: application/x-www-form-urlencoded"
    ],
  ]);

  $response = curl_exec($curl);
  $err = curl_error($curl);

  curl_close($curl);

  if ($err) {
    echo "cURL Error #:" . $err;
  } else {
    echo $response;
  }
  ```

  ```python Python theme={null}
  import http.client

  conn = http.client.HTTPSConnection("")

  payload = "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER"

  headers = { 'content-type': "application/x-www-form-urlencoded" }

  conn.request("POST", "/{yourDomain}/oauth/token", payload, headers)

  res = conn.getresponse()
  data = res.read()

  print(data.decode("utf-8"))
  ```

  ```ruby Ruby theme={null}
  require 'uri'
  require 'net/http'
  require 'openssl'

  url = URI("https://{yourDomain}/oauth/token")

  http = Net::HTTP.new(url.host, url.port)
  http.use_ssl = true
  http.verify_mode = OpenSSL::SSL::VERIFY_NONE

  request = Net::HTTP::Post.new(url)
  request["content-type"] = 'application/x-www-form-urlencoded'
  request.body = "grant_type=client_credentials&client_id={yourClientId}&client_secret={yourClientSecret}&audience=YOUR_API_IDENTIFIER"

  response = http.request(request)
  puts response.read_body
  ```
</AuthCodeGroup>

La réponse devrait ressembler à l’exemple ci-dessous :

```json lines theme={null}
HTTP/1.1 200 OK
Content-Type: application/json
{
  "access_token":"eyJz93a...k4laUWw",
  "token_type":"Bearer",
  "expires_in":86400
}
```

<div id="token-expiration">
  #### Expiration du jeton
</div>

Vos jetons d’accès ont une durée de validité limitée. Comme vos communications se font sur le canal serveur à serveur, vous ne pouvez pas utiliser les <Tooltip tip="Jeton d’actualisation : jeton utilisé pour obtenir un nouveau Jeton d’accès sans obliger les utilisateurs à se reconnecter." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=refresh+tokens">jetons d’actualisation</Tooltip> pour prolonger les sessions; vous devriez donc envisager de configurer vos jetons d’accès avec une durée d’expiration d’une heure. Vous devrez peut-être trouver le bon équilibre entre sécurité et performance pour votre environnement. Pour en savoir plus, consultez [Mettre à jour la durée de vie du jeton d’accès](/fr-CA/docs/secure/tokens/access-tokens/update-access-token-lifetime).

<div id="scopes">
  ### Scopes
</div>

Avant que des applications ou des services non interactifs appellent votre API, vous devez définir les autorisations, ou scopes, qu’autorise votre API. Vous pouvez définir dans Auth0 Dashboard les scopes à inclure dans votre requête d’authentification à l’Authentication API. Pour voir d’autres exemples d’utilisation des scopes d’API, consultez [API Scopes](/fr-CA/docs/get-started/apis/scopes/api-scopes).

Pour configurer les scopes, suivez les instructions de [Add API Permissions](/fr-CA/docs/get-started/apis/add-api-permissions) dans Auth0 Dashboard, ou utilisez l’exemple fourni pour Management API.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Pour ajouter des claims personnalisés à un jeton d’accès, vous pouvez utiliser le flux Machine-to-Machine d’Actions. Pour en savoir plus, consultez Machine to Machine Flow.
</Callout>

<div id="branding">
  ## Image de marque
</div>

Même si vous prenez en charge des applications non interactives ou des services qui fonctionnent en canal serveur à serveur, vous pouvez tout de même personnaliser l’expérience pour qu’elle corresponde à l’apparence et au style de votre image de marque existante.

<div id="custom-domains">
  ### Domaines personnalisés
</div>

Auth0 permet d’utiliser des domaines personnalisés lorsque vous appelez le point de terminaison `/authorize` pour demander des jetons d’accès.

<Card title="Mise en route M2M - domaines personnalisés">
  Dans Auth0 Dashboard, vous devez :

  * Enregistrer et vérifier votre domaine avant de pouvoir l’utiliser avec vos services Auth0.
  * Déterminer si vous souhaitez gérer votre propre certificat ou utiliser un certificat géré par Auth0. Pour en savoir plus sur les certificats, consultez [Options de gestion des certificats](/fr-CA/docs/customize/custom-domains#certificate-management-options).
  * Vérifier que la version de TLS (SSL) et la suite de chiffrement que vous souhaitez utiliser pour les certificats autogérés sont prises en charge par Auth0. Pour en savoir plus, consultez [Versions et suites de chiffrement TLS (SSL)](/fr-CA/docs/customize/custom-domains/self-managed-certificates/tls-ssl).
</Card>

1. Pour configurer votre domaine personnalisé avec des certificats gérés par Auth0, suivez les instructions de [Configurer des domaines personnalisés avec des certificats gérés par Auth0](/fr-CA/docs/customize/custom-domains/auth0-managed-certificates).

   1. Si vous souhaitez gérer vos propres certificats, suivez les instructions de [Configurer des domaines personnalisés avec des certificats autogérés](/fr-CA/docs/customize/custom-domains/self-managed-certificates).

      <Callout icon="file-lines" color="#0EA5E9" iconType="regular">
        Vous devez avoir un abonnement Enterprise pour gérer les certificats de votre domaine personnalisé. Pour en savoir plus, consultez [Tarification d’Auth0](https://auth0.com/pricing/) et [Login](/fr-CA/docs/authenticate/login).
      </Callout>
2. Consultez la [configuration de l’API avec des domaines personnalisés](/fr-CA/docs/customize/custom-domains/configure-features-to-use-custom-domains#apis). Vous devrez peut-être ajuster les paramètres de votre API pour tenir compte d’un domaine personnalisé.

<div id="deployment-automation">
  ## Automatisation du déploiement
</div>

Auth0 prend en charge plusieurs options d’automatisation du déploiement, et chacune peut être utilisée avec les autres.

<Card title="Bonne pratique">
  Quelle que soit la façon dont vous configurez l’automatisation du déploiement, nous vous recommandons d’effectuer des tests unitaires sur votre code personnalisé et vos Actions avant le déploiement, puis d’exécuter également des tests d’intégration sur votre locataire après le déploiement.
</Card>

<div id="deploy-cli-tool">
  ### Outil Deploy CLI
</div>

Comme recommandé dans la section Architecture, vous devriez avoir des locataires Auth0 pour le développement, les tests et la production. Ces locataires devraient avoir des configurations identiques pour les contrôles de qualité et les tests; toutefois, des écarts de configuration entre vos environnements peuvent entraîner des erreurs. Par exemple, chaque environnement aura des <Tooltip tip="ID client : Valeur d’identification attribuée à votre ressource enregistrée par Auth0." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Client+IDs">ID client</Tooltip> et des <Tooltip tip="ID client : Valeur d’identification attribuée à votre ressource enregistrée par Auth0." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Client+Secrets">Secrets client</Tooltip> différents.

Pour réduire ces erreurs liées aux écarts de configuration, vous pouvez utiliser l’outil Deploy CLI pour intégrer votre instance Auth0 à votre pipeline CI/CD existant. Grâce au remplacement dynamique de mots-clés, vous pouvez remplacer les variables d’environnement dans des locataires qui partagent des configurations semblables. Pour en savoir plus, consultez [l’outil Deploy CLI](/fr-CA/docs/deploy-monitor/deploy-cli-tool) et [le remplacement de mots-clés](/fr-CA/docs/deploy-monitor/deploy-cli-tool/keyword-replacement).

<div id="actions-real-time-logs">
  ### Actions Real-time Logs
</div>

Actions Real-time Logs affiche tous les journaux du code personnalisé en temps réel, y compris la sortie de `console.log` et les autres exceptions générées. Si vous utilisez Auth0 Actions ou une autre logique personnalisée, vous pouvez utiliser cette extension pour déboguer et résoudre les problèmes. Pour en savoir plus sur l’installation et la configuration, consultez [Actions Real-time Logs](/fr-CA/docs/customize/actions/actions-real-time-logs).

<div id="quality-assurance">
  ## Assurance qualité
</div>

L’assurance qualité est essentielle pour déceler les problèmes avant la mise en production. Selon la nature de votre projet, il existe plusieurs types de tests d’assurance qualité à envisager dans le cadre de votre intégration avec Auth0 :

* Comment vos API se comporteront-elles lorsqu’elles seront soumises à des charges de production imprévues ?
* Quel sera l’impact des applications tierces sur vos limites de débit ?

Si vous n’utilisez pas les widgets ni les fonctionnalités d’Auth0, comme <Tooltip tip="Universal Login : votre application redirige vers Universal Login, hébergé sur le serveur d’autorisation d’Auth0, afin de vérifier l’identité d’un utilisateur." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Universal+Login">Universal Login</Tooltip>, vous ne profiterez pas d’emblée des pratiques exemplaires intégrées en matière de convivialité et d’accessibilité sur un vaste éventail de navigateurs et d’appareils. Afin de garantir le respect des exigences fonctionnelles et la bonne gestion des événements imprévus, des conseils sont fournis pour tester l’intégration entre votre ou vos applications et Auth0, ainsi que pour effectuer des tests unitaires sur des modules d’extensibilité individuels, comme Auth0 Actions. Nous vous recommandons également de consulter la [stratégie relative aux tests d’intrusion](/fr-CA/docs/troubleshoot/customer-support/operational-policies/penetration-testing-policy) d’Auth0 et d’effectuer des tests simulés, en complément de notre [stratégie relative aux tests de charge](/fr-CA/docs/troubleshoot/customer-support/operational-policies/load-testing-policy), afin de vous aider à vous assurer que votre ou vos applications fonctionnent sous une charge imprévue.

<div id="unit-testing">
  ### Tests unitaires
</div>

Les tests unitaires servent à vérifier des éléments d’extensibilité, comme les Auth0 Actions. Si vous utilisez du code personnalisé, nous vous recommandons d’utiliser un framework de test (comme [Mocha](https://mochajs.org/)) pour tester ce code supplémentaire avant le déploiement.

<div id="mock-testing">
  ### Tests simulés
</div>

Pour concilier la [politique de tests de charge](/fr-CA/docs/troubleshoot/customer-support/operational-policies/load-testing-policy) d’Auth0 et le besoin d’effectuer des tests de charge, il est courant de simuler les points de terminaison d’Auth0. C’est une pratique utile pour vérifier que votre configuration fonctionne avec les interfaces attendues sans devoir limiter vos tests, et des outils comme [MockServer](http://www.mock-server.com/), [JSON Server](https://github.com/typicode/json-server) ou même [Postman](https://learning.getpostman.com/docs/postman/mock_servers/setting_up_mock/) peuvent vous y aider.

<div id="deployment">
  ## Déploiement
</div>

Notre section [Déployer et surveiller](/fr-CA/docs/deploy-monitor) fournit des conseils sur les pratiques exemplaires de déploiement. Nous vous recommandons de consulter les [Vérifications avant le déploiem](/fr-CA/docs/deploy-monitor/pre-deployment-checks)[ent](/fr-CA/docs/deploy-monitor/pre-deployment-checks), en particulier les [vérifications de préparation intégrées dans Auth0 Dashboard](/fr-CA/docs/deploy-monitor/pre-deployment-checks/how-to-run-production-checks).

Pour consulter la vérification de préparation, sélectionnez le menu déroulant sous le nom et l’étiquette d’environnement de votre locataire dans [Auth0 Dashboard > Exécuter les vérifications de préparation](https://manage.auth0.com/#/production-checks).

<Frame>
  <img src="https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=818c1928dd347f6f8231793e30a70041" alt="Auth0 Dashboard > Liste de vérification de préparation" data-og-width="1002" width="1002" data-og-height="730" height="730" data-path="docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png" data-optimize="true" data-opv="3" srcset="https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?w=280&fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=4f01becf68d0b11aa53991ee3058ae29 280w, https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?w=560&fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=58060672e08a237b4e58cc78d17f6ed7 560w, https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?w=840&fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=83bfdd6c132c0f0308582e51191602f0 840w, https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?w=1100&fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=3bd522d521dd84dc26e58f9b294c5e3e 1100w, https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?w=1650&fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=09c2f9d8d19fdd2799daa6ae67b3c8a8 1650w, https://mintcdn.com/translations/c0RQ9V0YAcT0-8l5/docs/images/cdy7uua7fh8z/7iu1CzH0NgaXJbLBNWXZli/b598b8cdaad0c676e83a0fb0595d4603/Readiness_Checks_-_English.png?w=2500&fit=max&auto=format&n=c0RQ9V0YAcT0-8l5&q=85&s=78272d1d6b0337a489eefb36719a0825 2500w" />
</Frame>

Vous pouvez utiliser le filtre pour appliquer les vérifications de préparation aux applications sélectionnées. **Ces vérifications ne s’appliquent pas aux API que vous avez configurées**.

Pour les vérifications qui ne s’appliquent pas à votre configuration particulière, vous pouvez sélectionner **Ignorer** pour les retirer des résultats finaux.

Nous vous recommandons de consulter les [pratiques exemplaires de déploiement](/fr-CA/docs/deploy-monitor/deployment-best-practices) pour effectuer les vérifications finales avant la mise en production et de tirer parti des [journaux](/fr-CA/docs/deploy-monitor/logs) pour surveiller vos services.

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

* [Présentation d’Auth0](/fr-CA/docs/get-started/auth0-overview)
* [Présentation de la solution (applications serveur + API)](/fr-CA/docs/get-started/architecture-scenarios/server-application-api/part-1)
* [Appelez votre API à l’aide du flux d’identification du client](/fr-CA/docs/get-started/authentication-and-authorization-flow/client-credentials-flow/call-your-api-using-the-client-credentials-flow)
* [Récupérer les événements de journal à l’aide de la Management API](/fr-CA/docs/deploy-monitor/logs/retrieve-log-events-using-mgmt-api)
* [Obtenir des jetons d’accès pour la Management API en production](/fr-CA/docs/secure/tokens/access-tokens/management-api-access-tokens/get-management-api-access-tokens-for-production)