Gestisci utenti

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

  • Creare nuovi utenti senza alcuna limitazione o limitazione di frequenza.
  • Cerca gli utenti in base a diversi criteri, ad esempio UID, email o numero di telefono.
  • Elenca tutti gli utenti di un progetto specificato in batch.
  • Accedi ai metadati utente, tra cui la data di creazione dell'account e la data dell'ultimo accesso.
  • Elimina gli utenti senza richiedere la password esistente.
  • Aggiornare le proprietà utente, inclusa la password, senza dover accedere con le credenziali dell'utente.
  • Verificare le email senza dover seguire i flussi di azioni out-of-band per la verifica delle email.
  • Modificare l'email di un utente senza inviare link email per revocare queste modifiche.
  • Creare un nuovo utente con un numero di telefono senza dover seguire il flusso di verifica tramite SMS.
  • Modificare il numero di telefono di un utente senza dover seguire il flusso di verifica tramite SMS.
  • Esegui il provisioning offline degli utenti in stato disattivato e successivamente stabilisci quando attivarli.
  • Crea console utente personalizzate adattate al sistema di gestione degli utenti di un'applicazione specifica.

Prima di iniziare

Per utilizzare l'API di gestione degli utenti fornita dall'SDK Firebase Admin, devi avere un account di servizio. Segui le istruzioni di configurazione per ulteriori informazioni su come inizializzare l'SDK Admin.

Recuperare i dati utente

Il modo principale per identificare un utente è mediante il suo uid, un identificatore univoco per tale utente. L'SDK Admin fornisce un metodo che consente di recuperare le informazioni del profilo degli utenti in base al loro 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))

Vai

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

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

Se il valore uid fornito non appartiene a un utente esistente o se l'utente non può essere recuperato per qualsiasi altro motivo, il metodo riportato sopra genera un errore. Per un elenco completo dei codici di errore, incluse descrizioni e passaggi per la risoluzione, consulta Errori dell'API Admin Auth.

In alcuni casi, avrai l'indirizzo email di un utente anziché il suo uid. L'SDK Firebase Admin supporta la ricerca delle informazioni utente con un'email:

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

Vai

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

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

Se l'indirizzo email fornito non appartiene a un utente esistente o se l'utente non può essere recuperato per qualsiasi altro motivo, l'SDK Admin genera un errore. Per un elenco completo dei codici di errore, incluse descrizioni e passaggi per la risoluzione, consulta la pagina sugli errori dell'API Authentication per l'amministrazione.

In altri casi, avrai il numero di telefono di un utente anziché il suo uid. L'SDK Firebase Admin supporta la ricerca delle informazioni utente con un numero di telefono:

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

Vai

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

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

Se il numero di telefono fornito non appartiene a un utente esistente o se l'utente non può essere recuperato per qualsiasi altro motivo, l'SDK Admin genera un errore. Per un elenco completo dei codici di errore, incluse descrizioni e passaggi per la risoluzione, consulta la pagina sugli errori dell'API Authentication per l'amministrazione.

Recuperare collettivamente i dati utente

L'SDK Admin Firebase consente inoltre di recuperare un elenco di utenti in base agli identificatori da te forniti. Puoi identificare gli utenti in base al loro ID utente, indirizzo email o numero di telefono. In una singola chiamata è possibile fornire un massimo di 100 identificatori. Gli identificatori possono contenere una combinazione di tipi:

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

Java

GetUsersResult result = FirebaseAuth.getInstance().getUsersAsync(Arrays.asList(
    new UidIdentifier("uid1"),
    new EmailIdentifier("user2@example.com"),
    new PhoneIdentifier("+15555550003"),
    new ProviderIdentifier("google.com", "google_uid4"))).get();

System.out.println("Successfully fetched user data:");
for (UserRecord user : result.getUsers()) {
  System.out.println(user.getUid());
}

System.out.println("Unable to find users corresponding to these identifiers:");
for (UserIdentifier uid : result.getNotFound()) {
  System.out.println(uid);
}

Python

from firebase_admin import auth

result = auth.get_users([
    auth.UidIdentifier('uid1'),
    auth.EmailIdentifier('user2@example.com'),
    auth.PhoneIdentifier(+15555550003),
    auth.ProviderIdentifier('google.com', 'google_uid4')
])

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

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

Vai

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 dell'elenco di input, con ogni voce contenente il UserRecord corrispondente o un errore che indica il motivo per cui non è stato possibile eseguire la ricerca dell'identificatore. Per un elenco completo dei codici di errore, incluse descrizioni e procedure di risoluzione, consulta Errori dell'API Admin Authentication.

Crea un utente

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

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

Java

CreateRequest request = new CreateRequest()
    .setEmail("user@example.com")
    .setEmailVerified(false)
    .setPassword("secretPassword")
    .setPhoneNumber("+11234567890")
    .setDisplayName("John Doe")
    .setPhotoUrl("http://www.example.com/12345678/photo.png")
    .setDisabled(false);

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

Python

user = auth.create_user(
    email='user@example.com',
    email_verified=False,
    phone_number='+15555550100',
    password='secretPassword',
    display_name='John Doe',
    photo_url='http://www.example.com/12345678/photo.png',
    disabled=False)
print('Sucessfully created new user: {0}'.format(user.uid))

Vai

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)
auth.go

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 Authentication genera un uid casuale per il nuovo utente. Se invece vuoi specificare il tuo uid per il nuovo utente, puoi includerlo come argomento passato al metodo di creazione dell'utente:

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

Java

CreateRequest request = new CreateRequest()
    .setUid("some-uid")
    .setEmail("user@example.com")
    .setPhoneNumber("+11234567890");

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

Python

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

Vai

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)
auth.go

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

Puoi fornire qualsiasi combinazione delle seguenti proprietà:

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

Proprietà Tipo Descrizione
uid stringa Il uid da assegnare all'utente appena creato. Deve essere una stringa di lunghezza compresa tra 1 e 128 caratteri (inclusi). Se non viene fornito, verrà generato automaticamente un uid casuale. uid più brevi offrono un rendimento migliore.
email stringa L'indirizzo email principale dell'utente. Deve essere un indirizzo email valido.
emailVerified booleano Indica se l'indirizzo email principale dell'utente è verificato o meno. Se non viene fornito, il valore predefinito è false.
phoneNumber stringa Il numero di telefono principale dell'utente. Deve essere un numero di telefono valido conforme alle specifiche E.164.
password stringa La password non elaborata e non sottoposta ad hashing dell'utente. Deve avere una lunghezza di almeno sei caratteri.
displayName stringa Il nome visualizzato degli utenti.
photoURL stringa L'URL della foto dell'utente.
disabled booleano Indica se l'utente è disattivato o meno. true per disattivata; false per attivata. Se non viene fornito, il valore predefinito è false.

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

Se l'indirizzo uid, l'indirizzo email o il numero di telefono fornito sono già in uso da un utente esistente o se l'utente non può essere creato per qualsiasi altro motivo, il metodo riportato sopra non va a buon fine e genera un errore. Per un elenco completo dei codici di errore, incluse le descrizioni e la procedura di risoluzione, consulta Errori dell'API Admin Authentication.

Aggiornare un utente

L'SDK Firebase Admin semplifica la modifica dei dati di un utente esistente. Devi specificare un uid insieme alle proprietà da aggiornare per l'utente:

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

Java

UpdateRequest request = new UpdateRequest(uid)
    .setEmail("user@example.com")
    .setPhoneNumber("+11234567890")
    .setEmailVerified(true)
    .setPassword("newPassword")
    .setDisplayName("Jane Doe")
    .setPhotoUrl("http://www.example.com/12345678/photo.png")
    .setDisabled(true);

UserRecord userRecord = FirebaseAuth.getInstance().updateUser(request);
System.out.println("Successfully updated user: " + userRecord.getUid());

Python

user = auth.update_user(
    uid,
    email='user@example.com',
    phone_number='+15555550100',
    email_verified=True,
    password='newPassword',
    display_name='John Doe',
    photo_url='http://www.example.com/12345678/photo.png',
    disabled=True)
print('Sucessfully updated user: {0}'.format(user.uid))

Vai

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)
auth.go

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 di aggiornamento utente

Proprietà Tipo Descrizione
email stringa Il nuovo indirizzo email principale dell'utente. Deve essere un indirizzo email valido.
emailVerified booleano Indica se l'indirizzo email principale dell'utente è verificato o meno. Se non viene fornito, il valore predefinito è false.
phoneNumber stringa Il nuovo numero di telefono principale dell'utente. Deve essere un numero di telefono valido conforme alle specifiche E.164. Imposta su null per cancellare il numero di telefono esistente dell'utente.
password stringa La nuova password non sottoposta ad hashing e non elaborata dell'utente. Deve avere una lunghezza di almeno sei caratteri.
displayName stringa | null Nuovo nome visualizzato dell'utente. Imposta su null per cancellare il nome visualizzato esistente dell'utente.
photoURL stringa | null Il nuovo URL della foto dell'utente. Impostato su null per cancellare l'URL della foto esistente dell'utente. Se non è null, deve essere un URL valido.
disabled booleano Indica se l'utente è disattivato o meno. true per disattivata; false per attivata.

Il metodo update user restituisce un oggetto UserRecord aggiornato al termine dell'aggiornamento.

Se il valore uid fornito non corrisponde a un utente esistente, se l'indirizzo email o il numero di telefono fornito è già in uso da un utente esistente o se l'utente non può essere aggiornato per qualsiasi altro motivo, il metodo precedente non va a buon fine con un errore. Per un elenco completo dei codici di errore, incluse descrizioni e passaggi per la risoluzione, consulta Errori dell'API Authentication Amministrazione.

Eliminare un utente

L'SDK Firebase Admin consente di eliminare gli utenti esistenti in base al loro 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')

Vai

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

Il metodo elimina utente restituisce un risultato vuoto quando l'eliminazione viene completata correttamente.

Se il valore uid fornito non corrisponde a un utente esistente o se l'utente non può essere eliminato per qualsiasi altro motivo, il metodo di eliminazione dell'utente genera un errore. Per un elenco completo dei codici di errore, incluse descrizioni e passaggi per la risoluzione, consulta la pagina sugli errori dell'API Authentication per l'amministrazione.

Eliminare più utenti

L'SDK Admin di Firebase può anche eliminare più utenti contemporaneamente. Tuttavia, tieni presente che l'utilizzo di metodi come deleteUsers(uids) per eliminare più utenti contemporaneamente non attiverà i gestori eventi onDelete() per Cloud Functions for Firebase. Questo perché l'eliminazione batch non attiva un evento di eliminazione utente su ogni utente. Elimina gli utenti uno alla volta se vuoi che gli eventi di eliminazione degli utenti vengano attivati per ogni utente eliminato.

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

Vai

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 elimina utenti restituisce un elenco di errori relativi agli utenti che non è stato possibile eliminare. Per un elenco completo dei codici di errore, incluse le descrizioni e la procedura di risoluzione, consulta Errori dell'API Authentication Amministrazione.

Elenca tutti gli utenti

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

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)

Vai

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

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

Se non viene specificato alcun campo maxResults, viene utilizzato il valore predefinito di 1000 utenti per batch. Si tratta anche del numero massimo di utenti che è possibile elencare contemporaneamente. Qualsiasi valore maggiore del massimo genererà un errore relativo all'argomento. Se non viene specificato alcun valore pageToken, l'operazione elencherà gli utenti dall'inizio, ordinati in base a uid.

Per un elenco completo dei codici di errore, incluse le descrizioni e la procedura di risoluzione, consulta Errori dell'API Authentication Amministrazione.

Hash delle password degli utenti elencati

Questa API restituisce anche passwordSalt e passwordHash sottoposte ad hashing dal backend di Firebase Auth per gli utenti con password se l'account utente/di servizio utilizzato per generare il token di accesso OAuth della richiesta dispone dell'autorizzazione firebaseauth.configs.getHashConfig. In caso contrario, passwordHash e passwordSalt non verranno impostati.

A causa della natura sensibile degli hash delle password, per impostazione predefinita l'account di servizio SDK Firebase Admin non dispone dell'autorizzazione firebaseauth.configs.getHashConfig. Non puoi aggiungere un'autorizzazione direttamente a un account utente/di servizio, ma puoi farlo indirettamente creando un ruolo IAM personalizzato.

Per creare il ruolo IAM personalizzato:

  1. Vai alla pagina Ruoli nel riquadro IAM e amministrazione della console Google Cloud.
  2. Seleziona il progetto dal menu a discesa nella parte superiore della pagina.
  3. Fai clic su CREA RUOLO.
  4. Fai clic su AGGIUNGI AUTORIZZAZIONI.
  5. Cerca l'autorizzazione firebaseauth.configs.getHashConfig e seleziona la corrispondente casella di controllo.
  6. Fai clic su AGGIUNGI.
  7. Fai clic su CREA per completare la creazione del nuovo ruolo.

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

  1. Nel riquadro IAM e amministrazione, seleziona IAM.
  2. Seleziona l'account di servizio o utente dall'elenco dei membri da modificare.
  3. Fai clic su AGGIUNGI UN ALTRO RUOLO.
  4. Cerca il nuovo ruolo personalizzato creato in precedenza.
  5. Fai clic su SALVA.