Daten für authentifizierte Nutzer personalisieren

Regions-ID

REGION_ID ist ein abgekürzter Code, den Google anhand der Region zuweist, die Sie beim Erstellen Ihrer Anwendung ausgewählt haben. Der Code bezieht sich nicht auf ein Land oder eine Provinz, auch wenn einige Regions-IDs häufig verwendeten Länder- und Provinzcodes ähneln können. Bei Anwendungen, die nach Februar 2020 erstellt wurden, ist REGION_ID.r in den App Engine-URLs enthalten. Bei Anwendungen, die vor diesem Datum erstellt wurden, ist die Regions-ID in der URL optional.

Hier finden Sie weitere Informationen zu Regions-IDs.

Verwenden Sie authentifizierte Nutzerinformationen, um nutzerspezifische Daten zu speichern und abzurufen und um Ihren Webdienst für jeden Nutzer zu personalisieren.

In einem vorherigen Schritt haben Sie den Webdienst aktualisiert, damit die letzten zehn Anfragen aller Nutzer angezeigt werden. In diesem Schritt verwenden Sie authentifizierte Nutzerinformationen, um Ihren Webdienst so zu aktualisieren, dass auf der Seite nur eine Liste der letzten zehn Anfragen des derzeit authentifizierten Nutzers angezeigt wird.

Vorbereitung

Wenn Sie alle vorherigen Schritte in diesem Leitfaden abgeschlossen haben, überspringen Sie diesen Abschnitt. Wenn nicht, führen Sie einen der folgenden Schritte aus:

Erstellen Sie zuerst eine Python 3-Anwendung und führen Sie alle Schritte bis zu diesem Schritt aus.
Wenn Sie bereits ein Google Cloud-Projekt haben, laden Sie eine Kopie des Webdienstes herunter und fügen Sie diesem Firebase hinzu:
1. Laden Sie das Repository der Beispielanwendung mit Git herunter:
```
git clone https://github.com/GoogleCloudPlatform/python-docs-samples
```
  Alternativ können Sie das Beispiel als ZIP-Datei herunterladen und dann extrahieren.
2. Gehen Sie zu dem Verzeichnis, das eine Kopie der Dateien aus dem vorherigen Schritt enthält:
```
cd python-docs-samples/appengine/standard_python3/building-an-app/building-an-app-3
```
3. Fügen Sie Ihrem Google Cloud-Projekt und Ihrem Webdienst Firebase hinzu.

Nutzerspezifische Daten speichern und abrufen

Sie können angeben, dass Daten mit einem bestimmten Nutzer verbunden sind. Verwenden Sie dazu Firestore-Ancestors im Datastore-Modus (Datastore), mit denen Sie Ihre Datastore-Daten hierarchisch organisieren können.

Dazu müssen Sie die folgenden Schritte ausführen:

Ändern Sie die Methoden store_time und fetch_time so, dass sie Datastore-Ancestors für das Speichern und Abrufen der visit-Entitäten verwenden:
```
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
```
Jede Entität visit hat jetzt einen Ancestor, mit dem sie verbunden ist. Diese Ancestors sind Datastore-Entitäten, die einzelne authentifizierte Nutzer darstellen. Der Schlüssel jedes Ancestors enthält die Art User und eine benutzerdefinierte ID in Form der E-Mail-Adresse des authentifizierten Nutzers. Mit dem Ancestor-Schlüssel wird die Datenbank nur für die Zeiträume abgefragt, die einem bestimmten Nutzer zugeordnet sind.

Ändern Sie den Methodenaufruf store_times in der Methode root und verschieben Sie diesen in die Bedingung id_token, sodass er nur ausgeführt wird, wenn der Server einen Nutzer authentifiziert hat:

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

Indexe konfigurieren

Datastore erstellt Abfragen basierend auf Indexen. Bei einfachen Entitäten generiert Datastore diese Indexe automatisch. Für kompliziertere Entitäten, einschließlich solcher mit Ancestors, können allerdings keine Indexe automatisch generiert werden. Aus diesem Grund müssen Sie manuell einen Index für visit-Entitäten erstellen, damit Datastore Abfragen anhand der visit-Entitäten ausführen kann.

So erstellen Sie einen Index für visit-Entitäten:

Erstellen Sie im Stammverzeichnis Ihres Projekts eine index.yaml-Datei, z. B. building-an-app, und fügen Sie den folgenden Index hinzu:

# 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

Stellen Sie Ihre index.yaml-Indexe im Datastore bereit, indem Sie den folgenden Befehl ausführen und den Eingabeaufforderungen folgen:
```
gcloud datastore indexes create index.yaml
```

Es kann eine Weile dauern, bis Datastore die Indexe erstellt hat. Durch das Erstellen der Indexe vor dem Bereitstellen des Webdienstes in App Engine können Sie anhand dieser Indexe zuerst lokal testen. Außerdem werden Ausnahmen verhindert, die bei Abfragen auftreten können, für die ein Index benötigt wird, der noch erstellt wird.

Indexe ansehen

Weitere Informationen zum Erstellen von Datastore-Indizes finden Sie unter Konfigurieren von Datastore-Indizes.

Webdienst testen

Testen Sie jetzt Ihren Webdienst. Führen Sie ihn dazu lokal aus und verwenden Sie eine virtuelle Umgebung:

Rufen Sie den im Folgenden aufgeführten Befehl im Hauptverzeichnis Ihres Projekts auf, um den Webdienst auszuführen. Wenn keine virtuelle Umgebung für lokale Tests eingerichtet ist, finden Sie weitere Informationen unter Webdienst testen.
```
python main.py
```
Geben Sie die folgende Adresse in Ihren Webbrowser ein, um den Webdienst aufzurufen:
```
http://localhost:8080
```

Webdienst bereitstellen

Nun, da Datastore lokal ausgeführt wird, können Sie Ihren Webdienst wieder für App Engine bereitstellen.

Führen Sie den folgenden Befehl im Stammverzeichnis Ihres Projekts aus, in dem sich die Datei app.yaml befindet:

gcloud app deploy

Der gesamte Traffic wird automatisch an die neue Version geleitet, die Sie bereitgestellt haben.

Weitere Informationen zum Verwalten von Versionen finden Sie unter Dienste und Versionen verwalten.

Ihren Dienst aufrufen:

Mit dem folgenden Befehl können Sie den Browser schnell starten und unter https://PROJECT_ID.REGION_ID.r.appspot.com auf Ihren Webdienst zugreifen:

gcloud app browse

Nächste Schritte

Glückwunsch! Sie haben einen Webdienst erstellt, der Datastore-Datenspeicher und Firebase Authentication verwendet, um authentifizierten Nutzern eine personalisierte Webseite bereitzustellen.

Sie können jetzt mit der Bereinigung beginnen. Beenden oder deaktivieren Sie dazu das Projekt oder deaktivieren Sie die Abrechnung.

Zurück

Nutzer authentifizieren

Weiter

Bereinigen