Firebase Admin SDK dem Server hinzufügen

Die Admin SDK ist eine Reihe von Serverbibliotheken, mit denen Sie aus privilegierten Umgebungen mit Firebase interagieren und Aktionen wie die folgenden ausführen können:

  • Sie können Abfragen und Mutationen für die Bulk-Datenverwaltung und andere Vorgänge mit vollen Administratorberechtigungen auf einem Firebase Data Connect-Dienst ausführen.
  • Realtime Database-Daten mit vollständigen Administratorberechtigungen lesen und schreiben.
  • Programmgesteuertes Senden von Firebase Cloud Messaging-Nachrichten mit einem einfachen, alternativen Ansatz zu den Firebase Cloud Messaging-Serverprotokollen.
  • Firebase Auth-Tokens generieren und bestätigen
  • Zugriff auf Google Cloud-Ressourcen wie Cloud Storage-Buckets und Cloud Firestore-Datenbanken, die mit Ihren Firebase-Projekten verknüpft sind.
  • Erstellen Sie eine eigene vereinfachte Admin-Konsole, um beispielsweise Nutzerdaten abzurufen oder die E-Mail-Adresse eines Nutzers für die Authentifizierung zu ändern.

Wenn Sie das Node.js SDK als Client für den Endnutzerzugriff verwenden möchten (z. B. in einer Node.js-Desktop- oder IoT-Anwendung), anstatt den Administratorzugriff aus einer privilegierten Umgebung (z. B. einem Server) zu verwenden, folgen Sie stattdessen der Anleitung zum Einrichten des Client JavaScript SDK.

In der folgenden Funktionsmatrix sehen Sie, welche Firebase-Features in den einzelnen Sprachen unterstützt werden:

Funktion Node.js Java Python Go C#
Minting von benutzerdefinierten Tokens
ID-Token-Bestätigung
Nutzerverwaltung
Zugriff mit benutzerdefinierten Anforderungen steuern
Widerruf von Aktualisierungstokens
Nutzer importieren
Verwaltung von Sitzungscookies
E-Mail-Aktionslinks generieren
SAML-/OIDC-Anbieterkonfigurationen verwalten
Unterstützung für Mehrmandantenfähigkeit
Firebase Data Connect
Realtime Database *
Firebase Cloud Messaging
FCM Multicast
FCM Themenabonnements verwalten
Cloud Storage
Cloud Firestore
Funktionen mit Cloud Tasks in die Warteschlange stellen
Projektmanagement
Sicherheitsregeln
ML-Modellverwaltung
Firebase Remote Config
Firebase App Check
Firebase Extensions

Weitere Informationen zur Admin SDK-Integration für diese Anwendungsfälle finden Sie in der entsprechenden Dokumentation zu Realtime Database, FCM, Authentication, Remote Config und Cloud Storage. Im weiteren Verlauf dieser Seite geht es um die grundlegende Einrichtung der Admin SDK.

Vorbereitung

  • Sie benötigen eine Server-App.

  • Achten Sie darauf, dass auf Ihrem Server je nach verwendeter Admin SDK Folgendes ausgeführt wird:

    • Admin Node.js SDK – Node.js 18 und höher
    • Admin Java SDK – Java 8 und höher
    • Admin Python SDK – Python 3.7 und höher (Python 3.8 und höher empfohlen)
      Die Unterstützung für Python 3.7 wird eingestellt.
    • Admin Go SDK – Go 1.21 und höher
    • Admin .NET SDK – .NET Framework 4.6.2 oder höher oder .NET Standard 2.0 für .NET 6.0 oder höher

Firebase-Projekt und Dienstkonto einrichten

Für die Verwendung von Firebase Admin SDK benötigen Sie Folgendes:

  • Ein Firebase-Projekt
  • Ein Firebase Admin SDK-Dienstkonto für die Kommunikation mit Firebase. Dieses Dienstkonto wird automatisch erstellt, wenn Sie ein Firebase-Projekt erstellen oder Firebase einem Google Cloud-Projekt hinzufügen.
  • Eine Konfigurationsdatei mit den Anmeldedaten Ihres Dienstkontos.

Wenn Sie noch kein Firebase-Projekt haben, müssen Sie eines in der Firebase Console erstellen. Weitere Informationen zu Firebase-Projekten finden Sie unter Firebase-Projekte verstehen.

SDK hinzufügen

Wenn Sie ein neues Projekt einrichten, müssen Sie das SDK für die gewünschte Sprache installieren.

Node.js

Das Firebase Admin Node.js SDK ist auf npm verfügbar. Wenn Sie noch keine package.json-Datei haben, erstellen Sie eine mit npm init. Installieren Sie als Nächstes das npm-Paket firebase-admin und speichern Sie es in Ihrem package.json:

npm install firebase-admin --save

Wenn Sie das Modul in Ihrer Anwendung verwenden möchten, require Sie es über eine beliebige JavaScript-Datei:

