Google s'est engagé à promouvoir l'équité raciale pour les communautés noires. Regarde comment.
Cette page a été traduite par l'API Cloud Translation.
Switch to English

Ajoutez le SDK Firebase Admin à votre serveur

Le SDK Admin vous permet d'interagir avec Firebase à partir d'environnements privilégiés pour effectuer des actions telles que:

  • Lisez et écrivez les données de la base de données en temps réel avec tous les privilèges d'administrateur.
  • Envoyez par programme des messages Firebase Cloud Messaging en utilisant une approche alternative simple aux protocoles de serveur Firebase Cloud Messaging.
  • Générez et vérifiez les jetons d'authentification Firebase.
  • Accédez aux ressources Google Cloud Platform 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 opérations 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 de l'utilisateur final (par exemple, dans un bureau ou une application IoT Node.js), par opposition à l'accès administrateur à partir d'un environnement privilégié (comme un serveur), vous doit plutôt suivre les instructions de configuration du SDK JavaScript client .

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

Fonctionnalité Node.js Java Python Aller C #
Frappe de jeton personnalisé
Vérification du jeton d'identité
Gestion des utilisateurs
Contrôlez l'accès avec des revendications personnalisées
Refresh Token Revocation
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 la multi-location
Base de données en temps réel *
Messagerie Firebase Cloud
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

Pour en savoir plus sur l'intégration du SDK Admin pour ces utilisations, consultez la documentation correspondante sur la base de données en temps réel , le FCM , l' authentification et le stockage Cloud . 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 10.10.0+
    • Admin Java SDK - Java 7+ (recommande Java 8+)
      La prise en charge de Java 7 est obsolète.
    • SDK d'administration Python - Python 3.5+
    • SDK Admin Go - Go 1.11+
    • Admin .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 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.

Node.js

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

 $ npm install firebase-admin --save
 

Pour utiliser le module dans votre application, require le de n'importe quel fichier JavaScript:

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

Si vous utilisez ES2015, vous pouvez import le module à la place:

 import * as admin from 'firebase-admin';
 

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:6.15.0'
}
 

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

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

Python

Le SDK Firebase Admin Python 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 get :

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

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

C #

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

 $ Install-Package FirebaseAdmin -Version 1.15.0
 

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

 $ dotnet add package FirebaseAdmin --version 1.15.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="1.15.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 fichier de compte de service avec les informations d'identification par défaut de l'application Google .

Les projets Firebase prennent en charge les comptes de service Google, que vous pouvez utiliser pour appeler les API de serveur Firebase à partir de votre serveur d'applications ou de votre 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 soit définir la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS , soit transmettre explicitement le chemin d'accès à 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 sur le chemin du fichier JSON qui contient votre clé de 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 les étapes ci-dessus terminées, les informations d'identification par défaut de l'application (ADC) sont en mesure de déterminer implicitement vos informations d'identification, ce qui vous permet 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é:

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

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

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 :

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)
 

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 les informations d'identification par défaut de l'application Google et lit les options de 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 nom d'un fichier JSON contenant les options.

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

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 hors de cette application de deux manières équivalentes:

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

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

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

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, assurez-vous de définir également les bonnes étendues d'accès . Pour la base de données et l'authentification en temps réel, vous avez besoin d'étendues se terminant par userinfo.email et soit cloud-platform soit 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"
 

Prochaines étapes

En savoir plus sur Firebase:

Ajoutez des fonctionnalités Firebase à votre application: