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 dem App Engine Datastore, da beide auf denselben zugrunde liegenden Datastore-Dienst verweisen. 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 eine kostenlose Stufe. Sie können damit eine hoch skalierbare NoSQL-Dokumentdatenbank verwalten und haben die Flexibilität, später 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 kostenlose Nutzung mit täglichen Limits sowie unbegrenzten Speicher-, Lese- und Schreibvorgängen für kostenpflichtige Konten. Wenn App Engine-Apps deaktiviert sind, wird kein Traffic generiert und es fallen keine Kosten an. Die Datastore-Nutzung kann jedoch in Rechnung gestellt werden, wenn sie die Grenzwerte für das kostenlose Kontingent überschreitet.
Aktivieren Sie folgende APIs in dem Projekt, das Ihre Anwendung 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 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 der Prozess für 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 so, dass die Clientbibliotheken im Datastore-Modus verwendet werden.

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

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 hinzu, wie im Folgenden dargestellt:

<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 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 Anwendung 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 Methode DatastoreOptions.getDefaultInstance().getService(), 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. Erstellen Sie dazu eine neue KeyFactory des entsprechenden Kind und lassen Sie Datastore einen für Sie generieren. So rufen Sie einen vom Datastore generierten Schlüssel ab:

Erstellen Sie einen newKeyFactory.
Rufen Sie die Methode setKind() auf, um den kind der Entitäten zu ermitteln, die für Abfragekategorisierungen verwendet werden.

Hängen Sie die Methode newKey() an, um einen Datenspeicherschlü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 abgerufen haben, erstellen Sie Entitäten mithilfe der folgenden Methoden:

Verwende Entity.newBuilder und übergebe den vom Datastore generierten Schlüssel.

Suchen Sie die Zeilen, die den Konstruktoraufruf Entity verwenden, wie die folgenden:
```
Entity visit = new Entity(kind);
```
Ersetzen Sie den Konstruktoraufruf von Entity durch den Konstruktoraufruf von Entity.newBuilder, z. B. so:
```
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, zum Beispiel:
```
visit.setProperty("user_ip", userIp);
visit.setProperty("timestamp", Instant.now().toString());
```
Ersetzen Sie die setProperty-Methode durch die set-Methode, z. B. so:
```
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, z. B.:
```
// Save the entity
datastore.put(visit);
```
Ersetzen Sie die put()-Methode durch die add()-Methode, z. B. so:
```
// Save the entity
datastore.add(visit);
```

Abfrageergebnisse

Mit Abfragen werden entities abgerufen, die eine Reihe bestimmter Bedingungen erfüllen. Sie haben folgende Möglichkeiten, Ergebnisse anzuzeigen:

Mit der Methode OrderBy werden die Ergebnisse in aufsteigender oder absteigender Reihenfolge angezeigt.
Die Methode Limit begrenzt die maximale Anzahl von Ergebnissen, die mit demselben Builder abgerufen werden können.

Beim Abfragen wird eine Builder-Mustermethode 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 zehn Ergebnisse ab:

Suchen Sie Zeilen, die die Methode addSort() verwenden, wie zum Beispiel:

  // 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 Methode addSort() durch die Methode setOrderBy() und fügen Sie die Methode setLimit() an, z. B. so:

// 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 der Funktion hasNext().

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

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

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