Join us for Firebase Summit on November 10, 2021. Tune in to learn how Firebase can help you accelerate app development, release with confidence, and scale with ease. Register

Ajouter le SDK Firebase Admin à votre serveur

Le SDK Admin est un ensemble de bibliothèques de serveur qui vous permet d'interagir avec Firebase à partir d'environnements privilégiés pour effectuer des actions telles que :

  • Lisez et écrivez des données de base de données en temps réel avec des privilèges d'administrateur complets.
  • Envoyez par programmation des messages Firebase Cloud Messaging en utilisant une approche simple et alternative aux protocoles du serveur Firebase Cloud Messaging.
  • Générez et vérifiez les jetons d'authentification Firebase.
  • Accédez aux ressources Google Cloud telles que les buckets Cloud Storage et les bases de données Cloud Firestore associées à vos projets Firebase.
  • Créez votre propre console d'administration simplifiée pour faire des choses comme rechercher des données utilisateur ou modifier l'adresse e-mail d'un utilisateur pour l'authentification.

Si vous souhaitez utiliser le SDK Node.js en tant que client pour l'accès de l'utilisateur final (par exemple, dans un bureau Node.js ou une application IoT), par opposition à l'accès administrateur à partir d'un environnement privilégié (comme un serveur), vous devraient plutôt suivre les instructions pour la mise en place du SDK client JavaScript .

Voici une matrice des fonctionnalités montrant les fonctionnalités de Firebase prises en charge dans chaque langue :

Caractéristique Node.js Java Python Aller C#
Frappe de jetons personnalisés
Vérification du jeton d'identification
Gestion des utilisateurs
Contrôlez l'accès avec des revendications personnalisées
Actualiser la révocation du jeton
Importer des utilisateurs
Gestion des cookies de session
Génération de liens d'action par e-mail
Gestion des configurations de fournisseur SAML/OIDC
Prise en charge de plusieurs locataires
Base de données en temps réel *
Messagerie Cloud Firebase
Multidiffusion FCM
Gérer les abonnements aux rubriques FCM
Stockage en ligne
Cloud Firestore
Gestion de projet
Règles de sécurité
Gestion des modèles de ML
Configuration à distance Firebase
Vérification de l'application Firebase

Pour en savoir plus sur l' intégration d' administration SDK pour ces utilisations, consultez la correspondante Base de données en temps réel , la FCM , l' authentification , à distance Config et Cloud Storage documentation. Le reste de cette page se concentre sur la configuration de base du SDK Admin.

Conditions préalables

  • Assurez-vous d'avoir une application serveur.

  • Assurez-vous que votre serveur exécute les éléments suivants en fonction du SDK Admin que vous utilisez :

    • SDK administrateur Node.js — Node.js 12+
    • Admin Java SDK — Java 7+ (recommander Java 8+)
      La prise en charge de Java 7 est obsolète.
    • SDK Admin Python — Python 3.6+
    • Admin Go SDK — Go 1.11+
    • Administrateur .NET SDK — .NET Framework 4.5+ ou .Net Core 1.5+

Configurer un projet Firebase et un compte de service

Pour utiliser le SDK Firebase Admin, vous aurez besoin des éléments suivants :

  • Un projet Firebase
  • Un compte de service pour communiquer avec Firebase
  • Un fichier de configuration avec les informations d'identification de votre compte de service

Si vous ne possédez pas déjà un projet Firebase, vous devez créer un dans la console Firebase . Visitez Comprendre Firebase projets pour en savoir plus sur les projets Firebase.

Ajouter le SDK

Si vous configurez un nouveau projet, vous devez installer le SDK pour la langue de votre choix.

Node.js

Le SDK Firebase Admin Node.js est disponible sur npm. Si vous ne possédez pas déjà un package.json fichier, créer un via npm init . Ensuite, installez le firebase-admin package NPM et enregistrez - le à votre package.json :

$ npm install firebase-admin --save

Pour utiliser le module dans votre application, require à partir de tout fichier JavaScript:

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

Si vous utilisez ES2015, vous pouvez import le module:

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

Java

Le SDK Java Firebase Admin est publié dans le référentiel central Maven. Pour installer la bibliothèque, déclarer comme une dépendance dans votre build.gradle fichier:

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

Si vous utilisez Maven pour construire votre application, vous pouvez ajouter la dépendance suivante à votre pom.xml :

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

Python

Le SDK Python Firebase d' administration est disponible via pip . Vous pouvez installer la bibliothèque pour tous les utilisateurs via sudo :

$ sudo pip install firebase-admin

Ou bien , vous pouvez installer la bibliothèque pour seulement l'utilisateur actuel en passant le --user drapeau:

$ pip install --user firebase-admin

Aller

Le Go Administrateur SDK peut être installé en utilisant le go get utilitaire:

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

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

C#

Le SDK .NET Admin peut être installé à l'aide du gestionnaire de packages .NET :

$ Install-Package FirebaseAdmin -Version 2.2.0

Vous pouvez également installer à l'aide du dotnet utilitaire de ligne de commande:

$ dotnet add package FirebaseAdmin --version 2.2.0

Ou, vous pouvez l' installer en ajoutant l'entrée de référence du paquet suivant à votre .csproj fichier:

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

Initialiser le SDK

Une fois que vous avez créé un projet Firebase, vous pouvez initialiser le SDK avec une stratégie d'autorisation qui combine votre dossier de compte de service avec Google demande de vérification des pouvoirs par défaut .

Projets Firebase soutiennent Google comptes de service , que vous pouvez utiliser pour appeler les API de serveur Firebase à partir de votre serveur d'applications ou de l' environnement de confiance. Si vous développez du code localement ou déployez votre application sur site, vous pouvez utiliser les informations d'identification obtenues via ce compte de service pour autoriser les demandes du serveur.

Pour authentifier un compte de service et l'autoriser à accéder aux services Firebase, vous devez générer un fichier de clé privée au format JSON.

Pour générer un fichier de clé privée pour votre compte de service :

  1. Dans la console Firebase, ouvrez Paramètres> Comptes de service .

  2. Cliquez sur Générer une nouvelle clé privée, puis confirmez en cliquant sur Générer la clé.

  3. Stockez en toute sécurité le fichier JSON contenant la clé.

Lors de l'autorisation via un compte de service, vous avez deux choix pour fournir les informations d'identification à votre application. Vous pouvez définir la GOOGLE_APPLICATION_CREDENTIALS variable d'environnement, ou vous pouvez passer explicitement le chemin à la clé de compte de service dans le code. La première option est plus sécurisée et est fortement recommandée.

Pour définir la variable d'environnement :

Définissez la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS au chemin du fichier du fichier JSON qui contient la clé de votre compte de service. Cette variable ne s'applique qu'à votre session shell actuelle, donc si vous ouvrez une nouvelle session, définissez à nouveau la variable.

Linux ou macOS

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

les fenêtres

Avec PowerShell :

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

Une fois que vous avez terminé les étapes ci-dessus, les informations d'identification par défaut de l'application (ADC) sont capables de déterminer implicitement vos informations d'identification, vous permettant d'utiliser les informations d'identification du compte de service lors des tests ou de l'exécution dans des environnements autres que Google.

Initialisez le SDK comme indiqué :

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

Python

default_app = firebase_admin.initialize_app()

Aller

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

Utiliser un jeton d'actualisation OAuth 2.0

Le Admin SDK fournit également une information d' identification qui vous permet d'authentifier avec Google OAuth2 jeton rafraichissement

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

Python

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

Aller

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

Initialiser sans paramètres

Le SDK peut également être initialisé sans paramètres. Dans ce cas, le SDK utilise Google application de vérification des pouvoirs par défaut . Étant donné que la recherche des identifiants par défaut est entièrement automatisée dans les environnements Google, sans qu'il soit nécessaire de fournir des variables d'environnement ou une autre configuration, cette méthode d'initialisation du SDK est fortement recommandée pour les applications exécutées sur Compute Engine, Kubernetes Engine, App Engine et Cloud Functions.

Pour éventuellement spécifier des options d' initialisation pour des services tels que la base de données en temps réel, Cloud Storage ou des fonctions de Cloud, utilisez la FIREBASE_CONFIG variable d'environnement. Si le contenu de la FIREBASE_CONFIG variable commence par un { il sera analysé comme un objet JSON. Sinon, le SDK suppose que la chaîne est le chemin d'un fichier JSON contenant les options.

Node.js

const app = initializeApp();

Java

FirebaseApp.initializeApp();

Python

default_app = firebase_admin.initialize_app()

Aller

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

C#

FirebaseApp.Create();

Une fois qu'il est initialisé, vous pouvez utiliser le SDK Admin pour accomplir les types de tâches suivants :

Initialiser plusieurs applications

Dans la plupart des cas, vous n'avez qu'à initialiser une seule application par défaut. Vous pouvez accéder aux services à partir de cette application de deux manières équivalentes :

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

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

Aller

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

Certains cas d'utilisation vous obligent à créer plusieurs applications en même temps. Par exemple, vous souhaiterez peut-être lire les données de la base de données en temps réel d'un projet Firebase et créer des jetons personnalisés pour un autre projet. Ou vous voudrez peut-être authentifier deux applications avec des informations d'identification distinctes. Le SDK Firebase vous permet de créer plusieurs applications en même temps, chacune avec ses propres informations de configuration.

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

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)

Aller

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

Définir des étendues pour la base de données en temps réel et l'authentification

Si vous utilisez une machine virtuelle Google Compute Engine avec Google application Identifiants par défaut pour la base de données en temps réel ou d' authentification, assurez - vous de définir également les bons champs d'accès . Pour en temps réel et la base de données d' authentification, vous avez besoin champs d' application se terminant par userinfo.email et soit cloud-platform - firebase.database cloud-platform ou firebase.database . Pour vérifier les champs d'accès existants et de les modifier, exécutez les commandes suivantes à l' aide 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"

Tester avec les identifiants de l'utilisateur final gcloud

Lors du test de Admin SDK localement avec Google application de gcloud auth application-default login vérification des pouvoirs par défaut obtenus en exécutant gcloud auth application-default login par gcloud auth application-default login , il faut des modifications supplémentaires à utiliser Firebase d' authentification pour les raisons suivantes:

  • Firebase Authentication n'accepte pas les identifiants de l'utilisateur final gcloud générés à l'aide de l'ID client gcloud OAuth.
  • L'authentification Firebase nécessite que l'ID du projet soit fourni lors de l'initialisation pour ce type d'informations d'identification d'utilisateur final.

Pour contourner ce problème, vous pouvez générer Google demande de vérification des pouvoirs par défaut dans gcloud en utilisant votre propre OAuth 2.0 ID client . L'ID client OAuth doit être un type d'application de l' application de bureau.

gcloud

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

Vous pouvez spécifier l'ID de projet explicitement lors de l' initialisation de l' application ou tout simplement utiliser la GOOGLE_CLOUD_PROJECT variable d'environnement. Ce dernier évite d'avoir à apporter des modifications supplémentaires pour tester votre code.

Pour spécifier explicitement l'ID du projet :

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

Python

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

Aller

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

Prochaines étapes

En savoir plus sur Firebase :

Ajoutez des fonctionnalités Firebase à votre application :