Inscrivez-vous pour obtenir un{" "}
compte Auth0
{" "}
ou{" "}
console.log("log in")}>
connectez-vous
{" "}
à votre compte existant pour vous intégrer directement à votre propre locataire.
;
};
export const sections = [{
id: "prerequisites",
title: "Prérequis"
}, {
id: "request-device-code",
title: "Demander un code d’appareil"
}, {
id: "receive-device-code",
title: "Recevoir un 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 d’implémentation"
}, {
id: "limitations",
title: "Limitations"
}];
Ce tutoriel explique comment appeler votre API depuis un appareil à saisie limitée à l'aide du flux d'autorisation d'appareil. Nous vous recommandons de vous connecter pour
suivre ce démarrage rapide avec des exemples configurés pour votre compte.
Pour une expérience interactive, vous pouvez utiliser le [bac à sable Device Flow](https://auth0.github.io/device-flow-playground/).
* Enregistrez une application native.
* Assurez-vous que l’option **OIDC Conformant** est activée. Pour en savoir plus, consultez Authentification conforme à OIDC.
* Ajoutez **Device Code** aux types d’octroi de l’application. Pour en savoir plus, consultez Mettre à jour les types d’octroi.
* Ajoutez **Refresh Token** 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 **Allow Offline Access** si vous utilisez des jetons d’actualisation. Pour en savoir plus, consultez 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 du code utilisateur généré aléatoirement.
Lorsque l'utilisateur démarre l'application de l'appareil et souhaite l'autoriser, votre application doit demander un code d'appareil à l'API d'authentification Auth0 pour l'associer à la session utilisateur.
Pour obtenir le code d'appareil, votre application doit appeler le [point de terminaison d'autorisation](https://auth0.com/docs/api/authentication#-post-oauth-device-code-) du flux d'autorisation d'appareil de l'API d'authentification :
```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()
```
L’application sur l’appareil devrait recevoir une réponse HTTP 200 et une charge utile semblable à celle-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 sur l’appareil a reçu le `device_code` et le `user_code`, elle doit
demander à l’utilisateur de se rendre à `verification_uri` et d’entrer le `user_code`.
Le `device_code` n’est pas destiné à être utilisé directement par l’utilisateur et ne doit pas être affiché pendant
l’interaction afin d’éviter toute confusion.
Si vous créez une CLI, vous pouvez omettre cette étape et ouvrir immédiatement le navigateur avec
`verification_uri_complete`.
Pendant que votre application sur l’appareil attend que l’utilisateur l’active, elle doit appeler périodiquement le [point de terminaison POST /oauth/token de l’Authentication API](https://auth0.com/docs/api/authentication#-post-oauth-token-)
et traiter la réponse en conséquence.
Assurez-vous que votre application sur l’appareil attend le délai `interval` (en secondes) ou jusqu’à
ce qu’elle reçoive une réponse indiquant le succès, 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 numérisera le code QR ou ouvrira la page d’activation et saisira le code utilisateur :
Une page de confirmation s’affichera pour demander à l’utilisateur de confirmer 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 gérer 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 réussie et le consentement accordé, l’invite de confirmation s’affichera :
À ce stade, l’utilisateur s’est authentifié et l’appareil a été autorisé.
Une fois que l’utilisateur a autorisé l’application de l’appareil, celle-ci reçoit une réponse HTTP 200 et la charge utile suivante :
```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 les jetons d’identité.
Les jetons d’accès servent à appeler le [point de terminaison Get User Info](https://auth0.com/docs/api/authentication#get-user-info) de l’API d’authentification (si votre
application d’appareil a demandé le scope `openid`) ou l’API spécifiée par le paramètre `audience`.
Si vous appelez votre propre API, votre application d’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](/fr-CA/docs/secure/tokens/id-tokens#id-token-payload). L’API d’authentification
ne retourne un `id_token` que si votre application d’appareil a demandé le scope `openid`.
Les jetons d’actualisation servent à obtenir un nouveau jeton d’accès ou
un nouveau jeton d’identité après l’expiration du précédent. L’API d’authentification ne retourne un `refresh_token` que si
le réglage **Autoriser l’accès hors ligne** est activé pour l’API spécifiée par le paramètre `audience`,
et que votre application d’appareil a demandé le scope `offline_access`.
Pour appeler votre API, l’application de votre 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 sur l’appareil peut appeler le [point de terminaison POST /oauth/token de l’API d’authentification](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 réussit, l’application sur votre appareil reçoit une réponse HTTP 200 contenant la charge utile suivante :
```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 locataire sont créés pour chaque interaction
et peuvent servir à résoudre les problèmes.
### Réponses de 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 passe à l’action. Continuez le sondage à l’aide de 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 des requêtes d’interrogation trop rapidement. Ralentissez et utilisez l’intervalle suggéré récupéré à l’étape précédente de ce
tutoriel. Pour éviter que cette erreur ne se produise en raison de la latence réseau, vous devriez commencer à compter chaque intervalle après
avoir reçu la réponse à la dernière requête d’interrogation.
```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 aviser l’utilisateur que le flux a expiré et lui demander de redémarrer le flux.
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 rejeté la transaction.
* Une Action configurée a refusé l’accès.
Consultez les exemples ci-dessous pour voir comment implémenter ce flux dans des applications réelles.
* [Bac à sable
d’autorisation de l’appareil](https://auth0.github.io/device-flow-playground/)
* [AppleTV (Swift)](https://github.com/pushpabrol/auth0-device-flow-appletv) : Application simple montrant comment Auth0 peut être utilisé avec le
flux d’autorisation de l’appareil sur une Apple TV.
* [CLI (Node.js)](https://gist.github.com/panva/652c61e7d847e0ed99926c324fa91b36) : Exemple d’implémentation d’une CLI qui utilise le flux d’autorisation
de l’appareil au lieu du flux du code d’autorisation. La principale différence est que votre CLI n’a pas besoin
d’héberger un serveur Web ni d’écouter sur un port.
Pour utiliser le flux d’autorisation des appareils, une application sur appareil doit :
* Prendre en charge l’indication du nom du serveur (SNI)
* Être une application native
* Avoir la [méthode d’authentification](/fr-CA/docs/secure/application-credentials#application-authentication-methods) définie à **None**
* Être [conforme à OIDC](/fr-CA/docs/get-started/applications/application-settings#oauth)
* Ne pas avoir été créée au moyen de l’enregistrement dynamique des applications
De plus, le flux d’autorisation des appareils ne permet pas :
* Les connexions sociales utilisant les clés de développeur Auth0, sauf si vous utilisez la nouvelle expérience Universal Login
* D’accéder 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 les fonctionnalités de connexion, de déconnexion et de profil utilisateur opérationnelles dans votre application.
Ce tutoriel de démarrage rapide est maintenant terminé, 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 locataire Auth0 ainsi que vos applications
* [Auth0 Marketplace](https://marketplace.auth0.com/) - Découvrez les intégrations que vous pouvez activer pour étendre les fonctionnalités d’Auth0
Inscrivez-vous pour obtenir un{" "}
compte Auth0
{" "}
ou{" "}
console.log("log in")}>
connectez-vous
{" "}
à votre compte existant pour vous intégrer directement à votre propre locataire.
Une page de confirmation s’affichera pour demander à l’utilisateur de confirmer 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 gérer 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 réussie et le consentement accordé, l’invite de confirmation s’affichera :
À ce stade, l’utilisateur s’est authentifié et l’appareil a été autorisé.