Esta página se ha traducido con Cloud Translation API.

Migrar de App Engine Datastore a Firestore en modo Datastore

En esta guía se muestra cómo migrar de App Engine Datastore a Firestore en modo de almacén de datos (también conocido como Datastore).

Firestore en el modo Datastore es similar a Datastore de App Engine, ya que ambos hacen referencia al mismo servicio de Datastore subyacente. Aunque solo se puede acceder a Datastore de App Engine a través de los servicios empaquetados antiguos de App Engine, Firestore en el modo de Datastore es un producto independiente al que se accede a través de las bibliotecas de cliente de Cloud. Google Cloud

Firestore en el modo de Datastore también ofrece un nivel gratuito y te permite gestionar una base de datos de documentos NoSQL altamente escalable, así como tener la flexibilidad de migrar a Cloud Run u otra plataforma de alojamiento de aplicaciones en el futuro. Google Cloud

Antes de empezar

Consulta los diferentes modos de base de datos de Firestore para saber cuál es el mejor caso práctico para tu aplicación. Ten en cuenta que en esta guía se explica cómo migrar al modo de Datastore.
Consulta y comprende los precios y las cuotas de Firestore en el modo de Datastore.

Firestore en el modo de Datastore ofrece límites de uso gratuito diarios y operaciones de almacenamiento, lectura y escritura ilimitadas para las cuentas de pago. Mientras las aplicaciones de App Engine estén inhabilitadas, no recibirán tráfico y, por lo tanto, no se les aplicarán cargos. Sin embargo, el uso de Datastore puede facturarse si supera los límites de la cuota gratuita.
Habilita las siguientes APIs en el proyecto que contiene tu aplicación:
- API de Artifact Registry para almacenar y gestionar tus artefactos de compilación
- API Cloud Build para compilar, probar y desplegar tu aplicación de forma continua.
- API de Cloud Datastore para migrar de Datastore empaquetado de App Engine a Firestore en el modo de Datastore.
  
  Habilitar APIs
Tener una aplicación de App Engine que ejecute Java 8 u 11 y que esté conectada al servicio Datastore de App Engine.

Descripción general del proceso

A grandes rasgos, el proceso para migrar a Firestore en el modo de Datastore desde App Engine Datastore consta de los siguientes pasos:

Actualizar archivos de configuración
Actualizar una aplicación Java
Confirma la transacción
Resultados de la consulta

Actualizar los archivos de configuración

Actualiza los archivos de configuración para usar las bibliotecas de cliente del modo Datastore.

Actualiza el archivo pom.xml de tu aplicación Java de referencia:

Elimina las importaciones del SDK de App Engine appengine-api-1.0-sdk, como las siguientes:

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

Añade el cliente Datastore, como se indica a continuación:

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

Actualizar una aplicación Java

Actualizar las instrucciones de importación

Modifica los archivos de tu aplicación actualizando las líneas de importación e inicialización:

Elimina las siguientes instrucciones de importación de App Engine para 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;

Añade las siguientes importaciones de com.google.cloud.datastore.*Firestore en modo 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;

Modificar la forma en que tu aplicación accede al servicio Datastore

Firestore en el modo de Datastore usa la clase Datastore en lugar de DatastoreService. Para modificar la forma en que tu aplicación accede al servicio Datastore, sigue estos pasos:

Busca las líneas que usen el método DatastoreServiceFactory.getDatastoreService() como las siguientes:

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

Sustituye DatastoreServiceFactory.getDatastoreService() por el método DatastoreOptions.getDefaultInstance().getService(), como se muestra a continuación:
```
// Initialize a client
Datastore datastore = DatastoreOptions.getDefaultInstance().getService();
```

Obtener una clave generada por Datastore

Después de inicializar un cliente, obtenga su clave creando un nuevo KeyFactory del Kind adecuado y, a continuación, pida a Datastore que genere uno. Para obtener una clave generada por Datastore, sigue estos pasos:

Crea una newKeyFactory.
Llama al método setKind() para determinar el kind de la entidad que se ha usado para categorizar las consultas.

Añade el método newKey() para generar una clave de Datastore:

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

Modificar la creación de entidades

Después de obtener una clave de Datastore, cree entidades con los siguientes métodos:

Usa Entity.newBuilder y envía la clave generada por Datastore.

Busca las líneas que usen la llamada al constructor Entity, como la siguiente:
```
Entity visit = new Entity(kind);
```
Sustituye la llamada al constructor Entity por la llamada al constructor Entity.newBuilder, como se muestra a continuación:
```
Entity visit = Entity.newBuilder(key);
```
Usa el método set para definir propiedades en las entidades.

El primer parámetro es la propiedad de destino y el segundo es el valor. En el caso de la propiedad timestamp, el valor es un Timestamp en lugar de un Instant.toString().

Busca las líneas que usan el método setProperty, como las siguientes:
```
visit.setProperty("user_ip", userIp);
visit.setProperty("timestamp", Instant.now().toString());
```
Sustituye el método setProperty por el método set, como se indica a continuación:
```
Entity visit = Entity.newBuilder(key).set("user_ip", userIp).set("timestamp", Timestamp.now()).build();
```

Confirmar la transacción

La biblioteca de cliente de Firestore en el modo Datastore usa el método add() para confirmar una transacción. Para confirmar la transacción, sigue estos pasos:

Busca líneas que usen el método put(), como las siguientes:
```
// Save the entity
datastore.put(visit);
```
Sustituye el método put() por el método add(), como se indica a continuación:
```
// Save the entity
datastore.add(visit);
```

Resultados de la consulta

Las consultas recuperan entities que cumplen un conjunto de condiciones especificado. Puedes usar los siguientes métodos para mostrar los resultados:

El método OrderBy muestra los resultados en orden ascendente o descendente.
El método Limit limita el número máximo de resultados obtenidos mediante en el mismo compilador.

Las consultas usan un método de patrón de compilación con la variable kind. La variable kind se define como Visit en el paso Obtener una clave generada por Datastore.

Para obtener los 10 primeros resultados, sigue estos pasos:

Busca líneas que usen el método addSort(), como las siguientes:

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

Sustituye el método addSort() por el método setOrderBy() y añade el método setLimit(), como se muestra a continuación:

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

Cuando la consulta esté lista, ejecuta el código con datastore.run() y recoge los resultados en una colección QueryResultsEntity.

El objeto QueryResults resultante es un iterador con una función hasNext().

Comprueba si el conjunto de resultados tiene un objeto next para procesarlo en lugar de recorrer la lista de resultados. Por ejemplo:

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

Ejemplos

Para ver un ejemplo de cómo migrar una aplicación Java 8 a Firestore en el modo de Datastore, compara el código de muestra de App Engine Datastore para Java 8 y el código de muestra de Firestore en el modo de Datastore en GitHub.

Siguientes pasos

Consulta cómo usar Firestore en modo Datastore.
Consulta más información en la documentación de Firestore en modo Datastore.
Consulta cómo dejar de usar los servicios antiguos agrupados en Java.

Migrar de App Engine Datastore a Firestore en modo Datastore Organízate con las colecciones Guarda y clasifica el contenido según tus preferencias.