Diese Seite wurde von der Cloud Translation API übersetzt.

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 in Zukunft flexibel zu Cloud Run oder einer anderen Google Cloud App-Hosting-Plattform 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 und unbegrenzte Speicher-, Lese- und Schreibvorgänge 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 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 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-Anwendung aktualisieren
Commit der Transaktion durchführen
Abfrageergebnisse

Konfigurationsdateien aktualisieren

Aktualisieren Sie Ihre Konfigurationsdateien, um die Clientbibliotheken im Datastore-Modus zu verwenden.

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, z. B. so:

<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 den 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

Im Firestore-Datastore-Modus wird die Klasse Datastore anstelle von DatastoreService verwendet. So ändern Sie, wie Ihre App auf den Datastore-Dienst zugreift:

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, können Sie Ihren Schlüssel abrufen, indem Sie eine neue KeyFactory der entsprechenden Kind erstellen und dann von Datastore einen generieren lassen. So rufen Sie einen von Datastore generierten Schlüssel ab:

Erstellen Sie einen newKeyFactory.
Rufen Sie die Methode setKind() auf, um die kind der Entität zu ermitteln, die für die Kategorisierung von Suchanfragen 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 mit den folgenden Methoden Entitäten erstellen:

Verwenden Sie Entity.newBuilder und geben Sie den vom Datastore generierten Schlüssel weiter.

Suchen Sie die Zeilen, die den Konstruktoraufruf Entity verwenden, wie etwa 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, wie etwa die folgenden:
```
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 einen Commit der Transaktion durch:

Suchen Sie die Zeilen, die die Methode put() verwenden, wie etwa die folgenden:
```
// 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.
Mit der Methode Limit wird die maximale Anzahl der Ergebnisse begrenzt, die mit „“ im selben Builder abgerufen werden.

Für 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 10 Ergebnisse ab:

Suchen Sie nach Zeilen, die die Methode addSort() verwenden, z. B.:

  // 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 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 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.