Questa pagina è stata tradotta dall'API Cloud Translation.

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

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

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

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

Prima di iniziare

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

Firestore in modalità Datastore offre utilizzo gratuito con limiti giornalieri e operazioni di archiviazione, lettura e scrittura illimitate per gli account a pagamento. Quando le app App Engine sono disattivate, non generano traffico che comporta addebiti, ma l'utilizzo di Datastore potrebbe essere fatturabile se supera i limiti della quota gratuita.
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 dell'applicazione in modo continuo.
- API Cloud Datastore per eseguire la migrazione da Datastore incluso in App Engine a Firestore in modalità Datastore.
  
  Abilita le API
Avere un'app App Engine esistente che esegue Java 8 o 11 e che è collegata al servizio App Engine Datastore.

Panoramica della procedura

A livello generale, il processo per la migrazione a Firestore in modalità Datastore da App Engine Datastore è costituito dai seguenti passaggi:

Aggiornare i file di configurazione
Aggiorna l'app Java
Esegui il commit della transazione
Risultati delle query

Aggiornare i file di configurazione

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

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

Rimuovi le importazioni appengine-api-1.0-sdk dell'SDK App Engine, ad esempio:

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

Aggiungi il client Datastore nel seguente modo:

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

Aggiorna l'app Java

Aggiorna 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 le 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 linee che utilizzano DatastoreServiceFactory.getDatastoreService() , come il seguente:

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

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

Ottenere una chiave generata da Datastore

Dopo aver inizializzato un client, ottieni la chiave creando un nuovo KeyFactory del Kind appropriato e poi chiedi a Datastore di generarne uno per te. Per ottenere Chiave generata da Datastore:

Crea un newKeyFactory.
Chiama il metodo setKind() per determinare il kind dell'entità utilizzata per le classificazioni 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 creazione entità

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

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

Trova le linee che utilizzano la chiamata al costruttore Entity, come segue:
```
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à sulle entità.

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

Trova le righe che utilizzano il metodo setProperty, come la seguente:
```
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 add() per eseguire il commit di una transazione. Per confermare la transazione:

Trova le righe che utilizzano il metodo put(), come la seguente:
```
// 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 i entities che soddisfano un insieme specificato di condizioni. Per visualizzare i risultati, puoi utilizzare i seguenti metodi:

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

Per le query viene utilizzato un metodo con pattern del generatore con la variabile kind. kind è impostata su Visit in Ottenere una chiave generata da Datastore passaggio.

Per recuperare i primi 10 risultati:

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

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

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

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

Verifica se il set di risultati ha un oggetto next per l'elaborazione, anziché eseguire il loop attraverso il dei risultati di ricerca. 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 visualizzare un esempio di come eseguire la migrazione di un'app Java 8 a Firestore in In modalità Datastore, confronta l'esempio di codice Datastore per Java 8 di App Engine e l'esempio di codice Firestore in modalità Datastore in GitHub.

Passaggi successivi

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