Fügen Sie das Firebase Admin SDK zu Ihrem Server hinzu

Das Admin SDK besteht aus einer Reihe von Serverbibliotheken, mit denen Sie aus privilegierten Umgebungen mit Firebase interagieren können, um Aktionen auszuführen wie:

  • Lesen und schreiben Sie Echtzeitdatenbankdaten mit vollständigen Administratorrechten.
  • Senden Sie Firebase Cloud Messaging-Nachrichten programmgesteuert mit einem einfachen, alternativen Ansatz zu den Firebase Cloud Messaging-Serverprotokollen.
  • Generieren und überprüfen Sie Firebase-Authentifizierungstoken.
  • Greifen Sie auf Google Cloud-Ressourcen wie Cloud Storage-Buckets und Cloud Firestore-Datenbanken zu, die Ihren Firebase-Projekten zugeordnet sind.
  • Erstellen Sie Ihre eigene vereinfachte Admin-Konsole, um beispielsweise Benutzerdaten nachzuschlagen oder die E-Mail-Adresse eines Benutzers zur Authentifizierung zu ändern.

Wenn Sie daran interessiert sind, das Node.js SDK als Client für den Endbenutzerzugriff (z. B. in einem Node.js-Desktop oder einer IoT-Anwendung) zu verwenden, im Gegensatz zum Administratorzugriff aus einer privilegierten Umgebung (wie einem Server), sind Sie hier genau richtig Stattdessen sollten Sie den Anweisungen zum Einrichten des Client-JavaScript-SDK folgen.

Hier ist eine Funktionsmatrix, die zeigt, welche Firebase-Funktionen in den einzelnen Sprachen unterstützt werden:

Besonderheit Node.js Java Python Gehen C#
Benutzerdefinierte Token-Prägung
Überprüfung des ID-Tokens
Benutzerverwaltung
Kontrollieren Sie den Zugriff mit benutzerdefinierten Ansprüchen
Widerruf des Aktualisierungstokens
Benutzer importieren
Sitzungs-Cookie-Verwaltung
Generieren von E-Mail-Aktionslinks
Verwalten von SAML/OIDC-Anbieterkonfigurationen
Unterstützung für mehrere Mandanten
Echtzeitdatenbank *
Firebase Cloud-Messaging
FCM-Multicast
FCM-Themenabonnements verwalten
Cloud-Speicher
Cloud Firestore
Projektmanagement
Sicherheitsregeln
ML-Modellmanagement
Firebase-Remote-Konfiguration
Firebase-App-Check
Firebase-Erweiterungen

Weitere Informationen zur Admin SDK-Integration für diese Verwendungszwecke finden Sie in der entsprechenden Dokumentation zu Realtime Database , FCM , Authentication , Remote Config und Cloud Storage . Der Rest dieser Seite konzentriert sich auf die grundlegende Einrichtung des Admin SDK.

Voraussetzungen

  • Stellen Sie sicher, dass Sie über eine Server-App verfügen.

  • Stellen Sie sicher, dass auf Ihrem Server Folgendes ausgeführt wird, je nachdem, welches Admin SDK Sie verwenden:

    • Admin Node.js SDK – Node.js 14+ (empfehlen Node.js 16+)
      Die Unterstützung von Node.js 14 ist veraltet.
    • Admin Java SDK – Java 8+
    • Admin Python SDK – Python 3.7+ (empfehlen Python 3.8+)
      Die Unterstützung für Python 3.7 ist veraltet.
    • Admin Go SDK – Go 1.17+
    • Admin .NET SDK – .NET Framework 4.6.1+ oder .NET Standard 2.0 für .Net Core 2.0+

Richten Sie ein Firebase-Projekt und ein Dienstkonto ein

Um das Firebase Admin SDK verwenden zu können, benötigen Sie Folgendes:

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

Wenn Sie noch kein Firebase-Projekt haben, müssen Sie eines in der Firebase-Konsole erstellen. Besuchen Sie „Firebase-Projekte verstehen“ , um mehr über Firebase-Projekte zu erfahren.

Fügen Sie das SDK hinzu

Wenn Sie ein neues Projekt einrichten, müssen Sie das SDK für die Sprache Ihrer Wahl 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 über npm init . Als nächstes installieren Sie das firebase-admin npm-Paket und speichern es in Ihrer package.json :

npm install firebase-admin --save

Um das Modul in Ihrer Anwendung zu verwenden, require es aus einer beliebigen JavaScript-Datei an:

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

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

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

Java

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

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

Wenn Sie Maven zum Erstellen Ihrer Anwendung verwenden, können Sie die folgende Abhängigkeit zu Ihrer pom.xml hinzufügen:

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

Python

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

sudo pip install firebase-admin

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

pip install --user firebase-admin

Gehen

Das Go Admin SDK kann mit dem go install Dienstprogramm installiert werden:

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

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

C#

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

Install-Package FirebaseAdmin -Version 2.4.0

Alternativ können Sie es mit dem Befehlszeilenprogramm dotnet installieren:

dotnet add package FirebaseAdmin --version 2.4.0

Oder Sie können es installieren, indem Sie den folgenden Paketverweiseintrag zu Ihrer .csproj Datei hinzufügen:

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

Initialisieren Sie das SDK

Sobald Sie ein Firebase-Projekt erstellt haben, können Sie das SDK mit den Google Application Default Credentials initialisieren. Da die Suche nach Standardanmeldeinformationen in Google-Umgebungen vollständig automatisiert ist und keine Umgebungsvariablen oder andere Konfigurationen bereitgestellt werden müssen, wird diese Art der Initialisierung des SDK dringend für Anwendungen empfohlen, die in Google-Umgebungen wie Cloud Run, App Engine und Cloud Functions ausgeführt werden.

Um optional Initialisierungsoptionen für Dienste wie Realtime Database, Cloud Storage oder Cloud Functions anzugeben, 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 es sich bei der Zeichenfolge um den Pfad einer JSON-Datei handelt, die die Optionen enthält.

Node.js

const app = initializeApp();

Java

FirebaseApp.initializeApp();

Python

default_app = firebase_admin.initialize_app()

Gehen

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

C#

FirebaseApp.Create();

Sobald es initialisiert ist, können Sie das Admin SDK verwenden, um die folgenden Arten von Aufgaben auszuführen:

Verwendung eines OAuth 2.0-Aktualisierungstokens

Das Admin SDK stellt außerdem Anmeldeinformationen 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)

Gehen

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

Initialisieren Sie das SDK in Nicht-Google-Umgebungen

Wenn Sie in einer Nicht-Google-Serverumgebung arbeiten, in der die Suche nach Standardanmeldeinformationen 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 Ihrer vertrauenswürdigen Umgebung aus aufrufen können. Wenn Sie Code lokal entwickeln oder Ihre Anwendung lokal bereitstellen, können Sie die über dieses Dienstkonto erhaltenen Anmeldeinformationen verwenden, um Serveranfragen zu autorisieren.

Um ein Dienstkonto zu authentifizieren und es für den Zugriff auf Firebase-Dienste zu autorisieren, 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. Klicken Sie auf „Neuen privaten Schlüssel generieren“ und bestätigen Sie dann, indem Sie auf „Schlüssel generieren“ klicken.

  3. Speichern Sie die JSON-Datei, die den Schlüssel enthält, sicher.

Bei der Autorisierung über ein Dienstkonto haben Sie zwei Möglichkeiten, die Anmeldeinformationen 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 Dateipfad der JSON-Datei fest, die Ihren Dienstkontoschlüssel enthält. Diese Variable gilt nur für Ihre aktuelle Shell-Sitzung. Wenn Sie also eine neue Sitzung öffnen, legen Sie die Variable erneut fest.

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, kann Application Default Credentials (ADC) Ihre Anmeldeinformationen implizit ermitteln, sodass Sie beim Testen oder Ausführen in Nicht-Google-Umgebungen Dienstkonto-Anmeldeinformationen verwenden können.

Initialisieren Sie das SDK wie 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()

Gehen

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(),
    ProjectId = "my-project-id",
});

Initialisieren Sie mehrere Apps

In den meisten Fällen müssen Sie nur eine einzige Standard-App initialisieren. Sie können über diese App auf zwei gleichwertige Arten auf Dienste zugreifen:

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

Gehen

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

In einigen Anwendungsfällen müssen Sie mehrere Apps gleichzeitig erstellen. Beispielsweise möchten Sie möglicherweise Daten aus der Echtzeitdatenbank eines Firebase-Projekts lesen und benutzerdefinierte Token für ein anderes Projekt erstellen. Oder Sie möchten möglicherweise zwei Apps mit unterschiedlichen Anmeldeinformationen authentifizieren. Mit dem Firebase SDK können Sie mehrere Apps gleichzeitig erstellen, jede mit ihren 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)

Gehen

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

Legen Sie Bereiche für Echtzeitdatenbank und Authentifizierung fest

Wenn Sie eine Google Compute Engine-VM mit Google Application-Standardanmeldeinformationen für die Echtzeitdatenbank oder Authentifizierung verwenden, stellen Sie sicher, dass Sie auch die richtigen Zugriffsbereiche festlegen. Für die Echtzeitdatenbank und Authentifizierung benötigen Sie Bereiche, die auf userinfo.email und entweder cloud-platform oder firebase.database enden. Um die vorhandenen Zugriffsbereiche zu überprüfen und zu ändern, 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"

Testen mit gcloud-Endbenutzeranmeldeinformationen

Beim lokalen Testen des Admin SDK mit den Google Application-Standardanmeldeinformationen , die durch Ausführen von gcloud auth application-default login abgerufen wurden, sind aus folgenden Gründen zusätzliche Änderungen erforderlich, um die Firebase-Authentifizierung zu verwenden:

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

Um dieses Problem zu umgehen, können Sie in gcloud mithilfe Ihrer eigenen OAuth 2.0-Client-ID Standardanmeldeinformationen für Google-Anwendungen generieren. Die OAuth-Client-ID muss ein Desktop-App- Anwendungstyp sein.

gcloud

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

Sie können die Projekt-ID explizit bei der App-Initialisierung angeben oder einfach die Umgebungsvariable GOOGLE_CLOUD_PROJECT verwenden. Letzteres vermeidet die Notwendigkeit, zusätzliche Änderungen zum Testen Ihres Codes vorzunehmen.

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)

Gehen

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

Erfahren Sie mehr über Firebase:

Fügen Sie Ihrer App Firebase-Funktionen hinzu: