> ## 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 Auth0 Dashboard o la Management API.
# Habilitar el control de acceso basado en roles para APIs
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 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 que los permisos también se incluyan 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, esos cambios reemplazarán los alcances establecidos por RBAC.
## Dashboard
1. Ve a [Dashboard > Applications > APIs](https://manage.auth0.com/#/apis) y haz clic en el nombre de la API que quieres consultar.
2. Desplázate hasta **RBAC Settings** y activa el interruptor **Enable RBAC**.
3. Para incluir todos los permisos asignados al usuario en el claim `permissions` del token de acceso, activa el interruptor **Add Permissions in the Access Token** y haz clic en **Save**. Incluir permisos en el token de acceso te permite reducir al mínimo las llamadas necesarias para recuperar permisos, pero aumenta el tamaño del token.
Una vez que actives el interruptor **Add Permissions in the Access Token**, Auth0 también actualiza el dialecto del token según el [perfil de token de acceso](/es/docs/secure/tokens/access-tokens/access-token-profiles) que hayas 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, consulta [Opciones de dialecto de token](#token-dialect-options).
## Management API
Para habilitar RBAC mediante la Management API, haga una solicitud PATCH al [endpoint para actualizar un servidor de recursos](https://auth0.com/docs/api/management/v2/resource-servers/patch-resource-servers-by-id). En la solicitud PATCH, establezca `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
```
Sustituya `API_ID`, `MGMT_API_ACCESS_TOKEN` y `TOKEN_DIALECT` por sus respectivos valores, 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 de 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 del 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, consulta [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. Permite hacer un número mínimo de 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 conforme al [IETF JWT Profile for 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, consulta [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. Permite hacer un número mínimo de 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 prácticos: control de acceso basado en roles](/es/docs/manage-users/access-control/sample-use-cases-role-based-access-control)