Check out what’s new from Firebase at Google I/O 2022. Learn more

gérer les utilisateurs

Le SDK Firebase Admin fournit une API pour gérer vos utilisateurs Firebase Authentication avec des privilèges élevés. L'API de gestion des utilisateurs admin vous permet d'effectuer par programmation les tâches suivantes à partir d'un environnement de serveur sécurisé :

  • Créez de nouveaux utilisateurs sans limitation ni limitation de débit.
  • Recherchez les utilisateurs selon différents critères tels que l'uid, l'e-mail ou le numéro de téléphone.
  • Répertorier tous les utilisateurs d'un projet spécifié par lots.
  • Accédez aux métadonnées de l'utilisateur, y compris la date de création du compte et la date de la dernière connexion.
  • Supprimez des utilisateurs sans exiger leur mot de passe existant.
  • Mettez à jour les propriétés de l'utilisateur - y compris son mot de passe - sans avoir à se connecter en tant qu'utilisateur.
  • Vérifiez les e-mails sans avoir à passer par les flux d'action hors bande pour vérifier les e-mails.
  • Modifiez l'adresse e-mail d'un utilisateur sans envoyer de liens par e-mail pour annuler ces modifications.
  • Créez un nouvel utilisateur avec un numéro de téléphone sans avoir à passer par le flux de vérification par SMS.
  • Modifiez le numéro de téléphone d'un utilisateur sans avoir à passer par le flux de vérification par SMS.
  • Provisionnez les utilisateurs hors ligne dans un état désactivé, puis contrôlez ultérieurement quand les activer.
  • Créez des consoles utilisateur personnalisées adaptées au système de gestion des utilisateurs d'une application spécifique.

Avant que tu commences

Pour utiliser l'API de gestion des utilisateurs fournie par le SDK Firebase Admin, vous devez disposer d'un compte de service. Suivez les instructions de configuration pour plus d'informations sur l'initialisation du SDK Admin.

Récupérer les données de l'utilisateur

Le principal moyen d'identifier un utilisateur est son uid , un identifiant unique pour cet utilisateur. Le SDK Admin fournit une méthode qui permet de récupérer les informations de profil des utilisateurs par leur uid :

Node.js

getAuth()
  .getUser(uid)
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log(`Successfully fetched user data: ${userRecord.toJSON()}`);
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });

Java

UserRecord userRecord = FirebaseAuth.getInstance().getUser(uid);
// See the UserRecord reference doc for the contents of userRecord.
System.out.println("Successfully fetched user data: " + userRecord.getUid());

Python

from firebase_admin import auth

user = auth.get_user(uid)
print('Successfully fetched user data: {0}'.format(user.uid))

Aller

// Get an auth client from the firebase.App
client, err := app.Auth(ctx)
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}

u, err := client.GetUser(ctx, uid)
if err != nil {
	log.Fatalf("error getting user %s: %v\n", uid, err)
}
log.Printf("Successfully fetched user data: %v\n", u)

C#

UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserAsync(uid);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully fetched user data: {userRecord.Uid}");

Cette méthode renvoie un objet UserRecord pour l'utilisateur correspondant à l' uid fourni à la méthode.

Si l' uid fourni n'appartient pas à un utilisateur existant ou si l'utilisateur ne peut pas être récupéré pour une autre raison, la méthode ci-dessus génère une erreur. Pour obtenir la liste complète des codes d'erreur, y compris les descriptions et les étapes de résolution, consultez Admin Auth API Errors .

Dans certains cas, vous aurez l'e-mail d'un utilisateur au lieu de son uid . Le SDK Firebase Admin prend en charge la recherche d'informations sur les utilisateurs par e-mail :

Node.js

getAuth()
  .getUserByEmail(email)
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log(`Successfully fetched user data: ${userRecord.toJSON()}`);
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });

Java

UserRecord userRecord = FirebaseAuth.getInstance().getUserByEmail(email);
// See the UserRecord reference doc for the contents of userRecord.
System.out.println("Successfully fetched user data: " + userRecord.getEmail());

Python

from firebase_admin import auth

user = auth.get_user_by_email(email)
print('Successfully fetched user data: {0}'.format(user.uid))

Aller

u, err := client.GetUserByEmail(ctx, email)
if err != nil {
	log.Fatalf("error getting user by email %s: %v\n", email, err)
}
log.Printf("Successfully fetched user data: %v\n", u)

C#

UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserByEmailAsync(email);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully fetched user data: {userRecord.Uid}");

Cette méthode renvoie un objet UserRecord pour l'utilisateur correspondant à l'e-mail fourni.

Si l'e-mail fourni n'appartient pas à un utilisateur existant ou si l'utilisateur ne peut pas être récupéré pour une autre raison, le SDK Admin génère une erreur. Pour obtenir la liste complète des codes d'erreur, y compris les descriptions et les étapes de résolution, consultez Erreurs de l'API d'authentification de l'administrateur .

Dans d'autres cas, vous aurez le numéro de téléphone d'un utilisateur au lieu de son uid . Le SDK Firebase Admin prend en charge la recherche d'informations utilisateur avec un numéro de téléphone :

Node.js

getAuth()
  .getUserByPhoneNumber(phoneNumber)
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log(`Successfully fetched user data:  ${userRecord.toJSON()}`);
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });

Java

UserRecord userRecord = FirebaseAuth.getInstance().getUserByPhoneNumber(phoneNumber);
// See the UserRecord reference doc for the contents of userRecord.
System.out.println("Successfully fetched user data: " + userRecord.getPhoneNumber());

Python

from firebase_admin import auth

user = auth.get_user_by_phone_number(phone)
print('Successfully fetched user data: {0}'.format(user.uid))

Aller

u, err := client.GetUserByPhoneNumber(ctx, phone)
if err != nil {
	log.Fatalf("error getting user by phone %s: %v\n", phone, err)
}
log.Printf("Successfully fetched user data: %v\n", u)

C#

UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserByPhoneNumberAsync(phoneNumber);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully fetched user data: {userRecord.Uid}");

Cette méthode renvoie un objet UserRecord pour l'utilisateur correspondant au numéro de téléphone fourni.

Si le numéro de téléphone fourni n'appartient pas à un utilisateur existant ou si l'utilisateur ne peut pas être récupéré pour une autre raison, le SDK Admin génère une erreur. Pour obtenir la liste complète des codes d'erreur, y compris les descriptions et les étapes de résolution, consultez Erreurs de l'API d'authentification de l'administrateur .

Récupérer en masse les données utilisateur

Le SDK Firebase Admin permet également de récupérer une liste d'utilisateurs en fonction des identifiants que vous fournissez. Vous pouvez identifier les utilisateurs par leur ID utilisateur, leur adresse e-mail ou leur numéro de téléphone. Un maximum de 100 identifiants peuvent être fournis en un seul appel. Les identifiants peuvent contenir un mélange de types :

Node.js

getAuth()
  .getUsers([
    { uid: 'uid1' },
    { email: 'user2@example.com' },
    { phoneNumber: '+15555550003' },
    { providerId: 'google.com', providerUid: 'google_uid4' },
  ])
  .then((getUsersResult) => {
    console.log('Successfully fetched user data:');
    getUsersResult.users.forEach((userRecord) => {
      console.log(userRecord);
    });

    console.log('Unable to find users corresponding to these identifiers:');
    getUsersResult.notFound.forEach((userIdentifier) => {
      console.log(userIdentifier);
    });
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });

Java

GetUsersResult result = FirebaseAuth.getInstance().getUsersAsync(Arrays.asList(
    new UidIdentifier("uid1"),
    new EmailIdentifier("user2@example.com"),
    new PhoneIdentifier("+15555550003"),
    new ProviderIdentifier("google.com", "google_uid4"))).get();

System.out.println("Successfully fetched user data:");
for (UserRecord user : result.getUsers()) {
  System.out.println(user.getUid());
}

System.out.println("Unable to find users corresponding to these identifiers:");
for (UserIdentifier uid : result.getNotFound()) {
  System.out.println(uid);
}

Python

from firebase_admin import auth

result = auth.get_users([
    auth.UidIdentifier('uid1'),
    auth.EmailIdentifier('user2@example.com'),
    auth.PhoneIdentifier(+15555550003),
    auth.ProviderIdentifier('google.com', 'google_uid4')
])

print('Successfully fetched user data:')
for user in result.users:
    print(user.uid)

print('Unable to find users corresponding to these identifiers:')
for uid in result.not_found:
    print(uid)

Aller

getUsersResult, err := client.GetUsers(ctx, []auth.UserIdentifier{
	auth.UIDIdentifier{UID: "uid1"},
	auth.EmailIdentifier{Email: "user@example.com"},
	auth.PhoneIdentifier{PhoneNumber: "+15555551234"},
	auth.ProviderIdentifier{ProviderID: "google.com", ProviderUID: "google_uid1"},
})
if err != nil {
	log.Fatalf("error retriving multiple users: %v\n", err)
}

log.Printf("Successfully fetched user data:")
for _, u := range getUsersResult.Users {
	log.Printf("%v", u)
}

log.Printf("Unable to find users corresponding to these identifiers:")
for _, id := range getUsersResult.NotFound {
	log.Printf("%v", id)
}

C#

GetUsersResult result = await FirebaseAuth.DefaultInstance.GetUsersAsync(
    new List<UserIdentifier>
    {
        new UidIdentifier("uid1"),
        new EmailIdentifier("user2@example.com"),
        new PhoneIdentifier("+15555550003"),
        new ProviderIdentifier("google.com", "google_uid4"),
    });

Console.WriteLine("Successfully fetched user data:");
foreach (UserRecord user in result.Users)
{
    Console.WriteLine($"User: {user.Uid}");
}

Console.WriteLine("Unable to find users corresponding to these identifiers:");
foreach (UserIdentifier uid in result.NotFound)
{
    Console.WriteLine($"{uid}");
}

Cette méthode renvoie une liste de la même taille que la liste d'entrée, chaque entrée contenant soit le UserRecord correspondant, soit une erreur indiquant pourquoi cet identifiant n'a pas pu être recherché. Pour obtenir la liste complète des codes d'erreur, y compris les descriptions et les étapes de résolution, consultez Erreurs de l'API d'authentification de l'administrateur .

Créer un utilisateur

Le SDK Admin fournit une méthode qui vous permet de créer un nouvel utilisateur d'authentification Firebase. Cette méthode accepte un objet contenant les informations de profil à inclure dans le compte utilisateur nouvellement créé :

Node.js

getAuth()
  .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 doc for the contents of userRecord.
    console.log('Successfully created new user:', userRecord.uid);
  })
  .catch((error) => {
    console.log('Error creating new user:', error);
  });

Java

CreateRequest request = new CreateRequest()
    .setEmail("user@example.com")
    .setEmailVerified(false)
    .setPassword("secretPassword")
    .setPhoneNumber("+11234567890")
    .setDisplayName("John Doe")
    .setPhotoUrl("http://www.example.com/12345678/photo.png")
    .setDisabled(false);

UserRecord userRecord = FirebaseAuth.getInstance().createUser(request);
System.out.println("Successfully created new user: " + userRecord.getUid());

Python

user = auth.create_user(
    email='user@example.com',
    email_verified=False,
    phone_number='+15555550100',
    password='secretPassword',
    display_name='John Doe',
    photo_url='http://www.example.com/12345678/photo.png',
    disabled=False)
print('Sucessfully created new user: {0}'.format(user.uid))

Aller

params := (&auth.UserToCreate{}).
	Email("user@example.com").
	EmailVerified(false).
	PhoneNumber("+15555550100").
	Password("secretPassword").
	DisplayName("John Doe").
	PhotoURL("http://www.example.com/12345678/photo.png").
	Disabled(false)
u, err := client.CreateUser(ctx, params)
if err != nil {
	log.Fatalf("error creating user: %v\n", err)
}
log.Printf("Successfully created user: %v\n", u)

C#

UserRecordArgs args = new UserRecordArgs()
{
    Email = "user@example.com",
    EmailVerified = false,
    PhoneNumber = "+11234567890",
    Password = "secretPassword",
    DisplayName = "John Doe",
    PhotoUrl = "http://www.example.com/12345678/photo.png",
    Disabled = false,
};
UserRecord userRecord = await FirebaseAuth.DefaultInstance.CreateUserAsync(args);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully created new user: {userRecord.Uid}");

Par défaut, Firebase Authentication générera un uid aléatoire pour le nouvel utilisateur. Si vous souhaitez plutôt spécifier votre propre uid pour le nouvel utilisateur, vous pouvez l'inclure en tant qu'argument passé à la méthode de création d'utilisateur :

Node.js

