Das Firebase Admin SDK bietet eine API zum Verwalten Ihrer Firebase Authentication-Benutzer mit erhöhten Berechtigungen. Mit der Admin-Benutzerverwaltungs-API haben Sie 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 stapelweise auf.
- Greifen Sie auf Benutzermetadaten zu, einschließlich Kontoerstellungsdatum und Datum der letzten Anmeldung.
- Löschen Sie Benutzer, ohne dass ihr vorhandenes Passwort erforderlich ist.
- Aktualisieren Sie Benutzereigenschaften – einschließlich ihres Passworts –, ohne sich als Benutzer anmelden zu müssen.
- Verifizieren Sie E-Mails, ohne die Out-of-Band-Aktionsabläufe zur Verifizierung 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-Verifizierungsprozess durchlaufen zu müssen.
- Ändern Sie die Telefonnummer eines Benutzers, ohne den SMS-Verifizierungsprozess durchlaufen zu müssen.
- Stellen Sie Benutzer offline im 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. Befolgen Sie die Setup-Anweisungen , um weitere Informationen zum Initialisieren des Admin SDK zu erhalten.
Benutzerdaten abrufen
Die primäre Möglichkeit, einen Benutzer zu identifizieren, ist die uid
, eine eindeutige Kennung für diesen Benutzer. Das Admin SDK bietet eine Methode, die das Abrufen der Profilinformationen von Benutzern anhand ihrer uid
ermöglicht:
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))
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 bereitgestellte uid
nicht zu einem 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ösungsschritte, finden Sie unter Admin Auth API Errors .
In einigen Fällen haben Sie die E-Mail-Adresse eines Benutzers anstelle seiner uid
. Das Firebase Admin SDK unterstützt die Suche nach Benutzerinformationen per 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))
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, der der angegebenen E-Mail entspricht.
Wenn die angegebene E-Mail-Adresse 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ösungsschritte, finden Sie unter Fehler bei der Admin-Authentifizierungs-API .
In anderen Fällen haben Sie die Telefonnummer eines Benutzers anstelle seiner uid
. Das Firebase Admin SDK unterstützt die Suche nach Benutzerinformationen anhand einer Telefonnummer:
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))
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, der der angegebenen Telefonnummer entspricht.
Wenn die angegebene Telefonnummer keinem bestehenden 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ösungsschritte, finden Sie unter Fehler bei der Admin-Authentifizierungs-API .
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-Adresse oder Telefonnummer identifizieren. In einem einzigen Aufruf können maximal 100 Identifikatoren bereitgestellt werden. Bezeichner können verschiedene Typen enthalten:
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)
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 derselben 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ösungsschritte, finden Sie unter Fehler bei der Admin-Authentifizierungs-API .
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, das die Profilinformationen enthält, die in das neu erstellte Benutzerkonto aufgenommen werden sollen:
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))
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 diese als Argument einschließen, das an die Benutzererstellungsmethode übergeben wird:
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))
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. Von der Operation „Benutzer erstellen“ unterstützte Eigenschaften
Eigentum | Typ | Beschreibung |
---|---|---|
uid | Zeichenfolge | Die uid , die dem neu erstellten Benutzer zugewiesen werden soll. Muss eine Zeichenfolge mit einer Länge zwischen 1 und 128 Zeichen sein. Wenn nicht angegeben, wird automatisch eine zufällige uid generiert. Kürzere uid bieten eine bessere Leistung. |
email | Zeichenfolge | Die primäre E-Mail-Adresse des Benutzers. Muss eine gültige E-Mail-Adresse sein. |
emailVerified | Boolescher Wert | Ob die primäre E-Mail-Adresse des Benutzers überprüft wird oder nicht. Wenn nicht angegeben, ist der Standardwert false . |
phoneNumber | Zeichenfolge | Die primäre Telefonnummer des Benutzers. Muss eine gültige Telefonnummer sein, die der E.164-Spezifikation entspricht. |
password | Zeichenfolge | Das rohe, ungehashte 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 | Ob der Benutzer deaktiviert ist oder nicht. 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-Adresse oder Telefonnummer bereits von einem vorhandenen Benutzer verwendet wird oder der Benutzer aus einem anderen Grund nicht erstellt werden kann, schlägt die obige Methode mit einem Fehler fehl. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte, finden Sie unter Fehler bei der Admin-Authentifizierungs-API .
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
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))
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. Vom Benutzeraktualisierungsvorgang unterstützte Eigenschaften
Eigentum | Typ | Beschreibung |
---|---|---|
email | Zeichenfolge | Die neue primäre E-Mail-Adresse des Benutzers. Muss eine gültige E-Mail-Adresse sein. |
emailVerified | Boolescher Wert | Ob die primäre E-Mail-Adresse des Benutzers überprüft wird oder nicht. Wenn nicht angegeben, ist der Standardwert false . |
phoneNumber | Zeichenfolge | Die neue primäre Telefonnummer des Benutzers. Muss eine gültige Telefonnummer sein, die der E.164-Spezifikation entspricht. Auf null setzen, um die vorhandene Telefonnummer des Benutzers zu löschen. |
password | Zeichenfolge | Das neue rohe, ungehashte Passwort des Benutzers. Muss mindestens sechs Zeichen lang sein. |
displayName | Zeichenfolge | null | Der neue Anzeigename des Benutzers. Auf null setzen, um den vorhandenen Anzeigenamen des Benutzers zu löschen. |
photoURL | Zeichenfolge | null | Die neue Foto-URL des Benutzers. Auf null setzen, um die vorhandene Foto-URL des Benutzers zu löschen. Wenn nicht null , muss es sich um eine gültige URL handeln. |
disabled | Boolescher Wert | Ob der Benutzer deaktiviert ist oder nicht. true für Behinderte; false für aktiviert. |
Die Methode „Benutzer aktualisieren“ gibt ein aktualisiertes UserRecord
Objekt zurück, wenn die Aktualisierung erfolgreich abgeschlossen wurde.
Wenn die bereitgestellte uid
keinem vorhandenen Benutzer entspricht, die angegebene E-Mail-Adresse oder Telefonnummer bereits von einem vorhandenen Benutzer verwendet wird oder der Benutzer aus einem anderen Grund nicht aktualisiert werden kann, schlägt die obige Methode mit einem Fehler fehl. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte, finden Sie unter Fehler bei der Admin-Authentifizierungs-API .
Einen Benutzer löschen
Das Firebase Admin SDK ermöglicht das Löschen vorhandener Benutzer anhand ihrer 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')
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 „Benutzer löschen“ 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 „Benutzer löschen“ einen Fehler aus. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte, finden Sie unter Fehler bei der Admin-Authentifizierungs-API .
Mehrere Benutzer löschen
Das Firebase Admin SDK kann auch mehrere Benutzer gleichzeitig löschen. Beachten Sie jedoch, dass die Verwendung von Methoden wie deleteUsers(uids)
zum gleichzeitigen Löschen mehrerer Benutzer keine onDelete()
Ereignishandler für Cloud Functions for Firebase auslöst. Dies liegt daran, dass beim Batch-Löschen nicht für jeden Benutzer ein Benutzerlöschereignis ausgelöst wird. Löschen Sie Benutzer einzeln, wenn Sie möchten, dass Benutzerlöschereignisse für jeden gelöschten Benutzer ausgelöst werden.
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))
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 der Fehler für die Benutzer zurück, die nicht gelöscht werden konnten. Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte, finden Sie unter Fehler bei der Admin-Authentifizierungs-API .
Listen Sie alle Benutzer auf
Das Firebase Admin SDK ermöglicht das stapelweise Abrufen der gesamten Benutzerliste:
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)
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 nächste Seitentoken, das zum Auflisten des nächsten Benutzerstapels verwendet wird. Wenn bereits alle Benutzer aufgelistet sind, wird kein pageToken
zurückgegeben.
Wenn kein maxResults
Feld angegeben ist, werden standardmäßig 1000 Benutzer 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, listet der Vorgang die Benutzer von Anfang an auf, sortiert nach uid
.
Eine vollständige Liste der Fehlercodes, einschließlich Beschreibungen und Lösungsschritte, finden Sie unter Fehler bei der Admin-Authentifizierungs-API .
Passwort-Hashes der aufgelisteten Benutzer
Diese API gibt auch den vom Firebase Auth-Backend gehashten Wert passwordSalt
und passwordHash
für Passwortbenutzer zurück, wenn das Benutzer-/Dienstkonto, das zum Generieren des Anforderungs-OAuth-Zugriffstokens verwendet wurde, über die Berechtigung firebaseauth.configs.getHashConfig
verfügt. Andernfalls werden passwordHash
und passwordSalt
nicht gesetzt.
Aufgrund der sensiblen Natur von Passwort-Hashes verfügt das Firebase Admin SDK-Dienstkonto standardmäßig nicht über die Berechtigung firebaseauth.configs.getHashConfig
. Sie können einem Benutzer-/Dienstkonto keine Berechtigung direkt hinzufügen, aber Sie können dies indirekt tun, indem Sie eine benutzerdefinierte IAM-Rolle erstellen .
So erstellen Sie die benutzerdefinierte IAM-Rolle:
- Gehen Sie zur Seite „Rollen“ im IAM- und Admin- Bereich der Google Cloud Console.
- Wählen Sie Ihr Projekt aus der Dropdown-Liste oben auf der Seite aus.
- Klicken Sie auf ROLLE ERSTELLEN
- Klicken Sie auf BERECHTIGUNGEN HINZUFÜGEN
- Suchen Sie nach der Berechtigung
firebaseauth.configs.getHashConfig
“ und aktivieren Sie dieses Kontrollkästchen. - Klicken Sie auf HINZUFÜGEN
- Klicken Sie auf ERSTELLEN, um die Erstellung der neuen Rolle abzuschließen.
Fügen Sie die erstellte benutzerdefinierte Rolle zum Benutzer-/Dienstkonto auf der IAM-Seite hinzu:
- Wählen Sie im IAM- und Admin- Bereich IAM aus
- Wählen Sie den Dienst oder das Benutzerkonto aus der Mitgliederliste zur Bearbeitung aus.
- Klicken Sie auf WEITERE ROLLE HINZUFÜGEN .
- Suchen Sie nach der neuen benutzerdefinierten Rolle, die zuvor erstellt wurde.
- Klicken Sie auf SPEICHERN .