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.

Créez une nouvelle connexion à une base de données dans Dashboard > Authentication > Database. Assurez-vous de sélectionner la vue Custom Database et d’activer l’option Use my own database.
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

Exporter les utilisateurs de Gigya : Utilisez IdentitySync de Gigya 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.

Suivez les instructions pour convertir les données des utilisateurs de votre base de données Gigya au bon schéma, puis exporter les données converties au format JSON.
Importer vos utilisateurs Gigya dans Auth0 : Vous pouvez importer des utilisateurs à l’aide de l’extension User Import/Export ou de la Management API.
- Extension User Import/Export : Accédez à Auth0 Dashboard > 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.
- Management API : Créez une tâche pour importer vos utilisateurs dans Auth0. Pour obtenir des instructions détaillées, consultez Bulk User Imports.

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

Activez l’importation des utilisateurs : accédez à Auth0 Dashboard > Authentication > Database et sélectionnez votre connexion de base de données. Dans ses paramètres, activez l’option Import Users to Auth0.

Créez le script de connexion : 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 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, qui contient le profil de l’utilisateur dans les ressources intégrées. 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.

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.

Créez le script 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 en passant l’adresse courriel de l’utilisateur comme paramètre login. Vous devrez également créer un jeton d’API, 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 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.

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.

Testez la connexion à la base de données personnalisée : cliquez sur Try connection. Le widget Auth0 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.
Pour voir les utilisateurs nouvellement importés, accédez à Tableau de bord Auth0 > Gestion des utilisateurs > Utilisateurs.

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

Activez l’importation des utilisateurs : accédez à Auth0 Dashboard > Authentication > Database et sélectionnez votre connexion de base de données. Dans les Settings, activez l’option Import Users to Auth0.
Activez les applications pour cette connexion : sélectionnez la vue Applications. Activez les applications qui utiliseront la connexion à la base de données.

Créez le script 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.

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.

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.

Testez la connexion à la base de données personnalisée : cliquez sur Try connection. Le widget Auth0 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.
Pour voir les utilisateurs qui viennent d’être importés, accédez à Tableau de bord > Gestion des utilisateurs > Utilisateurs.

​Prérequis

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

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

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

Prérequis

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

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

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