Android-App mit Firebase und der flexiblen App Engine-Umgebung erstellen

Last reviewed 2018-07-31 UTC

In dieser Anleitung erfahren Sie, wie Sie mit Firebase eine mobile App mit Back-End-Datenspeicher, Echtzeitsynchronisierung und Nutzerereignis-Logging schreiben. Java-Servlets, die in der flexiblen App Engine-Umgebung von Google Cloud Platform (GCP) ausgeführt werden, warten auf neue Nutzerlogs, die in Firebase gespeichert sind, und verarbeiten sie.

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 Folgendes veranschaulicht:

  • Erstellen der Android-App "PlayChat", die Daten in der Firebase-Echtzeitdatenbank speichert

  • Ausführen eines Java-Servlets in der flexiblen App Engine-Umgebung, 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 entsprechend den Kosten der zugrunde liegenden virtuellen Maschinen von Google Compute Engine abgerechnet.

Vorbereitung

Installieren Sie folgende Software:

Installieren Sie die App Engine Java-Komponente der gcloud CLI, indem Sie folgenden Befehl über die Befehlszeile ausführen.

gcloud components install app-engine-java

Beispielcode klonen

  1. Klonen Sie den Front-End-Client-App-Code.

    git clone https://github.com/GoogleCloudPlatform/firebase-android-client

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

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

SHA-1-Fingerabdruck für die App erstellen

Um Ihre Client-App für Google Sign-in zu authentifizieren, müssen Sie einen SHA-1-Fingerabdruck des Zertifikats angeben. In dieser Anleitung wird der Keystore für die Fehlerbehebung verwendet. Weitere Informationen zum Erstellen von Release-Versionen des Keystore-Fingerabdrucks finden Sie unter Client authentifizieren.

  • Erstellen Sie ein SHA-1 des Schlüsselspeichers für die Fehlerbehebung.

    keytool -list -v \
-alias androiddebugkey -keystore ~/.android/debug.keystore

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. Wenn Sie die Seite zum ersten Mal besuchen, klicken Sie auf Projekt erstellen.

  4. Geben Sie unter Projektname Folgendes ein: Playchat.

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

    • Sie müssen Google Analytics für dieses Projekt nicht aktivieren.

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

  7. Klicken Sie auf der Seite Projektübersicht Ihres Projekts auf Einstellungen und wählen Sie Projekteinstellungen aus.

  8. Klicken Sie auf das Android-Symbol, um die Seite Firebase zu meiner Android-App hinzufügen aufzurufen.

  9. Geben Sie unter Android-Paketname Folgendes ein: com.google.cloud.solutions.flexenv.

  10. Geben Sie im Feld SHA1-Wert des Signaturzertifikats für die Fehlerbehebung den SHA-1-Wert ein, den Sie im vorherigen Schritt erstellt haben.

  11. Klicken Sie auf App registrieren.

  12. Führen Sie die Schritte im Abschnitt Konfigurationsdatei herunterladen aus, um die Datei google-services.json Ihrem Projekt hinzuzufügen.

  13. Klicken Sie im Bereich Konfigurationsdatei herunterladen auf Weiter.

  14. Notieren Sie sich die Änderungsvorschläge für die Projekt- und App-Ebene der build.gradle-Dateien.

  15. Klicken Sie im Bereich Firebase-SDK hinzufügen auf Weiter.

  16. Klicken Sie auf Weiter zur Konsole, um die Einrichtung abzuschließen.

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>

Abrechnungen und APIs für das Cloud Platform-Projekt aktivieren

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

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

    Zur Seite "Projekte"

  2. Die Abrechnung für das Google Cloud-Projekt muss aktiviert sein.

  3. App Engine Admin API and Compute Engine API APIs aktivieren.

    Aktivieren Sie die 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 Client-Anfragen zu verarbeiten.

Firebase und Google Play-Dienste der Android-App hinzufügen

Die Client-App verwendet die Firebase Realtime Database, um Nachrichten zu speichern und zu synchronisieren und um Nutzerereignis-Logs aufzuzeichnen. Die Client-App verwendet Google Play-Dienste, um Nutzer anhand ihres Google-Kontos zu authentifizieren.

  1. Wählen Sie in Android Studio Tools > SDK-Manager aus.

  2. Wählen Sie den Tab SDK-Tools aus.

  3. Wählen Sie Google Play-Dienste aus, falls sie nicht bereits ausgewählt sind.

  4. Klicken Sie auf OK, um sie zu installieren.

  5. Wählen Sie Datei > Öffnen… und anschließend das Verzeichnis firebase-android-client aus.

  6. Warten Sie, bis die Gradle-Projektinformationen fertiggestellt wurden. Wenn Sie zur Verwendung des Gradle-Wrappers aufgefordert werden, klicken Sie auf OK.

  7. Die Änderungen an den build.gradle-Dateien auf Projekt- und App-Ebene, die Sie im Abschnitt Firebase-Projekt erstellen notiert haben, wurden im Beispielcode bereits vorgenommen.

Android-App ausführen und testen

  1. Wählen Sie in Android Studio bei geöffnetem Projekt firebase-android-client Ausführen > "App" ausführen aus.

  2. Wählen Sie als Testgerät ein Gerät oder einen Emulator aus, der Android 6.0 mit Google APIs ausführt.

  3. Wenn die App auf das Gerät geladen wurde, melden Sie sich mit Ihrem Google-Konto an.

    In PlayChat anmelden

  4. Klicken Sie auf das Menü links neben dem PlayChat-Titel und wählen Sie den Kanal "books" aus.

    Kanal auswählen

  5. Geben Sie eine Nachricht ein.

    Nachricht senden

  6. 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 auswä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 Android-App PlayChat definiert eine Klasse, FirebaseLogger, die sie verwendet, um Nutzerereignislogs in die Firebase Realtime Database zu schreiben.

app/src/main/java/com/google/cloud/solutions/flexenv/FirebaseLogger.java 

import com.google.cloud.solutions.flexenv.common.LogEntry;
import com.google.firebase.database.DatabaseReference;
import com.google.firebase.database.FirebaseDatabase;

/*
 * FirebaseLogger pushes user event logs to a specified path.
 * A backend servlet instance listens to
 * the same key and keeps track of event logs.
 */
class FirebaseLogger {
    private final DatabaseReference logRef;

    FirebaseLogger(String path) {
        logRef = FirebaseDatabase.getInstance().getReference().child(path);
    }

    public void log(String tag, String message) {
        LogEntry entry = new LogEntry(tag, message);
        logRef.push().setValue(entry);
    }

}

Wenn sich ein neuer Nutzer anmeldet, ruft PlayChat die Funktion requestLogger auf, um dem Speicherort /inbox/ 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.

app/src/main/java/com/google/cloud/solutions/flexenv/PlayActivity.java 
/*
 * Request that a servlet instance be assigned.
 */
private void requestLogger(final LoggerListener loggerListener) {
    final DatabaseReference databaseReference = FirebaseDatabase.getInstance().getReference();
    databaseReference.child(IBX + "/" + inbox).addListenerForSingleValueEvent(new ValueEventListener() {
        public void onDataChange(@NonNull DataSnapshot snapshot) {
            if (snapshot.exists() && snapshot.getValue(String.class) != null) {
                firebaseLoggerPath = IBX + "/" + snapshot.getValue(String.class) + "/logs";
                fbLog = new FirebaseLogger(firebaseLoggerPath);
                databaseReference.child(IBX + "/" + inbox).removeEventListener(this);
                loggerListener.onLoggerAssigned();
            }
        }

        public void onCancelled(@NonNull DatabaseError error) {
            Log.e(TAG, error.getDetails());
        }
    });

    databaseReference.child(REQLOG).push().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:

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 Cloud Platform Console löschen, da die Firebase- und Cloud Platform-Projekte identisch sind.

  1. Wechseln Sie in der Google Cloud Console zur Seite Ressourcen verwalten.

    Zur Seite „Ressourcen verwalten“

  2. Wählen Sie in der Projektliste das Projekt aus, das Sie löschen möchten, und klicken Sie dann auf Löschen.
  3. Geben Sie im Dialogfeld die Projekt-ID ein und klicken Sie auf Shut down (Beenden), um das Projekt zu löschen.

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

Wenn Sie Ihr Cloud Platform- und Firebase-Projekt nicht löschen möchten, können Sie die Kosten reduzieren, indem Sie die nicht standardmäßigen Versionen Ihrer flexiblen App Engine-Umgebungsanwendung löschen.

  1. Rufen Sie in der Google Cloud Console die Seite Versionen für App Engine auf.

    Zur Seite "Versionen"

  2. Klicken Sie auf das Kästchen für die nicht standardmäßige Anwendungsversion, die Sie löschen möchten.
  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.