REST-Anfragen authentifizieren

Die Firebase SDKs übernehmen die gesamte Authentifizierung und Kommunikation mit der Firebase Realtime Database für Sie. Wenn Sie sich jedoch in einer Umgebung befinden, in der kein Client SDK vorhanden ist, oder den Aufwand einer dauerhaften Datenbankverbindung vermeiden möchten, können Sie die Realtime Database REST API verwenden, um Daten zu lesen und zu schreiben.

Authentifizieren Sie Nutzer mit einer der folgenden Methoden:

1. Google OAuth 2.0-Zugriffstokens : In der Regel wird die Möglichkeit, Daten aus der Realtime Database zu lesen und in sie zu schreiben, durch Realtime Database-Regeln bestimmt.Realtime DatabaseRealtime Database Sie können jedoch von einem Server aus auf Ihre Daten zugreifen und diesem Server mit einem Google OAuth 2.0-Zugriffstoken, das von einem Dienstkonto generiert wurde, vollständigen Lese- und Schreibzugriff auf Ihre Daten gewähren.

2. Firebase-ID-Tokens : Möglicherweise möchten Sie auch Anfragen senden, die als einzelner Nutzer authentifiziert wurden, z. B. den Zugriff mit Realtime Database Regeln auf den Client SDKs beschränken. Die REST API akzeptiert dieselben Firebase-ID-Tokens, die von den Client SDKs verwendet werden.

Google OAuth 2.0-Zugriffstokens

Alle Daten, die gemäß Ihren Realtime Database Regeln öffentlich lesbar oder beschreibbar sind, können auch ohne Authentifizierung über die REST API gelesen und geschrieben werden. Wenn Ihr Server Ihre Realtime Database Regeln umgehen soll, müssen Sie Ihre Lese- und Schreib anfragen authentifizieren. Die Authentifizierung über Google OAuth 2.0 erfordert die folgenden Schritte:

1. Zugriffstoken generieren
2. Mit diesem Zugriffstoken authentifizieren

Zugriffstoken generieren

Die Realtime Database REST API akzeptiert standardmäßige Google OAuth 2.0-Zugriffstokens. Die Zugriffstokens können mit einem Dienstkonto mit den entsprechenden Berechtigungen für Ihre Realtime Database generiert werden. Wenn Sie noch keine Dienstkontoschlüsseldatei haben, können Sie ganz einfach eine neue erstellen, indem Sie in der Firebase Console im Bereich Dienstkonten unten auf die Schaltfläche Neuen privaten Schlüssel generieren klicken.

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

Hier sind einige Beispielimplementierungen, die zeigen, wie Sie Google OAuth2 Zugriffstokens erstellen, um sich in verschiedenen Sprachen bei der Realtime Database REST API zu authentifizieren:

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.
  }
});

// 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.

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 OAuth 2.0-Zugriffstoken als Authorization: Bearer <ACCESS_TOKEN> Header oder als access_token=<ACCESS_TOKEN> Abfragestringparameter. Hier ist eine Beispielanfrage mit curl, um den Namen von Ada zu lesen:

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 OAuth 2.0-Zugriffstoken.

Eine erfolgreiche Anfrage wird durch den HTTP-Statuscode 200 OK 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 gewährt, z. B. Realtime Database und Cloud Storage. 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

Informationen zum Abrufen des Firebase-ID-Tokens vom Client finden Sie unter ID-Tokens auf Clients abrufen.

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

Mit einem ID-Token authentifizieren

Wenn Sie authentifizierte Anfragen an die Realtime Database REST API senden möchten, übergeben Sie das ID-Token, das oben als auth=<ID_TOKEN> Abfragestringparameter generiert wurde. Hier ist eine Beispielanfrage mit curl, 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 Ihrer Realtime Database und <ID_TOKEN> durch ein Firebase-ID-Token.

Eine erfolgreiche Anfrage wird durch den HTTP-Statuscode 200 OK angezeigt. Die Antwort enthält die abgerufenen Daten:

{"first":"Ada","last":"Lovelace"}

Alte Tokens

Wenn Sie noch alte 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 Console im Bereich Firebase.

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.