Von App Engine Datastore zu Firestore im Datastore-Modus migrieren

In dieser Anleitung wird gezeigt, wie Sie von App Engine Datastore zu Firestore im Datastore-Modus (auch als Datastore bezeichnet) migrieren.

Firestore im Datastore-Modus ähnelt App Engine Datastore, da sich beide auf denselben zugrunde liegenden Datastore-Dienst beziehen. Während auf App Engine Datastore nur über die gebündelten App Engine-Legacy-Dienste zugegriffen werden kann, ist Firestore im Datastore-Modus ein eigenständiges Google Cloud Produkt, auf das über die Cloud-Clientbibliotheken zugegriffen wird.

Firestore im Datastore-Modus bietet auch ein kostenloses Kontingent und ermöglicht es Ihnen, eine hoch skalierbare NoSQL-Dokumentdatenbank zu verwalten. Außerdem haben Sie die Flexibilität, in Zukunft zu Cloud Run oder einer anderen Google Cloud App-Hosting-Plattform zu migrieren.

Hinweise

Prüfen Sie die verschiedenen Firestore-Datenbankmodi, um den besten Anwendungsfall für Ihre Anwendung zu ermitteln. In dieser Anleitung wird beschrieben, wie Sie in den Datastore-Modus migrieren.
Preise und Kontingente von Firestore im Datastore-Modus.

Firestore im Datastore-Modus bietet eine kostenlose Nutzung mit täglichen Limits sowie unbegrenzte Speicher-, Lese- und Schreibvorgänge für kostenpflichtige Konten. Wenn App Engine-Apps deaktiviert sind, wird kein Traffic empfangen, der Kosten verursacht. Die Datastore-Nutzung kann jedoch in Rechnung gestellt werden, wenn sie die Limits für das kostenlose Kontingent überschreitet.
Aktivieren Sie die folgenden APIs in dem Projekt, das Ihre App enthält:
- Artifact Registry API zum Speichern und Verwalten Ihrer Build-Artefakte.
- Cloud Build API zum kontinuierlichen Erstellen, Testen und Bereitstellen Ihrer Anwendung.
- Cloud Datastore API zum Migrieren von App Engine-gebündeltem Datastore zu Firestore im Datastore-Modus.
  
  APIs aktivieren
Sie benötigen eine vorhandene App Engine-Anwendung, auf der Java 8 oder 11 ausgeführt wird und die mit dem App Engine Datastore-Dienst verbunden ist.

Prozessübersicht

Im Großen und Ganzen setzt sich die Migration von App Engine Datastore zu Firestore im Datastore-Modus aus den folgenden Schritten zusammen:

Konfigurationsdateien aktualisieren
Java-App aktualisieren
Commit der Transaktion durchführen
Abfrageergebnisse

Konfigurationsdateien aktualisieren

Aktualisieren Sie Ihre Konfigurationsdateien, um die Clientbibliotheken für den Datastore-Modus zu verwenden.

Aktualisieren Sie die Datei pom.xml Ihrer Baseline-Java-App:

Entfernen Sie die appengine-api-1.0-sdk-Importe des App Engine SDK so:

<dependency>
  <groupId>com.google.appengine</groupId>
  <artifactId>appengine-api-1.0-sdk</artifactId>
  <version>2.0.4</version>
</dependency>

Fügen Sie den Datastore-Client wie folgt hinzu:

<dependency>
  <groupId>com.google.cloud</groupId>
  <artifactId>google-cloud-datastore</artifactId>
  <!-- Use latest version -->
  <version>2.2.9</version>
</dependency>

Java-Anwendung aktualisieren

Importanweisungen aktualisieren

Ändern Sie die Anwendungsdateien, indem Sie die Import- und Initialisierungszeilen aktualisieren:

Entfernen Sie die folgenden App Engine-Importanweisungen für App Engine Datastore com.google.appengine.api.datastore.*:

  import com.google.appengine.api.datastore.DatastoreService;
  import com.google.appengine.api.datastore.DatastoreServiceFactory;
  import com.google.appengine.api.datastore.Entity;
  import com.google.appengine.api.datastore.FetchOptions;
  import com.google.appengine.api.datastore.Query;

Fügen Sie die folgenden com.google.cloud.datastore.*-Importe für Firestore im Datastore-Modus hinzu:

  import com.google.cloud.Timestamp;
  import com.google.cloud.datastore.Datastore;
  import com.google.cloud.datastore.DatastoreOptions;
  import com.google.cloud.datastore.Entity;
  import com.google.cloud.datastore.Key;
  import com.google.cloud.datastore.FullEntity;
  import com.google.cloud.datastore.KeyFactory;
  import com.google.cloud.datastore.Query;
  import com.google.cloud.datastore.QueryResults;
  import com.google.cloud.datastore.StructuredQuery;

Zugriff der Anwendung auf den Datastore-Dienst ändern

In Firestore im Datastore-Modus wird die Klasse Datastore anstelle von DatastoreService verwendet. So ändern Sie den Zugriff Ihrer App auf den Datastore-Dienst:

Suchen Sie die Zeilen, die die Methode DatastoreServiceFactory.getDatastoreService() verwenden, wie etwa die folgenden:
```
// Initialize a client
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();
```
Ersetzen Sie DatastoreServiceFactory.getDatastoreService() durch die DatastoreOptions.getDefaultInstance().getService()-Methode, z. B. so:
```
// Initialize a client
Datastore datastore = DatastoreOptions.getDefaultInstance().getService();
```

Von Datastore generierten Schlüssel abrufen

