Google 致力于为黑人社区推动种族平等。查看具体举措
Questa pagina è stata tradotta dall'API Cloud Translation.
Switch to English

Aggiungi Firebase Admin SDK al tuo server

Admin SDK è un insieme di librerie server che ti consente di interagire con Firebase da ambienti privilegiati per eseguire azioni come:

  • Leggere e scrivere i dati del database in tempo reale con privilegi di amministratore completi.
  • Invia messaggi Firebase Cloud Messaging a livello di programmazione utilizzando un approccio semplice e alternativo ai protocolli server Firebase Cloud Messaging.
  • Genera e verifica i token di autenticazione Firebase.
  • Accedi alle risorse di Google Cloud come i bucket Cloud Storage e i database Cloud Firestore associati ai tuoi progetti Firebase.
  • Crea la tua console di amministrazione semplificata per eseguire operazioni come cercare i dati degli utenti o modificare l'indirizzo email di un utente per l'autenticazione.

Se sei interessato a utilizzare Node.js SDK come client per l'accesso dell'utente finale (ad esempio, in un desktop Node.js o in un'applicazione IoT), invece dell'accesso amministratore da un ambiente privilegiato (come un server), dovrebbe invece seguire le istruzioni per configurare l'SDK JavaScript del client .

Ecco una matrice delle funzionalità che mostra quali funzionalità Firebase sono supportate in ciascuna lingua:

Caratteristica Node.js Giava Pitone Partire C #
Conio di token personalizzato
Verifica del token ID
Gestione utenti
Controllo dell'accesso con reclami personalizzati
Aggiorna la revoca del token
Importa utenti
Gestione dei cookie di sessione
Generazione di link azione email
Gestione delle configurazioni del provider SAML / OIDC
Supporto multi-tenancy
Database in tempo reale *
Firebase Cloud Messaging
FCM Multicast
Gestisci gli abbonamenti agli argomenti FCM
Cloud Storage
Cloud Firestore
Gestione di progetto
Regole di sicurezza
Gestione del modello ML
Firebase Remote Config

Per ulteriori informazioni sull'integrazione di Admin SDK per questi usi, vedere la documentazione relativa a Realtime Database , FCM , Authentication , Remote Config e Cloud Storage . Il resto di questa pagina si concentra sulla configurazione di base per Admin SDK.

Prerequisiti

  • Assicurati di avere un'app server.

  • Assicurati che il tuo server esegua quanto segue a seconda dell'SDK di amministrazione che utilizzi:

    • SDK Admin Node.js - Node.js 10.10.0+
    • Admin Java SDK - Java 7+ (consigliato Java 8+)
      Il supporto di Java 7 è deprecato.
    • Admin Python SDK - Python 3.5+ (consigliato Python 3.6+)
    • Admin Go SDK - Vai 1.11+
    • Admin .NET SDK - .NET Framework 4.5+ o .Net Core 1.5+

Configura un progetto Firebase e un account di servizio

Per utilizzare Firebase Admin SDK, avrai bisogno di quanto segue:

  • Un progetto Firebase
  • Un account di servizio per comunicare con Firebase
  • Un file di configurazione con le credenziali del tuo account di servizio

Se non hai già un progetto Firebase, devi crearne uno nella console Firebase . Visita Comprendere i progetti Firebase per ulteriori informazioni sui progetti Firebase.

Aggiungi l'SDK

Se stai configurando un nuovo progetto, devi installare l'SDK per la lingua che preferisci.

Node.js

L'SDK Firebase Admin Node.js è disponibile su npm. Se non hai già un file package.json , creane uno tramite npm init . Successivamente, installa il pacchetto npm firebase-admin e salvalo nel tuo package.json :

$ npm install firebase-admin --save

Per utilizzare il modulo nella tua applicazione, require da qualsiasi file JavaScript:

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

Se stai usando ES2015, puoi invece import il modulo:

import * as admin from 'firebase-admin';

Giava

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

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

Se usi Maven per creare la tua applicazione, puoi aggiungere la seguente dipendenza al tuo pom.xml :

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

Pitone

Firebase Admin Python SDK è disponibile tramite pip . Puoi installare la libreria per tutti gli utenti tramite sudo :

$ sudo pip install firebase-admin

Oppure puoi installare la libreria solo per l'utente corrente passando il flag --user :

$ pip install --user firebase-admin

Partire

Go Admin SDK può essere installato utilizzando l'utility go get :

# Install as a module dependency
$ go get firebase.google.com/go/v4

# Install to $GOPATH
$ go get firebase.google.com/go

C #

.NET Admin SDK può essere installato utilizzando il gestore di pacchetti .NET:

$ Install-Package FirebaseAdmin -Version 2.0.0

In alternativa, installalo utilizzando l'utilità della riga di comando dotnet :

$ dotnet add package FirebaseAdmin --version 2.0.0

In alternativa, puoi installarlo aggiungendo la seguente voce di riferimento del pacchetto al tuo file .csproj :

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

Inizializza l'SDK

Dopo aver creato un progetto Firebase, puoi inizializzare l'SDK con una strategia di autorizzazione che combina il file del tuo account di servizio con le credenziali predefinite dell'applicazione Google .

I progetti Firebase supportano account di servizio Google, che puoi utilizzare per chiamare le API del server Firebase dal server delle app o dall'ambiente attendibile. Se stai sviluppando codice localmente o distribuendo la tua applicazione in locale, puoi usare le credenziali ottenute tramite questo account di servizio per autorizzare le richieste del server.

Per autenticare un account di servizio e autorizzarlo ad accedere ai servizi Firebase, devi generare un file di chiave privata in formato JSON.

Per generare un file di chiave privata per il tuo account di servizio:

  1. Nella console Firebase, apri Impostazioni> Account di servizio .

  2. Fare clic su Genera nuova chiave privata , quindi confermare facendo clic su Genera chiave .

  3. Archivia in modo sicuro il file JSON contenente la chiave.

Quando si autorizza tramite un account di servizio, sono disponibili due scelte per fornire le credenziali alla propria applicazione. Puoi impostare la variabile d'ambiente GOOGLE_APPLICATION_CREDENTIALS oppure passare esplicitamente il percorso alla chiave dell'account di servizio nel codice. La prima opzione è più sicura ed è vivamente consigliata.

Per impostare la variabile d'ambiente:

Imposta la variabile di ambiente GOOGLE_APPLICATION_CREDENTIALS sul percorso del file JSON che contiene la chiave dell'account di servizio. Questa variabile si applica solo alla sessione corrente della shell, quindi se apri una nuova sessione, imposta di nuovo la variabile.

Linux o macOS

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

finestre

Con PowerShell:

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

Dopo aver completato i passaggi precedenti, le credenziali predefinite dell'applicazione (ADC) è in grado di determinare in modo implicito le tue credenziali, consentendoti di utilizzare le credenziali dell'account di servizio durante i test o l'esecuzione in ambienti non Google.

Inizializza l'SDK come mostrato:

Node.js

admin.initializeApp({
  credential: admin.credential.applicationDefault(),
  databaseURL: 'https://<DATABASE_NAME>.firebaseio.com'
});

Giava

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

FirebaseApp.initializeApp(options);

Pitone

default_app = firebase_admin.initialize_app()

Partire

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

C #

FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.GetApplicationDefault(),
});

Utilizzo di un token di aggiornamento OAuth 2.0

L'Admin SDK fornisce anche una credenziale che ti consente di autenticarti con un token di aggiornamento OAuth2 di Google :

Node.js

var refreshToken; // Get refresh token from OAuth2 flow

admin.initializeApp({
  credential: admin.credential.refreshToken(refreshToken),
  databaseURL: 'https://<DATABASE_NAME>.firebaseio.com'
});

Giava

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

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

FirebaseApp.initializeApp(options);

Pitone

cred = credentials.RefreshToken('path/to/refreshToken.json')
default_app = firebase_admin.initialize_app(cred)

Partire

opt := option.WithCredentialsFile("path/to/refreshToken.json")
config := &firebase.Config{ProjectID: "my-project-id"}
app, err := firebase.NewApp(context.Background(), config, opt)
if err != nil {
	log.Fatalf("error initializing app: %v\n", err)
}

C #

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

Inizializza senza parametri

L'SDK può anche essere inizializzato senza parametri. In questo caso, l'SDK utilizza le credenziali predefinite dell'applicazione Google . Poiché la ricerca delle credenziali predefinite è completamente automatizzata negli ambienti Google, senza necessità di fornire variabili di ambiente o altra configurazione, questo modo di inizializzare l'SDK è fortemente consigliato per le applicazioni in esecuzione su Compute Engine, Kubernetes Engine, App Engine e Cloud Functions.

Per specificare facoltativamente le opzioni di inizializzazione per servizi come Realtime Database, Cloud Storage o Cloud Functions, utilizza la variabile di ambiente FIREBASE_CONFIG . Se il contenuto della variabile FIREBASE_CONFIG inizia con una { verrà analizzato come un oggetto JSON. In caso contrario, l'SDK presume che la stringa sia il percorso di un file JSON contenente le opzioni.

Node.js

// Initialize the default app
var admin = require('firebase-admin');
var app = admin.initializeApp();

Giava

FirebaseApp.initializeApp();

Pitone

default_app = firebase_admin.initialize_app()

Partire

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

C #

FirebaseApp.Create();

Una volta inizializzato, puoi utilizzare Admin SDK per eseguire i seguenti tipi di attività:

Inizializza più app

Nella maggior parte dei casi, devi solo inizializzare una singola app predefinita. Puoi accedere ai servizi da quell'app in due modi equivalenti:

Node.js

// Initialize the default app
var defaultApp = admin.initializeApp(defaultAppConfig);

console.log(defaultApp.name);  // '[DEFAULT]'

// Retrieve services via the defaultApp variable...
var defaultAuth = defaultApp.auth();
var defaultDatabase = defaultApp.database();

// ... or use the equivalent shorthand notation
defaultAuth = admin.auth();
defaultDatabase = admin.database();

Giava

// Initialize the default app
FirebaseApp defaultApp = FirebaseApp.initializeApp(defaultOptions);

System.out.println(defaultApp.getName());  // "[DEFAULT]"

// Retrieve services by passing the defaultApp variable...
FirebaseAuth defaultAuth = FirebaseAuth.getInstance(defaultApp);
FirebaseDatabase defaultDatabase = FirebaseDatabase.getInstance(defaultApp);

// ... or use the equivalent shorthand notation
defaultAuth = FirebaseAuth.getInstance();
defaultDatabase = FirebaseDatabase.getInstance();

Pitone

# Import the Firebase service
from firebase_admin import auth

# Initialize the default app
default_app = firebase_admin.initialize_app(cred)
print(default_app.name)  # "[DEFAULT]"

# Retrieve services via the auth package...
# auth.create_custom_token(...)

Partire

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

// Access auth service from the default app
client, err := app.Auth(context.Background())
if err != nil {
	log.Fatalf("error getting Auth client: %v\n", err)
}

C #

// Initialize the default app
var defaultApp = FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.GetApplicationDefault(),
});
Console.WriteLine(defaultApp.Name); // "[DEFAULT]"

// Retrieve services by passing the defaultApp variable...
var defaultAuth = FirebaseAuth.GetAuth(defaultApp);

// ... or use the equivalent shorthand notation
defaultAuth = FirebaseAuth.DefaultInstance;

Alcuni casi d'uso richiedono la creazione di più app contemporaneamente. Ad esempio, potresti voler leggere i dati dal database in tempo reale di un progetto Firebase e coniare token personalizzati per un altro progetto. Oppure potresti voler autenticare due app con credenziali separate. L'SDK Firebase ti consente di creare più app contemporaneamente, ciascuna con le proprie informazioni di configurazione.

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();
var defaultDatabase = admin.database();

// Use the otherApp variable to retrieve the other app's services
var otherAuth = otherApp.auth();
var otherDatabase = otherApp.database();

Giava

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

Pitone

# 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)

Partire

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

Imposta gli ambiti per il database in tempo reale e l'autenticazione

Se utilizzi una VM di Google Compute Engine con le credenziali predefinite dell'applicazione Google per il database in tempo reale o l'autenticazione, assicurati di impostare anche gli ambiti di accesso corretti. Per il database e l'autenticazione in tempo reale, sono necessari ambiti che terminano con userinfo.email e cloud-platform o firebase.database . Per controllare gli ambiti di accesso esistenti e modificarli, esegui i seguenti comandi utilizzando gcloud .

gcloud

# Check the existing access scopes
gcloud compute instances describe [INSTANCE_NAME] --format json

# The above command returns the service account information. For example:
  "serviceAccounts": [
   {
    "email": "your.gserviceaccount.com",
    "scopes": [
     "https://www.googleapis.com/auth/cloud-platform",
     "https://www.googleapis.com/auth/userinfo.email"
     ]
    }
  ],

# Stop the VM, then run the following command, using the service account
# that gcloud returned when you checked the scopes.

gcloud compute instances set-service-account [INSTANCE_NAME] --service-account "your.gserviceaccount.com" --scopes "https://www.googleapis.com/auth/firebase.database,https://www.googleapis.com/auth/userinfo.email"

Prossimi passi

Informazioni su Firebase:

Aggiungi le funzionalità Firebase alla tua app: