Fügen Sie das Firebase Admin SDK zu Ihrem Server 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. B. in einem Node.js-Desktop oder einer IoT-Anwendung) anstelle des Administratorzugriffs aus einer privilegierten Umgebung (z sollte stattdessen die folgen Anweisungen , um den Client - JavaScript SDK für die Einrichtung .

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

Besonderheit 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 über die Admin SDK - Integration für diese Anwendungen finden Sie in der entsprechenden Echtzeit - Datenbank , FCM , Authentifizierung , Remote - Konfiguration und Cloud Storage - Dokumentation. 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 nicht bereits über ein Projekt Firebase haben, müssen Sie eine in der erstellen Firebase Konsole . Besuchen Sie verstehen Firebase Projekte mehr über Projekte Firebase zu lernen.

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 keinen haben package.json Datei, erstellen Sie über npm init . Als nächstes installieren Sie das firebase-admin npm Paket und es speichern package.json :

$ npm install firebase-admin --save

Um das Modul in Ihrer Anwendung zu verwenden, require sie von jeder JavaScript - Datei:

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

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

import * as admin from 'firebase-admin';

Java

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

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

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

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

Python

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

$ sudo pip install firebase-admin

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

$ pip install --user firebase-admin

gehen

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

# 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 installieren Sie die Verwendung von dotnet - Befehlszeilenprogramm:

$ dotnet add package FirebaseAdmin --version 2.2.0

Oder können Sie es installieren , indem Sie das folgende Paket Referenzeintrag auf Ihre Zugabe .csproj Datei:

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

Initialisieren des SDK

Sobald Sie ein Projekt Firebase erstellt haben, können Sie das SDK mit einer Berechtigungsstrategie initialisieren , die Ihre Dienstkonto - Datei zusammen mit kombiniert Google - Anwendung Standard - Anmeldeinformationen .

Firebase Projekte unterstützen Google Dienstkonten , die Sie Firebase Server aufrufen APIs von Ihrem App - Server oder vertrauenswürdigen Umgebung verwenden können. Wenn Sie Code lokal entwickeln oder Ihre Anwendung lokal bereitstellen, können Sie die über dieses Dienstkonto abgerufenen Anmeldeinformationen verwenden, um Serveranforderungen 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. In der Firebase Konsole, öffnen Sie Einstellungen> Dienstkonten .

  2. Generieren Klicken Sie auf Neu Private Key, dann bestätigen Sie 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 eingestellte GOOGLE_APPLICATION_CREDENTIALS Umgebungsvariable, oder Sie können explizit den Pfad zu dem Dienstkonto Schlüssel 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 , die Ihr Dienstkonto Schlü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

Die Admin - SDK stellt auch eine Berechtigung , die Sie mit einem zur Authentifizierung ermöglicht Google OAuth2 Aktualisierungs - Token:

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 Standardanmeldeinformationen Google - Anwendung . 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 angeben Initialisierungsoptionen für Dienste wie Echtzeit - Datenbank, Cloud Storage, oder Cloud - Funktionen, verwenden Sie die FIREBASE_CONFIG Umgebungsvariable. Wenn der Inhalt des FIREBASE_CONFIG Variable mit einem beginnt { wird es als JSON - Objekt analysiert werden. 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 einen Google Compute Engine - VM mit Google - Anwendung Standard - Anmeldeinformationen für Echtzeit - Datenbank oder Authentifizierung verwenden, stellen Sie sicher, auch die richtigen Zugriffsumfänge . Für Echtzeit - Datenbank und Authentifizierung, müssen Sie Bereiche in endend userinfo.email und jede cloud-platform oder firebase.database . Um die vorhandenen Zugriffs Bereiche zu überprüfen und ändern, führen Sie die folgenden Befehle mit 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"

Testen mit gcloud-Endnutzer-Anmeldedaten

Wenn die Admin SDK Testen lokal mit Google - gcloud auth application-default login Anwendung Standardanmeldeinformationen erhalten , indem Sie gcloud auth application-default login - gcloud auth application-default login , sind weitere Änderungen erforderlich aufgrund der folgenden Firebase - Authentifizierung zu verwenden:

  • Firebase Authentication akzeptiert keine gcloud-Endnutzeranmeldeinformationen, die mit der gcloud-OAuth-Client-ID generiert wurden.
  • Firebase Authentication erfordert, dass die Projekt-ID bei der Initialisierung für diese Art von Endbenutzeranmeldeinformationen bereitgestellt wird.

Als Abhilfe können Sie Google - Anwendung Standard - Anmeldeinformationen in generieren gcloud mit Ihrer eigenen OAuth 2.0 - Client - ID . Die OAuth - Client - ID verfügt über einen Desktop - App Anwendungstyp sein.

gcloud

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

Sie können das Projekt ID explizit auf App - Initialisierung angeben oder einfach nur die Verwendung GOOGLE_CLOUD_PROJECT Umgebungsvariable. Letzteres vermeidet die Notwendigkeit, zusätzliche Änderungen vorzunehmen, um Ihren Code zu testen.

So geben Sie die Projekt-ID explizit an:

Node.js

admin.initializeApp({
  credential: admin.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

Weitere Informationen zu Firebase:

Fügen Sie Ihrer App Firebase-Funktionen hinzu: