Regístrate para obtener una{" "}
cuenta de Auth0
{" "}
o{" "}
console.log("log in")}>
inicia sesión
{" "}
en tu cuenta existente para integrarte directamente con tu propio tenant.
;
};
export const sections = [{
id: "prerequisites",
title: "Requisitos previos"
}, {
id: "request-device-code",
title: "Solicitar code de dispositivo"
}, {
id: "receive-device-code",
title: "Recibir el code de dispositivo"
}, {
id: "request-device-activation",
title: "Solicitar la activación del dispositivo"
}, {
id: "poll-the-token-endpoint",
title: "Consultar periódicamente el endpoint de token"
}, {
id: "user-authorization",
title: "Autorización del usuario"
}, {
id: "receive-tokens",
title: "Recibir tokens"
}, {
id: "call-your-api",
title: "Llamar a tu API"
}, {
id: "refresh-tokens",
title: "Actualizar tokens"
}, {
id: "troubleshooting",
title: "Solución de problemas"
}, {
id: "sample-implementations",
title: "Implementaciones de ejemplo"
}, {
id: "limitations",
title: "Limitaciones"
}];
Este tutorial muestra cómo llamar a tu API desde un dispositivo con entrada restringida mediante el Flujo de Autorización de Dispositivos. Te recomendamos que inicies sesión para
seguir este inicio rápido con ejemplos configurados para tu cuenta.
Para una experiencia interactiva, puede utilizar el [entorno de pruebas de Device Flow](https://auth0.github.io/device-flow-playground/).
* Registre una aplicación nativa.
* Asegúrese de que el interruptor **Conforme con OIDC** esté habilitado. Para obtener más información, consulte Autenticación conforme con OIDC.
* Agregue **Código de dispositivo** a los tipos de concesión de la aplicación. Para obtener más información, consulte Actualizar tipos de concesión.
* Agregue **Token de actualización** a los tipos de concesión de la aplicación si desea habilitar los tokens de actualización.
* Configure y habilite al menos una conexión para la
aplicación.
* Registre su API en Auth0.
* Habilite **Permitir acceso sin conexión** si usa tokens de actualización. Para obtener más información, consulte Configuración de la API.
* Configure los ajustes del código de usuario del dispositivo para definir el
conjunto de caracteres, el formato y la longitud del código de usuario generado aleatoriamente.
Cuando el usuario inicia la aplicación del dispositivo y desea autorizarla, su aplicación debe solicitar un code de dispositivo a la Authentication API de Auth0 para asociarlo con la sesión del usuario.
Para obtener el código de dispositivo, su aplicación debe llamar al [Authorize endpoint](https://auth0.com/docs/api/authentication#-post-oauth-device-code-) del flujo de autorización de dispositivos de la API de autenticación:
```bash cURL lines theme={null}
curl --request post \
--url 'https://{yourDomain}/oauth/device/code' \
--header 'content-type: application/x-www-form-urlencoded'
```
```csharp C# lines theme={null}
var client = new RestClient("https://{yourDomain}/oauth/device/code");
var request = new RestRequest(Method.POST);
request.AddHeader("content-type", "application/x-www-form-urlencoded");
IRestResponse response = client.Execute(request);
```
```go Go lines theme={null}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "https://{yourDomain}/oauth/device/code"
req, _ := http.NewRequest("post", url, nil)
req.Header.Add("content-type", "application/x-www-form-urlencoded")
res, _ := http.DefaultClient.Do(req)
defer res.Body.Close()
body, _ := ioutil.ReadAll(res.Body)
fmt.Println(res)
fmt.Println(string(body))
}
```
```java Java lines theme={null}
HttpResponse response = Unirest.post("https://{yourDomain}/oauth/device/code")
.header("content-type", "application/x-www-form-urlencoded")
.asString();
```
```javascript Node.JS lines theme={null}
var axios = require("axios").default;
var options = {
method: 'post',
url: 'https://{yourDomain}/oauth/device/code',
headers: {'content-type': 'application/x-www-form-urlencoded'}
};
axios.request(options).then(function (response) {
console.log(response.data);
}).catch(function (error) {
console.error(error);
});
```
```objc Obj-C lines theme={null}
#import
NSDictionary *headers = @{ @"content-type": @"application/x-www-form-urlencoded" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"https://{yourDomain}/oauth/device/code"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"post"];
[request setAllHTTPHeaderFields:headers];
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 lines theme={null}
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => "https://{yourDomain}/oauth/device/code",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "post",
CURLOPT_HTTPHEADER => [
"content-type: application/x-www-form-urlencoded"
],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}
```
```python Python lines theme={null}
import http.client
conn = http.client.HTTPSConnection("")
headers = { 'content-type': "application/x-www-form-urlencoded" }
conn.request("post", "/{yourDomain}/oauth/device/code", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```ruby Ruby lines theme={null}
require 'uri'
require 'net/http'
require 'openssl'
url = URI("https://{yourDomain}/oauth/device/code")
http = Net::HTTP.new(url.host, url.port)
http.use_ssl = true
http.verify_mode = OpenSSL::SSL::VERIFY_NONE
request = Net::HTTP::Post.new(url)
request["content-type"] = 'application/x-www-form-urlencoded'
response = http.request(request)
puts response.read_body
```
```swift Swift lines theme={null}
import Foundation
let headers = ["content-type": "application/x-www-form-urlencoded"]
let request = NSMutableURLRequest(url: NSURL(string: "https://{yourDomain}/oauth/device/code")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "post"
request.allHTTPHeaderFields = headers
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()
```
La aplicación del dispositivo debería recibir una respuesta HTTP 200 y una carga útil similar a esta:
```json lines theme={null}
{
"device_code": "GmRh...k9eS",
"user_code": "WDJB-MJHT",
"verification_uri": "https://my-tenant.auth0.com/device",
"verification_uri_complete": "https://my-tenant.auth0.com/device?user_code=WDJB-MJHT",
"expires_in": 900,
"interval": 5
}
```
Después de que la aplicación del dispositivo reciba `device_code` y `user_code`, debe
indicarle al usuario que vaya a `verification_uri` e introduzca `user_code`.
`device_code` no está pensado para el usuario y no debe mostrarse durante
la interacción para evitar confundirlo.
Al crear una CLI, puede omitir este paso y abrir inmediatamente el navegador con
`verification_uri_complete`.
Mientras la aplicación de su dispositivo espera a que el usuario la active, debe llamar de forma intermitente al [endpoint POST /oauth/token de la API de autenticación](https://auth0.com/docs/api/authentication#-post-oauth-token-)
y gestionar la respuesta adecuadamente.
Asegúrese de que la aplicación de su dispositivo espere la duración de `interval` (en segundos) o hasta
que reciba una respuesta exitosa, lo que sea mayor, para evitar problemas de latencia de red.
```bash theme={null}
curl --request POST \
--url 'https://{yourDomain}/oauth/token' \
--header 'content-type: application/x-www-form-urlencoded' \
--data grant_type=urn:ietf:params:oauth:grant-type:device_code \
--data device_code=AUTH0_SCOPES \
--data 'client_id={yourClientId}'
```
El usuario escaneará el código QR o bien abrirá la página de activación e introducirá el code de usuario:
Se mostrará una página de confirmación para que el usuario confirme que se trata del dispositivo correcto:
El usuario completará la transacción iniciando sesión. Este paso puede incluir uno o varios de los siguientes
procesos:
* Autenticar al usuario
* Redirigir al usuario a un Proveedor de identidad para realizar la autenticación
* Comprobar si hay sesiones de SSO activas
* Obtener el consentimiento del usuario para el dispositivo, a menos que ya se haya otorgado previamente
Tras la autenticación correcta y el consentimiento, se mostrará la pantalla de confirmación:
En este punto, el usuario se ha autenticado y el dispositivo ha sido autorizado.
Una vez que el usuario autoriza la aplicación del dispositivo, esta recibe una respuesta HTTP 200 y la siguiente carga:
```json lines theme={null}
{
"access_token": "eyJz93a...k4laUWw",
"refresh_token": "GEbRxBN...edjnXbL",
"id_token": "eyJ0XAi...4faeEoQ",
"token_type": "Bearer",
"expires_in": 86400
}
```
Debe validar sus tokens antes de guardarlos. Para saber cómo hacerlo, lea Validar tokens de acceso y Validar tokens de ID.
Los tokens de acceso se usan para llamar al [endpoint Get User Info de la API de autenticación](https://auth0.com/docs/api/authentication#get-user-info) (si su aplicación del dispositivo
solicitó el scope `openid`) o a la API especificada por el parámetro `audience`.
Si llama a su propia API, su aplicación del dispositivo debe verificar el token de acceso antes de usarlo.
Los tokens de ID contienen información del usuario que debe [decodificarse y extraerse](/es/docs/secure/tokens/id-tokens#id-token-payload). La API de autenticación
solo devuelve un `id_token` si su aplicación del dispositivo solicitó el scope `openid`.
Los tokens de actualización se usan para obtener un nuevo token de acceso o
token de ID después de que haya expirado el anterior. La API de autenticación solo devuelve un `refresh_token` si
la configuración **Allow Offline Access** está habilitada para la API especificada por el parámetro `audience`
y su aplicación del dispositivo solicitó el scope `offline_access`.
Para llamar a tu API, la aplicación de tu dispositivo debe enviar el token de acceso como token Bearer en el
encabezado `Authorization` de tu solicitud HTTP.
```bash lines theme={null}
curl --request GET \
--url https://myapi.com/api \
--header 'authorization: Bearer AUTH0_API_ACCESS_TOKEN' \
--header 'content-type: application/json'
```
Para obtener un nuevo token de acceso para un usuario, la aplicación del dispositivo puede llamar al [endpoint POST /oauth/token de la Authentication API](https://auth0.com/docs/api/authentication#-post-oauth-token-) con el
parámetro `refresh_token`.
```bash lines theme={null}
curl --request POST \
--url 'https://{yourDomain}/oauth/token' \
--header 'content-type: application/x-www-form-urlencoded' \
--data grant_type=refresh_token \
--data 'client_id={yourClientId}' \
--data 'client_secret={yourClientSecret}' \
--data refresh_token=AUTH0_REFRESH_TOKEN
```
Si la solicitud se realiza correctamente, la aplicación de su dispositivo recibe una respuesta HTTP 200 con la siguiente carga útil:
```json lines theme={null}
{
"access_token": "eyJ...MoQ",
"expires_in": 86400,
"scope": "openid offline_access",
"id_token": "eyJ...0NE",
"token_type": "Bearer"
}
```
Para obtener más información sobre los tokens de actualización, consulta [Tokens de actualización](https://auth0.com/docs/secure/tokens/refresh-tokens).
Los registros del Tenant se crean para cualquier interacción que se produzca y pueden usarse para solucionar problemas.
### Respuestas del token
Mientras esperas a que el usuario autorice el dispositivo, es posible que recibas varias respuestas HTTP 4xx.
#### Autorización pendiente
Verás este error mientras esperas a que el usuario realice una acción. Sigue consultando con el `interval` sugerido que recuperaste en el paso anterior de este tutorial.
```json lines theme={null}
`HTTP 403`
{
"error": "authorization_pending",
"error_description": "..."
}
```
#### Reduzca la frecuencia
Está realizando sondeos con demasiada frecuencia. Reduzca la frecuencia y use el intervalo sugerido obtenido en el paso anterior de este
tutorial. Para evitar este error debido a la latencia de la red, debe empezar a contar cada intervalo después de
recibir la respuesta a la última solicitud de sondeo.
```json lines theme={null}
`HTTP 429`
{
"error": "slow_down",
"error_description": "..."
}
```
#### Token expirado
El usuario no ha autorizado el dispositivo con la suficiente rapidez, por lo que `device_code` ha expirado. Su
aplicación debe notificarle que el flujo ha expirado y pedirle que lo reinicie.
El error `expired_token` se devuelve exactamente una vez. Después de eso, el endpoint devuelve el
error `invalid_grant`.
```json lines theme={null}
`HTTP 403`
{
"error": "expired_token",
"error_description": "..."
}
```
#### Acceso denegado
Si se deniega el acceso, recibirá:
```json lines theme={null}
`HTTP 403`
{
"error": "access_denied",
"error_description": "..."
}
```
Esto puede ocurrir por varios motivos, entre ellos:
* El usuario rechazó autorizar el dispositivo.
* El servidor de autorización denegó la transacción.
* Una Action configurada denegó el acceso.
Consulta los ejemplos a continuación para aprender a implementar este flujo en aplicaciones del mundo real.
* [Entorno de pruebas de autorización de dispositivos](https://auth0.github.io/device-flow-playground/)
* [AppleTV (Swift)](https://github.com/pushpabrol/auth0-device-flow-appletv): Aplicación sencilla que muestra cómo se puede usar Auth0 con el
flujo de autorización de dispositivos en un AppleTV.
* [CLI (Node.js)](https://gist.github.com/panva/652c61e7d847e0ed99926c324fa91b36): Implementación de ejemplo de una CLI que usa el flujo de autorización
de dispositivos en lugar del flujo de código de autorización. La principal diferencia es que tu CLI no necesita
alojar un servidor web ni escuchar en un puerto.
Para usar el flujo de autorización de dispositivos, una aplicación para dispositivos debe:
* Ser compatible con Server Name Indication (SNI)
* Ser una aplicación nativa
* Tener el [método de autenticación](/es/docs/secure/application-credentials#application-authentication-methods) configurado como **None**
* Ser [conforme con OIDC](/es/docs/get-started/applications/application-settings#oauth)
* No haberse creado mediante Dynamic Client Registration
Además, el flujo de autorización de dispositivos no permite lo siguiente:
* Conexiones sociales que usen claves de desarrollador de Auth0, a menos que utilice New Universal Login Experience
* Acceder a parámetros de cadena de consulta desde una página de inicio de sesión alojada o Actions.
## Pasos siguientes
¡Excelente trabajo! Si llegaste hasta aquí, ya deberías tener el inicio de sesión, el cierre de sesión y la información del perfil de usuario funcionando en tu aplicación.
Con esto concluye nuestro tutorial de inicio rápido, pero hay mucho más por explorar. Para saber más sobre lo que puedes hacer con Auth0, consulta:
* [Auth0 Dashboard](https://manage.auth0.com/dashboard/us/dev-gja8kxz4ndtex3rq) - Aprende a configurar y administrar tu inquilino y tus aplicaciones de Auth0
* [Auth0 Marketplace](https://marketplace.auth0.com/) - Descubra las integraciones que puede habilitar para ampliar las funcionalidades de Auth0
Regístrate para obtener una{" "}
cuenta de Auth0
{" "}
o{" "}
console.log("log in")}>
inicia sesión
{" "}
en tu cuenta existente para integrarte directamente con tu propio tenant.
Se mostrará una página de confirmación para que el usuario confirme que se trata del dispositivo correcto:
El usuario completará la transacción iniciando sesión. Este paso puede incluir uno o varios de los siguientes
procesos:
* Autenticar al usuario
* Redirigir al usuario a un Proveedor de identidad para realizar la autenticación
* Comprobar si hay sesiones de SSO activas
* Obtener el consentimiento del usuario para el dispositivo, a menos que ya se haya otorgado previamente
Tras la autenticación correcta y el consentimiento, se mostrará la pantalla de confirmación:
En este punto, el usuario se ha autenticado y el dispositivo ha sido autorizado.