Einführung in die Admin Database API

Mit dem Admin SDK können Sie Realtime Database-Daten mit vollständigen Administratorberechtigungen lesen und schreiben. oder mit detaillierteren, eingeschränkten Berechtigungen. 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. 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 aus auf die Firebase Realtime Database zugreifen können, müssen Sie Ihren Server bei Firebase zu authentifizieren. Wenn Sie einen Server authentifizieren, statt sich mit einem wie bei einer Client-Anwendung, authentifizieren Sie sich mit einem Dienstkonto damit Ihr Server für Firebase identifiziert wird.

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

Firebase Admin SDK-Auth-Zugriffsebenen
Administratorberechtigungen	Vollständiger Lese- und Schreibzugriff auf die Realtime Database eines Projekts. Verwenden mit dass Sie bei administrativen Aufgaben wie Datenmigration oder Umstrukturierung uneingeschränkten Zugriff auf die Ressourcen Ihres Projekts benötigen.
Eingeschränkte Berechtigungen	Zugriff auf die Realtime Database eines Projekts, beschränkt auf die Ressourcen, die Ihr Serveranforderungen. 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 einen Dienst initialisieren Bearbeiter in Ihrem Firebase-Projekt hat, hat diese Instanz vollständigen 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 den schreibgeschützten Modus beschränken, indem Sie ein Dienstkonto mit der Rolle „Leser“ in Ihrem Projekt. Ein Service Das Konto ohne Rolle für das Projekt kann 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 gewähren. zu den benötigten Ressourcen hinzu. 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'"
    }
  }
}

Verwenden Sie dann bei der Initialisierung der Firebase-App auf Ihrem Server die Methode databaseAuthVariableOverride-Option zum Überschreiben des auth-Objekts, das von Ihre Datenbankregeln. Legen Sie in diesem benutzerdefinierten auth-Objekt für das Feld uid den Wert Kennung, die Sie in Ihren Sicherheitsregeln für Ihren Dienst verwendet 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 möchten Sie vielleicht die Admin-SDKs herabstufen, sodass sie als nicht authentifizierten Client. Dazu können Sie den Wert null für die Überschreibung der Authentifizierungsvariablen der Datenbank.

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:
• Ihre Datenbank anzeigen in der Firebase-Konsole.