const { initializeApp } = require('firebase-admin/app');

Wenn Sie ES2015 verwenden, können Sie das Modul import löschen:

import { initializeApp } from 'firebase-admin/app';

Java

Das Firebase Admin Java SDK wird im zentralen Maven-Repository veröffentlicht. Um die Bibliothek zu installieren, müssen Sie sie als Abhängigkeit in Ihrer build.gradle-Datei deklarieren:

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

Wenn Sie die Anwendung mit Maven erstellen, können Sie Ihrer pom.xml die folgende Abhängigkeit hinzufügen:

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

Python

Das Firebase Admin Python SDK ist über pip verfügbar. Sie können die Bibliothek für alle Nutzer über sudo installieren:

sudo pip install firebase-admin

Alternativ können Sie die Bibliothek nur für den aktuellen Nutzer installieren, indem Sie das Flag --user übergeben:

pip install --user firebase-admin

Go

Die Go-Admin SDK-Version kann mit dem Dienstprogramm go get installiert werden:

# Install the latest version:
go get firebase.google.com/go/v4@latest

# Or install a specific version:
go get firebase.google.com/go/v4@4.15.0

C#

.NET Admin SDK kann mit dem .NET-Paketmanager installiert werden:

Install-Package FirebaseAdmin -Version 3.1.0

Alternativ können Sie es mit dem dotnet-Befehlszeilentool installieren:

dotnet add package FirebaseAdmin --version 3.1.0

Sie können es auch installieren, indem Sie der Datei .csproj den folgenden Paketverweis hinzufügen:

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

SDK initialisieren

Nachdem Sie ein Firebase-Projekt erstellt haben, können Sie das SDK mit den Standardanmeldedaten für Google-Anwendungen initialisieren. Da die Suche nach Standardanmeldedaten in Google-Umgebungen vollständig automatisiert ist und keine Umgebungsvariablen oder andere Konfigurationen angegeben werden müssen, wird diese Methode zum Initialisieren des SDKs für Anwendungen empfohlen, die in Google-Umgebungen wie Cloud Run, App Engine und Cloud Functions ausgeführt werden.

Wenn Sie optional Initialisierungsoptionen für Dienste wie Realtime Database, Cloud Storage oder Cloud Functions angeben möchten, verwenden Sie die Umgebungsvariable FIREBASE_CONFIG. Wenn der Inhalt der Variablen FIREBASE_CONFIG mit einem { beginnt, wird er als JSON-Objekt geparst. Andernfalls geht das SDK davon aus, dass der String der Pfad zu einer JSON-Datei mit den Optionen ist.

Node.js

const app = initializeApp();

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)
}
init.go

C#

FirebaseApp.Create();

Nach der Initialisierung können Sie die Admin SDK für die folgenden Aufgaben verwenden:

OAuth 2.0-Aktualisierungstoken verwenden

Die Admin SDK stellt auch Anmeldedaten bereit, mit denen Sie sich mit einem Google OAuth2-Aktualisierungstoken authentifizieren können:

Node.js

const myRefreshToken = '...'; // Get refresh token from OAuth2 flow

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

Java

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

Python

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

Go

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)
}
init.go

C#

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

SDK in nicht von Google stammenden Umgebungen initialisieren

Wenn Sie in einer Serverumgebung eines Drittanbieters arbeiten, in der die Suche nach Standardanmeldedaten nicht vollständig automatisiert werden kann, können Sie das SDK mit einer exportierten Dienstkontoschlüsseldatei initialisieren.

Firebase-Projekte unterstützen Google-Dienstkonten, mit denen Sie Firebase-Server-APIs von Ihrem App-Server oder einer vertrauenswürdigen Umgebung aus aufrufen können. Wenn Sie Code lokal entwickeln oder Ihre Anwendung vor Ort bereitstellen, können Sie über dieses Dienstkonto abgerufene Anmeldedaten verwenden, um Serveranfragen zu autorisieren.

Wenn Sie ein Dienstkonto authentifizieren und autorisieren möchten, auf Firebase-Dienste zuzugreifen, müssen Sie eine private Schlüsseldatei im JSON-Format generieren.

So generieren Sie eine private Schlüsseldatei für Ihr Dienstkonto:

  1. Öffnen Sie in der Firebase-Konsole Einstellungen > Dienstkonten.

  2. Klicke auf Neuen privaten Schlüssel generieren und bestätige die Aktion mit einem Klick auf Schlüssel generieren.

  3. Speichern Sie die JSON-Datei mit dem Schlüssel sicher.

Wenn Sie die Autorisierung über ein Dienstkonto vornehmen, haben Sie zwei Möglichkeiten, die Anmeldedaten für Ihre Anwendung bereitzustellen. Sie können entweder die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS festlegen oder den Pfad zum Dienstkontoschlüssel explizit im Code übergeben. Die erste Option ist sicherer und wird dringend empfohlen.

So legen Sie die Umgebungsvariable fest:

Legen Sie die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS auf den Pfad der JSON-Datei fest, die Ihren Dienstkontoschlüssel enthält. Diese Variable gilt nur für Ihre aktuelle Shell-Sitzung. Wenn Sie eine neue Sitzung öffnen, müssen Sie die Variable noch einmal festlegen.

Linux oder macOS

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

Windows

Mit PowerShell:

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

Nachdem Sie die oben genannten Schritte ausgeführt haben, können Ihre Anmeldedaten ermittelt werden, sodass Sie Dienstkontoanmeldedaten verwenden können, wenn Sie die Anwendung in Umgebungen testen oder ausführen, die nicht von Google stammen.

Initialisieren Sie das SDK wie hier gezeigt:

Node.js

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

Java

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

FirebaseApp.initializeApp(options);

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)
}
init.go

C#

FirebaseApp.Create(new AppOptions()
{
    Credential = GoogleCredential.GetApplicationDefault(),
    ProjectId = "my-project-id",
});

FirebaseAppSnippets.cs

Mehrere Apps initialisieren

In den meisten Fällen müssen Sie nur eine einzelne Standard-App initialisieren. Sie haben zwei Möglichkeiten, über diese App auf Dienste zuzugreifen:

Node.js

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

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

// Retrieve services via the defaultApp variable...
let defaultAuth = getAuth(defaultApp);
let defaultDatabase = getDatabase(defaultApp);

// ... or use the equivalent shorthand notation
defaultAuth = getAuth();
defaultDatabase = getDatabase();

Java

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

Python

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

Go

// 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)
}
init.go

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;

Bei einigen Anwendungsfällen müssen Sie mehrere Apps gleichzeitig erstellen. Beispielsweise können Sie Daten aus der Realtime Database eines Firebase-Projekts lesen und benutzerdefinierte Tokens für ein anderes Projekt erstellen. Oder Sie möchten zwei Apps mit separaten Anmeldedaten authentifizieren. Mit dem Firebase SDK können Sie mehrere Apps gleichzeitig erstellen, jede mit eigenen Konfigurationsinformationen.

Node.js

// Initialize the default app
initializeApp(defaultAppConfig);

// Initialize another app with a different config
var otherApp = initializeApp(otherAppConfig, 'other');

console.log(getApp().name);  // '[DEFAULT]'
console.log(otherApp.name);     // 'other'

// Use the shorthand notation to retrieve the default app's services
const defaultAuth = getAuth();
const defaultDatabase = getDatabase();

// Use the otherApp variable to retrieve the other app's services
const otherAuth = getAuth(otherApp);
const otherDatabase = getDatabase(otherApp);

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

Bereiche für Realtime Database und Authentication festlegen

Wenn Sie eine Google Compute Engine-VM mit Standardanmeldedaten für Google-Anwendungen für Realtime Database oder Authentication verwenden, müssen Sie auch die richtigen Zugriffsbereiche festlegen. Für Realtime Database und Authentication sind Bereiche erforderlich, die auf userinfo.email und entweder cloud-platform oder firebase.database enden. Wenn Sie die vorhandenen Zugriffsbereiche prüfen und ändern möchten, führen Sie die folgenden Befehle mit gcloud aus.

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"

Mit gcloud-Anmeldedaten von Endnutzern testen

Wenn Sie die Admin SDK lokal mit den Standardanmeldedaten für Google-Anwendungen testen, die Sie durch Ausführen von gcloud auth application-default login erhalten haben, sind für die Verwendung von Firebase Authentication zusätzliche Änderungen erforderlich:

  • Firebase Authentication akzeptiert keine gcloud-Endnutzeranmeldedaten, die mit der gcloud-OAuth-Client-ID generiert wurden.
  • Für diese Art von Endnutzeranmeldedaten muss bei der Initialisierung die Projekt-ID angegeben werden.Firebase Authentication

Als Problemumgehung können Sie in gcloud Standardanmeldedaten für Google-Anwendungen mit Ihrer eigenen OAuth 2.0-Client-ID generieren. Die OAuth-Client-ID muss eine Desktop-Anwendung sein.

gcloud

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

Sie können die Projekt-ID bei der App-Initialisierung explizit angeben oder einfach die Umgebungsvariable GOOGLE_CLOUD_PROJECT verwenden. Letzteres verhindert, dass Sie zusätzliche Änderungen vornehmen müssen, um Ihren Code zu testen.

So geben Sie die Projekt-ID explizit an:

Node.js

import { initializeApp, applicationDefault } from 'firebase-admin/app';

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

Java

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

FirebaseApp.initializeApp(options);

Python

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

Go

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>",
});

Nächste Schritte

Weitere Informationen zu Firebase:

Fügen Sie Ihrer App Firebase-Funktionen hinzu: