Catch up on everthing we announced at this year's Firebase Summit. Learn more

Gestisci utenti

Firebase Admin SDK fornisce un'API per la gestione degli utenti di Firebase Authentication con privilegi elevati. L'API di gestione degli utenti amministratore ti offre la possibilità di completare in modo programmatico le seguenti attività da un ambiente server sicuro:

  • Crea nuovi utenti senza alcuna limitazione o limitazione della velocità.
  • Cerca gli utenti in base a criteri diversi come uid, e-mail o numero di telefono.
  • Elenca tutti gli utenti di un progetto specificato in batch.
  • Accedi ai metadati dell'utente, inclusa la data di creazione dell'account e la data dell'ultimo accesso.
  • Elimina gli utenti senza richiedere la password esistente.
  • Aggiorna le proprietà dell'utente, inclusa la password, senza dover accedere come utente.
  • Verifica le e-mail senza dover eseguire i flussi di azione fuori banda per la verifica delle e-mail.
  • Modificare l'e-mail di un utente senza inviare collegamenti e-mail per revocare queste modifiche.
  • Crea un nuovo utente con un numero di telefono senza dover passare attraverso il flusso di verifica SMS.
  • Modifica il numero di telefono di un utente senza dover eseguire il flusso di verifica SMS.
  • Esegui il provisioning offline degli utenti in uno stato disabilitato e successivamente controlla quando abilitarli.
  • Crea console utente personalizzate su misura per il sistema di gestione degli utenti di un'applicazione specifica.

Prima di iniziare

Per utilizzare l'API di gestione degli utenti fornita da Firebase Admin SDK, devi disporre di un account di servizio. Seguire le istruzioni di installazione per ulteriori informazioni su come inizializzare l'SDK di amministrazione.

Recupera i dati dell'utente

Il modo principale per identificare un utente è dalla loro uid , un identificatore univoco per l'utente. L'Admin SDK fornisce un metodo che permette il recupero le informazioni sul profilo degli utenti da parte loro uid :

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

Giava

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

Pitone

from firebase_admin import auth

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

andare

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

Questo metodo restituisce un UserRecord oggetto per l'utente corrispondente alla uid fornito al metodo.

Se la condizione uid non appartiene a un utente esistente o l'utente non può essere recuperata per qualsiasi altro motivo, il metodo di cui sopra genera un errore. Per un elenco completo dei codici di errore, comprese le descrizioni e le fasi di risoluzione, vedi Admin Auth errori API .

In alcuni casi si avrà email di un utente, invece del loro uid . L'SDK di Firebase Admin supporta la ricerca di informazioni sugli utenti con un'e-mail:

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

Giava

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

Pitone

from firebase_admin import auth

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

andare

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

Questo metodo restituisce un UserRecord oggetto per l'utente corrispondente al email fornito.

Se l'email fornita non appartiene a un utente esistente o se l'utente non può essere recuperato per altri motivi, l'SDK di amministrazione genera un errore. Per un elenco completo dei codici di errore, comprese le descrizioni e le fasi di risoluzione, vedere Autenticazione Admin errori API .

In altri casi, si avrà il numero di telefono di un utente al posto del loro uid . Firebase Admin SDK supporta la ricerca di informazioni utente con un numero di telefono:

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

Giava

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

Pitone

from firebase_admin import auth

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

andare

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

Questo metodo restituisce un UserRecord oggetto per l'utente corrispondente al numero di telefono fornito.

Se il numero di telefono fornito non appartiene a un utente esistente o l'utente non può essere recuperato per altri motivi, l'SDK di amministrazione genera un errore. Per un elenco completo dei codici di errore, comprese le descrizioni e le fasi di risoluzione, vedere Autenticazione Admin errori API .

Recupero in blocco dei dati dell'utente

Firebase Admin SDK consente inoltre di recuperare un elenco di utenti in base agli identificatori forniti. Puoi identificare gli utenti in base al loro ID utente, e-mail o numero di telefono. È possibile fornire un massimo di 100 identificatori in una singola chiamata. Gli identificatori possono contenere un mix di tipi:

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

Giava

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

