iOS-App mit Firebase und der flexiblen App Engine-Umgebung entwickeln

Last reviewed 2018-08-27 UTC

In dieser Anleitung wird veranschaulicht, wie Sie mit Firebase eine iOS-App mit Back-End-Datenspeicher, Echtzeitsynchronisierung und Nutzerereignis-Logging entwickeln. In der flexiblen App Engine-Umgebung ausgeführte Java-Servlets prüfen, ob neue Nutzerlogs in Firebase gespeichert wurden, und verarbeiten diese.

Bei der vorliegenden Anleitung wird davon ausgegangen, dass Sie mit Firebase und der flexiblen App Engine-Umgebung arbeiten.

Wenn Ihre App Nutzerdaten verarbeiten oder Ereignisse verwalten soll, können Sie Firebase mit der flexiblen App Engine-Umgebung erweitern, um eine automatische Echtzeitdatensynchronisierung durchzuführen.

Die Beispiel-App "PlayChat" speichert Chatnachrichten in der Firebase Realtime Database, die diese Daten automatisch auf den Geräten synchronisiert. PlayChat schreibt außerdem Nutzerereignislogs in Firebase. Weitere Informationen dazu, wie in der Datenbank Daten synchronisiert werden, finden Sie in der Firebase-Dokumentation unter Funktionsweise.

Das folgende Diagramm zeigt die PlayChat-Clientarchitektur.

PlayChat-Clientarchitektur

Eine Reihe von Java-Servlets, die in der flexiblen App Engine-Umgebung ausgeführt werden, melden sich als Listener in Firebase an. Die Servlets antworten auf neue Nutzerereignislogs und verarbeiten die Logdaten. Sie verwenden Transaktionen, um sicherzustellen, dass nur ein Servlet auf jedes Nutzerereignislog angesetzt ist.

Das folgende Diagramm zeigt die PlayChat-Serverarchitektur.

PlayChat-Serverarchitektur

Die Kommunikation zwischen der App und dem Servlet erfolgt in drei Teilen:

  • Wenn sich ein neuer Nutzer bei PlayChat anmeldet, fordert die App ein Logging-Servlet für diesen Nutzer an. Dazu fügt sie in der Firebase Realtime Database unter /inbox/ einen Eintrag hinzu.

  • Eines der Servlets akzeptiert die Zuordnung, indem es den Wert des Eintrags in seiner Servlet-ID aktualisiert. Das Servlet verwendet eine Firebase-Transaktion, um sicherzustellen, dass kein anderes Servlet den Wert aktualisieren kann. Nachdem der Wert aktualisiert wurde, wird die Anfrage von allen anderen Servlets ignoriert.

  • Wenn sich der Nutzer anmeldet, abmeldet oder zu einem neuen Kanal wechselt, wird die Aktion von PlayChat in /inbox/[SERVLET_ID]/[USER_ID]/ protokolliert. Dabei ist [SERVLET_ID] die ID der Servlet-Instanz und [USER_ID] ein Hashwert, der für den Nutzer steht.

  • Das Servlet überwacht den Posteingang auf neue Einträge und erfasst die Logdaten.

In dieser Beispiel-App kopieren die Servlets die Logdaten lokal und zeigen diese auf einer Webseite an. In einer Produktionsversion dieser App können die Logdaten von den Servlets verarbeitet oder für die Speicherung und Analyse nach Cloud Storage, Cloud Bigtable oder BigQuery kopiert werden.

Ziele

In dieser Anleitung wird erklärt, wie Sie:

  • Die iOS-App PlayChat erstellen, die Daten in der Firebase Realtime Database speichert

  • Ein Java-Servlet in der flexiblen App Engine-Umgebung ausführen, das eine Verbindung zu Firebase herstellt und Benachrichtigungen empfängt, wenn sich die in Firebase gespeicherten Daten ändern

  • Mithilfe dieser beiden Komponenten einen verteilten Streaming- und Back-End-Dienst zum Erfassen und Verarbeiten von Logdaten erstellen

