;
};
export const sections = [{
id: "prerequisites",
title: "Prérequis"
}, {
id: "request-device-code",
title: "Demander le code d’appareil"
}, {
id: "receive-device-code",
title: "Recevoir le code d’appareil"
}, {
id: "request-device-activation",
title: "Demander l’activation de l’appareil"
}, {
id: "poll-the-token-endpoint",
title: "Interroger le point de terminaison des jetons"
}, {
id: "user-authorization",
title: "Autorisation de l’utilisateur"
}, {
id: "receive-tokens",
title: "Recevoir les jetons"
}, {
id: "call-your-api",
title: "Appeler votre API"
}, {
id: "refresh-tokens",
title: "Actualiser les jetons"
}, {
id: "troubleshooting",
title: "Dépannage"
}, {
id: "sample-implementations",
title: "Exemples de mises en œuvre"
}, {
id: "limitations",
title: "Limites"
}];
Ce tutoriel montre comment appeler votre API depuis un appareil à saisie limitée en utilisant le flux d'autorisation des appareils (Device Authorization Flow). Nous vous recommandons de vous connecter pour
suivre ce guide de démarrage rapide avec des exemples configurés pour votre compte.
Pour une expérience interactive, vous pouvez utiliser le [Device Flow Playground](https://auth0.github.io/device-flow-playground/).
* Enregistrez une application native.
* Assurez-vous que la bascule **OIDC Conformant** est activée. Pour en savoir plus, consultez Authentification conforme à OIDC.
* Ajoutez **Code d’appareil** aux types d’octroi de l’application. Pour en savoir plus, consultez Mettre à jour les types d’octroi.
* Ajoutez **Jeton d’actualisation** aux types d’octroi de l’application si vous souhaitez activer les jetons d’actualisation.
* Configurez et activez au moins une connexion pour
l’application.
* Enregistrez votre API dans Auth0.
* Activez **Autoriser l’accès hors ligne** si vous utilisez des jetons d’actualisation. Pour en savoir plus, consultez les paramètres de l’API.
* Configurez les paramètres du code utilisateur de l’appareil pour définir le
jeu de caractères, le format et la longueur de votre code utilisateur généré aléatoirement.
Lorsque l'utilisateur démarre l'application de l'appareil et souhaite l'autoriser, votre application doit faire une requête à l'API Auth0 Authentication pour obtenir un code d'appareil à associer à la session de l'utilisateur.
Pour obtenir le code d'appareil, votre application doit appeler le Device Authorization Flow de l'Authentication API — point de terminaison [Authorize](https://auth0.com/docs/api/authentication#-post-oauth-device-code-) :
```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_PEER
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()
```
L’application de l’appareil devrait recevoir une réponse HTTP 200 et un payload semblable à celui-ci :
```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
}
```
Après que votre application de l’appareil a reçu le `device_code` et le `user_code`, elle doit
inviter l’utilisateur à accéder à `verification_uri` et à saisir le `user_code`.
Le `device_code` n’est pas destiné à l’utilisateur et ne doit pas être affiché pendant
l’interaction, afin d’éviter toute confusion.
Si vous créez un CLI, vous pouvez sauter cette étape et ouvrir immédiatement le navigateur avec
`verification_uri_complete`.
Pendant que votre application de l’appareil attend que l’utilisateur l’active, elle devrait appeler périodiquement
le [point de terminaison POST /oauth/token](https://auth0.com/docs/api/authentication#-post-oauth-token-) de l’Authentication API et traiter la réponse de manière appropriée.
Assurez-vous que votre application de l’appareil attend la durée indiquée par `interval` (en secondes) ou jusqu’à
ce qu’elle reçoive une réponse positive, selon la période la plus longue, afin d’éviter les problèmes de latence réseau.
```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}'
```
L’utilisateur balayera le code QR ou ouvrira la page d’activation et saisira le code utilisateur :
Une page de confirmation s’affichera pour que l’utilisateur confirme qu’il s’agit du bon appareil :
L’utilisateur terminera la transaction en se connectant. Cette étape peut inclure un ou plusieurs des
processus suivants :
* Authentifier l’utilisateur
* Rediriger l’utilisateur vers un fournisseur d’identité pour prendre en charge l’authentification
* Vérifier s’il existe des sessions SSO actives
* Obtenir le consentement de l’utilisateur pour l’appareil, à moins qu’il n’ait déjà été accordé
Une fois l’authentification effectuée et le consentement obtenu, l’invite de confirmation s’affichera :
À ce stade, l’utilisateur est authentifié et l’appareil a été autorisé.
Après que l’utilisateur a autorisé l’application de l’appareil, celle-ci reçoit une réponse HTTP 200 et le payload suivant :
```json lines theme={null}
{
"access_token": "eyJz93a...k4laUWw",
"refresh_token": "GEbRxBN...edjnXbL",
"id_token": "eyJ0XAi...4faeEoQ",
"token_type": "Bearer",
"expires_in": 86400
}
```
Vous devriez valider vos jetons avant de les enregistrer. Pour savoir comment faire, consultez Valider les jetons d’accès et Valider le jeton d’identité.
Les jetons d’accès servent à effectuer des requêtes vers l’Authentication API [endpoint Get User Info](https://auth0.com/docs/api/authentication#get-user-info) (si votre application de l’appareil
a demandé la portée `openid`) ou vers l’API précisée par le paramètre `audience`.
Si vous appelez votre propre API, votre application de l’appareil doit vérifier le jeton d’accès avant de l’utiliser.
Les jetons d’identité contiennent des renseignements sur l’utilisateur qui doivent être [décodés et extraits](/docs/fr-ca/secure/tokens/id-tokens#id-token-payload). L’Authentication API
retourne uniquement un `id_token` si votre application de l’appareil a demandé la portée `openid`.
Les jetons d’actualisation servent à obtenir un nouveau jeton d’accès ou un
jeton d’identité après l’expiration du précédent. L’Authentication API retourne uniquement un `refresh_token` si
le paramètre **Allow Offline Access** est activé pour l’API précisée par le paramètre `audience`,
et si votre application de l’appareil a demandé la portée `offline_access`.
Pour appeler votre API, votre application de l’appareil doit transmettre le jeton d’accès en tant que jeton Bearer dans l’en-tête
`Authorization` de votre requête 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'
```
Pour obtenir un nouveau jeton d’accès pour un utilisateur, votre application de l’appareil peut envoyer une requête au [point de terminaison POST /oauth/token de l’Authentication API](https://auth0.com/docs/api/authentication#-post-oauth-token-) avec le
paramètre `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 requête a réussi, votre application de l’appareil reçoit une réponse HTTP 200 avec les données suivantes :
```json lines theme={null}
{
"access_token": "eyJ...MoQ",
"expires_in": 86400,
"scope": "openid offline_access",
"id_token": "eyJ...0NE",
"token_type": "Bearer"
}
```
Pour en savoir plus sur les jetons d’actualisation, consultez [Jetons d’actualisation](https://auth0.com/docs/secure/tokens/refresh-tokens).
Des journaux du tenant sont générés pour chaque interaction et peuvent être utilisés pour le dépannage.
### Réponses du jeton
Pendant que vous attendez que l’utilisateur autorise l’appareil, vous pourriez recevoir différentes réponses HTTP 4xx.
#### Autorisation en attente
Vous verrez cette erreur pendant que vous attendez que l’utilisateur agisse. Continuez à effectuer le polling en utilisant l’`interval` suggéré
récupéré à l’étape précédente de ce tutoriel.
```json lines theme={null}
`HTTP 403`
{
"error": "authorization_pending",
"error_description": "..."
}
```
#### Ralentissez
Vous effectuez les vérifications trop rapidement. Ralentissez et utilisez l’intervalle suggéré obtenu à l’étape précédente de ce
tutoriel. Pour éviter de recevoir cette erreur en raison de la latence du réseau, vous devriez commencer à compter chaque intervalle après
avoir reçu la réponse à la dernière requête de vérification.
```json lines theme={null}
`HTTP 429`
{
"error": "slow_down",
"error_description": "..."
}
```
#### Jeton expiré
L’utilisateur n’a pas autorisé l’appareil assez rapidement, donc le `device_code` a expiré. Votre
application doit informer l’utilisateur que le flux a expiré et l’inviter à le recommencer.
L’erreur `expired_token` n’est renvoyée qu’une seule fois. Par la suite, le point de terminaison renvoie l’erreur
`invalid_grant`.
```json lines theme={null}
`HTTP 403`
{
"error": "expired_token",
"error_description": "..."
}
```
#### Accès refusé
Si l’accès est refusé, vous obtenez :
```json lines theme={null}
`HTTP 403`
{
"error": "access_denied",
"error_description": "..."
}
```
Cela peut se produire pour diverses raisons, notamment :
* L’utilisateur a refusé d’autoriser l’appareil.
* Le serveur d’autorisation a refusé la transaction.
* Une Action configurée a refusé l’accès.
Consultez les exemples ci-dessous pour apprendre à mettre en œuvre ce flux dans des applications réelles.
* [Playground d’autorisation
d’appareil](https://auth0.github.io/device-flow-playground/)
* [AppleTV (Swift)](https://github.com/pushpabrol/auth0-device-flow-appletv) : Application simple qui montre comment Auth0 peut être utilisé avec le
flux d’autorisation d’appareil sur une AppleTV.
* [CLI (Node.js)](https://gist.github.com/panva/652c61e7d847e0ed99926c324fa91b36) : Exemple de mise en œuvre d’un CLI qui utilise le flux
d’autorisation d’appareil au lieu du flux de code d’autorisation. La principale différence, c’est que votre CLI n’a pas besoin
d’héberger un serveur Web ni d’écouter sur un port.
Pour utiliser le Device Authorization Flow, une application de l’appareil doit :
* prendre en charge l’indication du nom de serveur (SNI)
* être une application native
* avoir la [méthode d’authentification](/docs/fr-ca/secure/application-credentials#application-authentication-methods) définie sur **None**
* être [conforme à OIDC](/docs/fr-ca/get-started/applications/application-settings#oauth)
* ne pas avoir été créée au moyen de Dynamic Client Registration
De plus, le Device Authorization Flow ne permet pas :
* les connexions sociales utilisant des clés de développeur Auth0, sauf si vous utilisez la nouvelle expérience Universal Login
* l’accès aux paramètres de chaîne de requête à partir d’une page de connexion hébergée ou d’Actions.
## Prochaines étapes
Excellent travail ! Si vous êtes arrivé jusqu'ici, vous devriez maintenant avoir le login, le logout et les renseignements du profil utilisateur fonctionnels dans votre application.
Ceci conclut notre tutoriel de démarrage rapide, mais il reste encore beaucoup à explorer. Pour en savoir plus sur ce que vous pouvez faire avec Auth0, consultez :
* [Auth0 Dashboard](https://manage.auth0.com/dashboard/us/dev-gja8kxz4ndtex3rq) - Découvrez comment configurer et gérer votre tenant Auth0 et vos applications
* [Auth0 Marketplace](https://marketplace.auth0.com/) - Découvrez les intégrations que vous pouvez activer pour étendre les fonctionnalités d’Auth0
Créez un{" "}
compte Auth0
{" "}
ou{" "}
console.log("log in")}>
connectez-vous
{" "}
à votre compte existant pour vous intégrer directement à votre propre tenant.
Une page de confirmation s’affichera pour que l’utilisateur confirme qu’il s’agit du bon appareil :
L’utilisateur terminera la transaction en se connectant. Cette étape peut inclure un ou plusieurs des
processus suivants :
* Authentifier l’utilisateur
* Rediriger l’utilisateur vers un fournisseur d’identité pour prendre en charge l’authentification
* Vérifier s’il existe des sessions SSO actives
* Obtenir le consentement de l’utilisateur pour l’appareil, à moins qu’il n’ait déjà été accordé
Une fois l’authentification effectuée et le consentement obtenu, l’invite de confirmation s’affichera :
À ce stade, l’utilisateur est authentifié et l’appareil a été autorisé.