Einführung in die Admin Database API

Mit dem Admin SDK können Sie Realtime Database-Daten mit vollständigen Administratorberechtigungen oder mit detaillierteren eingeschränkten Berechtigungen lesen und schreiben. In diesem Dokument zeigen wir Ihnen, wie Sie Ihrem Projekt das Firebase Admin SDK hinzufügen, um auf die Firebase Realtime Database zuzugreifen.

Realtime Database-Instanzen können in verschiedenen geografischen Regionen mit separaten firebaseio.com- und firebasedatabase.app-URL-Schemas erstellt werden. Bei Admin SDK-Methoden zum Festlegen von URLs kann jedes dieser Schemas verwendet werden. Informationen zu derzeit unterstützten Regionen und URL-Schemas finden Sie im Leitfaden zum Auswählen von Standorten in Firebase-Projekten.

Admin SDK einrichten

Wenn Sie die Firebase Realtime Database auf Ihrem Server verwenden möchten, müssen Sie zuerst das Firebase Admin SDK in Ihrer gewünschten Sprache einrichten.

Wenn Sie das Node.js SDK als Client für den Endnutzerzugriff verwenden möchten (z. B. in einer Node.js-Desktop- oder IoT-Anwendung), anstatt den Administratorzugriff aus einer privilegierten Umgebung (z. B. einem Server) zu verwenden, folgen Sie stattdessen der Anleitung zum Einrichten des Client JavaScript SDK.

Admin SDK-Authentifizierung

Bevor Sie mit dem Firebase Admin SDK von einem Server auf die Firebase Realtime Database zugreifen können, müssen Sie Ihren Server bei Firebase authentifizieren. Wenn Sie einen Server authentifizieren, melden Sie sich nicht wie in einer Client-App mit den Anmeldedaten eines Nutzerkontos an, sondern mit einem Dienstkonto, das Ihren Server bei Firebase identifiziert.

Wenn Sie sich mit dem Firebase Admin SDK authentifizieren, können Sie zwei verschiedene Zugriffsebenen erhalten:

Auth-Zugriffsebenen für das Firebase Admin SDK
Administratorberechtigungen	Vollständiger Lese- und Schreibzugriff auf die Realtime Database eines Projekts. Verwenden Sie diese Option mit Vorsicht, um administrative Aufgaben wie die Datenmigration oder -strukturierung auszuführen, für die uneingeschränkter Zugriff auf die Ressourcen Ihres Projekts erforderlich ist.
Eingeschränkte Berechtigungen	Zugriff auf die Realtime Database eines Projekts, beschränkt auf die Ressourcen, die Ihr Server benötigt. Verwenden Sie diese Ebene, um administrative Aufgaben mit klar definierten Zugriffsanforderungen auszuführen. Wenn Sie beispielsweise einen Summarisierungsjob ausführen, der Daten aus der gesamten Datenbank liest, können Sie sich vor versehentlichen Schreibvorgängen schützen, indem Sie eine schreibgeschützte Sicherheitsregel festlegen und dann das Admin SDK mit Berechtigungen initialisieren, die durch diese Regel eingeschränkt sind.

Mit Administratorberechtigungen authentifizieren

Wenn Sie das Firebase Admin SDK mit den Anmeldedaten für ein Dienstkonto mit der Rolle Bearbeiter in Ihrem Firebase-Projekt initialisieren, hat diese Instanz vollen Lese- und Schreibzugriff auf die Realtime Database Ihres Projekts.

Java

// Fetch the service account key JSON file contents
FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccount.json");

// Initialize the app with a service account, granting admin privileges
FirebaseOptions options = FirebaseOptions.builder()
    .setCredentials(GoogleCredentials.fromStream(serviceAccount))
    // The database URL depends on the location of the database
    .setDatabaseUrl("https://DATABASE_NAME.firebaseio.com")
    .build();
FirebaseApp.initializeApp(options);

// As an admin, the app has access to read and write all data, regardless of Security Rules
DatabaseReference ref = FirebaseDatabase.getInstance()
    .getReference("restricted_access/secret_document");
ref.addListenerForSingleValueEvent(new ValueEventListener() {
  @Override
  public void onDataChange(DataSnapshot dataSnapshot) {
    Object document = dataSnapshot.getValue();
    System.out.println(document);
  }

  @Override
  public void onCancelled(DatabaseError error) {
  }
});

Node.js

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

// Fetch the service account key JSON file contents
var serviceAccount = require("path/to/serviceAccountKey.json");

// Initialize the app with a service account, granting admin privileges
admin.initializeApp({
  credential: admin.credential.cert(serviceAccount),
  // The database URL depends on the location of the database
  databaseURL: "https://DATABASE_NAME.firebaseio.com"
});

// As an admin, the app has access to read and write all data, regardless of Security Rules
var db = admin.database();
var ref = db.ref("restricted_access/secret_document");
ref.once("value", function(snapshot) {
  console.log(snapshot.val());
});

Python

import firebase_admin
from firebase_admin import credentials
from firebase_admin import db

# Fetch the service account key JSON file contents
cred = credentials.Certificate('path/to/serviceAccountKey.json')

# Initialize the app with a service account, granting admin privileges
firebase_admin.initialize_app(cred, {
    'databaseURL': 'https://databaseName.firebaseio.com'
})

# As an admin, the app has access to read and write all data, regradless of Security Rules
ref = db.reference('restricted_access/secret_document')
print(ref.get())

Go

ctx := context.Background()
conf := &firebase.Config{
	DatabaseURL: "https://databaseName.firebaseio.com",
}
// Fetch the service account key JSON file contents
opt := option.WithCredentialsFile("path/to/serviceAccountKey.json")

// Initialize the app with a service account, granting admin privileges
app, err := firebase.NewApp(ctx, conf, opt)
if err != nil {
	log.Fatalln("Error initializing app:", err)
}

client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// As an admin, the app has access to read and write all data, regradless of Security Rules
ref := client.NewRef("restricted_access/secret_document")
var data map[string]interface{}
if err := ref.Get(ctx, &data); err != nil {
	log.Fatalln("Error reading from database:", err)
}
fmt.Println(data)

Ihr Dienst hat nur so viel Zugriff wie das Dienstkonto, mit dem er authentifiziert wurde. Sie können Ihren Dienst beispielsweise auf Lesezugriff beschränken, indem Sie ein Dienstkonto mit der Rolle „Leser“ für Ihr Projekt verwenden. Ein Dienstkonto ohne Rolle im Projekt kann ebenfalls keine Daten lesen oder schreiben.

Mit eingeschränkten Berechtigungen authentifizieren

Als Best Practice sollte ein Dienst nur auf die Ressourcen zugreifen können, die er benötigt. Wenn Sie die Ressourcen, auf die eine Firebase-App-Instanz zugreifen kann, genauer steuern möchten, verwenden Sie in Ihren Sicherheitsregeln eine eindeutige Kennung für Ihren Dienst. Richten Sie dann entsprechende Regeln ein, die Ihrem Dienst Zugriff auf die erforderlichen Ressourcen gewähren. Beispiel:

{
  "rules": {
    "public_resource": {
      ".read": true,
      ".write": true
    },
    "some_resource": {
      ".read": "auth.uid === 'my-service-worker'",
      ".write": false
    },
    "another_resource": {
      ".read": "auth.uid === 'my-service-worker'",
      ".write": "auth.uid === 'my-service-worker'"
    }
  }
}

Wenn Sie dann auf Ihrem Server die Firebase App initialisieren, verwenden Sie die Option databaseAuthVariableOverride, um das auth-Objekt zu überschreiben, das von Ihren Datenbankregeln verwendet wird. Legen Sie in diesem benutzerdefinierten auth-Objekt das Feld uid auf die Kennung fest, mit der Sie Ihren Dienst in Ihren Sicherheitsregeln dargestellt haben.

Java

// Fetch the service account key JSON file contents
FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccountCredentials.json");

// Initialize the app with a custom auth variable, limiting the server's access
Map<String, Object> auth = new HashMap<String, Object>();
auth.put("uid", "my-service-worker");

FirebaseOptions options = new FirebaseOptions.Builder()
    .setCredential(FirebaseCredentials.fromCertificate(serviceAccount))
    // The database URL depends on the location of the database
    .setDatabaseUrl("https://DATABASE_NAME.firebaseio.com")
    .setDatabaseAuthVariableOverride(auth)
    .build();
FirebaseApp.initializeApp(options);

// The app only has access as defined in the Security Rules
DatabaseReference ref = FirebaseDatabase
    .getInstance()
    .getReference("/some_resource");
ref.addListenerForSingleValueEvent(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
        String res = dataSnapshot.getValue();
        System.out.println(res);
    }
});

Node.js

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

// Fetch the service account key JSON file contents
var serviceAccount = require("path/to/serviceAccountKey.json");

// Initialize the app with a custom auth variable, limiting the server's access
admin.initializeApp({
  credential: admin.credential.cert(serviceAccount),
  // The database URL depends on the location of the database
  databaseURL: "https://DATABASE_NAME.firebaseio.com",
  databaseAuthVariableOverride: {
    uid: "my-service-worker"
  }
});

// The app only has access as defined in the Security Rules
var db = admin.database();
var ref = db.ref("/some_resource");
ref.once("value", function(snapshot) {
  console.log(snapshot.val());
});

Python

import firebase_admin
from firebase_admin import credentials
from firebase_admin import db

# Fetch the service account key JSON file contents
cred = credentials.Certificate('path/to/serviceAccountKey.json')

# Initialize the app with a custom auth variable, limiting the server's access
firebase_admin.initialize_app(cred, {
    'databaseURL': 'https://databaseName.firebaseio.com',
    'databaseAuthVariableOverride': {
        'uid': 'my-service-worker'
    }
})

# The app only has access as defined in the Security Rules
ref = db.reference('/some_resource')
print(ref.get())

Go

ctx := context.Background()
// Initialize the app with a custom auth variable, limiting the server's access
ao := map[string]interface{}{"uid": "my-service-worker"}
conf := &firebase.Config{
	DatabaseURL:  "https://databaseName.firebaseio.com",
	AuthOverride: &ao,
}

// Fetch the service account key JSON file contents
opt := option.WithCredentialsFile("path/to/serviceAccountKey.json")

app, err := firebase.NewApp(ctx, conf, opt)
if err != nil {
	log.Fatalln("Error initializing app:", err)
}

client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// The app only has access as defined in the Security Rules
ref := client.NewRef("/some_resource")
var data map[string]interface{}
if err := ref.Get(ctx, &data); err != nil {
	log.Fatalln("Error reading from database:", err)
}
fmt.Println(data)

In einigen Fällen kann es sinnvoll sein, die Admin SDKs so einzuschränken, dass sie als nicht authentifizierter Client agieren. Geben Sie dazu den Wert null für die Variable „database auth“ an.

Java

// Fetch the service account key JSON file contents
FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccountCredentials.json");

FirebaseOptions options = new FirebaseOptions.Builder()
    .setCredential(FirebaseCredentials.fromCertificate(serviceAccount))
    // The database URL depends on the location of the database
    .setDatabaseUrl("https://DATABASE_NAME.firebaseio.com")
    .setDatabaseAuthVariableOverride(null)
    .build();
FirebaseApp.initializeApp(options);

// The app only has access to public data as defined in the Security Rules
DatabaseReference ref = FirebaseDatabase
    .getInstance()
    .getReference("/public_resource");
ref.addListenerForSingleValueEvent(new ValueEventListener() {
    @Override
    public void onDataChange(DataSnapshot dataSnapshot) {
        String res = dataSnapshot.getValue();
        System.out.println(res);
    }
});

Node.js

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

// Fetch the service account key JSON file contents
var serviceAccount = require("path/to/serviceAccountKey.json");

// Initialize the app with a null auth variable, limiting the server's access
admin.initializeApp({
  credential: admin.credential.cert(serviceAccount),
  // The database URL depends on the location of the database
  databaseURL: "https://DATABASE_NAME.firebaseio.com",
  databaseAuthVariableOverride: null
});

// The app only has access to public data as defined in the Security Rules
var db = admin.database();
var ref = db.ref("/public_resource");
ref.once("value", function(snapshot) {
  console.log(snapshot.val());
});

Python

import firebase_admin
from firebase_admin import credentials
from firebase_admin import db

# Fetch the service account key JSON file contents
cred = credentials.Certificate('path/to/serviceAccountKey.json')

# Initialize the app with a None auth variable, limiting the server's access
firebase_admin.initialize_app(cred, {
    'databaseURL': 'https://databaseName.firebaseio.com',
    'databaseAuthVariableOverride': None
})

# The app only has access to public data as defined in the Security Rules
ref = db.reference('/public_resource')
print(ref.get())

Go

ctx := context.Background()
// Initialize the app with a nil auth variable, limiting the server's access
var nilMap map[string]interface{}
conf := &firebase.Config{
	DatabaseURL:  "https://databaseName.firebaseio.com",
	AuthOverride: &nilMap,
}

// Fetch the service account key JSON file contents
opt := option.WithCredentialsFile("path/to/serviceAccountKey.json")

app, err := firebase.NewApp(ctx, conf, opt)
if err != nil {
	log.Fatalln("Error initializing app:", err)
}

client, err := app.Database(ctx)
if err != nil {
	log.Fatalln("Error initializing database client:", err)
}

// The app only has access to public data as defined in the Security Rules
ref := client.NewRef("/some_resource")
var data map[string]interface{}
if err := ref.Get(ctx, &data); err != nil {
	log.Fatalln("Error reading from database:", err)
}
fmt.Println(data)

Nächste Schritte

• Weitere Informationen zum Strukturieren von Daten für Realtime Database
• Daten auf mehrere Datenbankinstanzen skalieren
• Daten speichern
• Daten abrufen
• Rufen Sie Ihre Datenbank in der Firebase Console auf.