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: "installer-les-dépendances",
title: "Installer les dépendances"
}, {
id: "créer-une-classe-auth0client",
title: "Créer une classe Auth0Client"
}, {
id: "définir-un-concern-secured",
title: "Définir un concern Secured"
}, {
id: "inclure-la-préoccupation-secure-dans-votre-applicationcontroller",
title: "Inclure la préoccupation Secure dans votre ApplicationController"
}, {
id: "créer-le-point-de-terminaison-public",
title: "Créer le point de terminaison public"
}, {
id: "créer-les-points-de-terminaison-privés",
title: "Créer les points de terminaison privés"
}];
Ce tutoriel effectue la validation des jetons d’accès en utilisant le gem [**jwt**](https://github.com/jwt/ruby-jwt) dans une classe `Auth0Client` personnalisée. Un concern appelé `Secured` est utilisé pour autoriser les points de terminaison qui nécessitent une authentification par le biais d’un jeton d’accès entrant.
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 pour votre projet.
Pour configurer votre première API via Auth0 Dashboard, consultez [notre guide de démarrage](https://auth0.com/docs/get-started/auth0-overview/set-up-apis).
Chaque API Auth0 utilise l’identificateur API, dont votre application a besoin 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 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 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) d’Auth0 Dashboard.
Cet exemple utilise la permission `read:messages`.
Installer le gem **jwt**.
```
gem 'jwt'
bundle install
```
Créez une classe appelée `Auth0Client`. Cette classe décode et vérifie le jeton d’accès entrant provenant de l’en-tête `Authorization` de la requête.
La classe `Auth0Client` récupère la clé publique de votre locataire Auth0 et l’utilise pour vérifier la signature du jeton d’accès. La structure `Token` définit une méthode `validate_permissions` pour rechercher une `scope` particulière dans un jeton d’accès en fournissant un tableau des permissions requises et en vérifiant si elles sont présentes dans la charge utile du jeton.
Créez un concern appelé `Secured` qui recherche le jeton d’accès dans l’en-tête `Authorization` d’une requête entrante.
Si le jeton est présent, `Auth0Client.validate_token` utilisera le gem `jwt` pour vérifier la signature du jeton et valider les demandes du jeton.
Outre la vérification de la validité du jeton d’accès, concern possède un mécanisme permettant de confirmer que le jeton dispose d’une **permission** suffisante pour accéder aux ressources demandées. Dans cet exemple, nous définissons une méthode `validate_permissions` qui reçoit un bloc et vérifie les autorisations en appelant la méthode `Token.validate_permissions` de la classe `Auth0Client`.
Pour la route `/private-scoped`, les permissions définies seront croisées avec les permissions provenant de la charge utile, afin de déterminer si elle contient un ou plusieurs éléments de l’autre tableau.
En ajoutant la préoccupation `Secure` à votre contrôleur d’application, vous n’aurez plus qu’à utiliser un filtre `before_action` dans le contrôleur qui requiert une autorisation.
Créez un contrôleur pour gérer le point de terminaison public `/api/public`.
Le point de terminaison `/public` ne requiert aucune autorisation et aucune `before_action` n’est donc nécessaire.
Créez un contrôleur pour traiter les points de terminaison privés : `/api/private` et `/api/private-scoped`.
`/api/private` est disponible pour les requêtes authentifiées contenant un jeton d’accès sans permission supplémentaire.
`/api/private-scoped` est disponible pour les requêtes authentifiées contenant un jeton d’accès dont la permission `read:messages` est accordée.
Les points de terminaison protégés doivent appeler la méthode `authorize` du concern `Secured`; vous devez pour cela utiliser `before_action :authorize`, ce qui assure que la méthode `Secured.authorize` est appelée avant chaque action dans le `PrivateController`.
### 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).
Fournissez 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()
```
##### Point de contrôle
Maintenant que vous avez configuré votre application, exécutez-la pour vérifier que :
`GET /api/public` est disponible pour les demandes non authentifiées.
`GET /api/private` est disponible pour les demandes authentifiées.
`GET /api/private-scoped` est disponible pour les demandes authentifiées contenant un jeton d’accès avec la permission `read:messages`.
## É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 omniauth-auth0](https://github.com/auth0/omniauth-auth0) : 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
```rb app/controllers/concerns/secured.rb lines highlight={} theme={null}
# frozen_string_literal: true
module Secured
extend ActiveSupport::Concern
REQUIRES_AUTHENTICATION = { message: 'Requires authentication' }.freeze
BAD_CREDENTIALS = {
message: 'Bad credentials'
}.freeze
MALFORMED_AUTHORIZATION_HEADER = {
error: 'invalid_request',
error_description: 'Authorization header value must follow this format: Bearer access-token',
message: 'Bad credentials'
}.freeze
INSUFFICIENT_PERMISSIONS = {
error: 'insufficient_permissions',
error_description: 'The access token does not contain the required permissions',
message: 'Permission denied'
}.freeze
def authorize
token = token_from_request
return if performed?
validation_response = Auth0Client.validate_token(token)
@decoded_token = validation_response.decoded_token
return unless (error = validation_response.error)
render json: { message: error.message }, status: error.status
end
def validate_permissions(permissions)
raise 'validate_permissions needs to be called with a block' unless block_given?
return yield if @decoded_token.validate_permissions(permissions)
render json: INSUFFICIENT_PERMISSIONS, status: :forbidden
end
private
def token_from_request
authorization_header_elements = request.headers['Authorization']&.split
render json: REQUIRES_AUTHENTICATION, status: :unauthorized and return unless authorization_header_elements
unless authorization_header_elements.length == 2
render json: MALFORMED_AUTHORIZATION_HEADER,
status: :unauthorized and return
end
scheme, token = authorization_header_elements
render json: BAD_CREDENTIALS, status: :unauthorized and return unless scheme.downcase == 'bearer'
token
end
end
```
```rb app/controllers/application_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class ApplicationController < ActionController::API
include Secured
end
```
```rb app/lib/auth0_client.rb lines highlight={} theme={null}
```
```rb app/controllers/public_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class PublicController < ApplicationController
def public
render json: { message: 'All good. You don\'t need to be authenticated to call this.' }
end
end
```
```rb app/controllers/private_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class PublicController < ApplicationController
def public
render json: { message: 'All good. You don\'t need to be authenticated to call this.' }
end
end
```
```rb app/controllers/concerns/secured.rb lines highlight={} theme={null}
# frozen_string_literal: true
module Secured
extend ActiveSupport::Concern
REQUIRES_AUTHENTICATION = { message: 'Requires authentication' }.freeze
BAD_CREDENTIALS = {
message: 'Bad credentials'
}.freeze
MALFORMED_AUTHORIZATION_HEADER = {
error: 'invalid_request',
error_description: 'Authorization header value must follow this format: Bearer access-token',
message: 'Bad credentials'
}.freeze
INSUFFICIENT_PERMISSIONS = {
error: 'insufficient_permissions',
error_description: 'The access token does not contain the required permissions',
message: 'Permission denied'
}.freeze
def authorize
token = token_from_request
return if performed?
validation_response = Auth0Client.validate_token(token)
@decoded_token = validation_response.decoded_token
return unless (error = validation_response.error)
render json: { message: error.message }, status: error.status
end
def validate_permissions(permissions)
raise 'validate_permissions needs to be called with a block' unless block_given?
return yield if @decoded_token.validate_permissions(permissions)
render json: INSUFFICIENT_PERMISSIONS, status: :forbidden
end
private
def token_from_request
authorization_header_elements = request.headers['Authorization']&.split
render json: REQUIRES_AUTHENTICATION, status: :unauthorized and return unless authorization_header_elements
unless authorization_header_elements.length == 2
render json: MALFORMED_AUTHORIZATION_HEADER,
status: :unauthorized and return
end
scheme, token = authorization_header_elements
render json: BAD_CREDENTIALS, status: :unauthorized and return unless scheme.downcase == 'bearer'
token
end
end
```
```rb app/controllers/application_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class ApplicationController < ActionController::API
include Secured
end
```
```rb app/lib/auth0_client.rb lines highlight={} theme={null}
```
```rb app/controllers/public_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class PublicController < ApplicationController
def public
render json: { message: 'All good. You don\'t need to be authenticated to call this.' }
end
end
```
```rb app/controllers/private_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class PublicController < ApplicationController
def public
render json: { message: 'All good. You don\'t need to be authenticated to call this.' }
end
end
```
```rb app/controllers/application_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class ApplicationController < ActionController::API
include Secured
end
```
```rb app/lib/auth0_client.rb lines highlight={} theme={null}
```
```rb app/controllers/concerns/secured.rb lines highlight={} theme={null}
# frozen_string_literal: true
module Secured
extend ActiveSupport::Concern
REQUIRES_AUTHENTICATION = { message: 'Requires authentication' }.freeze
BAD_CREDENTIALS = {
message: 'Bad credentials'
}.freeze
MALFORMED_AUTHORIZATION_HEADER = {
error: 'invalid_request',
error_description: 'Authorization header value must follow this format: Bearer access-token',
message: 'Bad credentials'
}.freeze
INSUFFICIENT_PERMISSIONS = {
error: 'insufficient_permissions',
error_description: 'The access token does not contain the required permissions',
message: 'Permission denied'
}.freeze
def authorize
token = token_from_request
return if performed?
validation_response = Auth0Client.validate_token(token)
@decoded_token = validation_response.decoded_token
return unless (error = validation_response.error)
render json: { message: error.message }, status: error.status
end
def validate_permissions(permissions)
raise 'validate_permissions needs to be called with a block' unless block_given?
return yield if @decoded_token.validate_permissions(permissions)
render json: INSUFFICIENT_PERMISSIONS, status: :forbidden
end
private
def token_from_request
authorization_header_elements = request.headers['Authorization']&.split
render json: REQUIRES_AUTHENTICATION, status: :unauthorized and return unless authorization_header_elements
unless authorization_header_elements.length == 2
render json: MALFORMED_AUTHORIZATION_HEADER,
status: :unauthorized and return
end
scheme, token = authorization_header_elements
render json: BAD_CREDENTIALS, status: :unauthorized and return unless scheme.downcase == 'bearer'
token
end
end
```
```rb app/controllers/public_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class PublicController < ApplicationController
def public
render json: { message: 'All good. You don\'t need to be authenticated to call this.' }
end
end
```
```rb app/controllers/private_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class PublicController < ApplicationController
def public
render json: { message: 'All good. You don\'t need to be authenticated to call this.' }
end
end
```
```rb app/controllers/public_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class PublicController < ApplicationController
def public
render json: { message: 'All good. You don\'t need to be authenticated to call this.' }
end
end
```
```rb app/controllers/application_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class ApplicationController < ActionController::API
include Secured
end
```
```rb app/lib/auth0_client.rb lines highlight={} theme={null}
```
```rb app/controllers/concerns/secured.rb lines highlight={} theme={null}
# frozen_string_literal: true
module Secured
extend ActiveSupport::Concern
REQUIRES_AUTHENTICATION = { message: 'Requires authentication' }.freeze
BAD_CREDENTIALS = {
message: 'Bad credentials'
}.freeze
MALFORMED_AUTHORIZATION_HEADER = {
error: 'invalid_request',
error_description: 'Authorization header value must follow this format: Bearer access-token',
message: 'Bad credentials'
}.freeze
INSUFFICIENT_PERMISSIONS = {
error: 'insufficient_permissions',
error_description: 'The access token does not contain the required permissions',
message: 'Permission denied'
}.freeze
def authorize
token = token_from_request
return if performed?
validation_response = Auth0Client.validate_token(token)
@decoded_token = validation_response.decoded_token
return unless (error = validation_response.error)
render json: { message: error.message }, status: error.status
end
def validate_permissions(permissions)
raise 'validate_permissions needs to be called with a block' unless block_given?
return yield if @decoded_token.validate_permissions(permissions)
render json: INSUFFICIENT_PERMISSIONS, status: :forbidden
end
private
def token_from_request
authorization_header_elements = request.headers['Authorization']&.split
render json: REQUIRES_AUTHENTICATION, status: :unauthorized and return unless authorization_header_elements
unless authorization_header_elements.length == 2
render json: MALFORMED_AUTHORIZATION_HEADER,
status: :unauthorized and return
end
scheme, token = authorization_header_elements
render json: BAD_CREDENTIALS, status: :unauthorized and return unless scheme.downcase == 'bearer'
token
end
end
```
```rb app/controllers/private_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class PublicController < ApplicationController
def public
render json: { message: 'All good. You don\'t need to be authenticated to call this.' }
end
end
```
```rb app/controllers/private_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class PublicController < ApplicationController
def public
render json: { message: 'All good. You don\'t need to be authenticated to call this.' }
end
end
```
```rb app/controllers/application_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class ApplicationController < ActionController::API
include Secured
end
```
```rb app/lib/auth0_client.rb lines highlight={} theme={null}
```
```rb app/controllers/concerns/secured.rb lines highlight={} theme={null}
# frozen_string_literal: true
module Secured
extend ActiveSupport::Concern
REQUIRES_AUTHENTICATION = { message: 'Requires authentication' }.freeze
BAD_CREDENTIALS = {
message: 'Bad credentials'
}.freeze
MALFORMED_AUTHORIZATION_HEADER = {
error: 'invalid_request',
error_description: 'Authorization header value must follow this format: Bearer access-token',
message: 'Bad credentials'
}.freeze
INSUFFICIENT_PERMISSIONS = {
error: 'insufficient_permissions',
error_description: 'The access token does not contain the required permissions',
message: 'Permission denied'
}.freeze
def authorize
token = token_from_request
return if performed?
validation_response = Auth0Client.validate_token(token)
@decoded_token = validation_response.decoded_token
return unless (error = validation_response.error)
render json: { message: error.message }, status: error.status
end
def validate_permissions(permissions)
raise 'validate_permissions needs to be called with a block' unless block_given?
return yield if @decoded_token.validate_permissions(permissions)
render json: INSUFFICIENT_PERMISSIONS, status: :forbidden
end
private
def token_from_request
authorization_header_elements = request.headers['Authorization']&.split
render json: REQUIRES_AUTHENTICATION, status: :unauthorized and return unless authorization_header_elements
unless authorization_header_elements.length == 2
render json: MALFORMED_AUTHORIZATION_HEADER,
status: :unauthorized and return
end
scheme, token = authorization_header_elements
render json: BAD_CREDENTIALS, status: :unauthorized and return unless scheme.downcase == 'bearer'
token
end
end
```
```rb app/controllers/public_controller.rb lines highlight={} theme={null}
# frozen_string_literal: true
class PublicController < ApplicationController
def public
render json: { message: 'All good. You don\'t need to be authenticated to call this.' }
end
end
```
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 un en-tête `Authorization` dans vos demandes.