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

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

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

לפני שמתחילים

כדי להשתמש בממשק ה-API לניהול משתמשים שסופק על ידי ה-SDK של Firebase Admin, צריך להיות לכם חשבון שירות. בהוראות ההגדרה מוסבר איך מפעילים את 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('Successfully fetched user data: {0}'.format(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('Successfully fetched user data: {0}'.format(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}");

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

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

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

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

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('Successfully fetched user data: {0}'.format(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.

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

ה-SDK של Firebase Admin מאפשר גם לאחזר רשימת משתמשים על סמך מזהים שאתם מספקים. אפשר לזהות משתמשים לפי מזהה המשתמש, כתובת האימייל או מספר הטלפון שלהם. אפשר לספק עד 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 התואם או שגיאה שמציינת למה לא ניתן היה לחפש את המזהה. לרשימה המלאה של קודי השגיאה, כולל תיאורים ושלבים לפתרון, ראו שגיאות 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('Sucessfully created new user: {0}'.format(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('Sucessfully created new user: {0}'.format(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	מחרוזת	הסיסמה הגולמית, ללא גיבוב (hash) של המשתמש. אורך השם צריך להיות שישה תווים לפחות.
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('Sucessfully updated user: {0}'.format(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	מחרוזת | null	השם המוצג החדש של המשתמשים. צריך להגדיר את הערך כ-null כדי למחוק את השם המוצג הקיים של המשתמש.
photoURL	מחרוזת | null	כתובת ה-URL החדשה של התמונה של המשתמשים. מגדירים את הערך null כדי למחוק את כתובת ה-URL הקיימת של התמונה של המשתמש. אם השדה לא מכיל את הערך null, הוא חייב לכלול כתובת URL חוקית.
disabled	בוליאני	האם המשתמש מושבת או לא. true לצורך השבתה,‏ false לצורך הפעלה.

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

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

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

מחיקת משתמש

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

מחיקת משתמשים מרובים

אפשר גם למחוק כמה משתמשים בו-זמנית באמצעות ה-SDK של Firebase Admin. עם זאת, חשוב לזכור: שימוש בשיטות כמו 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('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))

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

השיטה delete users מחזירה רשימה של כשלים של משתמשים שלא ניתן למחוק. רשימה מלאה של קודי השגיאה, כולל תיאורים והוראות לפתרון, מופיעה במאמר שגיאות ב-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 למשתמשים עם סיסמה, אם לחשבון המשתמש או לחשבון השירות ששימשו ליצירת אסימון הגישה של הבקשה ל-OAuth יש את ההרשאה firebaseauth.configs.getHashConfig. אחרת, הערכים של passwordHash ו-passwordSalt לא יוגדרו.

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

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

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

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

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

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