Gérer les utilisateurs

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

  • Créer des utilisateurs sans limitation ni limitation du débit
  • Recherchez des utilisateurs en fonction de différents critères, tels que l'UID, l'adresse e-mail ou le numéro de téléphone.
  • Répertorier tous les utilisateurs d'un projet spécifié par lots.
  • Accéder 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 demander leur mot de passe existant.
  • Mettez à jour les propriétés utilisateur, y compris leur mot de passe, sans avoir à vous connecter en tant qu'utilisateur.
  • Validez les e-mails sans avoir à passer par les flux d'actions hors bande pour les valider.
  • Pour annuler ces modifications, modifiez l'adresse e-mail d'un utilisateur sans envoyer de liens d'e-mail.
  • Créez un utilisateur avec un numéro de téléphone sans avoir à passer par la procédure de validation par SMS.
  • Modifier le numéro de téléphone d'un utilisateur sans avoir à effectuer la validation par SMS le flux de travail.
  • Provisionnez les utilisateurs hors connexion dans un état désactivé, puis contrôlez plus tard 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 de commencer

Pour utiliser l'API de gestion des utilisateurs fournie par le SDK Admin Firebase, vous devez disposer d'un compte de service. Pour savoir comment initialiser le SDK Admin, suivez les instructions de configuration.

Récupérer les données utilisateur

Le moyen principal d'identifier un utilisateur est d'utiliser son uid, un identifiant unique de cet utilisateur. Le SDK Admin fournit une méthode permettant de récupérer le profil informations des utilisateurs en fonction de 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);
  });
manage_users.js

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))

Go

// 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)
auth.go

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 UserRecord pour l'utilisateur correspondant au uid fourni à la méthode.

Si le uid fourni n'appartient pas à un utilisateur existant ou si l'utilisateur ne peut pas être récupérée pour toute autre raison, la méthode ci-dessus génère une erreur. Pour obtenir la liste complète des codes d'erreur, avec leur description et procédure de résolution, consultez Erreurs de l'API Admin Auth.

Dans certains cas, vous aurez l'adresse e-mail d'un utilisateur au lieu de son uid. Firebase Le SDK Admin permet de rechercher des informations sur les utilisateurs à l'aide d'une adresse 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);
  });
manage_users.js

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))

Go

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)
auth.go

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'adresse e-mail fournie.

Si l'adresse e-mail fournie n'appartient pas à un utilisateur existant ou si l'utilisateur ne peut pas être extrait pour toute 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 la page Erreurs de l'API Admin Authentication.

Dans d'autres cas, c'est le numéro de téléphone de l'utilisateur qui s'affiche au lieu de son uid. La Le SDK Firebase Admin permet de rechercher des informations sur les utilisateurs à l'aide d'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);
  });
manage_users.js

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))

Go

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)
auth.go

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 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 à l'utilisateur ne peut pas être récupérée 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 la page Erreurs de l'API Admin Authentication.

Récupérer des informations sur l'utilisateur de manière groupée

Le SDK Firebase Admin permet également de récupérer une liste d'utilisateurs basée sur les 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. Vous pouvez indiquer jusqu'à 100 identifiants par appel. Les identifiants peuvent contenir une combinaison 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);
  });
manage_users.js

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)

Go

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 même taille que la liste d'entrée, chaque entrée contenant le champ UserRecord correspondant ou 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 la page Erreurs de l'API Admin Authentication.

Créer un compte utilisateur

Le SDK Admin fournit une méthode vous permet de créer un utilisateur Firebase Authentication. 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);
  });
manage_users.js

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))

Go

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)
auth.go

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ère un uid aléatoire pour le nouvel utilisateur. Si vous souhaitez spécifier votre propre uid pour le nouvel utilisateur, vous pouvez l'inclure en tant qu'argument transmis à 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);
  });
manage_users.js

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))

Go

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)
auth.go

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}");

Vous pouvez fournir n'importe quelle combinaison des propriétés suivantes :

Tableau 1. Propriétés compatibles avec l'opération de création d'utilisateur

Propriété Type Description
uid chaîne Le uid à attribuer au nouvel utilisateur créé. Doit être un Chaîne comportant entre 1 et 128 caractères inclus. Si ce champ n'est pas fourni, une valeur aléatoire uid est générée automatiquement. Les uid plus courts offrent de meilleures performances.
email chaîne Adresse e-mail principale de l'utilisateur. Il doit s'agir d'une adresse e-mail valide.
emailVerified boolean Indique si l'adresse e-mail principale de l'utilisateur est validée ou non. Si aucune valeur n'est spécifiée, la valeur par défaut est false.
phoneNumber chaîne Numéro de téléphone principal de l'utilisateur. Doit être une norme valide conforme à la norme E.164 numéro de téléphone.
password chaîne Mot de passe brut non haché de l'utilisateur. Ce champ doit comporter au moins six caractères.
displayName chaîne L'expérience utilisateur nom à afficher.
photoURL chaîne URL de la photo de l'utilisateur.
disabled boolean Indique si l'utilisateur est désactivé ou non. true pour "désactivé" ; false pour activé. Si cette valeur n'est pas spécifiée, la valeur par défaut est false.

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

Si l'uid, l'adresse 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 et renvoie une erreur. Pour obtenir la liste complète des codes d'erreur, y compris et les procédures de résolution, consultez API Admin Authentication Erreurs.

Mettre à jour un utilisateur

Le SDK Firebase Admin facilite la modification des données d'un utilisateur existant. Vous devez pour 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);
  });
manage_users.js

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))

Go

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)
auth.go

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}");

Vous pouvez fournir n'importe quelle combinaison des propriétés suivantes:

Tableau 2. Propriétés compatibles avec l'opération de mise à jour de l'utilisateur

Propriété Type Description
email chaîne Nouvelle adresse e-mail principale de l'utilisateur. Il doit s'agir d'une adresse e-mail valide.
emailVerified boolean Indique si l'adresse e-mail principale de l'utilisateur est validée ou non. Si aucune valeur n'est spécifiée, la valeur par défaut est false.
phoneNumber chaîne Nouveau numéro de téléphone principal de l'utilisateur. Il doit s'agir d'un numéro de téléphone valide conforme à la norme E.164. Définissez cette valeur sur null pour effacer le numéro de téléphone existant de l'utilisateur.
password chaîne Le nouveau mot de passe brut non haché de l'utilisateur. Ce champ doit comporter au moins six caractères.
displayName chaîne | null Nouveau nom à afficher de l'utilisateur. Définissez la valeur sur null pour effacer le contenu nom à afficher existant.
photoURL chaîne | null URL de la nouvelle photo de l'utilisateur. Définissez cette valeur sur null pour effacer l'URL de la photo existante de l'utilisateur. S'il ne s'agit pas de null, il doit s'agir d'une URL valide.
disabled boolean Indique si l'utilisateur est désactivé ou non. true pour "désactivé" ; false pour activé.

La méthode update user renvoie un objet UserRecord mis à jour une fois la mise à jour terminée.

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

Supprimer un compte utilisateur

Le SDK Admin Firebase permet de supprimer des utilisateurs existants à l'aide de leur uid:

Node.js

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

Java

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

Python

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

Go

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

C#

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

La méthode de suppression d'utilisateur renvoie un résultat vide une fois la suppression terminée.

Si l'élément uid fourni ne correspond pas à un utilisateur existant ou si l'utilisateur ne peut pas supprimé pour toute autre raison, la méthode delete user génère une erreur. Pour obtenir la liste complète des codes d'erreur avec leur description et les étapes de résolution, consultez Erreurs de l'API Admin Authentication.

Supprimer plusieurs comptes utilisateur

Le SDK Firebase Admin peut également supprimer plusieurs utilisateurs à la fois. Toutefois, notez que l'utilisation de méthodes telles que deleteUsers(uids) pour supprimer plusieurs comptes utilisateur ne déclenchera pas de gestionnaires d'événements onDelete() pour Cloud Functions for Firebase. En effet, la suppression par lot ne déclenche pas d'événement de suppression d'utilisateur chaque utilisateur. Supprimer les utilisateurs un à une heure 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))

Go

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 de suppression d'utilisateurs 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 la page Erreurs de l'API Admin Authentication.

Répertorier tous les utilisateurs

Le SDK Admin Firebase 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();
manage_users.js

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)

Go

// 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
	}
}
auth.go

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 suivant utilisé pour lister le prochain lot d'utilisateurs. Lorsque tous les utilisateurs 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 utilisateurs par lot. Il s'agit également du nombre maximal d'utilisateurs autorisés à la fois. N'importe quelle valeur supérieure à la valeur maximale génère une erreur d'argument. Si aucun pageToken n'est spécifié, l'opération listera les utilisateurs du début, trié par uid.

Pour obtenir la liste complète des codes d'erreur avec leur description et les étapes de résolution, consultez Erreurs de l'API Admin Authentication.

Hachages de mot de passe des utilisateurs listés

Cette API renvoie également les passwordSalt et passwordHash hachés par le backend Firebase Auth pour les utilisateurs de mots de passe si le compte utilisateur/de service utilisé pour générer le jeton d'accès OAuth de la requête 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 mots de passe, le 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 utilisateur/compte de service, pouvez le faire indirectement en Créer un rôle IAM personnalisé

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

  1. Accédez à la page Rôles dans le panneau IAM et administration de la console Google Cloud.
  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 sélectionnez-la .
  6. Cliquez sur AJOUTER.
  7. Cliquez sur CRÉER pour finaliser la création du rôle.

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

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