Gérer les sessions avec Firestore

De nombreuses applications requièrent une fonctionnalité de gestion de session pour l'authentification et le stockage des préférences utilisateur. Le framework Flask intègre une mise en œuvre basée sur la mémoire pour assurer cette gestion. Cette mise en œuvre n'est toutefois pas adaptée à une application pouvant être diffusée depuis plusieurs instances. En effet, la session enregistrée dans une instance peut différer des autres instances. Ce tutoriel explique comment gérer des sessions sur App Engine.

Objectifs

Écrire l'application
Exécuter l'application en local
Déployer l'application sur App Engine

Coûts

Ce tutoriel utilise les composants facturables suivants de Google Cloud :

Obtenez une estimation des coûts en fonction de votre utilisation prévue à l'aide du simulateur de coût. Les nouveaux utilisateurs de Google Cloud peuvent bénéficier d'un essai gratuit.

Une fois que vous avez terminé ce tutoriel, vous pouvez éviter de continuer à payer des frais en supprimant les ressources que vous avez créées. Consultez la page Effectuer un nettoyage pour en savoir plus.

Avant de commencer

Connectez-vous à votre compte Google.
Si vous n'en possédez pas déjà un, vous devez en créer un.

Dans Google Cloud Console, sur la page de sélection du projet, sélectionnez ou créez un projet Google Cloud.

Remarque : Si vous ne comptez pas conserver les ressources créées dans cette procédure, créez un projet au lieu de sélectionner un projet existant. Après avoir suivi ces étapes, vous pouvez supprimer le projet. Cela entraîne la suppression de toutes les ressources qui lui sont associées.

Accéder à la page de sélection du projet

Assurez-vous que la facturation est activée pour votre projet Cloud. Découvrez comment vérifier que la facturation est activée pour votre projet.

Activez l'API Firestore.
Activer l'API

Installez et initialisez le SDK Cloud.

Installez Python, pip et virtualenv sur votre système. Pour obtenir des instructions, consultez la page Configurer un environnement de développement Python pour Google Cloud.

Mettre en place le projet

Dans votre fenêtre de terminal, accédez au répertoire de votre choix et créez-y un répertoire nommé sessions. L'ensemble du code de ce tutoriel se base sur une exécution dans le répertoire sessions.
Accédez donc à ce répertoire sessions :
```
cd sessions
```
Créez requirements.txt avec le contenu suivant :

sessions/requirements.txt

Afficher sur GitHub
```
google-cloud-firestore==2.0.2
flask==1.1.2
```
Installez les dépendances :
```
pip install  -r requirements.txt
```

À la fin de ce tutoriel, la structure de fichiers finale ressemble à ce qui suit :

sessions
├── app.yaml
├── main.py
└── requirements.txt

Écrire l'application Web

L'application affiche des messages d'accueil dans différentes langues pour chaque utilisateur. Les utilisateurs connus reçoivent toujours les messages d'accueil dans la même langue.

Fenêtres d'application affichant un message d'accueil dans différentes langues.

Pour que votre application puisse stocker les préférences d'un utilisateur, vous devez mettre en œuvre une méthode permettant de stocker les informations sur l'utilisateur actuel dans une session. Dans cet exemple d'application, les données de session sont stockées à l'aide de cookies et de Firestore.

Dans votre fenêtre de terminal, créez un fichier nommé main.py contenant le code suivant :

sessions/main.py

Afficher sur GitHub

import random
from uuid import uuid4

from flask import Flask, make_response, request
from google.cloud import firestore

app = Flask(__name__)
db = firestore.Client()
sessions = db.collection('sessions')
greetings = [
    'Hello World',
    'Hallo Welt',
    'Ciao Mondo',
    'Salut le Monde',
    'Hola Mundo',
]

@firestore.transactional
def get_session_data(transaction, session_id):
    """ Looks up (or creates) the session with the given session_id.
        Creates a random session_id if none is provided. Increments
        the number of views in this session. Updates are done in a
        transaction to make sure no saved increments are overwritten.
    """
    if session_id is None:
        session_id = str(uuid4())   # Random, unique identifier

    doc_ref = sessions.document(document_id=session_id)
    doc = doc_ref.get(transaction=transaction)
    if doc.exists:
        session = doc.to_dict()
    else:
        session = {
            'greeting': random.choice(greetings),
            'views': 0
        }

    session['views'] += 1   # This counts as a view
    transaction.set(doc_ref, session)

    session['session_id'] = session_id
    return session

@app.route('/', methods=['GET'])
def home():
    template = '<body>{} views for "{}"</body>'

    transaction = db.transaction()
    session = get_session_data(transaction, request.cookies.get('session_id'))

    resp = make_response(template.format(
        session['views'],
        session['greeting']
        )
    )
    resp.set_cookie('session_id', session['session_id'], httponly=True)
    return resp

if __name__ == '__main__':
    app.run(host='127.0.0.1', port=8080)

Le schéma suivant décrit la façon dont Firestore gère les sessions pour l'application App Engine.

Supprimer des sessions

Vous pouvez supprimer les données de session ou mettre en œuvre une stratégie de suppression automatique. Si vous utilisez des solutions de stockage pour des sessions telles que Memcache ou Redis, les sessions expirées sont automatiquement supprimées.

Exécution locale

Dans la fenêtre de terminal, installez le serveur HTTP Gunicorn :
```
pip install gunicorn
```
Exécutez le serveur HTTP Gunicorn :
```
gunicorn -b :8080 main:app
```
Affichez l'application dans votre navigateur Web :

Cloud Shell

Dans la barre d'outils Cloud Shell, cliquez sur Aperçu sur le Web et sélectionnez Prévisualiser sur le port 8080.

Machine locale

Dans votre navigateur, accédez à http://localhost:8080

L'un des cinq messages d'accueil suivants s'affiche : "Hello World", "Hallo Welt", "Hola mundo", "Salut le Monde" ou "Ciao Mondo". La langue change si vous ouvrez la page dans un autre navigateur ou en mode navigation privée. Vous pouvez consulter et modifier les données de session dans Google Cloud Console.
Dans votre fenêtre de terminal, appuyez sur Control+C pour arrêter le serveur HTTP.

Déployer et exécuter l'application sur App Engine

Vous pouvez utiliser l'environnement standard App Engine pour créer et déployer une application qui s'exécute de manière fiable, même lorsqu'elle est soumise à une charge importante et doit gérer de grandes quantités de données.

Dans ce tutoriel, le serveur est déployé dans l'environnement standard App Engine.

Dans votre fenêtre de terminal, créez un fichier app.yaml et copiez le contenu suivant :

sessions/app.yaml

Afficher sur GitHub
```
runtime: python37
```
Déployez l'application sur App Engine :
```
gcloud app deploy
```
Affichez l'application en direct à l'adresse https://your-project-id.appspot.com :
```
gcloud app browse
```
où your-project-id correspond à l’ID de votre projet Google Cloud.

Le message d'accueil est désormais diffusé par un serveur Web exécuté sur une instance App Engine.

Déboguer l'application

Si vous ne parvenez pas à vous connecter à votre application App Engine, vérifiez les éléments suivants :

Vérifiez que les commandes de déploiement gcloud ont bien abouti et n'ont généré aucune erreur. Si des erreurs se sont produites (par exemple, message=Build failed), corrigez-les, puis essayez de redéployer l'application App Engine.
Dans Cloud Console, accédez à la page Visionneuse de journaux.

Accéder à la page "Visionneuse de journaux"
1. Dans la liste déroulante Ressources sélectionnées récemment, cliquez sur Application App Engine, puis sur Tous les ID de module. La liste des requêtes correspondant à votre accès à l'application s'affiche. Si cette liste n'apparaît pas, vérifiez que vous avez bien sélectionné Tous les ID de module dans la liste déroulante. Si des messages d'erreur s'affichent dans Cloud Console, vérifiez que le code de votre application correspond au code décrit dans la section sur l'écriture de l'application Web.
2. Assurez-vous que l'API Firestore est activée.

Nettoyer

Supprimer le projet

Attention : La suppression d'un projet aura les effets suivants :

Tout le contenu du projet est supprimé. Si vous avez utilisé un projet existant pour ce tutoriel et que vous le supprimez, vous supprimerez également tout autre travail effectué dans le projet.
Les ID de projets personnalisés sont perdus. Lorsque vous avez créé ce projet, vous avez peut-être créé un ID de projet personnalisé que vous souhaitez utiliser à l'avenir. Pour conserver les URL qui utilisent l'ID de projet, telle qu'une URL appspot.com, supprimez les ressources sélectionnées dans le projet au lieu de supprimer l'ensemble du projet.

Si vous envisagez d'explorer plusieurs tutoriels et guides de démarrage rapide, vous pouvez constater que réutiliser des projets peut vous aider à éviter de dépasser les limites de quotas des projets.

Dans Cloud Console, accédez à la page Gérer les ressources.
Accéder à la page Gérer les ressources
Dans la liste des projets, sélectionnez le projet que vous souhaitez supprimer, puis cliquez sur Supprimer.
Dans la boîte de dialogue, saisissez l'ID du projet, puis cliquez sur Arrêter pour supprimer le projet.

Supprimer l'instance App Engine

Dans Cloud Console, accédez à la page Versions pour App Engine.
Accéder à la page Versions
Cochez la case correspondant à la version de l'application autre que celle par défaut que vous souhaitez supprimer.
Note : Le seul moyen de supprimer la version par défaut de votre application App Engine consiste à supprimer votre projet. Vous pouvez toutefois arrêter la version par défaut dans Cloud Console. Cette opération a pour effet d'arrêter toutes les instances associées à la version. Vous pourrez redémarrer ces instances ultérieurement si nécessaire.

Dans l'environnement standard App Engine, vous ne pouvez arrêter la version par défaut que si vous avez spécifié le scaling manuel ou de base pour votre application.
Cliquez sur Supprimer pour supprimer la version de l'application.

Étape suivante

Suivez d'autres tutoriels Cloud Functions.
Obtenez plus d'informations sur App Engine.
Essayez Cloud Run, qui vous permet d'exécuter des conteneurs sans état dans un environnement entièrement géré ou dans votre propre cluster Google Kubernetes Engine.