> ## 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.
> Aprenda a habilitar el control de acceso basado en roles (RBAC) para una API mediante el Auth0 Dashboard o la Management API.
# Habilitar el control de acceso basado en roles para las 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) + "*****ENMASCARADO*****";
}
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}
;
};
Puede habilitar el [control de acceso basado en roles (RBAC)](/es/docs/manage-users/access-control/rbac) mediante el Auth0 Dashboard o la Management API. Esto habilita el conjunto de funciones de Authorization Core para la API.
Cuando RBAC está habilitado, el claim `scope` del token de acceso incluye la intersección entre los permisos solicitados y los permisos asignados al usuario, independientemente de si los permisos también se incluyen en el token de acceso. Cuando RBAC está deshabilitado, una aplicación puede solicitar cualquier permiso definido para la API, y el claim `scope` incluye todos los permisos solicitados.
Si configura [Actions](/es/docs/customize/actions) que modifiquen los alcances del token de acceso, estos reemplazarán los alcances establecidos por RBAC.
## Dashboard
1. Vaya a [Dashboard > Applications > APIs](https://manage.auth0.com/#/apis) y haga clic en el nombre de la API para verla.
2. Desplácese hasta **RBAC Settings** y active el interruptor **Enable RBAC**.
3. Para incluir todos los permisos asignados al usuario en el claim `permissions` del token de acceso, active el interruptor **Add Permissions in the Access Token** y haga clic en **Save**. Incluir permisos en el token de acceso le permite hacer menos llamadas para recuperar permisos, pero aumenta el tamaño del token.
Una vez que active el interruptor **Add Permissions in the Access Token**, Auth0 también actualizará el dialecto del token según el [perfil del token de acceso](/es/docs/secure/tokens/access-tokens/access-token-profiles) que haya configurado para la API:
* Si el dialecto del token es `access_token`, Auth0 lo actualiza a `access_token_authz`, que equivale al perfil `access_token` con el claim `permissions` incluido.
* Si el dialecto del token es `rfc9068_profile`, Auth0 lo actualiza a `rfc9068_profile_authz`, que equivale a `rfc9068_profile` con el claim `permissions` incluido.
Para obtener más información sobre los dialectos de token disponibles, consulte [Opciones de dialecto del token](#token-dialect-options).
## Management API
Para habilitar RBAC con la Management API, haz una solicitud PATCH al [endpoint Actualizar un servidor de recursos](https://auth0.com/docs/api/management/v2/resource-servers/patch-resource-servers-by-id). En la solicitud PATCH, establece `enforce_policies` en `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);
});
```
```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
```
Reemplace `API_ID`, `MGMT_API_ACCESS_TOKEN` y `TOKEN_DIALECT` por sus valores correspondientes, como se muestra en la siguiente tabla:
| Parámetro | Descripción |
| ----------------------- | ------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `API_ID` | ID de la API para la que desea habilitar RBAC. |
| `MGMT_API_ACCESS_TOKEN` | [Token de acceso para la Management API](https://auth0.com/docs/api/management/v2/tokens) con el scope `update:resource_servers`. |
| `TOKEN_DIALECT` | Dialecto del token de acceso para la API especificada. Para obtener más información, consulte [Opciones de dialecto del token](#token-dialect-options). |
### Opciones de dialecto del token
Auth0 admite los siguientes dialectos de token:
| Valor | Descripción |
| ----------------------- | ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
| `access_token` | El perfil de token predeterminado de Auth0 genera un token de acceso con formato de [JSON Web Token (JWT)](/es/docs/secure/tokens/json-web-tokens). En el claim `scope` del token de acceso, incluye la intersección entre los permisos solicitados y los permisos asignados al usuario. No se incluye ningún claim `permissions`. Para obtener más información, consulte [Access Token Profiles](/es/docs/secure/tokens/access-tokens/access-token-profiles). |
| `access_token_authz` | El perfil de token predeterminado de Auth0 (`access_token`) con el claim `permissions`. En el claim `scope` del token de acceso, incluye la intersección entre los permisos solicitados y los permisos asignados al usuario. En el claim `permissions` del token de acceso, incluye todos los permisos asignados al usuario. Le permite realizar menos llamadas para recuperar permisos, pero aumenta el tamaño del token. |
| `rfc9068_profile` | El perfil de token RFC 9068 genera un token de acceso con formato JWT siguiendo el [perfil JWT de IETF para OAuth 2.0 Access Tokens (RFC 9068)](https://datatracker.ietf.org/doc/html/rfc9068). En el claim `scope` del token de acceso, incluye la intersección entre los permisos solicitados y los permisos asignados al usuario. No se incluye ningún claim `permissions`. Para obtener más información, consulte [Access Token Profiles](/es/docs/secure/tokens/access-tokens/access-token-profiles). |
| `rfc9068_profile_authz` | El perfil de token RFC 9068 (`rfc9068_profile`) con el claim `permissions`. En el claim `scope` del token de acceso, incluye la intersección entre los permisos solicitados y los permisos asignados al usuario. En el claim `permissions` del token de acceso, incluye todos los permisos asignados al usuario. Le permite realizar menos llamadas para recuperar permisos, pero aumenta el tamaño del token. |
## Más información
* [Administrar usuarios del control de acceso basado en roles](/es/docs/manage-users/access-control/configure-core-rbac/rbac-users)
* [Administrar permisos del control de acceso basado en roles](/es/docs/manage-users/access-control/configure-core-rbac/manage-permissions)
* [Casos de uso de ejemplo: control de acceso basado en roles](/es/docs/manage-users/access-control/sample-use-cases-role-based-access-control)