> ## Documentation Index
> Fetch the complete documentation index at: https://translations.mintlify.site/llms.txt
> Use this file to discover all available pages before exploring further.

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

# Implémentation de l’application (applications 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](/fr-CA/docs/get-started/architecture-scenarios/server-application-api).

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  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.
</Callout>

<div id="define-the-api-endpoints">
  ## Définir les points de terminaison de l’API
</div>

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 |

```json lines theme={null}
{
  '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 :

```json lines theme={null}
{
"message": "Created timesheet 14 for employee 007."
}
```

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Consultez l’implémentation en [Node.js](/fr-CA/docs/get-started/architecture-scenarios/server-application-api/api-implementation-nodejs#1-define-the-api-endpoint).
</Callout>

<div id="secure-the-api-endpoints">
  ### Sécuriser les points de terminaison de l’API
</div>

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 <Tooltip tip="Jeton d’accès : justificatif d’autorisation, sous la forme d’une chaîne opaque ou d’un JWT, utilisé pour accéder à une API." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=access+token">jeton d’accès</Tooltip> 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**](/fr-CA/docs/get-started/architecture-scenarios/server-application-api/api-implementation-nodejs#2-secure-the-api-endpoint)**.**

<div id="get-an-access-token">
  #### Obtenir un jeton d’accès
</div>

Pour obtenir un jeton d’accès sans utiliser notre exemple d’implémentation d’application, appelez le point de terminaison [Get Token](https://auth0.com/docs/api/authentication#get-token54) de l’Auth0 Authentication API avec le payload suivant :

```json lines theme={null}
{
  audience: "{yourApiIdentifier}",
  grant_type: "client_credentials",
  client_id: "${account.client_id}",
  client_secret: "${account.client_secret}"
}
```

<div id="check-the-application-permissions">
  ## Vérifier les permissions de l’application
</div>

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](/fr-CA/docs/get-started/architecture-scenarios/server-application-api/part-3#configure-the-scopes).

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

**Consultez l’implémentation dans** [**Node.js**](/fr-CA/docs/get-started/architecture-scenarios/server-application-api/api-implementation-nodejs#3-check-the-client-permissions)**.**

<div id="implement-the-machine-to-machine-application">
  ### Mettre en œuvre l’application Machine-to-Machine
</div>

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](https://manage.auth0.com/#/applications) :

* **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`.
* **<Tooltip tip="Audience : identifiant unique de l’audience d’un jeton émis. Nommée aud dans un jeton, sa valeur contient l’ID d’une application (ID client) pour un ID Token ou d’une API (identifiant d’API) pour un Jeton d’accès." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Audience">Audience</Tooltip>** : identifiant d’API.
* **<Tooltip tip="ID client : valeur d’identification attribuée par Auth0 à votre ressource enregistrée." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Client+ID">ID client</Tooltip>** : ID client de l’application Auth0.
* **<Tooltip tip="Secret client : secret utilisé par une application pour s’authentifier auprès du serveur d’autorisation ; il ne doit être connu que de l’application et du serveur d’autorisation et doit être suffisamment aléatoire pour ne pas pouvoir être deviné." cta="Voir le glossaire" href="/fr-CA/docs/glossary?term=Client+Secret">Secret client</Tooltip>** : 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 :

```json lines theme={null}
{
  "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](/fr-CA/docs/get-started/authentication-and-authorization-flow/client-credentials-flow/call-your-api-using-the-client-credentials-flow).

**Voir l’implémentation en** [**Python**](/fr-CA/docs/get-started/architecture-scenarios/server-application-api/cron-implementation-python#get-an-access-token).

<div id="invoke-the-api">
  ## Appeler l’API
</div>

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**](/fr-CA/docs/get-started/architecture-scenarios/server-application-api/cron-implementation-python#invoke-the-api).