Kosten

Firebase kann kostenlos genutzt werden. Wenn die Nutzung dieser Dienste in den Rahmen des kostenlosen Firebase-Tarifs fallen, wird die Nutzung von Firebase nicht berechnet.

Instanzen innerhalb der flexiblen App Engine-Umgebung werden nach den Kosten der zugrunde liegenden virtuellen Maschinen in Compute Engine berechnet.

Hinweis

Installieren Sie folgende Software:

Installieren Sie die App Engine Java-Komponente der gcloud CLI. Führen Sie dazu den folgenden Befehl in einem Terminalfenster aus:

gcloud components install app-engine-java

Beispielcode klonen

  1. Klonen Sie den Code der Client-App.

    git clone https://github.com/GoogleCloudPlatform/firebase-ios-samples

  2. Klonen Sie den Back-End-Servlet-Code.

    git clone https://github.com/GoogleCloudPlatform/firebase-appengine-backend

Firebase-Projekt erstellen

  1. Erstellen Sie ein Firebase-Konto oder melden Sie sich in einem bestehenden Konto an.

  2. Klicken Sie auf Projekt hinzufügen.

  3. Geben Sie unter Projektname Folgendes ein: Playchat. Notieren Sie sich die Projekt-ID, die Ihrem Projekt zugewiesen ist. Sie wird in dieser Anleitung in mehreren Schritten verwendet.

  4. Folgen Sie den verbleibenden Einrichtungsschritten und klicken Sie auf Projekt erstellen.

  5. Klicken Sie nach der Bereitstellung des Projekts durch den Assistenten auf Weiter.

  6. Klicken Sie auf der Seite Übersicht des Projekts auf Einstellungen und dann auf Projekteinstellungen.

  7. Klicken Sie auf Firebase zu meiner iOS-App hinzufügen.

  8. Geben Sie unter iOS-Bundle-ID Folgendes ein: com.google.cloud.solutions.flexenv.PlayChat.

  9. Klicken Sie auf App registrieren.

  10. Führen Sie die Schritte im Bereich Konfigurationsdatei herunterladen aus, um die Datei GoogleService-Info.plist dem Ordner PlayChat des Projekts hinzuzufügen.

  11. Klicken Sie im Bereich Konfigurationsdatei herunterladen auf Weiter.

  12. Notieren Sie sich die Anleitung zum Installieren und Verwalten von Projektabhängigkeiten mit CocoaPods. Der CocoaPods-Abhängigkeitsmanager ist im Beispielcode bereits konfiguriert.

  13. Führen Sie den folgenden Befehl aus, um die Abhängigkeiten zu installieren: Der Befehl kann eine längere Ausführungszeit benötigen.

    pod install

    Wenn die CocoaPods-Installation die Firebase-Abhängigkeit nicht finden kann, führen Sie den Befehl pod repo update aus.

    Verwenden Sie anschließend für die weitere Entwicklung in der iOS-App die neu erstellte Datei .xcworkspace anstelle der Datei .xcodeproj.

  14. Klicken Sie im Abschnitt Firebase-SDK hinzufügen auf Weiter.

  15. Notieren Sie sich den Code, der zum Initialisieren von Firebase in Ihrem Projekt erforderlich ist.

  16. Klicken Sie im Bereich Initialisierungscode hinzufügen auf Weiter.

  17. Klicken Sie im Abschnitt Run your app to verify installation (App ausführen, um die Installation zu überprüfen) auf Skip this step (Diesen Schritt überspringen).

Echtzeitdatenbank erstellen

  1. Wählen Sie in der Firebase Console Ihr Projekt aus.

  2. Wählen Sie im Menü auf der linken Seite der Konsole in der Gruppe Build die Option Realtime Database aus.

  3. Klicken Sie im Abschnitt Realtime Database auf Datenbank erstellen.

  4. Wählen Sie einen Standort in Ihrer Nähe aus.

  5. Wählen Sie im Dialogfeld Sicherheitsregeln die Option Im Testmodus starten aus und klicken Sie dann auf Aktivieren.

    In diesem Schritt werden die Daten angezeigt, die Sie in Firebase gespeichert haben. In späteren Schritten dieser Anleitung können Sie diese Webseite noch einmal aufrufen, um die von der Client-App und dem Back-End-Servlet hinzugefügten und aktualisierten Daten anzuzeigen.

  6. Im Tab der Datenbank Regeln müssen die Sicherheitsregeln für den Lese-/Schreibzugriff ein Datum angeben, das 30 Tage in der Zukunft liegt, wobei die Zeiteinheit in Unix-Epochenzeit definiert ist. Wenn Sie die Regel beispielsweise am 4. August erstellen, sollte sie nach dem 4. September ablaufen:

    {
  "rules": {
    ".read": "now < 1659639249000", //2022-08-04
    ".write": "now < 1659639249000" //2022-08-04
  }
}

  7. Notieren Sie sich die Firebase-URL für Ihr Projekt. Sie hat das Format https://[FIREBASE_PROJECT_ID].firebaseio.com/ und wird neben einem Linksymbol angezeigt.

Google-Authentifizierung für das Firebase-Projekt aktivieren

Es gibt viele Anmeldemethoden, die Sie konfigurieren können, um eine Verbindung zu Ihrem Firebase-Projekt herzustellen. In dieser Anleitung erfahren Sie, wie Sie die Authentifizierung einrichten, damit sich der Nutzer mit einem Google-Konto anmelden kann.

  1. Klicken Sie im linken Menü der Firebase Console in der Gruppe Build auf Authentifizierung.

  2. Klicken Sie auf Anmeldemethode einrichten oder Jetzt starten, wenn Sie die Seite zum ersten Mal besuchen.

  3. Unter dem Tab Anmeldemethode: Wählen Sie Google aus, aktivieren Sie den Schalter Aktivieren, wählen Sie die Support-E-Mail-Adresse aus und klicken Sie auf Speichern.

Dienstkonto dem Firebase-Projekt hinzufügen

Für das Back-End-Servlet wird kein Google-Konto zur Anmeldung verwendet. Stattdessen wird ein Dienstkonto für die Verbindung mit Firebase genutzt. Mit den folgenden Schritten erstellen Sie ein Dienstkonto, mit dem eine Verbindung zu Firebase hergestellt werden kann, und fügen dem Servlet-Code die Anmeldedaten für dieses Dienstkonto hinzu.

  1. Klicken Sie im Menü auf der linken Seite der Firebase Console neben der Startseite des Projekts "PlayChat" auf das Zahnradsymbol für Einstellungen und dann auf Projekteinstellungen.

  2. Wählen Sie Dienstkonten aus und klicken Sie dann auf den Link Dienstkontoberechtigungen verwalten.

  3. Klicken Sie auf Dienstkonto erstellen.

  4. Legen Sie folgende Einstellungen fest:

    1. Geben Sie unter Name des Dienstkontos den Namen playchat-servlet ein und klicken Sie dann auf Erstellen und fortfahren.

    2. Wählen Sie unter Rolle auswählen die Option Projekt > Inhaber aus und klicken Sie dann auf Weiter.

    3. Klicken Sie auf Fertig.

  5. Klicken Sie auf das soeben erstellte Dienstkonto, klicken Sie auf dem Tab SCHLÜSSEL auf Schlüssel hinzufügen und dann auf Neuen Schlüssel erstellen.

  6. Klicken Sie neben Schlüsseltyp auf JSON und dann auf Erstellen, um den Schlüssel herunterzuladen.

  7. Speichern Sie die heruntergeladene JSON-Schlüsseldatei für das Dienstkonto im Back-End-Dienstprojekt firebase-appengine-backend im Verzeichnis src/main/webapp/WEB-INF/. Der Dateiname hat das Format Playchat-[UNIQUE_ID].json.

  8. Bearbeiten Sie src/main/webapp/WEB-INF/web.xml und ändern Sie die Initialisierungsparameter so:

    • Ersetzen Sie JSON_FILE_NAME durch den Namen der heruntergeladenen JSON-Schlüsseldatei.

    • Ersetzen Sie FIREBASE_URL durch die zuvor notierte Firebase-URL.

      <init-param>
  <param-name>credential</param-name>
  <param-value>/WEB-INF/JSON_FILE_NAME</param-value>
</init-param>
<init-param>
  <param-name>databaseUrl</param-name>
  <param-value>FIREBASE_URL</param-value>
</init-param>

Abrechnung und APIs für das Google Cloud-Projekt aktivieren

Damit der Back-End-Dienst in der GCP ausgeführt werden kann, müssen Sie die Abrechnung und die APIs für das Projekt aktivieren. Das Cloud-Projekt ist dasselbe, das Sie im Abschnitt Firebase-Projekt erstellen erstellt haben, und hat dieselbe Projekt-ID.

  1. Wählen Sie in der Google Cloud Console das PlayChat-Projekt aus.

    Zur Seite "Projekte"

  2. Make sure that billing is enabled for your Google Cloud project.

  3. Enable the App Engine Admin and Compute Engine APIs.

    Enable the APIs

Back-End-Dienst erstellen und bereitstellen

Der Back-End-Dienst in diesem Beispiel verwendet eine Docker-Konfiguration zur Definition seiner Hosting-Umgebung. Diese Anpassung bedeutet, dass Sie anstelle der App Engine-Standardumgebung die flexible App Engine-Umgebung verwenden müssen.

Sie können das Maven-Plug-in der Google App Engine verwenden, um das Back-End-Servlet zu erstellen und in der flexiblen App Engine-Umgebung bereitzustellen. Dieses Plug-in ist bereits in der mit diesem Beispiel enthaltenen Maven-Build-Datei angegeben.

Projekt einrichten

Damit Maven das Back-End-Servlet ordnungsgemäß erstellen kann, müssen Sie es dem Google Cloud Platform-Projekt (GCP) bereitstellen, in dem die Servlet-Ressourcen gestartet werden. Die GCP-Projekt-ID und die Firebase-Projekt-ID sind identisch.

  1. Geben Sie die Anmeldedaten an, die die gcloud CLI für den Zugriff auf die GCP verwendet.

    gcloud auth login

  2. Setzen Sie das Projekt mit folgendem Befehl auf Ihr Firebase-Projekt und ersetzen Sie [FIREBASE_PROJECT_ID] durch den Namen der zuvor notierten Firebase-Projekt-ID.

    gcloud config set project [FIREBASE_PROJECT_ID]

  3. Prüfen Sie durch Auflisten der Konfiguration, ob das Projekt eingerichtet wurde.

    gcloud config list

  4. Wenn Sie App Engine zum ersten Mal verwenden, initialisieren Sie die App Engine-Anwendung:

    gcloud app create

(Optional) Dienst auf dem lokalen Server ausführen

Wenn Sie einen neuen Back-End-Dienst entwickeln, führen Sie den Dienst lokal aus, bevor Sie ihn für App Engine bereitstellen. Dadurch werden Änderungen schnell iteriert, ohne dass eine vollständige Bereitstellung in App Engine erforderlich ist.

Wenn Sie den Server lokal ausführen, verwendet er keine Docker-Konfiguration und er wird nicht in einer App Engine-Umgebung ausgeführt. Stattdessen gewährleistet Maven, dass alle abhängigen Bibliotheken lokal installiert sind und die App auf dem Jetty-Webserver ausgeführt wird.

  1. Erstellen Sie im Verzeichnis firebase-appengine-backend das Back-End-Modul und führen Sie es mit dem folgenden Befehl lokal aus:

    mvn clean package appengine:run

    Wenn Sie das Google Cloud CLI in einem anderen Verzeichnis als ~/google-cloud-sdk installiert haben, fügen Sie dem Befehl wie unten gezeigt den Installationspfad hinzu und ersetzen Sie dabei [PATH_TO_TOOL] durch Ihren benutzerdefinierten Pfad.

    mvn clean package appengine:run -Dgcloud.gcloud_directory=[PATH_TO_TOOL]

  2. Wenn die Aufforderung Soll die Anwendung "Python.app" eingehende Netzwerkverbindungen akzeptieren? angezeigt wird, wählen Sie Zulassen aus.

Öffnen Sie nach der Bereitstellung http://localhost:8080/printLogs, um zu überprüfen, ob Ihr Back-End-Dienst ausgeführt wird. Die Webseite zeigt Posteingang:, gefolgt von einer 16-stelligen ID an. Dies ist die Posteingangs-ID für das Servlet, das auf dem lokalen Computer ausgeführt wird.

Wenn Sie die Seite aktualisieren, ändert sich diese Kennzeichnung nicht. Ihr lokaler Server erstellt eine einzelne Servlet-Instanz. Dies ist zum Testen hilfreich, da in der Firebase-Echtzeitdatenbank nur eine Servlet-ID gespeichert ist.

Klicken Sie auf Strg + C, um den lokalen Server herunterzufahren.

Dienst in der flexiblen App Engine-Umgebung bereitstellen

Wenn Sie den Back-End-Dienst in der flexiblen App Engine-Umgebung ausführen, verwendet App Engine die Konfiguration in /firebase-appengine-backend/src/main/webapp/Dockerfiles, um die Hostingumgebung zu erstellen, in der der Dienst ausgeführt wird. Die flexible Umgebung erstellt mehrere Servlet-Instanzen und skaliert sie nach Bedarf.

  • Erstellen Sie mit dem folgenden Befehl das Back-End-Modul im Verzeichnis firebase-appengine-backend und führen Sie es lokal aus:

    mvn clean package appengine:deploy

    mvn clean package appengine:deploy -Dgcloud.gcloud_directory=[PATH_TO_GCLOUD]

Beim Ausführen des Builds wird die Meldung "Sende Build-Kontext zu Docker-Daemon…" angezeigt. Der vorherige Befehl lädt die Docker-Konfiguration hoch und richtet sie in der flexiblen App Engine-Umgebung ein.

Wenn die Bereitstellung beendet ist, öffnen Sie https://[FIREBASE_PROJECT_ID].appspot.com/printLogs. [FIREBASE_PROJECT_ID] ist hier die ID aus dem Abschnitt Firebase-Projekt erstellen. Die Webseite zeigt Posteingang:, gefolgt von einer 16-stelligen ID an. Dies ist die Posteingangs-ID für ein Servlet, das in der flexiblen App Engine-Umgebung ausgeführt wird.

Wenn Sie die Seite aktualisieren, ändert sich diese ID regelmäßig, da App Engine mehrere Servlet-Instanzen erstellt, um eingehende Clientanfragen zu verarbeiten.

URL-Schema im iOS-Beispiel aktualisieren

  1. Öffnen Sie in Xcode bei geöffnetem PlayChat-Arbeitsbereich den Ordner PlayChat.

  2. Öffnen Sie GoogleService-Info.plist und kopieren Sie den Wert von REVERSED_CLIENT_ID.

  3. Öffnen Sie Info.plist und rufen Sie key URL types > Item 0 (Editor) > URL Schemes > Item 0 auf.

  4. Ersetzen Sie den Platzhalterwert [REVERSED_CLIENT_ID] durch den Wert, den Sie aus GoogleService-Info.plist kopiert haben.

iOS-App ausführen und testen

  1. Wählen Sie in Xcode bei geöffnetem PlayChat-Arbeitsbereich Product > Run aus.

  2. Wenn die App auf den Simulator geladen wird, melden Sie sich mit Ihrem Google-Konto an.

    In PlayChat anmelden

  3. Wählen Sie den Kanal Books aus.

  4. Geben Sie eine Nachricht ein.

    Nachricht senden

Hierbei speichert die PlayChat-App Ihre Nachricht in der Firebase Realtime Database. Firebase synchronisiert die in der Datenbank gespeicherten Daten geräteübergreifend. Geräte, auf denen Playchat ausgeführt wird, zeigen die neue Nachricht an, wenn ein Nutzer den Kanal Books wählt.

Nachricht senden

Daten prüfen

Nachdem Sie die PlayChat-App verwendet haben, um einige Nutzerereignisse mit der PlayChat-App zu generieren, können Sie überprüfen, ob sich die Servlets als Listener anmelden und Nutzerereignislogs sammeln.

Öffnen Sie die Firebase Realtime Database für Ihre App, wobei [FIREBASE_PROJECT_ID] die ID aus dem Abschnitt Firebase-Projekt erstellen ist.

https://console.firebase.google.com/project/[FIREBASE_PROJECT_ID]/database/data

Am unteren Rand der Firebase Realtime Database befindet sich unter dem Datenspeicherort /inbox/ eine Gruppe von Knoten mit dem Präfix client-, gefolgt von einem zufällig generierten Schlüssel, der die Kontoanmeldung eines Nutzers darstellt. Auf den letzten Eintrag in diesem Beispiel, client-1240563753, folgt eine 16-stellige ID des Servlets, das derzeit Logereignisse dieses Nutzers beobachtet, in diesem Beispiel 0035806813827987.

In Firebase Realtime Database gespeicherte Daten

Unmittelbar darüber befinden sich unter dem Datenspeicherort /inbox/ Servlet-IDs für alle aktuell zugewiesenen Servlets. In diesem Beispiel erfasst nur ein einziges Servlet Logs. Unter /inbox/[SERVLET_IDENTIFIER] befinden sich die Nutzerlogs, die von der App in dieses Servlet geschrieben wurden.

Öffnen Sie die Seite "App Engine" für Ihren Back-End-Dienst unter https://[FIREBASE_PROJECT_ID].appspot.com/printLogs. [FIREBASE_PROJECT_ID] ist hierbei die ID aus dem Abschnitt Firebase-Projekt erstellen. Die Seite zeigt die ID für das Servlet an, das die von Ihnen generierten Nutzerereignisse aufgezeichnet hat. Auch die Logeinträge für diese Ereignisse werden unter der Posteingangs-ID des Servlets angezeigt.

Code erforschen

Die PlayChat iOS-App definiert eine Klasse (FirebaseLogger) die sie verwendet, um Nutzerereignislogs in die Firebase Realtime Database zu schreiben.

PlayChat/FirebaseLogger.swift 
import Firebase

class FirebaseLogger {
  var logRef: DatabaseReference!

  init(ref: DatabaseReference!, path: String!) {
    logRef = ref.child(path)
  }

  func log(_ tag: String!, message: String!) {
    let entry: LogEntry = LogEntry(tag: tag, log: message)
    logRef.childByAutoId().setValue(entry.toDictionary())
  }
}

Wenn sich ein neuer Nutzer anmeldet, ruft PlayChat die Funktion requestLogger auf, um dem Speicherort /requestLogger/ in der Firebase Realtime Database einen neuen Eintrag hinzuzufügen und einen Listener festzulegen, damit PlayChat reagieren kann, wenn ein Servlet den Wert dieses Eintrags aktualisiert und damit die Zuordnung akzeptiert.

