Ajoutez le SDK d'administration Firebase à votre serveur

Le SDK Admin est un ensemble de bibliothèques de serveurs qui vous permettent 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 effectuer des tâches telles que 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 des utilisateurs finaux (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 devez plutôt suivre les instructions de configuration du SDK JavaScript client .

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

Fonctionnalité Noeud.js Java Python Aller C#
Création de jetons personnalisés
Vérification du jeton d'identification
Gestion des utilisateurs
Contrôler 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 du fournisseur SAML/OIDC
Prise en charge multi-location
Base de données en temps réel *
Messagerie cloud Firebase
Multidiffusion FCM
Gérer les abonnements aux sujets FCM
Stockage en ligne
Cloud Firestore
Gestion de projet
Règles de sécurité
Gestion des modèles ML
Configuration à distance Firebase
Vérification de l'application Firebase
Extensions Firebase

Pour en savoir plus sur l'intégration du SDK Admin pour ces utilisations, consultez la documentation correspondante sur Realtime Database , FCM , Authentication , Remote Config et Cloud Storage . Le reste de cette page se concentre sur la configuration de base du SDK Admin.

Conditions préalables

  • Assurez-vous que vous disposez d'une application serveur.

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

    • SDK Admin Node.js — Node.js 14+ (recommander Node.js 16+)
      La prise en charge de Node.js 14 est obsolète.
    • SDK Java d'administration — Java 8+
    • SDK Python d'administration — Python 3.7+ (recommander Python 3.8+)
      La prise en charge de Python 3.7 est obsolète.
    • SDK Go d'administration — Go 1.17+
    • SDK Admin .NET — .NET Framework 4.6.1+ ou .NET Standard 2.0 pour .Net Core 2.0+

Configurer un projet Firebase et un compte de service

Pour utiliser le SDK d'administration Firebase, vous aurez besoin des éléments suivants :

  • Un projet Firebase.
  • Un compte de service Firebase Admin SDK pour communiquer avec Firebase. Ce compte de service est créé automatiquement lorsque vous créez un projet Firebase ou ajoutez Firebase à un projet Google Cloud.
  • Un fichier de configuration avec les informations d'identification de votre compte de service.

Si vous n'avez pas encore de projet Firebase, vous devez en créer un dans la console Firebase . Consultez Comprendre les projets Firebase 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.

Noeud.js

Le SDK Firebase Admin Node.js est disponible sur npm. Si vous n'avez pas déjà de fichier package.json , créez-en un via npm init . Ensuite, installez le package npm firebase-admin et enregistrez-le dans votre package.json :

npm install firebase-admin --save

Pour utiliser le module dans votre application, require -le à partir de n'importe quel 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éclarez-la comme dépendance dans votre fichier build.gradle :

dependencies {
  implementation 'com.google.firebase:firebase-admin:9.2.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>9.2.0</version>
</dependency>

Python

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

sudo pip install firebase-admin

Ou, vous pouvez installer la bibliothèque uniquement pour l'utilisateur actuel en passant l'indicateur --user :

pip install --user firebase-admin

Aller

Le SDK Go Admin peut être installé à l'aide de l'utilitaire go install :

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

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

C#

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

Install-Package FirebaseAdmin -Version 2.4.0

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

dotnet add package FirebaseAdmin --version 2.4.0

Vous pouvez également l'installer en ajoutant l'entrée de référence de package suivante à votre fichier .csproj :

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

Initialiser le SDK

Une fois que vous avez créé un projet Firebase, vous pouvez initialiser le SDK avec les informations d'identification par défaut de l'application Google . Étant donné que la recherche d'informations d'identification 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 d'autres configurations, cette méthode d'initialisation du SDK est fortement recommandée pour les applications exécutées dans des environnements Google telles que Cloud Run, App Engine et Cloud Functions.

Pour spécifier éventuellement des options d'initialisation pour des services tels que Realtime Database, Cloud Storage ou Cloud Functions, utilisez la variable d'environnement FIREBASE_CONFIG . Si le contenu de la variable FIREBASE_CONFIG 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.

Noeud.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 initialisé, vous pouvez utiliser le SDK Admin pour accomplir les types de tâches suivants :

Utilisation d'un jeton d'actualisation OAuth 2.0

Le SDK Admin fournit également un identifiant qui vous permet de vous authentifier avec un jeton d'actualisation Google OAuth2 :

Noeud.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 le SDK dans des environnements non Google

Si vous travaillez dans un environnement de serveur autre que Google dans lequel la recherche d'informations d'identification par défaut ne peut pas être entièrement automatisée, vous pouvez initialiser le SDK avec un fichier de clé de compte de service exporté.

Les projets Firebase prennent en charge les comptes de service Google, que vous pouvez utiliser pour appeler les API du serveur Firebase à partir de votre serveur d'applications ou d'un environnement approuvé. 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 requêtes 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 une 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 soit définir la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS , soit transmettre explicitement le chemin d'accès à la clé du 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 sur le chemin du fichier JSON qui contient la clé de votre compte de service. Cette variable s'applique uniquement à 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 ainsi d'utiliser les informations d'identification du compte de service lors des tests ou de l'exécution dans des environnements non Google.

Initialisez le SDK comme indiqué :

Noeud.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(),
    ProjectId = "my-project-id",
});

Initialiser plusieurs applications

Dans la plupart des cas, il vous suffit d’initialiser une seule application par défaut. Vous pouvez accéder aux services depuis cette application de deux manières équivalentes :

Noeud.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 nécessitent la création de 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 souhaiterez 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.

Noeud.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 les étendues pour la base de données en temps réel et l'authentification

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

Test avec les identifiants de l'utilisateur final gcloud

Lors du test local du SDK Admin avec les informations d'identification par défaut de l'application Google obtenues en exécutant gcloud auth application-default login , des modifications supplémentaires sont nécessaires pour utiliser l'authentification Firebase pour les raisons suivantes :

  • L'authentification Firebase n'accepte pas les informations d'identification de l'utilisateur final gcloud générées à 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 de l'utilisateur final.

Pour contourner le problème, vous pouvez générer les informations d'identification par défaut de l'application Google dans gcloud en utilisant votre propre ID client OAuth 2.0 . L'ID client OAuth doit être un type d'application d'application de bureau .

gcloud

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

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

Pour spécifier explicitement l'ID du projet :

Noeud.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 :