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

> Mise en œuvre de l’application pour le scénario d’architecture serveur + API

# Mise en œuvre de l’application (applications serveur + API)

Dans cette section du tutoriel, nous examinerons en profondeur notre API et l’application machine à machine qui y est associée. Pour reprendre depuis le début, consultez [Applications serveur avec API](/docs/fr-ca/get-started/architecture-scenarios/server-application-api).

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Par souci de simplicité, nous concentrerons notre mise en œuvre uniquement sur l’authentification et l’autorisation. Comme vous le verrez dans les exemples, l’entrée de feuille de temps fournie sera codée en dur, et l’API n’enregistrera pas cette entrée de feuille de temps. Elle se contentera plutôt de renvoyer certaines informations.
</Callout>

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

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

Par exemple, l’API d’un restaurant peut 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 envoyant une requête à un point de terminaison d’API 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 d’API | 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 doté d’une propriété `message` qui décrit la nouvelle feuille de temps :

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

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Consultez la mise en œuvre en [Node.js](/docs/fr-ca/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 d’API
</div>

Pour sécuriser vos points de terminaison d’API, vous devez implémenter une fonction 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 confirme que les scopes requis pour exécuter l’action demandée sont présentes.

Si tous les critères sont remplis, l’application API renvoie le message mentionné précédemment. En cas de problème avec le <Tooltip tip="Jeton d’accès : information d’autorisation, sous forme de chaîne opaque ou de JWT, utilisée pour accéder à une API." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=access+token">jeton d’accès</Tooltip> fourni (ou s’il n’est pas fourni du tout), l’application API envoie une réponse avec le code d’état `HTTP 401 Unauthorized`.

**Consultez la mise en œuvre dans** [**Node.js**](/docs/fr-ca/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 de mise en œuvre pour l’application, envoyez une requête au point de terminaison [Obtenir un jeton](https://auth0.com/docs/api/authentication#get-token54) de l’API d’authentification Auth0 avec la charge utile suivante :

```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érifiez 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 ajouter 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 le paragraphe [Configurer les scopes](/docs/fr-ca/get-started/architecture-scenarios/server-application-api/part-3#configure-the-scopes).

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

**Consultez la mise en œuvre dans** [**Node.js**](/docs/fr-ca/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 place l’application machine à machine
</div>

Dans cette section, nous verrons comment mettre en place une application machine à machine pour 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, nous aurons besoin des valeurs de configuration suivantes, que vous trouverez dans les [paramètres de l’application](https://manage.auth0.com/#/applications) :

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

Notre mise en œuvre doit envoyer une requête `POST` au point de terminaison `https://{yourDomain}/oauth/token` avec une charge utile 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 Client Credentials Flow](/docs/fr-ca/get-started/authentication-and-authorization-flow/client-credentials-flow/call-your-api-using-the-client-credentials-flow).

**Voir la mise en œuvre en** [**Python**](/docs/fr-ca/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 comprend 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 dans l’en-tête `Authorization` de notre requête.
* Envoyer la requête HTTP `POST`.
* Analyser la réponse et l’afficher dans le terminal (facultatif).

**Consultez la mise en œuvre en** [**Python**](/docs/fr-ca/get-started/architecture-scenarios/server-application-api/cron-implementation-python#invoke-the-api).