Authentifier les requêtes REST

Les SDK Firebase gèrent toutes les authentifications et communications avec Firebase Realtime Database en votre nom. Toutefois, lorsque vous vous trouvez dans un environnement qui ne dispose pas d'un SDK client ou que vous souhaitez éviter la surcharge d'une connexion de base de données persistante, vous pouvez utiliser l'API REST Realtime Database pour lire et écrire des données.

Authentifiez les utilisateurs à l'aide de l'une des méthodes suivantes :

1. Jetons d'accès Google OAuth2 : en règle générale, la possibilité de lire et d'écrire dans Realtime Database est régie par les règles Realtime Database. Toutefois, vous pouvez accéder à vos données depuis un serveur et lui accorder un accès complet en lecture et en écriture à vos données avec un jeton d'accès Google OAuth2 généré à partir d'un compte de service.

2. Jetons d'identification Firebase : vous pouvez également envoyer des requêtes authentifiées en tant qu'utilisateur individuel, par exemple pour limiter l'accès avec des règles Realtime Database sur les SDK client. L'API REST accepte les mêmes jetons d'identification Firebase que ceux utilisés par les SDK client.

Jetons d'accès Google OAuth2

Toutes les données qui sont publiquement lisibles ou modifiables selon vos règles Realtime Database sont également lisibles et modifiables via l'API REST sans authentification. Toutefois, si vous souhaitez que votre serveur ignore vos règles Realtime Database, vous devez authentifier vos requêtes de lecture et d'écriture. L'authentification via Google OAuth2 nécessite les étapes suivantes :

1. Générez un jeton d'accès.
2. Authentifiez-vous avec ce jeton d'accès.

Générer un jeton d'accès

L'API REST Realtime Database accepte les jetons d'accès Google OAuth2 standards. Les jetons d'accès peuvent être générés à l'aide d'un compte de service disposant des autorisations appropriées pour votre Realtime Database. Si vous n'en avez pas encore, vous pouvez facilement générer un fichier de clé de compte de service en cliquant sur le bouton Générer une clé privée en bas de la section Comptes de service de la console Firebase.

Une fois que vous disposez d'un fichier de clé de compte de service, vous pouvez utiliser l'une des bibliothèques clientes des API Google pour générer un jeton d'accès Google OAuth2 avec les niveaux d'accès requis suivants :

• https://www.googleapis.com/auth/userinfo.email
• https://www.googleapis.com/auth/firebase.database

Voici quelques exemples d'implémentations qui montrent comment créer des jetons d'accès Google OAuth2 pour s'authentifier auprès de l'API REST Realtime Database dans différents langages :

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

S'authentifier avec un jeton d'accès

Pour envoyer des requêtes authentifiées à l'API REST Realtime Database, transmettez le jeton d'accès Google OAuth2 généré ci-dessus en tant qu'en-tête Authorization: Bearer <ACCESS_TOKEN> ou paramètre de chaîne de requête access_token=<ACCESS_TOKEN>. Voici un exemple de requête curl pour lire le nom d'Ada :

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

Veillez à remplacer <DATABASE_NAME> par le nom de votre Realtime Database et <ACCESS_TOKEN> par un jeton d'accès Google OAuth2.

Une requête réussie est indiquée par un code d'état HTTP 200 OK. La réponse contient les données récupérées :

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

Jetons d'identification Firebase

Lorsqu'un utilisateur ou un appareil se connecte à l'aide de Firebase Authentication, Firebase crée un jeton d'ID correspondant qui l'identifie de manière unique et lui donne accès à plusieurs ressources, telles que Realtime Database et Cloud Storage. Vous pouvez réutiliser ce jeton d'identité pour authentifier l'API REST Realtime Database et envoyer des requêtes au nom de cet utilisateur.

Générer un jeton d'ID

Pour récupérer le jeton d'identification Firebase à partir du client, suivez les étapes décrites dans Récupérer les jetons d'identification sur les clients.

Notez que les jetons d'identité expirent après une courte période et doivent être utilisés le plus rapidement possible après leur récupération.

S'authentifier avec un jeton d'identité

Pour envoyer des requêtes authentifiées à l'API REST Realtime Database, transmettez le jeton d'identité généré ci-dessus en tant que paramètre de chaîne de requête auth=<ID_TOKEN>. Voici un exemple de requête curl pour lire le nom d'Ada :

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

Veillez à remplacer <DATABASE_NAME> par le nom de votre Realtime Database et <ID_TOKEN> par un jeton d'identité Firebase.

Une requête réussie est indiquée par un code d'état HTTP 200 OK. La réponse contient les données récupérées :

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

Anciens jetons

Si vous utilisez encore d'anciens jetons d'authentification Firebase, nous vous recommandons de mettre à jour votre authentification REST en utilisant l'une des méthodes d'authentification décrites ci-dessus.

L'API REST Realtime Database est toujours compatible avec l'authentification via les anciens jetons d'authentification, y compris les secrets. Vos secrets Realtime Database se trouvent dans la section Comptes de service de la console Firebase.

Les secrets sont des identifiants de longue durée. Nous vous recommandons de générer un nouveau secret et de révoquer l'existant lorsque vous supprimez des utilisateurs ayant accès aux secrets (comme les propriétaires) d'un projet.