Créez un{" "}
compte Auth0
{" "}
ou{" "}
console.log("log in")}>
connectez-vous
{" "}
à votre compte existant pour l'intégrer directement à votre propre locataire.
;
};
export const sections = [{
id: "définir-les-autorisations",
title: "Définir les autorisations"
}, {
id: "installer-des-dépendances",
title: "Installer des dépendances"
}, {
id: "créer-le-validateur-jwt",
title: "Créer le validateur JWT"
}, {
id: "créer-une-application-flask",
title: "Créer une application Flask"
}];
Ce guide explique comment intégrer Auth0 à n’importe quelle API Python, nouvelle ou ancienne, développée avec [Flask](https://flask.palletsprojects.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](https://auth0.com/docs/get-started/auth0-overview/set-up-apis) qui vous aide à configurer votre première API via Auth0 Dashboard.
Toute API dans Auth0 est configurée à l’aide d’un identificateur d’API que votre code d’application utilisera comme Audience (Public) pour valider le jeton d’accès.
**Vous ne connaissez pas Auth0?** Découvrez [Auth0](https://auth0.com/docs/overview) et [l’implémentation de l’authentification et de l’autorisation d’API](https://auth0.com/docs/api-auth) 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 en particulier. 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 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 [APIs (API)](https://manage.auth0.com/#/apis) d'Auth0 Dashboard.
Cet exemple utilise la permission `read:messages`.
Ajoutez les dépendances suivantes à votre fichier `requirements.txt` :
```
# /requirements.txt
flask
Authlib
```
Nous allons utiliser 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 [Flask decorator](https://flask.palletsprojects.com/patterns/viewdecorators/) qui protège nos ressources (routes API) avec un validateur donné.
Le validateur validera le jeton d’accès que nous transmettons à la ressource en vérifiant qu’il a une signature et des demandes valides.
Nous pouvons utiliser le validateur `JWTBearerTokenValidator` d’AuthLib avec quelques ajustements pour nous 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 notre `Auth0JWTBearerTokenValidator`, nous devons lui transmettre notre `domain` et notre `audience` (Identificateur API). Il obtiendra alors la clé publique nécessaire pour vérifier la signature du jeton et la transmettra à la classe `JWTBearerTokenValidator`.
Nous remplacerons ensuite les `claims_options` de la classe pour nous assurer que les demandes d’échéance, de public et d’émission du jeton sont validées selon nos exigences.
Ensuite, nous allons créer une application Flask avec 3 routes API :
* `/api/public` Un point de terminaison public qui ne nécessite aucune authentification.
* `/api/private` Un point de terminaison privé qui nécessite un jeton d’accès JWT valide.
* `/api/private-scoped` Un point de terminaison privé qui nécessite un jeton d’accès JWT valide contenant la `scope` donnée.
Les routes protégées auront un décorateur `require_auth`, qui est un `ResourceProtector` qui utilise le `Auth0JWTBearerTokenValidator` que nous avons créé précédemment.
Pour créer `Auth0JWTBearerTokenValidator`, nous devons lui transmettre le domaine de notre locataire et l’identificateur de l’API que nous avons créée 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 nous avons créé précédemment.
### Faire un appel à votre API
Pour appeler votre API, vous avez besoin d’un jeton d’accès. Vous pouvez obtenir 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).
Fournir le jeton d’accès comme un en-tête `Authorization` dans vos demandes.
```bash cURL lines theme={null}
curl --request get \
--url 'http:///%7ByourDomain%7D/api_path' \
--header 'authorization: Bearer YOUR_ACCESS_TOKEN_HERE'
```
```csharp C# lines theme={null}
var client = new RestClient("http:///%7ByourDomain%7D/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/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/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/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/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}
#import
NSDictionary *headers = @{ @"authorization": @"Bearer YOUR_ACCESS_TOKEN_HERE" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http:///%7ByourDomain%7D/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];
```
```python Python lines theme={null}
import http.client
conn = http.client.HTTPConnection("")
headers = { 'authorization': "Bearer YOUR_ACCESS_TOKEN_HERE" }
conn.request("get", "/%7ByourDomain%7D/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/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/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
* [Trousse SDK auth0-python](https://github.com/auth0/auth0-python) : explorez en détail la trousse SDK utilisée dans ce tutoriel
* [Auth0 Marketplace](https://marketplace.auth0.com/) : découvrez des intégrations que vous pouvez activer pour étendre les fonctionnalités d’Auth0
```python 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},
}
```
```python server.py lines highlight={} theme={null}
"""Exemple d'intégration d'Auth0 avec l'API Python Flask
"""
from os import environ as env
from dotenv import load_dotenv, find_dotenv
from flask import Flask, jsonify
from authlib.integrations.flask_oauth2 import ResourceProtector
from validator import Auth0JWTBearerTokenValidator
require_auth = ResourceProtector()
validator = Auth0JWTBearerTokenValidator(
"{yourDomain}",
"{yourApiIdentifier}"
)
require_auth.register_token_validator(validator)
APP = Flask(__name__)
@APP.route("/api/public")
def public():
"""Aucun jeton d'accès n'est requis."""
response = (
"Bonjour d'un point de terminaison public! Vous n'avez pas besoin d'être"
" authentifié pour voir ceci."
)
return jsonify(message=response)
@APP.route("/api/private")
@require_auth(None)
def private():
"""Un jeton d'accès valide est requis."""
response = (
"Bonjour d'un point de terminaison privé! Vous devez être"
" authentifié pour voir ceci."
)
return jsonify(message=response)
@APP.route("/api/private-scoped")
@require_auth("read:messages")
def private_scoped():
"""Un jeton d'accès valide et une portée sont requis."""
response = (
"Bonjour d'un point de terminaison privé! Vous devez être"
" authentifié et avoir une portée de read:messages pour voir"
" ceci."
)
return jsonify(message=response)
```
```python server.py lines highlight={} theme={null}
"""Exemple d'intégration d'Auth0 avec l'API Python Flask
"""
from os import environ as env
from dotenv import load_dotenv, find_dotenv
from flask import Flask, jsonify
from authlib.integrations.flask_oauth2 import ResourceProtector
from validator import Auth0JWTBearerTokenValidator
require_auth = ResourceProtector()
validator = Auth0JWTBearerTokenValidator(
"{yourDomain}",
"{yourApiIdentifier}"
)
require_auth.register_token_validator(validator)
APP = Flask(__name__)
@APP.route("/api/public")
def public():
"""Aucun jeton d'accès n'est requis."""
response = (
"Bonjour d'un point de terminaison public! Vous n'avez pas besoin d'être"
" authentifié pour voir ceci."
)
return jsonify(message=response)
@APP.route("/api/private")
@require_auth(None)
def private():
"""Un jeton d'accès valide est requis."""
response = (
"Bonjour d'un point de terminaison privé! Vous devez être"
" authentifié pour voir ceci."
)
return jsonify(message=response)
@APP.route("/api/private-scoped")
@require_auth("read:messages")
def private_scoped():
"""Un jeton d'accès valide et une portée sont requis."""
response = (
"Bonjour d'un point de terminaison privé! Vous devez être"
" authentifié et avoir une portée de read:messages pour voir"
" ceci."
)
return jsonify(message=response)
```
```python 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},
}
```
Créez un{" "}
compte Auth0
{" "}
ou{" "}
console.log("log in")}>
connectez-vous
{" "}
à votre compte existant pour l'intégrer directement à votre propre locataire.
![Auth0 Dashboard> Applications > APIs (API) > [Specific API (API précise)] > Onglet Permissions (Autorisations)](https://mintcdn.com/generaltranslationinc/YjN60X_U-1aBZwRP/docs/images/fr-ca/cdy7uua7fh8z/1s3Yp5zqJiKiSWqbPSezNO/677a3405b2853f5fdf9e42f6e83ceba7/Quickstarts_API_-_French.png?fit=max&auto=format&n=YjN60X_U-1aBZwRP&q=85&s=9e4188afcf98fb42a7f42a9610cb5dae)
![Auth0 Dashboard> Applications > API > [API specifique] > Onglet Test](https://mintcdn.com/generaltranslationinc/9lDbWecp3mLK18lk/docs/images/fr-ca/cdy7uua7fh8z/6jeVBuypOGX5qMRXeJn5ow/8aa621c6d95e3f21115493a19ab05f7a/Quickstart_Example_App_-_API.png?fit=max&auto=format&n=9lDbWecp3mLK18lk&q=85&s=247c647eaf2a40ae6db8ba586c2a9605)
Fournir le jeton d’accès comme un en-tête `Authorization` dans vos demandes.