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

נהל משתמשים

Firebase Admin SDK מספק API לניהול משתמשי Firebase Authentication עם הרשאות גבוהות. ממשק ה-API לניהול משתמש מנהל נותן לך את היכולת להשלים באופן תכנותי את המשימות הבאות מסביבת שרת מאובטחת:

  • צור משתמשים חדשים ללא כל הגבלה או הגבלת קצב.
  • חפש משתמשים לפי קריטריונים שונים כגון uid, אימייל או מספר טלפון.
  • רשום את כל המשתמשים של פרויקט שצוין בקבוצות.
  • גישה למטא נתונים של משתמשים, כולל תאריך יצירת החשבון ותאריך הכניסה האחרון.
  • מחק משתמשים מבלי לדרוש את הסיסמה הקיימת שלהם.
  • עדכן את מאפייני המשתמש - כולל הסיסמה שלו - ללא צורך להיכנס כמשתמש.
  • אמת הודעות דוא"ל מבלי לעבור את זרימות הפעולה מחוץ לתחום לאימות הודעות דוא"ל.
  • שנה אימייל של משתמש מבלי לשלוח קישורי דוא"ל כדי לבטל שינויים אלה.
  • צור משתמש חדש עם מספר טלפון מבלי לעבור את זרימת האימות ב-SMS.
  • שנה מספר טלפון של משתמש מבלי לעבור את זרימת האימות ב-SMS.
  • משתמשים בהקצאה לא מקוונת במצב מושבת ולאחר מכן לשלוט במועד להפעיל אותם.
  • בנו קונסולות משתמש מותאמות אישית המותאמות למערכת ניהול המשתמשים של אפליקציה ספציפית.

לפני שאתה מתחיל

כדי להשתמש ב-API לניהול משתמשים שסופק על ידי Firebase Admin SDK, עליך להיות בעל חשבון שירות. עקוב אחר הוראות ההגדרה לקבלת מידע נוסף על אופן האתחול של ה-Admin SDK.

אחזר נתוני משתמש

הדרך העיקרית לזהות משתמש היא באמצעות ה- uid , מזהה ייחודי עבור אותו משתמש. ה-Admin SDK מספק שיטה המאפשרת לאחזר את פרטי הפרופיל של המשתמשים לפי ה- uid שלהם:

Node.js

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

Java

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

פִּיתוֹן

from firebase_admin import auth

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

ללכת

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

שיטה זו מחזירה אובייקט UserRecord עבור המשתמש התואם ל- uid שסופק לשיטה.

אם ה- uid שסופק אינו שייך למשתמש קיים או שלא ניתן לאחזר את המשתמש מכל סיבה אחרת, השיטה לעיל זורקת שגיאה. לרשימה מלאה של קודי שגיאה, כולל תיאורים ושלבי פתרון, ראה Admin Auth API Errors .

במקרים מסוימים יהיה לך אימייל של משתמש במקום ה- uid . ה-SDK של Firebase Admin תומך בחיפוש פרטי משתמש באמצעות אימייל:

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

פִּיתוֹן

from firebase_admin import auth

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

ללכת

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

שיטה זו מחזירה אובייקט UserRecord עבור המשתמש התואם לאימייל שסופק.

אם האימייל שסופק אינו שייך למשתמש קיים או שלא ניתן לאחזר את המשתמש מכל סיבה אחרת, ה-Admin SDK משליך שגיאה. לרשימה מלאה של קודי שגיאה, כולל תיאורים ושלבי פתרון, ראה שגיאות ממשק API של אימות מנהל מערכת .

במקרים אחרים, יהיה לך מספר טלפון של משתמש במקום ה- uid שלו. Firebase Admin SDK תומך בחיפוש פרטי משתמש עם מספר טלפון:

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

פִּיתוֹן

from firebase_admin import auth

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

ללכת

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

שיטה זו מחזירה אובייקט UserRecord עבור המשתמש המתאים למספר הטלפון שסופק.

אם מספר הטלפון שסופק אינו שייך למשתמש קיים או שלא ניתן לאחזר את המשתמש מכל סיבה אחרת, ה-Admin SDK משליך שגיאה. לרשימה מלאה של קודי שגיאה, כולל תיאורים ושלבי פתרון, ראה שגיאות ממשק API של אימות מנהל מערכת .

אחזור בכמות גדולה של נתוני משתמש

Firebase Admin SDK מאפשר גם לאחזר רשימה של משתמשים על סמך מזהים שאתה מספק. אתה יכול לזהות משתמשים לפי מזהה המשתמש, האימייל או מספר הטלפון שלהם. ניתן לספק לכל היותר 100 מזהים בשיחה אחת. מזהים יכולים להכיל שילוב של סוגים:

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

פִּיתוֹן

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)

ללכת

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

שיטה זו מחזירה רשימה בגודל זהה לרשימת הקלט, כאשר כל ערך מכיל את UserRecord התואם או שגיאה המציינת מדוע לא ניתן היה לחפש את המזהה הזה. לרשימה מלאה של קודי שגיאה, כולל תיאורים ושלבי פתרון, ראה שגיאות ממשק API של אימות מנהל מערכת .

צור משתמש

ה-Admin SDK מספק שיטה המאפשרת לך ליצור משתמש Firebase Authentication חדש. שיטה זו מקבלת אובייקט המכיל את פרטי הפרופיל שיכלול בחשבון המשתמש החדש שנוצר:

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

פִּיתוֹן

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

ללכת

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

כברירת מחדל, אימות Firebase יפיק uid אקראי עבור המשתמש החדש. אם במקום זאת תרצה לציין את ה- uid שלך עבור המשתמש החדש, תוכל לכלול אותו כארגומנט המועבר לשיטת יצירת המשתמש:

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

פִּיתוֹן

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

ללכת

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

ניתן לספק כל שילוב של המאפיינים הבאים:

טבלה 1. מאפיינים הנתמכים על ידי פעולת יצירת המשתמש

תכונה סוּג תיאור
uid חוּט ה- uid להקצאה למשתמש החדש שנוצר. חייבת להיות מחרוזת באורך של בין 1 ל-128 תווים, כולל. אם לא מסופק, ייווצר אוטומטית uid אקראי.
email חוּט האימייל הראשי של המשתמש. חייב להיות כתובת דואר אלקטרוני חוקית.
emailVerified בוליאני האם האימייל הראשי של המשתמש מאומת או לא. אם לא מסופק, ברירת המחדל היא false .
phoneNumber חוּט מספר הטלפון הראשי של המשתמש. חייב להיות מספר טלפון תקף תואם למפרט E.164.
password חוּט הסיסמה הגולמית והלא מגובבת של המשתמש. חייב להיות באורך שישה תווים לפחות.
displayName חוּט שם התצוגה של המשתמשים.
photoURL חוּט כתובת האתר של התמונה של המשתמש.
disabled בוליאני האם המשתמש מושבת או לא. true לנכים; false עבור מופעל. אם לא מסופק, ברירת המחדל היא false .

שיטת יצירת המשתמש מחזירה אובייקט UserRecord עבור המשתמש החדש שנוצר.

אם ה- uid , האימייל או מספר הטלפון שסופקו כבר נמצאים בשימוש על ידי משתמש קיים או שלא ניתן ליצור את המשתמש מכל סיבה אחרת, השיטה שלעיל נכשלת עם שגיאה. לרשימה מלאה של קודי שגיאה, כולל תיאורים ושלבי פתרון, ראה שגיאות ממשק API של אימות מנהל מערכת .

עדכן משתמש

Firebase Admin SDK מאפשר לשנות נתונים של משתמש קיים. עליך לציין uid יחד עם המאפיינים לעדכון עבור אותו משתמש:

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

פִּיתוֹן

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

ללכת

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

ניתן לספק כל שילוב של המאפיינים הבאים:

טבלה 2. מאפיינים הנתמכים על ידי פעולת העדכון של המשתמש

תכונה סוּג תיאור
email חוּט האימייל הראשי החדש של המשתמש. חייב להיות כתובת דואר אלקטרוני חוקית.
emailVerified בוליאני האם האימייל הראשי של המשתמש מאומת או לא. אם לא מסופק, ברירת המחדל היא false .
phoneNumber חוּט מספר הטלפון הראשי החדש של המשתמש. חייב להיות מספר טלפון תקף תואם למפרט E.164. הגדר ל- null כדי למחוק את מספר הטלפון הקיים של המשתמש.
password חוּט הסיסמה החדשה והגולמית של המשתמש ללא גיבוב. חייב להיות באורך שישה תווים לפחות.
displayName מחרוזת | null שם התצוגה החדש של המשתמשים. הגדר ל- null כדי לנקות את שם התצוגה הקיים של המשתמש.
photoURL מחרוזת | null כתובת האתר של התמונה החדשה של המשתמשים. הגדר ל- null כדי לנקות את כתובת האתר הקיימת של התמונה של המשתמש. אם אינו null , חייבת להיות כתובת אתר חוקית.
disabled בוליאני האם המשתמש מושבת או לא. true לנכים; false עבור מופעל.

שיטת העדכון משתמש מחזירה אובייקט UserRecord מעודכן כאשר העדכון מסתיים בהצלחה.

אם ה- uid שסופק אינו תואם למשתמש קיים, האימייל או מספר הטלפון שסופק כבר נמצאים בשימוש על ידי משתמש קיים, או שלא ניתן לעדכן את המשתמש מכל סיבה אחרת, השיטה שלעיל נכשלת עם שגיאה. לרשימה מלאה של קודי שגיאה, כולל תיאורים ושלבי פתרון, ראה שגיאות ממשק API של אימות מנהל מערכת .

מחק משתמש

Firebase Admin SDK מאפשר למחוק משתמשים קיימים לפי ה- 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.");

פִּיתוֹן

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

ללכת

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

שיטת מחיקת המשתמש מחזירה תוצאה ריקה כאשר המחיקה מסתיימת בהצלחה.

אם ה- uid שסופק אינו מתאים למשתמש קיים או שלא ניתן למחוק את המשתמש מכל סיבה אחרת, שיטת מחיקת המשתמש זורקת שגיאה. לרשימה מלאה של קודי שגיאה, כולל תיאורים ושלבי פתרון, ראה שגיאות ממשק API של אימות מנהל מערכת .

מחק מספר משתמשים

Firebase Admin SDK יכול גם למחוק מספר משתמשים בו-זמנית. עם זאת, שים לב ששימוש בשיטות כמו deleteUsers(uids) למחיקת משתמשים מרובים בו-זמנית לא יפעיל מטפלי אירועים onDelete() עבור Cloud Functions for Firebase. הסיבה לכך היא שמחיקת אצווה אינה מפעילה אירוע מחיקת משתמש בכל משתמש. מחק משתמשים אחד בכל פעם אם אתה רוצה שאירועי מחיקת משתמש יפעלו עבור כל משתמש שנמחק.

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

פִּיתוֹן

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

ללכת

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

שיטת מחיקת משתמשים מחזירה רשימה של כשלים עבור המשתמשים שלא ניתן היה למחוק. לרשימה מלאה של קודי שגיאה, כולל תיאורים ושלבי פתרון, ראה שגיאות ממשק API של אימות מנהל מערכת .

רשום את כל המשתמשים

Firebase Admin SDK מאפשר לאחזר את כל רשימת המשתמשים באצווה:

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

פִּיתוֹן

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

ללכת

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

כל אצווה של תוצאות מכילה רשימה של משתמשים ואת אסימון העמוד הבא המשמש לרשימת אצווה המשתמשים הבאה. כאשר כל המשתמשים כבר רשומים, שום pageToken לא מוחזר.

אם לא צוין שדה maxResults , נעשה שימוש ברירת המחדל של 1000 משתמשים בכל אצווה. זהו גם המספר המקסימלי של משתמשים המותר להופיע בכל פעם. כל ערך גדול מהמקסימום יזרוק שגיאת ארגומנט. אם לא צוין pageToken , הפעולה תפרט את המשתמשים מההתחלה, לפי סדר uid .

לרשימה מלאה של קודי שגיאה, כולל תיאורים ושלבי פתרון, ראה שגיאות ממשק API של אימות מנהל מערכת .

גיבוב סיסמא של משתמשים ברשימה

ממשק API זה מחזיר גם את passwordSalt ואת passwordHash שגובצו על ידי ה-Firebase Auth backend עבור משתמשי סיסמה, אם לחשבון המשתמש/השירות המשמש ליצירת אסימון הגישה לבקשת OAuth יש הרשאת firebaseauth.configs.getHashConfig . אחרת ה- passwordHash ו- passwordSalt לא יוגדרו.

בשל האופי הרגיש של גיבוב סיסמאות, לחשבון שירות Firebase Admin SDK אין את ההרשאה firebaseauth.configs.getHashConfig כברירת מחדל. אינך יכול להוסיף הרשאה ישירות לחשבון משתמש/שירות, אך אתה יכול לעשות זאת בעקיפין על ידי יצירת תפקיד IAM מותאם אישית .

כדי ליצור את תפקיד IAM המותאם אישית:

  1. עבור לדף התפקידים ב- IAM ופאנל הניהול ב-Google Cloud Console.
  2. בחר את הפרויקט שלך מהתפריט הנפתח בחלק העליון של הדף.
  3. לחץ על צור תפקיד
  4. לחץ על הוסף הרשאות
  5. חפש את הרשאת firebaseauth.configs.getHashConfig ובחר את תיבת הסימון.
  6. לחץ על הוסף
  7. לחץ על צור כדי לסיים את יצירת התפקיד החדש.

הוסף את התפקיד המותאם אישית שנוצר לחשבון המשתמש/שירות בדף IAM:

  1. בחלונית IAM & admin , בחר IAM
  2. בחר את השירות או חשבון המשתמש מרשימת החברים לעריכה.
  3. לחץ על הוסף תפקיד נוסף .
  4. חפש את התפקיד המותאם אישית החדש שנוצר בעבר.
  5. לחץ על שמור .