Migra de Aerospike a Bigtable

---

En este instructivo, se describe cómo migrar datos de Aerospike a Bigtable. En este instructivo, se explican las diferencias entre Aerospike y Bigtable, y cómo transformar la carga de trabajo para ejecutar en Bigtable. Es para profesionales de bases de datos que buscan un servicio de base de datos en Google Cloud similar a Aerospike. En este instructivo, se supone que conoces los esquemas de base de datos, los tipos de datos, los aspectos principales de NoSQL y los sistemas de base de datos relacional. Este instructivo se basa en la ejecución de tareas predefinidas para realizar una migración de ejemplo. Después de terminar el instructivo, puedes modificar el código proporcionado y los pasos para que coincidan con tu entorno.

Cloud Bigtable es un servicio de base de datos NoSQL completamente administrado y a escala de petabytes para grandes cargas de trabajo de análisis y operaciones. Puedes usarlo como motor de almacenamiento para tu servicio de baja latencia y a escala de petabytes con mayor disponibilidad y durabilidad. Puedes analizar datos en Cloud Bigtable con los servicios de análisis de datos de Google Cloud, como Dataproc y BigQuery.

Bigtable es ideal para los servicios de la tecnología publicitaria, la tecnología financiera y la Internet de las cosas (IoT) que se implementan con bases de datos NoSQL, como AeroSpike o Cassandra. Si buscas un servicio administrado por NoSQL, usa Bigtable.

Arquitectura

En el siguiente diagrama de arquitectura de referencia, se muestran los componentes comunes que puedes usar para migrar datos de Aerospike a Bigtable.

En el diagrama anterior, los datos migran de un entorno local mediante Aerospike a Bigtable en Google Cloud mediante dos métodos diferentes. El primer método migra los datos mediante el procesamiento por lotes. Para comenzar, se mueven los datos de la copia de seguridad de Aerospike a un bucket de Cloud Storage. Cuando llegan los datos de copia de seguridad a Cloud Storage, se activa Cloud Functions para iniciar un proceso de extracción, transformación y carga (ETL) por lotes con Dataflow. El trabajo de Dataflow convierte los datos de la copia de seguridad en un formato compatible con Bigtable y, luego, importa los datos a la instancia de Bigtable.

El segundo método migra los datos mediante el procesamiento de transmisión. En este método, te conectas a Aerospike con una cola de mensajes, como Kafka, que usa Aerospike Connect, y transfieres mensajes en tiempo real a Pub/Sub en Google Cloud. Cuando llega el mensaje a un tema de Pub/Sub, el trabajo de transmisión de Dataflow lo procesa en tiempo real para convertir y, luego, importar los datos a la instancia de Bigtable.

Con el procesamiento por lotes, puedes migrar grandes fragmentos de datos de forma eficiente. Sin embargo, a menudo requiere tiempo de inactividad suficiente durante la migración de sistemas, mientras se migra y actualiza el servicio para bases de datos nuevas. Si quieres minimizar el tiempo de inactividad durante la migración de sistemas, te recomendamos usar el procesamiento de transmisión para migrar datos de forma gradual después del primer procesamiento por lotes a fin de mantener la coherencia de los datos de la copia de seguridad hasta que finalice el traspaso. En este documento, puedes migrar de Aerospike mediante el procesamiento por lotes con aplicaciones de ejemplo, incluido el proceso de migración de sistemas.

Compara Aerospike y Bigtable

Antes de comenzar la migración de datos, es fundamental que comprendas las diferencias del modelo de datos entre Aerospike y Bigtable.

El modelo de datos de Bigtable es un mapa de clave-valor distribuido, multidimensional y ordenado con familias de columnas y filas. Por el contrario, el modelo de datos Aerospike es una base de datos orientada a filas, en la que cada registro se identifica de forma única con una clave. La diferencia entre los modelos es la forma en que agrupan los atributos de una entidad. Bigtable agrupa los atributos relacionados en una familia de columnas, mientras que Aerospike agrupa los atributos en un conjunto. Aerospike admite más tipos de datos en comparación con Bigtable. Por ejemplo, Aerospike admite números enteros, strings, listas y mapas. Bigtable trata todos los datos como strings de bytes sin procesar para todos los propósitos.

Un esquema en Aerospike es flexible y los valores dinámicos en las mismas discretizaciones pueden tener tipos diferentes. Las aplicaciones que usan Aerospike o Bigtable tienen una flexibilidad similar y responsabilidad de administración de datos: las apps manejan tipos de datos y restricciones de integridad, en lugar de depender del motor de base de datos.

Migración de Bookshelf

La app de Bookshelf es una aplicación web en la que los usuarios pueden almacenar información sobre libros y ver la lista de todos los libros almacenados actualmente en la base de datos. La app usa un identificador de libro (ID) para buscar información sobre libros. La app o la base de datos genera estos ID de forma automática. Cuando un usuario selecciona la imagen de un libro, el backend de la app carga los detalles de ese libro desde la base de datos.

En este instructivo, migrarás a Bigtable los datos de la app de Bookshelf con Aerospike. Después de la migración, puedes acceder a los libros desde Bigtable.

En el siguiente diagrama, se muestra cómo se migran los datos de Aerospike a Bigtable:

En el diagrama anterior, los datos se migran de la siguiente manera:

1. Realiza una copia de seguridad de los datos sobre libros de la base de datos actual de Aerospike y transfiere los datos a un bucket de Cloud Storage.
2. Cuando subes los datos de la copia de seguridad al bucket, se muestra automáticamente el trabajo de Dataflow as2bt a través de notificaciones de actualización de Cloud Storage mediante Cloud Function.
3. Después de que el trabajo de Dataflow as2bt completa la migración de datos, puedes cambiar el backend de la base de datos de Aerospike a Bigtable para que la app de Bookshelf cargue los datos de libros del clúster de Bigtable.

Objetivos

• Implementa un entorno de instructivo para la migración de Aerospike a Bigtable.
• Crea en Cloud Storage desde Aerospike un conjunto de datos de copia de seguridad de la app de ejemplo.
• Usa Dataflow para transferir el esquema de datos y migrarlo a Bigtable.
• Cambia la configuración de la app de ejemplo para usar Bigtable como un backend.
• Verifica que la app de Bookshelf se ejecute de forma correcta con Bigtable.

Costos

En este documento, usarás los siguientes componentes facturables de Google Cloud:

• Compute Engine
• Bigtable
• Pub/Sub
• Cloud Storage
• Dataflow

Para generar una estimación de costos en función del uso previsto, usa la calculadora de precios. Es posible que los usuarios nuevos de Google Cloud califiquen para obtener una prueba gratuita.

Los cargos de Bigtable se basan en la cantidad de horas de procesamiento de nodo, y la cantidad de datos almacenados y el ancho de banda de red que usas. Para estimar el costo del clúster de Bigtable y otros recursos, puedes usar la calculadora de precios. En la configuración de la calculadora de precios de ejemplo, se usan tres nodos de Bigtable en lugar de uno solo. El costo total estimado del ejemplo anterior es superior al costo total real de este instructivo.

Cuando finalices las tareas que se describen en este documento, puedes borrar los recursos que creaste para evitar que continúe la facturación. Para obtener más información, consulta Cómo realizar una limpieza.

Antes de comenzar

1. En la página del selector de proyectos de la consola de Google Cloud, selecciona o crea un proyecto de Google Cloud.

   Nota: Si no planeas conservar los recursos que creaste durante este procedimiento, crea un proyecto en lugar de seleccionar uno existente. Cuando termines, puedes borrar el proyecto y quitar todos los recursos asociados con él.

   Ir al selector de proyectos

2. Asegúrate de que la facturación esté habilitada para tu proyecto de Google Cloud.

3. Habilita Cloud Resource Manager API.

   Habilita la API

   Terraform usa la API de Cloud Resource Manager para habilitar las APIs necesarias en este instructivo.

4. En la consola de Google Cloud, activa Cloud Shell.

   Activar Cloud Shell

Prepare su entorno

A fin de preparar el entorno para la migración de Aerospike a Bigtable, debes ejecutar las siguientes herramientas directamente desde Cloud Shell:

• Google Cloud CLI
• La herramienta de línea de comandos gsutil
• La herramienta de línea de comandos de Bigtable, cbt
• Terraform
• Apache Maven

Estas herramientas ya están disponibles en Cloud Shell, por lo que no es necesario que las instales de nuevo.

Configura tu proyecto

1. En Cloud Shell, inspecciona el ID del proyecto que Cloud Shell configura automáticamente. El símbolo del sistema se actualiza para reflejar el proyecto activo actual y se muestra en este formato: USERNAME@cloudshell:~ (PROJECT_ID)$

   Si el ID del proyecto no está configurado correctamente, sigue estos pasos para hacerlo de forma manual:

   gcloud config set project <var>PROJECT_ID</var>
   

   Reemplaza PROJECT_ID por el ID del proyecto de Google Cloud.

2. Configura us-east1 como la región y us-east1-b como la zona:

   gcloud config set compute/region us-east1
   gcloud config set compute/zone us-east1-b
   

   Para obtener más información sobre las regiones y zonas, consulta Geografía y regiones.

Implementa el entorno del instructivo

1. En Cloud Shell, clona el repositorio de código:

    git clone https://github.com/fakeskimo/as2bt.git/
   

2. En Cloud Shell, inicializa el directorio de trabajo de Terraform:

   cd "$HOME"/as2bt/bookshelf/terraform
   terraform init
   

3. Configura las variables de entorno de Terraform para su implementación:

   export TF_VAR_gce_vm_zone="$(gcloud config get-value compute/zone)"
   export TF_VAR_gcs_bucket_location="$(gcloud config get-value compute/region)"
   

4. Revisa el plan de ejecución de Terraform:

   terraform plan
   

   El resultado es similar al siguiente:

   Terraform will perform the following actions:
   # google_bigtable_instance.bookshelf_bigtable will be created
   + resource "google_bigtable_instance" "bookshelf_bigtable" {
     + display_name  = (known after apply)
     + id            = (known after apply)
     + instance_type = "DEVELOPMENT"
     + name          = "bookshelf-bigtable"
     + project       = (known after apply)
     + cluster {
         + cluster_id   = "bookshelf-bigtable-cluster"
         + storage_type = "SSD"
         + zone         = "us-east1-b"
       }
   }
   

5. Para visualizar qué recursos con dependencias se implementan en Terraform, dibuja gráficos (opcional):

   terraform graph | dot -Tsvg > graph.svg
   

6. Aprovisiona el entorno del instructivo:

   terraform apply
   

Verifica el entorno del instructivo y la app de Bookshelf

Después de aprovisionar el entorno y antes de comenzar el trabajo de migración de datos, debes verificar que todos los recursos se hayan implementado y configurado. En esta sección, se explica cómo verificar el proceso de aprovisionamiento y te ayuda a comprender qué componentes están configurados en el entorno.

Verifica el entorno del instructivo

1. En Cloud Shell, verifica la instancia bookshelf-aerospike de Compute Engine:

   gcloud compute instances list
   

   El resultado muestra que la instancia se implementa en la zona us-east1-b:

   NAME                 ZONE        MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP  STATUS
   bookshelf-aerospike  us-east1-b  n1-standard-2               10.142.0.4   34.74.72.3   RUNNING
   

2. Verifica la instancia bookshelf-bigtable de Bigtable:

   gcloud bigtable instances list
   

   El resultado es similar al siguiente:

   NAME                DISPLAY_NAME        STATE
   bookshelf-bigtable  bookshelf-bigtable  READY
   

   Esta instancia de Bigtable se usa como destino de migración para los pasos posteriores.

3. Verifica que el depósito bookshelf de Cloud Storage esté en el trabajo de canalización de Dataflow:

   gsutil ls -b gs://bookshelf-*
   

   Debido a que los nombres de los buckets de Cloud Storage deben ser únicos a nivel global, el nombre del bucket se crea con un sufijo aleatorio. El resultado es similar al siguiente:

   gs://bookshelf-616f60d65a3abe62/
   

Agrega un libro a la aplicación Bookshelf

1. En Cloud Shell, obtén la dirección IP externa de la instancia bookshelf-aerospike:

   gcloud compute instances list --filter="name:bookshelf-aerospike" \
       --format="value(networkInterfaces[0].accessConfigs.natIP)"
   

   Toma nota de la dirección IP, ya que será necesaria en el siguiente paso.

2. Para abrir la app de Bookshelf, ve a http://IP_ADDRESS:8080 desde un navegador web.

   Reemplaza IP_ADDRESS por la dirección IP externa que copiaste del paso anterior.

3. Para crear un libro nuevo, haz clic en Agregar libro.

4. En la ventana Agregar libro, completa los siguientes campos y haz clic en Guardar:

   • En el campo Title, ingresa Aerospike-example.
   • En el campo Author, ingresa Aerospike-example.
   • En el campo Fecha de publicación, ingresa la fecha de hoy.
   • En el campo Descripción, ingresa Aerospike-example.

   Este libro se usa para verificar que la app de Bookshelf use Aerospike como el almacenamiento del libro.

5. En la URL de la app de Bookshelf, toma nota del ID del libro. Por ejemplo, si la URL es 34.74.80.160:8080/books/10000, el ID del libro es 10000.

   

6. En Cloud Shell, usa SSH para conectarte a la instancia bookshelf-aerospike.

   gcloud compute ssh bookshelf-aerospike
   

7. A partir de la sesión de la instancia bookshelf-aerospike, verifica que se haya creado un libro nuevo con el ID del libro que anotaste antes:

   aql -c 'select * from bookshelf.books where id = "BOOK_ID"'
   

   El resultado es similar al siguiente:

   +----------------------+----------------------+---------------+----------------------+----------+---------+
   | title                | author               | publishedDate | description          | imageUrl | id      |
   +----------------------+----------------------+---------------+----------------------+----------+---------+
   | " Aerospike-example" | " Aerospike-example" | "2000-01-01"  | " Aerospike-example" | ""       | "10000" |
   +----------------------+----------------------+---------------+----------------------+----------+---------+
   1 row in set (0.001 secs)
   

   Si el ID de tu libro no aparece en la lista, repite los pasos para agregar un libro nuevo.

Transfiere datos de la copia de seguridad de Aerospike a Cloud Storage

