Benutzer verwalten

Das Firebase Admin SDK bietet eine API zum Verwalten Ihrer Firebase Authentication-Benutzer mit erhöhten Rechten. Die Admin-Benutzerverwaltungs-API bietet Ihnen die Möglichkeit, die folgenden Aufgaben programmgesteuert in einer sicheren Serverumgebung auszufü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 Erstellungsdatum des Kontos und Datum der letzten Anmeldung.
  • Löschen Sie Benutzer, ohne ihr vorhandenes Kennwort zu benötigen.
  • Aktualisieren Sie die Benutzereigenschaften - einschließlich ihres Kennworts -, ohne sich als Benutzer anmelden zu müssen.
  • Verifizieren Sie E-Mails, ohne die Out-of-Band-Aktionsabläufe zum Verifizieren von E-Mails durchlaufen zu müssen.
  • Ändern Sie die E-Mail 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.
  • Stellen Sie Benutzer offline in einem deaktivierten Zustand bereit und steuern Sie 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. Folgen Sie den Installationsanweisungen für weitere Informationen, wie das Admin SDK zu initialisieren.

Benutzerdaten abrufen

Der primäre Weg , um einen Benutzer zu identifizieren , ist durch ihre uid , eine eindeutige Kennung für den Benutzer. Der Admin - SDK bietet eine Methode , die die Profilinformationen von Benutzern durch ihr ermöglicht das Abrufen 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 an dem entsprechenden uid des Verfahren zur Verfügung gestellt.

Wenn die mitgelieferte uid nicht gehört in einen vorhandenen Benutzer oder der Benutzer kann nicht aus einem anderen Grunde geholt wird, wirft das obige Verfahren einen Fehler. Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Sie Admin Auth API - Fehler .

In einigen Fällen werden Sie einen Benutzer E - Mail statt ihrer haben uid . Das Firebase Admin SDK unterstützt das Abrufen von Nutzerinformationen 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 an der E - Mail entspricht , zur Verfügung gestellt.

Wenn die bereitgestellte E-Mail keinem vorhandenen Benutzer gehört oder der Benutzer aus anderen Gründen nicht abgerufen werden kann, gibt das Admin SDK einen Fehler aus. Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Sie Admin - Authentifizierung API - Fehler .

In anderen Fällen müssen Sie die Telefonnummer des Benutzers statt ihrer uid . Das Firebase Admin SDK unterstützt das Nachschlagen von Nutzerinformationen 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 an die Telefonnummer zur Verfügung gestellt entspricht.

Wenn die angegebene Telefonnummer keinem vorhandenen Benutzer gehört oder der Benutzer aus anderen Gründen nicht abgerufen werden kann, gibt das Admin SDK einen Fehler aus. Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Sie Admin - Authentifizierung API - Fehler .

Massenabruf von Benutzerdaten

Das Firebase Admin SDK ermöglicht auch das Abrufen einer Liste von Benutzern basierend auf den von Ihnen bereitgestellten Kennungen. Sie können Benutzer anhand ihrer Benutzer-ID, E-Mail oder Telefonnummer identifizieren. In einem einzigen Aufruf können maximal 100 Identifikatoren bereitgestellt 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 liefert eine Liste die gleiche Größe wie die Eingabeliste, wobei jeder Eintrag entweder die entsprechenden enthaltenden UserRecord oder einen Fehler anzeigt , warum dieser Kennung werden nachgeschlagen nicht in der Lage war. Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Sie Admin - Authentifizierung API - Fehler .

Erstellen Sie einen Benutzer

Das Admin SDK bietet eine Methode, mit der Sie einen neuen Firebase Authentication-Benutzer erstellen können. Diese Methode akzeptiert ein Objekt mit den Profilinformationen, 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 wird Firebase - Authentifizierung ein zufälliges erzeugen uid für den neuen Benutzer. Wenn Sie stattdessen möchten , dass Ihre eigene angeben uid für den neuen Benutzer, können Sie es Argument für die Benutzererstellung Methode übergeben sind:

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

Jede Kombination der folgenden Eigenschaften kann bereitgestellt werden:

Tabelle 1. Von der Operation „Benutzer erstellen“ unterstützte Eigenschaften

Eigentum Typ Beschreibung
uid Schnur Die uid in den neu erstellten Benutzer zugeordnet werden . Muss eine Zeichenfolge mit einer Länge von 1 bis einschließlich 128 Zeichen sein. Wenn nicht vorgesehen ist , ein zufälliges uid wird automatisch generiert.
email Schnur Die primäre E-Mail-Adresse des Benutzers. Muss eine gültige E-Mail-Adresse sein.
emailVerified boolesch Ob die primäre E-Mail des Benutzers verifiziert wurde. Falls nicht angegeben, ist der Standardwert false .
phoneNumber Schnur Die primäre Telefonnummer des Benutzers. Muss eine gültige Telefonnummer sein, die der E.164-Spezifikation entspricht.
password Schnur Das rohe, nicht gehashte Kennwort des Benutzers. Muss mindestens sechs Zeichen lang sein.
displayName Schnur Der Anzeigename des Benutzers.
photoURL Schnur Die Foto-URL des Benutzers.
disabled boolesch Ob der Benutzer deaktiviert ist oder nicht. true für Behinderte; false für aktiviert. Falls nicht angegeben, ist der Standardwert false .

Die Benutzererstellung Methode gibt ein UserRecord Objekt für die neu erstellten Benutzer.

Wenn die mitgelieferte uid , E - Mail oder Telefonnummer ist bereits von einem vorhandenen Benutzer oder der Benutzer kann nicht aus einem anderen Grunde erstellt wird, schlägt das obige Verfahren mit einem Fehler. Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Sie Admin - Authentifizierung API - Fehler .

Aktualisieren eines Benutzers

Das Firebase Admin SDK erleichtert das Ändern der Daten eines vorhandenen Nutzers. Sie benötigen einen angeben uid für den Benutzer zusammen mit den Eigenschaften Update:

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

Jede Kombination der folgenden Eigenschaften kann bereitgestellt werden:

Tabelle 2. Vom Benutzeraktualisierungsvorgang unterstützte Eigenschaften

Eigentum Typ Beschreibung
email Schnur Die neue primäre E-Mail-Adresse des Benutzers. Muss eine gültige E-Mail-Adresse sein.
emailVerified boolesch Ob die primäre E-Mail des Benutzers verifiziert wurde. Falls nicht angegeben, ist der Standardwert false .
phoneNumber Schnur Die neue primäre Telefonnummer des Benutzers. Muss eine gültige Telefonnummer sein, die der E.164-Spezifikation entspricht. Auf null den Benutzer vorhandene Telefonnummer zu löschen.
password Schnur Das neue rohe, nicht gehashte Kennwort des Benutzers. Muss mindestens sechs Zeichen lang sein.
displayName Zeichenfolge | null Der neue Anzeigename des Benutzers. Auf null des Benutzers vorhandenen Anzeigenamen zu löschen.
photoURL Zeichenfolge | null Die neue Foto-URL des Benutzers. Auf null den Benutzer vorhandene Foto - URL zu löschen. Wenn nicht null , muss eine gültige URL sein.
disabled boolesch Ob der Benutzer deaktiviert ist oder nicht. true für Behinderte; false für aktiviert.

Das Update User - Methode gibt eine aktualisierte UserRecord Objekt , wenn das Update erfolgreich abgeschlossen wurde .

Wenn die mitgelieferte uid an einen vorhandenen Benutzer nicht entsprechen, die angegebene E - Mail oder Telefonnummer ist bereits von einem vorhandenen Benutzer, oder der Benutzer kann nicht aus einem anderen Grunde aktualisiert wird, schlägt das obige Verfahren mit einem Fehler. Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Sie Admin - Authentifizierung API - Fehler .

Einen Benutzer löschen

Das Firebase Admin SDK ermöglicht das Löschen vorhandene Benutzer durch ihre 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 mitgelieferte uid an einen vorhandenen Benutzer oder der Benutzer nicht kann nicht aus anderen Gründen gelöscht entspricht, wirft der Benutzer löscht Methode einen Fehler. Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Sie Admin - Authentifizierung API - Fehler .

Mehrere Benutzer löschen

Das Firebase Admin SDK kann auch mehrere Nutzer gleichzeitig löschen. Beachten Sie jedoch, dass Methoden wie mit deleteUsers(uids) , um mehrere Benutzer löschen nicht ausgelöst onDelete() Ereignishandler für Cloud - Funktionen für die Firebase. Dies liegt daran, dass das Stapellöschen nicht bei jedem Benutzer ein Benutzerlöschereignis auslöst. Löschen Sie Benutzer einzeln, wenn Sie möchten, dass Benutzerlöschereignisse für jeden gelöschten Benutzer ausgelöst werden.

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 delete users gibt eine Liste mit Fehlern für die Benutzer zurück, die nicht gelöscht werden konnten. Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Sie Admin - Authentifizierung API - Fehler .

Alle Benutzer auflisten

Mit dem Firebase Admin SDK können Sie die gesamte Benutzerliste in Stapeln 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 von Benutzern und das Token für die nächste Seite, der verwendet wird, um den nächsten Stapel von Benutzern aufzulisten. Wenn alle Benutzer haben bereits aufgeführt worden sind , keine pageToken zurückgegeben.

Wenn kein maxResults Feld angegeben ist, wird die Standard - 1000 Benutzer pro Charge 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, wird der Betrieb Liste Benutzer von Anfang an durch geordnete uid .

Für eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte finden Sie Admin - Authentifizierung API - Fehler .

Passwort-Hashes der aufgelisteten Benutzer

Diese API gibt auch die passwordSalt und passwordHash durch die Firebase - Authentifizierungs - Backend für Passwort Benutzer gehasht , wenn der Benutzer / Dienstkonto verwendet , um die Anforderung OAuth Zugang zu generieren Token das hat firebaseauth.configs.getHashConfig Erlaubnis. Andernfalls wird die passwordHash und passwordSalt wird nicht eingestellt werden.

Aufgrund der sensiblen Natur des Passwort - Hashes, wird das Firebase Admin SDK - Dienstkonto nicht hat firebaseauth.configs.getHashConfig Berechtigung standardmäßig. Sie können keine Erlaubnis direkt an einen Benutzer / Dienstkonto hinzufügen, aber Sie können so indirekt tun Erstellen einer benutzerdefinierten IAM Rolle .

So erstellen Sie die benutzerdefinierte IAM-Rolle:

  1. Gehen Sie auf die Seite Rollen in IAM & Admin - Panel in der Google Cloud Console.
  2. Wählen Sie Ihr Projekt aus dem Dropdown-Menü oben auf der Seite aus.
  3. Klicken Sie auf CREATE ROLE
  4. Klicken Sie auf ADD PERMISSIONS
  5. Suchen Sie nach firebaseauth.configs.getHashConfig Erlaubnis und wählen Sie die Checkbox.
  6. Klicken Sie ADD
  7. Klicken Sie auf CREATE beenden die neue Rolle zu schaffen.

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

  1. Im IAM & Admin - Panel, wählen Sie IAM
  2. Wählen Sie den Dienst oder das Benutzerkonto aus der Mitgliederliste zum Bearbeiten aus.
  3. Klicken Sie auf eine andere Rolle ADD.
  4. Suchen Sie nach der zuvor erstellten neuen benutzerdefinierten Rolle.
  5. Klicken Sie auf SPEICHERN.