Agregue el SDK de administración de Firebase a su servidor

El SDK de administración es un conjunto de bibliotecas de servidor que le permite interactuar con Firebase desde entornos privilegiados para realizar acciones como:

  • Lea y escriba datos de bases de datos en tiempo real con privilegios completos de administrador.
  • Envíe mediante programación mensajes de Firebase Cloud Messaging utilizando un enfoque simple y alternativo a los protocolos del servidor de Firebase Cloud Messaging.
  • Genere y verifique tokens de autenticación de Firebase.
  • Acceda a recursos de Google Cloud, como depósitos de Cloud Storage y bases de datos de Cloud Firestore asociadas con sus proyectos de Firebase.
  • Cree su propia consola de administración simplificada para hacer cosas como buscar datos de usuario o cambiar la dirección de correo electrónico de un usuario para autenticación.

Si está interesado en utilizar el SDK de Node.js como cliente para el acceso del usuario final (por ejemplo, en una aplicación de IoT o de escritorio de Node.js), en lugar del acceso de administrador desde un entorno privilegiado (como un servidor), puede en su lugar, debe seguir las instrucciones para configurar el SDK de JavaScript del cliente .

A continuación se muestra una matriz de funciones que muestra qué funciones de Firebase son compatibles en cada idioma:

Característica Nodo.js Java Pitón Ir C#
Acuñación de tokens personalizados
Verificación de token de identificación
Gestión de usuarios
Controle el acceso con reclamos personalizados
Actualizar revocación de token
Importar usuarios
Gestión de cookies de sesión
Generar enlaces de acción de correo electrónico
Gestión de configuraciones de proveedores SAML/OIDC
Soporte multiinquilino
Base de datos en tiempo real *
Mensajería en la nube de Firebase
Multidifusión FCM
Administrar suscripciones a temas de FCM
Almacenamiento en la nube
Tienda de fuego en la nube
Poner en cola funciones con Cloud Tasks
Gestión de proyectos
Reglas de seguridad
Gestión de modelos de aprendizaje automático
Configuración remota de Firebase
Verificación de la aplicación Firebase
Extensiones de base de fuego

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

Requisitos previos

  • Asegúrate de tener una aplicación de servidor.

  • Asegúrese de que su servidor ejecute lo siguiente según el SDK de administrador que utilice:

    • Administrador del SDK de Node.js: Node.js 14+ (recomiendo Node.js 16+)
      La compatibilidad con Node.js 14 está obsoleta.
    • SDK de Java de administrador: Java 8+
    • Admin Python SDK: Python 3.7+ (se recomienda Python 3.8+)
      La compatibilidad con Python 3.7 está obsoleta.
    • Administrador Go SDK - Ir 1.17+
    • Admin .NET SDK: .NET Framework 4.6.1+ o .NET Standard 2.0 para .Net Core 2.0+

Configurar un proyecto de Firebase y una cuenta de servicio

Para usar el SDK de Firebase Admin, necesitarás lo siguiente:

  • Un proyecto de Firebase.
  • Una cuenta de servicio Firebase Admin SDK para comunicarse con Firebase. Esta cuenta de servicio se crea automáticamente cuando creas un proyecto de Firebase o agregas Firebase a un proyecto de Google Cloud.
  • Un archivo de configuración con las credenciales de su cuenta de servicio.

Si aún no tienes un proyecto de Firebase, debes crear uno en Firebase console . Visita Comprender los proyectos de Firebase para obtener más información sobre los proyectos de Firebase.

Agrega el SDK

Si está configurando un nuevo proyecto, debe instalar el SDK para el idioma que elija.

Nodo.js

El SDK de Firebase Admin Node.js está disponible en npm. Si aún no tiene un archivo package.json , cree uno mediante npm init . A continuación, instale el paquete npm firebase-admin y guárdelo en su package.json :

npm install firebase-admin --save

Para utilizar el módulo en su aplicación, require desde cualquier archivo JavaScript:

const { initializeApp } = require('firebase-admin/app');

Si está utilizando ES2015, puede import el módulo:

import { initializeApp } from 'firebase-admin/app';

Java

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

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

Si usa Maven para crear su aplicación, puede agregar la siguiente dependencia a su pom.xml :

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

Pitón

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

sudo pip install firebase-admin

O puede instalar la biblioteca solo para el usuario actual pasando el indicador --user :

pip install --user firebase-admin

Ir

El SDK de Go Admin se puede instalar usando la utilidad go get :

# Install the latest version:
go get firebase.google.com/go/v4@latest

# Or install a specific version:
go get firebase.google.com/go/v4@4.13.0

C#

El SDK de administración de .NET se puede instalar utilizando el administrador de paquetes de .NET:

Install-Package FirebaseAdmin -Version 2.4.0

Alternativamente, instálelo usando la utilidad de línea de comandos dotnet :

dotnet add package FirebaseAdmin --version 2.4.0

O puede instalarlo agregando la siguiente entrada de referencia del paquete a su archivo .csproj :

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

Inicializar el SDK

Una vez que haya creado un proyecto de Firebase, puede inicializar el SDK con las credenciales predeterminadas de la aplicación de Google . Debido a que la búsqueda de credenciales predeterminadas está completamente automatizada en entornos de Google, sin necesidad de proporcionar variables de entorno u otra configuración, se recomienda encarecidamente esta forma de inicializar el SDK para aplicaciones que se ejecutan en entornos de Google, como Cloud Run, App Engine y Cloud Functions.

Para especificar opcionalmente opciones de inicialización para servicios como Realtime Database, Cloud Storage o Cloud Functions, utilice la variable de entorno FIREBASE_CONFIG . Si el contenido de la variable FIREBASE_CONFIG comienza con { se analizará como un objeto JSON. De lo contrario, el SDK supone que la cadena es la ruta de un archivo JSON que contiene las opciones.

Nodo.js

const app = initializeApp();

Java

FirebaseApp.initializeApp();

Pitón

default_app = firebase_admin.initialize_app()

Ir

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

C#

FirebaseApp.Create();

Una vez inicializado, puede utilizar el SDK de administración para realizar los siguientes tipos de tareas:

Usando un token de actualización de OAuth 2.0

El SDK de administración también proporciona una credencial que le permite autenticarse con un token de actualización de Google OAuth2 :

Nodo.js

const myRefreshToken = '...'; // Get refresh token from OAuth2 flow

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

Java

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

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

FirebaseApp.initializeApp(options);

Pitón

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

Ir

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)
}
init.go

C#

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

Inicialice el SDK en entornos que no sean de Google

Si está trabajando en un entorno de servidor que no es de Google en el que la búsqueda de credenciales predeterminadas no se puede automatizar por completo, puede inicializar el SDK con un archivo de clave de cuenta de servicio exportado.

Los proyectos de Firebase admiten cuentas de servicio de Google, que puedes usar para llamar a las API del servidor de Firebase desde tu servidor de aplicaciones o entorno confiable. Si está desarrollando código localmente o implementando su aplicación localmente, puede usar las credenciales obtenidas a través de esta cuenta de servicio para autorizar las solicitudes del servidor.

Para autenticar una cuenta de servicio y autorizarla a acceder a los servicios de Firebase, debe generar un archivo de clave privada en formato JSON.

Para generar un archivo de clave privada para su cuenta de servicio:

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

  2. Haga clic en Generar nueva clave privada y luego confirme haciendo clic en Generar clave .

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

Al realizar la autorización a través de una cuenta de servicio, tiene dos opciones para proporcionar las credenciales a su aplicación. Puede configurar la variable de entorno GOOGLE_APPLICATION_CREDENTIALS o puede pasar explícitamente la ruta a la clave de la cuenta de servicio en el código. La primera opción es más segura y muy recomendable.

Para configurar la variable de entorno:

Establezca la variable de entorno GOOGLE_APPLICATION_CREDENTIALS en la ruta del archivo JSON que contiene su clave de cuenta de servicio. Esta variable solo se aplica a su sesión actual de Shell, por lo que si abre una nueva sesión, configure la variable nuevamente.

Linux o macOS

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

ventanas

Con PowerShell:

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

Una vez que haya completado los pasos anteriores, las Credenciales predeterminadas de la aplicación (ADC) pueden determinar implícitamente sus credenciales, lo que le permite utilizar las credenciales de la cuenta de servicio al realizar pruebas o ejecutarlas en entornos que no son de Google.

Inicialice el SDK como se muestra:

Nodo.js

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

Java

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

FirebaseApp.initializeApp(options);

Pitón

default_app = firebase_admin.initialize_app()

Ir

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

C#

FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.GetApplicationDefault(),
    ProjectId = "my-project-id",
});

FirebaseAppSnippets.cs

Inicializar múltiples aplicaciones

En la mayoría de los casos, sólo tienes que inicializar una única aplicación predeterminada. Puede acceder a los servicios desde esa aplicación de dos formas equivalentes:

Nodo.js

// Initialize the default app
const defaultApp = initializeApp(defaultAppConfig);

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

// Retrieve services via the defaultApp variable...
let defaultAuth = getAuth(defaultApp);
let defaultDatabase = getDatabase(defaultApp);

// ... or use the equivalent shorthand notation
defaultAuth = getAuth();
defaultDatabase = getDatabase();

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

Pitón

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

Ir

// 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)
}
init.go

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;

Algunos casos de uso requieren que crees varias aplicaciones al mismo tiempo. Por ejemplo, es posible que desees leer datos de la base de datos en tiempo real de un proyecto de Firebase y generar tokens personalizados para otro proyecto. O quizás quieras autenticar dos aplicaciones con credenciales independientes. El SDK de Firebase te permite crear varias aplicaciones al mismo tiempo, cada una con su propia información de configuración.

Nodo.js

// Initialize the default app
initializeApp(defaultAppConfig);

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

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

// Use the shorthand notation to retrieve the default app's services
const defaultAuth = getAuth();
const defaultDatabase = getDatabase();

// Use the otherApp variable to retrieve the other app's services
const otherAuth = getAuth(otherApp);
const otherDatabase = getDatabase(otherApp);

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

Pitón

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

Ir

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

Establecer ámbitos para la autenticación y la base de datos en tiempo real

Si está utilizando una máquina virtual de Google Compute Engine con credenciales predeterminadas de aplicaciones de Google para autenticación o base de datos en tiempo real, asegúrese de configurar también los alcances de acceso correctos. Para la autenticación y la base de datos en tiempo real, necesita ámbitos que terminen en userinfo.email y cloud-platform o firebase.database . Para verificar los alcances de acceso existentes y cambiarlos, ejecuta los siguientes comandos usando gcloud .

nube de 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"

Pruebas con credenciales de usuario final de gcloud

Al probar el SDK de administración localmente con las credenciales predeterminadas de la aplicación de Google obtenidas al ejecutar gcloud auth application-default login , se necesitan cambios adicionales para usar la autenticación de Firebase debido a lo siguiente:

  • Firebase Authentication no acepta credenciales de usuario final de gcloud generadas con el ID de cliente de gcloud OAuth.
  • La autenticación de Firebase requiere que se proporcione el ID del proyecto en la inicialización para este tipo de credenciales de usuario final.

Como solución alternativa, puedes generar credenciales predeterminadas de aplicaciones de Google en gcloud usando tu propio ID de cliente de OAuth 2.0 . El ID del cliente OAuth debe ser un tipo de aplicación de aplicación de escritorio .

nube de gcloud

gcloud auth application-default login --client-id-file=[/path/to/client/id/file]

Puede especificar el ID del proyecto explícitamente al inicializar la aplicación o simplemente usar la variable de entorno GOOGLE_CLOUD_PROJECT . Esto último evita la necesidad de realizar cambios adicionales para probar su código.

Para especificar explícitamente el ID del proyecto:

Nodo.js

import { initializeApp, applicationDefault } from 'firebase-admin/app';

initializeApp({
  credential: applicationDefault(),
  projectId: '<FIREBASE_PROJECT_ID>',
});

Java

FirebaseOptions options = FirebaseOptions.builder()
    .setCredentials(GoogleCredentials.getApplicationDefault())
    .setProjectId("<FIREBASE_PROJECT_ID>")
    .build();

FirebaseApp.initializeApp(options);

Pitón

app_options = {'projectId': '<FIREBASE_PROJECT_ID>'}
default_app = firebase_admin.initialize_app(options=app_options)

Ir

config := &firebase.Config{ProjectID: "<FIREBASE_PROJECT_ID>"}
app, err := firebase.NewApp(context.Background(), config)
if err != nil {
        log.Fatalf("error initializing app: %v\n", err)
}

C#

FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.GetApplicationDefault(),
    ProjectId = "<FIREBASE_PROJECT_ID>",
});

Próximos pasos

Más información sobre Firebase:

Agregue funciones de Firebase a su aplicación: