Die Firebase SDKs übernehmen die gesamte Authentifizierung und Kommunikation mit dem Firebase Realtime Database für Sie. Wenn Sie sich jedoch in einer Umgebung befinden, in der kein Client-SDK verfügbar ist, oder Sie den Aufwand einer persistenten Datenbankverbindung vermeiden möchten, können Sie die Realtime Database REST API zum Lesen und Schreiben von Daten verwenden.
Authentifizieren Sie Nutzer mit einer der folgenden Methoden:
Google OAuth2-Zugriffstokens: Die Möglichkeit, Daten aus Realtime Database zu lesen und in Realtime Database zu schreiben, wird in der Regel durch Realtime Database-Regeln geregelt. Sie können jedoch von einem Server aus auf Ihre Daten zugreifen und diesem Server mit einem Google OAuth2-Zugriffstoken, das von einem Dienstkonto generiert wurde, vollständigen Lese- und Schreibzugriff auf Ihre Daten gewähren.
Firebase-ID-Tokens: Möglicherweise möchten Sie auch Anfragen senden, die als einzelner Nutzer authentifiziert sind, z. B. um den Zugriff mit Realtime Database-Regeln in den Client-SDKs einzuschränken. Die REST API akzeptiert dieselben Firebase-ID-Tokens, die von den Client-SDKs verwendet werden.
Google OAuth2-Zugriffstokens
Alle Daten, die gemäß Ihren Realtime Database-Regeln öffentlich lesbar oder schreibbar sind, können auch ohne Authentifizierung über die REST API gelesen und geschrieben werden. Wenn Ihr Server jedoch Ihre Realtime Database-Regeln umgehen soll, müssen Sie Ihre Lese- und Schreibanfragen authentifizieren. Für die Authentifizierung über Google OAuth2 sind die folgenden Schritte erforderlich:
- Erstellen Sie ein Zugriffstoken.
- Authentifizieren Sie sich mit diesem Zugriffstoken.
Zugriffstoken erstellen
Die Realtime Database REST API akzeptiert standardmäßige Google OAuth2-Zugriffstokens. Die Zugriffstokens können mit einem Dienstkonto mit den entsprechenden Berechtigungen für Ihre Realtime Database generiert werden. Wenn Sie in der Firebase-Konsole unten im Bereich Dienstkonten auf die Schaltfläche Neuen privaten Schlüssel generieren klicken, können Sie ganz einfach eine neue Dienstkontoschlüsseldatei generieren, falls Sie noch keine haben.
Sobald Sie eine Dienstkontoschlüsseldatei haben, können Sie eine der Google API-Clientbibliotheken verwenden, um ein Google OAuth 2.0-Zugriffstoken mit den folgenden erforderlichen Bereichen zu generieren:
https://www.googleapis.com/auth/userinfo.emailhttps://www.googleapis.com/auth/firebase.database
Hier sind einige Beispielimplementierungen, die zeigen, wie Google OAuth2-Zugriffstokens erstellt werden, um sich in verschiedenen Sprachen bei der Realtime Database REST API zu authentifizieren:
Node.js
Google API-Clientbibliothek für Node.js verwenden:
var {google} = require("googleapis");
// Load the service account key JSON file.
var serviceAccount = require("path/to/serviceAccountKey.json");
// Define the required scopes.
var scopes = [
"https://www.googleapis.com/auth/userinfo.email",
"https://www.googleapis.com/auth/firebase.database"
];
// Authenticate a JWT client with the service account.
var jwtClient = new google.auth.JWT(
serviceAccount.client_email,
null,
serviceAccount.private_key,
scopes
);
// Use the JWT client to generate an access token.
jwtClient.authorize(function(error, tokens) {
if (error) {
console.log("Error making request to generate access token:", error);
} else if (tokens.access_token === null) {
console.log("Provided service account does not have permission to generate access tokens");
} else {
var accessToken = tokens.access_token;
// See the "Using the access token" section below for information
// on how to use the access token to send authenticated requests to
// the Realtime Database REST API.
}
});
Java
Google API-Clientbibliothek für Java verwenden:
// Load the service account key JSON file
FileInputStream serviceAccount = new FileInputStream("path/to/serviceAccountKey.json");
// Authenticate a Google credential with the service account
GoogleCredential googleCred = GoogleCredential.fromStream(serviceAccount);
// Add the required scopes to the Google credential
GoogleCredential scoped = googleCred.createScoped(
Arrays.asList(
"https://www.googleapis.com/auth/firebase.database",
"https://www.googleapis.com/auth/userinfo.email"
)
);
// Use the Google credential to generate an access token
scoped.refreshToken();
String token = scoped.getAccessToken();
// See the "Using the access token" section below for information
// on how to use the access token to send authenticated requests to the
// Realtime Database REST API.
Python
So verwenden Sie die Bibliothek google-auth:
from google.oauth2 import service_account
from google.auth.transport.requests import AuthorizedSession
# Define the required scopes
scopes = [
"https://www.googleapis.com/auth/userinfo.email",
"https://www.googleapis.com/auth/firebase.database"
]
# Authenticate a credential with the service account
credentials = service_account.Credentials.from_service_account_file(
"path/to/serviceAccountKey.json", scopes=scopes)
# Use the credentials object to authenticate a Requests session.
authed_session = AuthorizedSession(credentials)
response = authed_session.get(
"https://<DATABASE_NAME>.firebaseio.com/users/ada/name.json")
# Or, use the token directly, as described in the "Authenticate with an
# access token" section below. (not recommended)
request = google.auth.transport.requests.Request()
credentials.refresh(request)
access_token = credentials.token
Mit einem Zugriffstoken authentifizieren
Wenn Sie authentifizierte Anfragen an die Realtime Database REST API senden möchten, übergeben Sie das oben generierte Google OAuth2-Zugriffstoken als Authorization: Bearer <ACCESS_TOKEN>-Header oder als access_token=<ACCESS_TOKEN>-Abfrageparameter. Hier ein Beispiel für eine curl-Anfrage zum Lesen des Namens von Ada:
curl "https://<DATABASE_NAME>.firebaseio.com/users/ada/name.json?access_token=<ACCESS_TOKEN>"
Ersetzen Sie <DATABASE_NAME> durch den Namen Ihres Realtime Database und <ACCESS_TOKEN> durch ein Google OAuth2-Zugriffstoken.
Eine erfolgreiche Anfrage wird durch einen 200 OK-HTTP-Statuscode angezeigt. Die Antwort enthält die abgerufenen Daten:
{"first":"Ada","last":"Lovelace"}
Firebase-ID-Tokens
Wenn sich ein Nutzer oder Gerät mit Firebase Authentication anmeldet, erstellt Firebase ein entsprechendes ID-Token, das ihn eindeutig identifiziert und ihm Zugriff auf verschiedene Ressourcen wie Realtime Database und Cloud Storage gewährt. Sie können dieses ID-Token wiederverwenden, um die Realtime Database REST API zu authentifizieren und Anfragen im Namen dieses Nutzers zu stellen.
ID-Token generieren
Wenn Sie das Firebase-ID-Token vom Client abrufen möchten, folgen Sie der Anleitung unter ID-Tokens auf Clients abrufen.
Beachten Sie, dass ID-Tokens nach kurzer Zeit ablaufen und so schnell wie möglich nach dem Abrufen verwendet werden sollten.
Mit einem ID-Token authentifizieren
Wenn Sie authentifizierte Anfragen an die Realtime Database REST API senden möchten, übergeben Sie das oben generierte ID-Token als auth=<ID_TOKEN>-Abfragestringparameter. Hier ist ein Beispiel für eine curl-Anfrage, um den Namen von Ada zu lesen:
curl "https://<DATABASE_NAME>.firebaseio.com/users/ada/name.json?auth=<ID_TOKEN>"
Ersetzen Sie <DATABASE_NAME> durch den Namen Ihres Realtime Database und <ID_TOKEN> durch ein Firebase-ID-Token.
Eine erfolgreiche Anfrage wird durch einen 200 OK-HTTP-Statuscode angezeigt. Die Antwort enthält die abgerufenen Daten:
{"first":"Ada","last":"Lovelace"}
Alte Tokens
Wenn Sie noch Legacy-Firebase-Authentifizierungstokens verwenden, empfehlen wir, die REST-Authentifizierung auf eine der oben beschriebenen Authentifizierungsmethoden umzustellen.
Die Realtime Database REST API unterstützt weiterhin die Authentifizierung über Legacy-Authentifizierungstokens, einschließlich Secrets. Ihre Realtime Database-Secrets finden Sie in der Firebase-Konsole im Bereich Dienstkonten.
Secrets sind langlebige Anmeldedaten. Wir empfehlen, ein neues Secret zu generieren und das vorhandene zu widerrufen, wenn Sie Nutzer mit Secret-Zugriff (z. B. Inhaber) aus einem Projekt entfernen.