Implémentation de l’application (applications serveur + API)

Implémentation de l’application pour le scénario d’architecture Serveur + API

Dans cette section du tutoriel, nous examinerons en détail notre API et l’application Machine-to-Machine qui lui est associée. Si vous souhaitez repartir du début, consultez Applications serveur avec API.

Par souci de simplicité, notre implémentation portera uniquement sur l’authentification et l’autorisation. Comme vous le verrez dans les exemples, l’entrée de feuille de temps sera codée en dur, et l’API ne la conservera pas. Elle renverra simplement une partie des informations.

​

Définir les points de terminaison de l’API

Un point de terminaison est un URI statique qui représente une ressource (collection de données).

Par exemple, l’API d’un restaurant pourrait avoir des points de terminaison comme /orders et /customers. Une application qui se connecte à cette API peut effectuer des opérations CRUD (créer, lire, mettre à jour, supprimer) en appelant un point de terminaison avec la méthode HTTP correspondante (POST, GET, PUT, PATCH ou DELETE).

Pour l’API Timesheets d’ExampleCo, vous devrez configurer un point de terminaison pour créer des entrées de feuille de temps.

Méthode HTTP	Point de terminaison	Description
POST	/timesheets/upload	Crée une nouvelle entrée de feuille de temps

{
  'user_id': '007',
  'date': '2017-05-10T17:40:20.095Z',
  'project': 'StoreZero',
  'hours': 5
}

Si l’API traite la requête avec succès, elle renvoie une réponse avec le code d’état HTTP 201 Created et un corps contenant un objet JSON avec une propriété message qui décrit la feuille de temps nouvellement créée :

{
"message": "Created timesheet 14 for employee 007."
}

Consultez l’implémentation en Node.js.

​

Sécuriser les points de terminaison de l’API

Pour sécuriser les points de terminaison de votre API, vous devez implémenter une fonction de middleware dans votre application API pour gérer les jetons. Cette fonction vérifie si un jeton a été inclus dans la requête API, valide le jeton, puis vérifie que les scopes requis pour exécuter l’action demandée sont présents.

Si tous les critères sont remplis, l’application API renvoie le message mentionné précédemment. S’il y a le moindre problème avec le jeton d’accès fourni (ou s’il n’est pas fourni du tout), l’application API renvoie une réponse avec le code d’état HTTP 401 Unauthorized.

Consultez l’implémentation dans Node.js.

​

Obtenir un jeton d’accès

Pour obtenir un jeton d’accès sans utiliser notre exemple d’implémentation d’application, appelez le point de terminaison Get Token de l’Auth0 Authentication API avec le payload suivant :

{
  audience: "{yourApiIdentifier}",
  grant_type: "client_credentials",
  client_id: "${account.client_id}",
  client_secret: "${account.client_secret}"
}

​

Vérifier les permissions de l’application

Nous avons maintenant sécurisé le point de terminaison de notre API avec un jeton d’accès, mais nous n’avons toujours pas vérifié que le processus qui appelle l’API a les droits nécessaires pour publier une nouvelle entrée de feuille de temps.

Comme nous l’avons vu plus tôt, chaque jeton d’accès peut inclure une liste des permissions accordées à l’application. Ces permissions sont définies à l’aide du paramètre de requête scope. Pour savoir comment le configurer, consultez la section Configurer les scopes.

Pour notre point de terminaison, nous exigerons le scope batch:upload.

Consultez l’implémentation dans Node.js.

​

Mettre en œuvre l’application Machine-to-Machine

Dans cette section, nous verrons comment mettre en œuvre une application Machine-to-Machine dans notre scénario.

​

Obtenir un jeton d’accès

Nous allons commencer par appeler le point de terminaison d’API Auth0 /oauth/token pour obtenir un jeton d’accès.

Pour ce faire, vous aurez besoin des valeurs de configuration suivantes, que vous trouverez dans les paramètres de l’application :

• Domaine : le domaine Auth0, qui correspond aussi à l’identifiant de votre locataire. Cette valeur fera partie de l’URL de l’API : https://{yourTenant}/oauth/token.
• Audience : identifiant d’API.
• ID client : ID client de l’application Auth0.
• Secret client : Secret client de l’application Auth0.

Notre implémentation doit envoyer une requête POST au point de terminaison https://{yourDomain}/oauth/token avec un payload au format suivant :

{
  "audience": "{yourApiIdentifier}",
  "grant_type": "client_credentials",
  "client_id": "${account.client_id}",
  "client_secret": "${account.client_secret}"
}

Pour en savoir plus, consultez Appelez votre API à l’aide du flux d’identification du client.

Voir l’implémentation en Python.

​

Appeler l’API

Maintenant que nous avons un jeton d’accès qui contient les scopes valides, nous pouvons appeler notre API.

Pour ce faire, nous allons :

• Créer une entrée de feuille de temps codée en dur au format JSON.
• Ajouter le jeton d’accès en tant qu’en-tête Authorization dans notre requête.
• Effectuer la requête HTTP POST.
• Analyser la réponse et l’afficher dans le terminal (facultatif).

Consultez l’implémentation en Python.