Installazione dell'SDK Admin
Questo documento mostra come installare l'SDK Identity Platform Admin. SDK Admin ti consente di gestire Identity Platform da un ambiente server e di eseguire azioni amministrative come la migrazione degli utenti, l'impostazione di rivendicazioni personalizzate e la configurazione dei provider di identità.
Prima di iniziare
Per utilizzare SDK Admin, è necessaria un'app server che esegua una delle seguenti operazioni:
Lingua | Versione minima del framework |
---|---|
Node.js | Node.js 8.13.0 o versioni successive |
Java | Java 7+ (Java 8+ consigliato) |
Python | Python 2.7+ o 3.4+ (consigliato 3.4+) |
Go | Passa a 1.9 o versioni successive |
C# | .NET Framework 4.5 e versioni successive o .NET Core 1.5 e versioni successive |
Nella tabella seguente sono elencate le funzionalità supportate da ogni lingua dell'SDK:
Inoltre, per il progetto avrai bisogno di un account di servizio e di una chiave:
Console
Crea un account di servizio:
-
Nella console Google Cloud, vai alla pagina Crea account di servizio.
Vai a Crea account di servizio - Seleziona il progetto.
-
Nel campo Nome account di servizio, inserisci un nome. La console Google Cloud compila il campo ID account di servizio in base a questo nome.
Nel campo Descrizione account di servizio, inserisci una descrizione. Ad esempio,
Service account for quickstart
. - Fai clic su Crea e continua.
-
Concedi il ruolo Other > Identity Toolkit Admin all'account di servizio.
Per concedere il ruolo, trova l'elenco Seleziona un ruolo e scegli Other > Identity Toolkit Admin.
- Fai clic su Continua.
-
Fai clic su Fine per completare la creazione dell'account di servizio.
Non chiudere la finestra del browser. La utilizzerai nel passaggio successivo.
Crea una chiave dell'account di servizio:
- Nella console Google Cloud, fai clic sull'indirizzo email dell'account di servizio che hai creato.
- Fai clic su Chiavi.
- Fai clic su Aggiungi chiave, quindi su Crea nuova chiave.
- Fai clic su Crea. Un file della chiave JSON viene scaricato sul computer.
- Fai clic su Chiudi.
gcloud
Configura l'autenticazione:
-
Crea l'account di servizio:
gcloud iam service-accounts create SERVICE_ACCOUNT_NAME
Sostituisci
SERVICE_ACCOUNT_NAME
con un nome per l'account di servizio. -
Concedi il ruolo IAM
Project > Admin
all'account di servizio:gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com" --role=Project > Admin
Sostituisci quanto segue:
SERVICE_ACCOUNT_NAME
: il nome dell'account di servizio.PROJECT_ID
: l'ID progetto in cui hai creato l'account di servizio
-
Genera il file della chiave:
gcloud iam service-accounts keys create FILE_NAME.json --iam-account=SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com
Sostituisci quanto segue:
FILE_NAME
: un nome per il file della chiaveSERVICE_ACCOUNT_NAME
: il nome dell'account di servizio.PROJECT_ID
: l'ID progetto in cui hai creato l'account di servizio
Fornisci le credenziali di autenticazione al codice dell'applicazione impostando la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS
. Questa variabile si applica solo alla sessione di shell attuale. Se vuoi che la variabile venga applicata a future sessioni shell, impostala nel file di avvio della shell, ad esempio nel file ~/.bashrc
o ~/.profile
.
Linux o macOS
export GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH
"
Sostituisci KEY_PATH
con il percorso del file JSON che contiene le tue credenziali.
Ad esempio:
export GOOGLE_APPLICATION_CREDENTIALS="/home/user/Downloads/service-account-file.json"
Windows
Per PowerShell:
$env:GOOGLE_APPLICATION_CREDENTIALS="KEY_PATH
"
Sostituisci KEY_PATH
con il percorso del file JSON che contiene le tue credenziali.
Ad esempio:
$env:GOOGLE_APPLICATION_CREDENTIALS="C:\Users\username\Downloads\service-account-file.json"
Per il prompt dei comandi:
set GOOGLE_APPLICATION_CREDENTIALS=KEY_PATH
Sostituisci KEY_PATH
con il percorso del file JSON che contiene le tue credenziali.
Installazione dell'SDK
Node.js
L'SDK Admin di Node.js è disponibile su npm. Se non hai già un file package.json
, creane uno utilizzando npm init
. Dopodiché, installa il pacchetto npm e salvalo nel tuo package.json
:
npm install firebase-admin --save
Per utilizzare il modulo nella tua app, require
da qualsiasi file JavaScript:
var admin = require('firebase-admin');
Se utilizzi ES2015, il modulo è invece import
:
import * as admin from 'firebase-admin';
Java
L'SDK Java Admin viene pubblicato nel repository centrale Maven.
Per installare la libreria, dichiarala come una dipendenza nel file build.gradle
:
dependencies {
implementation 'com.google.firebase:firebase-admin:6.11.0'
}
Se utilizzi Maven per creare la tua app, puoi aggiungere la seguente dipendenza a pom.xml
:
<dependency>
<groupId>com.google.firebase</groupId>
<artifactId>firebase-admin</artifactId>
<version>6.11.0</version>
</dependency>
Python
L'SDK Admin di Python è disponibile tramite pip.
pip install --user firebase-admin
Go
Usa l'utilità go get
per installare l'SDK Go Admin:
go get firebase.google.com/go
C#
Installa l'SDK .NET Admin utilizzando il gestore di pacchetti .NET:
Install-Package FirebaseAdmin -Version 1.9.1
In alternativa, installalo utilizzando l'utilità a riga di comando dotnet
:
dotnet add package FirebaseAdmin --version 1.9.1
In alternativa, puoi installarlo aggiungendo la seguente voce di riferimento del pacchetto al
file .csproj
:
<ItemGroup>
<PackageReference Include="FirebaseAdmin" Version="1.9.1" />
</ItemGroup>
Inizializzazione dell'SDK utilizzando credenziali predefinite
Aggiungi il seguente codice all'app server per inizializzare l'SDK Admin utilizzando le credenziali predefinite:
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();
Inizializzazione dell'SDK con un file di chiavi dell'account di servizio
Puoi anche specificare manualmente un file di chiavi dell'account di servizio:
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"), });
Inizializzazione di più app
In genere, ti consigliamo di inizializzare una sola app predefinita. Tuttavia, puoi anche creare più istanze di app, ciascuna con opzioni di configurazione e stato di autenticazione specifici.
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);
Ambiti di impostazione
Se utilizzi una VM di Compute Engine con le Credenziali predefinite dell'applicazione Google per l'autenticazione, devi impostare gli ambiti di accesso corretti.
Identity Platform richiede gli ambiti di accesso userinfo.email
e cloud-platform
.
Per verificare gli ambiti di accesso esistenti, esegui questo comando:
gcloud compute instances describe [INSTANCE-NAME] --format json
Il comando restituirà informazioni sull'account di servizio. Ad esempio:
"serviceAccounts": [
{
"email": "example.gserviceaccount.com",
"scopes": [
"https://www.googleapis.com/auth/cloud-platform",
"https://www.googleapis.com/auth/userinfo.email"
]
}
]
Per aggiornare gli ambiti di accesso, arresta la VM, quindi esegui questo comando:
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"
Passaggi successivi
- Visualizza il codice sorgente e la documentazione aggiuntiva per l'SDK Admin su GitHub:
- Eseguire la migrazione degli utenti esistenti a Identity Platform
- Gestire i provider SAML e OIDC in modo programmatico
- Gestire i tenant di Identity Platform