Installazione dell'SDK Admin

Questo documento mostra come installare l'SDK Admin di Identity Platform. L'SDK Admin ti consente di gestire Identity Platform da un ambiente server ed 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 l'SDK Admin, devi disporre di un'app server che esegue uno dei seguenti elementi:

Lingua Versione minima del framework
Node.js Node.js 8.13.0+
Java Java 7+ (Java 8+ consigliato)
Python Python 2.7+ o 3.4+ (3.4+ consigliato)
Go Go 1.9+
C# .NET Framework 4.5+ o .NET Core 1.5+

La tabella seguente elenca le funzionalità supportate da ogni linguaggio SDK:

Funzionalità Node.js Java Python Go C#
Custom token minting
Verifica del token ID
Gestione utenti
Controllare l'accesso con rivendicazioni personalizzate
Revoca del token di aggiornamento
Importa utenti
Gestione dei cookie di sessione
Generazione di link di azione email
Gestione delle configurazioni dei provider SAML/OIDC
Supporto multi-tenant
Realtime Database *
Firebase Cloud Messaging
FCM Multicast
Gestisci le iscrizioni agli argomenti FCM
Cloud Storage
Firestore
Project management
Regole di sicurezza
Gestione dei modelli ML
Firebase Remote Config
Firebase App Check
Firebase Extensions

Console

  1. Crea un service account:

    1. Assicurati di disporre del ruolo IAM Creazione account di servizio (roles/iam.serviceAccountCreator) e del ruolo Amministratore IAM progetto (roles/resourcemanager.projectIamAdmin). Scopri come concedere i ruoli.

    2. Nella console Google Cloud vai a Crea service account.

      Vai a Crea service account
    3. Seleziona il progetto.

    4. Nel campo Nome service account, inserisci un nome. La console Google Cloud compila il campo ID service account in base a questo nome.

      Nel campo Descrizione service account, inserisci una descrizione. Ad esempio, Service account for quickstart.

    5. Fai clic su Crea e continua.

    6. Concedi il ruolo Altro > Amministratore Identity Toolkit all'account di servizio.

      Per concedere il ruolo, individua l'elenco Seleziona un ruolo, quindi seleziona Altro > Amministratore Identity Toolkit.

    7. Fai clic su Continua.

    8. Fai clic su Fine per completare la creazione del service account.

      Non chiudere la finestra del browser. Lo utilizzerai nel prossimo passaggio.

  2. Crea una chiave dell'account di servizio:

    1. Nella console Google Cloud , fai clic sull'indirizzo email del account di servizio che hai creato.
    2. Fai clic su Chiavi.
    3. Fai clic su Aggiungi chiave, poi su Crea nuova chiave.
    4. Fai clic su Crea. Un file della chiave JSON viene scaricato sul computer.
    5. Fai clic su Chiudi.

gcloud

  1. Configura l'autenticazione:

    1. Assicurati di disporre del ruolo IAM Creazione account di servizio (roles/iam.serviceAccountCreator) e del ruolo Amministratore IAM progetto (roles/resourcemanager.projectIamAdmin). Scopri come concedere i ruoli.

    2. Crea l'account di servizio: 

      gcloud iam service-accounts create SERVICE_ACCOUNT_NAME

      Sostituisci SERVICE_ACCOUNT_NAME con un nome per il account di servizio.

    3. Concedi il ruolo IAM roles/identitytoolkit.admin al account di servizio: 

      gcloud projects add-iam-policy-binding PROJECT_ID --member="serviceAccount:SERVICE_ACCOUNT_NAME@PROJECT_ID.iam.gserviceaccount.com" --role=roles/identitytoolkit.admin

      Sostituisci quanto segue:

      • SERVICE_ACCOUNT_NAME: il nome del account di servizio
      • PROJECT_ID: l'ID progetto in cui hai creato il account di servizio

    4. 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 chiave
      • SERVICE_ACCOUNT_NAME: il nome del account di servizio
      • PROJECT_ID: l'ID progetto in cui hai creato il account di servizio

Installazione dell'SDK

Node.js

L'SDK Admin Node.js è disponibile su npm. Se non hai già un file package.json, creane uno utilizzando npm init. Poi, installa il pacchetto npm e salvalo in 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, puoi import il modulo:

import * as admin from 'firebase-admin';

Java

L'SDK Admin Java è pubblicato nel repository centrale Maven. Per installare la libreria, dichiarala come 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 al file pom.xml:

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

Python

L'SDK Admin Python è disponibile tramite pip.

pip install --user firebase-admin

Go

Utilizza l'utilità go get per installare l'SDK Admin di Go:

go get firebase.google.com/go

C#

Installa l'SDK Admin .NET 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 le 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();
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

Inizializzazione dell'SDK con un file di chiave del account di servizio

Puoi anche specificare manualmente un file della chiave del 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);
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 = CredentialFactory.FromFile<ServiceAccountCredential>("path/to/serviceAccountKey.json").ToGoogleCredential(),
});

FirebaseAppSnippets.cs

Inizializzazione di più app

In genere, ti consigliamo di inizializzare una sola app predefinita. Tuttavia, puoi anche creare più istanze dell'app, ognuna con le proprie opzioni di configurazione e stato di autenticazione.

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

Impostazione degli ambiti

Se utilizzi una VM 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 controllare gli ambiti di accesso esistenti, esegui questo comando:

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

Il comando restituirà informazioni sul 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