Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.

Installazione dell'SDK Admin

Questo documento mostra come installare l'SDK Identity Platform Admin. L'SDK Admin consente di gestire Identity Platform da un ambiente server ed eseguire azioni come la migrazione degli utenti da parte degli amministratori, l'impostazione di rivendicazioni personalizzate e la configurazione dei provider di identità.

Prima di iniziare

Per utilizzare l'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 Vai a 1.9+
C# .NET Framework 4.5+ o .NET Core 1.5+

Nella tabella che segue vengono elencate le funzionalità supportate da ogni linguaggio dell'SDK:

Funzionalità Node.js Java Python Go C#
Contingenza token personalizzata
Verifica dei token ID
Gestire gli utenti
Controllare l'accesso con rivendicazioni personalizzate
Revoca dei token di aggiornamento
Importazione degli utenti
Gestione dei cookie di sessione
Generazione di link a azioni email
Gestione delle configurazioni dei provider SAML e OIDC
Supporto multitenancy

Inoltre, avrai bisogno di un account di servizio e di una chiave per il tuo progetto:

Console

Crea un account di servizio:

  1. Nella console Google Cloud, vai alla pagina Crea account di servizio.

    Vai a Crea account di servizio
  2. Seleziona il progetto.
  3. Inserisci un nome nel campo Service account name (Nome account di servizio). 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.

  4. Fai clic su Crea e continua.
  5. Per fornire l'accesso al progetto, concedi i seguenti ruoli al tuo account di servizio: Other > Identity Toolkit Admin .

    Nell'elenco Seleziona un ruolo, seleziona un ruolo.

    Per altri ruoli, fai clic su Aggiungi un altro ruolo e aggiungi ogni ruolo aggiuntivo.

  6. Fai clic su Continua.
  7. 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:

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

gcloud CLI

Configurare l'autenticazione:

  1. Crea l'account di servizio:

    gcloud iam service-accounts create NAME

    Sostituisci NAME con un nome per l'account di servizio.

  2. Concedi i ruoli all'account di servizio. Esegui il comando seguente una volta per ciascuno dei seguenti ruoli IAM: Project > Admin :

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

    Sostituisci quanto segue:

    • SERVICE_ACCOUNT_NAME: nome dell'account di servizio
    • PROJECT_ID: l'ID progetto in cui hai creato l'account di servizio
    • ROLE: il ruolo da concedere
  3. 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: 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 della tua applicazione impostando la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS. Questa variabile si applica solo alla sessione shell corrente. Se vuoi che la variabile venga applicata alle sessioni shell future, 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 la chiave dell'account di servizio.

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 la chiave dell'account di servizio.

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 la chiave dell'account di servizio.

Installazione dell'SDK

Node.js

L'SDK Admin Node.js è disponibile a npm. Se non hai ancora un file package.json, creane uno utilizzando npm init. Poi, installa il pacchetto npm e salvalo su package.json:

npm install firebase-admin --save

Per usare il modulo nella tua app, require da qualsiasi file JavaScript:

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

Se invece utilizzi ES2015, puoi import il modulo:

import * as admin from 'firebase-admin';

Java

L'SDK Admin di Java viene pubblicato nel repository centrale di Maven. Per installare la libreria, dichiarala come dipendenza nel file build.gradle:

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

Se usi 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 Python Admin è disponibile tramite pip.

pip install --user firebase-admin

Go

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

go get firebase.google.com/go

C#

Installa l'SDK Admin di .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 installarla aggiungendo al file .csproj la seguente voce di riferimento per il pacchetto:

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

Inizializzazione dell'SDK con credenziali predefinite

Aggiungi il seguente codice all'app del 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 della chiave dell'account di servizio

Puoi anche specificare manualmente un file della chiave 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 corso...

In genere, è consigliabile inizializzare una sola app predefinita. Tuttavia, puoi anche creare più istanze di app, ciascuna 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);

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, dovrai 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 restituisce 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 il comando seguente:


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