1. En Cloud Shell, a partir de la sesión de la instancia bookshelf-aerospike, crea un archivo de copia de seguridad Aerospike:

   aql -c "select * from bookshelf.books" --timeout=-1 --outputmode=json \`
       | tail -n +2 | jq -c '.[0] | .[]' \
       | gsutil cp - $(gsutil ls -b gs://bookshelf-*)bookshelf-backup.json
   

   Con este comando, se procesan los datos y se crea un archivo de copia de seguridad a través del siguiente proceso:

   • Selecciona la información del libro de Aerospike y, luego, preséntala en el formato JSON prettyprint.
   • Quita los dos primeros encabezados del resultado y convierte los datos al formato Newline delimited JSON (ndjson) con jq, un procesador JSON de línea de comandos.
   • Usa la herramienta de línea de comandos de gsutil para subir los datos al bucket de Cloud Storage.

2. Verifica que se haya subido el archivo de copia de seguridad Aerospike y que exista en el bucket de Cloud Storage:

   gsutil ls gs://bookshelf-*/bookshelf-*\
       gs://bookshelf-616f60d65a3abe62/bookshelf-backup.json
   

3. Revisa el contenido del archivo de copia de seguridad del bucket de Cloud Storage (opcional):

   gsutil cat -r 0-1024 gs://bookshelf-*/bookshelf-backup.json | head -n 2
   

   El resultado es similar al siguiente:

   {"title":"book_2507","author":"write_2507","publishedDate":"1970-01-01","imageUrl":"https://storage.googleapis.com/aerospike2bt-bookshelf/The_Home_Edit-2019-06-24-044906.jpg","description":"test_2507","createdBy":"write_2507","createdById":"2507_anonymous","id":"2507"}
   {"title":"book_3867","author":"write_3867","publishedDate":"1970-01-01","imageUrl":"https://storage.googleapis.com/aerospike2bt-bookshelf/The_Home_Edit-2019-06-24-044906.jpg","description":"test_3867","createdBy":"write_3867","createdById":"3867_anonymous","id":"3867"}
   

4. Sal de la sesión SSH y regrese a Cloud Shell:

   exit
   

Migra los datos de la copia de seguridad a Bigtable con Dataflow

Ahora puedes migrar los datos de la copia de seguridad de Cloud Storage a una instancia de Bigtable. En esta sección, se explica cómo usar las canalizaciones de Dataflow para migrar datos compatibles con un esquema de Bigtable.

Configura el trabajo de migración de Dataflow

1. En Cloud Shell, ve al directorio dataflow en el repositorio de código de ejemplo:

   cd "$HOME"/as2bt/dataflow/
   

2. Configura las variables de entorno para un trabajo de Dataflow:

   export BOOKSHELF_BACKUP_FILE="$(gsutil ls
   gs://bookshelf*/bookshelf-backup.json)"
   export BOOKSHELF_DATAFLOW_ZONE="$(gcloud config get-value compute/zone)"
   

3. Comprueba que las variables de entorno estén configuradas correctamente:

   env | grep BOOKSHELF
   

   Si las variables de entorno están configuradas correctamente, el resultado es similar al siguiente:

   BOOKSHELF_BACKUP_FILE=gs://bookshelf-616f60d65a3abe62/bookshelf-backup.json
   BOOKSHELF_DATAFLOW_ZONE=us-east1-b
   

Ejecuta el trabajo de Dataflow:

1. En Cloud Shell, migra los datos desde Cloud Storage a la instancia de Bigtable:

   ./run_oncloud_json.sh
   

2. En la consola de Google Cloud, ve a la página Trabajos para supervisar el trabajo de migración de datos de la copia de seguridad.

   Ir a Trabajos

   Espera hasta que se complete correctamente el trabajo. Cuando se completa correctamente el trabajo, el resultado en Cloud Shell es similar al siguiente:

   Dataflow SDK version: 2.13.0
   Submitted job: 2019-12-16_23_24_06-2124083021829446026
   [INFO] ------------------------------------------------------------------------
   [INFO] BUILD SUCCESS
   [INFO] ------------------------------------------------------------------------
   [INFO] Total time:  08:20 min
   [INFO] Finished at: 2019-12-17T16:28:08+09:00
   [INFO] ------------------------------------------------------------------------
   

Verifica los resultados del trabajo de migración

• En Cloud Shell, verifica que los datos de la copia de seguridad se hayan transferido de forma correcta a Bigtable:

  cbt -instance bookshelf-bigtable lookup books 00001
  

  El resultado es similar al siguiente:

    ----------------------------------------
  00001
    info:author                              @ 2019/12/17-16:26:04.434000
      "Aerospike-example"
    info:description                         @ 2019/12/17-16:26:04.434000
      "Aerospike-example"
    info:id                                  @ 2019/12/17-16:26:04.434000
      "00001"
    info:imageUrl                            @ 2019/12/17-16:26:04.434000
      ""
    info:publishedDate                       @ 2019/12/17-16:26:04.434000
      "2019-10-01"
    info:title                               @ 2019/12/17-16:26:04.434000
      "Aerospike-example"
  

  Nota: Los modelosAerospike-example el ID del libro se invierte de10000 a00001 para evitarproblemas de hotspot.

Cambia la base de datos de Bookshelf de Aerospike a Bigtable

Después de migrar con éxito los datos de Aerospike a Bigtable, puedes cambiar la configuración de la app de Bookshelf a fin de usar Bigtable para el almacenamiento. Cuando estableces esta configuración, los libros nuevos se guardan en las instancias de Bigtable.

Cambia la configuración de la app de Bookshelf

1. En Cloud Shell, usa SSH para conectarte a la app bookshelf-aerospike:

   gcloud compute ssh bookshelf-aerospike
   

2. Verifica que la configuración DATA_BACKEND actual sea aerospike:

   grep DATA_BACKEND /opt/app/bookshelf/config.py
   

   Este es el resultado:

   DATA_BACKEND = 'aerospike'
   

3. Cambia la configuración DATA_BACKEND de aerospike a bigtable:

   sudo sed -i "s/DATA_BACKEND =.*/DATA_BACKEND = 'bigtable'/g" /opt/app/bookshelf/config.py
   

4. Verifica que la configuración DATA_BACKEND se cambió a bigtable:

   grep DATA_BACKEND /opt/app/bookshelf/config.py
   

   Este es el resultado:

   DATA_BACKEND = 'bigtable'
   

5. Reinicia la app de Bookshelf que usa la configuración de backend bigtable nueva:

   sudo supervisorctl restart bookshelf
   

6. Verifica que la app de Bookshelf se haya reiniciado y que se esté ejecutando correctamente:

   sudo supervisorctl status bookshelf
   

   El resultado es similar al siguiente:

   bookshelf  RUNNING   pid 18318, uptime 0:01:00
   

Verifica que la app de Bookshelf use el backend de Bigtable

1. En un navegador, ve a http://IP_ADDRESS:8080.

2. Agrega un libro nuevo con el nombre Bigtable-example.

3. Para verificar que el libro Bigtable-example se haya creado en una instancia de Bigtable desde la app de Bookshelf, copia el ID del libro desde la barra de direcciones del navegador.

4. En Cloud Shell, busca los datos del libro Bigtable-example desde una instancia de Bigtable:

   cbt -instance bookshelf-bigtable lookup books 7406950188
   

   El resultado es similar al siguiente:

   ----------------------------------------
   7406950188
     info:author                              @ 2019/12/17-17:28:25.592000
       "Bigtable-example"
     info:description                         @ 2019/12/17-17:28:25.592000
       "Bigtable-example"
     info:id                                  @ 2019/12/17-17:28:25.592000
       "7406950188"
     info:image_url                           @ 2019/12/17-17:28:25.592000
       ""
     info:published_date                      @ 2019/12/17-17:28:25.592000
       "2019-10-01"
     info:title                               @ 2019/12/17-17:28:25.592000
       "Bigtable-example"
   

Realizaste correctamente una migración de datos desde Aerospike a Bigtable y cambiaste la configuración de la estantería para conectarte a un backend de Bigtable.

Realiza una limpieza

La manera más fácil de eliminar la facturación es borrar el proyecto de Google Cloud que creaste para el instructivo. Como alternativa, puedes borrar los recursos individuales.

Borra el proyecto

Precaución: Borrar un proyecto tiene estas consecuencias:
• Se borra todo en el proyecto. Si usaste un proyecto existente para las tareas de este documento, cuando lo borres, también se borrará cualquier otro trabajo que hayas realizado en el proyecto.
• Se pierden los ID personalizados de proyectos. Cuando creaste este proyecto, es posible que hayas creado un ID del proyecto personalizado que desees utilizar en el futuro. Para conservar las URL que utilizan el ID del proyecto, como una URL appspot.com, borra los recursos seleccionados dentro del proyecto en lugar de borrar todo el proyecto.
1. En la consola de Google Cloud, ve a la página Administrar recursos.

   Ir a Administrar recursos

2. En la lista de proyectos, elige el proyecto que quieres borrar y haz clic en Borrar.
3. En el diálogo, escribe el ID del proyecto y, luego, haz clic en Cerrar para borrar el proyecto.

¿Qué sigue?

• Aprende a diseñar tu esquema de Bigtable.
• Lee sobre cómo iniciar la Migración a Google Cloud.
• Configura una canalización de CI/CD para tu flujo de trabajo de procesamiento de datos
• Comprende qué estrategias tienes para transferir grandes conjuntos de datos.
• Explora arquitecturas de referencia, diagramas y prácticas recomendadas sobre Google Cloud. Consulta nuestro Cloud Architecture Center.