Check out what’s new from Firebase@ Google I/O 2021, and join our alpha program for early access to the new Remote Config personalization feature. Learn more

Fügen Sie Ihrem Server das Firebase Admin SDK hinzu

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

  • Lesen und schreiben Sie Echtzeit-Datenbankdaten mit vollen Administratorrechten.
  • Senden Sie Firebase Cloud Messaging-Nachrichten programmatisch mit einem einfachen, alternativen Ansatz zu den Firebase Cloud Messaging-Serverprotokollen.
  • Firebase-Authentifizierungstokens generieren und überprüfen.
  • 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 Admin-Konsole, um beispielsweise Benutzerdaten abzurufen oder die E-Mail-Adresse eines Benutzers zur Authentifizierung zu ändern.

Wenn Sie das Node.js-SDK als Client für den Endbenutzerzugriff (z Befolgen Sie stattdessen die Anweisungen zum Einrichten des Client-JavaScript-SDK .

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

Feature Node.js Java Python Gehen C#
Benutzerdefinierte Tokenprägung
ID-Token-Verifizierung
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
Multi-Tenancy-Unterstützung
Echtzeit-Datenbank *
Firebase Cloud-Messaging
FCM-Multicast
FCM-Themenabonnements verwalten
Cloud-Speicher
Cloud Firestore
Projektmanagement
Sicherheitsregeln
ML-Modellverwaltung
Firebase Remote-Konfiguration
Firebase-App-Check

Weitere Informationen zur Admin SDK-Integration für diese Verwendungen 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 für das Admin SDK.

Voraussetzungen

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

  • Stellen Sie sicher, dass auf Ihrem Server je nach verwendetem Admin-SDK Folgendes ausgeführt wird:

    • Admin Node.js SDK — Node.js 10.13.0+
    • Admin Java SDK – Java 7+ (empfohlen Java 8+)
      Die Unterstützung von Java 7 ist veraltet.
    • Python-SDK für Administratoren — Python 3.6+
    • Admin Go SDK — Go 1.11+
    • Admin .NET SDK – .NET Framework 4.5+ oder .Net Core 1.5+

Ein Firebase-Projekt und -Dienstkonto einrichten

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

  • Ein Firebase-Projekt
  • Ein Dienstkonto für die Kommunikation mit Firebase
  • 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.

SDK hinzufügen

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 package.json firebase-admin und speichern Sie es in Ihrer package.json :

$ npm install firebase-admin --save

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

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

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

import * as admin from 'firebase-admin';

Java

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

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

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

<dependency>
  <groupId>com.google.firebase</groupId>
  <artifactId>firebase-admin</artifactId>
  <version>7.3.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.2.0

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

$ dotnet add package FirebaseAdmin --version 2.2.0

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

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

Initialisieren des SDK

Nachdem Sie ein Firebase-Projekt erstellt haben, können Sie das SDK mit einer Autorisierungsstrategie initialisieren, die Ihre Dienstkontodatei mit den Standardanmeldedaten der Google-Anwendung kombiniert.

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

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 mit „ Schlüssel generieren“ .

  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 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:

GOOGLE_APPLICATION_CREDENTIALS 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 Anmeldeinformationen implizit ermitteln, sodass Sie die Anmeldeinformationen für Dienstkonten beim Testen oder Ausführen in Umgebungen außerhalb von Google verwenden können.

Initialisieren Sie das SDK wie gezeigt:

Node.js

admin.initializeApp({
    credential: admin.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 bietet auch Anmeldeinformationen, mit denen Sie sich mit einem Google OAuth2- Aktualisierungstoken authentifizieren können:

Node.js

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

admin.initializeApp({
  credential: admin.credential.refreshToken(refreshToken),
  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 Google Application Default Credentials . Da die standardmäßige Suche nach Anmeldedaten in Google-Umgebungen vollständig automatisiert ist, ohne dass Umgebungsvariablen oder andere Konfigurationen bereitgestellt werden müssen, wird diese Art der Initialisierung des SDK 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 FIREBASE_CONFIG , 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 die Zeichenfolge der Pfad einer JSON-Datei ist, die die Optionen enthält.

Node.js

const app = admin.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 Aufgabentypen auszuführen:

Mehrere Apps initialisieren

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

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

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. Sie können beispielsweise 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 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
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();

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

Bereiche für Echtzeitdatenbank und Authentifizierung festlegen

Wenn Sie eine Google Compute Engine-VM mit Standardanmeldeinformationen für Google-Anwendungen für die Echtzeitdatenbank oder Authentifizierung verwenden, stellen Sie sicher, dass Sie auch die richtigen Zugriffsbereiche festlegen Für Echtzeitdatenbank und Authentifizierung benötigen Sie Bereiche, die auf userinfo.email 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"

Nächste Schritte

Weitere Informationen zu Firebase:

Fügen Sie Ihrer App Firebase-Funktionen hinzu: