Passer au contenu principal
Dans le cadre du scénario d’architecture Server + API, nous allons mettre en œuvre l’API Timesheets en Node.js. Consultez le scénario pour en savoir plus sur la solution mise en œuvre. Le code source complet de l’implémentation de l’API Node.js se trouve dans ce dépôt GitHub.

​
Étape 1. Définir le point de terminaison de l’API

Nous utiliserons le framework d’applications Web Express pour créer notre API Node.js.

​
Créer un fichier package.json

Créez un dossier pour votre API, accédez-y, puis exécutez npm init. Cette commande créera votre fichier package.json. Vous pouvez conserver les paramètres par défaut ou les modifier selon vos besoins. Le fichier package.json de notre exemple ressemble à ceci : 
{
  "name": "timesheets-api",
  "version": "1.0.0",
  "description": "API used to add timesheet entries for employees and contractors",
  "main": "index.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "repository": {
    "type": "git",
    "url": "git+https://github.com/auth0-samples/auth0-pnp-timesheets.git"
  },
  "author": "Auth0",
  "license": "MIT",
  "bugs": {
    "url": "https://github.com/auth0-samples/auth0-pnp-timesheets/issues"
  },
  "homepage": "https://github.com/auth0-samples/auth0-pnp-timesheets#readme"
}

​
Installer les dépendances

Ensuite, nous devons configurer nos dépendances. Nous utiliserons les modules suivants :
  • express : Ce module ajoute le framework d’applications Web Express.
  • jwks-rsa : Cette bibliothèque récupère des clés de signature RSA à partir d’un point de terminaison JWKS (JSON Web Key Set). En utilisant expressJwtSecret, nous pouvons générer un fournisseur de secrets qui fournira la clé de signature appropriée à express-jwt en fonction du kid dans l’en-tête du . Pour en savoir plus, consultez le dépôt GitHub node-jwks-rsa.
  • express-jwt : Ce module vous permet d’authentifier des requêtes HTTP à l’aide de jetons JWT dans vos applications Node.js. Il fournit plusieurs fonctions qui facilitent l’utilisation des JWT. Pour en savoir plus, consultez le dépôt GitHub express-jwt.
  • body-parser : Il s’agit d’un intergiciel Node.js d’analyse du corps des requêtes. Il extrait l’intégralité du corps d’un flux de requête entrant et l’expose dans req.body sous une forme plus facile à utiliser. Pour en savoir plus et découvrir plusieurs solutions de rechange, consultez le dépôt GitHub de body-parser.
Pour installer ces dépendances, exécutez ce qui suit : 
npm install express express-jwt jwks-rsa body-parser --save

​
Implémentez le point de terminaison

Accédez au répertoire de votre API et créez un fichier server.js. Votre code doit :
  • Configurer les dépendances.
  • Activer le middleware d’analyse du corps de la requête.
  • Implémenter le point de terminaison.
  • Lancer le serveur de l’API.
Voici un exemple d’implémentation : 
// définir les dépendances
const express = require('express');
const app = express();
const jwt = require('express-jwt');
const jwksRsa = require('jwks-rsa');
const bodyParser = require('body-parser');

// activer l'utilisation du middleware d'analyse du corps de la requête
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({
  extended: true
}));

// créer le point de terminaison API pour le téléversement des feuilles de temps
app.post('/timesheets/upload', function(req, res){
  res.status(201).send({message: "This is the POST /timesheets/upload endpoint"});
})

// lancer le serveur d’API à localhost:8080
app.listen(8080);
Démarrez votre serveur d’API à l’aide de node server, puis effectuez une requête HTTP POST vers localhost:8080/timesheets/upload. Vous devriez voir une réponse JSON contenant le message This is the POST /timesheets/upload endpoint. Nous avons maintenant notre point de terminaison, mais n’importe qui peut y accéder. Passez au paragraphe suivant pour voir comment régler ce problème.

​
Étape 2. Sécuriser le point de terminaison de l’API

Afin de valider notre jeton, nous utiliserons la fonction jwt, fournie par le middleware express-jwt, ainsi que le package jwks-rsa pour récupérer la clé publique d’Auth0. Les bibliothèques font ce qui suit :
  1. express-jwt décodera le jeton et transmettra la requête, l’en-tête et la charge utile à jwksRsa.expressJwtSecret.
  2. jwks-rsa téléchargera ensuite toutes les clés de signature à partir du point de terminaison JWKS et vérifiera si l’une d’elles correspond au kid dans l’en-tête du JWT. Si aucune des clés de signature ne correspond au kid reçu, une erreur sera générée. Si une correspondance est trouvée, nous transmettrons la bonne clé de signature à express-jwt.
  3. express-jwt poursuivra ensuite sa logique de validation de la signature du jeton, de l’expiration, de audience et de issuer.
Les étapes que nous suivrons dans notre code sont les suivantes :
  • Créer la fonction middleware pour valider le .
  • Activer l’utilisation du middleware sur nos routes.
C’est aussi un bon moment pour implémenter la logique permettant d’enregistrer les entrées de feuille de temps dans une base de données locale, ou dans tout autre mécanisme de stockage de votre choix. Voici notre exemple d’implémentation (une partie du code est omise par souci de concision) : Si nous démarrons maintenant notre serveur et effectuons une requête HTTP POST vers localhost:8080/timesheets/upload, nous devrions obtenir le message d’erreur Missing or invalid token (ce qui est tout à fait normal, puisque nous n’avons pas envoyé de jeton d’accès dans notre requête). Pour tester également le scénario où tout fonctionne, nous devons :
  • Obtenir un jeton d’accès. Pour savoir comment faire, consultez : Get an Access Token
  • Appeler l’API en ajoutant à notre requête un en-tête Authorization ayant pour valeur Bearer ACCESS_TOKEN (où ACCESS_TOKEN correspond à la valeur du jeton récupéré à la première étape).

​
Étape 3. Vérifier les autorisations de l’application

À cette étape, nous allons ajouter à notre implémentation la possibilité de vérifier si l’application dispose des autorisations (ou du scope) requises pour utiliser notre point de terminaison afin de téléverser une feuille de temps. Plus précisément, nous voulons nous assurer que le jeton possède le bon scope, soit batch:upload. Pour ce faire, nous utiliserons le package Node.js express-jwt-authz; ajoutez-le donc à votre projet : 
npm install express-jwt-authz --save
Il suffit maintenant d’ajouter un appel à jwtAuthz(...) à votre middleware pour vérifier que le JWT contient un scope particulier avant d’exécuter un point de terminaison donné. Voici notre exemple d’implémentation (une partie du code est omise par souci de concision) : 
// définir les dépendances - certains codes omis
const jwtAuthz = require('express-jwt-authz');

// Créer un middleware pour vérifier le JWT

// Activer l'utilisation du middleware d'analyse du corps de la requête
app.use(bodyParser.json());
app.use(bodyParser.urlencoded({
  extended: true
}));

// Point de terminaison de téléversement par lot
app.post('/timesheets/upload', checkJwt, jwtAuthz(['batch:upload']), function(req, res){
  var timesheet = req.body;

  // Enregistrer l'entrée de feuille de temps dans la base de données...

  // Envoyer la réponse
  res.status(201).send(timesheet);
});

// Lancer le serveur d’API à localhost:8080 - code omis
Si nous appelons notre API avec un jeton qui n’inclut pas ce scope, nous devrions obtenir le message d’erreur Forbidden avec le code d’état HTTP 403. Vous pouvez le vérifier en supprimant ce scope de votre API. Et voilà ! C’est terminé !