Google setzt sich dafür ein, die Rassengerechtigkeit für schwarze Gemeinschaften zu fördern. Siehe wie.
Diese Seite wurde von der Cloud Translation API übersetzt.
Switch to English

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

Mit dem Admin SDK können Sie aus privilegierten Umgebungen mit Firebase interagieren, um folgende Aktionen auszuführen:

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

Wenn Sie das Node.js-SDK als Client für den Endbenutzerzugriff verwenden möchten (z. B. in einem Node.js-Desktop oder einer IoT-Anwendung), im Gegensatz zum Administratorzugriff aus einer privilegierten Umgebung (wie einem Server), sind Sie 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 Token-Prägung
ID-Token-Überprüfung
Benutzerverwaltung
Kontrollieren Sie den Zugriff mit benutzerdefinierten Ansprüchen
Token-Widerruf aktualisieren
Benutzer importieren
Sitzungscookie-Verwaltung
Generieren von E-Mail-Aktionslinks
Verwalten von SAML / OIDC-Anbieterkonfigurationen
Mandantenfähigkeitsunterstützung
Echtzeitdatenbank * *
Firebase Cloud Messaging
FCM Multicast
Verwalten von FCM-Themenabonnements
Cloud-Speicher
Cloud Firestore
Projektmanagement
Sicherheitsregeln
ML-Modellverwaltung
Firebase Remote Config

Weitere Informationen zur Admin SDK-Integration für diese Zwecke finden Sie in der entsprechenden Dokumentation zu Echtzeitdatenbank , FCM , Authentifizierung und Cloud-Speicher . Der Rest dieser Seite konzentriert sich auf die Grundeinstellungen für das 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 10.10.0+
    • Admin Java SDK - Java 7+ (empfehlen Java 8+)
      Java 7-Unterstützung ist veraltet.
    • Admin Python SDK - Python 3.5+
    • Admin Go SDK - Go 1.11+
    • Admin .NET SDK - .NET Framework 4.5+ oder .Net Core 1.5+

Richten Sie ein Firebase-Projekt- und Dienstkonto ein

Um das Firebase Admin SDK verwenden zu können, 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.

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 ab npm verfügbar. Wenn Sie noch keine package.json Datei haben, erstellen Sie eine über npm init . Installieren Sie als Nächstes das Paket package.json firebase-admin npm und speichern Sie 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:

 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 als Abhängigkeit in Ihrer build.gradle Datei:

 dependencies {
  implementation 'com.google.firebase:firebase-admin:6.15.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>6.15.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
 

Sie können die Bibliothek auch 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 1.15.0
 

Alternativ können Sie es mit dem dotnet installieren:

 $ dotnet add package FirebaseAdmin --version 1.15.0
 

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

 <ItemGroup>
  <PackageReference Include="FirebaseAdmin" Version="1.15.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 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 aus aufrufen können. Wenn Sie Code lokal entwickeln oder Ihre Anwendung lokal bereitstellen, können Sie über dieses Dienstkonto erhaltene 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. Öffnen Sie in der Firebase-Konsole Einstellungen> Dienstkonten .

  2. Klicken Sie auf Neuen privaten Schlüssel generieren und bestätigen Sie mit Klicken auf Schlüssel generieren .

  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 explizit an den Dienstkontoschlüssel im Code übergeben. Die erste Option ist sicherer und wird dringend empfohlen.

So legen Sie die Umgebungsvariable fest:

Setzen Sie die Umgebungsvariable GOOGLE_APPLICATION_CREDENTIALS auf den Dateipfad der JSON-Datei, 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 Umgebungen, die nicht von Google stammen, die Anmeldeinformationen des Dienstkontos verwenden können.

Initialisieren Sie das SDK wie folgt:

Node.js

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

Java

 FirebaseOptions options = new 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 außerdem einen Berechtigungsnachweis, mit dem Sie sich mit einem Google OAuth2- Aktualisierungstoken authentifizieren können:

Node.js

 var 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 = new 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 der Google-Anwendung und liest Optionen aus der Umgebungsvariablen FIREBASE_CONFIG . Wenn der Inhalt der Variablen FIREBASE_CONFIG mit einem { beginnt, wird sie als JSON-Objekt analysiert. Andernfalls geht das SDK davon aus, dass die Zeichenfolge der Name einer JSON-Datei ist, die die Optionen enthält.

Node.js

 // Initialize the default app
var admin = require('firebase-admin');
var 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 Arten von Aufgaben auszuführen:

Initialisieren Sie mehrere Apps

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

Node.js

 // Initialize the default app
var defaultApp = admin.initializeApp(defaultAppConfig);

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

// Retrieve services via the defaultApp variable...
var defaultAuth = defaultApp.auth();
var 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. Beispielsweise möchten Sie möglicherweise Daten aus der Echtzeitdatenbank eines Firebase-Projekts lesen und benutzerdefinierte Token für ein anderes Projekt neu erstellen. Oder Sie möchten möglicherweise zwei Apps mit separaten Anmeldeinformationen authentifizieren. Mit dem Firebase SDK können Sie mehrere Apps gleichzeitig mit jeweils eigenen Konfigurationsinformationen erstellen.

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
var defaultAuth = admin.auth();
var defaultDatabase = admin.database();

// Use the otherApp variable to retrieve the other app's services
var otherAuth = otherApp.auth();
var 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);
 

Legen Sie Bereiche für die Echtzeitdatenbank und -authentifizierung fest

Wenn Sie eine Google Compute Engine-VM mit Standardanmeldeinformationen für die Google-Anwendung für die Echtzeitdatenbank oder -authentifizierung verwenden, müssen Sie auch die richtigen Zugriffsbereiche festlegen . Für Echtzeit - Datenbank und Authentifizierung, müssen Sie Bereiche in endend userinfo.email und jede 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

Erfahren Sie mehr über Firebase:

Fügen Sie Ihrer App Firebase-Funktionen hinzu: