Catch up on everything announced at Firebase Summit, and learn how Firebase can help you accelerate app development and run your app with confidence. Learn More

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

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Admin SDK 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 la base de datos en tiempo real con privilegios de administrador completos.
  • Envíe mensajes de Firebase Cloud Messaging mediante programación utilizando un enfoque simple y alternativo a los protocolos del servidor de Firebase Cloud Messaging.
  • Genere y verifique los tokens de autenticación de Firebase.
  • Accede a los recursos de Google Cloud, como depósitos de Cloud Storage y bases de datos de Cloud Firestore asociadas con tus 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 la autenticación.

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

Aquí hay una matriz de funciones que muestra qué funciones de Firebase son compatibles en cada idioma:

Rasgo Nodo.js Java Pitón Vamos C#
Acuñación de fichas personalizadas
Verificación de token de identificación
Gestión de usuarios
Controle el acceso con reclamos personalizados
Revocación de token de actualización
Importar usuarios
Gestión de cookies de sesión
Generación de enlaces de acción de correo electrónico
Administrar configuraciones de proveedores de SAML/OIDC
Soporte de múltiples inquilinos
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
Gestión de proyectos
Reglas de seguridad
Gestión de modelos de aprendizaje automático
Configuración remota de Firebase
Comprobación de la aplicación Firebase
Extensiones de base de fuego

Para obtener más información sobre la integración del SDK de administrador para estos usos, consulte la documentación correspondiente de Realtime Database , FCM , autenticación , configuración remota y almacenamiento en la nube . El resto de esta página se centra en la configuración básica del SDK de administrador.

requisitos previos

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

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

    • Admin Node.js SDK — Node.js 14+
    • Administrador Java SDK — Java 8+
    • Admin Python SDK: Python 3.6+ (se recomienda Python 3.7+)
    • Admin Go SDK — Go 1.15+
    • 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 administrador de Firebase, necesitará lo siguiente:

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

Si aún no tiene un proyecto de Firebase, debe crear uno en la consola de Firebase . Visite Comprender los proyectos de Firebase para obtener más información sobre los proyectos de Firebase.

Agregar el SDK

Si está configurando un nuevo proyecto, debe instalar el SDK para el idioma de su elección.

Nodo.js

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

npm install firebase-admin --save

Para usar 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, declárala como una dependencia en tu archivo build.gradle :

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

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

<dependency>
  <groupId>com.google.firebase</groupId>
  <artifactId>firebase-admin</artifactId>
  <version>9.1.1</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 a través de sudo :

sudo pip install firebase-admin

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

pip install --user firebase-admin

Vamos

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

# Install as a module dependency
go get firebase.google.com/go/v4

# Install to $GOPATH
go get firebase.google.com/go

C#

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

Install-Package FirebaseAdmin -Version 2.3.0

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

dotnet add package FirebaseAdmin --version 2.3.0

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

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

Inicializar el SDK

Una vez que haya creado un proyecto de Firebase, puede inicializar el SDK con una estrategia de autorización que combine el archivo de su cuenta de servicio junto con las Credenciales predeterminadas de la aplicación de Google .

Los proyectos de Firebase admiten cuentas de servicio de Google, que puede usar para llamar a las API del servidor de Firebase desde su servidor de aplicaciones o entorno de confianza. 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, abra Configuración > Cuentas de servicio .

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

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

Al autorizar 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 se recomienda encarecidamente.

Para establecer la variable de entorno:

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

Linux o mac OS

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 usar las credenciales de la cuenta de servicio cuando realiza pruebas o se ejecuta 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()

Vamos

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

Uso de un token de actualización de OAuth 2.0

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

Vamos

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

Inicializar sin parámetros

El SDK también se puede inicializar sin parámetros. En este caso, el SDK utiliza las Credenciales predeterminadas de la aplicación de Google . Debido a que la búsqueda de credenciales predeterminadas está totalmente automatizada en los entornos de Google, sin necesidad de proporcionar variables de entorno u otra configuración, se recomienda encarecidamente esta forma de inicializar el SDK para las aplicaciones que se ejecutan en Compute Engine, Kubernetes Engine, App Engine y Cloud Functions.

Para especificar opcionalmente opciones de inicialización para servicios como Realtime Database, Cloud Storage o Cloud Functions, use 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 asume 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()

Vamos

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

C#

FirebaseApp.Create();

Una vez inicializado, puede usar Admin SDK para realizar los siguientes tipos de tareas:

Inicializar múltiples aplicaciones

En la mayoría de los casos, solo tiene que inicializar una única aplicación predeterminada. Puede acceder a los servicios fuera de esa aplicación de dos maneras 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(...)

Vamos

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

Algunos casos de uso requieren que cree varias aplicaciones al mismo tiempo. Por ejemplo, es posible que desee leer datos de la base de datos en tiempo real de un proyecto de Firebase y crear tokens personalizados para otro proyecto. O quizás desee autenticar dos aplicaciones con credenciales separadas. El SDK de Firebase le 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)

Vamos

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

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

Si está utilizando una VM de Google Compute Engine con credenciales predeterminadas de la aplicación de Google para la autenticación o la base de datos en tiempo real, asegúrese de configurar también los ámbitos de acceso correctos. Para Realtime Database and Authentication, 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 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"

Prueba con credenciales de usuario final de gcloud

Al probar el SDK de administrador de forma local 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.
  • Firebase Authentication requiere que se proporcione el ID del proyecto en la inicialización para este tipo de credenciales de usuario final.

Como solución alternativa, puede generar credenciales predeterminadas de aplicaciones de Google en gcloud utilizando su propia ID de cliente de OAuth 2.0 . El ID de cliente de OAuth debe ser un tipo de aplicación de aplicación de escritorio .

gcloud

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

Puede especificar el ID del proyecto explícitamente en la inicialización de la aplicación o simplemente usar la variable de entorno GOOGLE_CLOUD_PROJECT . Este ú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)

Vamos

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: