Installer le SDK Admin

Ce document explique comment installer le SDK Admin Identity Platform. Le SDK Admin vous permet de gérer Identity Platform à partir d'un environnement de serveur et d'effectuer des actions d'administration, telles que la migration d'utilisateurs, la définition de revendications personnalisées et la configuration de fournisseurs d'identité.

Avant de commencer

Pour utiliser le SDK Admin, vous avez besoin d'une application de serveur exécutant l'une des applications suivantes :

Langue Version minimale du framework
Node.js Node.js 8.13.0 ou version ultérieure
Java Java 7 ou version ultérieure (Java 8 ou version ultérieure recommandé)
Python Python 2.7 ou version ultérieure ou 3.4 ou version ultérieure (3.4 ou version ultérieure recommandé)
Go Go 1.9 ou version ultérieure
C# .NET Framework 4.5 ou version ultérieure ou .NET Core 1.5 ou version ultérieure

Le tableau suivant répertorie les fonctionnalités acceptées par chaque langage SDK :

Fonctionnalité Node.js Java Python Go C#
Émission de jetons personnalisés
Validation des jetons d'identification
Gestion des utilisateurs
Contrôler l'accès à l'aide de revendications personnalisées
Révocation du jeton d'actualisation
Importer des utilisateurs
Gestion des cookies de session
Générer des liens d'action pour les e-mails
Gérer les configurations de fournisseur SAML/OIDC
Compatibilité avec l'architecture multitenancy
Realtime Database *
Firebase Cloud Messaging
Multicast FCM
Gérer les abonnements à des thèmes FCM
Cloud Storage
Firestore
Gestion de projets
Règles de sécurité
Gestion des modèles de ML
Firebase Remote Config
Firebase App Check
Extensions Firebase

En outre, vous aurez besoin d'un compte de service et d'une clé pour votre projet :

Console

Create a service account:

  1. In the Google Cloud console, go to the Create service account page.

    Go to Create service account
  2. Select your project.

  3. In the Service account name field, enter a name. The Google Cloud console fills in the Service account ID field based on this name.

    In the Service account description field, enter a description. For example, Service account for quickstart.

  4. Click Create and continue.

  5. Grant the Other > Identity Toolkit Admin role to the service account.

    To grant the role, find the Select a role list, then select Other > Identity Toolkit Admin.

  6. Click Continue.

  7. Click Done to finish creating the service account.

    Do not close your browser window. You will use it in the next step.

Create a service account key:

  1. In the Google Cloud console, click the email address for the service account that you created.
  2. Click Keys.
  3. Click Add key, and then click Create new key.
  4. Click Create. A JSON key file is downloaded to your computer.
  5. Click Close.

gcloud

Set up authentication:

  1. Create the service account: 

    gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

    Replace SERVICE_ACCOUNT_NAME with a name for the service account.

  2. Grant the Project > Admin IAM role to the service account: 

    gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com" --role=Project > Admin

    Replace the following:

    • SERVICE_ACCOUNT_NAME: the name of the service account
    • PROJECT_ID: the project ID where you created the service account

  3. Generate the key file: 

    gcloud iam service-accounts keys create FILE_NAME.json --iam-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com

    Replace the following:

    • FILE_NAME: a name for the key file
    • SERVICE_ACCOUNT_NAME: the name of the service account
    • PROJECT_ID: the project ID where you created the service account

Provide authentication credentials to your application code by setting the environment variable GOOGLE_APPLICATION_CREDENTIALS. This variable applies only to your current shell session. If you want the variable to apply to future shell sessions, set the variable in your shell startup file, for example in the ~/.bashrc or ~/.profile file.

Linux ou macOS

export GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH"

Replace KEY_PATH with the path of the JSON file that contains your credentials.

For example:

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

Windows

For PowerShell:

$env:GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH"

Replace KEY_PATH with the path of the JSON file that contains your credentials.

For example:

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

For command prompt:

set GOOGLE_APPLICATION_CREDENTIALS=KEY_PATH

Replace KEY_PATH with the path of the JSON file that contains your credentials.

Installing the SDK

Node.js

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

npm install firebase-admin --save

Pour utiliser le module dans votre application, demandez-le en exécutant la commande require depuis n'importe quel fichier JavaScript :

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

Si vous utilisez ES2015, vous pouvez importer le module en exécutant la commande import à la place :

import * as admin from 'firebase-admin';

Java

Le SDK Admin Java est publié dans le dépôt central Maven. Pour installer la bibliothèque, déclarez-la en tant que dépendance dans votre fichier build.gradle :

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

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

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

Python

Le SDK Admin Python est disponible à l'aide de pip.

pip install --user firebase-admin

Go

Utilisez l'utilitaire go get pour installer le SDK Admin Go :

go get firebase.google.com/go

C#

Installez le SDK Admin .NET à l'aide du gestionnaire de packages .NET :

Install-Package FirebaseAdmin -Version 1.9.1

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

dotnet add package FirebaseAdmin --version 1.9.1

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

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

Initialiser le SDK à l'aide des identifiants par défaut

Ajoutez le code suivant à votre application de serveur pour initialiser le SDK Admin à l'aide des identifiants par défaut :

Node.js

// Initialize the default app
var admin = require('firebase-admin');
var app = admin.initializeApp({
  credential: admin.credential.applicationDefault()
});

Java

FirebaseApp.initializeApp();
FirebaseAppSnippets.java

Python

default_app = firebase_admin.initialize_app()
index.py

Go

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

C#

FirebaseApp.Create();

FirebaseAppSnippets.cs

Initialiser le SDK avec un fichier de clé de compte de service

Vous pouvez également spécifier manuellement un fichier de clé de compte de service :

Node.js

// Initialize the default app
var admin = require('firebase-admin');
var app = admin.initializeApp({
  credential: admin.credential.cert('/path/to/serviceAccountKey.json')
});

Java

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

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

FirebaseApp.initializeApp(options);
FirebaseAppSnippets.java

Python

import firebase_admin
from firebase_admin import credentials
from firebase_admin import exceptions

cred = credentials.Certificate('path/to/serviceAccountKey.json')
default_app = firebase_admin.initialize_app(cred)
index.py

Go

opt := option.WithCredentialsFile("path/to/serviceAccountKey.json")
app, err := firebase.NewApp(context.Background(), nil, opt)
if err != nil {
	log.Fatalf("error initializing app: %v\n", err)
}
init.go

C#

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

FirebaseAppSnippets.cs

Initialiser plusieurs applications

En règle générale, vous ne souhaiterez initialiser qu'une seule application par défaut. Toutefois, vous pouvez également créer plusieurs instances d'application, chacune ayant ses propres options de configuration et son propre état d'authentification.

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

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);
FirebaseAppSnippets.java

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)
index.py

Go

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

FirebaseAppSnippets.cs

Définir des champs d'application

Si vous utilisez une VM Compute Engine avec des identifiants par défaut de l'application Google pour l'authentification, vous devez définir les niveaux d'accès appropriés. Identity Platform nécessite les niveaux d'accès userinfo.email et cloud-platform.

Pour vérifier vos niveaux d'accès existants, exécutez la commande suivante :

gcloud compute instances describe [INSTANCE-NAME] --format json

La commande renvoie des informations sur le compte de service. Exemple :

"serviceAccounts": [
 {
  "email": "example.gserviceaccount.com",
  "scopes": [
   "https://www.googleapis.com/auth/cloud-platform",
   "https://www.googleapis.com/auth/userinfo.email"
   ]
  }
]

Pour mettre à jour les niveaux d'accès, arrêtez la VM, puis exécutez la commande suivante :


gcloud compute instances set-service-account [INSTANCE-NAME] \
  --service-account "your.gserviceaccount.com" \
  --scopes ""https://www.googleapis.com/auth/cloud-platform,https://www.googleapis.com/auth/userinfo.email"

Étape suivante