Ir a la consola

Agrega el SDK de Firebase Admin a tu servidor

El SDK de Admin te permite interactuar con Firebase desde entornos privilegiados para ejecutar acciones como las siguientes:

  • Lee y escribe datos de Realtime Database con todos los privilegios de administrador.
  • Envía mensajes de Firebase Cloud Messaging de manera programática con un enfoque simple y alternativo a los protocolos de servidor de FCM.
  • Genera y verifica tokens de autenticación de Firebase.
  • Accede a recursos de Google Cloud Platform como depósitos de Cloud Storage y bases de datos de Firestore asociadas con tus proyectos de Firebase.
  • Crea tu propia consola del administrador simplificada para ejecutar tareas como buscar datos del usuario o cambiar la dirección de correo electrónico de un usuario para la autenticación.

Si deseas usar el SDK de Node.js como cliente para el acceso de los usuarios finales (por ejemplo, en un escritorio de Node.js o una aplicación de IoT) y no para el acceso de administrador desde un entorno con privilegios (como un servidor), sigue las instrucciones para configurar el SDK de cliente de JavaScript

A continuación, se muestra una matriz de funciones de Firebase que indica cuáles son compatibles con cada lenguaje:

Función Node.js Java Python Go C#
Creación de tokens personalizados
Verificación de token de ID
Administración de usuarios
Controla el acceso con reclamaciones personalizadas
Revocación de token de actualización
Importar usuarios
Administración de cookies de sesión
Genera vínculos de acciones de correo electrónico
Administra configuraciones del proveedor SAML/OIDC
Realtime Database *
Firebase Cloud Messaging
FCM Multicast
Administra suscripciones a temas de FCM
Cloud Storage
Cloud Firestore
Administración de proyectos

A fin de obtener más información sobre la integración del SDK de Admin para estos usos, consulta la documentación correspondiente de Realtime Database, FCM, Authentication y Cloud Storage. El resto de esta página se enfoca en la configuración básica del SDK de Admin.

Requisitos previos

Antes de comenzar, asegúrate de tener lo siguiente:

  • Si usas el SDK de Admin de Node.js, un servidor que ejecute Node.js 6+ (la compatibilidad con Node 6 actualmente está obsoleta, y se recomienda a los desarrolladores usar Node 8+).
  • Si usas el SDK de Admin de Java, un servidor que ejecute Java 7+ (la compatibilidad con Java 7 actualmente está obsoleta, y se recomienda a los desarrolladores usar Java 8+).
  • Si usas el SDK de Admin de Python, un servidor que ejecute Python 2.7 o 3.4+ (la compatibilidad con Python 2 actualmente está obsoleta, y se recomienda a los desarrolladores usar Python 3.4+).
  • Si usas el SDK de Admin de Go, un servidor que ejecute Go 1.9+.
  • Si usas el SDK de Admin de .NET, un servidor con .NET Framework 4.5 o una versión superior o uno .NET Core 1.5 o una versión superior.
  • Una app de servidor.

Agrega Firebase a la app

Para usar los SDK de Firebase Admin, necesitarás un proyecto de Firebase, una cuenta de servicio para comunicarte con el servicio de Firebase y un archivo de configuración con las credenciales de tu cuenta de servicio. Si aún no tienes un proyecto de Firebase, agrega uno en Firebase console. El diálogo Agregar proyecto también te permite agregar Firebase a un proyecto existente de Google Cloud Platform.

Agrega el SDK

Si estás configurando un nuevo proyecto, deberás instalar el SDK correspondiente al idioma de tu preferencia.

Node.js

El SDK de administrador Node.js de Firebase está disponible en npm. Si todavía no tienes un archivo package.json, crea uno mediante npm init. A continuación, instala el paquete npm firebase-admin y guárdalo en el package.json:

$ npm install firebase-admin --save

Para usar el módulo en tu aplicación, usa la función require en cualquier archivo JavaScript:

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

Si estás usando ES2015, también puedes usar la función import para importar el módulo:

import * as admin from 'firebase-admin';

Java

El SDK de administrador Java de Firebase se publica en el repositorio central de Maven. A fin de instalar la biblioteca, debes declararla como dependencia en el archivo build.gradle:

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

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

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

Python

El SDK de Firebase Admin para Python está disponible mediante pip. Puedes instalar la biblioteca para todos los usuarios a través de sudo:

$ sudo pip install firebase-admin

O bien, si deseas instalar la biblioteca solo para el usuario actual, pasa la marca --user:

$ pip install --user firebase-admin

Ir

El SDK de Admin de Go se puede instalar con la función go get:

$ go get firebase.google.com/go

C#

El SDK de Admin de .NET se puede instalar con el administrador de paquetes de .NET:

$ Install-Package FirebaseAdmin -Version 1.4.0

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

$ dotnet add package FirebaseAdmin --version 1.4.0

O bien, puedes hacerlo con solo agregar la siguiente entrada de referencia de paquete a tu archivo .csproj:

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

Inicializa el SDK

Una vez que hayas creado un proyecto de Firebase, puedes inicializar el SDK con una estrategia de autorización que combine el archivo de tu cuenta de servicio junto con la credencial predeterminada de la aplicación de Google.

Los proyectos de Firebase son compatibles con las cuentas de servicio de Google, por lo que puedes llamar a las API del servidor de Firebase desde tu servidor de apps o un entorno de confianza. Si desarrollas código o implementas tu aplicación de manera local, puedes usar las credenciales obtenidas mediante la cuenta de servicio para autorizar las solicitudes del servidor.

Para autenticar una cuenta de servicio y autorizar su acceso a los servicios de Firebase, debes generar un archivo de claves privadas en formato JSON.

Sigue estos pasos a fin de generar un archivo de claves privadas para tu cuenta de servicio:

  1. En Firebase console, abre Configuración > Cuentas de servicio.

  2. Haz clic en Generar nueva clave privada y, luego, en Generar clave para confirmar.

  3. Almacena de forma segura el archivo JSON que contiene la clave.

Cuando autorices mediante una cuenta de servicio, tienes dos opciones para proporcionar las credenciales a tu aplicación. Puedes configurar la variable de entorno GOOGLE_APPLICATION_CREDENTIALS o pasar la ruta a la clave de la cuenta de servicio en el código de forma explícita. Recomendamos enfáticamente que uses la primera opción, ya que es más segura.

Para configurar la variable de entorno, haz lo siguiente:

Configura la variable de entorno GOOGLE_APPLICATION_CREDENTIALS con la ruta del archivo JSON que contiene la clave de tu cuenta de servicio. Esta variable solo se aplica a la sesión actual de Cloud Shell. Por lo tanto, si abres una sesión nueva, deberás volver a configurar la variable.

Linux o macOS

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

Windows

Con PowerShell:

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

Cuando completes los pasos anteriores, el servicio de credenciales predeterminadas de aplicación (ADC) puede determinar de forma implícita tus credenciales, lo que te permite usar credenciales de cuentas de servicio cuando realizas pruebas o ejecutas aplicaciones en entornos de terceros.

Inicializa el SDK, como se muestra a continuación:

Node.js

admin.initializeApp({
  credential: admin.credential.applicationDefault(),
  databaseURL: 'https://<DATABASE_NAME>.firebaseio.com'
});

Java

FirebaseOptions options = new FirebaseOptions.Builder()
    .setCredentials(GoogleCredentials.getApplicationDefault())
    .setDatabaseUrl("https://<DATABASE_NAME>.firebaseio.com/")
    .build();

FirebaseApp.initializeApp(options);

Python

default_app = firebase_admin.initialize_app()

Go

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

C#

FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.GetApplicationDefault(),
});

Utiliza un token de actualización de OAuth 2.0

Los SDK de Admin también proporcionan una credencial que te permite autenticar con un token de actualización de Google OAuth2:

Node.js

var refreshToken; // Get refresh token from OAuth2 flow

admin.initializeApp({
  credential: admin.credential.refreshToken(refreshToken),
  databaseURL: 'https://<DATABASE_NAME>.firebaseio.com'
});

Java

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

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

FirebaseApp.initializeApp(options);

Python

cred = credentials.RefreshToken('path/to/refreshToken.json')
default_app = firebase_admin.initialize_app(cred)

Go

opt := option.WithCredentialsFile("path/to/refreshToken.json")
config := &firebase.Config{ProjectID: "my-project-id"}
app, err := firebase.NewApp(context.Background(), config, opt)
if err != nil {
	log.Fatalf("error initializing app: %v\n", err)
}

C#

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

Inicializa sin parámetros

El SDK también se puede inicializar sin parámetros. En este caso, el SDK utiliza la credencial predeterminada de la aplicación de Google y lee las opciones de la variable del entorno FIREBASE_CONFIG. Si el contenido de la variable FIREBASE_CONFIG comienza con un {, se analizará como un objeto JSON. De lo contrario, el SDK supone que el string es el nombre de un archivo JSON que contiene las opciones.

Node.js

// Initialize the default app
var admin = require('firebase-admin');
var app = admin.initializeApp();

Java

FirebaseApp.initializeApp();

Python

default_app = firebase_admin.initialize_app()

Go

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

C#

FirebaseApp.Create();

Una vez que se inicializa el SDK, puedes utilizar los SDK de Firebase Admin para ejecutar las siguientes tareas:

Inicializa varias apps

En la mayoría de los casos, solo debes inicializar una sola app predeterminada. Puedes acceder a los servicios mediante esa app de dos maneras que son equivalentes:

Node.js

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

console.log(defaultApp.name);  // '[DEFAULT]'

// Retrieve services via the defaultApp variable...
var defaultAuth = defaultApp.auth();
var defaultDatabase = defaultApp.database();

// ... or use the equivalent shorthand notation
defaultAuth = admin.auth();
defaultDatabase = admin.database();

Java

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

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

// Retrieve services by passing the defaultApp variable...
FirebaseAuth defaultAuth = FirebaseAuth.getInstance(defaultApp);
FirebaseDatabase defaultDatabase = FirebaseDatabase.getInstance(defaultApp);

// ... or use the equivalent shorthand notation
defaultAuth = FirebaseAuth.getInstance();
defaultDatabase = FirebaseDatabase.getInstance();

Python

# Import the Firebase service
from firebase_admin import auth

# Initialize the default app
default_app = firebase_admin.initialize_app(cred)
print(default_app.name)  # "[DEFAULT]"

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

Go

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

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

C#

// Initialize the default app
var defaultApp = FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.GetApplicationDefault(),
});
Console.WriteLine(defaultApp.Name); // "[DEFAULT]"

// Retrieve services by passing the defaultApp variable...
var defaultAuth = FirebaseAuth.GetAuth(defaultApp);

// ... or use the equivalent shorthand notation
defaultAuth = FirebaseAuth.DefaultInstance;

En algunos casos prácticos, tendrás que crear varias apps al mismo tiempo. Por ejemplo, tal vez necesites leer datos de la Realtime Database de un proyecto de Firebase y generar tokens personalizados para otro proyecto. O tal vez necesites autenticar dos apps con credenciales distintas. El SDK de Firebase te permite crear varias apps al mismo tiempo, cada una de las cuales tendrá su propia información de configuració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();
var defaultDatabase = admin.database();

// Use the otherApp variable to retrieve the other app's services
var otherAuth = otherApp.auth();
var otherDatabase = otherApp.database();

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

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)

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

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

Configura los alcances de Realtime Database y Authentication

Si usas una VM de Google Compute Engine con las credenciales predeterminadas de la aplicación de Google para Realtime Database o Authentication, asegúrate de configurar también los alcances de acceso correctos. Para Realtime Database y Authentication, necesitas alcances que terminen en userinfo.email y ya sea cloud-platform o firebase.database. Para verificar los alcances de acceso existentes y cambiarlos, ejecuta los siguientes comandos con gcloud.

gcloud

# Check the existing access scopes
gcloud compute instances describe [INSTANCE_NAME] --format json

# The above command returns the service account information. For example:
  "serviceAccounts": [
   {
    "email": "your.gserviceaccount.com",
    "scopes": [
     "https://www.googleapis.com/auth/cloud-platform",
     "https://www.googleapis.com/auth/userinfo.email"
     ]
    }
  ],

# Stop the VM, then run the following command, using the service account
# that gcloud returned when you checked the scopes.

gcloud compute instances set-service-account [INSTANCE_NAME] --service-account "your.gserviceaccount.com" --scopes "https://www.googleapis.com/auth/firebase.database,https://www.googleapis.com/auth/userinfo.email"

Próximos pasos

Obtén información acerca de Firebase:

Agrega funciones de Firebase a tu app: