> ## 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.
> Configuration d’Auth0 pour le scénario d’architecture Mobile + API
# Configuration d’Auth0 (applications mobiles + API)
Dans cette section, nous passerons en revue toutes les configurations à effectuer dans l’[Auth0 Dashboard](https://manage.auth0.com/#).
## Créer l’API
Cliquez sur l’[option APIs du menu](https://manage.auth0.com/#/apis) à gauche, puis sur le bouton Create API.
Vous devrez fournir les renseignements suivants pour votre API :
* **Nom** : un nom convivial pour l’API. N’affecte aucune fonctionnalité.
* **Identifiant** : 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’appellera jamais votre API. Cette valeur ne peut pas être modifiée par la suite.
* **Algorithme de signature** : l’algorithme utilisé pour signer les jetons. Les valeurs disponibles sont `HS256` et `RS256`. Si vous sélectionnez RS256, le jeton sera signé avec la clé privée du locataire. Pour en savoir plus sur les algorithmes de signature, consultez [Algorithmes de signature](/fr-CA/docs/get-started/applications/signing-algorithms).
Remplissez les renseignements requis, puis cliquez sur le bouton **Create**.
#### Algorithmes de signature
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’expéditeur du JWT est bien celui qu’il prétend être et à s’assurer que le message n’a pas été modifié en cours de route.
La signature fait partie d’un JWT. Si la structure d’un JWT ne vous est pas familière, consultez [Structure d’un JSON Web Token](/fr-CA/docs/secure/tokens/json-web-tokens/json-web-token-structure).
Pour créer la partie signature, vous devez prendre l’en-tête encodé, la charge utile encodée, un secret et l’algorithme indiqué dans l’en-tête, puis signer le tout. 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 détient la clé secrète, qui sert à générer la signature, et le consommateur du JWT détient 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. Des précautions particulières doivent être prises pour que la clé demeure confidentielle.
La pratique la plus sécuritaire, et celle que nous recommandons, consiste à utiliser **RS256**. Voici quelques raisons :
* Avec RS256, vous avez l’assurance que seul le détenteur de la clé privée (Auth0) peut signer les 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 mettre en œuvre une rotation des clés sans avoir à redéployer l’API avec le nouveau secret.
Pour un aperçu plus détaillé des algorithmes de signature JWT, consultez : [Présentation des algorithmes de signature JSON Web Token (JWT)](https://auth0.com/blog/json-web-token-signing-algorithms-overview/).
### Configurer les autorisations
Une fois l’application créée, vous devrez configurer les autorisations que les applications peuvent demander lors de 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`.
## Créer l’application
Il existe quatre types d’applications dans Auth0 : **Native App** (utilisée par les applications mobiles ou de bureau), **Single-Page Web App**, **Regular Web App** et **Machine to Machine App** (utilisée par les interfaces de ligne de commande, les démons ou les 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 le type d’application Native.
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**.
Attribuez un nom à votre application (nous utiliserons `Timesheets Mobile`) et sélectionnez `Native App` comme type.
Cliquez sur **Create**.
## Configurer l’extension Authorization
Vous devez vous assurer que l’extension Authorization est installée pour votre locataire. Consultez la [documentation de l’extension Authorization](/fr-CA/docs/customize/extensions/authorization-extension) pour savoir comment procéder.
### Définir les autorisations
Vous devrez définir les autorisations 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, renseignez les détails de chaque autorisation. Assurez-vous que le nom de l’autorisation est exactement le même que le scope correspondant :
Créez ensuite les autorisations pour tous les scopes restants :
### Définir des rôles
Accédez à l’onglet Roles et créez deux roles. Cliquez sur le bouton **Create Role** et sélectionnez l’application **Timesheets SPA**. Donnez au rôle le nom et la description Employee, puis sélectionnez les autorisations `delete:timesheets`, `create:timesheets` et `read:timesheets`. Cliquez sur **Save**.
Ensuite, suivez le même processus pour créer un rôle **Manager** et assurez-vous d’avoir sélectionné toutes les autorisations :
### Attribuer des rôles aux utilisateurs
Vous devrez attribuer à tous les utilisateurs le rôle Manager ou User. Pour ce faire, accédez à l’onglet Users de l’Authorization Extension et sélectionnez un utilisateur. À l’écran d’information de l’utilisateur, accédez à 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é.
### Configuration de l’Authorization Extension
Vous devrez aussi vous assurer que la Rule de l’Authorization Extension est publiée. Pour ce faire, cliquez sur l’avatar de votre profil 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**.
### Créer une Rule pour valider les scopes du jeton
La dernière étape de ce processus consiste à créer une Rule qui validera que les scopes contenus dans un Jeton d’accès sont valides en fonction des autorisations 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 Auth0 Dashboard, 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 **Scopes du Jeton d’accès**, 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 garantit que tous les jetons d’accès ne contiendront que des scopes au format approprié (p. ex., `action:area` ou `delete:timesheets`) qui sont valides en fonction des autorisations de l’utilisateur. Une fois que vous avez terminé, vous pouvez cliquer sur le bouton **Save**.
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, afin qu’elle s’exécute après celle de l’Authorization Extension.
TUTORIEL PRÉCÉDENT [1. Aperçu de la solution](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/part-1)
TUTORIEL SUIVANT [3. API + implémentation mobile](/fr-CA/docs/get-started/architecture-scenarios/mobile-api/api-implementation-nodejs)