Personaliza los datos para los usuarios autenticados

ID de región

REGION_ID es un código abreviado que Google asigna en función de la región que eliges cuando creas la app. El código no corresponde a un país ni a una provincia, aunque algunos ID de región puedan parecer similares a los códigos de país y provincia que se suelen usar. En el caso de las apps creadas después de febrero de 2020, REGION_ID.r se incluye en las URL de App Engine. En el caso de las apps existentes creadas antes de esta fecha, el ID de región es opcional en la URL.

Obtén más información acerca de los ID de región.

Usa la información del usuario autenticado para almacenar y recuperar datos específicos del usuario, y personaliza cada experiencia del usuario con tu servicio web.

En un paso anterior, actualizaste el servicio web para mostrar las últimas diez solicitudes de todos los usuarios. En este paso, usarás información del usuario autenticado para actualizar tu servicio web, de manera que la página solo muestre una lista de las últimas diez solicitudes del usuario autenticado actualmente.

Antes de comenzar

Si completaste todos los pasos anteriores de esta guía, omite esta sección. De lo contrario, sigue una de las siguientes instrucciones:

Comienza desde Compila una app de Python 3 y completa todos los pasos previos a este.
Si ya tienes un proyecto de Google Cloud, puedes continuarlo si descargas una copia del servicio web y agregas Firebase:
1. Descarga el repositorio de aplicaciones de muestra con Git:
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples
```
  Si no, puedes descargar la muestra como un archivo ZIP y, luego, descomprimirlo.
2. Dirígete al directorio que contiene una copia de los archivos del paso anterior:
```
cd python-docs-samples/appengine/standard_python3/building-an-app/building-an-app-3
```
3. Agrega Firebase a tu proyecto de Google Cloud y a tu servicio web.

Almacena y recupera los datos específicos del usuario

Puedes indicar que los datos están conectados a un usuario determinado mediante principales de Firestore en modo Datastore (Datastore), que te permiten organizar tus datos de Datastore de forma jerárquica.

Para hacerlo, sigue los pasos que se indican a continuación:

Actualiza tus métodos store_time y fetch_time a fin de usar los principales de Datastore para almacenar y recuperar entidades 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
```
Cada entidad visit ahora tiene un principal al que está conectado. Estos principales son entidades de Datastore que representan usuarios individuales autenticados. Cada clave de principal incluye el grupo de similares User y un ID personalizado, que es la dirección de correo electrónico del usuario autenticado. Usas la clave del principal a fin de consultar la base de datos solo para los tiempos que están asociados con un usuario específico.

Actualiza la llamada de método store_times en tu método root y muévela dentro del condicional id_token para que solo se ejecute si el servidor autenticó un usuario:

@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
    )

Configura índices

Datastore realiza consultas basadas en índices. Para las entidades sencillas, Datastore genera estos índices automáticamente. Sin embargo, no puede generar índices de manera automática para entidades más complicadas, incluidas las que tienen principales. Por este motivo, es necesario crear de forma manual un índice para las entidades visit de modo que Datastore pueda realizar consultas que incluyan entidades visit.

A fin de crear un índice para las entidades visit, completa los siguientes pasos:

Crea un archivo index.yaml en el directorio raíz de tu proyecto, por ejemplo, building-an-app, y agrega el siguiente índice:

# 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

Implementa tus índices index.yaml en Datastore mediante la ejecución del siguiente comando y sigue las indicaciones:
```
gcloud datastore indexes create index.yaml
```

Puede que Datastore tarde un poco en crear los índices. Crear índices antes de implementar tu servicio web en App Engine te permite probar el uso de esos índices de forma local y evita que se produzcan excepciones para las consultas que requieren un índice que aún esté en el proceso de compilación.

Ver tus índices

Para obtener más información sobre cómo crear índices de Datastore, consulta Configura índices de Datastore.

Prueba tu servicio web

Para probar un servicio web, ejecútalo de forma local en un entorno virtual:

Ejecuta el siguiente comando en el directorio principal de tu proyecto para ejecutar tu servicio web. Si no configuraste un entorno virtual para las pruebas locales, consulta Prueba tu servicio web.
```
python main.py
```
Ingresa la siguiente dirección en el navegador web para ver tu servicio web:
```
http://localhost:8080
```

Implementa tu servicio web

Ahora que Datastore funciona de manera local, puedes volver a implementar el servicio web en App Engine.

Ejecuta el siguiente comando desde el directorio raíz de tu proyecto, en el que se encuentra el archivo app.yaml:

gcloud app deploy

Todo el tráfico se enruta automáticamente a la nueva versión que implementaste.

Para obtener más información sobre la administración de versiones, consulta Cómo administrar servicios y versiones.

Visualiza tu servicio

Para iniciar el navegador y acceder al servicio web en https://PROJECT_ID.REGION_ID.r.appspot.com con rapidez, ejecuta el siguiente comando:

gcloud app browse

Próximos pasos

¡Felicitaciones! Compilaste de manera correcta un servicio web que usa almacenamiento de datos de Datastore y autenticación de Firebase para proporcionar a los usuarios autenticados una página web personalizada.

Ahora puedes limpiar mediante el cierre, la desactivación o la inhabilitación de la facturación para tu proyecto.

Autenticar usuarios

Realiza una limpieza