Wenn ein Servlet den Wert aktualisiert, entfernt PlayChat den Listener und schreibt das Log „Angemeldet“ in den Posteingang des Servlets.

PlayChat/AppDelegate.swift 
func requestLogger() {
  ref.child(IBX + "/" + inbox!).removeValue()
  ref.child(IBX + "/" + inbox!)
    .observe(.value, with: { snapshot in
      print(self.inbox!)
      if snapshot.exists() {
        self.fbLog = FirebaseLogger(ref: self.ref, path: self.IBX + "/"
          + String(describing: snapshot.value!) + "/logs")
        self.ref.child(self.IBX + "/" + self.inbox!).removeAllObservers()
        self.msgViewController!.fbLog = self.fbLog
        self.fbLog!.log(self.inbox, message: "Signed in")
      }
    })
  ref.child(REQLOG).childByAutoId().setValue(inbox)
}

Auf der Seite des Back-End-Dienstes stellt die Funktion init(ServletConfig config) in MessageProcessorServlet.java beim Start einer Servlet-Instanz eine Verbindung zur Firebase Realtime Database her und fügt dem Datenspeicherort /inbox/ einen Listener hinzu.

Wenn dem Datenspeicherort /inbox/ ein neuer Eintrag hinzugefügt wird, aktualisiert das Servlet den Wert mit seiner ID. Das ist ein Signal für die PlayChat-App, dass das Servlet die Zuordnung zur Bearbeitung von Logs für diesen Nutzer akzeptiert. Das Servlet verwendet Firebase-Transaktionen, um sicherzustellen, dass nur ein einziges Servlet den Wert aktualisieren und die Zuweisung akzeptieren kann.

src/main/java/com/google/cloud/solutions/flexenv/backend/MessageProcessorServlet.java 
/*
 * Receive a request from a client and reply back its inbox ID.
 * Using a transaction ensures that only a single servlet instance replies
 * to the client. This lets the client know to which servlet instance
 * send consecutive user event logs.
 */
firebase.child(REQLOG).addChildEventListener(new ChildEventListener() {
  public void onChildAdded(DataSnapshot snapshot, String prevKey) {
    firebase.child(IBX + "/" + snapshot.getValue()).runTransaction(new Transaction.Handler() {
      public Transaction.Result doTransaction(MutableData currentData) {
        // Only the first servlet instance writes its ID to the client inbox.
        if (currentData.getValue() == null) {
          currentData.setValue(inbox);
        }
        return Transaction.success(currentData);
      }

      public void onComplete(DatabaseError error, boolean committed, DataSnapshot snapshot) {}
    });
    firebase.child(REQLOG).removeValue();
  }
  // ...
});

Nachdem ein Servlet eine Zuordnung zur Bearbeitung der Ereignislogs eines Nutzers akzeptiert hat, fügt es einen Listener hinzu, der erkennt, wann die PlayChat-App eine neue Logdatei in den Posteingang des Servlets schreibt. Das Servlet antwortet, indem es die neuen Logdaten aus der Firebase Realtime Database abruft.

src/main/java/com/google/cloud/solutions/flexenv/backend/MessageProcessorServlet.java 
/*
 * Initialize user event logger. This is just a sample implementation to
 * demonstrate receiving updates. A production version of this app should
 * transform, filter, or load to another data store such as Google BigQuery.
 */
private void initLogger() {
  String loggerKey = IBX + "/" + inbox + "/logs";
  purger.registerBranch(loggerKey);
  firebase.child(loggerKey).addChildEventListener(new ChildEventListener() {
    public void onChildAdded(DataSnapshot snapshot, String prevKey) {
      if (snapshot.exists()) {
        LogEntry entry = snapshot.getValue(LogEntry.class);
        logs.add(entry);
      }
    }

    public void onCancelled(DatabaseError error) {
      localLog.warning(error.getDetails());
    }

    public void onChildChanged(DataSnapshot arg0, String arg1) {}

    public void onChildMoved(DataSnapshot arg0, String arg1) {}

    public void onChildRemoved(DataSnapshot arg0) {}
  });
}

Bereinigen

So vermeiden Sie, dass Ihrem Google Cloud Platform-Konto die in dieser Anleitung verwendeten Ressourcen berechnet werden:

Google Cloud Platform- und Firebase-Projekt löschen

Am einfachsten vermeiden Sie weitere Kosten, wenn Sie das für die Anleitung erstellte Projekt löschen. Obwohl Sie das Projekt in der Firebase Console erstellt haben, können Sie es auch in der Google Cloud Console löschen, da die Firebase- und Cloud-Projekte identisch sind.

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

Nicht standardmäßige Versionen Ihrer App Engine-App löschen

Wenn Sie das GCP- und Firebase-Projekt nicht löschen möchten, können Sie Kosten senken, wenn Sie die nicht standardmäßigen Versionen der App in der flexiblen App Engine-Umgebung löschen.

  1. In the Google Cloud console, go to the Versions page for App Engine.

    Go to Versions

  2. Select the checkbox for the non-default app version that you want to delete.
  3. Klicken Sie zum Löschen der Anwendungsversion auf Löschen.

Nächste Schritte

  • Daten analysieren und archivieren – In diesem Beispiel speichern die Servlets Logdaten nur im Speicher. Sie können dieses Beispiel bei Bedarf erweitern und die Servlets beispielsweise anweisen, die Daten mithilfe von Diensten wie Cloud Storage, Cloud Bigtable, Google Cloud Dataflow und BigQuery zu archivieren, zu transformieren und zu analysieren.

  • Arbeitslast gleichmäßig auf Servlets verteilen – App Engine bietet eine automatische und eine manuelle Skalierung. Bei der automatischen Skalierung erkennt die flexible Umgebung Änderungen in der Arbeitslast und reagiert durch Hinzufügen oder Entfernen von VM-Instanzen im Cluster. Bei manueller Skalierung geben Sie eine statische Anzahl von Instanzen zur Handhabung des Traffics an. Weitere Informationen zur Konfiguration der Skalierung finden Sie in der App Engine-Dokumentation unter Einstellungen der Dienstskalierung.

    Da die Nutzeraktivitätslogs den Servlets über die Firebase Realtime Database zugewiesen werden, wird die Arbeitslast möglicherweise nicht gleichmäßig verteilt. Beispielsweise kann es vorkommen, dass ein Servlet mehr Nutzerereignislogs verarbeitet als andere Servlets.

    Sie können die Effizienz verbessern, indem Sie einen Arbeitslastmanager implementieren, der die Arbeitslast unabhängig auf jeder VM steuert. Dieser Arbeitslastenausgleich kann auf Messwerte, wie zum Beispiel Logging-Anfragen pro Sekunde oder Anzahl gleichzeitiger Clients, basieren.

  • Nicht verarbeitete Nutzerereignislogs wiederherstellen – In dieser beispielhaften Implementierung sendet die Client-App, die mit einer Instanz verknüpft ist, weiterhin Logereignisse an den Posteingang des Servlets in der Firebase Realtime Database, wenn diese Servlet-Instanz abstürzt. In einer Produktionsversion dieser App muss der Back-End-Dienst diese Situation erkennen, um die nicht verarbeiteten Nutzerereignislogs wiederherzustellen.

  • Zusätzliche Features mit Cloud KI-Produkten implementieren – Hier wird beschrieben, wie Sie mit Cloud KI-Produkten und -Diensten ML-basierte Features nutzen. Zum Beispiel können Sie dieses Implementierungsbeispiel um ein Sprachübersetzungsfeature erweitern, die eine Kombination aus den Speech-to-Text, Translation und Text-to-Speech APIs verwendet. Weitere Informationen finden Sie unter Sprachübersetzung zur Android-App hinzufügen.