REST-Anforderungen 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 es kein Client-SDK gibt, oder wenn Sie den Overhead einer dauerhaften Datenbankverbindung vermeiden möchten, können Sie die Realtime Database REST API zum Lesen und Schreiben von Daten verwenden.

Authentifizieren Sie Benutzer mit einer der folgenden Methoden:

1. Google OAuth2-Zugriffstokens – Normalerweise wird die Fähigkeit, aus der Echtzeitdatenbank zu lesen und in sie zu schreiben, durch Echtzeitdatenbankregeln geregelt. Sie können jedoch von einem Server aus auf Ihre Daten zugreifen und diesem Server mit einem von einem Dienstkonto generierten Google OAuth2-Zugriffstoken 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 Benutzer authentifiziert sind, z. B. um den Zugriff mit Echtzeitdatenbankregeln auf die Client-SDKs einzuschränken. Die REST-API akzeptiert dieselben Firebase-ID-Tokens, die von den Client-SDKs verwendet werden.

Google OAuth2-Zugriffstoken

Alle Daten, die gemäß Ihren Echtzeitdatenbankregeln öffentlich lesbar oder beschreibbar sind, sind auch über die REST-API ohne Authentifizierung lesbar und beschreibbar. Wenn Sie jedoch möchten, dass Ihr Server Ihre Echtzeitdatenbankregeln umgeht, müssen Sie Ihre Lese- und Schreibanforderungen authentifizieren. Die Authentifizierung über Google OAuth2 erfordert die folgenden Schritte:

1. Generieren Sie ein Zugriffstoken.
2. Authentifizieren Sie sich mit diesem Zugriffstoken.

Generieren Sie ein Zugriffstoken

Die Realtime Database REST API akzeptiert standardmäßige Google OAuth2-Zugriffstokens . Die Zugriffstoken können mithilfe eines Dienstkontos mit den entsprechenden Berechtigungen für Ihre Echtzeitdatenbank generiert werden. Wenn Sie unten im Abschnitt „Dienstkonten“ der Firebase-Konsole 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 über eine Dienstkontoschlüsseldatei verfügen, können Sie eine der Google API-Clientbibliotheken verwenden, um ein Google OAuth2-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 Google OAuth2-Zugriffstokens zur Authentifizierung bei der Realtime Database REST API in verschiedenen Sprachen erstellt werden:

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

Authentifizieren Sie sich mit einem Zugriffstoken

Um authentifizierte Anfragen an die Realtime Database REST API zu senden, übergeben Sie das oben generierte Google OAuth2-Zugriffstoken als Authorization: Bearer <ACCESS_TOKEN> -Header oder den Abfragezeichenfolgenparameter access_token=<ACCESS_TOKEN> . Hier ist eine Beispiel- curl Anfrage zum Lesen von Adas Namen:

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

Stellen Sie sicher, dass Sie <DATABASE_NAME> durch den Namen Ihrer Echtzeitdatenbank und <ACCESS_TOKEN> durch ein Google OAuth2-Zugriffstoken ersetzen.

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 Benutzer oder ein Gerät mithilfe der Firebase-Authentifizierung anmeldet, erstellt Firebase ein entsprechendes ID-Token, das ihn eindeutig identifiziert und ihm Zugriff auf mehrere Ressourcen gewährt, beispielsweise auf die Echtzeitdatenbank und den Cloud-Speicher. Sie können dieses ID-Token erneut verwenden, um die Realtime Database REST API zu authentifizieren und Anfragen im Namen dieses Benutzers zu stellen.

Generieren Sie ein ID-Token

Um das Firebase-ID-Token vom Client abzurufen, befolgen Sie die Schritte unter ID-Tokens auf Clients abrufen .

Beachten Sie, dass ID-Tokens nach kurzer Zeit ablaufen und nach dem Abruf so schnell wie möglich verwendet werden sollten.

Authentifizieren Sie sich mit einem ID-Token

Um authentifizierte Anforderungen an die Realtime Database REST API zu senden, übergeben Sie das oben generierte ID-Token als Abfragezeichenfolgenparameter auth=<ID_TOKEN> . Hier ist eine Beispiel- curl Anfrage zum Lesen von Adas Namen:

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

Stellen Sie sicher, dass Sie <DATABASE_NAME> durch den Namen Ihrer Echtzeitdatenbank und <ID_TOKEN> durch ein Firebase-ID-Token ersetzen.

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

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

Legacy-Token

Wenn Sie immer noch ältere Firebase-Authentifizierungstoken verwenden, empfehlen wir Ihnen, Ihre REST-Authentifizierung auf eine der oben beschriebenen Authentifizierungsmethoden zu aktualisieren.

Die Realtime Database REST API unterstützt weiterhin die Authentifizierung über Legacy-Authentifizierungstoken, einschließlich Geheimnisse . Die Geheimnisse Ihrer Echtzeitdatenbank finden Sie im Abschnitt „Dienstkonten“ der Firebase-Konsole.

Geheimnisse sind langlebige Referenzen. Wir empfehlen, ein neues Geheimnis zu generieren und das bestehende zu widerrufen, wenn Sie Benutzer mit geheimem Zugriff (z. B. Eigentümer) aus einem Projekt entfernen.