> ## 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écouvrez comment activer le contrôle d’accès basé sur les rôles (RBAC) pour une API à l’aide de l’Auth0 Dashboard ou de la Management API.

# Activer le contrôle d’accès basé sur les rôles pour les API

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

Vous pouvez activer le [contrôle d’accès basé sur les rôles (RBAC)](/docs/fr-ca/manage-users/access-control/rbac) à l’aide de l’<Tooltip tip="Auth0 Dashboard : principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip> ou de la <Tooltip tip="Auth0 Dashboard : principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Management+API">Management API</Tooltip>. Cela active l’ensemble de fonctionnalités Authorization Core de l’API.

Lorsque RBAC est activé, la claim `scope` du <Tooltip tip="Jeton d’accès : information d’identification 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="/docs/fr-ca/glossary?term=access+token">jeton d’accès</Tooltip> contient l’intersection entre les permissions demandées et les permissions attribuées à l’utilisateur, que des permissions soient ou non également incluses dans le jeton d’accès. Lorsque RBAC est désactivé, une application peut demander n’importe quelle permission définie pour l’API, et la claim `scope` contient toutes les permissions demandées.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Si vous configurez des [Actions](/docs/fr-ca/customize/actions) qui modifient les scopes du jeton d’accès, elles remplaceront les scopes définis par RBAC.
</Callout>

<div id="dashboard">
  ## Dashboard
</div>