Pitone

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)

andare

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

Questo metodo restituisce un elenco delle stesse dimensioni come la lista di ingresso, con ogni voce che contiene sia il corrispondente UserRecord o un errore che indica il motivo per cui tale identificatore non è stato in grado di essere guardato. Per un elenco completo dei codici di errore, comprese le descrizioni e le fasi di risoluzione, vedere Autenticazione Admin errori API .

Crea un utente

L'Admin SDK fornisce un metodo che consente di creare un nuovo utente Firebase Authentication. Questo metodo accetta un oggetto contenente le informazioni sul profilo da includere nell'account utente appena creato:

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

Giava

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

Pitone

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

andare

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

Per impostazione predefinita, Firebase autenticazione genererà un caso uid per il nuovo utente. Se invece desidera specificare il proprio uid per il nuovo utente, è possibile includere come argomento passato al metodo creazione dell'utente:

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

Giava

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

Pitone

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

andare

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

È possibile fornire qualsiasi combinazione delle seguenti proprietà:

Tabella 1. Proprietà supportate dall'operazione di creazione dell'utente

Proprietà Tipo Descrizione
uid corda uid da assegnare al nuovo utente. Deve essere una stringa di lunghezza compresa tra 1 e 128 caratteri, inclusi. Se non fornito, un casuale uid verrà generato automaticamente.
email corda L'email principale dell'utente. Deve essere un indirizzo email valido.
emailVerified booleano Se l'email principale dell'utente è verificata o meno. Se non previsto, il valore predefinito è false .
phoneNumber corda Il numero di telefono principale dell'utente. Deve essere un numero di telefono valido conforme alle specifiche E.164.
password corda La password grezza e senza hash dell'utente. Deve contenere almeno sei caratteri.
displayName corda Il nome visualizzato degli utenti.
photoURL corda L'URL della foto dell'utente.
disabled booleano Se l'utente è disabilitato o meno. true per disabili; false per abilitato. Se non previsto, il valore predefinito è false .

Il metodo di creazione dell'utente restituisce un UserRecord oggetto per l'utente appena creato.

Se la condizione uid , e-mail o numero di telefono è già in uso da parte di un utente esistente o l'utente non possono essere creati per qualsiasi altro motivo, il metodo di cui sopra non riesce con un errore. Per un elenco completo dei codici di errore, comprese le descrizioni e le fasi di risoluzione, vedere Autenticazione Admin errori API .

Aggiorna un utente

Firebase Admin SDK facilita la modifica dei dati di un utente esistente. È necessario specificare un uid insieme con le proprietà di aggiornamento per l'utente:

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

Giava

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

Pitone

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

andare

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

È possibile fornire qualsiasi combinazione delle seguenti proprietà:

Tabella 2. Proprietà supportate dall'operazione dell'utente di aggiornamento

Proprietà Tipo Descrizione
email corda La nuova email principale dell'utente. Deve essere un indirizzo email valido.
emailVerified booleano Se l'email principale dell'utente è verificata o meno. Se non previsto, il valore predefinito è false .
phoneNumber corda Il nuovo numero di telefono principale dell'utente. Deve essere un numero di telefono valido conforme alle specifiche E.164. Impostare a null per cancellare il numero di telefono esistente dell'utente.
password corda La nuova password grezza e senza hash dell'utente. Deve contenere almeno sei caratteri.
displayName stringa | null Il nuovo nome visualizzato degli utenti. Impostare a null per cancellare il nome visualizzato esistente dell'utente.
photoURL stringa | null L'URL della nuova foto degli utenti. Impostare a null per cancellare URL foto esistente dell'utente. Se non null , deve essere un URL valido.
disabled booleano Se l'utente è disabilitato o meno. true per disabili; false per abilitato.

Il metodo di aggiornamento utente restituisce un aggiornato UserRecord oggetto quando l'aggiornamento viene completato correttamente.

Se la condizione uid non corrisponde a un utente esistente, l'email fornito o il numero di telefono è già in uso da un utente esistente, oppure l'utente non possono essere aggiornate per qualunque altro motivo, il metodo precedente non riesce con un errore. Per un elenco completo dei codici di errore, comprese le descrizioni e le fasi di risoluzione, vedere Autenticazione Admin errori API .

Elimina un utente

Il Firebase Admin SDK permette di cancellare gli utenti esistenti per la loro uid :

Nodo.js

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

Giava

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

Pitone

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

andare

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

Il metodo delete user restituisce un risultato vuoto quando l'eliminazione viene completata correttamente.

Se la condizione uid non corrisponde a un utente esistente o l'utente non può essere cancellato per qualsiasi altro motivo, il metodo di eliminazione utente genera un errore. Per un elenco completo dei codici di errore, comprese le descrizioni e le fasi di risoluzione, vedere Autenticazione Admin errori API .

Elimina più utenti

Firebase Admin SDK può anche eliminare più utenti contemporaneamente. Tuttavia, nota che l'uso di metodi come deleteUsers(uids) per eliminare più utenti contemporaneamente non si innescherà onDelete() gestori di eventi per le funzioni cloud per Firebase. Questo perché l'eliminazione batch non attiva un evento di eliminazione utente su ogni utente. Elimina gli utenti uno alla volta se desideri che gli eventi di eliminazione degli utenti vengano attivati ​​per ogni utente eliminato.

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

Giava

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

Pitone

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

andare

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

Il metodo delete users restituisce un elenco di errori per gli utenti che non è stato possibile eliminare. Per un elenco completo dei codici di errore, comprese le descrizioni e le fasi di risoluzione, vedere Autenticazione Admin errori API .

Elenca tutti gli utenti

Firebase Admin SDK consente di recuperare l'intero elenco di utenti in batch:

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

Giava

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

Pitone

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

andare

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

Ogni batch di risultati contiene un elenco di utenti e il token della pagina successiva utilizzato per elencare il batch di utenti successivo. Quando tutti gli utenti sono già stati elencati, non pageToken viene restituito.

Se nessun maxResults è specificato campo, il valore di default di 1000 utenti per ogni lotto viene utilizzato. Questo è anche il numero massimo di utenti che possono essere elencati alla volta. Qualsiasi valore maggiore del massimo genererà un errore di argomento. Se nessun pageToken viene specificato, l'operazione elencherà gli utenti fin dall'inizio, ordinato da uid .

Per un elenco completo dei codici di errore, comprese le descrizioni e le fasi di risoluzione, vedere Autenticazione Admin errori API .

Hash delle password degli utenti elencati

Questa API restituisce anche il passwordSalt e passwordHash hash dal backend Firebase Auth per gli utenti delle password se l'account utente / servizio utilizzato per generare la richiesta di accesso token OAuth ha la firebaseauth.configs.getHashConfig permesso. In caso contrario, il passwordHash e passwordSalt non verranno impostate.

A causa della natura sensibile del hash delle password, l'account del servizio Firebase Admin SDK non ha il firebaseauth.configs.getHashConfig autorizzazione per impostazione predefinita. Non è possibile aggiungere un permesso direttamente a un account utente / servizio, ma è possibile farlo indirettamente la creazione di un ruolo IAM personalizzato .

Per creare il ruolo IAM personalizzato:

  1. Vai alla pagina Ruoli in IAM e pannello di amministrazione nel Cloud Console di Google.
  2. Seleziona il tuo progetto dal menu a discesa nella parte superiore della pagina.
  3. Fare clic su Crea RUOLO
  4. Fare clic su Autorizzazioni ADD
  5. Cerca firebaseauth.configs.getHashConfig permesso e selezionare la casella di controllo.
  6. Fare clic su Aggiungi
  7. Fare clic su Crea per completare la creazione del nuovo ruolo.

Aggiungi il ruolo personalizzato creato all'account utente/servizio nella pagina IAM:

  1. Nel pannello di IAM e di amministrazione, selezionare IAM
  2. Selezionare il servizio o l'account utente dall'elenco dei membri per la modifica.
  3. Fare clic su Aggiungi un altro ruolo.
  4. Cerca il nuovo ruolo personalizzato creato in precedenza.
  5. Fare clic su SALVA.