Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.
;
};
export const sections = [{
id: "définir-les-autorisations",
title: "Définir les autorisations"
}, {
id: "configurer-django-pour-utiliser-auth0",
title: "Configurer Django pour utiliser Auth0"
}, {
id: "créer-le-validateur-jwt",
title: "Créer le validateur JWT"
}, {
id: "créer-les-vues-api",
title: "Créer les vues API"
}, {
id: "ajouter-des-mappages-d-url",
title: "Ajouter des mappages d’URL"
}];
Ce guide explique comment intégrer Auth0 à n’importe quelle API Python, nouvelle ou ancienne, développée avec [Django](https://www.djangoproject.com/).
Si vous n’avez pas encore créé d’API dans votre Auth0 Dashboard, vous pouvez utiliser le sélecteur interactif pour créer une nouvelle API Auth0 ou sélectionner une API existante qui représente le projet avec lequel vous souhaitez vous intégrer.
Vous pouvez également lire notre guide de démarrage, qui vous aidera à configurer votre première API via Auth0 Dashboard.
Toute API dans Auth0 est configurée à l’aide d’un identifiant d’API que votre code d’application utilisera comme Audience pour valider le jeton d’accès.
**Vous ne connaissez pas Auth0 ?** Découvrez Auth0 et l’implémentation de l’authentification et de l’autorisation d’API en utilisant le cadre d’applications OAuth 2.0.
Les autorisations vous permettent de définir comment les ressources peuvent être accessibles au nom de l’utilisateur avec un jeton d’accès donné. Par exemple, vous pouvez choisir d’accorder un accès en lecture à la ressource `messages` si les utilisateurs ont le niveau d’accès gestionnaire et accorder un accès en écriture à cette ressource s’ils ont le niveau d’accès administrateur.
Vous pouvez définir les autorisations autorisées dans la vue **Permissions (Autorisations)** de la section [API](https://manage.auth0.com/#/apis) du Auth0 Dashboard. L’exemple suivant utilise la permission `read:messages`.
### Installez des dépendances
1. Ajoutez les dépendances suivantes à votre `requirements.txt` :
2. Exécutez `pip install -r requirements.txt`
### Créez une application Django
Vous utiliserez une bibliothèque appelée [Authlib](https://github.com/lepture/authlib) pour créer un [ResourceProtector](https://docs.authlib.org/en/latest/flask/1/resource-server.html), qui est un type de [Django view decorator (Décorateur de vue Django)](https://docs.djangoproject.com/en/4.0/topics/http/decorators/) qui protège vos ressources (vues API) avec un validateur donné.
Le validateur vérifiera le jeton d’accès que vous passez à la ressource en vérifiant qu’il a une signature et des demandes valides.
Vous pouvez utiliser le validateur `JWTBearerTokenValidator` d’AuthLib avec quelques ajustements pour vous assurer qu’il est conforme à nos exigences de [validation des jetons d’accès](https://auth0.com/docs/secure/tokens/access-tokens/validate-access-tokens).
Pour créer votre `Auth0JWTBearerTokenValidator`, vous devez le passer à votre `domaine` et à votre `public` (Identificateur API). Il obtiendra alors la clé publique nécessaire pour vérifier la signature du jeton et la passera à la classe `JWTBearerTokenValidator`.
Vous remplacerez ensuite les `claims_options` de la classe pour vous assurer que les demandes `expiry`, `audience` et `issue` du jeton sont validées selon nos exigences.
Créez le fichier `apiexample/validator.py` en utilisant le code du panneau interactif.
Ensuite, vous allez créer trois vues API dans `apiexample/views.py` :
* `/api/public` : point de terminaison public qui ne nécessite aucune authentification.
* `/api/private` : point de terminaison privé qui nécessite un JWT de jeton d’accès valide.
* `/api/private-scoped` : termpoint de terminaison inal privé qui nécessite un JWT de jeton d’accès valide contenant la `scope` donnée.
Les routes protégées auront un "decorator" `require_auth`, qui est un `ResourceProtector` qui utilise le `Auth0JWTBearerTokenValidator` que vous avez créé précédemment.
Pour créer le `Auth0JWTBearerTokenValidator`, vous devez le transmettre au domaine de votre locataire et à l’identificateur de l’API que vous avez créé précédemment.
Le decorator `require_auth` sur la route `private_scoped` prend en charge un argument supplémentaire `"read:messages"` qui vérifie la permission du jeton d’accès que vous avez créé précédemment.
Dans les étapes précédentes, vous avez ajouté des méthodes au fichier `views.py` . Mappez à présent ces méthodes aux URL en utilisant le [URL Dispatcher (Répartiteur d’URL)](https://docs.djangoproject.com/en/4.0/topics/http/urls/) de Django, qui vous permet de mapper les modèles d’URL aux vues.
Ajoutez les modèles d’URL à votre fichier `apiexample/urls.py`.
### Faites un appel à votre API
Pour appeler votre API, vous aurez besoin d’un jeton d’accès. Vous pouvez récupérer un jeton d’accès à des fins de test dans la vue **Test** dans vos [API Settings (Paramètres API)](https://manage.auth0.com/#/apis).
Fournissez le jeton d’accès comme en-tête `Authorization` dans vos requêtes.
```bash cURL lines theme={null}
curl --request get \
--url 'http:///%7ByourDomain%7D.com/api_path' \
--header 'authorization: Bearer YOUR_ACCESS_TOKEN_HERE'
```
```csharp C# lines theme={null}
var client = new RestClient("http:///%7ByourDomain%7D.com/api_path");
var request = new RestRequest(Method.GET);
request.AddHeader("authorization", "Bearer YOUR_ACCESS_TOKEN_HERE");
IRestResponse response = client.Execute(request);
```
```go Go lines theme={null}
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "http:///%7ByourDomain%7D.com/api_path"
req, _ := http.NewRequest("get", url, nil)
req.Header.Add("authorization", "Bearer YOUR_ACCESS_TOKEN_HERE")
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.get("http:///%7ByourDomain%7D.com/api_path")
.header("authorization", "Bearer YOUR_ACCESS_TOKEN_HERE")
.asString();
```
```javascript Node.JS lines theme={null}
var axios = require("axios").default;
var options = {
method: 'get',
url: 'http:///%7ByourDomain%7D.com/api_path',
headers: {authorization: 'Bearer YOUR_ACCESS_TOKEN_HERE'}
};
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 = @{ @"authorization": @"Bearer YOUR_ACCESS_TOKEN_HERE" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http:///%7ByourDomain%7D.com/api_path"]
cachePolicy:NSURLRequestUseProtocolCachePolicy
timeoutInterval:10.0];
[request setHTTPMethod:@"get"];
[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 => "http:///%7ByourDomain%7D.com/api_path",
CURLOPT_RETURNTRANSFER => true,
CURLOPT_ENCODING => "",
CURLOPT_MAXREDIRS => 10,
CURLOPT_TIMEOUT => 30,
CURLOPT_HTTP_VERSION => CURL_HTTP_VERSION_1_1,
CURLOPT_CUSTOMREQUEST => "get",
CURLOPT_HTTPHEADER => [
"authorization: Bearer YOUR_ACCESS_TOKEN_HERE"
],
]);
$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.HTTPConnection("")
headers = { 'authorization': "Bearer YOUR_ACCESS_TOKEN_HERE" }
conn.request("get", "/{yourDomain}.com/api_path", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
```
```ruby Ruby lines theme={null}
require 'uri'
require 'net/http'
url = URI("http:///%7ByourDomain%7D.com/api_path")
http = Net::HTTP.new(url.host, url.port)
request = Net::HTTP::Get.new(url)
request["authorization"] = 'Bearer YOUR_ACCESS_TOKEN_HERE'
response = http.request(request)
puts response.read_body
```
```swift Swift lines theme={null}
import Foundation
let headers = ["authorization": "Bearer YOUR_ACCESS_TOKEN_HERE"]
let request = NSMutableURLRequest(url: NSURL(string: "http:///%7ByourDomain%7D.com/api_path")! as URL,
cachePolicy: .useProtocolCachePolicy,
timeoutInterval: 10.0)
request.httpMethod = "get"
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()
```
## Étapes suivantes
Beau travail! Si vous en êtes arrivé là, vous devriez avoir la connexion, la déconnexion et les informations de profil utilisateur actives dans votre application.
Cela conclut notre tutoriel de démarrage rapide, mais il y a tellement plus à explorer. Pour en savoir plus sur ce que vous pouvez faire avec Auth0, consultez :
* [Auth0 Dashboard](https://manage.auth0.com/#) : apprenez à configurer et gérer votre locataire et vos applications Auth0
* [Auth0 Marketplace](https://marketplace.auth0.com/) : découvrez des intégrations que vous pouvez activer pour étendre les fonctionnalités d’Auth0
```py apiexample/views.py lines highlight={} theme={null}
from authlib.integrations.django_oauth2 import ResourceProtector
from django.http import JsonResponse
from . import validator
require_auth = ResourceProtector()
validator = validator.Auth0JWTBearerTokenValidator(
"{yourDomain}",
"{yourApiIdentifier}"
)
require_auth.register_token_validator(validator)
def public(request):
"""No access token required to access this route
"""
response = "Hello from a public endpoint! You don't need to be authenticated to see this."
return JsonResponse(dict(message=response))
@require_auth(None)
def private(request):
"""A valid access token is required to access this route
"""
response = "Hello from a private endpoint! You need to be authenticated to see this."
return JsonResponse(dict(message=response))
@require_auth("read:messages")
def private_scoped(request):
"""A valid access token and an appropriate scope are required to access this route
"""
response = "Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this."
return JsonResponse(dict(message=response))
```
```py apiexample/validator.py lines highlight={} theme={null}
import json
from urllib.request import urlopen
from authlib.oauth2.rfc7523 import JWTBearerTokenValidator
from authlib.jose.rfc7517.jwk import JsonWebKey
class Auth0JWTBearerTokenValidator(JWTBearerTokenValidator):
def __init__(self, domain, audience):
issuer = f"https://{domain}/"
jsonurl = urlopen(f"{issuer}.well-known/jwks.json")
public_key = JsonWebKey.import_key_set(
json.loads(jsonurl.read())
)
super(Auth0JWTBearerTokenValidator, self).__init__(
public_key
)
self.claims_options = {
"exp": {"essential": True},
"aud": {"essential": True, "value": audience},
"iss": {"essential": True, "value": issuer},
}
```
```py apiexample/urls.py lines highlight={8-10} theme={null}
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('api/public', views.public),
path('api/private', views.private),
path('api/private-scoped', views.private_scoped)
]
```
```py apiexample/validator.py lines highlight={} theme={null}
import json
from urllib.request import urlopen
from authlib.oauth2.rfc7523 import JWTBearerTokenValidator
from authlib.jose.rfc7517.jwk import JsonWebKey
class Auth0JWTBearerTokenValidator(JWTBearerTokenValidator):
def __init__(self, domain, audience):
issuer = f"https://{domain}/"
jsonurl = urlopen(f"{issuer}.well-known/jwks.json")
public_key = JsonWebKey.import_key_set(
json.loads(jsonurl.read())
)
super(Auth0JWTBearerTokenValidator, self).__init__(
public_key
)
self.claims_options = {
"exp": {"essential": True},
"aud": {"essential": True, "value": audience},
"iss": {"essential": True, "value": issuer},
}
```
```py apiexample/views.py lines highlight={} theme={null}
from authlib.integrations.django_oauth2 import ResourceProtector
from django.http import JsonResponse
from . import validator
require_auth = ResourceProtector()
validator = validator.Auth0JWTBearerTokenValidator(
"{yourDomain}",
"{yourApiIdentifier}"
)
require_auth.register_token_validator(validator)
def public(request):
"""No access token required to access this route
"""
response = "Hello from a public endpoint! You don't need to be authenticated to see this."
return JsonResponse(dict(message=response))
@require_auth(None)
def private(request):
"""A valid access token is required to access this route
"""
response = "Hello from a private endpoint! You need to be authenticated to see this."
return JsonResponse(dict(message=response))
@require_auth("read:messages")
def private_scoped(request):
"""A valid access token and an appropriate scope are required to access this route
"""
response = "Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this."
return JsonResponse(dict(message=response))
```
```py apiexample/urls.py lines highlight={8-10} theme={null}
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('api/public', views.public),
path('api/private', views.private),
path('api/private-scoped', views.private_scoped)
]
```
```py apiexample/urls.py lines highlight={8-10} theme={null}
from django.contrib import admin
from django.urls import path
from . import views
urlpatterns = [
path('admin/', admin.site.urls),
path('api/public', views.public),
path('api/private', views.private),
path('api/private-scoped', views.private_scoped)
]
```
```py apiexample/validator.py lines highlight={} theme={null}
import json
from urllib.request import urlopen
from authlib.oauth2.rfc7523 import JWTBearerTokenValidator
from authlib.jose.rfc7517.jwk import JsonWebKey
class Auth0JWTBearerTokenValidator(JWTBearerTokenValidator):
def __init__(self, domain, audience):
issuer = f"https://{domain}/"
jsonurl = urlopen(f"{issuer}.well-known/jwks.json")
public_key = JsonWebKey.import_key_set(
json.loads(jsonurl.read())
)
super(Auth0JWTBearerTokenValidator, self).__init__(
public_key
)
self.claims_options = {
"exp": {"essential": True},
"aud": {"essential": True, "value": audience},
"iss": {"essential": True, "value": issuer},
}
```
```py apiexample/views.py lines highlight={} theme={null}
from authlib.integrations.django_oauth2 import ResourceProtector
from django.http import JsonResponse
from . import validator
require_auth = ResourceProtector()
validator = validator.Auth0JWTBearerTokenValidator(
"{yourDomain}",
"{yourApiIdentifier}"
)
require_auth.register_token_validator(validator)
def public(request):
"""No access token required to access this route
"""
response = "Hello from a public endpoint! You don't need to be authenticated to see this."
return JsonResponse(dict(message=response))
@require_auth(None)
def private(request):
"""A valid access token is required to access this route
"""
response = "Hello from a private endpoint! You need to be authenticated to see this."
return JsonResponse(dict(message=response))
@require_auth("read:messages")
def private_scoped(request):
"""A valid access token and an appropriate scope are required to access this route
"""
response = "Hello from a private endpoint! You need to be authenticated and have a scope of read:messages to see this."
return JsonResponse(dict(message=response))
```
Sign up for an{" "}
Auth0 account
{" "}
or{" "}
console.log("log in")}>
log in
{" "}
to your existing account to integrate directly with your own tenant.
![Auth0 Dashboard> Applications > APIs (API) > [Specific API (API précise)] > Onglet Permissions (Autorisations)](https://mintcdn.com/docs-dev-docs-event-stream-action-templates/i2ZmWeCuZRFq3k1v/docs/images/fr-ca/cdy7uua7fh8z/1s3Yp5zqJiKiSWqbPSezNO/677a3405b2853f5fdf9e42f6e83ceba7/Quickstarts_API_-_French.png?fit=max&auto=format&n=i2ZmWeCuZRFq3k1v&q=85&s=81fd9c131b7cfcfa0af80517dc295b7d)
![Auth0 Dashboard> Applications > API > [API specifique] > Onglet Test](https://mintcdn.com/docs-dev-docs-event-stream-action-templates/1giWs3MwX5Akld9c/docs/images/fr-ca/cdy7uua7fh8z/6jeVBuypOGX5qMRXeJn5ow/8aa621c6d95e3f21115493a19ab05f7a/Quickstart_Example_App_-_API.png?fit=max&auto=format&n=1giWs3MwX5Akld9c&q=85&s=7691b71c701a702e48598d5d26b7a999)
Fournissez le jeton d’accès comme en-tête `Authorization` dans vos requêtes.