Esegui la migrazione da Datastore di App Engine a Firestore in modalità Datastore

Questa guida mostra come eseguire la migrazione da App Engine Datastore a Firestore in modalità Datastore (chiamato anche Datastore).

Firestore in modalità Datastore è simile ad App Engine Datastore in quanto entrambi fanno riferimento allo stesso servizio Datastore sottostante. Mentre App Engine Datastore è accessibile solo tramite i servizi in bundle legacy di App Engine, Firestore in modalità Datastore è un prodotto autonomo Google Cloud a cui si accede tramite le librerie client Cloud.

Firestore in modalità Datastore offre anche un livello senza costi e ti consente di gestire un database di documenti NoSQL altamente scalabile e ti offre la flessibilità di eseguire la migrazione a Cloud Run o a un'altra piattaforma di hosting di app in futuro. Google Cloud

Prima di iniziare

Esamina le diverse modalità del database Firestore per assicurarti di comprendere il miglior caso d'uso per la tua app. Tieni presente che questa guida spiega come eseguire la migrazione alla modalità Datastore.
Esamina e comprendi i prezzi e le quote di Firestore in modalità Datastore.

Firestore in modalità Datastore offre un utilizzo senza costi con limiti giornalieri e operazioni di archiviazione, lettura e scrittura illimitate per gli account a pagamento. Mentre le app App Engine sono disattivate, non ricevono traffico e non vengono addebitati costi, tuttavia l'utilizzo di Datastore potrebbe essere fatturabile se supera i limiti della quota senza costi.
Abilita le seguenti API nel progetto contenente la tua app:
- API Artifact Registry per archiviare e gestire gli artefatti della build
- API Cloud Build per creare, testare ed eseguire il deployment della tua applicazione in modo continuo.
- API Cloud Datastore per eseguire la migrazione da Datastore in bundle di App Engine a Firestore in modalità Datastore.
  
  Abilita le API
Avere un'app App Engine esistente che esegue Java 8 o 11 e che è connessa al servizio App Engine Datastore.

Panoramica della procedura

A livello generale, la procedura di migrazione a Firestore in modalità Datastore da App Engine Datastore è costituita dai seguenti passaggi:

Aggiornare i file di configurazione
Aggiornare l'app Java
Conferma la transazione
Risultati query

Aggiornare i file di configurazione

Aggiorna i file di configurazione per utilizzare le librerie client della modalità Datastore.

Aggiorna il file pom.xml dell'app Java di base:

Rimuovi le importazioni dell'SDK App Engine appengine-api-1.0-sdk, come le seguenti:

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

Aggiungi il client Datastore, come segue:

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

Aggiornare l'app Java

Aggiornare le istruzioni di importazione

Modifica i file dell'applicazione aggiornando le righe di importazione e inizializzazione:

Rimuovi le seguenti istruzioni di importazione di App Engine per 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;

Aggiungi i seguenti importazioni di Firestore in modalità Datastore com.google.cloud.datastore.*:

  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;

Modificare il modo in cui l'app accede al servizio Datastore

Firestore in modalità Datastore utilizza la classe Datastore anziché DatastoreService. Per modificare il modo in cui l'app accede al servizio Datastore:

Trova le righe che utilizzano il metodo DatastoreServiceFactory.getDatastoreService(), come le seguenti:

// Initialize a client
DatastoreService datastore = DatastoreServiceFactory.getDatastoreService();

Sostituisci DatastoreServiceFactory.getDatastoreService() con il metodo DatastoreOptions.getDefaultInstance().getService(), come segue:
```
// Initialize a client
Datastore datastore = DatastoreOptions.getDefaultInstance().getService();
```

Ottenere una chiave generata da Datastore

Dopo aver inizializzato un client, recupera la chiave creando un nuovo KeyFactory del Kind appropriato, quindi chiedi a Datastore di generarne una per te. Per ottenere una chiave generata da Datastore:

Crea un newKeyFactory.
Chiama il metodo setKind() per determinare il kind dell'entità utilizzata per le categorizzazioni delle query.

Aggiungi il metodo newKey() per generare una chiave Datastore:

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

Modifica la creazione di entità

Dopo aver ottenuto una chiave Datastore, crea le entità utilizzando i seguenti metodi:

Utilizza Entity.newBuilder e trasmetti la chiave generata da Datastore.

Trova le righe che utilizzano la chiamata al costruttore Entity, come la seguente:
```
Entity visit = new Entity(kind);
```
Sostituisci la chiamata al costruttore Entity con la chiamata al costruttore Entity.newBuilder, come segue:
```
Entity visit = Entity.newBuilder(key);
```
Utilizza il metodo set per impostare le proprietà delle entità.

Il primo parametro è la proprietà di destinazione, mentre il secondo è il valore. Nel caso della proprietà timestamp, il valore è un Timestamp anziché un Instant.toString().

Trova le righe che utilizzano il metodo setProperty, come le seguenti:
```
visit.setProperty("user_ip", userIp);
visit.setProperty("timestamp", Instant.now().toString());
```
Sostituisci il metodo setProperty con il metodo set, come segue:
```
Entity visit = Entity.newBuilder(key).set("user_ip", userIp).set("timestamp", Timestamp.now()).build();
```

Esegui il commit della transazione

La libreria client di Firestore in modalità Datastore utilizza il metodo add() per eseguire il commit di una transazione. Per eseguire il commit della transazione:

Trova le righe che utilizzano il metodo put(), come le seguenti:
```
// Save the entity
datastore.put(visit);
```
Sostituisci il metodo put() con il metodo add(), come segue:
```
// Save the entity
datastore.add(visit);
```

Risultati query

Le query recuperano entities che soddisfano un insieme specificato di condizioni. Per visualizzare i risultati, puoi utilizzare i seguenti metodi:

Il metodo OrderBy mostra i risultati in ordine crescente o decrescente.
Il metodo Limit limita il numero massimo di risultati recuperati utilizzando nello stesso builder.

L'esecuzione di query utilizza un metodo di pattern builder con la variabile kind. La variabile kind è impostata su Visit dal passaggio Ottieni una chiave generata da Datastore.

Per recuperare i primi 10 risultati:

Trova le righe che utilizzano il metodo addSort(), come le seguenti:

  // 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));

Sostituisci il metodo addSort() con il metodo setOrderBy() e aggiungi il metodo setLimit(), come segue:

// 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();

Una volta pronta la query, esegui il codice utilizzando datastore.run() e raccogli i risultati in una raccolta QueryResultsEntity.

L'oggetto QueryResults risultante è un iteratore con una funzione hasNext().

Controlla se il set di risultati contiene un oggetto next per l'elaborazione, anziché scorrere l'elenco dei risultati. Ad esempio:

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"));
      }

Esempi

Per vedere un esempio di come eseguire la migrazione di un'app Java 8 a Firestore in modalità Datastore, confronta l'esempio di codice di App Engine Datastore per Java 8 e l'esempio di codice di Firestore in modalità Datastore su GitHub.

Passaggi successivi

Scopri come utilizzare Firestore in modalità Datastore.
Per ulteriori dettagli, consulta la documentazione di Firestore in modalità Datastore.
Scopri come eseguire la migrazione dai servizi in bundle legacy per Java.

Esegui la migrazione da Datastore di App Engine a Firestore in modalità Datastore Mantieni tutto organizzato con le raccolte Salva e classifica i contenuti in base alle tue preferenze.