Instalar el SDK de Admin

En este documento, se muestra cómo instalar el SDK de Admin de Identity Platform. El SDK de Admin te permite administrar Identity Platform desde un entorno del servidor y realizar acciones de administrador, como migrar usuarios, configurar reclamaciones personalizadas y configurar proveedores de identidad.

Antes de comenzar

Para usar el SDK de Admin, necesitas una aplicación del servidor que ejecute uno de los siguientes:

Lenguaje Versión mínima del framework
Node.js Node.js 8.13.0+
Java Java 7+r (se recomienda Java 8 o superior)
Python Python 2.7+ o 3.4+ (se recomienda 3.4+)
Go Go 1.9+
C# .NET Framework 4.5+ o .NET Core 1.5+

En la siguiente tabla, se enumeran las características que admite cada lenguaje de SDK:

Atributo Node.js Java Python Go C#
Creación de tokens personalizados
Verificación de token de ID
Administración de usuarios
Cómo controlar el acceso con reclamaciones personalizadas
Revocación de tokens de actualización
Cómo importar usuarios
Administración de cookies de sesión
Generación de vínculos de acciones de correo electrónico
Administra configuraciones del proveedor SAML/OIDC
Compatibilidad con los multiusuarios
Realtime Database *
Firebase Cloud Messaging
Multidifusión de FCM
Administra las suscripciones a temas de FCM
Cloud Storage
Firestore
Administración de proyectos
Reglas de seguridad
Administración de modelos de AA
Firebase Remote Config
Verificación de aplicaciones de Firebase
Extensiones de Firebase

Además, necesitarás una cuenta de servicio y una clave para tu proyecto:

Consola

Crear una cuenta de servicio:

  1. En la consola de Google Cloud, ve a la página Crear cuenta de servicio.

    Ve a Crear cuenta de servicio
  2. Selecciona tu proyecto.

  3. Ingresa un nombre en el campo Nombre de cuenta de servicio. La consola de Google Cloud completa el campo ID de cuenta de servicio en función de este nombre.

    Opcional: en el campo Descripción de la cuenta de servicio, ingresa una descripción. Por ejemplo, Service account for quickstart.

  4. Haz clic en Crear y continuar.

  5. Para proporcionar acceso a tu proyecto, otorga el rol Other > Identity Toolkit Admin a tu cuenta de servicio.

    Para otorgar el rol, busca la lista Seleccionar un rol y, luego, selecciona Other > Identity Toolkit Admin.

  6. Haga clic en Continuar.

  7. Haz clic en Listo para terminar de crear la cuenta de servicio.

    No cierres la ventana del navegador. La usarás en la próxima tarea.

Haz lo siguiente para crear una clave de cuenta de servicio:

  1. En la consola de Google Cloud, haz clic en la dirección de correo electrónico de la cuenta de servicio que creaste.
  2. Haga clic en Claves.
  3. Haz clic en Agregar clave y, luego, en Crear clave nueva.
  4. Haga clic en Crear. Se descargará un archivo de claves JSON en tu computadora.
  5. Haga clic en Cerrar.

gcloud

Configura la autenticación:

  1. Crea la cuenta de servicio: 

    gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

    Reemplaza SERVICE_ACCOUNT_NAME por un nombre para la cuenta de servicio.

  2. Otorga el rol de IAM Project > Admin a la cuenta de servicio.

    gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com" --role=Project > Admin

    Reemplaza lo siguiente:

    • SERVICE_ACCOUNT_NAME: el nombre de la cuenta de servicio
    • PROJECT_ID: el ID del proyecto en el que creaste la cuenta de servicio

  3. Genera el archivo de claves: 

    gcloud iam service-accounts keys create FILE_NAME.json --iam-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

    Reemplaza lo siguiente:

    • FILE_NAME: un nombre para el archivo de claves
    • SERVICE_ACCOUNT_NAME: el nombre de la cuenta de servicio
    • PROJECT_ID: el ID del proyecto en el que creaste la cuenta de servicio

Configura la variable de entorno GOOGLE_APPLICATION_CREDENTIALS para proporcionar credenciales de autenticación al código de la aplicación. Esta variable se aplica solo a tu sesión de shell actual. Si quieres que la variable se aplique a sesiones de shell futuras, configura la variable en tu archivo de inicio de shell, por ejemplo, en el archivo ~/.bashrc o ~/.profile.

Linux o macOS

export GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH"

Reemplaza KEY_PATH por la ruta de acceso del archivo JSON que contiene la clave de tu cuenta de servicio.

Por ejemplo:

export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"

Windows

Para PowerShell:

$env:GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH"

Reemplaza KEY_PATH por la ruta de acceso del archivo JSON que contiene la clave de tu cuenta de servicio.

Por ejemplo:

$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\service-account-file.json"

Para el símbolo del sistema:

set GOOGLE_APPLICATION_CREDENTIALS=KEY_PATH

Reemplaza KEY_PATH por la ruta de acceso del archivo JSON que contiene la clave de tu cuenta de servicio.

Instalar el SDK

Node.js

El SDK de Admin de Node.js está disponible en npm. Si aún no tienes un archivo package.json, crea uno mediante npm init. A continuación, instala el paquete de npm y guárdalo en tu package.json:

npm install firebase-admin --save

Para usar el módulo en tu app, usa require desde cualquier archivo de JavaScript:

var admin = require('firebase-admin');

Si usas ES2015, también puedes import el módulo en su lugar:

import * as admin from 'firebase-admin';

Java

El SDK de Admin de Java se publica en el repositorio central de Maven. Para instalar la biblioteca, debes declararla como una dependencia en el archivo build.gradle:

dependencies {
  implementation 'com.google.firebase:firebase-admin:6.11.0'
}

Si usas Maven para compilar tu app, puedes agregar la siguiente dependencia a pom.xml:

<dependency>
  <groupId>com.google.firebase</groupId>
  <artifactId>firebase-admin</artifactId>
  <version>6.11.0</version>
</dependency>

Python

El SDK de Admin de Python está disponible mediante pip.

pip install --user firebase-admin

Go

Usa la utilidad go get para instalar el SDK de Admin de Go:

go get firebase.google.com/go

C#

Instala el SDK de Admin de .NET mediante el administrador de paquetes de .NET:

Install-Package FirebaseAdmin -Version 1.9.1

De manera alternativa, instálalo mediante la utilidad de línea de comandos de dotnet:

dotnet add package FirebaseAdmin --version 1.9.1

O bien, puedes hacerlo si agregas la siguiente entrada de referencia de paquete en el archivo .csproj:

<ItemGroup>
  <PackageReference Include="FirebaseAdmin" Version="1.9.1" />
</ItemGroup>

Inicializa el SDK mediante credenciales predeterminadas

Agrega el siguiente código a tu app de servidor para inicializar el SDK de Admin mediante las credenciales predeterminadas:

Node.js

// Initialize the default app
var admin = require('firebase-admin');
var app = admin.initializeApp({
  credential: admin.credential.applicationDefault()
});

Java

FirebaseApp.initializeApp();
FirebaseAppSnippets.java

Python

default_app = firebase_admin.initialize_app()
index.py

Go

app, err := firebase.NewApp(context.Background(), nil)
if err != nil {
	log.Fatalf("error initializing app: %v\n", err)
}
init.go

C#

FirebaseApp.Create();

FirebaseAppSnippets.cs

Inicializa el SDK con un archivo de claves de la cuenta de servicio

También puedes especificar un archivo de claves de una cuenta de servicio de forma manual:

Node.js

// Initialize the default app
var admin = require('firebase-admin');
var app = admin.initializeApp({
  credential: admin.credential.cert('/path/to/serviceAccountKey.json')
});

Java

FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccountKey.json");

FirebaseOptions options = FirebaseOptions.builder()
    .setCredentials(GoogleCredentials.fromStream(serviceAccount))
    .setDatabaseUrl("https://<DATABASE_NAME>.firebaseio.com/")
    .build();

FirebaseApp.initializeApp(options);
FirebaseAppSnippets.java

Python

import firebase_admin
from firebase_admin import credentials
from firebase_admin import exceptions

cred = credentials.Certificate('path/to/serviceAccountKey.json')
default_app = firebase_admin.initialize_app(cred)
index.py

Go

opt := option.WithCredentialsFile("path/to/serviceAccountKey.json")
app, err := firebase.NewApp(context.Background(), nil, opt)
if err != nil {
	log.Fatalf("error initializing app: %v\n", err)
}
init.go

C#

FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.FromFile("path/to/serviceAccountKey.json"),
});

FirebaseAppSnippets.cs

Inicializa varias aplicaciones

Por lo general, solo querrás inicializar una única app predeterminada. Sin embargo, también puedes crear varias instancias de aplicación, cada una con sus propias opciones de configuración y su propio estado de autenticación.

Node.js

// Initialize the default app
admin.initializeApp(defaultAppConfig);

// Initialize another app with a different config
var otherApp = admin.initializeApp(otherAppConfig, 'other');

console.log(admin.app().name);  // '[DEFAULT]'
console.log(otherApp.name);     // 'other'

// Use the shorthand notation to retrieve the default app's services
var defaultAuth = admin.auth();

Java

// Initialize the default app
FirebaseApp defaultApp = FirebaseApp.initializeApp(defaultOptions);

// Initialize another app with a different config
FirebaseApp otherApp = FirebaseApp.initializeApp(otherAppConfig, "other");

System.out.println(defaultApp.getName());  // "[DEFAULT]"
System.out.println(otherApp.getName());    // "other"

// Use the shorthand notation to retrieve the default app's services
FirebaseAuth defaultAuth = FirebaseAuth.getInstance();
FirebaseDatabase defaultDatabase = FirebaseDatabase.getInstance();

// Use the otherApp variable to retrieve the other app's services
FirebaseAuth otherAuth = FirebaseAuth.getInstance(otherApp);
FirebaseDatabase otherDatabase = FirebaseDatabase.getInstance(otherApp);
FirebaseAppSnippets.java

Python

# Initialize the default app
default_app = firebase_admin.initialize_app(cred)

#  Initialize another app with a different config
other_app = firebase_admin.initialize_app(cred, name='other')

print(default_app.name)    # "[DEFAULT]"
print(other_app.name)      # "other"

# Retrieve default services via the auth package...
# auth.create_custom_token(...)

# Use the `app` argument to retrieve the other app's services
# auth.create_custom_token(..., app=other_app)
index.py

Go

// Initialize the default app
defaultApp, err := firebase.NewApp(context.Background(), nil)
if err != nil {
	log.Fatalf("error initializing app: %v\n", err)
}

// Initialize another app with a different config
opt := option.WithCredentialsFile("service-account-other.json")
otherApp, err := firebase.NewApp(context.Background(), nil, opt)
if err != nil {
	log.Fatalf("error initializing app: %v\n", err)
}

// Access Auth service from default app
defaultClient, err := defaultApp.Auth(context.Background())
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}

// Access auth service from other app
otherClient, err := otherApp.Auth(context.Background())
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}
init.go

C#

// Initialize the default app
var defaultApp = FirebaseApp.Create(defaultOptions);

// Initialize another app with a different config
var otherApp = FirebaseApp.Create(otherAppConfig, "other");

Console.WriteLine(defaultApp.Name); // "[DEFAULT]"
Console.WriteLine(otherApp.Name); // "other"

// Use the shorthand notation to retrieve the default app's services
var defaultAuth = FirebaseAuth.DefaultInstance;

// Use the otherApp variable to retrieve the other app's services
var otherAuth = FirebaseAuth.GetAuth(otherApp);

FirebaseAppSnippets.cs

Configura los permisos

Si usas una VM de Compute Engine con las credenciales predeterminadas de la aplicación de Google para la autenticación, deberás establecer los permisos de acceso adecuados. Identity Platform requiere los permisos de acceso userinfo.email y cloud-platform.

Para verificar los permisos de acceso existentes, ejecuta el siguiente comando:

gcloud compute instances describe [INSTANCE-NAME] --format json

El comando mostrará información sobre la cuenta de servicio. Por ejemplo:

"serviceAccounts": [
 {
  "email": "example.gserviceaccount.com",
  "scopes": [
   "https://www.googleapis.com/auth/cloud-platform",
   "https://www.googleapis.com/auth/userinfo.email"
   ]
  }
]

Para actualizar los permisos de acceso, detén la VM y, luego, ejecuta el siguiente comando:


gcloud compute instances set-service-account [INSTANCE-NAME] \
  --service-account "your.gserviceaccount.com" \
  --scopes ""https://www.googleapis.com/auth/cloud-platform,https://www.googleapis.com/auth/userinfo.email"

¿Qué sigue?