Gerenciar usuários

O Firebase Admin SDK fornece uma API para gerenciar usuários do Firebase Authentication com privilégios elevados. A API de gerenciamento de usuários administradores oferece a capacidade de concluir programaticamente as seguintes tarefas em um ambiente de servidor seguro:

• Crie novos usuários sem qualquer limitação ou limitação de taxa.
• Procure usuários por diferentes critérios, como uid, email ou número de telefone.
• Liste todos os usuários de um projeto especificado em lotes.
• Acesse os metadados do usuário, incluindo a data de criação da conta e a data do último login.
• Exclua usuários sem exigir a senha existente.
• Atualize as propriedades do usuário, incluindo a senha, sem precisar fazer login como usuário.
• Verifique e-mails sem precisar passar pelos fluxos de ação fora de banda para verificação de e-mails.
• Altere o e-mail de um usuário sem enviar links de e-mail para revogar essas alterações.
• Crie um novo usuário com um número de telefone sem precisar passar pelo fluxo de verificação por SMS.
• Altere o número de telefone de um usuário sem precisar passar pelo fluxo de verificação por SMS.
• Provisione usuários off-line em um estado desativado e, posteriormente, controle quando ativá-los.
• Crie consoles de usuário personalizados, adaptados ao sistema de gerenciamento de usuários de um aplicativo específico.

Antes de você começar

Para usar a API de gerenciamento de usuários fornecida pelo SDK Admin do Firebase, você precisa ter uma conta de serviço. Siga as instruções de configuração para obter mais informações sobre como inicializar o Admin SDK.

Recuperar dados do usuário

A principal forma de identificar um usuário é pelo seu uid , um identificador exclusivo desse usuário. O Admin SDK fornece um método que permite buscar as informações de perfil dos usuários por meio de seu 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());

Pitão

from firebase_admin import auth

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

Ir

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

Este método retorna um objeto UserRecord para o usuário correspondente ao uid fornecido ao método.

Se o uid fornecido não pertencer a um usuário existente ou o usuário não puder ser obtido por qualquer outro motivo, o método acima gerará um erro. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Em alguns casos, você terá o email de um usuário em vez de seu uid . O Firebase Admin SDK oferece suporte à pesquisa de informações do usuário por e-mail:

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

Pitão

from firebase_admin import auth

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

Ir

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

Este método retorna um objeto UserRecord para o usuário correspondente ao email fornecido.

Se o e-mail fornecido não pertencer a um usuário existente ou o usuário não puder ser obtido por qualquer outro motivo, o Admin SDK gerará um erro. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Aviso: para pesquisa de e-mail, você só pode pesquisar o e-mail principal (nível superior) e não e-mails específicos do provedor. Por exemplo, se uma conta do Facebook com um e-mail diferente [e-mail] estiver vinculada a um usuário existente com o e-mail [e-mail] , chamar getUserByEmail("[e-mail]") não produzirá resultados, enquanto getUserByEmail("[e-mail]") retornará o usuário esperado. No caso da configuração padrão "conta única por e-mail", o primeiro e-mail usado para fazer login será usado como e-mail de nível superior, a menos que seja modificado posteriormente. Quando "várias contas por e-mail" é definido, o e-mail principal só é definido quando uma senha de usuário é criada, a menos que seja atualizada manualmente.

Em outros casos, você terá o número de telefone do usuário em vez do uid . O Firebase Admin SDK oferece suporte à pesquisa de informações do usuário com um número de telefone:

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

Pitão

from firebase_admin import auth

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

Ir

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

Este método retorna um objeto UserRecord para o usuário correspondente ao número de telefone fornecido.

Se o número de telefone fornecido não pertencer a um usuário existente ou o usuário não puder ser obtido por qualquer outro motivo, o Admin SDK gerará um erro. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Recuperar dados do usuário em massa

O SDK Admin do Firebase também permite recuperar uma lista de usuários com base nos identificadores que você fornece. Você pode identificar usuários por ID de usuário, email ou número de telefone. Um máximo de 100 identificadores podem ser fornecidos em uma única chamada. Os identificadores podem conter uma combinação de tipos:

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

Pitão

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)

Ir

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

Este método retorna uma lista do mesmo tamanho da lista de entrada, com cada entrada contendo o UserRecord correspondente ou um erro indicando por que esse identificador não pôde ser consultado. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Crie um usuário

O SDK Admin fornece um método que permite criar um novo usuário do Firebase Authentication. Este método aceita um objeto contendo as informações do perfil para incluir na conta de usuário recém-criada:

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

Pitão

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

Ir

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

Por padrão, o Firebase Authentication irá gerar um uid aleatório para o novo usuário. Se você quiser especificar seu próprio uid para o novo usuário, poderá incluí-lo como um argumento passado para o método de criação de usuário:

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

Pitão

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

Ir

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

Qualquer combinação das seguintes propriedades pode ser fornecida:

Tabela 1. Propriedades suportadas pela operação de criação de usuário

Propriedade	Tipo	Descrição
uid	corda	O uid a ser atribuído ao usuário recém-criado. Deve ser uma string entre 1 e 128 caracteres, inclusive. Se não for fornecido, um uid aleatório será gerado automaticamente. uid s mais curtos oferecem melhor desempenho.
email	corda	O e-mail principal do usuário. Deve ser um endereço de e-mail válido.
emailVerified	boleano	Se o e-mail principal do usuário foi verificado ou não. Se não for fornecido, o padrão será false .
phoneNumber	corda	O número de telefone principal do usuário. Deve ser um número de telefone válido e compatível com a especificação E.164.
password	corda	A senha bruta e sem hash do usuário. Deve ter pelo menos seis caracteres.
displayName	corda	O nome de exibição dos usuários.
photoURL	corda	O URL da foto do usuário.
disabled	boleano	Se o usuário está desabilitado ou não. true para deficientes; false para habilitado. Se não for fornecido, o padrão será false .

Nota: Todas as propriedades acima são opcionais. Se uma determinada propriedade não for especificada, o valor dessa propriedade ficará vazio, a menos que um padrão seja mencionado na tabela acima.

O método de criação de usuário retorna um objeto UserRecord para o usuário recém-criado.

Se o uid , e-mail ou número de telefone fornecido já estiver em uso por um usuário existente ou o usuário não puder ser criado por qualquer outro motivo, o método acima falhará com um erro. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Atualizar um usuário

O SDK Admin do Firebase facilita a modificação dos dados de um usuário existente. Você precisa especificar um uid junto com as propriedades a serem atualizadas para esse usuário:

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

Pitão

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

Ir

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

Qualquer combinação das seguintes propriedades pode ser fornecida:

Tabela 2. Propriedades suportadas pela operação de atualização do usuário

Propriedade	Tipo	Descrição
email	corda	O novo e-mail principal do usuário. Deve ser um endereço de e-mail válido.
emailVerified	boleano	Se o e-mail principal do usuário foi verificado ou não. Se não for fornecido, o padrão será false .
phoneNumber	corda	O novo número de telefone principal do usuário. Deve ser um número de telefone válido e compatível com a especificação E.164. Defina como null para limpar o número de telefone existente do usuário.
password	corda	A nova senha bruta e sem hash do usuário. Deve ter pelo menos seis caracteres.
displayName	corda | null	O novo nome de exibição dos usuários. Defina como null para limpar o nome de exibição existente do usuário.
photoURL	corda | null	O novo URL da foto dos usuários. Defina como null para limpar o URL da foto existente do usuário. Se não for null , deverá ser um URL válido.
disabled	boleano	Se o usuário está desabilitado ou não. true para deficientes; false para habilitado.

Nota: Todas as propriedades acima são opcionais. Se uma determinada propriedade não for especificada, o valor existente dessa propriedade permanecerá inalterado.

O método update user retorna um objeto UserRecord atualizado quando a atualização é concluída com êxito.

Se o uid fornecido não corresponder a um usuário existente, o e-mail ou número de telefone fornecido já estiver em uso por um usuário existente ou o usuário não puder ser atualizado por qualquer outro motivo, o método acima falhará com um erro. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Excluir um usuário

O SDK Admin do Firebase permite excluir usuários existentes pelo seu 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.");

Pitão

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

Ir

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

O método delete user retorna um resultado vazio quando a exclusão é concluída com sucesso.

Se o uid fornecido não corresponder a um usuário existente ou o usuário não puder ser excluído por qualquer outro motivo, o método delete user gerará um erro. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Excluir vários usuários

O Firebase Admin SDK também pode excluir vários usuários de uma só vez. No entanto, observe que o uso de métodos como deleteUsers(uids) para excluir vários usuários de uma vez não acionará manipuladores de eventos onDelete() para Cloud Functions para Firebase. Isso ocorre porque a exclusão em lote não aciona um evento de exclusão de usuário em cada usuário. Exclua um usuário por vez se desejar que eventos de exclusão de usuário sejam acionados para cada usuário excluído.

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

Pitão

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

Ir

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

O método delete users retorna uma lista de falhas para os usuários que não puderam ser excluídos. Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Listar todos os usuários

O Firebase Admin SDK permite recuperar a lista completa de usuários em lotes:

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

Pitão

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

Ir

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

Cada lote de resultados contém uma lista de usuários e o token da próxima página usado para listar o próximo lote de usuários. Quando todos os usuários já estiverem listados, nenhum pageToken será retornado.

Se nenhum campo maxResults for especificado, o padrão de 1.000 usuários por lote será usado. Este também é o número máximo de usuários que podem ser listados por vez. Qualquer valor maior que o máximo gerará um erro de argumento. Se nenhum pageToken for especificado, a operação listará os usuários desde o início, ordenados por uid .

Para obter uma lista completa de códigos de erro, incluindo descrições e etapas de resolução, consulte Erros da API de autenticação de administrador .

Hashes de senha dos usuários listados

Essa API também retorna o hash passwordSalt e passwordHash pelo back-end do Firebase Auth para usuários de senha se a conta de usuário/serviço usada para gerar o token de acesso OAuth da solicitação tiver a permissão firebaseauth.configs.getHashConfig . Caso contrário, passwordHash e passwordSalt não serão definidos.

Devido à natureza confidencial dos hashes de senha, a conta de serviço do SDK Admin do Firebase não tem a permissão firebaseauth.configs.getHashConfig por padrão. Você não pode adicionar uma permissão diretamente a uma conta de usuário/serviço, mas pode fazer isso indiretamente criando uma função IAM personalizada .

Para criar a função personalizada do IAM:

1. Acesse a página Funções no IAM e painel de administração no console do Google Cloud.
2. Selecione seu projeto no menu suspenso na parte superior da página.
3. Clique em CRIAR PAPEL
4. Clique em ADICIONAR PERMISSÕES
5. Pesquise a permissão firebaseauth.configs.getHashConfig e marque essa caixa de seleção.
6. Clique em ADICIONAR
7. Clique em CRIAR para finalizar a criação da nova função.

Adicione a função personalizada criada à conta de usuário/serviço na página do IAM:

1. No painel IAM e administração , selecione IAM
2. Selecione o serviço ou conta de usuário na lista de membros para edição.
3. Clique em ADICIONAR OUTRA FUNÇÃO .
4. Procure a nova função personalizada criada anteriormente.
5. Clique em SALVAR .

Aviso: não use a função Editor como meio de adicionar a permissão firebaseauth.configs.getHashConfig . Essa função poderosa concede permissões além do escopo pretendido.