Save the date - Google I/O returns May 18-20. Register to get the most out of the digital experience: Build your schedule, reserve space, participate in Q&As, earn Google Developer profile badges, and more. Register now
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

Benutzer verwalten

Das Firebase Admin SDK bietet eine API zum Verwalten Ihrer Firebase-Authentifizierungsbenutzer mit erhöhten Berechtigungen. Mit der Administrator-Benutzerverwaltungs-API können Sie die folgenden Aufgaben programmgesteuert in einer sicheren Serverumgebung ausführen:

  • Erstellen Sie neue Benutzer ohne Drosselung oder Ratenbegrenzung.
  • Suchen Sie Benutzer nach verschiedenen Kriterien wie UID, E-Mail oder Telefonnummer.
  • Listen Sie alle Benutzer eines bestimmten Projekts in Stapeln auf.
  • Greifen Sie auf Benutzermetadaten zu, einschließlich des Erstellungsdatums des Kontos und des letzten Anmeldedatums.
  • Löschen Sie Benutzer, ohne ihr vorhandenes Passwort zu benötigen.
  • Aktualisieren Sie die Benutzereigenschaften - einschließlich ihres Kennworts -, ohne sich als Benutzer anmelden zu müssen.
  • Überprüfen Sie E-Mails, ohne die Out-of-Band-Aktionsabläufe zum Überprüfen von E-Mails durchlaufen zu müssen.
  • Ändern Sie die E-Mail-Adresse eines Benutzers, ohne E-Mail-Links zu senden, um diese Änderungen zu widerrufen.
  • Erstellen Sie einen neuen Benutzer mit einer Telefonnummer, ohne den SMS-Bestätigungsablauf durchlaufen zu müssen.
  • Ändern Sie die Telefonnummer eines Benutzers, ohne den SMS-Bestätigungsablauf durchlaufen zu müssen.
  • Offline-Bereitstellungsbenutzer in einem deaktivierten Zustand und steuern später, wann sie aktiviert werden sollen.
  • Erstellen Sie benutzerdefinierte Benutzerkonsolen, die auf das Benutzerverwaltungssystem einer bestimmten Anwendung zugeschnitten sind.

Bevor Sie beginnen

Um die vom Firebase Admin SDK bereitgestellte Benutzerverwaltungs-API verwenden zu können, müssen Sie über ein Dienstkonto verfügen. Befolgen Sie die Setup-Anweisungen, um weitere Informationen zum Initialisieren des Admin SDK zu erhalten.

Benutzerdaten abrufen

Der primäre Weg, einen Benutzer zu identifizieren, ist seine uid , eine eindeutige Kennung für diesen Benutzer. Das Admin-SDK bietet eine Methode, mit der die Profilinformationen von Benutzern anhand ihrer uid :

Node.js

admin
  .auth()
  .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))

Gehen

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

Diese Methode gibt ein UserRecord Objekt für den Benutzer zurück, das der für die Methode bereitgestellten uid entspricht.

Wenn die angegebene uid keinem vorhandenen Benutzer gehört oder der Benutzer aus einem anderen Grund nicht abgerufen werden kann, gibt die obige Methode einen Fehler aus. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritten, finden Sie unter Admin Auth API-Fehler .

In einigen Fällen haben Sie die E-Mail- uid eines Benutzers anstelle seiner uid . Das Firebase Admin SDK unterstützt das Nachschlagen von Benutzerinformationen per E-Mail:

Node.js

admin
  .auth()
  .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))

Gehen

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

Diese Methode gibt ein UserRecord Objekt für den Benutzer zurück, das der angegebenen E-Mail entspricht.

Wenn die bereitgestellte E-Mail keinem vorhandenen Benutzer gehört oder der Benutzer aus einem anderen Grund nicht abgerufen werden kann, gibt das Admin-SDK einen Fehler aus. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritten, finden Sie unter Admin-Authentifizierungs-API-Fehler .

In anderen Fällen haben Sie die Telefonnummer eines Benutzers anstelle seiner uid . Das Firebase Admin SDK unterstützt das Nachschlagen von Benutzerinformationen mit einer Telefonnummer:

Node.js

admin
  .auth()
  .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))

Gehen

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

Diese Methode gibt ein UserRecord Objekt für den Benutzer zurück, das der angegebenen Telefonnummer entspricht.

Wenn die angegebene Telefonnummer keinem vorhandenen Benutzer gehört oder der Benutzer aus einem anderen Grund nicht abgerufen werden kann, gibt das Admin SDK einen Fehler aus. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritten, finden Sie unter Admin-Authentifizierungs-API-Fehler .

Massenabruf von Benutzerdaten

Mit dem Firebase Admin SDK können Sie auch eine Liste der Benutzer basierend auf den von Ihnen angegebenen Kennungen abrufen. Sie können Benutzer anhand ihrer Benutzer-ID, E-Mail-Adresse oder Telefonnummer identifizieren. In einem einzigen Anruf können maximal 100 Kennungen angegeben werden. Bezeichner können eine Mischung von Typen enthalten:

Node.js

admin
  .auth()
  .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)

Gehen

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

Diese Methode gibt eine Liste mit der gleichen Größe wie die Eingabeliste zurück, wobei jeder Eintrag entweder den entsprechenden UserRecord oder einen Fehler enthält, der angibt, warum dieser Bezeichner nicht nachgeschlagen werden konnte. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritten, finden Sie unter Admin-Authentifizierungs-API-Fehler .

Erstellen Sie einen Benutzer

Das Admin-SDK bietet eine Methode, mit der Sie einen neuen Benutzer für die Firebase-Authentifizierung erstellen können. Diese Methode akzeptiert ein Objekt, das die Profilinformationen enthält, die in das neu erstellte Benutzerkonto aufgenommen werden sollen:

Node.js

admin
  .auth()
  .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))

Gehen

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

Standardmäßig generiert die Firebase-Authentifizierung eine zufällige uid für den neuen Benutzer. Wenn Sie stattdessen Ihre eigene uid für den neuen Benutzer angeben möchten, können Sie das an die Benutzererstellungsmethode übergebene Argument einschließen:

Node.js

admin
  .auth()
  .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))

Gehen

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

Es kann eine beliebige Kombination der folgenden Eigenschaften bereitgestellt werden:

Tabelle 1. Eigenschaften, die von der Operation "Benutzer erstellen" unterstützt werden

Eigentum Art Beschreibung
uid Zeichenfolge Die uid , die dem neu erstellten Benutzer uid . Muss eine Zeichenfolge zwischen 1 und 128 Zeichen sein, einschließlich. Wenn nicht uid wird automatisch eine zufällige uid generiert.
email Zeichenfolge Die primäre E-Mail-Adresse des Benutzers. Muss eine gültige E-Mail-Adresse sein.
emailVerified Boolescher Wert Gibt an, ob die primäre E-Mail-Adresse des Benutzers überprüft wurde. Wenn nicht angegeben, ist der Standardwert false .
phoneNumber Zeichenfolge Die primäre Telefonnummer des Benutzers. Muss eine gültige E.164-konforme Telefonnummer sein.
password Zeichenfolge Das ungehackte Passwort des Benutzers. Muss mindestens sechs Zeichen lang sein.
displayName Zeichenfolge Der Anzeigename des Benutzers.
photoURL Zeichenfolge Die Foto-URL des Benutzers.
disabled Boolescher Wert Gibt an, ob der Benutzer deaktiviert ist. true für Behinderte; false für aktiviert. Wenn nicht angegeben, ist der Standardwert false .

Die Benutzererstellungsmethode gibt ein UserRecord Objekt für den neu erstellten Benutzer zurück.

Wenn die angegebene uid , E-Mail- uid oder Telefonnummer bereits von einem vorhandenen Benutzer verwendet wird oder der Benutzer aus einem anderen Grund nicht erstellt werden kann, schlägt die oben beschriebene Methode mit einem Fehler fehl. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritten, finden Sie unter Admin-Authentifizierungs-API-Fehler .

Aktualisieren Sie einen Benutzer

Das Firebase Admin SDK erleichtert das Ändern der Daten eines vorhandenen Benutzers. Sie müssen eine uid zusammen mit den Eigenschaften angeben, die für diesen Benutzer aktualisiert werden sollen:

Node.js

admin
  .auth()
  .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))

Gehen

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

Es kann eine beliebige Kombination der folgenden Eigenschaften bereitgestellt werden:

Tabelle 2. Eigenschaften, die vom Vorgang zum Aktualisieren des Benutzers unterstützt werden

Eigentum Art Beschreibung
email Zeichenfolge Die neue primäre E-Mail-Adresse des Benutzers. Muss eine gültige E-Mail-Adresse sein.
emailVerified Boolescher Wert Gibt an, ob die primäre E-Mail-Adresse des Benutzers überprüft wurde. Wenn nicht angegeben, ist der Standardwert false .
phoneNumber Zeichenfolge Die neue primäre Telefonnummer des Benutzers. Muss eine gültige E.164-konforme Telefonnummer sein. Auf null , um die vorhandene Telefonnummer des Benutzers zu löschen.
password Zeichenfolge Das neue ungehackte Passwort des Benutzers. Muss mindestens sechs Zeichen lang sein.
displayName Zeichenfolge | null Der neue Anzeigename der Benutzer. Auf null , um den vorhandenen Anzeigenamen des Benutzers zu löschen.
photoURL Zeichenfolge | null Die neue Foto-URL der Benutzer. Auf null , um die vorhandene Foto-URL des Benutzers zu löschen. Wenn nicht null , muss eine gültige URL vorhanden sein.
disabled Boolescher Wert Gibt an, ob der Benutzer deaktiviert ist. true für Behinderte; false für aktiviert.

