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 Google Cloud piattaforma di hosting Google Cloud di app.

Prima di iniziare

Esamina le diverse modalità del database Firestore per assicurarti di comprendere il caso d'uso migliore per la tua app. Tieni presente che questa guida illustra 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 gratuito con limiti giornalieri e operazioni di lettura, scrittura e archiviazione 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

In linea generale, la procedura per eseguire la migrazione a Firestore in modalità Datastore da Datastore di App Engine è costituita dai seguenti passaggi:

Aggiornare i file di configurazione
Aggiornare l'app Java
Eseguire 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 riferimento:

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, ad esempio:

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

Aggiornare 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 Datastore di App Engine 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 com.google.cloud.datastore.* di Firestore in modalità 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 la modalità di accesso dell'app al servizio Datastore:

Trova le righe che utilizzano il metodo DatastoreServiceFactory.getDatastoreService(), ad esempio:

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

Modificare la creazione di 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 righe che utilizzano la chiamata del 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à sulle entità.

Il primo parametro è la proprietà prevista e il secondo è il valore. Nel caso della proprietà timestamp, il valore è Timestamp anziché 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, ad esempio:
```
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 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(), ad esempio:
```
// 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 utilizzando nello stesso generatore.

L'esecuzione di query utilizza un metodo del pattern di 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 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();

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é eseguire un ciclo nell'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.