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

# Scénarios de migration des utilisateurs

> Les scénarios de migration d’utilisateurs à partir de diverses plateformes utilisent plusieurs méthodes.

Voici quelques exemples de scénarios de migration d’utilisateurs de Gigya, Okta et Stormpath vers Auth0. Chacun de ces scénarios suppose que vous avez des comptes sur ces plateformes.

## Prérequis

Configurez la [connexion à la base de données personnalisée](/docs/fr-ca/authenticate/database-connections/custom-db).

1. Créez une nouvelle connexion à la base de données dans [Dashboard > Authentification > Base de données](https://manage.auth0.com/#/connections/database). Veillez à sélectionner la vue **Base de données personnalisée** et à activer le bouton à bascule **Utiliser ma propre base de données**.
2. Connectez la base de données à l’application : Dans vos réglages de connexion à la base de données, sélectionnez la vue **Applications**. Localisez la section **Applications utilisant cette connexion** et activez la connexion à la base de données pour chaque application.

## Scénario 1 : Migrer les utilisateurs de Gigya vers Auth0

1. Exportez les utilisateurs de Gigya : Utilisez [Gigya’s IdentitySync](https://help.sap.com/docs/SAP_CUSTOMER_DATA_CLOUD/8b8d6fffe113457094a17701f63e3d6a/2b717202e42a4165aa7f75f7eecab64f.html) pour transformer et exporter les données des utilisateurs afin qu’elles correspondent à un schéma cible. Pour en savoir plus sur ce processus, voir [Gigya IdentitySync : Utiliser IdentitySync](https://help.sap.com/docs/SAP_CUSTOMER_DATA_CLOUD/8b8d6fffe113457094a17701f63e3d6a/2b717202e42a4165aa7f75f7eecab64f.html?locale=en-US).

   Suivez les instructions pour transformer les données utilisateur de votre base de données Gigya dans le [schéma](/docs/fr-ca/manage-users/user-migration/bulk-user-import-database-schema-and-examples) correct et exporter les données transformées au format JSON.
2. Importez vos utilisateurs Gigya dans Auth0 : Vous pouvez importer des utilisateurs avec [l’extension Importation/Exportation des utilisateurs](/docs/fr-ca/manage-users/user-migration/user-import-export-extension) ou [Management API](/docs/fr-ca/api/management/v2).

   * **L’extension Importation/Exportation des utilisateurs** : Allez sur [Auth0 Dashboard > Extensions](https://manage.auth0.com/#/extensions), sélectionnez l’extension **Importation/Exportation des utilisateurs** et installez-la. Une fois l’extension installée, vous pouvez cliquer dessus pour ouvrir une interface d’importation/exportation.

     Glissez votre fichier JSON d’utilisateurs Gigya exportés dans la zone de téléchargement désignée, et sélectionnez la base de données que vous avez créée précédemment. Sélectionnez **Commencer à importer des utilisateurs** pour commencer votre importation. Pour en savoir plus, voir [l’extension Importation/Exportation des utilisateurs](/docs/fr-ca/manage-users/user-migration/user-import-export-extension).
   * **Management API** : Pour importer vos utilisateurs dans Auth0, [créez une tâche](/docs/fr-ca/api/management/v2#!/Jobs/post_users_imports). Pour des instructions détaillées, lisez [Importations d’utilisateurs en lot](/docs/fr-ca/manage-users/user-migration/bulk-user-imports).

## Scénario 2 : Migrer les utilisateurs d’Okta vers Auth0

1. Activez l’importation d’utilisateurs : Allez sur [Auth0 Dashboard > Authentification > Base de données](https://manage.auth0.com/#/connections/database) et sélectionnez votre connexion à la base de données. Dans ses **Paramètres**, activez l’option **Importer les utilisateurs vers Auth0**.
2. Créez le [Connexion](/docs/fr-ca/authenticate/database-connections/custom-db/templates/login) : Le script **Connexion** est exécuté lorsqu’un utilisateur tente de se connecter, mais que son compte n’est pas trouvé dans la base de données Auth0. Vous devez créer un script qui appellera le point de terminaison Okta [Authentification primaire](https://developer.okta.com/docs/api/resources/authn.html#primary-authentication), en transmettant le courriel et le mot de passe comme paramètres `nom d’utilisateur` et `mot de passe`.
   En cas d’authentification réussie, Okta renvoie un [objet Transaction d’authentification](https://developer.okta.com/docs/api/resources/authn.html#authentication-transaction-model) dans les [ressources intégrées](https://developer.okta.com/docs/api/resources/authn.html#embedded-resources). Vous pouvez alors extraire les informations de l’utilisateur et les transmettre à Auth0 dans la fonction de rappel.

   Dans la vue **Base de données personnalisée** de votre connexion à la base de données, localisez **Scripts d’action de base de données** et sélectionnez **Connexion**.

   ```javascript lines expandable theme={null}
   function login (email, password, callback) {
     // Replace {yourOktaDomain} with your own Okta domain
     var url = 'https:/{yourOktaDomain}/api/v1/authn';

     // Make the POST request to authenticate a user
     request({
       url: url,
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
         'Accept': 'application/json'
       },
       body: {
         username: email,
         password: password,
         options: {
           multiOptionalFactorEnroll: false,
           warnBeforePasswordExpired: false
         }
       },
       json: true
     }, function (error, response, body) {
       // Ensure we have a successful response
       if (response.statusCode !== 200) return callback();

       // Get the user from the response body
       var user = body._embedded.user;

       // Set the data we want to store in Auth0 and migrate the user
       return callback(null, {
           user_id : user.id,
           username: user.profile.login,
           email: user.profile.login,
           // We set the users email_verified to true as we assume if they were a valid
           // user in Okta, they have already verified their email
           // If this field is not set, the user will get an email asking them to verify
           // their account
           email_verified: true,
           name: user.profile.firstName + ' ' + user.profile.lastName
         });
     });
   }
   ```

   Cliquez sur le bouton **Essayer** au-dessus du script pour tester le fonctionnement du script.
3. Créez le [Obtenir l’utilisateur](/docs/fr-ca/authenticate/database-connections/custom-db/templates/get-user) : Le script **Obtenir l’utilisateur** est exécuté lorsque l’utilisateur tente de réinitialiser son mot de passe mais que son compte n’est pas trouvé dans la base de données Auth0. Vous devrez créer un script qui appelle le point de terminaison Okta [Obtenir un utilisateur avec une connexion](https://developer.okta.com/docs/api/resources/users.html#get-user-with-login), en utilisant le courriel de l’utilisateur comme paramètre `Connexion`.
   Vous devrez également [Créer un jeton API](https://developer.okta.com/docs/api/getting_started/getting_a_token.html) qui doit être transmis à ce point de terminaison dans l’en-tête `Autorisation`.
   En cas de succès, Okta renverra un [Objet utilisateur](https://developer.okta.com/docs/api/resources/users.html#user-model) contenant les informations de l’utilisateur. Une fois de plus, vous pouvez extraire les informations de l’utilisateur et les transmettre à Auth0 dans la fonction de rappel.

   Dans la vue **Base de données personnalisée** de votre connexion à la base de données, localisez **Scripts d’action de base de données** et sélectionnez **Obtenir l’utilisateur**.

   ```javascript lines expandable theme={null}
   function getByEmail(email, callback) {
     // Replace {yourOktaDomain} with your own Okta domain
     var url = 'https://{yourOktaDomain}/api/v1/users/' + encodeURIComponent(email);

     // Make a GET request to find a user by email
     // Replace {yourOktaApiToken} with an Okta API Token 
     // (see https://developer.okta.com/docs/api/getting_started/getting_a_token.html) 
     request({
       url: url,
       method: 'GET',
       headers: {
         'Content-Type': 'application/json',
         'Accept': 'application/json',
         'Authorization': 'SSWS ' + '{yourOktaApiToken}'
       },
       json: true
     }, function (error, response, body) {
       // Ensure we have a successful response
       if (response.statusCode !== 200) return callback();

       // Set the data we want to store in Auth0 and migrate the user
       return callback(null, {
         user_id: body.id,
         username: body.profile.login,
         email: body.profile.login,
         email_verified: true,
         name: body.profile.firstName + ' ' + body.profile.lastName
       });
     });
   }
   ```

   Cliquez sur le bouton **Essayer** au-dessus du script pour tester le fonctionnement du script.
4. Testez la connexion à la base de données personnalisée : Cliquez sur **Try connection (Essayer la connexion)**. Le [gadget logiciel Auth0 Lock](/docs/fr-ca/libraries/lock) apparaît. Saisissez l’adresse courriel et le mot de passe de l’utilisateur Okta, puis cliquez sur **Log In (Connexion).** Vous devriez voir une page Web indiquant que la connexion fonctionne, avec des informations sur l’utilisateur.
5. Pour voir les utilisateurs nouvellement importés, allez sur  [Auth0 Dashboard > Gestion des utilisateurs > Utilisateurs](https://manage.auth0.com/#/users).

## Scénario 3 : Migrer les utilisateurs de Stormpath vers Auth0

1. Activez l’importation d’utilisateurs : Allez sur [Auth0 Dashboard > Authentification > Base de données](https://manage.auth0.com/#/connections/database) et sélectionnez votre connexion à la base de données. Dans ses **Paramètres**, activez l’option **Importer les utilisateurs vers Auth0**.
2. Activez les applications pour votre connexion : Sélectionnez les **Applications** à afficher. Activez les applications qui utiliseront la connexion à la base de données.
3. Créez le [script Connexion](/docs/fr-ca/authenticate/database-connections/custom-db/templates/login) : Le script **Connexion** est exécuté lorsqu’un utilisateur tente de se connecter, mais que son compte n’est pas trouvé dans la base de données Auth0. Vous devrez créer un script qui appelle l’API de Stormpath pour authentifier l’utilisateur, transmettant alors les informations d’identification de l’utilisateur en tant que paramètres `username` et `password`.

   Si l’authentification est réussie, la réponse de Stormpath inclura l’URL du compte de l’utilisateur. Effectuez une seconde requête à l’URL du compte pour récupérer les informations de l’utilisateur. Vous pouvez alors extraire les informations de l’utilisateur et les transmettre à Auth0 dans la fonction de rappel.

   ```javascript lines expandable theme={null}
   function login(username, password, callback) {
     // Replace the {yourStormpathClientId} attribute with your Stormpath ID
     var url = 'https://api.stormpath.com/v1/applications/{yourStormpathClientId}/loginAttempts';

     // Stormpath requires the user credentials be passed in as a base64 encoded message
     var message = username + ':' + password;
     var pass = new Buffer(message).toString('base64');

     // Here we are making the POST request to authenticate a user
     request({
       url: url,
       method: 'POST',
       auth: {
         // Your API Client ID
         user: '{yourStormpathClientId}',
         // Your API Client Secret
         password: '{yourStormpathClientSecret}'
       },
       headers: {
         'Content-Type': 'application/json'
       },
       json: {
         type: 'basic',
         // Passing in the base64 encoded credentials
         value: pass
       }
     }, function (error, response, body) {
       // If response is successful we'll continue
       if (response.statusCode !== 200) return callback();
       // A successful response will return a URL to get the user information
       var accountUrl = body.account.href;

       // We'll make a second request to get the user info. This time it will be a GET request
       request({
         url: accountUrl,
         method: 'GET',
         auth: {
           // Your API Client ID
           user: '{yourStormpathClientId}',
           // YOUR API Client Secret
           password: '{yourStormpathClientSecret}'
         }
       }, function (errorUserInfo, responseUserInfo, bodyUserInfo) {
         // If we get a successful response, we'll process it
         if (responseUserInfo.statusCode !== 200) return callback();

         var parsedBody = JSON.parse(bodyUserInfo);
         // To get the user identifier, we'll strip out the Stormpath API
         var id = parsedBody.href.replace('https://api.stormpath.com/v1/accounts/', '');

         // Finally, we'll set the data we want to store in Auth0 and migrate the user
         return callback(null, {
           user_id : id,
           username: parsedBody.username,
           email: parsedBody.email,
           // We set the users email_verified to true as we assume if they were a valid
           // user in Stormpath, they have already verified their email
           // If this field is not set, the user will get an email asking them to verify
           // their account
           email_verified: true,
           // Add any additional fields you would like to carry over from Stormpath
         });
       });
     });
   }
   ```

   Cliquez sur le bouton **Essayer** au-dessus du script pour tester et voir si le script fonctionne correctement.
4. Créez le script [Obtenir l’utilisateur](/docs/fr-ca/authenticate/database-connections/custom-db/templates/get-user) : Le script **Obtenir l’utilisateur** est exécuté lorsque l’utilisateur tente de réinitialiser son mot de passe mais que son compte n’est pas trouvé dans la base de données Auth0. Vous devrez créer un script qui appellera le point de terminaison `/accounts` de l’API de Stormpath, en utilisant le courriel de l’utilisateur comme paramètre `email`.
   En cas de succès, Stormpath renverra les informations associées à l’utilisateur. Vous pouvez extraire les informations de l’utilisateur et les transmettre à Auth0 dans la fonction de rappel.

   ```javascript lines expandable theme={null}
   function getByEmail(email, callback) {
     // Replace the {yourStormpathClientId} attribute with your Stormpath ID
     var url = 'https://api.stormpath.com/v1/applications/{yourStormpathClientId}/accounts';

     request({
       url: url,
       method: 'GET',
       auth: {
         // Your API Client ID
         user: '{yourStormpathClientId}',
         // YOUR API Client Secret
         password: '{yourStormpathClientSecret}'
       },
       qs: { q: email }
     }, function (error, response, body) {
       if (response.statusCode !== 200) return callback();

       var parsedBody = JSON.parse(body);
       var user = parsedBody.items[0];

       if (!user) return callback();

       var id = user.href.replace('https://api.stormpath.com/v1/accounts/', '');

       return callback(null, {
         user_id: id,
         username: user.username,
         email: user.email,
         email_verified: true,
         // Add any additional fields you would like to carry over from Stormpath
       });
     });
   }
   ```

   Cliquez sur le bouton **Essayer** au-dessus du script pour tester et voir si le script fonctionne.
5. Testez la connexion à la base de données personnalisée : Cliquez sur **Try connection (Tester la connexion)**. Le [gadget logiciel Auth0 Lock](/docs/fr-ca/libraries/lock) apparaît. Saisissez l’adresse courriel et le mot de passe de l’utilisateur Stormpath, et cliquez sur **Log In (Connexion).** Vous devriez voir une page Web indiquant que la connexion fonctionne, avec des informations sur l’utilisateur.
6. Pour voir les utilisateurs nouvellement importés, allez dans [Dashboard > Gestion des utilisateurs > Utilisateurs](https://manage.auth0.com/#/users).