Ajouter une autorisation à votre API Ruby on Rails

Ce tutoriel effectue la validation des jetons d’accès en utilisant le gem 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.

Chaque API Auth0 utilise l’identificateur API, dont votre application a besoin pour valider le jeton d’accès.

1

Définir les autorisations

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 d’Auth0 Dashboard.

Auth0 Dashboard> Applications > APIs (API) > [Specific API (API précise)] > Onglet Permissions (Autorisations)

2

Installer les dépendances

Installer le gem jwt.

gem 'jwt'
bundle install

Was this helpful?

/

3

Créer une classe Auth0Client

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.

4

Définir un concern Secured

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.

5

Inclure la préoccupation Secure dans votre ApplicationController

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.

6

Créer le point de terminaison public

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.

7

Créer les points de terminaison privés

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).

Auth0 Dashboard> Applications > API > [API specifique] > Onglet Test

Fournissez le jeton d’accès comme un en-tête Authorization dans vos demandes.


  

  
  
curl --request get \
--url 'http:///{yourDomain}/api_path' \
--header 'authorization: Bearer YOUR_ACCESS_TOKEN_HERE'
Was this helpful?
/
var client = new RestClient("http:///{yourDomain}/api_path");
var request = new RestRequest(Method.GET);
request.AddHeader("authorization", "Bearer YOUR_ACCESS_TOKEN_HERE");
IRestResponse response = client.Execute(request);
Was this helpful?
/
package main
import (
"fmt"
"net/http"
"io/ioutil"
)
func main() {
url := "http:///{yourDomain}/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))
}
Was this helpful?
/
HttpResponse<String> response = Unirest.get("http:///{yourDomain}/api_path")
.header("authorization", "Bearer YOUR_ACCESS_TOKEN_HERE")
.asString();
Was this helpful?
/
var axios = require("axios").default;
var options = {
method: 'get',
url: 'http:///{yourDomain}/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);
});
Was this helpful?
/
#import <Foundation/Foundation.h>
NSDictionary *headers = @{ @"authorization": @"Bearer YOUR_ACCESS_TOKEN_HERE" };
NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:[NSURL URLWithString:@"http:///{yourDomain}/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(@&quot;%@&quot;, error);

                                            } else {

                                                NSHTTPURLResponse *httpResponse = (NSHTTPURLResponse *) response;

                                                NSLog(@&quot;%@&quot;, httpResponse);

                                            }

                                        }];

[dataTask resume];
Was this helpful?
/
$curl = curl_init();
curl_setopt_array($curl, [
CURLOPT_URL => "http:///{yourDomain}/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 => [
&quot;authorization: Bearer YOUR_ACCESS_TOKEN_HERE&quot;

],
]);
$response = curl_exec($curl);
$err = curl_error($curl);
curl_close($curl);
if ($err) {
echo "cURL Error #:" . $err;
} else {
echo $response;
}
Was this helpful?
/
import http.client
conn = http.client.HTTPConnection("")
headers = { 'authorization': "Bearer YOUR_ACCESS_TOKEN_HERE" }
conn.request("get", "/{yourDomain}/api_path", headers=headers)
res = conn.getresponse()
data = res.read()
print(data.decode("utf-8"))
Was this helpful?
/
require 'uri'
require 'net/http'
url = URI("http:///{yourDomain}/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
Was this helpful?
/
import Foundation
let headers = ["authorization": "Bearer YOUR_ACCESS_TOKEN_HERE"]
let request = NSMutableURLRequest(url: NSURL(string: "http:///{yourDomain}/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()
Was this helpful?
/
checkpoint.header
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.




Next Steps
Excellent work! If you made it this far, you should now have login, logout, and user profile information running in your application.
This concludes our quickstart tutorial, but there is so much more to explore. To learn more about what you can do with Auth0, check out:
Did it work?
Any suggestion or typo?
Edit on GitHub
Sign Up
Sign up for an  or  to your existing account to integrate directly with your own tenant.