Como personalizar dados para usuários autenticados

ID da região

O REGION_ID é um código abreviado que o Google atribui com base na região que você selecionou ao criar o aplicativo. O código não corresponde a um país ou estado, ainda que alguns IDs de região sejam semelhantes aos códigos de país e estado geralmente usados. Para apps criados após fevereiro de 2020, o REGION_ID.r está incluído nos URLs do App Engine. Para apps existentes criados antes dessa data, o ID da região é opcional no URL.

Saiba mais sobre IDs de região.

Use informações de usuários autenticados para armazenar e recuperar dados específicos do usuário e personalizar a experiência de cada usuário com seu serviço da Web.

Em uma etapa anterior, você atualizou o serviço da Web para exibir as últimas dez solicitações de todos os usuários. Nesta etapa, você usa informações de usuários autenticados para atualizar seu serviço da Web de forma que a página exiba apenas uma lista das dez últimas solicitações feitas pelo usuário autenticado naquele momento.

Antes de começar

Se você concluiu todas as etapas anteriores deste guia, pule esta seção. Caso contrário, conclua um dos procedimentos abaixo:

Comece por Como criar um aplicativo Python 3 e conclua todas as etapas anteriores a esta.
Se você já tiver um projeto do Google Cloud, continue fazendo o download de uma cópia do serviço da Web e adicionando o Firebase:
1. Faça o download do repositório do aplicativo de amostra usando Git:
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples
```
  Outra alternativa é fazer o download da amostra como um arquivo ZIP e extraí-lo.
2. Navegue até o diretório que contém uma cópia dos arquivos da etapa anterior:
```
cd python-docs-samples/appengine/standard_python3/building-an-app/building-an-app-3
```
3. Adicione o Firebase ao projeto do Google Cloud e ao serviço da Web.

Como armazenar e recuperar dados específicos do usuário

Para indicar que os dados estão conectados a um determinado usuário, use os ancestrais do Firestore no modo Datastore (Datastore), que permitem organizar seus dados do Datastore hierarquicamente.

Para isso, siga as seguintes etapas:

Atualize seus métodos store_time e fetch_time para usar ancestrais do Datastore no armazenamento e na recuperação de 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 entidade visit agora tem um ancestral ao qual está conectado. Esses ancestrais são entidades do Datastore que representam usuários individuais autenticados. A chave de cada ancestral inclui o tipo de User e um ID personalizado, que é o endereço de e-mail do usuário autenticado. A chave ancestral é usada para consultar o banco de dados somente para os horários associados a um usuário específico.

Atualize a chamada de método store_times no seu método root e mova-a para dentro da condicional id_token para que ela seja executada somente se o servidor autenticar um usuário:

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

Como configurar índices

O Datastore faz consultas com base em índices. Para entidades simples, o Datastore gera automaticamente esses índices. Mas o Cloud Datastore não é capaz de gerar automaticamente índices para entidades mais complexas, incluindo as que possuem ancestrais. Por esse motivo, você precisa criar manualmente um índice para entidades visit de modo que o Datastore possa executar consultas envolvendo entidades visit.

Se quiser criar um índice para entidades visit, conclua as seguintes etapas:

Crie um arquivo index.yaml no diretório raiz do seu projeto, como building-an-app, e adicione o seguinte í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

Implante seus índices index.yaml no Datastore executando o comando a seguir e seguindo os prompts:
```
gcloud datastore indexes create index.yaml
```

Pode levar algum tempo para que o Datastore crie índices. A criação de índices antes da implantação do serviço da Web no App Engine permite que você teste localmente usando esses índices e evita exceções que podem ocorrer em consultas que exigem um índice que ainda esteja em processo de criação.

Ver seus índices

Para mais informações sobre como criar índices do Datastore, consulte Como configurar índices do Datastore.

Como testar o serviço da Web

Teste seu serviço da Web executando-o localmente em um ambiente virtual:

Execute o seguinte comando no diretório principal do projeto para executar seu serviço da Web. Se você não tiver configurado um ambiente virtual para testes locais, consulte Como testar seu serviço da Web.
```
python main.py
```
Digite o seguinte endereço no navegador da Web para ver o serviço da Web:
```
http://localhost:8080
```

Como implantar serviços da Web

Agora que o Datastore está funcionando localmente, é possível reimplantar o serviço da Web no App Engine.

Execute o comando a seguir no diretório raiz do projeto, em que o arquivo app.yaml está localizado:

gcloud app deploy

Todo o tráfego é roteado automaticamente para a nova versão implantada.

Para mais informações sobre como gerenciar versões, consulte Como gerenciar serviços e versões.

Como ver o serviço

Para iniciar rapidamente o navegador e acessar o serviço da Web em https://PROJECT_ID.REGION_ID.r.appspot.com, execute o comando a seguir:

gcloud app browse

A seguir

Parabéns! Você criou um serviço da Web que usa o armazenamento de dados do Datastore e a autenticação do Firebase para fornecer aos usuários autenticados uma página da Web personalizada.

Agora é possível fazer uma limpeza ao fechar ou desativar o projeto, além de ao desativar o faturamento.

Autenticar usuários

Limpar