Migra de Aerospike a Bigtable

Last reviewed 2024-10-16 UTC

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.

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 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.

Componentes del proceso de transferencia de 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 activan las funciones de Cloud Run 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 cadenas de bytes sin procesar para la mayoría de 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:

Pasos para la migración de datos.

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 la función de Cloud Run.
  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:

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. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  2. Make sure that billing is enabled for your Google Cloud project.

  3. Enable the Cloud Resource Manager API.

    Enable the API

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

  4. In the Google Cloud console, activate Cloud Shell.

    Activate 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 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 la 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 a este:

    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:

    gcloud storage ls gs://bookshelf-* --buckets

    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.

    ID del libro en URL.

  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] | .[]' \
    | gcloud storage cp - $(gcloud storage ls gs://bookshelf-* --buckets)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 gcloud CLI 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:

    gcloud storage 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):

    gcloud storage 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="$(gcloud storage 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 a este:

      ----------------------------------------
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"

Cambia la base de datos de Bookshelf de Aerospike a Cloud 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

    Esta es la salida:

    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

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

¿Qué sigue?