1. Allez à [Dashboard > Applications > APIs](https://manage.auth0.com/#/apis), puis cliquez sur le nom de l’API à afficher.

   <Frame>
     <img src="https://mintcdn.com/translations/3nS3prIggmJG9TUI/docs/images/cdy7uua7fh8z/3rhmhghYZDSi6YWHRA5yMQ/c71340259481b0b6787d5f3887cfda0f/dashboard-apis-list.png?fit=max&auto=format&n=3nS3prIggmJG9TUI&q=85&s=2e2b2011e06ce0bae2558b5edfd56667" alt="Liste des API dans Dashboard Applications APIs" width="1478" height="562" data-path="docs/images/cdy7uua7fh8z/3rhmhghYZDSi6YWHRA5yMQ/c71340259481b0b6787d5f3887cfda0f/dashboard-apis-list.png" />
   </Frame>
2. Faites défiler jusqu’à **RBAC Settings** et activez la bascule **Enable RBAC**.

   <Frame>
     <img src="https://mintcdn.com/translations/6GE5Z24GDCZehiJ9/docs/images/cdy7uua7fh8z/65tKb6aj0ktc2qXLUVlV3e/641adef615d6af9e5a3b588ff397af87/dashboard-apis-edit_view-settings_rbac-settings.png?fit=max&auto=format&n=6GE5Z24GDCZehiJ9&q=85&s=eb1461b7d34e7acb830b90a0c8f77619" alt="bascule RBAC des paramètres d’API dans Auth0 Dashboard" width="1200" height="408" data-path="docs/images/cdy7uua7fh8z/65tKb6aj0ktc2qXLUVlV3e/641adef615d6af9e5a3b588ff397af87/dashboard-apis-edit_view-settings_rbac-settings.png" />
   </Frame>
3. Pour inclure toutes les permissions attribuées à l’utilisateur dans la claim `permissions` du jeton d’accès, activez la bascule **Add Permissions in the Access Token**, puis cliquez sur **Save**. L’inclusion des permissions dans le jeton d’accès vous permet de réduire au minimum le nombre de requêtes nécessaires pour récupérer les permissions, mais augmente la taille du jeton.
   Une fois la bascule **Add Permissions in the Access Token** activée, Auth0 met également à jour votre dialecte de jeton en fonction du [profil de jeton d’accès](/docs/fr-ca/secure/tokens/access-tokens/access-token-profiles) que vous avez défini pour l’API :

   * Si votre dialecte de jeton est `access_token`, Auth0 le met à jour vers `access_token_authz`, ce qui équivaut au profil `access_token` avec la claim `permissions` incluse.
   * Si votre dialecte de jeton est `rfc9068_profile`, Auth0 le met à jour vers `rfc9068_profile_authz`, ce qui équivaut à `rfc9068_profile` avec la claim `permissions` incluse.

   Pour en savoir plus sur les dialectes de jeton disponibles, consultez [Options de dialecte de jeton](#token-dialect-options).

<div id="management-api">
  ## Management API
</div>

Pour activer le RBAC à l’aide de la Management API, envoyez une requête PATCH au [point de terminaison « Mettre à jour un serveur de ressources »](https://auth0.com/docs/api/management/v2/resource-servers/patch-resource-servers-by-id). Dans la requête PATCH, définissez `enforce_policies` à `true` :

<AuthCodeGroup>
  ```bash cURL theme={null}
  curl --request PATCH \
    --url 'https://{yourDomain}/api/v2/resource-servers/API_ID' \
    --header 'authorization: Bearer MGMT_API_ACCESS_TOKEN' \
    --header 'cache-control: no-cache' \
    --header 'content-type: application/json' \
    --data '{ "enforce_policies": "true", "token_dialect": "TOKEN_DIALECT" }'
  ```

  ```csharp C# theme={null}
  var client = new RestClient("https://{yourDomain}/api/v2/resource-servers/API_ID");
  var request = new RestRequest(Method.PATCH);
  request.AddHeader("content-type", "application/json");
  request.AddHeader("authorization", "Bearer MGMT_API_ACCESS_TOKEN");
  request.AddHeader("cache-control", "no-cache");
  request.AddParameter("application/json", "{ "enforce_policies": "true", "token_dialect": "TOKEN_DIALECT" }", 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}/api/v2/resource-servers/API_ID"

  	payload := strings.NewReader("{ "enforce_policies": "true", "token_dialect": "TOKEN_DIALECT" }")

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

  	req.Header.Add("content-type", "application/json")
  	req.Header.Add("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
  	req.Header.Add("cache-control", "no-cache")

  	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<String> response = Unirest.patch("https://{yourDomain}/api/v2/resource-servers/API_ID")
    .header("content-type", "application/json")
    .header("authorization", "Bearer MGMT_API_ACCESS_TOKEN")
    .header("cache-control", "no-cache")
    .body("{ "enforce_policies": "true", "token_dialect": "TOKEN_DIALECT" }")
    .asString();
  ```

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

  var options = {
    method: 'PATCH',
    url: 'https://{yourDomain}/api/v2/resource-servers/API_ID',
    headers: {
      'content-type': 'application/json',
      authorization: 'Bearer MGMT_API_ACCESS_TOKEN',
      'cache-control': 'no-cache'
    },
    data: {enforce_policies: 'true', token_dialect: 'TOKEN_DIALECT'}
  };

  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}/api/v2/resource-servers/API_ID",
    CURLOPT_RETURNTRANSFER => true,
    CURLOPT_ENCODING => "",
    CURLOPT_MAXREDIRS => 10,
    CURLOPT_TIMEOUT => 30,
    CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
    CURLOPT_CUSTOMREQUEST => "PATCH",
    CURLOPT_POSTFIELDS => "{ "enforce_policies": "true", "token_dialect": "TOKEN_DIALECT" }",
    CURLOPT_HTTPHEADER => [
      "authorization: Bearer MGMT_API_ACCESS_TOKEN",
      "cache-control: no-cache",
      "content-type: application/json"
    ],
  ]);

  $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 = "{ "enforce_policies": "true", "token_dialect": "TOKEN_DIALECT" }"

  headers = {
      'content-type': "application/json",
      'authorization': "Bearer MGMT_API_ACCESS_TOKEN",
      'cache-control': "no-cache"
      }

  conn.request("PATCH", "/{yourDomain}/api/v2/resource-servers/API_ID", 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}/api/v2/resource-servers/API_ID")

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

  request = Net::HTTP::Patch.new(url)
  request["content-type"] = 'application/json'
  request["authorization"] = 'Bearer MGMT_API_ACCESS_TOKEN'
  request["cache-control"] = 'no-cache'
  request.body = "{ "enforce_policies": "true", "token_dialect": "TOKEN_DIALECT" }"

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

