> ## Documentation Index
> Fetch the complete documentation index at: https://docs-dev-actions-triggers-prototype.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.
# Activer le contrôle d'accès basé sur les rôles (RBAC) pour les API
> Découvrez comment activer le contrôle d'accès basé sur les rôles (RBAC) pour une API à l’aide de Auth0 Dashboard ou de Management 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 {processedChildren};
};
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
{displayText}
;
};
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 Auth0 Dashboard ou de Management API. Cela permet d’activer l’ensemble de fonctionnalités de l’API Authorization Core.
Lorsque le RBAC est activé, la demande `scope` du jeton d’accès comprend une intersection des autorisations demandées et des autorisations attribuées à l’utilisateur, indépendamment des autorisations également incluses dans le jeton d’accès. Lorsque le RBAC est désactivé, une application peut demander n’importe quelle autorisation définie pour l’API, et la demande `scope` inclut toutes les autorisations demandées.
Si vous configurez des [Actions](/docs/fr-ca/customize/actions)
## Dashboard
1. Rendez-vous dans [Dashboard > Applications > APIs](https://manage.auth0.com/#/apis) et cliquez sur le nom de l’API pour l’afficher.
2. Faites défiler jusqu’aux **RBAC Settings (Paramètres RBAC)** et activez la bascule **Enable RBAC (Activer RBAC)**.
3. Pour inclure toutes les autorisations attribuées à l’utilisateur dans la demande `permissions` du jeton d’accès, activez la bascule **Add Permissions in the Access Token (Ajouter des autorisations au jeton d’accès)**, puis cliquez sur **Save (Enregistrer)**. Inclure les autorisations dans le jeton d’accès vous permet de faire peu d’appels pour récupérer les autorisations, mais augmente la taille du jeton.
Une fois que vous avez activé la bascule **Add Permissions in the Access Token (Ajouter des autorisations au jeton d’accès)**, Auth0 met également à jour le dialecte de votre jeton en fonction du [access token profile](/docs/fr-ca/secure/tokens/access-tokens/access-token-profiles) que vous avez défini pour l’API :
* Si le dialecte de votre token est `access_token`, Auth0 le met à jour en `access_token_authz`, ce qui équivaut à `access_token` avec la demande `permissions` incluse.
* Si le dialecte de votre jeton est `rfc9068_profile`, Auth0 le met à jour en`rfc9068_profile_authz`, ce qui équivaut à `rfc9068_profile` avec la demande `permissions` incluse.
Pour en savoir plus sur les dialectes de jetons disponibles, consultez [Options de dialecte des jetons](#token-dialect-options).
## Management API
Pour activer le RBAC à l’aide de Management API, envoyez une requête PATCH au point de terminaison [Update a resource server (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` sur `true` :
```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 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);
});
```
```objc Obj-C theme={null}
#import
NSDictionary *headers = @{ @"content-type": @"application/json",
@"authorization": @"Bearer MGMT_API_ACCESS_TOKEN",
@"cache-control": @"no-cache" };
NSDictionary *parameters = @{ @"enforce_policies": @"true",
@"token_dialect": @"TOKEN_DIALECT" };
NSData *postData = [NSJSONSerialization dataWithJSONObject:parameters options:0 error:nil];
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://{yourDomain}/api/v2/resource-servers/API_ID"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"PATCH"];
[request setAllHTTPHeaderFields:headers];
[request setHTTPBody:postData];
NSURLSession *session = [NSURLSession sharedSession];
NSURLSessionDataTask *dataTask = [session dataTaskWithRequest:request
completionHandler:^(NSData *data, NSURLResponse *response, NSError *error) {
if (error) {
NSLog(@"%@", error);
} else {
NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;
NSLog(@"%@", httpResponse);
}
}];
[dataTask resume];
```
```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_NONE
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
```
```swift Swift theme={null}
import Foundation
let headers = [
"content-type": "application/json",
"authorization": "Bearer MGMT_API_ACCESS_TOKEN",
"cache-control": "no-cache"
]
let parameters = [
"enforce_policies": "true",
"token_dialect": "TOKEN_DIALECT"
] as [String : Any]
let postData = JSONSerialization.data(withJSONObject: parameters, options: [])
let request = NSMutableURLRequest(url: NSURL(string: "https://{yourDomain}/api/v2/resource-servers/API_ID")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "PATCH"
request.allHTTPHeaderFields = headers
request.httpBody = postData as Data
let session = URLSession.shared
let dataTask = session.dataTask(with: request as URLRequest, completionHandler: { (data, response, error) -> Void in
if (error != nil) {
print(error)
} else {
let httpResponse = response as? HTTPURLResponse
print(httpResponse)
}
})
dataTask.resume()
```
Remplacez les valeurs `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 Management API](https://auth0.com/docs/api/management/v2/tokens) avec la permission `update:resource_servers`. |
| `TOKEN_DIALECT` | Dialecte du jeton d’accès pour l’API indiquée. Pour en savoir plus, consultez [Options du dialecte des jetons](#token-dialect-options). |
### Options de dialecte des jetons
Auth0 prend en charge les dialectes des jetons suivants :
| Valeur | Description |
| --------------------------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `access_token` | Le jeton Auth0 par défaut génère un jeton d’accès au format [Jeton Web JSON (JWT)](/docs/fr-ca/secure/tokens/json-web-tokens). Une intersection des autorisations demandées et des autorisations attribuées à l’utilisateur est incluse dans la demande « scope » du jeton d’accès. Aucune demande `permissions` n’est transmise. Pour en savoir plus, consultez [Profils de jeton d’accès](/docs/fr-ca/secure/tokens/access-tokens/access-token-profiles). |
| `access_token_authz` | Le profil de jeton Auth0 par défaut (`access_token`) avec la demande `scope`. Une intersection des autorisations demandées et des autorisations attribuées à l’utilisateur est incluse dans la demande `scope` du jeton d’accès. Toutes les autorisations attribuées à l’utilisateur sont incluses dans la demande `permissions` du jeton d’accès. Cela vous permet de faire des appels minimaux pour récupérer les autorisations, tout en augmentant la taille du jeton. |
| `rfc9068_profile` | Le profil de jeton RFC 9068 génère un jeton d’accès au format JWT suivant la page [Profil JWT IETF pour les jetons d’accès OAuth 2.0 (RFC 9068)](https://datatracker.ietf.org/doc/html/rfc9068). Une intersection des autorisations demandées et des autorisations attribuées à l’utilisateur est incluse dans la demande `scope` du jeton d’accès. Aucune demande `permissions` n’est transmise. Pour en savoir plus, consultez [Profils de jeton 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 demande `permissions`. Une intersection des autorisations demandées et des autorisations attribuées à l’utilisateur est incluse dans la demande `scope` du jeton d’accès. Toutes les autorisations attribuées à l’utilisateur sont incluess dans la demande `permissions` du jeton d’accès. Cela vous permet de faire des appels minimaux pour récupérer les autorisations, tout en augmentant la taille du jeton. |
## En savoir plus
* [Gérer les utilisateurs du contrôle d'accès basé sur les rôles (RBAC)](/docs/fr-ca/manage-users/access-control/configure-core-rbac/rbac-users)
* [Gérer les permissions du contrôle d'accès basé sur les rôles (RBAC)](/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 (RBAC)](/docs/fr-ca/manage-users/access-control/sample-use-cases-role-based-access-control)
* [Dépannage du contrôle d’accès et de l’autorisation basés sur les rôles](/docs/fr-ca/troubleshoot/authentication-issues/troubleshoot-rbac-authorization)