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: "define-permissions",
title: "Définir les autorisations"
}, {
id: "install-dependencies",
title: "Installer les dépendances"
}, {
id: "create-an-auth0client-class",
title: "Créer une classe Auth0Client"
}, {
id: "define-a-secured-concern",
title: "Définir un concern Secured"
}, {
id: "include-the-secure-concern-in-your-applicationcontroller",
title: "Inclure le concern Secure dans votre ApplicationController"
}, {
id: "create-the-public-endpoint",
title: "Créer le point de terminaison public"
}, {
id: "create-the-private-endpoints",
title: "Créer les points de terminaison privés"
}];
Ce tutoriel effectue la validation du jeton d'accès à l'aide du gem [jwt](https://github.com/jwt/ruby-jwt) au sein d'une classe `Auth0Client` personnalisée. Un Concern appelé
`Secured` est utilisé pour autoriser les points de terminaison qui nécessitent une authentification via un jeton d'accès entrant.
Si vous n'avez pas encore créé d'API dans votre Auth0 Dashboard, utilisez le sélecteur interactif pour créer une nouvelle API Auth0
ou sélectionnez une API existante pour votre projet.
Pour configurer votre première API via le Auth0 Dashboard, consultez [notre guide de démarrage](https://auth0.com/docs/get-started/auth0-overview/set-up-apis).
Chaque API Auth0 utilise l'identifiant d'API, que votre application doit utiliser pour valider le jeton d'accès.
**Vous découvrez Auth0 ?** Découvrez [comment Auth0 fonctionne](https://auth0.com/docs/overview)
et consultez [comment implémenter l’authentification
et l’autorisation des API](https://auth0.com/docs/api-auth) à l’aide du cadre OAuth 2.0.
Les autorisations vous permettent de définir comment il est possible d’accéder aux ressources au nom de l’utilisateur à l’aide d’un jeton d’accès donné. Par
exemple, vous pourriez choisir d’accorder un accès en lecture à la ressource `messages` si les utilisateurs ont le niveau d’accès de gestionnaire,
et un accès en écriture à cette ressource s’ils ont le niveau d’accès d’administrateur.
Vous pouvez définir les autorisations autorisées dans la vue **Permissions** de la section [APIs](https://manage.auth0.com/#/apis) de l’Auth0 Dashboard.
Cet exemple utilise le scope `read:messages`.
Installez la gem \*\*jwt \*\*.
```bash lines theme={null}
gem 'jwt'
bundle install
```
Créez une classe appelée `Auth0Client`. Cette classe décode et vérifie le jeton d’accès reçu extrait
de l’en-tête `Authorization` de la requête.
La classe `Auth0Client` récupère la clé publique de votre locataire Auth0, puis l’utilise pour vérifier la
signature du jeton d’accès. La structure `Token` définit une méthode `validate_permissions` pour
rechercher un `scope` particulier dans un jeton d’accès en fournissant un tableau des scopes requis et vérifier s’ils
sont présents dans la charge utile du jeton.
Créez un Concern nommé `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 la gem `jwt` pour vérifier
la signature du jeton et valider ses claims.
En plus de vérifier que le jeton d’accès est valide, le Concern inclut aussi un mécanisme pour confirmer que le
jeton dispose du **scope** requis 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 permissions en appelant la
méthode `Token.validate_permissions` de la classe `Auth0Client`.
Pour la route `/private-scoped`, les scopes définis seront comparés aux scopes provenant du
payload afin de déterminer s’ils contiennent un ou plusieurs éléments de l’autre tableau.
En ajoutant le module `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 nécessite aucune autorisation; aucun `before_action` n’est donc requis.
Créez un contrôleur pour gérer 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
scopes supplémentaires.
`/api/private-scoped` est disponible pour les requêtes authentifiées contenant un jeton d'accès avec le scope
`read:messages` accordé
Les points de terminaison protégés doivent appeler la méthode `authorize` du concern `Secured`.
Pour ce faire, utilisez `before_action :authorize`, ce qui garantit que la méthode `Secured.authorize` est
appelée avant chaque action dans le `PrivateController`.
### Effectuer un appel à votre API
Pour effectuer des appels à votre API, vous avez besoin d'un jeton d'accès. Vous pouvez obtenir un jeton d'accès à des fins de test depuis la vue **Test** dans vos [paramètres
d'API](https://manage.auth0.com/#/apis).
Fournissez le jeton d'accès dans l'en-tête `Authorization` de vos requêtes.
```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()
```
##### Vérification
Maintenant que vous avez configuré votre application, exécutez-la pour vérifier que :
* `GET /api/public` est accessible pour les requêtes non authentifiées.
* `GET /api/private` est accessible pour les requêtes authentifiées.
* `GET /api/private-scoped` est accessible pour les requêtes authentifiées contenant un jeton d’accès
avec le scope `read:messages`.
## 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 et vos applications
* [SDK omniauth-auth0](https://github.com/auth0/omniauth-auth0) - Explorez plus en profondeur le SDK utilisé dans ce tutoriel
* [Auth0 Marketplace](https://marketplace.auth0.com/) - Découvrez les intégrations que vous pouvez activer pour étendre les capacité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
```
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.
Fournissez le jeton d'accès dans l'en-tête `Authorization` de vos requêtes.