Nachdem Sie einen Client initialisiert haben, rufen Sie Ihren Schlüssel ab, indem Sie eine neue KeyFactory des entsprechenden Kind erstellen und dann von Datastore einen Schlüssel generieren lassen. So erhalten Sie einen von Datastore generierten Schlüssel:

Erstellen Sie einen newKeyFactory.
Rufen Sie die Methode setKind() auf, um die kind der Entität zu ermitteln, die für die Kategorisierung von Anfragen verwendet wird.

Hängen Sie die Methode newKey() an, um einen Datastore-Schlüssel zu generieren:

//Prepare a new entity
String kind = "visit";
Key key = datastore.allocateId(datastore.newKeyFactory().setKind(kind).newKey());

Erstellung von Entitäten ändern

Nachdem Sie einen Datastore-Schlüssel erhalten haben, können Sie Entitäten mit den folgenden Methoden erstellen:

Verwenden Sie Entity.newBuilder und übergeben Sie den von Datastore generierten Schlüssel.

Suchen Sie die Zeilen, die den Konstruktoraufruf Entity verwenden, wie etwa die folgenden:
```
Entity visit = new Entity(kind);
```
Ersetzen Sie den Entity-Konstruktoraufruf durch den Entity.newBuilder-Konstruktoraufruf, wie im folgenden Beispiel:
```
Entity visit = Entity.newBuilder(key);
```
Verwenden Sie die Methode set, um Attribute für Entitäten festzulegen.

Der erste Parameter ist das beabsichtigte Attribut und der zweite der Wert. Beim Attribut timestamp ist der Wert ein Timestamp anstelle eines Instant.toString().

Suchen Sie die Zeilen, die die Methode setProperty verwenden, wie etwa die folgenden:
```
visit.setProperty("user_ip", userIp);
visit.setProperty("timestamp", Instant.now().toString());
```
Ersetzen Sie die setProperty-Methode durch die set-Methode, wie im folgenden Beispiel:
```
Entity visit = Entity.newBuilder(key).set("user_ip", userIp).set("timestamp", Timestamp.now()).build();
```

Commit der Transaktion durchführen

Die Clientbibliothek von Firestore im Datastore-Modus verwendet die Methode add(), um einen Commit einer Transaktion durchzuführen. So führen Sie ein Commit der Transaktion durch:

Suchen Sie nach Zeilen, in denen die Methode put() verwendet wird, wie etwa die folgenden:
```
// Save the entity
datastore.put(visit);
```
Ersetzen Sie die put()-Methode durch die add()-Methode, wie im folgenden Beispiel:
```
// Save the entity
datastore.add(visit);
```

Abfrageergebnisse

Bei Abfragen werden entities abgerufen, die einen bestimmten Satz von Bedingungen erfüllen. Sie haben folgende Möglichkeiten, Ergebnisse zu präsentieren:

Mit der Methode OrderBy werden die Ergebnisse in aufsteigender oder absteigender Reihenfolge angezeigt.
Mit der Methode Limit wird die maximale Anzahl der Ergebnisse begrenzt, die mit im selben Builder abgerufen werden.

Für die Abfrage wird eine Builder-Pattern-Methode mit der Variablen kind verwendet. Die Variable kind wird auf Visit aus dem Schritt Von Datastore generierten Schlüssel abrufen gesetzt.

So rufen Sie die ersten 10 Ergebnisse ab:

Suchen Sie nach Zeilen, in denen die Methode addSort() verwendet wird, wie etwa die folgenden:

  // Retrieve the last 10 visits from the datastore, ordered by timestamp.
  Query query = new Query(kind).addSort("timestamp", Query.SortDirection.DESCENDING);
  List<Entity> results = datastore.prepare(query).asList(FetchOptions.Builder.withLimit(10));

Ersetzen Sie die addSort()-Methode durch die setOrderBy()-Methode und hängen Sie die setLimit()-Methode an, wie im folgenden Beispiel:

// Retrieve the last 10 visits from the datastore, ordered by timestamp.
Query<Entity> query = Query.newEntityQueryBuilder()
                        .setKind(kind)
                        .setOrderBy(StructuredQuery.OrderBy.desc("timestamp"))
                        .setLimit(10)
                        .build();

Wenn die Abfrage fertig ist, führen Sie den Code mit datastore.run() aus und erfassen Sie die Ergebnisse in einer QueryResultsEntity-Sammlung.

Das resultierende QueryResults-Objekt ist ein Iterator mit einer hasNext()-Funktion.

Prüfen Sie, ob die Ergebnismenge ein next-Objekt zur Verarbeitung enthält, anstatt in einer Schleife die Ergebnisliste zu durchlaufen. Beispiele:

QueryResults<Entity> results = datastore.run(query);

      resp.setContentType("text/plain");
      PrintWriter out = resp.getWriter();
      out.print("Last 10 visits:\n");
      while (results.hasNext()) {
          Entity entity = results.next();
          out.format(
                  "Time: %s Addr: %s\n", entity.getTimestamp("timestamp"), entity.getString("user_ip"));
      }

Beispiele

Für ein Beispiel für die Migration einer Java 8-Anwendung zu Firestore im Datastore-Modus vergleichen Sie das Codebeispiel für App Engine Datastore für Java 8 und das Codebeispiel für Firestore im Datastore-Modus in GitHub.

Weiteres Vorgehen

Informationen zur Verwendung von Firestore im Datastore-Modus
Weitere Informationen finden Sie in der Dokumentation zu Firestore im Datastore-Modus.
Informationen zur Migration ausgehend von gebündelten Legacy-Diensten für Java

Von App Engine Datastore zu Firestore im Datastore-Modus migrieren Mit Sammlungen den Überblick behalten Sie können Inhalte basierend auf Ihren Einstellungen speichern und kategorisieren.