Remplacez `API_ID`, `MGMT_API_ACCESS_TOKEN` et `TOKEN_DIALECT` par leurs valeurs respectives, comme indiqué dans le tableau suivant :

| Paramètre               | Description                                                                                                                           |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------- |
| `API_ID`                | ID de l’API pour laquelle vous souhaitez activer RBAC.                                                                                |
| `MGMT_API_ACCESS_TOKEN` | [Jeton d’accès pour la Management API](https://auth0.com/docs/api/management/v2/tokens) avec le scope `update:resource_servers`.      |
| `TOKEN_DIALECT`         | Dialecte du jeton d’accès pour l’API indiquée. Pour en savoir plus, consultez [Options de dialecte de jeton](#token-dialect-options). |

<div id="token-dialect-options">
  ### Options de dialecte de jeton
</div>

Auth0 prend en charge les dialectes de jeton suivants :

| Valeur                  | Description                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                     |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `access_token`          | Le profil de jeton par défaut d’Auth0 génère un jeton d’accès sous la forme d’un [JSON Web Token (JWT)](/docs/fr-ca/secure/tokens/json-web-tokens). Dans la claim `scope` du jeton d’accès, il inclut l’intersection des permissions demandées et des permissions attribuées à l’utilisateur. Aucune claim `permissions` n’est transmise. Pour en savoir plus, consultez [Profils de jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/access-token-profiles).                                                            |
| `access_token_authz`    | Le profil de jeton par défaut d’Auth0 (`access_token`) avec la claim `permissions`. Dans la claim `scope` du jeton d’accès, il inclut l’intersection des permissions demandées et des permissions attribuées à l’utilisateur. Dans la claim `permissions` du jeton d’accès, il inclut toutes les permissions attribuées à l’utilisateur. Ce profil permet de réduire au minimum les requêtes nécessaires pour récupérer les permissions, mais augmente la taille du jeton.                                                      |
| `rfc9068_profile`       | Le profil de jeton RFC 9068 génère un jeton d’accès sous la forme d’un JWT conformément au [profil JWT de l’IETF pour les jetons d’accès OAuth 2.0 (RFC 9068)](https://datatracker.ietf.org/doc/html/rfc9068). Dans la claim `scope` du jeton d’accès, il inclut l’intersection des permissions demandées et des permissions attribuées à l’utilisateur. Aucune claim `permissions` n’est transmise. Pour en savoir plus, consultez [Profils de jetons d’accès](/docs/fr-ca/secure/tokens/access-tokens/access-token-profiles). |
| `rfc9068_profile_authz` | Le profil de jeton RFC 9068 (`rfc9068_profile`) avec la claim `permissions`. Dans la claim `scope` du jeton d’accès, il inclut l’intersection des permissions demandées et des permissions attribuées à l’utilisateur. Dans la claim `permissions` du jeton d’accès, il inclut toutes les permissions attribuées à l’utilisateur. Ce profil permet de réduire au minimum les requêtes nécessaires pour récupérer les permissions, mais augmente la taille du jeton.                                                             |

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

* [Gérer les utilisateurs du contrôle d’accès basé sur les rôles](/docs/fr-ca/manage-users/access-control/configure-core-rbac/rbac-users)
* [Gérer les autorisations du contrôle d’accès basé sur les rôles](/docs/fr-ca/manage-users/access-control/configure-core-rbac/manage-permissions)
* [Exemples de cas d’utilisation : contrôle d’accès basé sur les rôles](/docs/fr-ca/manage-users/access-control/sample-use-cases-role-based-access-control)