getAuth()
  .createUser({
    uid: 'some-uid',
    email: 'user@example.com',
    phoneNumber: '+11234567890',
  })
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully created new user:', userRecord.uid);
  })
  .catch((error) => {
    console.log('Error creating new user:', error);
  });

Java

CreateRequest request = new CreateRequest()
    .setUid("some-uid")
    .setEmail("user@example.com")
    .setPhoneNumber("+11234567890");

UserRecord userRecord = FirebaseAuth.getInstance().createUser(request);
System.out.println("Successfully created new user: " + userRecord.getUid());

Python

user = auth.create_user(
    uid='some-uid', email='user@example.com', phone_number='+15555550100')
print('Sucessfully created new user: {0}'.format(user.uid))

Aller

params := (&auth.UserToCreate{}).
	UID(uid).
	Email("user@example.com").
	PhoneNumber("+15555550100")
u, err := client.CreateUser(ctx, params)
if err != nil {
	log.Fatalf("error creating user: %v\n", err)
}
log.Printf("Successfully created user: %v\n", u)

C#

UserRecordArgs args = new UserRecordArgs()
{
    Uid = "some-uid",
    Email = "user@example.com",
    PhoneNumber = "+11234567890",
};
UserRecord userRecord = await FirebaseAuth.DefaultInstance.CreateUserAsync(args);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully created new user: {userRecord.Uid}");

Toute combinaison des propriétés suivantes peut être fournie :

Tableau 1. Propriétés prises en charge par l'opération de création d'utilisateur

Propriété Taper La description
uid chaîne de caractères L' uid à attribuer à l'utilisateur nouvellement créé. Doit être une chaîne de 1 à 128 caractères inclus. S'il n'est pas fourni, un uid aléatoire sera automatiquement généré.
email chaîne de caractères L'adresse e-mail principale de l'utilisateur. Doit être une adresse e-mail valide.
emailVerified booléen Indique si l'adresse e-mail principale de l'utilisateur est vérifiée ou non. S'il n'est pas fourni, la valeur par défaut est false .
phoneNumber chaîne de caractères Numéro de téléphone principal de l'utilisateur. Doit être un numéro de téléphone valide conforme à la spécification E.164.
password chaîne de caractères Le mot de passe brut et non haché de l'utilisateur. Doit comporter au moins six caractères.
displayName chaîne de caractères Le nom d'affichage des utilisateurs.
photoURL chaîne de caractères L'URL de la photo de l'utilisateur.
disabled booléen Si l'utilisateur est désactivé ou non. true pour les personnes handicapées ; false pour activé. S'il n'est pas fourni, la valeur par défaut est false .

La méthode de création d'utilisateur renvoie un objet UserRecord pour l'utilisateur nouvellement créé.

Si l' uid , l'e-mail ou le numéro de téléphone fournis sont déjà utilisés par un utilisateur existant ou si l'utilisateur ne peut pas être créé pour une autre raison, la méthode ci-dessus échoue avec une erreur. Pour obtenir la liste complète des codes d'erreur, y compris les descriptions et les étapes de résolution, consultez Erreurs de l'API d'authentification de l'administrateur .

Mettre à jour un utilisateur

Le SDK Firebase Admin facilite la modification des données d'un utilisateur existant. Vous devez spécifier un uid avec les propriétés à mettre à jour pour cet utilisateur :

Node.js

getAuth()
  .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 doc for the contents of userRecord.
    console.log('Successfully updated user', userRecord.toJSON());
  })
  .catch((error) => {
    console.log('Error updating user:', error);
  });

Java

UpdateRequest request = new UpdateRequest(uid)
    .setEmail("user@example.com")
    .setPhoneNumber("+11234567890")
    .setEmailVerified(true)
    .setPassword("newPassword")
    .setDisplayName("Jane Doe")
    .setPhotoUrl("http://www.example.com/12345678/photo.png")
    .setDisabled(true);

UserRecord userRecord = FirebaseAuth.getInstance().updateUser(request);
System.out.println("Successfully updated user: " + userRecord.getUid());

Python

user = auth.update_user(
    uid,
    email='user@example.com',
    phone_number='+15555550100',
    email_verified=True,
    password='newPassword',
    display_name='John Doe',
    photo_url='http://www.example.com/12345678/photo.png',
    disabled=True)
print('Sucessfully updated user: {0}'.format(user.uid))

Aller

params := (&auth.UserToUpdate{}).
	Email("user@example.com").
	EmailVerified(true).
	PhoneNumber("+15555550100").
	Password("newPassword").
	DisplayName("John Doe").
	PhotoURL("http://www.example.com/12345678/photo.png").
	Disabled(true)
u, err := client.UpdateUser(ctx, uid, params)
if err != nil {
	log.Fatalf("error updating user: %v\n", err)
}
log.Printf("Successfully updated user: %v\n", u)

C#

UserRecordArgs args = new UserRecordArgs()
{
    Uid = uid,
    Email = "modifiedUser@example.com",
    PhoneNumber = "+11234567890",
    EmailVerified = true,
    Password = "newPassword",
    DisplayName = "Jane Doe",
    PhotoUrl = "http://www.example.com/12345678/photo.png",
    Disabled = true,
};
UserRecord userRecord = await FirebaseAuth.DefaultInstance.UpdateUserAsync(args);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully updated user: {userRecord.Uid}");

Toute combinaison des propriétés suivantes peut être fournie :

Tableau 2. Propriétés prises en charge par l'opération de mise à jour de l'utilisateur

Propriété Taper La description
email chaîne de caractères La nouvelle adresse e-mail principale de l'utilisateur. Doit être une adresse e-mail valide.
emailVerified booléen Indique si l'adresse e-mail principale de l'utilisateur est vérifiée ou non. S'il n'est pas fourni, la valeur par défaut est false .
phoneNumber chaîne de caractères Le nouveau numéro de téléphone principal de l'utilisateur. Doit être un numéro de téléphone valide conforme à la spécification E.164. Définissez sur null pour effacer le numéro de téléphone existant de l'utilisateur.
password chaîne de caractères Le nouveau mot de passe brut et non haché de l'utilisateur. Doit comporter au moins six caractères.
displayName chaîne | null Le nouveau nom d'affichage des utilisateurs. Définissez sur null pour effacer le nom d'affichage existant de l'utilisateur.
photoURL chaîne | null L'URL de la nouvelle photo des utilisateurs. Définissez sur null pour effacer l'URL de la photo existante de l'utilisateur. Si non null , doit être une URL valide.
disabled booléen Si l'utilisateur est désactivé ou non. true pour les personnes handicapées ; false pour activé.

La méthode utilisateur de mise à jour renvoie un objet UserRecord mis à jour lorsque la mise à jour se termine avec succès.

Si l' uid fourni ne correspond pas à un utilisateur existant, si l'e-mail ou le numéro de téléphone fourni est déjà utilisé par un utilisateur existant, ou si l'utilisateur ne peut pas être mis à jour pour toute autre raison, la méthode ci-dessus échoue avec une erreur. Pour obtenir la liste complète des codes d'erreur, y compris les descriptions et les étapes de résolution, consultez Erreurs de l'API d'authentification de l'administrateur .

Supprimer un utilisateur

Le SDK Firebase Admin permet de supprimer des utilisateurs existants par leur uid :

Node.js

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

Java

FirebaseAuth.getInstance().deleteUser(uid);
System.out.println("Successfully deleted user.");

Python

auth.delete_user(uid)
print('Successfully deleted user')

Aller

err := client.DeleteUser(ctx, uid)
if err != nil {
	log.Fatalf("error deleting user: %v\n", err)
}
log.Printf("Successfully deleted user: %s\n", uid)

C#

await FirebaseAuth.DefaultInstance.DeleteUserAsync(uid);
Console.WriteLine("Successfully deleted user.");

La méthode utilisateur delete renvoie un résultat vide lorsque la suppression se termine avec succès.

Si l' uid fourni ne correspond pas à un utilisateur existant ou si l'utilisateur ne peut pas être supprimé pour une autre raison, la méthode delete user génère une erreur. Pour obtenir la liste complète des codes d'erreur, y compris les descriptions et les étapes de résolution, consultez Erreurs de l'API d'authentification de l'administrateur .

Supprimer plusieurs utilisateurs

Le SDK Firebase Admin peut également supprimer plusieurs utilisateurs à la fois. Cependant, notez que l'utilisation de méthodes telles que deleteUsers(uids) pour supprimer plusieurs utilisateurs à la fois ne déclenchera pas les gestionnaires d'événements onDelete() pour Cloud Functions pour Firebase. En effet, la suppression par lots ne déclenche pas d'événement de suppression d'utilisateur sur chaque utilisateur. Supprimez les utilisateurs un par un si vous souhaitez que les événements de suppression d'utilisateurs se déclenchent pour chaque utilisateur supprimé.

Node.js

getAuth()
  .deleteUsers([uid1, uid2, uid3])
  .then((deleteUsersResult) => {
    console.log(`Successfully deleted ${deleteUsersResult.successCount} users`);
    console.log(`Failed to delete ${deleteUsersResult.failureCount} users`);
    deleteUsersResult.errors.forEach((err) => {
      console.log(err.error.toJSON());
    });
  })
  .catch((error) => {
    console.log('Error deleting users:', error);
  });

Java

DeleteUsersResult result = FirebaseAuth.getInstance().deleteUsersAsync(
    Arrays.asList("uid1", "uid2", "uid3")).get();

System.out.println("Successfully deleted " + result.getSuccessCount() + " users");
System.out.println("Failed to delete " + result.getFailureCount() + " users");
for (ErrorInfo error : result.getErrors()) {
  System.out.println("error #" + error.getIndex() + ", reason: " + error.getReason());
}

Python

from firebase_admin import auth

result = auth.delete_users(["uid1", "uid2", "uid3"])

print('Successfully deleted {0} users'.format(result.success_count))
print('Failed to delete {0} users'.format(result.failure_count))
for err in result.errors:
    print('error #{0}, reason: {1}'.format(result.index, result.reason))

Aller

deleteUsersResult, err := client.DeleteUsers(ctx, []string{"uid1", "uid2", "uid3"})
if err != nil {
	log.Fatalf("error deleting users: %v\n", err)
}

log.Printf("Successfully deleted %d users", deleteUsersResult.SuccessCount)
log.Printf("Failed to delete %d users", deleteUsersResult.FailureCount)
for _, err := range deleteUsersResult.Errors {
	log.Printf("%v", err)
}

C#

DeleteUsersResult result = await FirebaseAuth.DefaultInstance.DeleteUsersAsync(new List<string>
    {
        "uid1",
        "uid2",
        "uid3",
    });

Console.WriteLine($"Successfully deleted {result.SuccessCount} users.");
Console.WriteLine($"Failed to delete {result.FailureCount} users.");

foreach (ErrorInfo err in result.Errors)
{
    Console.WriteLine($"Error #{err.Index}, reason: {err.Reason}");
}

La méthode delete users renvoie une liste d'échecs pour les utilisateurs qui n'ont pas pu être supprimés. Pour obtenir la liste complète des codes d'erreur, y compris les descriptions et les étapes de résolution, consultez Erreurs de l'API d'authentification de l'administrateur .

Lister tous les utilisateurs

Le SDK Firebase Admin permet de récupérer la liste complète des utilisateurs par lots :

Node.js

const listAllUsers = (nextPageToken) => {
  // List batch of users, 1000 at a time.
  getAuth()
    .listUsers(1000, nextPageToken)
    .then((listUsersResult) => {
      listUsersResult.users.forEach((userRecord) => {
        console.log('user', userRecord.toJSON());
      });
      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();

Java

// Start listing users from the beginning, 1000 at a time.
ListUsersPage page = FirebaseAuth.getInstance().listUsers(null);
while (page != null) {
  for (ExportedUserRecord user : page.getValues()) {
    System.out.println("User: " + user.getUid());
  }
  page = page.getNextPage();
}

// Iterate through all users. This will still retrieve users in batches,
// buffering no more than 1000 users in memory at a time.
page = FirebaseAuth.getInstance().listUsers(null);
for (ExportedUserRecord user : page.iterateAll()) {
  System.out.println("User: " + user.getUid());
}

Python

# Start listing users from the beginning, 1000 at a time.
page = auth.list_users()
while page:
    for user in page.users:
        print('User: ' + user.uid)
    # Get next batch of users.
    page = page.get_next_page()

# Iterate through all users. This will still retrieve users in batches,
# buffering no more than 1000 users in memory at a time.
for user in auth.list_users().iterate_all():
    print('User: ' + user.uid)

Aller

// Note, behind the scenes, the Users() iterator will retrive 1000 Users at a time through the API
iter := client.Users(ctx, "")
for {
	user, err := iter.Next()
	if err == iterator.Done {
		break
	}
	if err != nil {
		log.Fatalf("error listing users: %s\n", err)
	}
	log.Printf("read user user: %v\n", user)
}

// Iterating by pages 100 users at a time.
// Note that using both the Next() function on an iterator and the NextPage()
// on a Pager wrapping that same iterator will result in an error.
pager := iterator.NewPager(client.Users(ctx, ""), 100, "")
for {
	var users []*auth.ExportedUserRecord
	nextPageToken, err := pager.NextPage(&users)
	if err != nil {
		log.Fatalf("paging error %v\n", err)
	}
	for _, u := range users {
		log.Printf("read user user: %v\n", u)
	}
	if nextPageToken == "" {
		break
	}
}

C#

// Start listing users from the beginning, 1000 at a time.
var pagedEnumerable = FirebaseAuth.DefaultInstance.ListUsersAsync(null);
var responses = pagedEnumerable.AsRawResponses().GetAsyncEnumerator();
while (await responses.MoveNextAsync())
{
    ExportedUserRecords response = responses.Current;
    foreach (ExportedUserRecord user in response.Users)
    {
        Console.WriteLine($"User: {user.Uid}");
    }
}

// Iterate through all users. This will still retrieve users in batches,
// buffering no more than 1000 users in memory at a time.
var enumerator = FirebaseAuth.DefaultInstance.ListUsersAsync(null).GetAsyncEnumerator();
while (await enumerator.MoveNextAsync())
{
    ExportedUserRecord user = enumerator.Current;
    Console.WriteLine($"User: {user.Uid}");
}

Chaque lot de résultats contient une liste d'utilisateurs et le jeton de page suivante utilisé pour répertorier le prochain lot d'utilisateurs. Lorsque tous les utilisateurs ont déjà été listés, aucun pageToken n'est renvoyé.

Si aucun champ maxResults n'est spécifié, les 1 000 utilisateurs par lot par défaut sont utilisés. Il s'agit également du nombre maximum d'utilisateurs autorisés à être répertoriés à la fois. Toute valeur supérieure au maximum générera une erreur d'argument. Si aucun pageToken n'est spécifié, l'opération listera les utilisateurs depuis le début, classés par uid .

Pour obtenir la liste complète des codes d'erreur, y compris les descriptions et les étapes de résolution, consultez Erreurs de l'API d'authentification de l'administrateur .

Hachages de mot de passe des utilisateurs répertoriés

Cette API renvoie également le passwordSalt et le passwordHash hachés par le backend Firebase Auth pour les utilisateurs de mot de passe si le compte d'utilisateur/de service utilisé pour générer le jeton d'accès OAuth de demande dispose de l'autorisation firebaseauth.configs.getHashConfig . Sinon, passwordHash et passwordSalt ne seront pas définis.

En raison de la nature sensible des hachages de mot de passe, le compte de service Firebase Admin SDK ne dispose pas de l'autorisation firebaseauth.configs.getHashConfig par défaut. Vous ne pouvez pas ajouter une autorisation directement à un compte d'utilisateur/de service, mais vous pouvez le faire indirectement en créant un rôle IAM personnalisé .

Pour créer le rôle IAM personnalisé :

  1. Accédez à la page Rôles dans IAM et panneau d'administration dans Google Cloud Console.
  2. Sélectionnez votre projet dans le menu déroulant en haut de la page.
  3. Cliquez sur CRÉER UN RÔLE
  4. Cliquez sur AJOUTER DES AUTORISATIONS
  5. Recherchez l'autorisation firebaseauth.configs.getHashConfig et cochez cette case.
  6. Cliquez sur AJOUTER
  7. Cliquez sur CRÉER pour terminer la création du nouveau rôle.

Ajoutez le rôle personnalisé créé au compte d'utilisateur/de service sur la page IAM :

  1. Dans le panneau IAM et admin , sélectionnez IAM
  2. Sélectionnez le service ou le compte d'utilisateur dans la liste des membres à modifier.
  3. Cliquez sur AJOUTER UN AUTRE RÔLE .
  4. Recherchez le nouveau rôle personnalisé précédemment créé.
  5. Cliquez sur ENREGISTRER .