Google 致力于为黑人社区推动种族平等。查看具体举措

Persistance de l'état d'authentification

Vous pouvez spécifier la manière dont l'état d'authentification persiste lors de l'utilisation du SDK Firebase JS. Cela inclut la possibilité de spécifier si un utilisateur connecté doit être conservé indéfiniment jusqu'à la déconnexion explicite, effacé lorsque la fenêtre est fermée ou effacée lors du rechargement de la page.

Pour une application Web, le comportement par défaut consiste à conserver la session d'un utilisateur même après que l'utilisateur a fermé le navigateur. Ceci est pratique car l'utilisateur n'est pas obligé de se connecter en permanence chaque fois que la page Web est visitée sur le même appareil. Cela pourrait obliger l'utilisateur à ressaisir son mot de passe, envoyer une vérification par SMS, etc., ce qui pourrait ajouter beaucoup de friction à l'expérience utilisateur.

Cependant, il existe des cas où ce comportement peut ne pas être idéal :

  • Les applications contenant des données sensibles peuvent vouloir effacer l'état lorsque la fenêtre ou l'onglet est fermé. Ceci est important au cas où l'utilisateur oublie de se déconnecter.
  • Applications utilisées sur un appareil partagé par plusieurs utilisateurs. Un exemple courant ici est une application exécutée sur un ordinateur de bibliothèque.
  • Application sur un appareil partagé accessible à plusieurs utilisateurs. Le développeur est incapable de dire comment cette application est accessible et peut vouloir fournir à un utilisateur la possibilité de choisir de conserver ou non sa session. Cela peut être fait en ajoutant une option "Se souvenir de moi" lors de la connexion.
  • Dans certaines situations, un développeur peut souhaiter ne pas conserver un utilisateur anonyme jusqu'à ce que cet utilisateur soit mis à niveau vers un compte non anonyme (fédéré, mot de passe, téléphone, etc.).
  • Un développeur peut souhaiter autoriser différents utilisateurs à se connecter à une application sur différents onglets. Le comportement par défaut consiste à conserver l'état dans les onglets pour la même origine.

Comme indiqué ci-dessus, il existe plusieurs situations dans lesquelles la persistance permanente par défaut peut devoir être remplacée.

Types de persistance d'état d'authentification pris en charge

Vous pouvez choisir l'un des trois types de persistance de l'état d'authentification sur une instance Firebase Auth spécifiée en fonction des besoins de votre application ou de l'utilisateur.

Énumération Valeur La description
firebase.auth.Auth.Persistence.LOCAL 'local' Indique que l'état sera conservé même lorsque la fenêtre du navigateur est fermée ou que l'activité est détruite dans React Native. Une déconnexion explicite est nécessaire pour effacer cet état. Notez que les sessions Web Firebase Auth sont à l'origine d'un seul hôte et ne seront conservées que pour un seul domaine.
firebase.auth.Auth.Persistence.SESSION 'session' Indique que l'état ne persistera que dans la session ou l'onglet en cours et sera effacé lorsque l'onglet ou la fenêtre dans laquelle l'utilisateur authentifié sera fermé. S'applique uniquement aux applications Web.
firebase.auth.Auth.Persistence.NONE 'rien' Indique que l'état ne sera stocké qu'en mémoire et sera effacé lors de l'actualisation de la fenêtre ou de l'activité.

Modification de la persistance de l'état Auth

Vous pouvez spécifier ou modifier le type de persistance existant en appelant la firebase.auth().setPersistence :

Web version 9

import { getAuth, setPersistence, signInWithEmailAndPassword, browserSessionPersistence } from "firebase/auth";

const auth = getAuth();
setPersistence(auth, browserSessionPersistence)
  .then(() => {
    // Existing and future Auth states are now persisted in the current
    // session only. Closing the window would clear any existing state even
    // if a user forgets to sign out.
    // ...
    // New sign-in will be persisted with session persistence.
    return signInWithEmailAndPassword(auth, email, password);
  })
  .catch((error) => {
    // Handle Errors here.
    const errorCode = error.code;
    const errorMessage = error.message;
  });

Web version 8

firebase.auth().setPersistence(firebase.auth.Auth.Persistence.SESSION)
  .then(() => {
    // Existing and future Auth states are now persisted in the current
    // session only. Closing the window would clear any existing state even
    // if a user forgets to sign out.
    // ...
    // New sign-in will be persisted with session persistence.
    return firebase.auth().signInWithEmailAndPassword(email, password);
  })
  .catch((error) => {
    // Handle Errors here.
    var errorCode = error.code;
    var errorMessage = error.message;
  });

