Cette page a été traduite par l'API Cloud Translation.

Personnaliser des données pour les utilisateurs authentifiés

ID de la région

Le REGION_ID est un code abrégé que Google attribue en fonction de la région que vous sélectionnez lors de la création de votre application. Le code ne correspond pas à un pays ou une province, même si certains ID de région peuvent ressembler aux codes de pays et de province couramment utilisés. Pour les applications créées après février 2020, REGION_ID.r est inclus dans les URL App Engine. Pour les applications existantes créées avant cette date, l'ID de région est facultatif dans l'URL.

En savoir plus sur les ID de région

Utilisez les informations des utilisateurs authentifiés pour stocker et récupérer les données spécifiques à l'utilisateur, et personnalisez l'expérience de chaque utilisateur grâce à votre service Web.

Lors d'une étape précédente, vous avez mis à jour le service Web afin d'afficher les dix dernières requêtes de tous les utilisateurs. Ici, vous allez utiliser les informations des utilisateurs authentifiés pour mettre à jour votre service Web et n'afficher que la liste des dix dernières requêtes effectuées par l'utilisateur actuellement authentifié.

Avant de commencer

Si vous avez suivi toutes les étapes précédentes de ce guide, ignorez cette section. Sinon, effectuez l'une des opérations suivantes :

Commencez par Créer une application Python 3 et suivez toutes les étapes menant à celle-ci.
Si vous avez déjà un projet Google Cloud, vous pouvez continuer en téléchargeant une copie du service Web et en ajoutant Firebase :
1. Téléchargez le dépôt de l'exemple d'application à l'aide de Git :
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples
```
  Vous pouvez également télécharger l'exemple en tant que fichier zip et l'extraire.
2. Accédez au répertoire contenant une copie des fichiers de l'étape précédente :
```
cd python-docs-samples/appengine/standard_python3/building-an-app/building-an-app-3
```
3. Ajoutez Firebase à votre projet Google Cloud et service Web.

Stocker et récupérer des données spécifiques à l'utilisateur

Vous pouvez indiquer que les données sont associées à un certain utilisateur grâce aux ancêtres Firestore en mode Datastore (Datastore), qui vous permettent d'organiser vos données Datastore de manière hiérarchique.

Pour ce faire, procédez comme suit :

Mettez à jour vos méthodes store_time et fetch_time pour utiliser les ancêtres Datastore afin de stocker et récupérer des entités visit :
```
datastore_client = datastore.Client()

def store_time(email, dt):
    entity = datastore.Entity(key=datastore_client.key("User", email, "visit"))
    entity.update({"timestamp": dt})

    datastore_client.put(entity)


def fetch_times(email, limit):
    ancestor = datastore_client.key("User", email)
    query = datastore_client.query(kind="visit", ancestor=ancestor)
    query.order = ["-timestamp"]

    times = query.fetch(limit=limit)

    return times
```
Chaque entité visit dispose maintenant d'un ancêtre auquel elle est associée. Ces ancêtres sont des entités Datastore qui représentent des utilisateurs authentifiés individuels. La clé de chaque ancêtre comprend le genre User et un ID personnalisé qui correspond à l'adresse e-mail de l'utilisateur authentifié. Vous utilisez la clé d'ancêtre pour n'interroger la base de données que pour les périodes liées à un utilisateur spécifique.

Mettez à jour l'appel de méthode store_times dans votre méthode root, puis déplacez-le dans l'expression conditionnelle id_token pour qu'il ne s'exécute que si le serveur a authentifié un utilisateur :

@app.route("/")
def root():
    # Verify Firebase auth.
    id_token = request.cookies.get("token")
    error_message = None
    claims = None
    times = None

    if id_token:
        try:
            # Verify the token against the Firebase Auth API. This example
            # verifies the token on each page load. For improved performance,
            # some applications may wish to cache results in an encrypted
            # session store (see for instance
            # http://flask.pocoo.org/docs/1.0/quickstart/#sessions).
            claims = google.oauth2.id_token.verify_firebase_token(
                id_token, firebase_request_adapter
            )

            store_time(claims["email"], datetime.datetime.now(tz=datetime.timezone.utc))
            times = fetch_times(claims["email"], 10)

        except ValueError as exc:
            # This will be raised if the token is expired or any other
            # verification checks fail.
            error_message = str(exc)

    return render_template(
        "index.html", user_data=claims, error_message=error_message, times=times
    )

Configurer des index

Datastore effectue des requêtes basées sur des index. Pour les entités simples, Datastore génère automatiquement ces index. Toutefois, il ne peut pas les générer automatiquement pour les entités plus complexes, y compris celles disposant d'ancêtres. Pour cette raison, vous devez créer manuellement un index pour les entités visit afin de permettre à Datastore d'effectuer des requêtes impliquant des entités visit.

Pour créer un index pour les entités visit, procédez comme suit :

Créez un fichier index.yaml dans le répertoire racine de votre projet, par exemple building-an-app, et ajoutez l'index suivant :

# Copyright 2021 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

indexes:

- kind: visit
  ancestor: yes
  properties:
  - name: timestamp
    direction: desc

Déployez vos index index.yaml dans Datastore en exécutant la commande suivante et en suivant les invites :
```
gcloud datastore indexes create index.yaml
```

Datastore peut mettre un certain temps à créer les index. Si vous créez les index avant de déployer votre service Web sur App Engine, vous pouvez tester localement le service à l'aide de ces derniers et éviter les exceptions pouvant survenir pour les requêtes nécessitant un index en cours de création.

Afficher les index

Pour plus d'informations sur la création d'index Datastore, consultez la page Configurer des index Datastore.

Tester votre service Web

Testez votre service Web en l'exécutant localement dans un environnement virtuel :

Exécutez la commande suivante dans le répertoire principal de votre projet pour lancer votre service Web. Si vous n'avez pas configuré d'environnement virtuel pour les tests en local, consultez la section Tester votre service Web.
```
python main.py
```
Saisissez l'adresse suivante dans votre navigateur Web pour afficher votre service Web :
```
http://localhost:8080
```

Déployer votre service Web

Maintenant que Datastore fonctionne localement, vous pouvez redéployer votre service Web sur App Engine.

Exécutez la commande suivante à partir du répertoire racine de votre projet, où se trouve le fichier app.yaml :

gcloud app deploy

Tout le trafic est automatiquement acheminé vers la nouvelle version que vous avez déployée.

Pour plus d'informations sur la gestion des versions, consultez la section Gérer les services et les versions.

Affichez votre service :

Pour lancer rapidement votre navigateur et accéder à votre service Web à l'adresse https://PROJECT_ID.REGION_ID.r.appspot.com, exécutez la commande suivante :

gcloud app browse

Étapes suivantes

Félicitations ! Vous venez de créer un service Web qui utilise le stockage de données Datastore et l'authentification Firebase pour fournir une page Web personnalisée aux utilisateurs authentifiés.

Vous pouvez maintenant nettoyer votre projet en arrêtant ou en désactivant la facturation.

Authentifier les utilisateurs

Nettoyage