Die Update-Benutzermethode gibt ein aktualisiertes UserRecord Objekt zurück, wenn die Aktualisierung erfolgreich abgeschlossen wurde.

Wenn die angegebene uid keinem vorhandenen Benutzer entspricht, die angegebene E-Mail- oder Telefonnummer bereits von einem vorhandenen Benutzer verwendet wird oder der Benutzer aus einem anderen Grund nicht aktualisiert werden kann, schlägt die oben beschriebene Methode mit einem Fehler fehl. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritten, finden Sie unter Admin-Authentifizierungs-API-Fehler .

Löschen Sie einen Benutzer

Das Firebase Admin SDK ermöglicht das Löschen vorhandener Benutzer anhand ihrer uid :

Node.js

admin
  .auth()
  .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')

Gehen

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

Die Methode delete user gibt ein leeres Ergebnis zurück, wenn der Löschvorgang erfolgreich abgeschlossen wurde.

Wenn die angegebene uid keinem vorhandenen Benutzer entspricht oder der Benutzer aus einem anderen Grund nicht gelöscht werden kann, gibt die Methode delete user einen Fehler aus. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritten, finden Sie unter Admin-Authentifizierungs-API-Fehler .

Mehrere Benutzer löschen

Das Firebase Admin SDK kann auch mehrere Benutzer gleichzeitig löschen:

Node.js

admin
  .auth()
  .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))

Gehen

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

Die Methode "Benutzer löschen" gibt eine Liste von Fehlern für die Benutzer zurück, die nicht gelöscht werden konnten. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritten, finden Sie unter Admin-Authentifizierungs-API-Fehler .

Listen Sie alle Benutzer auf

Mit dem Firebase Admin SDK können Sie die gesamte Benutzerliste stapelweise abrufen:

Node.js

const listAllUsers = (nextPageToken) => {
  // List batch of users, 1000 at a time.
  admin
    .auth()
    .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)

Gehen

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

Jeder Ergebnisstapel enthält eine Liste der Benutzer und das Token für die nächste Seite, mit dem der nächste Stapel von Benutzern aufgelistet wird. Wenn alle Benutzer bereits aufgelistet sind, wird kein pageToken zurückgegeben.

Wenn kein maxResults Feld angegeben ist, werden die Standardbenutzer von 1000 Benutzern pro Stapel verwendet. Dies ist auch die maximale Anzahl von Benutzern, die gleichzeitig aufgelistet werden dürfen. Jeder Wert, der größer als das Maximum ist, löst einen Argumentfehler aus. Wenn kein pageToken angegeben ist, pageToken der Vorgang Benutzer von Anfang an auf, sortiert nach uid .

Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritten, finden Sie unter Admin-Authentifizierungs-API-Fehler .

Passwort-Hashes der aufgelisteten Benutzer

Diese API gibt auch das vom Firebase Auth-Backend für passwordHash gehashte passwordSalt und passwordHash wenn das Benutzer- / Dienstkonto, das zum Generieren des OAuth-Zugriffstokens für die Anforderung verwendet wird, über die Berechtigung firebaseauth.configs.getHashConfig . Andernfalls werden passwordHash und passwordSalt nicht festgelegt.

Aufgrund der sensiblen Natur des Passwort - Hashes, wird das Firebase Admin SDK - Dienstkonto nicht hat firebaseauth.configs.getHashConfig Berechtigung standardmäßig. Sie können einem Benutzer- / Dienstkonto keine Berechtigung direkt hinzufügen, dies können Sie jedoch indirekt tun, indem Sie eine benutzerdefinierte IAM-Rolle erstellen .

So erstellen Sie die benutzerdefinierte IAM-Rolle:

  1. Wechseln Sie in der Google Cloud Console zur Seite " Rollen " im Bereich " IAM & Admin" .
  2. Wählen Sie Ihr Projekt aus der Dropdown-Liste oben auf der Seite aus.
  3. Klicken Sie auf ROLLE ERSTELLEN
  4. Klicken Sie auf ERLAUBNISSE HINZUFÜGEN
  5. Suchen Sie nach der Berechtigung firebaseauth.configs.getHashConfig und aktivieren Sie dieses Kontrollkästchen.
  6. Klicken Sie auf HINZUFÜGEN
  7. Klicken Sie auf ERSTELLEN , um die Erstellung der neuen Rolle abzuschließen .

Fügen Sie die erstellte benutzerdefinierte Rolle dem Benutzer- / Dienstkonto auf der IAM-Seite hinzu:

  1. Wählen Sie im Bereich IAM & Admin die Option IAM aus
  2. Wählen Sie den Dienst oder das Benutzerkonto aus der Liste der zu bearbeitenden Mitglieder aus.
  3. Klicken Sie auf EINE ANDERE ROLLE HINZUFÜGEN .
  4. Suchen Sie nach der neuen benutzerdefinierten Rolle, die zuvor erstellt wurde.
  5. Klicken Sie auf SPEICHERN .