Authentifier les requêtes REST

Les SDK Firebase gèrent l'ensemble de l'authentification et de la communication 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 les frais généraux 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 en utilisant l'une des méthodes suivantes:

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

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

Jetons d'accès Google OAuth2

Toutes les données lisibles ou écrites publiquement conformément à vos règles Realtime Database sont également lisibles et écrites via l'API REST sans aucune 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. Cliquez sur le bouton Générer une nouvelle clé privée en bas de la section Comptes de service de la console Firebase pour générer facilement un fichier de clé de compte de service si vous n'en avez pas déjà un.

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 champs d'application obligatoires 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érentes langues:

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 en cours de récupération:

{"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 les identifie de manière unique et leur accorde l'accès à plusieurs ressources, telles que Realtime Database et Cloud Storage. Vous pouvez réutiliser ce jeton d'ID pour authentifier l'API REST Realtime Database et effectuer des requêtes au nom de cet utilisateur.

Générer un jeton d'ID

Pour récupérer le jeton d'ID Firebase auprès du client, suivez la procédure décrite dans la section Récupérer les jetons d'ID sur les clients.

Notez que les jetons d'ID 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'ID

Pour envoyer des requêtes authentifiées à l'API REST Realtime Database, transmettez le jeton d'ID 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'ID 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 toujours d'anciens jetons d'authentification Firebase, nous vous recommandons de passer à l'une des méthodes d'authentification décrites ci-dessus.

L'API REST Realtime Database est toujours compatible avec l'authentification via d'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 secret et de révoquer l'ancien lorsque vous supprimez des utilisateurs disposant d'un accès secret (tels que les propriétaires) d'un projet.