Si vous avez travaillé avec le SDK JS Firebase ou d'autres SDK clients Firebase, vous connaissez probablement l'interface FirebaseApp et la façon de l'utiliser pour configurer des instances d'application. Pour faciliter des opérations similaires côté serveur, Firebase fournit FirebaseServerApp.
FirebaseServerApp est une variante de FirebaseApp à utiliser dans les environnements de rendu côté serveur (SSR). Il inclut des outils permettant de poursuivre les sessions Firebase qui couvrent la division entre le rendu côté client (CSR) et le rendu côté serveur (SSR). Ces outils et stratégies peuvent vous aider à améliorer les applications Web dynamiques créées avec Firebase et déployées dans des environnements Google tels que Firebase App Hosting.
Utiliser FirebaseServerApp pour :
- Exécuter du code côté serveur dans le contexte utilisateur, contrairement au SDK Firebase Admin, qui dispose de droits d'administration complets.
- Activez l'utilisation d'App Check dans les environnements SSR.
- Poursuite d'une session Firebase Auth créée dans le client.
Cycle de vie de FirebaseServerApp
Les frameworks de rendu côté serveur (SSR) et les autres environnements d'exécution autres que le navigateur, tels que les nœuds de calcul cloud, optimisent le temps d'initialisation en réutilisant les ressources sur plusieurs exécutions. FirebaseServerApp est conçu pour s'adapter à ces environnements à l'aide d'un mécanisme de comptage des références. Si une application appelle initializeServerApp avec les mêmes paramètres qu'une initializeServerApp précédente, elle reçoit la même instance FirebaseServerApp déjà initialisée. Cela réduit les coûts d'initialisation et les allocations de mémoire inutiles. Lorsque deleteApp est appelé sur une instance FirebaseServerApp, il réduit le nombre de références et l'instance est libérée une fois que le nombre de références atteint zéro.
Nettoyer les instances FirebaseServerApp
Il peut être difficile de savoir quand appeler deleteApp sur une instance FirebaseServerApp, en particulier si vous exécutez de nombreuses opérations asynchrones en parallèle. Le champ releaseOnDeref de FirebaseServerAppSettings permet de simplifier ce processus. Si vous attribuez à releaseOnDeref une référence à un objet avec la durée de vie de la portée de la requête (par exemple, l'objet d'en-tête de la requête SSR), FirebaseServerApp réduira son nombre de références lorsque le framework récupérera l'objet d'en-tête. Votre instance FirebaseServerApp est ainsi automatiquement nettoyée.
Voici un exemple d'utilisation de releaseOnDeref:
/// Next.js
import { headers } from 'next/headers'
import { FirebaseServerAppSettings, initializeServerApp} from "@firebase/app";
export default async function Page() {
const headersObj = await headers();
appSettings.releaseOnDeref = headersObj;
let appSettings: FirebaseServerAppSettings = {};
const serverApp = initializeServerApp(firebaseConfig, appSettings);
...
}
Réactiver les sessions authentifiées créées sur le client
Lorsqu'une instance de FirebaseServerApp est initialisée avec un jeton d'ID d'authentification, elle permet de mettre en place un pont entre les sessions utilisateur authentifiées entre les environnements de rendu côté client (CSR) et de rendu côté serveur (SSR). Les instances du SDK Firebase Auth initialisées avec un objet FirebaseServerApp contenant un jeton d'ID d'authentification tenteront de connecter l'utilisateur lors de l'initialisation sans que l'application n'ait besoin d'invoquer des méthodes de connexion.
Fournir un jeton d'ID Auth permet aux applications d'utiliser n'importe quelle méthode de connexion Auth sur le client, ce qui garantit la poursuite de la session côté serveur, même pour les méthodes de connexion nécessitant une interaction de l'utilisateur. De plus, il permet de décharger des opérations intensives sur le serveur, telles que les requêtes Firestore authentifiées, ce qui devrait améliorer les performances de rendu de votre application.
/// Next.js
import { initializeServerApp } from "firebase/app";
import { getAuth } from "firebase/auth";
// Replace the following with your app's
// Firebase project configuration
const firebaseConfig = {
// ...
};
const firebaseServerAppSettings = {
authIdToken: token // See "Pass client tokens to the server side
// rendering phase" for an example on how transmit
// the token from the client and the server.
}
const serverApp =
initializeServerApp(firebaseConfig,
firebaseServerAppSettings);
const serverAuth = getAuth(serverApp);
// FirebaseServerApp and Auth will now attempt
// to sign in the current user based on provided
// authIdToken.
Utiliser App Check dans les environnements SSR
L'application de la fonctionnalité App Check repose sur une instance de SDK App Check que les SDK Firebase utilisent pour appeler getToken en interne. Le jeton obtenu est ensuite inclus dans les requêtes envoyées à tous les services Firebase, ce qui permet au backend de valider l'application.
Toutefois, comme le SDK App Check a besoin d'un navigateur pour accéder à des heuristiques spécifiques à la validation des applications, il ne peut pas être initialisé dans les environnements serveur.
FirebaseServerApp propose une alternative. Si un jeton App Check généré par le client est fourni lors de l'initialisation de FirebaseServerApp, il sera utilisé par les SDK de produits Firebase lors de l'appel des services Firebase, ce qui élimine la nécessité d'une instance de SDK App Check.
/// Next.js
import { initializeServerApp } from "firebase/app";
// Replace the following with your app's
// Firebase project configuration
const firebaseConfig = {
// ...
};
const firebaseServerAppSettings = {
appCheckToken: token // See "Pass client tokens to the server side
// rendering phase" for an example on how transmit
// the token from the client and the server.
}
const serverApp =
initializeServerApp(firebaseConfig,
firebaseServerAppSettings);
// The App Check token will now be appended to all Firebase service requests.
Transmettre des jetons client à la phase de rendu côté serveur
Pour transmettre des jetons d'ID d'authentification authentifiés (et des jetons App Check) du client à la phase de rendu côté serveur (SSR), utilisez un service worker. Cette approche consiste à intercepter les requêtes de récupération qui déclenchent le SSR et à ajouter les jetons aux en-têtes de requête.
Pour obtenir une implémentation de référence d'un service worker Firebase Authentication, consultez la section Gestion des sessions avec les service workers. Consultez également la section Modifications côté serveur pour obtenir un code qui montre comment analyser ces jetons à partir des en-têtes pour les utiliser lors de l'initialisation de FirebaseServerApp.