Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Gestisci utenti

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

  • Crea nuovi utenti senza limitazione o limitazione della velocità.
  • Cerca gli utenti in base a diversi criteri come uid, email o numero di telefono.
  • Elencare tutti gli utenti di un progetto specificato in batch.
  • Accedi ai metadati dell'utente tra cui la data di creazione dell'account e la data dell'ultimo accesso.
  • Elimina gli utenti senza richiedere la loro password esistente.
  • Aggiorna le proprietà dell'utente, inclusa la password, senza dover accedere come utente.
  • Verifica le e-mail senza dover passare attraverso i flussi di azioni 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 passare attraverso il flusso di verifica SMS.
  • Gli utenti di provisioning offline in uno stato disabilitato e successivamente controllano quando abilitarli.
  • Crea console utente personalizzate su misura per il sistema di gestione utenti di un'applicazione specifica.

Prima di iniziare

Per utilizzare l'API di gestione utenti fornita da Firebase Admin SDK, è necessario 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 è tramite il suo uid , un identificatore univoco per quell'utente. Admin SDK fornisce un metodo che consente di recuperare le informazioni del profilo degli utenti tramite il loro uid :

Node.js

 admin.auth().getUser(uid)
  .then(function(userRecord) {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully fetched user data:', userRecord.toJSON());
  })
  .catch(function(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))
 

Partire

 // 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 l' uid fornito non appartiene a un utente esistente o l'utente non può essere recuperato per nessun altro motivo, il metodo sopra genera un errore. Per un elenco completo dei codici di errore, comprese le descrizioni e i passaggi per la risoluzione, vedere Errori dell'API di autenticazione amministratore .

In alcuni casi avrai l'e-mail di un utente invece del loro uid . Firebase Admin SDK supporta la ricerca delle informazioni utente tramite e-mail:

Node.js

 admin.auth().getUserByEmail(email)
  .then(function(userRecord) {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully fetched user data:', userRecord.toJSON());
  })
  .catch(function(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))
 

Partire

 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 oggetto UserRecord per l'utente corrispondente UserRecord fornita.

Se l'e-mail fornita non appartiene a un utente esistente o l'utente non può essere recuperato per altri motivi, Admin SDK genera un errore. Per un elenco completo dei codici di errore, inclusi descrizioni e passaggi della risoluzione, vedere Errori dell'API di autenticazione dell'amministratore .

In altri casi, avrai il numero di telefono di un utente invece del loro uid . Firebase Admin SDK supporta la ricerca delle informazioni utente con un numero di telefono:

Node.js

 admin.auth().getUserByPhoneNumber(phoneNumber)
  .then(function(userRecord) {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully fetched user data:', userRecord.toJSON());
  })
  .catch(function(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))
 

Partire

 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 oggetto UserRecord 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 nessun altro motivo, Admin SDK genera un errore. Per un elenco completo dei codici di errore, inclusi descrizioni e passaggi della risoluzione, vedere Errori dell'API di autenticazione dell'amministratore .

Recupero in blocco dei dati utente

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

Node.js

 admin.auth().getUsers([
    { uid: 'uid1' },
    { email: 'user2@example.com' },
    { phoneNumber: '+15555550003' },
    { providerId: 'google.com', providerUid: 'google_uid4' },
  ])
  .then(function(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(function(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)
 

Partire

 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 ciascuna voce contenente il corrispondente UserRecord o un errore che indica il motivo per cui tale identificatore non è stato possibile cercare. Per un elenco completo dei codici di errore, inclusi descrizioni e passaggi della risoluzione, vedere Errori dell'API di autenticazione dell'amministratore .

Crea un utente

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

Node.js

 admin.auth().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(function(userRecord) {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully created new user:', userRecord.uid);
  })
  .catch(function(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))
 

Partire

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

Node.js

 admin.auth().createUser({
  uid: 'some-uid',
  email: 'user@example.com',
  phoneNumber: '+11234567890'
})
  .then(function(userRecord) {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully created new user:', userRecord.uid);
  })
  .catch(function(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))
 

Partire

 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à genere Descrizione
uid corda L' uid da assegnare all'utente appena creato. Deve contenere una stringa compresa tra 1 e 128 caratteri, inclusi. Se non fornito, un uid casuale verrà generato automaticamente.
email corda L'email principale dell'utente. Deve essere un indirizzo email valido.
emailVerified booleano Verifica dell'email principale dell'utente. Se non fornito, il valore predefinito è false .
phoneNumber corda Il numero di telefono principale dell'utente. Deve essere un numero di telefono conforme alle specifiche E.164 valido.
password corda La password grezza e non trattata 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 fornito, il valore predefinito è false .

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

Se l' uid , l'e-mail o il numero di telefono forniti sono già in uso da un utente esistente o l'utente non può essere creato per nessun altro motivo, il metodo sopra riportato non riesce con un errore. Per un elenco completo dei codici di errore, inclusi descrizioni e passaggi della risoluzione, vedere Errori dell'API di autenticazione dell'amministratore .

Aggiorna un utente

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

Node.js

 admin.auth().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(function(userRecord) {
    // See the UserRecord reference doc for the contents of userRecord.
    console.log('Successfully updated user', userRecord.toJSON());
  })
  .catch(function(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))
 

Partire

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

Proprietà genere Descrizione
email corda La nuova email principale dell'utente. Deve essere un indirizzo email valido.
emailVerified booleano Verifica dell'email principale dell'utente. Se non fornito, il valore predefinito è false .
phoneNumber corda Il nuovo numero di telefono principale dell'utente. Deve essere un numero di telefono conforme alle specifiche E.164 valido. Impostare su null per cancellare il numero di telefono esistente dell'utente.
password corda La nuova password grezza e non trattata dell'utente. Deve contenere almeno sei caratteri.
displayName stringa | null Il nuovo nome visualizzato degli utenti. Impostare su null per cancellare il nome visualizzato esistente dell'utente.
photoURL stringa | null Il nuovo URL della foto degli utenti. Impostare su null per cancellare l'URL della 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 oggetto UserRecord aggiornato al UserRecord dell'aggiornamento.

Se l' uid fornito non corrisponde a un utente esistente, l'e-mail o il numero di telefono forniti sono già in uso da un utente esistente o l'utente non può essere aggiornato per nessun altro motivo, il metodo sopra riportato non riesce con un errore. Per un elenco completo dei codici di errore, inclusi descrizioni e passaggi della risoluzione, vedere Errori dell'API di autenticazione dell'amministratore .

Elimina un utente

Firebase Admin SDK consente di eliminare gli utenti esistenti tramite il loro uid :

Node.js

 admin.auth().deleteUser(uid)
  .then(function() {
    console.log('Successfully deleted user');
  })
  .catch(function(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')
 

Partire

 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 di eliminazione utente restituisce un risultato vuoto quando l'eliminazione viene completata correttamente.

Se l' uid fornito non corrisponde a un utente esistente o l'utente non può essere eliminato per nessun altro motivo, il metodo di eliminazione utente genera un errore. Per un elenco completo dei codici di errore, inclusi descrizioni e passaggi della risoluzione, vedere Errori dell'API di autenticazione dell'amministratore .

Elimina più utenti

Firebase Admin SDK può anche eliminare più utenti contemporaneamente:

Node.js

 admin.auth().deleteUsers([uid1, uid2, uid3])
  .then(function(deleteUsersResult) {
    console.log('Successfully deleted ' + deleteUsersResult.successCount + ' users');
    console.log('Failed to delete ' +  deleteUsersResult.failureCount + ' users');
    deleteUsersResult.errors.forEach(function(err) {
      console.log(err.error.toJSON());
    });
  })
  .catch(function(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))
 

Partire

 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 di eliminazione degli utenti restituisce un elenco di errori per gli utenti che non sono stati in grado di essere eliminati. Per un elenco completo dei codici di errore, inclusi descrizioni e passaggi della risoluzione, vedere Errori dell'API di autenticazione dell'amministratore .

Elenca tutti gli utenti

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

Node.js

 function listAllUsers(nextPageToken) {
  // List batch of users, 1000 at a time.
  admin.auth().listUsers(1000, nextPageToken)
    .then(function(listUsersResult) {
      listUsersResult.users.forEach(function(userRecord) {
        console.log('user', userRecord.toJSON());
      });
      if (listUsersResult.pageToken) {
        // List next batch of users.
        listAllUsers(listUsersResult.pageToken);
      }
    })
    .catch(function(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)
 

Partire

 // 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().GetEnumerator();
while (await responses.MoveNext())
{
    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).GetEnumerator();
while (await enumerator.MoveNext())
{
    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 viene restituito nessun pageToken .

Se non viene specificato alcun campo maxResults , vengono utilizzati i 1000 utenti predefiniti per batch. Questo è anche il numero massimo di utenti che possono essere elencati alla volta. Qualsiasi valore maggiore del massimo genererà un errore argomento. Se non viene specificato pageToken , l'operazione elencherà gli utenti dall'inizio, ordinati per uid .

Per un elenco completo dei codici di errore, inclusi descrizioni e passaggi della risoluzione, vedere Errori dell'API di autenticazione dell'amministratore .

Hash password degli utenti elencati

Questa API restituisce anche passwordSalt e passwordHash hash dal back-end di Firebase Auth per gli utenti di password se l'account utente / servizio utilizzato per generare il token di accesso OAuth della richiesta dispone dell'autorizzazione firebaseauth.configs.getHashConfig . Altrimenti passwordHash e passwordSalt non verranno impostati.

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

Per creare il ruolo IAM personalizzato:

  1. Vai alla pagina Ruoli in IAM e pannello di amministrazione nella Console GCP.
  2. Seleziona il tuo progetto dal menu a discesa nella parte superiore della pagina.
  3. Fai clic su CREA RUOLO
  4. Fai clic su AGGIUNGI PERMESSI
  5. Cerca l'autorizzazione firebaseauth.configs.getHashConfig e seleziona quella casella di controllo.
  6. Fai clic su AGGIUNGI
  7. Fai clic su CREA per terminare la creazione del nuovo ruolo.

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

  1. Nel pannello IAM e amministrazione , selezionare IAM
  2. Seleziona il servizio o l'account utente dall'elenco dei membri per la modifica.
  3. Fai clic su AGGIUNGI UN ALTRO RUOLO .
  4. Cerca il nuovo ruolo personalizzato precedentemente creato.
  5. Fai clic su SALVA .