Join us in person and online for Firebase Summit on October 18, 2022. Learn how Firebase can help you accelerate app development, release your app with confidence, and scale with ease. Register now

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

Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.

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

  • Lesen und schreiben Sie Realtime Database-Daten mit vollen 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 mit Ihren Firebase-Projekten verknüpft sind.
  • Erstellen Sie Ihre eigene vereinfachte Verwaltungskonsole, 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 einer Node.js-Desktop- oder IoT-Anwendung) zu verwenden, im Gegensatz zum Administratorzugriff von einer privilegierten Umgebung (wie einem Server), können Sie sollten stattdessen den Anweisungen zum Einrichten des Client-JavaScript-SDK folgen.

Hier ist eine Funktionsmatrix, die zeigt, welche Firebase-Funktionen in jeder Sprache unterstützt werden:

Feature Node.js Java Python gehen C#
Benutzerdefiniertes Token-Minting
ID-Token-Überprüfung
Benutzerverwaltung
Kontrollieren Sie den Zugriff mit benutzerdefinierten Ansprüchen
Token-Widerruf aktualisieren
Benutzer importieren
Verwaltung von Sitzungscookies
Generieren von E-Mail-Aktionslinks
Verwalten von SAML/OIDC-Anbieterkonfigurationen
Unterstützung mehrerer Mandanten
Echtzeit-Datenbank *
Firebase Cloud Messaging
FCM-Multicast
FCM-Themenabonnements verwalten
Cloud-Speicher
Cloud-Firestore
Projektmanagement
Sicherheitsregeln
ML-Modellverwaltung
Firebase-Remote-Konfiguration
Firebase-App-Check

Um mehr über die Admin SDK-Integration für diese Verwendungszwecke zu erfahren, lesen Sie die entsprechende 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 eine Server-App haben.

  • 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+
    • Admin-Java-SDK – Java 8+
    • Admin Python SDK – Python 3.6+ (empfohlen wird Python 3.7+)
    • Admin Go-SDK – Go 1.15+
    • 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

Zur Verwendung des 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 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 . Installieren Sie als Nächstes das npm-Paket firebase firebase-admin und speichern Sie es in Ihrer package.json :

$ npm install firebase-admin --save

Um das Modul in Ihrer Anwendung zu verwenden, require Sie es von 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.0.0'
}

Wenn Sie Ihre 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.0.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 :

$ pip install --user firebase-admin

gehen

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

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

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

C#

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

$ Install-Package FirebaseAdmin -Version 2.3.0

Installieren Sie es alternativ mit dem dotnet -Befehlszeilendienstprogramm:

$ dotnet add package FirebaseAdmin --version 2.3.0

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

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

Initialisieren Sie das SDK

Nachdem Sie ein Firebase-Projekt erstellt haben, können Sie das SDK mit einer Autorisierungsstrategie initialisieren, die Ihre Dienstkontodatei mit den Standardanmeldeinformationen für Google-Anwendungen kombiniert.

Firebase-Projekte unterstützen Google -Dienstkonten , mit denen Sie Firebase-Server-APIs von Ihrem App-Server oder Ihrer vertrauenswürdigen Umgebung aufrufen können. Wenn Sie Code lokal entwickeln oder Ihre Anwendung lokal bereitstellen, können Sie Anmeldeinformationen verwenden, die Sie über dieses Dienstkonto erhalten haben, um Serveranforderungen zu autorisieren.

Um ein Dienstkonto zu authentifizieren und 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 mit dem Schlüssel 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 oder den Pfad zum Schlüssel des Dienstkontos 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"

Fenster

Mit PowerShell:

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

Nachdem Sie die obigen Schritte ausgeführt haben, kann Application Default Credentials (ADC) Ihre Anmeldedaten implizit bestimmen, sodass Sie beim Testen oder Ausführen in Nicht-Google-Umgebungen Dienstkonto-Anmeldedaten 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(),
});

Verwenden eines OAuth 2.0-Aktualisierungstokens

Das Admin SDK stellt auch einen Berechtigungsnachweis bereit, mit dem 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"),
});

Ohne Parameter initialisieren

Das SDK kann auch ohne Parameter initialisiert werden. In diesem Fall verwendet das SDK die Standardanmeldeinformationen für Google-Anwendungen . Da die Suche nach Standardanmeldeinformationen in Google-Umgebungen vollständig automatisiert ist, ohne dass Umgebungsvariablen oder andere Konfigurationen bereitgestellt werden müssen, wird diese Art der SDK-Initialisierung dringend für Anwendungen empfohlen, die auf Compute Engine, Kubernetes Engine, 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 Variable FIREBASE_CONFIG mit einem { beginnt, wird er als JSON-Objekt geparst. Andernfalls geht das SDK davon aus, dass die Zeichenfolge der Pfad einer JSON-Datei ist, 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();

Nach der Initialisierung können Sie das Admin SDK verwenden, um die folgenden Arten von Aufgaben auszuführen:

Initialisieren Sie mehrere Apps

In den meisten Fällen müssen Sie nur eine einzelne Standard-App initialisieren. Sie können von dieser App aus 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;

Einige Anwendungsfälle erfordern, dass 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 zwei Apps mit separaten 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 die Echtzeitdatenbank und die Authentifizierung fest

Wenn Sie eine Google Compute Engine-VM mit Standardanmeldedaten für Google-Anwendungen für die Echtzeitdatenbank oder -authentifizierung verwenden, achten Sie darauf, auch die richtigen Zugriffsbereiche festzulegen . Für Echtzeitdatenbank und -authentifizierung benötigen Sie Bereiche, die auf userinfo.email enden, und entweder cloud-platform oder firebase.database . Führen Sie die folgenden Befehle mit gcloud aus, um die vorhandenen Zugriffsbereiche zu überprüfen und zu ändern.

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-Anmeldedaten für Endnutzer

Beim lokalen Testen des Admin SDK mit Standardanmeldeinformationen für Google-Anwendungen , 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.
  • Die Firebase-Authentifizierung erfordert, dass die Projekt-ID bei der Initialisierung für diese Art von Endbenutzeranmeldeinformationen bereitgestellt wird.

Als Problemumgehung können Sie Standardanmeldeinformationen für Google-Anwendungen in gcloud mit Ihrer eigenen OAuth 2.0-Client-ID 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: