Compartir a través de

Migración de CouchBase a Azure Cosmos DB para NoSQL

  • Se aplica a: ✅ NoSQL

Azure Cosmos DB es una base de datos totalmente administrada, escalable y distribuida globalmente. Proporciona acceso de baja latencia garantizado a los datos. Para obtener más información sobre Azure Cosmos DB, vea el artículo de información general. En este artículo se proporcionan instrucciones para migrar aplicaciones Java que están conectadas a Couchbase a una API para una cuenta noSQL en Azure Cosmos DB.

Diferencias en la nomenclatura

A continuación se muestran las características clave que funcionan de forma diferente en Azure Cosmos DB en comparación con Couchbase:

Couchbase Azure Cosmos DB (la base de datos de Azure Cosmos)
Servidor Couchbase Cuenta
Cubo Base de datos
Cubo Contenedor o colección
Documento JSON Elemento o documento

Diferencias clave

  • Azure Cosmos DB tiene un campo "ID" dentro del documento, mientras que Couchbase tiene el identificador como parte del cubo. El campo "ID" es único en toda la partición.

  • Azure Cosmos DB se escala mediante la técnica de particionamiento o fragmentación. Lo que significa que divide los datos en varios fragmentos o particiones. Estas particiones o fragmentos se crean en función de la propiedad de clave de partición que proporciones. También puede seleccionar la clave de partición para optimizar las operaciones de lectura y escritura o lectura y escritura optimizadas. Para más información, consulte el artículo creación de particiones .

  • En Azure Cosmos DB, no es necesario que la jerarquía de nivel superior denota la colección porque el nombre de la colección ya existe. Esta característica simplifica la estructura JSON. A continuación se muestra un ejemplo que muestra las diferencias en el modelo de datos entre Couchbase y Azure Cosmos DB:

    Couchbase: Id. de documento = "99FF4444"

    {
  "TravelDocument":
  {
    "Country":"India",
    "Validity" : "2022-09-01",
    "Person":
    {
      "Name": "Manish",
      "Address": "AB Road, City-z"
    },
    "Visas":
    [
      {
      "Country":"India",
      "Type":"Multi-Entry",
      "Validity":"2022-09-01"
      },
      {
      "Country":"US",
      "Type":"Single-Entry",
      "Validity":"2022-08-01"
      }
    ]
  }
}

    Azure Cosmos DB: consulte el "id." en el documento, como se muestra a continuación

    {
  "id" : "99FF4444",

  "Country":"India",
   "Validity" : "2022-09-01",
    "Person":
    {
      "Name": "Manish",
      "Address": "AB Road, City-z"
    },
    "Visas":
    [
      {
      "Country":"India",
      "Type":"Multi-Entry",
      "Validity":"2022-09-01"
      },
      {
      "Country":"US",
      "Type":"Single-Entry",
      "Validity":"2022-08-01"
      }
    ]
  }

Compatibilidad con el SDK de Java

Azure Cosmos DB tiene los siguientes kits de desarrollo de software (SDK) para admitir diferentes marcos de Java:

  • SDK asíncrono
  • Spring Boot SDK

En las secciones siguientes se describe cuándo usar cada uno de estos SDK. Considere un ejemplo en el que tenemos tres tipos de cargas de trabajo:

Couchbase como repositorio de documentos y consultas personalizadas basadas en datos spring

Si la carga de trabajo que va a migrar se basa en el SDK basado en Spring Boot, puede seguir estos pasos:

  1. Agregue el elemento primario al archivo POM.xml:

    <parent>
   <groupId>org.springframework.boot</groupId>
   <artifactId>spring-boot-starter-parent</artifactId>
   <version>2.1.5.RELEASE</version>
   <relativePath/>
</parent>

  2. Agregue propiedades al archivo POM.xml:

    <azure.version>2.1.6</azure.version>

  3. Agregue dependencias al archivo POM.xml:

    <dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>azure-cosmosdb-spring-boot-starter</artifactId>
    <version>2.1.6</version>
</dependency>

  4. Agregue propiedades de aplicación en recursos y especifique lo siguiente. Asegúrese de reemplazar los parámetros de dirección URL, clave y nombre de base de datos:

       azure.cosmosdb.uri=<your-cosmosDB-URL>
   azure.cosmosdb.key=<your-cosmosDB-key>
   azure.cosmosdb.database=<your-cosmosDB-dbName>

  5. Defina el nombre de la colección en el modelo. También puede especificar más anotaciones. Por ejemplo, identificador, clave de partición para indicarlas explícitamente:

    @Document(collection = "mycollection")
    public class User {
        @id
        private String id;
        private String firstName;
        @PartitionKey
        private String lastName;
    }

A continuación se muestran los fragmentos de código para las operaciones CRUD:

Operaciones de inserción y actualización

Donde _repo es el objeto del repositorio y doc es el objeto de la clase POJO. Puede usar .save para insertar o upsert (si se ha encontrado un documento con el id. especificado). El siguiente fragmento de código muestra cómo insertar o actualizar un objeto de documento:

_repo.save(doc);

Operación de borrado

Tenga en cuenta el siguiente fragmento de código, donde el objeto doc tendrá el identificador y la clave de partición obligatorias para localizar y eliminar el objeto:

_repo.delete(doc);

Operación de lectura

Puede leer el documento con o sin especificar la clave de partición. Si no especifica la clave de partición, se trata como una consulta entre particiones. Tenga en cuenta los ejemplos de código siguientes, primero se realizará una operación mediante el campo id. y clave de partición. En el segundo ejemplo se usa un campo normal y sin especificar el campo de clave de partición.

  • _repo.findByIdAndName(objDoc.getId(),objDoc.getName());
  • _repo.findAllByStatus(objDoc.getStatus());

Es decir, ahora puede usar la aplicación con Azure Cosmos DB. El ejemplo de código completo del ejemplo descrito en este documento está disponible en el repositorio CouchbaseToCosmosDB-SpringCosmos de GitHub.

Couchbase como repositorio de documentos y uso de consultas N1QL

Las consultas N1QL son la manera de definir consultas en Couchbase.

Consulta N1QL Consulta de Azure Cosmos DB
SELECT META(TravelDocument).id AS id, TravelDocument.* FROM TravelDocument WHERE _type = "com.xx.xx.xx.xxx.xxx.xxxx " and country = 'India’ and ANY m in Visas SATISFIES m.type == 'Multi-Entry' and m.Country IN ['India', Bhutan’] ORDER BY Validity DESC LIMIT 25 OFFSET 0 SELECT c.id,c FROM c JOIN m in c.country=’India’ WHERE c._type = " com.xx.xx.xx.xxx.xxx.xxxx" and c.country = 'India' and m.type = 'Multi-Entry' and m.Country IN ('India', 'Bhutan') ORDER BY c.Validity DESC OFFSET 0 LIMIT 25

Puede observar los siguientes cambios en las consultas N1QL:

  • No es necesario usar la palabra clave META ni hacer referencia al documento de primer nivel. En su lugar, puede crear su propia referencia al contenedor. En este ejemplo, lo hemos considerado como "c" (puede ser cualquier cosa). Esta referencia se usa como prefijo para todos los campos de primer nivel. Por ejemplo, c.id, c.country, etc.

  • En lugar de "ANY", ahora se puede realizar una combinación en el subdocumento y hacer referencia a él con un alias dedicado como "m". Una vez que haya creado un alias para un subdocumento, debe usar el alias. Por ejemplo, m.Country.

  • La secuencia de OFFSET es diferente en la consulta de Azure Cosmos DB, primero debe especificar OFFSET y, a continuación, LIMIT. Se recomienda no usar el SDK de Spring Data si usa el máximo de consultas definidas personalizadas, ya que puede tener una sobrecarga innecesaria en el lado cliente mientras pasa la consulta a Azure Cosmos DB. En su lugar, tenemos un SDK de Java asincrónico directo, que se puede usar de forma mucho eficaz en este caso.

Operación de lectura

Use el SDK de Java asincrónico con los pasos siguientes:

  1. Configure la dependencia siguiente en el archivo POM.xml:

    <!-- https://mvnrepository.com/artifact/com.microsoft.azure/azure-cosmosdb -->
<dependency>
    <groupId>com.microsoft.azure</groupId>
    <artifactId>azure-cosmos</artifactId>
    <version>3.0.0</version>
</dependency>

  2. Cree un objeto de conexión para Azure Cosmos DB mediante el ConnectionBuilder método como se muestra en el ejemplo siguiente. Asegúrese de colocar esta declaración en el bean para que el código siguiente se ejecute solo una vez:

    ConnectionPolicy cp=new ConnectionPolicy();
cp.connectionMode(ConnectionMode.DIRECT);

if(client==null)
   client= CosmosClient.builder()
      .endpoint(Host)//(Host, PrimaryKey, dbName, collName).Builder()
       .connectionPolicy(cp)
       .key(PrimaryKey)
       .consistencyLevel(ConsistencyLevel.EVENTUAL)
       .build();

container = client.getDatabase(_dbName).getContainer(_collName);

  3. Para ejecutar la consulta, debe ejecutar el siguiente fragmento de código:

    Flux<FeedResponse<CosmosItemProperties>> objFlux= container.queryItems(query, fo);

Ahora, con la ayuda del método anterior, puede pasar varias consultas y ejecutar sin problemas. En caso de que tenga el requisito de ejecutar una consulta grande, que se puede dividir en varias consultas, pruebe el siguiente fragmento de código en lugar del anterior:

for(SqlQuerySpec query:queries)
{
   objFlux= container.queryItems(query, fo);
   objFlux .publishOn(Schedulers.elastic())
         .subscribe(feedResponse->
            {
               if(feedResponse.results().size()>0)
               {
                  _docs.addAll(feedResponse.results());
               }
            
            },
            Throwable::printStackTrace,latch::countDown);
   lstFlux.add(objFlux);
}
                  
      Flux.merge(lstFlux);
      latch.await();
}

Con el código anterior, puede ejecutar consultas en paralelo y aumentar las ejecuciones distribuidas para optimizar. Además, también puede ejecutar las operaciones de inserción y actualización:

Operación de inserción

Para insertar el documento, ejecute el código siguiente:

Mono<CosmosItemResponse> objMono= container.createItem(doc,ro);

A continuación, suscríbase a Mono como:

CountDownLatch latch=new CountDownLatch(1);
objMono .subscribeOn(Schedulers.elastic())
        .subscribe(resourceResponse->
        {
           if(resourceResponse.statusCode()!=successStatus)
              {
                 throw new RuntimeException(resourceResponse.toString());
              }
           },
        Throwable::printStackTrace,latch::countDown);
latch.await();

Operación de upsert

La operación Upsert requiere que especifique el documento que debe actualizarse. Para capturar el documento completo, puede usar el fragmento de código mencionado en la operación de lectura del encabezado y, a continuación, modificar los campos necesarios. El siguiente fragmento de código realiza la operación de upsert en el documento:

Mono<CosmosItemResponse> obs= container.upsertItem(doc, ro);

A continuación, suscríbase a mono. Vea el fragmento de código de suscripción a Mono de la operación de inserción.

Operación de eliminación

El fragmento de código siguiente realizará la operación de eliminación:

CosmosItem objItem= container.getItem(doc.Id, doc.Tenant);
Mono<CosmosItemResponse> objMono = objItem.delete(ro);

Luego, para suscribirse a Mono, vea el fragmento de código de suscripción a Mono de la operación de inserción. El ejemplo de código completo está disponible en el repositorio couchbaseToCosmosDB-AsyncInSpring de GitHub.

Couchbase como par clave-valor

Se trata de un tipo sencillo de carga de trabajo en la que puede realizar búsquedas en lugar de consultas. Siga estos pasos para pares clave-valor:

  1. Considere la posibilidad de tener "/ID" como clave principal, lo que garantiza que puede realizar la operación de búsqueda directamente en la partición específica. Cree una colección y especifique "/ID" como clave de partición.

  2. Desactive completamente la indexación. Dado que ejecutará operaciones de búsqueda, no tiene sentido cargar con la sobrecarga de indexación. Para desactivar la indexación, inicie sesión en el portal de Azure, vaya a la Cuenta de Azure Cosmos DB. Abra el Explorador de datos, seleccione la base de datos y el contenedor. Abra la pestaña Escala y configuración y seleccione la Directiva de indexación. Actualmente, la directiva de indexación es similar a la siguiente:

    {
 "indexingMode": "consistent",
 "automatic": true,
 "includedPaths": [
     {
         "path": "/*"
     }
 ],
 "excludedPaths": [
     {
         "path": "/\"_etag\"/?"
     }
 ]
 }

    Reemplace la directiva de indexación anterior por la siguiente directiva:

    {
 "indexingMode": "none",
 "automatic": false,
 "includedPaths": [],
 "excludedPaths": []
 }

  3. Use el siguiente fragmento de código para crear el objeto de conexión. Objeto de Conexión (para colocar en @Bean o hacerlo estático):

    ConnectionPolicy cp=new ConnectionPolicy();
cp.connectionMode(ConnectionMode.DIRECT);

if(client==null)
   client= CosmosClient.builder()
      .endpoint(Host)//(Host, PrimaryKey, dbName, collName).Builder()
       .connectionPolicy(cp)
       .key(PrimaryKey)
       .consistencyLevel(ConsistencyLevel.EVENTUAL)
       .build();

container = client.getDatabase(_dbName).getContainer(_collName);

Ahora puede ejecutar las operaciones CRUD de la siguiente manera:

Operación de lectura

Para leer el elemento, use el siguiente fragmento de código:

CosmosItemRequestOptions ro=new CosmosItemRequestOptions();
ro.partitionKey(new PartitionKey(documentId));
CountDownLatch latch=new CountDownLatch(1);
      
var objCosmosItem= container.getItem(documentId, documentId);
Mono<CosmosItemResponse> objMono = objCosmosItem.read(ro);
objMono .subscribeOn(Schedulers.elastic())
        .subscribe(resourceResponse->
        {
           if(resourceResponse.item()!=null)
           {
              doc= resourceResponse.properties().toObject(UserModel.class);
           }
        },
        Throwable::printStackTrace,latch::countDown);
latch.await();

Operación de inserción

Para insertar un elemento, puede realizar el código siguiente:

Mono<CosmosItemResponse> objMono= container.createItem(doc,ro);

Luego suscríbase a Mono como:

CountDownLatch latch=new CountDownLatch(1);
objMono.subscribeOn(Schedulers.elastic())
      .subscribe(resourceResponse->
      {
         if(resourceResponse.statusCode()!=successStatus)
            {
               throw new RuntimeException(resourceResponse.toString());
            }
         },
      Throwable::printStackTrace,latch::countDown);
latch.await();

Operación de upsert

Para actualizar el valor de un elemento, consulte el fragmento de código siguiente:

Mono<CosmosItemResponse> obs= container.upsertItem(doc, ro);

Luego, para suscribirse a Mono, vea el fragmento de código de suscripción a Mono de la operación de inserción.

Operación de eliminación

Use el siguiente fragmento de código para ejecutar la operación de eliminación:

CosmosItem objItem= container.getItem(id, id);
Mono<CosmosItemResponse> objMono = objItem.delete(ro);

Luego, para suscribirse a Mono, vea el fragmento de código de suscripción a Mono de la operación de inserción. El ejemplo de código completo está disponible en el repositorio CouchbaseToCosmosDB-AsyncKeyValue de GitHub.

Migración de datos

Use Azure Data Factory para migrar datos. Este es el método más recomendado para migrar los datos. Configura el origen como Couchbase y el destino como Azure Cosmos DB para NoSQL, consulta el artículo Conector de Azure Cosmos DB Data Factory para ver los pasos detallados.

Pasos siguientes

  • Last updated on