Google 致力于为黑人社区推动种族平等。查看具体举措

Aggiungi l'SDK Firebase Admin al tuo server

L'Admin SDK è un insieme di librerie di 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 a livello di codice i messaggi di Firebase Cloud Messaging utilizzando un approccio semplice e alternativo ai protocolli del 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 utente o modificare l'indirizzo email di un utente per l'autenticazione.

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

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

Caratteristica Nodo.js Giava Pitone andare 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 azioni email
Gestione delle configurazioni del provider SAML/OIDC
Supporto multi-tenant
Database in tempo reale *
Messaggistica cloud Firebase
Multicast FCM
Gestire gli abbonamenti agli argomenti FCM
Archiviazione cloud
Cloud Firestore
Gestione del progetto
Regole di sicurezza
Gestione del modello ML
Configurazione remota Firebase
Controllo dell'app Firebase

Per saperne di più su integrazione Admin SDK per questi usi, vedere la corrispondente base di dati in tempo reale , FCM , Autenticazione , Configurazione remota , e Cloud Storage documentazione. Il resto di questa pagina si concentra sulla configurazione di base per l'SDK Admin.

Prerequisiti

  • Assicurati di avere un'app server.

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

    • Admin Node.js SDK — Node.js 10.13.0+
    • Admin Java SDK — Java 7+ (consigliato Java 8+)
      Il supporto per Java 7 è deprecato.
    • Admin Python SDK — 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 si dispone già di un progetto Firebase, è necessario creare uno nella console Firebase . Visita Capire Firebase progetti per saperne di più su progetti Firebase.

Aggiungi l'SDK

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

Nodo.js

L'SDK Firebase Admin Node.js è disponibile su npm. Se non si dispone già di un package.json di file, creare uno via npm init . Successivamente, installare il firebase-admin pacchetto NPM e salvarlo sul package.json :

$ npm install firebase-admin --save

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

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

Se si utilizza ES2015, è possibile import il modulo, invece:

import * as admin from 'firebase-admin';

Giava

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

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

Se si utilizza Maven per generare l'applicazione, è possibile aggiungere le seguenti dipendenze al pom.xml :

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

Pitone

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

$ sudo pip install firebase-admin

In alternativa, è possibile installare la libreria solo per l'utente corrente passando il --user bandiera:

$ pip install --user firebase-admin

andare

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

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

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

C#

È possibile installare .NET Admin SDK utilizzando il gestore di pacchetti .NET:

$ Install-Package FirebaseAdmin -Version 2.2.0

In alternativa, installarlo utilizzando la dotnet riga di comando:

$ dotnet add package FirebaseAdmin --version 2.2.0

In alternativa, è possibile installarlo aggiungendo la voce di riferimento pacchetto seguente al vostro .csproj del file:

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

Inizializza l'SDK

Dopo aver creato un progetto Firebase, è possibile inizializzare l'SDK con una strategia di autorizzazione che unisce il file account del servizio insieme a Google Application credenziali predefinite .

Progetti Firebase supportano Google account di servizio , che è possibile utilizzare per chiamare le API di server Firebase dal server app o ambiente attendibile. Se stai sviluppando codice in locale 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, aprire 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 opzioni per fornire le credenziali alla propria applicazione. O si può impostare la GOOGLE_APPLICATION_CREDENTIALS variabile d'ambiente, oppure si può passare in modo esplicito il percorso della chiave account di servizio nel codice. La prima opzione è più sicura ed è fortemente consigliata.

Per impostare la variabile d'ambiente:

Impostare la variabile d'ambiente GOOGLE_APPLICATION_CREDENTIALS al percorso del file JSON che contiene il codice di account di servizio. Questa variabile si applica solo alla tua sessione di shell corrente, 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, Application Default Credentials (ADC) è in grado di determinare implicitamente le tue credenziali, consentendoti di utilizzare le credenziali dell'account di servizio durante il test o l'esecuzione in ambienti non Google.

Inizializza l'SDK come mostrato:

Nodo.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()

andare

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 inoltre una credenziale che consente di autenticazione con un Google OAuth2 token di aggiornamento:

Nodo.js

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

andare

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ò essere inizializzato anche senza parametri. In questo caso, l'SDK utilizza Google Application Credenziali predefinite . Poiché la ricerca delle credenziali predefinite è completamente automatizzata negli ambienti Google, senza la necessità di fornire variabili di ambiente o altre configurazioni, 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 opzionalmente di inizializzazione opzioni per i servizi come ad esempio in tempo reale del database, Cloud Storage, o funzioni cloud, utilizzare il FIREBASE_CONFIG variabile d'ambiente. Se il contenuto del FIREBASE_CONFIG variabile inizia con un { verrà analizzato come un oggetto JSON. In caso contrario, l'SDK presuppone che la stringa sia il percorso di un file JSON contenente le opzioni.

Nodo.js

const app = admin.initializeApp();

Giava

FirebaseApp.initializeApp();

Pitone

default_app = firebase_admin.initialize_app()

andare

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 un'unica app predefinita. Puoi accedere ai servizi da quell'app in due modi equivalenti:

Nodo.js

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

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

// Retrieve services via the defaultApp variable...
let defaultAuth = defaultApp.auth();
let 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(...)

andare

// 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 Realtime Database 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, ognuna con le proprie informazioni di configurazione.

Nodo.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
const defaultAuth = admin.auth();
const defaultDatabase = admin.database();

// Use the otherApp variable to retrieve the other app's services
const otherAuth = otherApp.auth();
const 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)

andare

// 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 stai usando un Google Compute Engine VM con Google Application credenziali predefinite per tempo reale Database o l'autenticazione, assicurarsi di impostare anche i giusti scopi di accesso . Per tempo reale e autenticazione database, è necessario che terminano in ambiti userinfo.email eo cloud-platform o firebase.database . Per controllare gli ambiti di accesso esistenti e cambiarle, eseguire 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"

Test con le credenziali dell'utente finale di gcloud

Durante il test di Admin SDK localmente con Google Application credenziali predefinite ottenuti eseguendo gcloud auth application-default login , sono necessarie ulteriori modifiche per utilizzare l'autenticazione Firebase a causa di quanto segue:

  • L'autenticazione Firebase non accetta le credenziali dell'utente finale di gcloud generate utilizzando l'ID client OAuth di gcloud.
  • L'autenticazione Firebase richiede che l'ID progetto venga fornito all'inizializzazione per questo tipo di credenziali dell'utente finale.

Come soluzione alternativa, è possibile generare Google Application credenziali predefinite in gcloud utilizzando il proprio OAuth 2.0 ID cliente . L'ID client OAuth deve essere un tipo di applicazione un'applicazione desktop.

gcloud

gcloud auth application-default login --client-id-file=[/path/to/client/id/file]

È possibile specificare l'ID del progetto in modo esplicito su inizializzazione app o semplicemente utilizzare il GOOGLE_CLOUD_PROJECT variabile d'ambiente. Quest'ultimo evita la necessità di apportare ulteriori modifiche per testare il codice.

Per specificare esplicitamente l'ID progetto:

Nodo.js

admin.initializeApp({
  credential: admin.credential.applicationDefault(),
  projectId: '<FIREBASE_PROJECT_ID>',
});

Giava

FirebaseOptions options = FirebaseOptions.builder()
    .setCredentials(GoogleCredentials.getApplicationDefault())
    .setProjectId("<FIREBASE_PROJECT_ID>")
    .build();

FirebaseApp.initializeApp(options);

Pitone

app_options = {'projectId': '<FIREBASE_PROJECT_ID>'}
default_app = firebase_admin.initialize_app(options=app_options)

andare

config := &firebase.Config{ProjectID: "<FIREBASE_PROJECT_ID>"}
app, err := firebase.NewApp(context.Background(), config)
if err != nil {
        log.Fatalf("error initializing app: %v\n", err)
}

C#

FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.GetApplicationDefault(),
    ProjectId = "<FIREBASE_PROJECT_ID>",
});

Prossimi passi

Informazioni su Firebase:

Aggiungi le funzionalità di Firebase alla tua app: