Como gerenciar usuários de forma programática
Neste documento, mostramos como usar o SDK Admin do Identity Platform para gerenciar usuários de maneira programática. O SDK Admin permite que você execute uma ampla variedade de tarefas administrativas comuns, como criar, pesquisar e modificar usuários.
Antes de começar
Como receber um usuário
Como conseguir um usuário por ID
A principal maneira de identificar um usuário é por 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); });
Java
UserRecord userRecord = FirebaseAuth.getInstance().getUser(uid); // See the UserRecord reference doc for the contents of userRecord. System.out.println("Successfully fetched user data: " + userRecord.getUid());
Python
from firebase_admin import auth user = auth.get_user(uid) print('Successfully fetched user data: {0}'.format(user.uid))
Go
// Get an auth client from the firebase.App client, err := app.Auth(ctx) if err != nil { log.Fatalf("error getting Auth client: %v\n", err) } u, err := client.GetUser(ctx, uid) if err != nil { log.Fatalf("error getting user %s: %v\n", uid, err) } log.Printf("Successfully fetched user data: %v\n", u)
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}");
Como conseguir usuários por e-mail
Você também pode colocar um usuário no e-mail dele:
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); });
Java
UserRecord userRecord = FirebaseAuth.getInstance().getUserByEmail(email); // See the UserRecord reference doc for the contents of userRecord. System.out.println("Successfully fetched user data: " + userRecord.getEmail());
Python
from firebase_admin import auth user = auth.get_user_by_email(email) print('Successfully fetched user data: {0}'.format(user.uid))
Go
u, err := client.GetUserByEmail(ctx, email) if err != nil { log.Fatalf("error getting user by email %s: %v\n", email, err) } log.Printf("Successfully fetched user data: %v\n", u)
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}");
É possível fazer pesquisas somente usando e-mails principais, não e-mails específicos de
provedores. Por exemplo, se uma conta do Facebook com o e-mail
facebookUser@example.com
estiver vinculada a um usuário com o
endereço user@example.com
, chamar getUserByEmail("facebookUser@example.com")
não terá resultados. Chamar getUserByEmail("user@example.com")
retornará
o usuário esperado.
O e-mail principal depende das configurações de vinculação da conta:
- Vincular contas que usam o mesmo e-mail: o e-mail principal é o primeiro usado para fazer login, a menos que seja atualizado manualmente.
- Criar várias contas para cada provedor de identidade: o e-mail principal só é definido quando um usuário de senha é criado, a menos que seja atualizado manualmente.
Como receber um usuário por número de telefone
Se um usuário tiver um número de telefone, você poderá procurá-lo:
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); });
Java
UserRecord userRecord = FirebaseAuth.getInstance().getUserByPhoneNumber(phoneNumber); // See the UserRecord reference doc for the contents of userRecord. System.out.println("Successfully fetched user data: " + userRecord.getPhoneNumber());
Python
from firebase_admin import auth user = auth.get_user_by_phone_number(phone) print('Successfully fetched user data: {0}'.format(user.uid))
Go
u, err := client.GetUserByPhoneNumber(ctx, phone) if err != nil { log.Fatalf("error getting user by phone %s: %v\n", phone, err) } log.Printf("Successfully fetched user data: %v\n", u)
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}");
Recuperar dados do usuário em massa
Também é possível recuperar uma lista de usuários com base nos identificadores fornecidos. Você pode identificar usuários pelo uid, e-mail ou número de telefone. Um máximo de 100 identificadores pode ser fornecido em uma única chamada. Os identificadores podem apresentar uma mistura de tipos:
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); });
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)
Go
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}"); }
Esse método retorna uma lista do mesmo tamanho que a lista de entrada, cada uma
contendo o UserRecord
correspondente ou um erro indicando o motivo para
esse identificador não ter sido pesquisado.
Listar usuários
O código abaixo mostra como listar todos os usuários:
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();
Java
// Start listing users from the beginning, 1000 at a time. ListUsersPage page = FirebaseAuth.getInstance().listUsers(null); while (page != null) { for (ExportedUserRecord user : page.getValues()) { System.out.println("User: " + user.getUid()); } page = page.getNextPage(); } // Iterate through all users. This will still retrieve users in batches, // buffering no more than 1000 users in memory at a time. page = FirebaseAuth.getInstance().listUsers(null); for (ExportedUserRecord user : page.iterateAll()) { System.out.println("User: " + user.getUid()); }
Python
# Start listing users from the beginning, 1000 at a time. page = auth.list_users() while page: for user in page.users: print('User: ' + user.uid) # Get next batch of users. page = page.get_next_page() # Iterate through all users. This will still retrieve users in batches, # buffering no more than 1000 users in memory at a time. for user in auth.list_users().iterate_all(): print('User: ' + user.uid)
Go
// Note, behind the scenes, the Users() iterator will retrive 1000 Users at a time through the API iter := client.Users(ctx, "") for { user, err := iter.Next() if err == iterator.Done { break } if err != nil { log.Fatalf("error listing users: %s\n", err) } log.Printf("read user user: %v\n", user) } // Iterating by pages 100 users at a time. // Note that using both the Next() function on an iterator and the NextPage() // on a Pager wrapping that same iterator will result in an error. pager := iterator.NewPager(client.Users(ctx, ""), 100, "") for { var users []*auth.ExportedUserRecord nextPageToken, err := pager.NextPage(&users) if err != nil { log.Fatalf("paging error %v\n", err) } for _, u := range users { log.Printf("read user user: %v\n", u) } if nextPageToken == "" { break } }
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}"); }
Os usuários são retornados em lotes, ordenados pelo uid
. Cada lote de resultados
contém uma lista de usuários e um token de próxima página usado para buscar o próximo lote.
Quando todos os usuários tiverem sido listados, nenhum pageToken
será retornado.
O campo maxResult
especifica o tamanho máximo do lote. O valor padrão e
valor máximo é 1.000.
Como listar hashes de senha de usuários
Como os hashes de senha são confidenciais, o SDK Admin não os retorna,
a menos que o usuário tenha a permissão
firebaseauth.configs.getHashConfig
. Essa permissão não é concedida por papéis predefinidos. Para concedê-la:
Crie um papel personalizado que conceda a permissão
firebaseauth.configs.getHashConfig
.Conceda o papel personalizado ao usuário ou conta de serviço.
As chamadas subsequentes para listUsers()
pelos usuários com esse papel personalizado incluirão
os campos passwordHash
e passwordSalt
.
Criar um usuário
A criação de novos usuários de maneira programática evita algumas restrições colocadas em usuários finais. Você não está sujeito a limitação ou taxa limitada de taxas e pode ignorar o processo de verificação normal para e-mails e números de telefone.
Para criar um novo usuário:
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); });
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))
Go
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}");
Você pode definir qualquer uma das propriedades abaixo em um novo usuário. Todas as propriedades são opcionais.
Property | Tipo | Descrição |
---|---|---|
uid |
string |
O uid que será atribuído ao usuário recém-criado. Precisa ser uma
string entre 1 e 128 caracteres. Caso não seja fornecido, um uid
aleatório será gerado automaticamente.
|
email |
string | O e-mail principal do usuário. Deve ser um endereço de e-mail válido. |
emailVerified |
booleano |
Indica se o e-mail principal do usuário foi verificado ou não. Caso nenhum valor seja fornecido, o
padrão será false .
|
phoneNumber |
string | O número de telefone principal do usuário. Precisa ser um número de telefone compatível com a especificação E.164. |
password |
string | A senha bruta e sem hash do usuário. Deve ter pelo menos seis caracteres. |
displayName |
string | O nome de exibição do usuário. |
photoURL |
string | O URL da foto do usuário. |
disabled |
booleano |
Indica se o usuário está desativado ou não. true para desativado e
false para ativado. Caso nenhum valor seja fornecido, o padrão será
false .
|
Como atualizar um usuário
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); });
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))
Go
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}");
Você pode atualizar qualquer uma das propriedades do usuário abaixo. Todas as propriedades são opcionais. Se uma propriedade não for especificada, seu valor permanecerá inalterado.
Property | Tipo | Descrição |
---|---|---|
email |
string | O novo e-mail principal do usuário. Deve ser um endereço de e-mail válido. |
emailVerified |
booleano |
Indica se o e-mail principal do usuário foi verificado ou não. Caso nenhum valor seja fornecido, o
padrão será false .
|
phoneNumber |
string |
O novo número de telefone principal do usuário. Precisa ser um número de telefone compatível
com a especificação E.164. Defina como null para limpar o número de telefone
atual do usuário.
|
password |
string | A senha bruta e sem hash do usuário. Deve ter pelo menos seis caracteres. |
displayName |
string | null |
O novo nome de exibição do usuário. Defina como null para limpar o nome de
exibição atual do usuário.
|
photoURL |
string | null |
O novo URL da foto do usuário. Defina como null para limpar o URL da foto atual
do usuário. Se não for configurado como null , precisará ser um URL válido.
|
disabled |
booleano |
Indica se o usuário está desativado ou não. true para desativado e
false para ativado.
|
Como excluir um usuário
É possível excluir um usuário com o uid
:
Node.js
getAuth() .deleteUser(uid) .then(() => { console.log('Successfully deleted user'); }) .catch((error) => { console.log('Error deleting user:', error); });
Java
FirebaseAuth.getInstance().deleteUser(uid); System.out.println("Successfully deleted user.");
Python
auth.delete_user(uid) print('Successfully deleted user')
Go
err := client.DeleteUser(ctx, uid) if err != nil { log.Fatalf("error deleting user: %v\n", err) } log.Printf("Successfully deleted user: %s\n", uid)
C#
await FirebaseAuth.DefaultInstance.DeleteUserAsync(uid); Console.WriteLine("Successfully deleted user.");
Excluir vários usuários
Também é possível excluir vários usuários de uma só vez:
Node.js
getAuth() .deleteUsers([uid1, uid2, uid3]) .then((deleteUsersResult) => { console.log(`Successfully deleted ${deleteUsersResult.successCount} users`); console.log(`Failed to delete ${deleteUsersResult.failureCount} users`); deleteUsersResult.errors.forEach((err) => { console.log(err.error.toJSON()); }); }) .catch((error) => { console.log('Error deleting users:', error); });
Java
DeleteUsersResult result = FirebaseAuth.getInstance().deleteUsersAsync( Arrays.asList("uid1", "uid2", "uid3")).get(); System.out.println("Successfully deleted " + result.getSuccessCount() + " users"); System.out.println("Failed to delete " + result.getFailureCount() + " users"); for (ErrorInfo error : result.getErrors()) { System.out.println("error #" + error.getIndex() + ", reason: " + error.getReason()); }
Python
from firebase_admin import auth result = auth.delete_users(["uid1", "uid2", "uid3"]) print('Successfully deleted {0} users'.format(result.success_count)) print('Failed to delete {0} users'.format(result.failure_count)) for err in result.errors: print('error #{0}, reason: {1}'.format(result.index, result.reason))
Go
deleteUsersResult, err := client.DeleteUsers(ctx, []string{"uid1", "uid2", "uid3"}) if err != nil { log.Fatalf("error deleting users: %v\n", err) } log.Printf("Successfully deleted %d users", deleteUsersResult.SuccessCount) log.Printf("Failed to delete %d users", deleteUsersResult.FailureCount) for _, err := range deleteUsersResult.Errors { log.Printf("%v", err) }
C#
DeleteUsersResult result = await FirebaseAuth.DefaultInstance.DeleteUsersAsync(new List<string> { "uid1", "uid2", "uid3", }); Console.WriteLine($"Successfully deleted {result.SuccessCount} users."); Console.WriteLine($"Failed to delete {result.FailureCount} users."); foreach (ErrorInfo err in result.Errors) { Console.WriteLine($"Error #{err.Index}, reason: {err.Reason}"); }
O método de exclusão de usuários retorna uma lista de falhas para os usuários que não puderam ser excluídos.
A seguir
- Migrar usuários de um app atual para o Identity Platform
- Gerenciar provedores SAML e OIDC de maneira programática