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

> Auth0 Configuration pour le scénario d’architecture Mobile + API

# Auth0 Configuration (Apps mobiles + API)

Dans cette section, nous passerons en revue toutes les configurations à appliquer dans l’[Auth0 Dashboard](https://manage.auth0.com/#).

<div id="create-the-api">
  ## Créer l’API
</div>

Cliquez sur l’[option de menu APIs](https://manage.auth0.com/#/apis) à gauche, puis sur le bouton Create API.

Vous devrez fournir les renseignements suivants pour votre API :

* **Name** : un nom convivial pour l’API. N’affecte aucune fonctionnalité.
* **Identifier** : un identifiant unique pour l’API. Nous vous recommandons d’utiliser une URL, mais notez qu’il n’est pas nécessaire qu’elle soit accessible publiquement : Auth0 n’effectuera aucune requête vers votre API. Cette valeur ne peut pas être modifiée par la suite.
* **<Tooltip tip="Algorithme de signature : algorithme utilisé pour signer numériquement des jetons afin de s’assurer que le jeton n’a pas été altéré." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Signing+Algorithm">Algorithme de signature</Tooltip>** : l’algorithme utilisé pour signer les jetons. Les valeurs possibles sont `HS256` et `RS256`. Si vous sélectionnez RS256, le jeton sera signé avec la clé privée du tenant. Pour en savoir plus sur les algorithmes de signature, consultez [Algorithmes de signature](/docs/fr-ca/get-started/applications/signing-algorithms).

<Frame>
  <img src="https://mintcdn.com/translations/pvjQqAy3EB2TK6NP/docs/images/cdy7uua7fh8z/4kIH4BQc4vDel2zhJ6lwCE/094cff6e8e1788c39796eb28ab1925ca/2024-06-27_14-50-24.png?fit=max&auto=format&n=pvjQqAy3EB2TK6NP&q=85&s=ba2b5abee5018b4b55bd3e136e6673ac" alt="Dashboard - Applications - APIs - Create API - Popup" width="624" height="736" data-path="docs/images/cdy7uua7fh8z/4kIH4BQc4vDel2zhJ6lwCE/094cff6e8e1788c39796eb28ab1925ca/2024-06-27_14-50-24.png" />
</Frame>

Remplissez les renseignements requis, puis cliquez sur le bouton **Create**.

<div id="signing-algorithms">
  #### Algorithmes de signature
</div>

Lorsque vous créez une API, vous devez sélectionner l’algorithme avec lequel vos jetons seront signés. La signature sert à vérifier que l’émetteur du <Tooltip tip="JSON Web Token (JWT) : format standard d’ID Token (et souvent d’Access Token) utilisé pour représenter des claims de façon sécurisée entre deux parties." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=JWT">JWT</Tooltip> est bien celui qu’il prétend être et à s’assurer que le message n’a pas été modifié en cours de route.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  La signature fait partie d’un JWT. Si vous ne connaissez pas bien la structure d’un JWT, veuillez consulter [Structure du JSON Web Token](/docs/fr-ca/secure/tokens/json-web-tokens/json-web-token-structure).
</Callout>

Pour créer la partie signature, vous devez prendre l’en-tête encodé, le payload encodé, un secret, l’algorithme indiqué dans l’en-tête, puis signer l’ensemble. Cet algorithme, qui fait partie de l’en-tête du JWT, est celui que vous sélectionnez pour votre API : `HS256` ou `RS256`.

* **RS256** est un [algorithme asymétrique](https://en.wikipedia.org/wiki/Public-key_cryptography), ce qui signifie qu’il y a deux clés : une publique et une privée (secrète). Auth0 possède la clé secrète, qui sert à générer la signature, et le consommateur du JWT possède la clé publique, qui sert à valider la signature.
* **HS256** est un [algorithme symétrique](https://en.wikipedia.org/wiki/Symmetric-key_algorithm), ce qui signifie qu’il n’y a qu’une seule clé secrète, partagée entre les deux parties. La même clé sert à la fois à générer la signature et à la valider. Il faut donc prendre des précautions particulières pour que la clé demeure confidentielle.

La pratique la plus sécuritaire, et celle que nous recommandons, est d’utiliser **RS256**. Voici quelques raisons :

* Avec RS256, vous avez l’assurance que seul le détenteur de la clé privée (Auth0) peut signer des jetons, tandis que n’importe qui peut vérifier si le jeton est valide à l’aide de la clé publique.
* Avec HS256, si la clé privée est compromise, vous devrez redéployer l’API avec le nouveau secret. Avec RS256, vous pouvez demander un jeton valide pour plusieurs audiences.
* Avec RS256, vous pouvez effectuer une rotation des clés sans avoir à redéployer l’API avec le nouveau secret.

<Callout icon="file-lines" color="#0EA5E9" iconType="regular">
  Pour un aperçu plus détaillé des algorithmes de signature JWT, consultez : [Vue d’ensemble des algorithmes de signature de JSON Web Token (JWT)](https://auth0.com/blog/json-web-token-signing-algorithms-overview/).
</Callout>

<div id="configure-the-permissions">
  ### Configurer les Permissions
</div>

Une fois l’application créée, vous devrez configurer les Permissions que les applications pourront demander pendant l’autorisation.

Dans les paramètres de votre API, accédez à l’onglet **Permissions**. Dans cette section, vous pouvez ajouter les quatre scopes mentionnés précédemment, soit `read:timesheets`, `create:timesheets`, `delete:timesheets`, `approve:timesheets`.

<Frame>
  <img src="https://mintcdn.com/translations/xwVvTWJUElMm5YAK/docs/images/cdy7uua7fh8z/xxMOKezob6gNHJ0CcKhcg/ccbb9bbab29576a96ed8425329ecffb4/dashboard-apis-edit_view-permissions.png?fit=max&auto=format&n=xwVvTWJUElMm5YAK&q=85&s=b9f2abf9032519ff3382e45a2f73596b" alt="Dashboard - Applications - APIs - Permissions" width="1260" height="784" data-path="docs/images/cdy7uua7fh8z/xxMOKezob6gNHJ0CcKhcg/ccbb9bbab29576a96ed8425329ecffb4/dashboard-apis-edit_view-permissions.png" />
</Frame>

<div id="create-the-application">
  ## Créer l’application
</div>

Auth0 propose quatre types d’application : **Native App** (utilisée par les applis mobiles ou de bureau), **Single-Page Web App**, **Regular Web App** et **Machine to Machine App** (utilisée par des CLI, des daemons ou des services exécutés sur votre backend). Dans ce scénario, nous voulons créer une nouvelle Application pour notre application mobile; nous utiliserons donc **Native** comme type d’application.

Pour créer une nouvelle Application, accédez au [dashboard](https://manage.auth0.com/#), puis cliquez sur l’option de menu [Applications](https://manage.auth0.com/#/applications) à gauche. Cliquez sur le bouton **+ Create Application**.

Donnez un nom à votre Application (nous utiliserons `Timesheets Mobile`) et sélectionnez `Native App` comme type.

Cliquez sur **Create**.

<div id="configure-the-authorization-extension">
  ## Configurer l’Authorization Extension
</div>

Vous devrez vous assurer que l’Authorization Extension est installée dans votre tenant. Vous pouvez consulter la [documentation de l’Authorization Extension](/docs/fr-ca/customize/extensions/authorization-extension) pour savoir comment procéder.

<div id="define-permissions">
  ### Définir les permissions
</div>

Vous devrez définir des permissions qui correspondent aux scopes que vous avez déjà définis. Dans l’Authorization Extension, cliquez sur l’onglet Permissions, puis sur le bouton **Create Permission**. Dans la boîte de dialogue, saisissez les détails de chaque permission. Assurez-vous que le nom de la permission est exactement le même que le scope correspondant :

Créez ensuite les permissions pour tous les scopes restants :

<div id="define-roles">
  ### Définir des rôles
</div>

Rendez-vous dans l’onglet Roles et créez deux rôles. Cliquez sur le bouton **Create Role**, puis sélectionnez l’application **Timesheets SPA**. Donnez au rôle le nom et la description Employee, puis sélectionnez les permissions `delete:timesheets`, `create:timesheets` et `read:timesheets`. Cliquez sur **Enregistrer**.

Ensuite, suivez le même processus pour créer le rôle **Manager** et assurez-vous d’avoir sélectionné toutes les permissions :

<Frame>
  <img src="https://mintcdn.com/translations/3nS3prIggmJG9TUI/docs/images/cdy7uua7fh8z/3ver0yyJpTLypmcIDzwSNt/d880e8ae74e6e973c7ce1c8b0f7e7c87/create-manager-role.png?fit=max&auto=format&n=3nS3prIggmJG9TUI&q=85&s=358c25585d11bdd92b059d30edd235af" alt="Dashboard - Extensions - Authorization Extension - Create Manager Role" width="2624" height="2024" data-path="docs/images/cdy7uua7fh8z/3ver0yyJpTLypmcIDzwSNt/d880e8ae74e6e973c7ce1c8b0f7e7c87/create-manager-role.png" />
</Frame>

<div id="assign-users-to-roles">
  ### Attribuer des utilisateurs à des rôles
</div>

Vous devrez attribuer tous les utilisateurs soit au rôle Manager, soit au rôle User. Pour ce faire, allez à l’onglet Users de l’Authorization Extension et sélectionnez un utilisateur. À l’écran d’information de l’utilisateur, allez à l’onglet Roles. Vous pouvez ajouter un rôle à l’utilisateur en cliquant sur le bouton **Add Role to User** et en sélectionnant le rôle approprié.

<div id="configuring-the-authorization-extension">
  ### Configuration de l’Authorization Extension
</div>

Vous devez aussi vous assurer que la Rule de l’Authorization Extension est bien publiée. Pour ce faire, cliquez sur votre avatar dans le coin supérieur droit de l’Authorization Extension, puis sélectionnez l’option **Configuration** :

Assurez-vous d’avoir activé **Permissions**, puis cliquez sur le bouton **Publish Rule**.

<div id="create-a-rule-to-validate-token-scopes">
  ### Créer une Rule pour valider les scopes du jeton
</div>

La dernière étape de ce processus consiste à créer une Rule qui validera que les scopes contenus dans un <Tooltip tip="Jeton d’accès : information d’identification d’autorisation, sous la forme d’une chaîne opaque ou d’un 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> sont valides en fonction des permissions attribuées à l’utilisateur. Tous les scopes qui ne sont pas valides pour un utilisateur doivent être supprimés du jeton d’accès.

Dans votre <Tooltip tip="Auth0 Dashboard : principal produit d’Auth0 pour configurer vos services." cta="Voir le glossaire" href="/docs/fr-ca/glossary?term=Auth0+Dashboard">Auth0 Dashboard</Tooltip>, accédez à l’onglet Rules. Vous devriez voir la Rule créée par l’Authorization Extension.

Cliquez sur le bouton **Create Rule** et sélectionnez le modèle **Empty Rule**. Vous pouvez donner un nom à la Rule, par exemple **Access Token Scopes**, puis indiquer le code suivant pour la Rule :

```javascript lines theme={null}
function (user, context, callback) {
  if (context.clientName !== 'Timesheets SPA') {
    return callback(null, user, context);
  }

  var permissions = user.permissions || [];
  var requestedScopes = context.request.body.scope || context.request.query.scope;
  var filteredScopes = requestedScopes.split(' ').filter( function(x) {
    return x.indexOf(':') < 0;
  });
  Array.prototype.push.apply(filteredScopes, permissions);
  context.accessToken.scope = filteredScopes.join(' ');

  callback(null, user, context);
}
```

Le code ci-dessus garantira que tous les jetons d’accès ne contiennent que des scopes correctement formatés (p. ex., `action:area` ou `delete:timesheets`) qui sont valides selon les permissions de l’utilisateur. Une fois terminé, vous pouvez cliquer sur le bouton **Enregistrer**.

Les Rules s’exécutent dans l’ordre où elles sont affichées sur la page Rules; assurez-vous donc que la nouvelle règle que vous avez créée est placée sous la règle de l’Authorization Extension, pour qu’elle s’exécute après la règle Authorization Extension.

TUTORIEL PRÉCÉDENT [1. Aperçu de la solution](/docs/fr-ca/get-started/architecture-scenarios/mobile-api/part-1)

TUTORIEL SUIVANT [3. API + mise en œuvre mobile](/docs/fr-ca/get-started/architecture-scenarios/mobile-api/api-implementation-nodejs)