Cela modifiera le type de persistance sur l'instance Auth spécifiée pour la session Auth actuellement enregistrée et appliquera ce type de persistance pour les futures demandes de connexion, y compris la connexion avec des demandes de redirection. Cela renverra une promesse qui se résoudra une fois que l'état aura fini de copier d'un type de stockage à l'autre. L'appel d'une méthode de connexion après avoir modifié la persistance attendra que cette modification de la persistance soit terminée avant de l'appliquer au nouvel état Auth.

La valeur par défaut pour le navigateur Web et les applications React Native est local (à condition que le navigateur prenne en charge ce mécanisme de stockage, par exemple, les cookies/données tiers sont activés) alors qu'il n'en est none pour les applications backend Node.js.

Présentation du comportement de persistance

Les critères suivants seront appliqués lors de la détermination de l'état actuel de la persistance.

  • Initialement, le SDK vérifiera si un utilisateur authentifié existe. À moins que setPersistence ne soit appelé, le type de persistance actuel de cet utilisateur sera appliqué pour les futures tentatives de connexion. Ainsi, si cet utilisateur a été persisté dans la session sur une page Web précédente et qu'une nouvelle page a été visitée, la reconnexion avec un autre utilisateur entraînera également l'enregistrement de l'état de cet utilisateur avec la persistance de la session .
  • Si aucun utilisateur n'est connecté et qu'aucune persistance n'est spécifiée, le paramètre par défaut sera appliqué ( local dans une application de navigateur).
  • Si aucun utilisateur n'est connecté et qu'un nouveau type de persistance est défini, toute future tentative de connexion utilisera ce type de persistance.
  • Si l'utilisateur est connecté et que le type de persistance est modifié, cet utilisateur connecté existant remplacera la persistance par la nouvelle. Toutes les futures tentatives de connexion utiliseront cette nouvelle persistance.
  • Lorsque signInWithRedirect est appelé, le type de persistance actuel est conservé et appliqué à la fin du flux OAuth à l'utilisateur nouvellement connecté, même si la persistance était none . Si la persistance est explicitement spécifiée sur cette page, elle remplacera la persistance de l'état d'authentification conservé de la page précédente qui a démarré le flux de redirection.

    Web version 9

    import { getAuth, setPersistence, signInWithRedirect, inMemoryPersistence, GoogleAuthProvider } from "firebase/auth";
    
    const auth = getAuth();
    setPersistence(auth, inMemoryPersistence)
      .then(() => {
        const provider = new GoogleAuthProvider();
        // In memory persistence will be applied to the signed in Google user
        // even though the persistence was set to 'none' and a page redirect
        // occurred.
        return signInWithRedirect(auth, provider);
      })
      .catch((error) => {
        // Handle Errors here.
        const errorCode = error.code;
        const errorMessage = error.message;
      });

    Web version 8

    firebase.auth().setPersistence(firebase.auth.Auth.Persistence.NONE)
      .then(() => {
        var provider = new firebase.auth.GoogleAuthProvider();
        // In memory persistence will be applied to the signed in Google user
        // even though the persistence was set to 'none' and a page redirect
        // occurred.
        return firebase.auth().signInWithRedirect(provider);
      })
      .catch((error) => {
        // Handle Errors here.
        var errorCode = error.code;
        var errorMessage = error.message;
      });

Comportement attendu dans les onglets du navigateur

Le comportement attendu suivant s'appliquera lorsque différents types de persistance sont utilisés dans différents onglets. L'exigence est qu'à tout moment, il ne devrait jamais y avoir plusieurs types d'états enregistrés en même temps (par exemple, état d'authentification enregistré en session et types de stockage local ) :

  • Les utilisateurs peuvent se connecter en utilisant la session ou none persistance avec différents utilisateurs sur plusieurs onglets. Chaque onglet ne peut pas voir l'état de l'autre onglet.
  • Toute tentative de connexion à l'aide de la persistance local sera détectée et synchronisée sur tous les onglets. Si l'utilisateur était précédemment connecté à un onglet spécifique à l'aide de la persistance session ou none , cet état sera effacé.
  • Si l'utilisateur était précédemment connecté à l'aide de la persistance local avec plusieurs onglets ouverts, puis passe à none ou à la persistance de session dans un onglet, l'état de cet onglet sera modifié avec l'utilisateur persistant dans la session ou none et sur tous les autres onglets, l'utilisateur sera déconnecté.