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 :
En outre, vous aurez besoin d'un compte de service et d'une clé pour votre projet :
Console
Créez un compte de service :
-
Dans la console Google Cloud, accédez à la page Créer un compte de service.
Accéder à la page "Créer un compte de service" - Sélectionnez votre projet.
-
Dans le champ Nom du compte de service, saisissez un nom. La console Google Cloud remplit le champ ID du compte de service en fonction de ce nom.
Dans le champ Description du compte de service, saisissez une description. Exemple :
Service account for quickstart
. - Cliquez sur Créer et continuer.
-
Attribuez le rôle Other > Identity Toolkit Admin au compte de service.
Pour accorder le rôle, trouvez la liste Sélectionner un rôle, puis sélectionnez Other > Identity Toolkit Admin.
- Cliquez sur Continuer.
-
Cliquez sur OK pour terminer la création du compte de service.
Ne fermez pas la fenêtre de votre navigateur. Vous en aurez besoin lors de la tâche suivante.
Créez une clé de compte de service :
- Dans la console Google Cloud, cliquez sur l'adresse e-mail du compte de service que vous avez créé.
- Cliquez sur Keys (Clés).
- Cliquez sur Ajouter une clé, puis sur Créer une clé.
- Cliquez sur Create (Créer). Un fichier de clé JSON est téléchargé sur votre ordinateur.
- Cliquez sur Close (Fermer).
gcloud
Configurez l'authentification :
-
Créez le compte de service :
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
Remplacez
SERVICE_ACCOUNT_NAME
par le nom que vous souhaitez donner au compte de service. -
Attribuez le rôle IAM
Project > Admin
au compte de service.gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com" --role=Project > Admin
Remplacez les éléments suivants :
SERVICE_ACCOUNT_NAME
: nom du compte de service.PROJECT_ID
: ID du projet dans lequel vous avez créé le compte de service.
-
Générez le fichier de clé :
gcloud iam service-accounts keys create FILE_NAME.json --iam-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
Remplacez les éléments suivants :
FILE_NAME
: nom du fichier de cléSERVICE_ACCOUNT_NAME
: nom du compte de service.PROJECT_ID
: ID du projet dans lequel vous avez créé le compte de service.
Fournissez des identifiants d'authentification au code de votre application en définissant la variable d'environnement GOOGLE_APPLICATION_CREDENTIALS
. Cette variable ne s'applique qu'à la session de shell actuelle. Si vous souhaitez que la variable s'applique aux futures sessions de shell, définissez-la dans le fichier de démarrage du shell, par exemple dans le fichier ~/.bashrc
ou ~/.profile
.
Linux ou macOS
export GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH
"
Remplacez KEY_PATH
par le chemin d'accès du fichier JSON contenant vos identifiants.
Par exemple :
export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"
Windows
Pour PowerShell :
$env:GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH
"
Remplacez KEY_PATH
par le chemin d'accès du fichier JSON contenant vos identifiants.
Par exemple :
$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\service-account-file.json"
Pour l'invite de commande :
set GOOGLE_APPLICATION_CREDENTIALS=KEY_PATH
Remplacez KEY_PATH
par le chemin d'accès du fichier JSON contenant vos identifiants.
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();
Python
default_app = firebase_admin.initialize_app()
Go
app, err := firebase.NewApp(context.Background(), nil) if err != nil { log.Fatalf("error initializing app: %v\n", err) }
C#
FirebaseApp.Create();
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);
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)
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) }
C#
FirebaseApp.Create(new AppOptions() { Credential = GoogleCredential.FromFile("path/to/serviceAccountKey.json"), });
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);
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)
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) }
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 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"
Étapes suivantes
- Consultez le code source et la documentation supplémentaire concernant le SDK Admin sur GitHub :
- Migrer des utilisateurs existants vers Identity Platform
- Gérer les fournisseurs SAML et OIDC par programmation
- Gérer les locataires Identity Platform