ניהול משתמשים

‫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);
  });
manage_users.js

Java

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

Python

from firebase_admin import auth

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

Go

// Get an auth client from the firebase.App
client, err := app.Auth(ctx)
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}

u, err := client.GetUser(ctx, uid)
if err != nil {
	log.Fatalf("error getting user %s: %v\n", uid, err)
}
log.Printf("Successfully fetched user data: %v\n", u)
auth.go

C#‎

UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserAsync(uid);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully fetched user data: {userRecord.Uid}");

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

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

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

Node.js

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

Java

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

Python

from firebase_admin import auth

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

Go

u, err := client.GetUserByEmail(ctx, email)
if err != nil {
	log.Fatalf("error getting user by email %s: %v\n", email, err)
}
log.Printf("Successfully fetched user data: %v\n", u)
auth.go

C#‎

UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserByEmailAsync(email);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully fetched user data: {userRecord.Uid}");

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

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

אזהרה: כשמחפשים כתובות אימייל, אפשר לחפש רק את כתובת האימייל הראשית (ברמה העליונה) ולא כתובות אימייל ספציפיות של ספק. לדוגמה, אם חשבון פייסבוק עם כתובת אימייל שונה [e-mail] מקושר למשתמש קיים עם כתובת אימייל [e-mail], קריאה ל-getUserByEmail("[e-mail]") לא תחזיר תוצאות, אבל קריאה ל-getUserByEmail("[e-mail]") תחזיר את המשתמש הצפוי. במקרה של הגדרת ברירת המחדל 'חשבון יחיד לכל כתובת אימייל', כתובת האימייל הראשונה שמשמשת לכניסה לחשבון תשמש ככתובת האימייל ברמה העליונה, אלא אם היא תשונה בהמשך. כשהאפשרות 'מספר חשבונות לכל כתובת אימייל' מוגדרת, כתובת האימייל הראשית מוגדרת רק כשיוצרים משתמש עם סיסמה, אלא אם מעדכנים אותה באופן ידני.

במקרים אחרים, יופיע מספר הטלפון של המשתמש במקום 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);
  });
manage_users.js

Java

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

Python

from firebase_admin import auth

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

Go

u, err := client.GetUserByPhoneNumber(ctx, phone)
if err != nil {
	log.Fatalf("error getting user by phone %s: %v\n", phone, err)
}
log.Printf("Successfully fetched user data: %v\n", u)
auth.go

C#‎

UserRecord userRecord = await FirebaseAuth.DefaultInstance.GetUserByPhoneNumberAsync(phoneNumber);
// See the UserRecord reference doc for the contents of userRecord.
Console.WriteLine($"Successfully fetched user data: {userRecord.Uid}");

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

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

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

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

Node.js

getAuth()
  .getUsers([
    { uid: 'uid1' },
    { email: '[e-mail]' },
    { phoneNumber: '[phone]' },
    { providerId: 'google.com', providerUid: 'google_uid4' },
  ])
  .then((getUsersResult) => {
    console.log('Successfully fetched user data:');
    getUsersResult.users.forEach((userRecord) => {
      console.log(userRecord);
    });

    console.log('Unable to find users corresponding to these identifiers:');
    getUsersResult.notFound.forEach((userIdentifier) => {
      console.log(userIdentifier);
    });
  })
  .catch((error) => {
    console.log('Error fetching user data:', error);
  });
manage_users.js

Java

GetUsersResult result = FirebaseAuth.getInstance().getUsersAsync(Arrays.asList(
    new UidIdentifier("uid1"),
    new EmailIdentifier("[e-mail]"),
    new PhoneIdentifier("[phone]"),
    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('[e-mail]'),
    auth.PhoneIdentifier([phone]),
    auth.ProviderIdentifier('google.com', 'google_uid4')
])

print('Successfully fetched user data:')
for user in result.users:
    print(user.uid)

print('Unable to find users corresponding to these identifiers:')
for uid in result.not_found:
    print(uid)

Go

getUsersResult, err := client.GetUsers(ctx, []auth.UserIdentifier{
	auth.UIDIdentifier{UID: "uid1"},
	auth.EmailIdentifier{Email: "[e-mail]"},
	auth.PhoneIdentifier{PhoneNumber: "[phone]"},
	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("[e-mail]"),
        new PhoneIdentifier("[phone]"),
        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 המתאים או שגיאה שמציינת למה לא ניתן היה לחפש את המזהה הזה. רשימה מלאה של קודי השגיאה, כולל תיאורים ושלבי פתרון, מופיעה במאמר שגיאות ב-Admin Authentication API.

יצירת משתמש

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

Node.js

getAuth()
  .createUser({
    email: '[e-mail]',
    emailVerified: false,
    phoneNumber: '[phone]',
    password: 'secretPassword',
    displayName: 'John Doe',
    photoURL: 'http://www.example.com/12345678/photo.png',
    disabled: false,
  })
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully created new user:', userRecord.uid);
  })
  .catch((error) => {
    console.log('Error creating new user:', error);
  });
manage_users.js

Java

CreateRequest request = new CreateRequest()
    .setEmail("[e-mail]")
    .setEmailVerified(false)
    .setPassword("secretPassword")
    .setPhoneNumber("[phone]")
    .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='[e-mail]',
    email_verified=False,
    phone_number='[phone]',
    password='secretPassword',
    display_name='John Doe',
    photo_url='http://www.example.com/12345678/photo.png',
    disabled=False)
print(f'Sucessfully created new user: {user.uid}')

Go

params := (&auth.UserToCreate{}).
	Email("[e-mail]").
	EmailVerified(false).
	PhoneNumber("[phone]").
	Password("secretPassword").
	DisplayName("John Doe").
	PhotoURL("http://www.example.com/12345678/photo.png").
	Disabled(false)
u, err := client.CreateUser(ctx, params)
if err != nil {
	log.Fatalf("error creating user: %v\n", err)
}
log.Printf("Successfully created user: %v\n", u)
auth.go

C#‎

UserRecordArgs args = new UserRecordArgs()
{
    Email = "[e-mail]",
    EmailVerified = false,
    PhoneNumber = "[phone]",
    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 Authentication ייצור uid אקראי למשתמש החדש. אם אתם רוצים לציין uid משלכם עבור המשתמש החדש, אתם יכולים לכלול אותו כארגומנט שמועבר לשיטה ליצירת משתמש:

Node.js

getAuth()
  .createUser({
    uid: 'some-uid',
    email: '[e-mail]',
    phoneNumber: '[phone]',
  })
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully created new user:', userRecord.uid);
  })
  .catch((error) => {
    console.log('Error creating new user:', error);
  });
manage_users.js

Java

CreateRequest request = new CreateRequest()
    .setUid("some-uid")
    .setEmail("[e-mail]")
    .setPhoneNumber("[phone]");

UserRecord userRecord = FirebaseAuth.getInstance().createUser(request);
System.out.println("Successfully created new user: " + userRecord.getUid());

Python

user = auth.create_user(
    uid='some-uid', email='[e-mail]', phone_number='[phone]')
print(f'Sucessfully created new user: {user.uid}')

Go

params := (&auth.UserToCreate{}).
	UID(uid).
	Email("[e-mail]").
	PhoneNumber("[phone]")
u, err := client.CreateUser(ctx, params)
if err != nil {
	log.Fatalf("error creating user: %v\n", err)
}
log.Printf("Successfully created user: %v\n", u)
auth.go

C#‎

UserRecordArgs args = new UserRecordArgs()
{
    Uid = "some-uid",
    Email = "[e-mail]",
    PhoneNumber = "[phone]",
};
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 אקראי. סרטונים קצרים יותר של uid מניבים ביצועים טובים יותר.
email	מחרוזת	כתובת האימייל הראשית של המשתמש. חייבת להיות כתובת אימייל חוקית.
emailVerified	בוליאני	האם כתובת האימייל הראשית של המשתמש מאומתת. אם לא מציינים ערך, ברירת המחדל היא false.
phoneNumber	מחרוזת	מספר הטלפון הראשי של המשתמש. חייב להיות מספר טלפון תקין שתואם למפרט E.164.
password	מחרוזת	הסיסמה הגולמית של המשתמש, לא מוצפנת. הסיסמה צריכה לכלול לפחות שישה תווים.
displayName	מחרוזת	השם המוצג של המשתמשים.
photoURL	מחרוזת	כתובת ה-URL של התמונה של המשתמש.
disabled	בוליאני	האם המשתמש מושבת. ‫true להשבתה; ‫ false להפעלה. אם לא מציינים ערך, ברירת המחדל היא false.

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

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

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

עדכון משתמש

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

Node.js

getAuth()
  .updateUser(uid, {
    email: '[e-mail]',
    phoneNumber: '[phone]',
    emailVerified: true,
    password: 'newPassword',
    displayName: 'Jane Doe',
    photoURL: 'http://www.example.com/12345678/photo.png',
    disabled: true,
  })
  .then((userRecord) => {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully updated user', userRecord.toJSON());
  })
  .catch((error) => {
    console.log('Error updating user:', error);
  });
manage_users.js

Java

UpdateRequest request = new UpdateRequest(uid)
    .setEmail("[e-mail]")
    .setPhoneNumber("[phone]")
    .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='[e-mail]',
    phone_number='[phone]',
    email_verified=True,
    password='newPassword',
    display_name='John Doe',
    photo_url='http://www.example.com/12345678/photo.png',
    disabled=True)
print(f'Sucessfully updated user: {user.uid}')

Go

params := (&auth.UserToUpdate{}).
	Email("[e-mail]").
	EmailVerified(true).
	PhoneNumber("[phone]").
	Password("newPassword").
	DisplayName("John Doe").
	PhotoURL("http://www.example.com/12345678/photo.png").
	Disabled(true)
u, err := client.UpdateUser(ctx, uid, params)
if err != nil {
	log.Fatalf("error updating user: %v\n", err)
}
log.Printf("Successfully updated user: %v\n", u)
auth.go

C#‎

UserRecordArgs args = new UserRecordArgs()
{
    Uid = uid,
    Email = "[e-mail]",
    PhoneNumber = "[phone]",
    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	string | null	השם המוצג החדש של המשתמשים. מגדירים את הערך null כדי לנקות את השם המוצג הקיים של המשתמש.
photoURL	string | null	כתובת ה-URL של התמונה החדשה של המשתמשים. מגדירים את הערך null כדי לנקות את כתובת ה-URL הקיימת של התמונה של המשתמש. אם הערך הוא לא null, הוא חייב להיות כתובת URL תקינה.
disabled	בוליאני	האם המשתמש מושבת. ‫true להשבתה; ‫ false להפעלה.

הערה: כל המאפיינים שלמעלה הם אופציונליים. אם לא מציינים מאפיין מסוים, הערך הקיים של המאפיין הזה לא משתנה.

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

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

מחיקת משתמש

‫Firebase Admin SDK מאפשר למחוק משתמשים קיימים לפי uid:

Node.js

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

Java

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

Python

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

Go

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

C#‎

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

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

אם uid שצוין לא תואם למשתמש קיים או אם אי אפשר למחוק את המשתמש מסיבה אחרת, השיטה למחיקת משתמש מחזירה שגיאה. רשימה מלאה של קודי שגיאה, כולל תיאורים ושלבים לפתרון, זמינה במאמר שגיאות ב-Admin Authentication 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());
}

Python

from firebase_admin import auth

result = auth.delete_users(["uid1", "uid2", "uid3"])

print(f'Successfully deleted {result.success_count} users')
print(f'Failed to delete {result.failure_count} users')
for err in result.errors:
    print(f'error #{result.index}, reason: {result.reason}')

Go

deleteUsersResult, err := client.DeleteUsers(ctx, []string{"uid1", "uid2", "uid3"})
if err != nil {
	log.Fatalf("error deleting users: %v\n", err)
}

log.Printf("Successfully deleted %d users", deleteUsersResult.SuccessCount)
log.Printf("Failed to delete %d users", deleteUsersResult.FailureCount)
for _, err := range deleteUsersResult.Errors {
	log.Printf("%v", err)
}

C#‎

DeleteUsersResult result = await FirebaseAuth.DefaultInstance.DeleteUsersAsync(new List<string>
    {
        "uid1",
        "uid2",
        "uid3",
    });

Console.WriteLine($"Successfully deleted {result.SuccessCount} users.");
Console.WriteLine($"Failed to delete {result.FailureCount} users.");

foreach (ErrorInfo err in result.Errors)
{
    Console.WriteLine($"Error #{err.Index}, reason: {err.Reason}");
}

השיטה למחיקת משתמשים מחזירה רשימה של כשלים עבור המשתמשים שלא ניתן למחוק. רשימה מלאה של קודי שגיאה, כולל תיאורים ושלבים לפתרון, זמינה במאמר שגיאות ב-Admin Authentication 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();
manage_users.js

Java

// Start listing users from the beginning, 1000 at a time.
ListUsersPage page = FirebaseAuth.getInstance().listUsers(null);
while (page != null) {
  for (ExportedUserRecord user : page.getValues()) {
    System.out.println("User: " + user.getUid());
  }
  page = page.getNextPage();
}

// Iterate through all users. This will still retrieve users in batches,
// buffering no more than 1000 users in memory at a time.
page = FirebaseAuth.getInstance().listUsers(null);
for (ExportedUserRecord user : page.iterateAll()) {
  System.out.println("User: " + user.getUid());
}

Python

# Start listing users from the beginning, 1000 at a time.
page = auth.list_users()
while page:
    for user in page.users:
        print('User: ' + user.uid)
    # Get next batch of users.
    page = page.get_next_page()

# Iterate through all users. This will still retrieve users in batches,
# buffering no more than 1000 users in memory at a time.
for user in auth.list_users().iterate_all():
    print('User: ' + user.uid)

Go

// Note, behind the scenes, the Users() iterator will retrive 1000 Users at a time through the API
iter := client.Users(ctx, "")
for {
	user, err := iter.Next()
	if err == iterator.Done {
		break
	}
	if err != nil {
		log.Fatalf("error listing users: %s\n", err)
	}
	log.Printf("read user user: %v\n", user)
}

// Iterating by pages 100 users at a time.
// Note that using both the Next() function on an iterator and the NextPage()
// on a Pager wrapping that same iterator will result in an error.
pager := iterator.NewPager(client.Users(ctx, ""), 100, "")
for {
	var users []*auth.ExportedUserRecord
	nextPageToken, err := pager.NextPage(&users)
	if err != nil {
		log.Fatalf("paging error %v\n", err)
	}
	for _, u := range users {
		log.Printf("read user user: %v\n", u)
	}
	if nextPageToken == "" {
		break
	}
}
auth.go

C#‎

// Start listing users from the beginning, 1000 at a time.
var pagedEnumerable = FirebaseAuth.DefaultInstance.ListUsersAsync(null);
var responses = pagedEnumerable.AsRawResponses().GetAsyncEnumerator();
while (await responses.MoveNextAsync())
{
    ExportedUserRecords response = responses.Current;
    foreach (ExportedUserRecord user in response.Users)
    {
        Console.WriteLine($"User: {user.Uid}");
    }
}

// Iterate through all users. This will still retrieve users in batches,
// buffering no more than 1000 users in memory at a time.
var enumerator = FirebaseAuth.DefaultInstance.ListUsersAsync(null).GetAsyncEnumerator();
while (await enumerator.MoveNextAsync())
{
    ExportedUserRecord user = enumerator.Current;
    Console.WriteLine($"User: {user.Uid}");
}

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

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

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

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

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

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

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

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

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

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

אזהרה: אל תשתמשו בתפקיד Editor כדי להוסיף את ההרשאה firebaseauth.configs.getHashConfig. התפקיד הזה נותן הרשאות מעבר להיקף המיועד.