> ## Documentation Index
> Fetch the complete documentation index at: https://docs-dev-docs-event-stream-action-templates.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

# Configurer une API logique pour plusieurs API

> Comment utiliser une API logique unique dans Auth0 pour représenter et contrôler l’accès à plusieurs API.

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>;
};

export const codeExample = `https://{yourDomain}/authorize?
   scope=read:contacts%20read:calendar&
   audience=organize&
   response_type=id_token%20token&
   client_id={yourClientId}&
   redirect_uri=http://localhost:3000&
   nonce={nonce}
`;

Si vous avez plusieurs implémentations d’API distinctes qui font toutes logiquement partie de la même API, vous pouvez simplifier votre processus d’autorisation en les représentant avec une API logique unique dans <Tooltip href="/docs/fr-ca/glossary?term=auth0-dashboard" tip="Auth0 Dashboard
Principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire">Auth0 Dashboard</Tooltip>. Cela vous permet de mettre en œuvre un seul flux d’autorisation, tout en contrôlant l’accès aux API individuelles en leur attribuant les permissions appropriées.

Les sections suivantes décrivent comment utiliser et représenter plusieurs API en tant que serveur de ressources unique dans Auth0. Nous utiliserons l’exemple d’application suivant dans les exemples. L’exemple d’application utilise une architecture de microservices et contient :

* Deux API Node.js : `contacts` et `calendar` (à considérer comme microservices).
* Un serveur de ressources représentant les deux API.
* Deux permissions à espace de noms : `read:contacts` et `read:calendar`
* Le flux d’autorisation implicite pour obtenir un `access_token` qui fonctionne avec les deux API.

Nous représenterons les deux API à l’aide d’une seule API Auth0 appelée `Organizer Service`. Nous allons ensuite créer deux permissions pour démontrer comment vous pouvez utiliser le [flux implicite](/docs/fr-ca/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce) pour accéder aux API `calendar` et `contacts` à partir de l’application Web monopage.

Vous devez effectuer ce qui suit :

1. Activer une connexion pour votre application.
2. Créer un utilisateur de test.
3. Enregistrer une API logique dans Auth0.
4. Configurer des permissions pour l’API logique.
5. Accorder l’accès à l’API logique.
6. (Facultatif) Mettre en œuvre la déconnexion unique (SLO) ou l’authentification unique (SSO).

## Prérequis

* [Enregistrer votre application](/docs/fr-ca/get-started/auth0-overview/create-applications/single-page-web-apps).

  * Sélectionnez un **type d ’application** d’**application à page unique**.
  * Ajoutez les **Callback URL autorisées** de `http://localhost:3000` et `http://localhost:3000/callback.html`.
* Téléchargez l’ [exemple d’application](https://github.com/auth0-samples/auth0-api-auth-implicit-sample). Pour savoir comment configurer l’application d’exemple, consultez le fichier [README](https://github.com/auth0-samples/auth0-api-auth-implicit-sample#readme).

## Activer une connexion pour votre application.

Vous aurez besoin d’une source d’utilisateurs pour votre application nouvellement enregistrée, vous devrez donc configurer une [connexion](/docs/fr-ca/connections). Pour les besoins de cet exemple, nous allons créer une simple [connexion par base de données](/docs/fr-ca/connections/database) qui ne demande que l’adresse courriel et le mot de passe de l’utilisateur. Pour en savoir plus, consultez [Connexions par base de données](/docs/fr-ca/get-started/applications/set-up-database-connections).

## Créer un utilisateur de test.

Since you’re working with a newly-created connection, there won’t be any users associated with it. Before we can test the sample application’s login process, we’ll need to create and associate a user with the connection, so make sure you choose your newly-created Connection when you create your user. To learn more, read [Create Users](/docs/fr-ca/manage-users/user-accounts/create-users).

## Enregistrer une API logique dans Auth0.

Enregistrez une API logique unique que vous utiliserez pour représenter les multiples API contenues dans l’exemple d’application. Pour les besoins de cet exemple, appelez votre service `Organizer Service` et définissez son identifiant unique sur `organize`. Par défaut, l’algorithme de signature des jetons obtenus pour cette API est **RS256**, que vous devez laisser tel quel. Pour en savoir plus, lisez [Enregistrer les API](/docs/fr-ca/get-started/auth0-overview/set-up-apis).

## Configurer des autorisations pour l’API logique

Pour permettre à l’API logique de représenter les API incluses dans l’exemple d’application, vous devrez créer les autorisations appropriées ([permissions](/docs/fr-ca/get-started/apis/scopes/api-scopes)).

Les permissions vous permettent de définir les actions de l’API qui seront accessibles aux applications appelantes. Une permission représente une combinaison API/action. Dans le cadre de cet exemple, vous souhaitez que les applications appelantes puissent `read` les données d’une API appelée `calendar` et une autre appelée `contacts`, vous devez donc créer les autorisations suivantes :

* `read:calendar`
* `read:contacts`

Vous pouvez considérer chacune de ces API comme un microservice. Pour en savoir plus, lisez [Ajout de permissions API](/docs/fr-ca/get-started/apis/add-api-permissions) et [Permissions des API](/docs/fr-ca/get-started/apis/scopes/api-scopes).

## Accorder l’accès à l’API logique.

Vous êtes maintenant prêt à donner accès à vos API en permettant à l’API logique d’obtenir des jetons d’accès. En incluant les permissions nécessaires, vous pouvez contrôler l’accès d’une application aux API représentées par l’API logique. Les étapes suivantes utilisent le [flux implicite](/docs/fr-ca/get-started/authentication-and-authorization-flow/implicit-flow-with-form-post) pour illustrer l’exemple. Toutefois, vous pouvez utiliser le flux qui répond le mieux à vos besoins. Par exemple :

* Si vous avez une **Application de communication entre machines** , vous pouvez l’autoriser à demander des jetons d’accès à votre API en exécutant un [flux des identifiants client](/docs/fr-ca/get-started/authentication-and-authorization-flow/client-credentials-flow).
* Si vous créez une **application native**, utilisez le [Flux de code d’autorisation avec Proof Key for Code Exchange (PKCE)](/docs/fr-ca/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce).

Pour en savoir plus sur les flux d’autorisation, consultez [Flux d’authentification et d’autorisation](/docs/fr-ca/get-started/authentication-and-authorization-flow).

1. L’utilisateur clique sur Connexion dans l’application Web monopage, et l’application le redirige vers le serveur d’autorisation Auth0 (point de terminaison `/authorize`). Pour en savoir plus sur les paramètres de l’appel, consultez notre tutoriel : [Appeler votre API avec le flux de code d’autorisation avec PKCE](/docs/fr-ca/get-started/authentication-and-authorization-flow/authorization-code-flow-with-pkce/call-your-api-using-the-authorization-code-flow-with-pkce).

   <AuthCodeBlock children={codeExample} language="text" lines />

   <Frame>
     <img src="https://mintcdn.com/docs-dev-docs-event-stream-action-templates/i2ZmWeCuZRFq3k1v/docs/images/fr-ca/cdy7uua7fh8z/1ogYIaeDdyGL3Qo511m6Sh/5ab97c1535b2b62523a367594d44d66f/home.png?fit=max&auto=format&n=i2ZmWeCuZRFq3k1v&q=85&s=5ba1fc97d6d666510542eb5ad1d70008" alt="Example application sign in page" width="750" height="579" data-path="docs/images/fr-ca/cdy7uua7fh8z/1ogYIaeDdyGL3Qo511m6Sh/5ab97c1535b2b62523a367594d44d66f/home.png" />
   </Frame>

2. Votre serveur d’autorisation Auth0 redirige l’utilisateur vers la page de connexion, où l’utilisateur s’authentifie en utilisant l’une des options de connexion configurées.

   <Frame>
     <img src="https://mintcdn.com/docs-dev-docs-event-stream-action-templates/1giWs3MwX5Akld9c/docs/images/fr-ca/cdy7uua7fh8z/6z6aA5nfA1uwOyx8srhvvI/2435a0909cfe44a57bef3ff27ef24e5b/lock.png?fit=max&auto=format&n=1giWs3MwX5Akld9c&q=85&s=3e27b557605e8af9ef89cfc4e4a9636a" alt="Lock login page" width="750" height="579" data-path="docs/images/fr-ca/cdy7uua7fh8z/6z6aA5nfA1uwOyx8srhvvI/2435a0909cfe44a57bef3ff27ef24e5b/lock.png" />
   </Frame>

3. Si c’est la première fois que l’utilisateur passe par ce flux, il voit une invite de consentement listant les autorisatoins qu’Auth0 donnera à l’application Web monopage. Dans ce cas, on demande à l’utilisateur de donner son consentement pour que l’application puisse accéder à ses contacts et à son calendrier.

   <Frame>
     <img src="https://mintcdn.com/docs-dev-docs-event-stream-action-templates/i2ZmWeCuZRFq3k1v/docs/images/fr-ca/cdy7uua7fh8z/1te4FYRbu0aFcdohdXY2Rv/116bed5515eb2114c39374fb0a258912/consent-screen.png?fit=max&auto=format&n=i2ZmWeCuZRFq3k1v&q=85&s=d2b266af53dbcdb0dd15be0e0411ed92" alt="Example application Lock Consent screen" width="750" height="579" data-path="docs/images/fr-ca/cdy7uua7fh8z/1te4FYRbu0aFcdohdXY2Rv/116bed5515eb2114c39374fb0a258912/consent-screen.png" />
   </Frame>

4. Si l’utilisateur donne son accord, Auth0 le redirige vers l’application Web monopage avec des jetons dans le fragment de hachage de l’URI. L’application monopage peut alors extraire les jetons du fragment de hachage à l’aide de JavaScript et utiliser le jeton d’accès pour appeler vos API au nom de l’utilisateur.

   ```javascript lines theme={null}
   function getParameterByName(name) {
     var match = RegExp('[#&]' + name + '=([^&]*)').exec(window.location.hash);
     return match && decodeURIComponent(match[1].replace(/\+/g, ' '));
   }

   function getAccessToken() {
     return getParameterByName('access_token');
   }
   ```

Dans notre exemple, après avoir réussi à vous connecter, vous verrez des boutons qui vous permettront d’appeler l’une ou l’autre de vos API à l’aide du jeton d’accès obtenu auprès de l’API logique.

<Frame>
  <img src="https://mintcdn.com/docs-dev-docs-event-stream-action-templates/lVJB7tEBqNNqsQHu/docs/images/fr-ca/cdy7uua7fh8z/2pGWG5Wa7U1tBPhAJZ7Bat/7e194066560605cc842f20624b80d958/apis.png?fit=max&auto=format&n=lVJB7tEBqNNqsQHu&q=85&s=ed28bb95661e9a8266be1b1b885f8f8b" alt="Example application user authorized screen" width="750" height="579" data-path="docs/images/fr-ca/cdy7uua7fh8z/2pGWG5Wa7U1tBPhAJZ7Bat/7e194066560605cc842f20624b80d958/apis.png" />
</Frame>

### Mettre en œuvre la déconnexion unique (SLO) ou l’authentification unique (SSO).

Dans certains scénarios multi-applications où la déconnexion unique est souhaitée (c’est-à-dire qu’un utilisateur se déconnectant d’une application doit également être déconnecté des autres applications), une application peut être configurée pour interroger périodiquement Auth0 en utilisant `checkSession()` pour voir si une session existe. Si la session n’existe pas, vous pouvez alors déconnecter l’utilisateur de l’application. La même méthode d’interrogation peut être mise en place pour une authentification silencieuse dans un scénario d’authentification unique (<Tooltip href="/docs/fr-ca/glossary?term=single-sign-on" tip="Authentification unique (SSO)
Service qui, après qu’un utilisateur se soit connecté à une application, le connecte automatiquement à d’autres applications." cta="Voir le glossaire">SSO</Tooltip>).

L’intervalle d’interrogation entre les vérifications de `checkSession()` devrait être d’au moins 15 minutes entre chaque appel pour éviter tout problème ultérieur lié à la limite anti-attaques de cet appel.

## En savoir plus

* [Enregistrer les API](/docs/fr-ca/get-started/auth0-overview/set-up-apis)
* [Ajouter des autorisations API](/docs/fr-ca/get-started/apis/add-api-permissions)
* [Permissions des API](/docs/fr-ca/get-started/apis/scopes/api-scopes)
* [Vérifier les appels d’API](/docs/fr-ca/troubleshoot/authentication-issues/check-api-calls)