> ## 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.
> Scénarios de migration d’utilisateurs depuis diverses plateformes à l’aide de plusieurs méthodes.
# Scénarios de migration d’utilisateurs
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 possédez des comptes sur ces plateformes.
## Prérequis
Configurez la [connexion à une base de données personnalisée](/fr-CA/docs/authenticate/database-connections/custom-db).
1. Créez une nouvelle connexion à une base de données dans [Dashboard > Authentication > Database](https://manage.auth0.com/#/connections/database). Assurez-vous de sélectionner la vue **Custom Database** et d’activer l’option **Use my own database**.
2. Associez la base de données à l’application : dans les paramètres de votre connexion à la base de données, sélectionnez la vue **Applications**. Repérez la section **Applications Using This Connection**, puis activez la connexion à la base de données pour chaque application.
## Scénario 1 : Migrer les utilisateurs de Gigya vers Auth0
1. Exporter les utilisateurs de Gigya :
Utilisez [IdentitySync de Gigya](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, consultez [Gigya IdentitySync: Using IdentitySync](https://help.sap.com/docs/SAP_CUSTOMER_DATA_CLOUD/8b8d6fffe113457094a17701f63e3d6a/2b717202e42a4165aa7f75f7eecab64f.html?locale=en-US).
Suivez les instructions pour convertir les données des utilisateurs de votre base de données Gigya au bon [schéma](/fr-CA/docs/manage-users/user-migration/bulk-user-import-database-schema-and-examples), puis exporter les données converties au format JSON.
2. Importer vos utilisateurs Gigya dans Auth0 :
Vous pouvez importer des utilisateurs à l’aide de l’[extension User Import/Export](/fr-CA/docs/manage-users/user-migration/user-import-export-extension) ou de la [Management API](https://auth0.com/docs/api/management/v2).
* **Extension User Import/Export** : Accédez à [Auth0 Dashboard > Extensions](https://manage.auth0.com/#/extensions), sélectionnez l’extension **User Import / Export**, puis installez-la. Une fois l’extension installée, vous pouvez cliquer dessus pour ouvrir l’interface d’importation/exportation.
Glissez votre fichier JSON exporté des utilisateurs Gigya dans la zone de téléversement prévue à cet effet, puis sélectionnez la base de données que vous avez créée précédemment. Sélectionnez **Start Importing Users** pour lancer l’importation. Pour en savoir plus, consultez [extension User Import/Export](/fr-CA/docs/manage-users/user-migration/user-import-export-extension).
* **Management API** : [Créez une tâche](https://auth0.com/docs/api/management/v2#!/Jobs/post_users_imports) pour importer vos utilisateurs dans Auth0. Pour obtenir des instructions détaillées, consultez [Bulk User Imports](/fr-CA/docs/manage-users/user-migration/bulk-user-imports).
## Scénario 2 : Migrer les utilisateurs d’Okta vers Auth0
1. Activez l’importation des utilisateurs : accédez à [Auth0 Dashboard > Authentication > Database](https://manage.auth0.com/#/connections/database) et sélectionnez votre connexion de base de données. Dans ses **paramètres**, activez l’option **Import Users to Auth0**.
2. Créez le [script de connexion](/fr-CA/docs/authenticate/database-connections/custom-db/templates/login) : le script **Login** s’exécute lorsqu’un utilisateur tente de se connecter, mais que son compte est introuvable dans la base de données d’Auth0. Vous devez créer un script qui appellera le point de terminaison [Primary Authentication](https://developer.okta.com/docs/api/resources/authn.html#primary-authentication) d’Okta, en transmettant l’adresse courriel et le mot de passe dans les paramètres `username` et `password`.
Si l’authentification réussit, Okta renverra un [objet Authentication Transaction](https://developer.okta.com/docs/api/resources/authn.html#authentication-transaction-model), qui contient le [profil de l’utilisateur](https://developer.okta.com/docs/api/resources/authn.html#user-profile-object) dans les [ressources intégrées](https://developer.okta.com/docs/api/resources/authn.html#embedded-resources). Vous pourrez ensuite extraire les renseignements 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, repérez **Scripts d’action de la base de données**, puis sélectionnez **Login**.
```javascript lines expandable theme={null}
function login (email, password, callback) {
// Remplacez {yourOktaDomain} par votre propre domaine Okta
var url = 'https:/{yourOktaDomain}/api/v1/authn';
// Effectuez la requête POST pour authentifier un utilisateur
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) {
// Vérifiez que la réponse est bien réussie
if (response.statusCode !== 200) return callback();
// Récupérez l'utilisateur à partir du corps de la réponse
var user = body._embedded.user;
// Définissez les données à stocker dans Auth0 et migrez l'utilisateur
return callback(null, {
user_id : user.id,
username: user.profile.login,
email: user.profile.login,
// Nous définissons email_verified à true en supposant que si l'utilisateur était valide
// dans Okta, il a déjà vérifié son adresse courriel
// Si ce champ n'est pas défini, l'utilisateur recevra un courriel lui demandant de vérifier
// son compte
email_verified: true,
name: user.profile.firstName + ' ' + user.profile.lastName
});
});
}
```
Cliquez sur le bouton **Try** au-dessus du script pour vérifier que le script fonctionne.
3. Créez le [script Get User](/fr-CA/docs/authenticate/database-connections/custom-db/templates/get-user) : le script **Get User** s’exécute lorsque l’utilisateur tente de réinitialiser son mot de passe, mais que son compte est introuvable dans la base de données d’Auth0. Vous devrez créer un script qui appelle le point de terminaison Okta [Get User with Login](https://developer.okta.com/docs/api/resources/users.html#get-user-with-login) en passant l’adresse courriel de l’utilisateur comme paramètre `login`.
Vous devrez également [créer un jeton d’API](https://developer.okta.com/docs/api/getting_started/getting_a_token.html), qui devra être transmis à ce point de terminaison dans l’en-tête `Authorization`.
Si la requête réussit, Okta renverra un [objet User](https://developer.okta.com/docs/api/resources/users.html#user-model) contenant les renseignements de l’utilisateur. Là encore, vous pouvez extraire les renseignements 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, repérez **Scripts d’action de la base de données**, puis sélectionnez **Get User**.
```javascript lines expandable theme={null}
function getByEmail(email, callback) {
// Remplacez {yourOktaDomain} par votre propre domaine Okta
var url = 'https://{yourOktaDomain}/api/v1/users/' + encodeURIComponent(email);
// Effectuez une requête GET pour trouver un utilisateur par courriel
// Remplacez {yourOktaApiToken} par un jeton d'API Okta
// (voir 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) {
// Vérifiez que la réponse est bien réussie
if (response.statusCode !== 200) return callback();
// Définissez les données à stocker dans Auth0 et migrez l'utilisateur
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 **Try** au-dessus du script pour tester si le script fonctionne.
4. Testez la connexion à la base de données personnalisée : cliquez sur **Try connection**. Le [widget Auth0 Lock](/fr-CA/docs/libraries/lock) s’affichera. Entrez l’adresse courriel et le mot de passe de l’utilisateur Okta, puis cliquez sur **Log In.** Une page Web indiquant que la connexion fonctionne devrait s’afficher, avec des renseignements sur l’utilisateur.
5. Pour voir les utilisateurs nouvellement importés, accédez à [Tableau de bord Auth0 > Gestion des utilisateurs > Utilisateurs](https://manage.auth0.com/#/users).
## Scénario 3 : Migrer les utilisateurs de Stormpath vers Auth0
1. Activez l’importation des utilisateurs : accédez à [Auth0 Dashboard > Authentication > Database](https://manage.auth0.com/#/connections/database) et sélectionnez votre connexion de base de données. Dans les **Settings**, activez l’option **Import Users to Auth0**.
2. Activez les applications pour cette connexion : sélectionnez la vue **Applications**. Activez les applications qui utiliseront la connexion à la base de données.
3. Créez le [script Login](/fr-CA/docs/authenticate/database-connections/custom-db/templates/login) : le script **Login** s’exécute 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, en transmettant ses identifiants dans les paramètres `username` et `password`.
Une fois l’authentification réussie, la réponse de Stormpath inclura l’URL du compte utilisateur. Effectuez une deuxième requête à l’URL du compte pour récupérer les renseignements de l’utilisateur. Vous pourrez ensuite extraire ces renseignements et les transmettre à Auth0 dans la fonction de rappel.
```javascript lines expandable theme={null}
function login(username, password, callback) {
// Remplacez l'attribut {yourStormpathClientId} par votre identifiant Stormpath
var url = 'https://api.stormpath.com/v1/applications/{yourStormpathClientId}/loginAttempts';
// Stormpath exige que les informations d'identification de l'utilisateur soient transmises sous forme de message encodé en base64
var message = username + ':' + password;
var pass = new Buffer(message).toString('base64');
// Nous effectuons ici la requête POST pour authentifier un utilisateur
request({
url: url,
method: 'POST',
auth: {
// Votre identifiant client API
user: '{yourStormpathClientId}',
// Votre secret client API
password: '{yourStormpathClientSecret}'
},
headers: {
'Content-Type': 'application/json'
},
json: {
type: 'basic',
// Transmission des informations d'identification encodées en base64
value: pass
}
}, function (error, response, body) {
// Si la réponse est réussie, on continue
if (response.statusCode !== 200) return callback();
// Une réponse réussie retourne une URL pour récupérer les informations de l'utilisateur
var accountUrl = body.account.href;
// Nous effectuons une deuxième requête pour récupérer les informations de l'utilisateur. Cette fois, il s'agit d'une requête GET
request({
url: accountUrl,
method: 'GET',
auth: {
// Votre identifiant client API
user: '{yourStormpathClientId}',
// Votre secret client API
password: '{yourStormpathClientSecret}'
}
}, function (errorUserInfo, responseUserInfo, bodyUserInfo) {
// Si la réponse est réussie, on la traite
if (responseUserInfo.statusCode !== 200) return callback();
var parsedBody = JSON.parse(bodyUserInfo);
// Pour obtenir l'identifiant de l'utilisateur, on retire la partie API Stormpath
var id = parsedBody.href.replace('https://api.stormpath.com/v1/accounts/', '');
// Enfin, on définit les données à stocker dans Auth0 et on migre l'utilisateur
return callback(null, {
user_id : id,
username: parsedBody.username,
email: parsedBody.email,
// On définit email_verified à true, car on suppose que si l'utilisateur était valide
// dans Stormpath, il a déjà vérifié son adresse courriel
// Si ce champ n'est pas défini, l'utilisateur recevra un courriel lui demandant de vérifier
// son compte
email_verified: true,
// Ajoutez tout champ supplémentaire à transférer depuis Stormpath
});
});
});
}
```
Cliquez sur le bouton **Try** au-dessus du script pour l’essayer et vérifier s’il fonctionne.
4. Créez le [script Get User](/fr-CA/docs/authenticate/database-connections/custom-db/templates/get-user) : le script **Get User** s’exécute lorsque l’utilisateur tente de réinitialiser son mot de passe, mais que son compte est introuvable dans la base de données Auth0. Vous devrez créer un script qui appellera le point de terminaison `/accounts` de l’API Stormpath en transmettant l’adresse courriel de l’utilisateur comme paramètre `email`.
En cas de succès, Stormpath renverra les informations de l’utilisateur. Vous pourrez les extraire et les transmettre à Auth0 dans la fonction de rappel.
```javascript lines expandable theme={null}
function getByEmail(email, callback) {
// Remplacez l'attribut {yourStormpathClientId} par votre identifiant Stormpath
var url = 'https://api.stormpath.com/v1/applications/{yourStormpathClientId}/accounts';
request({
url: url,
method: 'GET',
auth: {
// Votre identifiant client API
user: '{yourStormpathClientId}',
// Votre secret client API
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,
// Ajoutez tout champ supplémentaire que vous souhaitez conserver depuis Stormpath
});
});
}
```
Cliquez sur le bouton **Try** au-dessus du script pour le tester et vérifier qu’il fonctionne.
5. Testez la connexion à la base de données personnalisée : cliquez sur **Try connection**. Le [widget Auth0 Lock](/fr-CA/docs/libraries/lock) s’affichera. Entrez l’adresse courriel et le mot de passe de l’utilisateur Stormpath, puis cliquez sur **Log In.** Vous devriez voir une page Web indiquant que la connexion fonctionne, accompagnée de renseignements sur l’utilisateur.
6. Pour voir les utilisateurs qui viennent d’être importés, accédez à [Tableau de bord > Gestion des utilisateurs > Utilisateurs](https://manage.auth0.com/#/users).