REST-Anfragen authentifizieren

Die Firebase SDKs übernehmen in Ihrem Namen die gesamte Authentifizierung und Kommunikation mit der Firebase Realtime Database. Wenn Sie sich jedoch in einer Umgebung befinden, in der kein Client-SDK vorhanden ist, oder den Overhead einer dauerhaften Datenbankverbindung vermeiden möchten, können Sie die Realtime Database REST API zum Lesen und Schreiben von Daten verwenden.

Nutzer können sich mit einer der folgenden Methoden authentifizieren:

  1. Google OAuth2-Zugriffstokens: Normalerweise wird die Lese- und Schreibberechtigung für die Realtime Database durch die Realtime Database-Regeln geregelt. Sie können jedoch über einen Server auf Ihre Daten zugreifen und diesem Server mit einem Google OAuth2-Zugriffstoken, das von einem Dienstkonto generiert wurde, vollen Lese- und Schreibzugriff auf Ihre Daten gewähren.

  2. Firebase-ID-Tokens: Du kannst 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 auch von den Client-SDKs verwendet werden.

Google OAuth2-Zugriffstokens

Alle Daten, die gemäß Ihren Realtime DatabaseRegeln öffentlich lesbar oder beschreibbar sind, können auch über die REST API ohne Authentifizierung gelesen und geschrieben werden. Wenn Sie jedoch möchten, dass Ihr Server Ihre Realtime Database-Regeln umgeht, müssen Sie Ihre Lese- und Schreibanfragen authentifizieren. Für die Authentifizierung über Google OAuth2 sind die folgenden Schritte erforderlich:

  1. Erstelle ein Zugriffstoken.
  2. 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 mit einer der Google API-Clientbibliotheken ein Google OAuth2-Zugriffstoken mit den folgenden erforderlichen Bereichen generieren:

  • https://www.googleapis.com/auth/userinfo.email
  • https://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

Mit der Google API-Clientbibliothek für Java:

// 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, geben Sie das oben generierte Google OAuth2-Zugriffstoken als Authorization: Bearer <ACCESS_TOKEN>-Header oder als access_token=<ACCESS_TOKEN>-Suchstringparameter an. Hier ist ein Beispiel für eine curl Anfrage, den Namen von Ada vorzulesen:

curl "https://<DATABASE_NAME>.firebaseio.com/users/ada/name.json?access_token=<ACCESS_TOKEN>"

Ersetzen Sie <DATABASE_NAME> durch den Namen Ihrer 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-Token

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 mehrere Ressourcen wie Realtime Database und Cloud Storage gewährt. Du kannst dieses ID-Token wiederverwenden, um die Realtime Database REST API zu authentifizieren und Anfragen im Namen dieses Nutzers zu senden.

ID-Token generieren

Wenn Sie das Firebase-ID-Token vom Client abrufen möchten, folgen Sie der Anleitung unter ID-Tokens auf Clients abrufen.

ID-Tokens laufen nach kurzer Zeit ab und sollten nach dem Abrufen so schnell wie möglich verwendet werden.

Mit einem ID-Token authentifizieren

Wenn du authentifizierte Anfragen an die Realtime Database REST API senden möchtest, übergebe das oben generierte ID-Token als auth=<ID_TOKEN>-Suchstringparameter. Hier ist ein Beispiel für eine curl-Anfrage, um Adas Namen vorzulesen:

curl "https://<DATABASE_NAME>.firebaseio.com/users/ada/name.json?auth=<ID_TOKEN>"

Ersetzen Sie <DATABASE_NAME> durch den Namen Ihrer 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"}

Legacy-Tokens

Wenn Sie noch Legacy-Firebase-Authentifizierungstokens verwenden, empfehlen wir, Ihre REST-Authentifizierung auf eine der oben beschriebenen Authentifizierungsmethoden umzustellen.

Die Realtime Database REST API unterstützt weiterhin die Authentifizierung über alte 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 Geheimes zu generieren und das vorhandene zu widerrufen, wenn Sie Nutzer mit geheimem Zugriff (z. B. Inhaber) aus einem Projekt entfernen.