Cette page a été traduite par l'API Cloud Translation.
Switch to English

Gérer les locataires Identity Platform par programmation

Ce document explique comment utiliser le SDK Admin Identity Platform pour gérer les locataires et leurs utilisateurs par programmation. Vous pouvez, par exemple, effectuer les actions suivantes en tant qu'administrateur :

  • Gestion des utilisateurs : créez, mettez à jour, supprimez et répertoriez les utilisateurs pour un locataire spécifique.

  • Validation de l'identité : identifiez les utilisateurs d'une application pour restreindre l'accès aux ressources de votre propre serveur.

  • Importation d'utilisateur : migrez des utilisateurs depuis un système d'authentification externe, ou un autre projet ou locataire Identity Platform.

  • Contrôle des accès avec revendications personnalisées : définissez des attributs personnalisés sur les comptes utilisateur pour un locataire spécifique et mettez en œuvre diverses stratégies de contrôle des accès, telles que le contrôle des accès basé sur les rôles.

  • Gestion des sessions utilisateur : révoquez les jetons d'actualisation d'un utilisateur pour un locataire spécifique.

  • Liens d'action par e-mail : générez des liens d'e-mail personnalisés pour la réinitialisation de mot de passe, la connexion par lien d'e-mail et la validation des e-mails pour les utilisateurs d'un locataire spécifique.

  • Gestion des locataires : créez, répertoriez, obtenez, mettez à jour et supprimez des locataires pour un projet Identity Platform spécifique.

  • Gestion des fournisseurs OIDC et SAML sur des locataires : gérez par programmation les configurations OIDC et SAML sur un locataire spécifié.

Avant de commencer

Fonctionnalités compatibles

Le tableau suivant répertorie les fonctionnalités compatibles avec chaque SDK dans un environnement mutualisé :

Fonctionnalité Node.js Java Python Go C#
Émettre un jeton personnalisé
Valider des jetons d'ID
Gérer des comptes utilisateur
Contrôler les accès avec des revendications personnalisées
Révoquer des jetons d'actualisation
Importer des utilisateurs
Générer des liens d'action par e-mail
Authentification multifacteur
Gérer des configurations de fournisseurs SAML/OIDC
Gérer des cookies de session

Le tableau suivant indique les méthodes de connexion que vous pouvez configurer à l'aide du SDK Admin et de Cloud Console dans un contexte spécifique au locataire :

Fonctionnalité Cloud Console SDK Admin
E-mail
OIDC
SAML
Social
Téléphone
Authentification multifacteur
Anonyme

Gestion locative

À l'aide du SDK Admin, vous pouvez gérer les locataires par programmation depuis un environnement de serveur sécurisé au lieu d'utiliser Cloud Console. Cela inclut la possibilité de créer, de répertorier, d'obtenir, de modifier ou de supprimer des locataires.

Chaque locataire contient des fournisseurs d'identité, des paramètres et des ensembles d'utilisateurs qui lui sont propres. Les opérations de gestion de la configuration du locataire (CRUD) sont disponibles à partir de l'instance de projet parent à l'aide de admin.auth().tenantManager().

Une configuration de locataire fournit des informations sur un locataire, telles que son nom à afficher, son identifiant et sa configuration d'authentification d'e-mail.

Tous les autres paramètres (tels que les domaines en liste blanche et les URI de redirection authentifiés) d'un locataire sont hérités du projet parent. Ils doivent être gérés à l'aide de Cloud Console.

Pour les opérations telles que la gestion des utilisateurs spécifiques au locataire, la configuration de fournisseurs OIDC/SAML et la génération de liens par e-mail, vous avez besoin d'une instance TenantAwareAuth pour le locataire cible (identifié par son tenantId unique).

const tenantManager = admin.auth().tenantManager();
const tenantAuth = tenantManager.authForTenant(tenantId);

Tous les appels aux API de gestion des utilisateurs, aux API de gestion des fournisseurs OIDC/SAML et aux API de génération de liens d'e-mail font partie du champ d'application de ce locataire (en utilisant son instance TenantAwareAuth).

Obtenir un locataire existant

Le SDK Admin fournit la méthode getTenant(), qui récupère des informations sur un locataire en fonction de son tenantId (identifiant unique du locataire).

admin.auth().tenantManager().getTenant(tenantId)
  .then((tenant) => {
    console.log(tenant.toJSON());
  })
  .catch((error) => {
    // Handle error.
  });

Cette méthode renvoie un objet Tenant correspondant au tenantId. Si le tenantId fourni n'appartient pas à un locataire existant, la promesse renvoyée est rejetée avec l'erreur auth/tenant-not-found.

Veillez à ne pas confondre une instance Tenant avec un objet TenantAwareAuth. authInstance.tenantManager().authForTenant() renvoie une instance TenantAwareAuth qui étend BaseAuth. La classe Auth étend également BaseAuth. BaseAuth fournit des API permettant de gérer les utilisateurs, et de configurer les fournisseurs OIDC/SAML dans différents contextes. Pour Auth, le contexte est au niveau du projet parent. Pour TenantAwareAuth, le contexte est au niveau du locataire (le locataire est déterminé par l'ID du locataire). La méthode getTenant() permet de résoudre les informations de base sur le locataire (telles que l'ID de locataire, le nom à afficher et les paramètres du fournisseur de messagerie), mais pour appeler les API sur ce locataire, vous devez utiliser authForTenant(tenantFromGetTenant.tenantId) pour consulter nos règles en matière de publicité.

Créer un locataire

Utilisez la méthode createTenant() pour créer une configuration de locataire :

admin.auth().tenantManager().createTenant({
  displayName: 'myTenant1',
  emailSignInConfig: {
    enabled: true,
    passwordRequired: false, // Email link sign-in enabled.
  },
  // TODO: Remove if you don't want to enable multi-factor authentication.
  multiFactorConfig: {
    state: 'ENABLED',
    factorIds: ['phone']
  },
  // TODO: Remove if you don't want to register test phone numbers for use
  // with multi-factor authentication.
  testPhoneNumbers: {
    '+16505551234': '145678',
    '+16505550000': '123456'
  },
})
.then((createdTenant) => {
  console.log(createdTenant.toJSON());
})
.catch((error) => {
  // Handle error.
});

Vous pouvez fournir n'importe quelle combinaison de ces propriétés :

Valeur Type Description
displayName

string
    
Nom à afficher du locataire. Il doit comporter entre 4 et 20 caractères, comprendre des lettres, des chiffres et des tirets, et doit commencer par une lettre.
emailSignInConfig

{
  enable: boolean,
  passwordRequired: boolean
}
    
Configuration du fournisseur de connexion par e-mail. Ces informations indiquent si le fournisseur de messagerie est activé et si un mot de passe est requis pour la connexion par e-mail. Lorsque cet indicateur n'est pas obligatoire, la connexion par e-mail peut être effectuée à l'aide d'un mot de passe par connexion par lien d'e-mail.
multiFactorConfig

{
  state: 'DISABLED' | 'ENABLED',
  factorIds: string[]
}
    
Indique si l'authentification multifacteur est activée pour le locataire et les types de facteurs autorisés. Actuellement, l'unique ID de facteur compatible est phone.
testPhoneNumbers

{
  string: string
}
  
Carte des numéros de téléphone et des codes d'authentification multifacteur associés à enregistrer à des fins de test. Un maximum de 10 entrées est autorisé. Pour supprimer tous les numéros de téléphone de test, définissez ce champ sur null.

La méthode renvoie un objet Tenant pour le locataire nouvellement créé.

Mettre à jour un locataire

Utilisez la méthode updateTenant() pour modifier les données d'un locataire existant. Vous devez spécifier tenantId, ainsi que les propriétés à mettre à jour pour ce locataire.

admin.auth().tenantManager().updateTenant(tenantId, {
  displayName: 'updatedName',
  emailSignInConfig: {
    enabled: false, // Disable email provider.
  },
  // Enable multi-factor authentication.
  multiFactorConfig: {
    state: 'ENABLED',
    factorIds: ['phone']
  },
  // Register phone numbers for testing.
  testPhoneNumbers: {
    '+16505551234': '145678',
    '+16505550000': '123456'
  },
})
.then((updatedTenant) => {
  console.log(updatedTenant.toJSON());
})
.catch((error) => {
  // Handle error.
});

updateTenant() accepte les mêmes propriétés que createTenant(). Toutes les propriétés sont facultatives. Si une propriété n'est pas spécifiée, la valeur existante n'est pas modifiée.

La méthode renvoie un objet Tenant mis à jour une fois l'opération terminée. Si le tenantId fourni n'appartient pas à un locataire existant, la promesse renvoyée est rejetée avec l'erreur auth/tenant-not-found.

Supprimer un locataire

Vous pouvez supprimer un locataire à l'aide de son tenantId :

admin.auth().tenantManager().deleteTenant(tenantId)
  .then(() => {
    // Tenant deleted.
  })
  .catch((error) => {
    // Handle error.
  });

La méthode renvoie un résultat vide une fois la suppression terminée. Si le tenantId fourni n'appartient pas à un locataire existant, la promesse renvoyée est rejetée avec l'erreur auth/tenant-not-found.

Répertorier les locataires

Utilisez la méthode listTenants() pour répertorier les locataires existants :

function listAllTenants(nextPageToken) {
  return admin.auth().tenantManager().listTenants(100, nextPageToken)
    .then((result) => {
      result.tenants.forEach((tenant) => {
        console.log(tenant.toJSON());
      });
      if (result.pageToken) {
        return listAllTenants(result.pageToken);
      }
    });
}

listAllTenants();

Chaque lot de résultats contient une liste de locataires, ainsi qu'un jeton de page suivant pour répertorier le prochain lot de locataires. Lorsque tous les locataires ont déjà été répertoriés, aucun objet pageToken n'est renvoyé.

Si aucun champ maxResults n'est spécifié, la valeur par défaut est de 1 000 locataires par lot. Il s'agit également du nombre maximal de locataires autorisés à la fois. Toute valeur supérieure à la valeur maximale génère une erreur d'argument. Si aucun élément pageToken n'est spécifié, la méthode répertorie les locataires depuis le début.

Gérer les fournisseurs SAML et OIDC par programmation

Le SDK Admin fournit des API permettant de gérer les configurations de fournisseurs SAML (Security Assertion Markup Language) 2.0 et OIDC (OpenID Connect) par programmation à partir d'un environnement de serveur sécurisé.

Avec le SDK Admin, vous pouvez gérer ces fournisseurs pour un locataire spécifique. Cette opération est semblable à la gestion des fournisseurs OIDC et SAML au niveau du projet.

Pour gérer les fournisseurs d'un locataire, commencez par créer une instance TenantAwareAuth :

const tenantAuth = admin.auth().tenantManager().authForTenant('TENANT-ID');

Vous pouvez ensuite effectuer des opérations courantes, telles que la création, la modification ou la suppression de fournisseurs pour un locataire.

Créer un fournisseur

Le code suivant montre comment créer un fournisseur SAML pour un locataire :

const newConfig = {
  displayName: 'SAML provider name',
  enabled: true,
  providerId: 'saml.myProvider',
  idpEntityId: 'IDP_ENTITY_ID',
  ssoURL: 'https://example.com/saml/sso/1234/',
  x509Certificates: [
    '-----BEGIN CERTIFICATE-----\nCERT1...\n-----END CERTIFICATE-----',
    '-----BEGIN CERTIFICATE-----\nCERT2...\n-----END CERTIFICATE-----'
  ],
  rpEntityId: 'RP_ENTITY_ID',
  // Using the default callback URL.
  callbackURL: 'https://project-id.firebaseapp.com/__/auth/handler'
};

tenantAuth.createProviderConfig(newConfig).then(() => {
  // Successful creation.
}).catch((error) => {
  // Handle error.
});

Modifier un fournisseur

Le code suivant montre comment modifier un fournisseur :

const updatedConfig = {
  x509Certificates: [
    '-----BEGIN CERTIFICATE-----\nCERT2...\n-----END CERTIFICATE-----',
    '-----BEGIN CERTIFICATE-----\nCERT3...\n-----END CERTIFICATE-----',
  ],
};
tenantAuth.updateProviderConfig('saml.myProvider', updatedConfig).then(() => {
  // Successful update.
}).catch((error) => {
  // Handle error.
});

Obtenir un fournisseur

Le code suivant montre comment récupérer la configuration de fournisseur pour un locataire spécifique à l'aide de son ID de fournisseur :

tenantAuth.getProviderConfig('saml.myProvider').then((config) => {
  // Get display name and whether it is enabled.
   console.log(config.displayName, config.enabled);
}).catch((error) => {
  // Handle error. Common error is that config is not found.
});

Répertorier les fournisseurs

Le code suivant montre comment répertorier les configurations de fournisseur pour un locataire donné :

// Returns 10 SAML provider configs starting from the specified nextPageToken offset.
tenantAuth.listProviderConfigs({type: 'saml', maxResults: 10, pageToken: 'nextPageToken'}).then((results) => {
  results.providerConfigs.forEach((config) => {
     console.log(config.providerId);
  });
  // To list the next 10:
  // return tenantAuth.listProviderConfigs(
  //     {type: 'saml', maxResults: 10, pageToken: results.pageToken});
}).catch((error) => {
   // Handle error.
});

Supprimer un fournisseur

Le code suivant montre comment supprimer un fournisseur :

tenantAuth.deleteProviderConfig('saml.myProvider').then(() => {
  // Successful deletion.
}).catch((error) => {
  // Handle error.
});

Les fournisseurs OIDC sont gérés de la même manière que les fournisseurs OIDC au niveau du projet, à ceci près qu'ils peuvent être gérés à partir de l'instance TenantAwareAuth correspondante, plutôt que d'une instance de niveau projet Auth.

Pour en savoir plus, consultez la page Gérer les fournisseurs SAML et OIDC par programmation.

Gérer des utilisateurs spécifiques au locataire

Vous pouvez utiliser le SDK Admin pour créer, récupérer, mettre à jour, supprimer et répertorier tous les utilisateurs d'un locataire spécifique.

Pour commencer, vous avez besoin d'une instance TenantAwareAuth pour le locataire correspondant :

const tenantAuth = admin.auth().tenantManager().authForTenant('TENANT-ID');

Obtenir un compte utilisateur

Vous pouvez récupérer un utilisateur spécifique au locataire à l'aide d'un identifiant uid :

tenantAuth.getUser(uid)
  .then((userRecord) => {
    // See the UserRecord reference documentation to learn more.
    console.log('Successfully fetched user data:', userRecord.toJSON());
    // Tenant ID will be reflected in userRecord.tenantId.
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });

Vous pouvez également identifier un utilisateur par son adresse e-mail :

tenantAuth.getUserByEmail(email)
  .then((userRecord) => {
    // See the UserRecord reference documentation to learn more.
    console.log('Successfully fetched user data:', userRecord.toJSON());
    // Tenant ID will be reflected in userRecord.tenantId.
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });

Créer un utilisateur

Utilisez la méthode createUser() afin de créer des utilisateurs pour un locataire spécifique. Lorsque vous créez un utilisateur, fournir un uid est facultatif. Si aucun n'est spécifié, Identity Platform en fournit un unique.

tenantAuth.createUser({
  email: 'user@example.com',
  emailVerified: false,
  phoneNumber: '+11234567890',
  password: 'secretPassword',
  displayName: 'John Doe',
  photoURL: 'http://www.example.com/12345678/photo.png',
  disabled: false
})
.then((userRecord) => {
  // See the UserRecord reference documentation to learn more.
  console.log('Successfully created new user:', userRecord.uid);
  // Tenant ID will be reflected in userRecord.tenantId.
})
.catch((error) => {
  console.log('Error creating new user:', error);
});

Modifier un compte utilisateur

Vous pouvez modifier des utilisateurs existants en spécifiant leur uid dans la méthode updateUser() :

tenantAuth.updateUser(uid, {
  email: 'modifiedUser@example.com',
  phoneNumber: '+11234567890',
  emailVerified: true,
  password: 'newPassword',
  displayName: 'Jane Doe',
  photoURL: 'http://www.example.com/12345678/photo.png',
  disabled: true
})
.then((userRecord) => {
  // See the UserRecord reference documentation to learn more.
  console.log('Successfully updated user', userRecord.toJSON());
})
.catch((error) => {
  console.log('Error updating user:', error);
});

Supprimer un compte utilisateur

L'exemple suivant montre comment supprimer un utilisateur en fonction de son uid :

tenantAuth.deleteUser(uid)
  .then(() => {
    console.log('Successfully deleted user');
  })
  .catch((error) => {
    console.log('Error deleting user:', error);
  });

Répertorier les utilisateurs

Pour récupérer la liste complète des utilisateurs pour un locataire spécifique par lot, utilisez la méthode listUsers(). Chaque lot contient une liste de fiches utilisateur, ainsi qu'un jeton de page suivant si d'autres utilisateurs restent.

function listAllUsers(nextPageToken) {
  // List batch of users, 1000 at a time.
  tenantAuth.listUsers(1000, nextPageToken)
    .then((listUsersResult) => {
      listUsersResult.users.forEach((userRecord) => {
        console.log('user', userRecord.toJSON());
        // Tenant ID will be reflected in userRecord.tenantId.
      });
      if (listUsersResult.pageToken) {
        // List next batch of users.
        listAllUsers(listUsersResult.pageToken);
      }
    })
    .catch((error) => {
      console.log('Error listing users:', error);
    });
}
// Start listing users from the beginning, 1000 at a time.
listAllUsers();

Consultez la documentation de SDK Admin portant sur la gestion des utilisateurs pour en savoir plus.

Importer des utilisateurs

Vous pouvez utiliser le SDK Admin pour importer des utilisateurs de manière groupée dans un locataire spécifique doté de privilèges élevés. Cela offre de nombreux avantages, comme la possibilité de migrer des utilisateurs depuis un autre produit Identity Platform, d'un autre locataire ou d'un système d'authentification externe à l'aide d'un différents algorithmes de hachage. Vous pouvez également importer directement des utilisateurs de fournisseurs fédérés (tels que SAML et OIDC) et bénéficier de revendications personnalisées directement.

Pour commencer, procurez-vous une instance TenantAwareAuth pour le locataire correspondant :

const tenantAuth = admin.auth().tenantManager().authForTenant('TENANT-ID');

Vous pouvez importer jusqu'à 1 000 utilisateurs simultanément à l'aide d'un algorithme de hachage spécifique.

tenantAuth.importUsers([{
  uid: 'uid1',
  email: 'user1@example.com',
  // Must be provided in a byte buffer.
  passwordHash: Buffer.from('password-hash-1'),
  // Must be provided in a byte buffer.
  passwordSalt: Buffer.from('salt1')
},
{
  uid: 'uid2',
  email: 'user2@example.com',
  // Must be provided in a byte buffer.
  passwordHash: Buffer.from('password-hash-2'),
  // Must be provided in a byte buffer.
  passwordSalt: Buffer.from('salt2')

}], {
  hash: {
    algorithm: 'HMAC_SHA256',
    // Must be provided in a byte buffer.
    key: Buffer.from('secret')
  }
})
.then((results) => {
  results.errors.forEach(function(indexedError) {
   console.log('Error importing user ' + indexedError.index);
  });
})
.catch((error) => {
  console.log('Error importing users:', error);
});

Le paramètre tenantId de tous les utilisateurs importés est défini sur tenantAuth.tenantId.

Les utilisateurs sans mot de passe peuvent également être importés vers un locataire spécifique. Ces utilisateurs peuvent être importés avec des fournisseurs fédérés et des revendications personnalisées.

tenantAuth.importUsers([{
  uid: 'some-uid',
  displayName: 'John Doe',
  email: 'johndoe@acme.com',
  photoURL: 'http://www.example.com/12345678/photo.png',
  emailVerified: true,
  phoneNumber: '+11234567890',
  // Set this user as admin.
  customClaims: {admin: true},
  // User with SAML provider.
  providerData: [{
    uid: 'saml-uid',
    email: 'johndoe@acme.com',
    displayName: 'John Doe',
    photoURL: 'http://www.example.com/12345678/photo.png',
    providerId: 'saml.acme'
  }]
}])
.then(function(results) {
  results.errors.forEach(function(indexedError) {
   console.log('Error importing user ' + indexedError.index);
  });
})
.catch(function(error) {
  console.log('Error importing users:', error);
});

Consultez la section Importer des utilisateurs de la documentation de SDK Admin pour en savoir plus.

Validation de l'identité

Lorsqu'une application cliente Identity Platform communique avec un serveur backend personnalisé, l'utilisateur actuellement connecté doit être identifié sur ce serveur. Pour ce faire, vous pouvez envoyer le jeton d'ID de l'utilisateur une fois la connexion établie avec votre serveur. Le serveur peut ensuite vérifier l'intégrité et l'authenticité du jeton d'ID.

Le SDK Admin dispose d'une méthode intégrée de vérification et de décodage de jetons d'ID pour un locataire spécifique.

Après avoir connecté un utilisateur à un locataire spécifique du client, récupérez le jeton d'ID de l'utilisateur à l'aide du SDK client :

auth.tenantId = 'TENANT-ID';
auth.signInWithEmailAndPassword('user@example.com', 'password')
  .then((userCredential) => {
    return userCredential.user.getIdToken();
  })
  .then((idToken) => {
    // Send the ID token to server for verification. ID token should be scoped to TENANT-ID.
  });

Créez une instance TenantAwareAuth sur le serveur :

const tenantAuth = admin.auth().tenantManager().authForTenant('TENANT-ID');

Vous pouvez ensuite valider le jeton d'ID de ce locataire spécifique :

// idToken comes from the client app
tenantAuth.verifyIdToken(idToken)
  .then((decodedToken) => {
    let uid = decodedToken.uid;
    // This should be set to TENANT-ID. Otherwise auth/mismatching-tenant-id error thrown.
    console.log(decodedToken.firebase.tenant);
    // ...
  }).catch((error) => {
    // Handle error
  });

Une ressource côté serveur peut être accessible par plusieurs locataires ayant différents niveaux d'accès. Étant donné que l'ID de locataire peut ne pas être connu à l'avance dans ce cas, le jeton d'ID peut d'abord être validé au niveau du projet.

admin.auth().verifyIdToken(idToken)
  .then((decodedToken) => {
    if (decodedToken.firebase.tenant === 'TENANT-ID1') {
      // Allow appropriate level of access for TENANT-ID1.
    } else if (decodedToken.firebase.tenant === 'TENANT-ID2') {
      // Allow appropriate level of access for TENANT-ID2.
    } else {
      // Block access for all other tenants.
      throw new Error('Access not allowed.');
    }
  }).catch((error) => {
    // Handle error
  });

Consultez la section Valider les jetons d'ID dans la documentation du SDK Admin pour en savoir plus.

Gérer les sessions utilisateur

Les sessions Identity Platform sont de longue durée. Chaque fois qu'un utilisateur se connecte, les identifiants de l'utilisateur sont validés sur le serveur Identity Platform, puis échangés contre un jeton d'ID court et un jeton d'actualisation permanent. Les jetons d'ID durent une heure. Les jetons d'actualisation n'expirent jamais, sauf lorsqu'un utilisateur est désactivé, supprimé ou concerné par une modification importante du compte (par exemple, mise à jour de l'e-mail ou du mot de passe).

Dans certains cas, le jeton d'actualisation d'un utilisateur peut nécessiter d'être révoqué pour des raisons de sécurité (par exemple, le signalement par l'utilisateur de la perte ou du vol d'un appareil, la découverte d'une faille générale dans une application ou une fuite à grande échelle de jetons actifs). Le SDK Admin fournit une API permettant de révoquer tous les jetons d'actualisation émis pour un utilisateur spécifié d'un locataire spécifique.

Pour commencer, vous avez besoin d'une instance TenantAwareAuth :

const tenantAuth = admin.auth().tenantManager().authForTenant('TENANT-ID');

Vous pouvez ensuite révoquer les jetons d'actualisation en spécifiant le paramètre uid de cet utilisateur :

// Revoke all refresh tokens for a specified user in a specified tenant for whatever reason.
// Retrieve the timestamp of the revocation, in seconds since the epoch.
tenantAuth.revokeRefreshTokens(uid)
  .then(() => {
    return tenantAuth.getUser(uid);
  })
  .then((userRecord) => {
    return new Date(userRecord.tokensValidAfterTime).getTime() / 1000;
  })
  .then((timestamp) => {
    console.log('Tokens revoked at: ', timestamp);
  });

Une fois les jetons d'actualisation révoqués, aucun nouveau jeton d'ID ne peut être émis pour cet utilisateur tant que ce dernier ne s'authentifie pas de nouveau. Toutefois, les jetons d'ID existants demeurent actifs jusqu'à leur heure d'expiration naturelle (une heure).

Vous pouvez vérifier qu'un jeton d'ID valide non expiré n'est pas révoqué en spécifiant le paramètre checkRevoked facultatif. Cela permet de vérifier qu'un jeton est révoqué une fois son intégrité et son authenticité validées.

// Verify the ID token for a specific tenant while checking if the token is revoked by passing
// checkRevoked true.
let checkRevoked = true;
tenantAuth.verifyIdToken(idToken, checkRevoked)
  .then(payload => {
    // Token is valid.
  })
  .catch(error => {
    if (error.code == 'auth/id-token-revoked') {
      // Token has been revoked. Inform the user to re-authenticate or
      // signOut() the user.
    } else {
      // Token is invalid.
    }
  });

Consultez la documentation du SDK Admin sur la gestion des sessions pour en savoir plus.

Contrôler les accès avec des revendications personnalisées

Le SDK Admin permet de définir des attributs personnalisés sur les comptes utilisateur d'un locataire spécifique. Ces attributs vous permettent de mettre en œuvre différentes stratégies de contrôle d'accès, telles que le contrôle des accès basé sur les rôles. Les attributs peuvent être utilisés pour accorder aux utilisateurs différents niveaux d'accès appliqués par les règles de sécurité de l'application.

Pour commencer, procurez-vous une instance TenantAwareAuth pour le locataire correspondant :

const tenantAuth = admin.auth().tenantManager().authForTenant('TENANT-ID');

Les revendications personnalisées peuvent contenir des données sensibles. Elles ne doivent donc être définies qu'à partir d'un environnement de serveur privilégié à l'aide du SDK Admin.

// Set admin privilege on the user corresponding to uid for a specific tenant.
tenantAuth.setCustomUserClaims(uid, {admin: true}).then(() => {
  // The new custom claims will propagate to the user's ID token the
  // next time a new one is issued.
});

Les attributs personnalisés nouvellement définis apparaîtront sur les attributs de premier niveau de la charge utile du jeton la prochaine fois que l'utilisateur se connecte ou actualise ses jetons d'ID sur une session existante. Dans l'exemple précédent, le jeton d'ID contient une revendication supplémentaire : {admin: true}.

Après la validation du jeton d'ID et le décodage de sa charge utile, les revendications personnalisées supplémentaires peuvent être vérifiées pour appliquer le contrôle des accès.

// Verify the ID token first.
tenantAuth.verifyIdToken(idToken).then((claims) => {
  if (claims.admin === true) {
    // Allow access to requested admin resource.
  }
});

Les revendications personnalisées pour un utilisateur existant pour un locataire spécifique sont également disponibles en tant que propriété dans la fiche de l'utilisateur.

// Lookup the user associated with the specified uid.
tenantAuth.getUser(uid).then((userRecord) => {
  // The claims can be accessed on the user record.
  console.log(userRecord.customClaims.admin);
});

Pour en savoir plus, consultez la documentation du SDK Admin sur les revendications personnalisées.

À l'aide des SDK Identity Platform clients, vous pouvez envoyer aux utilisateurs des adresses e-mail de locataires spécifiques contenant des liens qu'ils peuvent utiliser pour réinitialiser les mots de passe, valider l'adresse e-mail et se connecter par e-mail. Ces e-mails sont envoyés par Google et offrent une personnalisation limitée.

Avec le SDK Admin, vous pouvez générer ces liens par programmation dans le champ d'application d'un locataire spécifique.

Pour commencer, procurez-vous une instance TenantAwareAuth pour le locataire correspondant :

const tenantAuth = admin.auth().tenantManager().authForTenant('TENANT-ID');

L'exemple suivant montre comment générer un lien afin de valider l'adresse e-mail d'un utilisateur pour un locataire spécifié :

const actionCodeSettings = {
  // URL you want to redirect back to. The domain (www.example.com) for
  // this URL must be whitelisted in the Cloud Console.
  url: 'https://www.example.com/checkout?cartId=1234',
  // This must be true for email link sign-in.
  handleCodeInApp: true,
  iOS: {
    bundleId: 'com.example.ios'
  },
  android: {
    packageName: 'com.example.android',
    installApp: true,
    minimumVersion: '12'
  },
  // FDL custom domain.
  dynamicLinkDomain: 'coolapp.page.link'
};

// Admin SDK API to generate the email verification link.
const userEmail = 'user@example.com';
tenantAuth.generateEmailVerificationLink(userEmail, actionCodeSettings)
  .then((link) => {
    // Construct email verification template, embed the link and send
    // using custom SMTP server.
    return sendCustomVerificationEmail(userEmail, displayName, link);
  })
  .catch((error) => {
    // Some error occurred.
  });

Des mécanismes similaires sont disponibles pour générer des liens de réinitialisation du mot de passe et de connexion via e-mail. Notez que lorsque vous générez un lien d'action par e-mail dans un contexte de locataire, l'ID de locataire doit être analysé à partir du lien et défini sur l'instance Auth cliente pour que le code puisse être appliqué.

const actionCodeUrl = firebase.auth.ActionCodeURL.parseLink(window.location.href);
// A one-time code, used to identify and verify a request.
const code = actionCodeUrl.code;
// The tenant ID being used to trigger the email action.
const tenantId = actionCodeUrl.tenantId;
auth.tenantId = tenantId;

// Apply the action code.
auth.applyActionCode(actionCode)
  .then(() => {
    // User's email is now verified.
  })
  .catch((error) => {
    // Handle error.
  });

Pour en savoir plus, consultez la section Liens d'action par e-mail dans la documentation du SDK Admin.

Messages d'erreur

Le tableau suivant répertorie les messages d'erreur courants que vous pouvez rencontrer.

Code d'erreur Description et étapes de résolution
auth/billing-not-enabled Cette fonctionnalité nécessite l'activation de la facturation.
auth/invalid-display-name Le champ "displayName" doit être une chaîne valide.
auth/invalid-name Le nom de ressource fourni n'est pas valide.
auth/invalid-page-token Le jeton de page doit être une chaîne valide non vide.
auth/invalid-project-id Projet parent non valide. Architecture mutualisée non activée dans le projet parent.
auth/invalid-tenant-id L'ID de locataire doit être une chaîne non vide valide.
auth/mismatching-tenant-id L'ID de locataire d'utilisateur ne correspond pas à l'ID de locataire TenantAwareAuth actuel.
auth/missing-display-name Il manque un nom à afficher valide à la ressource en cours de création ou de modification.
auth/insufficient-permission L'utilisateur n'est pas autorisé à accéder à la ressource demandée ou à exécuter l'opération de locataire spécifique.
auth/quota-exceeded Le quota du projet pour l'opération spécifiée a été dépassé.
auth/tenant-not-found Aucun locataire ne correspond à l'identifiant fourni.
auth/unsupported-tenant-operation Cette opération n'est pas acceptée dans un contexte mutualisé.
auth/invalid-testing-phone-number Un numéro de téléphone de test ou un code de test non valides ont été fournis.
auth/test-phone-number-limit-exceeded Le nombre maximal de numéros de téléphone et de paires de code de test autorisé a été dépassé.