Migrar desde HBase alojado en Google Cloud

En esta página se describen los aspectos y procesos que se deben tener en cuenta para migrar a Bigtable desde un clúster de Apache HBase alojado en unGoogle Cloud servicio, como Dataproc o Compute Engine.

Para obtener información sobre la migración offline de un entorno de Apache HBase externo a Bigtable, consulta el artículo Migrar datos de HBase a Bigtable offline. Para la migración online, consulta Replicar de HBase a Bigtable.

Motivos para migrar de HBase en Google Cloud a Bigtable

Estos son algunos de los motivos por los que podrías elegir esta ruta de migración:

  • Puedes dejar tu aplicación cliente donde esté implementada actualmente y cambiar solo la configuración de la conexión.
  • Tus datos permanecen en el Google Cloud ecosistema.
  • Puedes seguir usando la API de HBase si quieres. El cliente de HBase de Cloud Bigtable para Java es una extensión totalmente compatible de la biblioteca de Apache HBase para Java.
  • Quieres disfrutar de las ventajas de usar un servicio gestionado para almacenar tus datos.

Cuestiones importantes

En esta sección, se sugieren algunas cosas que debes revisar y tener en cuenta antes de empezar la migración.

Diseño de esquemas de Bigtable

En la mayoría de los casos, puedes usar el mismo diseño de esquema en Bigtable que en HBase. Si quieres cambiar tu esquema o si tu caso de uso va a cambiar, consulta los conceptos que se explican en Diseñar tu esquema antes de migrar tus datos.

Preparación y pruebas

Antes de migrar los datos, asegúrese de que conoce las diferencias entre HBase y Bigtable. Deberías dedicar un tiempo a aprender a configurar tu conexión para conectar tu aplicación a Bigtable. Además, puede que quieras hacer pruebas funcionales y del sistema antes de la migración para validar la aplicación o el servicio.

Pasos de la migración

Para migrar los datos de HBase a Bigtable, haz una captura de HBase e importa los datos directamente del clúster de HBase a Bigtable. Estos pasos son para un solo clúster de HBase y se describen en detalle en las siguientes secciones.

  1. Dejar de enviar operaciones de escritura a HBase.
  2. Crea tablas de destino en Bigtable.
  3. Haz capturas de HBase e impórtalas a Bigtable.
  4. Valide los datos importados.
  5. Actualiza la aplicación para enviar lecturas y escrituras a Bigtable.

imagen

Antes de empezar

  1. Instala Google Cloud CLI o usa Cloud Shell.

  2. Crea un segmento de Cloud Storage para almacenar los datos de salida de la validación. Crea el segmento en la misma ubicación en la que vayas a ejecutar tu tarea de Dataproc.

  3. Identifique el clúster de Hadoop desde el que va a migrar. Debes ejecutar los trabajos de migración en un clúster de Dataproc 1.x que tenga conectividad de red con el nodo de nombres y los nodos de datos del clúster de HBase. Anota la dirección del quórum de ZooKeeper y el URI del nodo de nombres del clúster de HBase, que son necesarios para las secuencias de comandos de migración.

  4. Crea un clúster de Dataproc versión 1.x en la misma red que el clúster de HBase de origen. Este clúster se usa para ejecutar las tareas de importación y validación.

  5. Crea una instancia de Bigtable para almacenar las nuevas tablas. Al menos un clúster de la instancia de Bigtable también debe estar en la misma región que el clúster de Dataproc. Ejemplo: us-central1

  6. Obtén la herramienta Traducción de esquemas:

    wget BIGTABLE_HBASE_TOOLS_URL

    Sustituye BIGTABLE_HBASE_TOOLS_URL por la URL de la versión JAR with dependencies más reciente disponible en el repositorio de Maven de la herramienta. El nombre del archivo es similar a https://repo1.maven.org/maven2/com/google/cloud/bigtable/bigtable-hbase-1.x-tools/2.6.0/bigtable-hbase-1.x-tools-2.6.0-jar-with-dependencies.jar.

    Para encontrar la URL o descargar el archivo JAR manualmente, siga estos pasos:

    1. Ve al repositorio.
    2. Haz clic en Examinar para ver los archivos del repositorio.
    3. Haz clic en el número de la versión más reciente.
    4. Identifica el JAR with dependencies file (normalmente en la parte superior).
    5. Haz clic con el botón derecho y copia la URL, o haz clic para descargar el archivo.

  7. Obtén la herramienta MapReduce, que usarás para las tareas de importación y validación:

    wget BIGTABLE_MAPREDUCE_URL

    Sustituye BIGTABLE_MAPREDUCE_URL por la URL de la versión shaded-byo JAR más reciente disponible en el repositorio de Maven de la herramienta. El nombre del archivo es similar a https://repo1.maven.org/maven2/com/google/cloud/bigtable/bigtable-hbase-1.x-mapreduce/2.6.0/bigtable-hbase-1.x-mapreduce-2.6.0-shaded-byo-hadoop.jar.

    Para encontrar la URL o descargar el archivo JAR manualmente, sigue estos pasos:

    1. Ve al repositorio.
    2. Haz clic en el número de la versión más reciente.
    3. Haz clic en Descargas.
    4. Coloca el cursor sobre shaded-byo-hadoop.jar.
    5. Haz clic con el botón derecho y copia la URL, o haz clic para descargar el archivo.

  8. Define las siguientes variables de entorno:

    #Google Cloud

export PROJECT_ID=PROJECT_ID
export REGION=REGION

##Cloud Bigtable

export BIGTABLE_INSTANCE_ID=BIGTABLE_INSTANCE_ID

##Dataproc

export DATAPROC_CLUSTER_ID=DATAPROC_CLUSTER_NAME

#Cloud Storage

export BUCKET_NAME="gs://BUCKET_NAME"
export STORAGE_DIRECTORY="$BUCKET_NAME/hbase-migration"

#HBase

export ZOOKEEPER_QUORUM=ZOOKEPER_QUORUM
export ZOOKEEPER_PORT=2181
export ZOOKEEPER_QUORUM_AND_PORT="$ZOOKEEPER_QUORUM:$ZOOKEEPER_PORT"
export MIGRATION_SOURCE_NAMENODE_URI=MIGRATION_SOURCE_NAMENODE_URI
export MIGRATION_SOURCE_TMP_DIRECTORY=${MIGRATION_SOURCE_NAMENODE_URI}/tmp
export MIGRATION_SOURCE_DIRECTORY=${MIGRATION_SOURCE_NAMENODE_URI}/hbase

#JAR files

export TRANSLATE_JAR=TRANSLATE_JAR
export MAPREDUCE_JAR=MAPREDUCE_JAR

    Sustituye los marcadores de posición por los valores de tu migración.

    Google Cloud:

    • PROJECT_ID: el Google Cloud proyecto en el que se encuentra tu instancia de Bigtable
    • REGION: la región que contiene el clúster de Dataproc que ejecutará las tareas de importación y validación.

    Bigtable:

    • BIGTABLE_INSTANCE_ID: identificador de la instancia de Bigtable a la que vas a importar los datos.

    Dataproc:

    • DATAPROC_CLUSTER_ID: el ID del clúster de Dataproc que ejecutará las tareas de importación y validación.

    Cloud Storage:

    • BUCKET_NAME: el nombre del segmento de Cloud Storage en el que almacenas tus copias de seguridad

    HBase:

    • ZOOKEEPER_QUORUM: el host de ZooKeeper al que se conectará la herramienta, con el formato host1.myownpersonaldomain.com
    • MIGRATION_SOURCE_NAMENODE_URI: el URI del Namenode de tu clúster de HBase, con el formato hdfs://host1.myownpersonaldomain.com:8020

    Archivos JAR

    • TRANSLATE_JAR: el nombre y el número de versión del archivo JAR bigtable hbase tools que has descargado de Maven. El valor debe ser similar a bigtable-hbase-1.x-tools-2.6.0-jar-with-dependencies.jar.
    • MAPREDUCE_JAR: el nombre y el número de versión del archivo JAR bigtable hbase mapreduce que has descargado de Maven. El valor debe ser similar a bigtable-hbase-1.x-mapreduce-2.6.0-shaded-byo-hadoop.jar.

  9. (Opcional) Para confirmar que las variables se han definido correctamente, ejecuta el comando printenv para ver todas las variables de entorno.

Dejar de enviar operaciones de escritura a HBase

Antes de hacer copias de tus tablas de HBase, deja de enviar escrituras a tu clúster de HBase.

Crear tablas de destino en Bigtable

El siguiente paso es crear una tabla de destino en tu instancia de Bigtable para cada tabla de HBase que vayas a migrar. Usa una cuenta que tenga permiso bigtable.tables.create para la instancia.

En esta guía se usa la herramienta de traducción de esquemas de Bigtable, que crea la tabla automáticamente. Sin embargo, si no quieres que tu esquema de Bigtable coincida exactamente con el esquema de HBase, puedes crear una tabla con la CLI de cbt o la consola de Google Cloud .

La herramienta de traducción de esquemas de Bigtable captura el esquema de la tabla de HBase, incluido el nombre de la tabla, las familias de columnas, las políticas de recogida de elementos no utilizados y las divisiones. A continuación, crea una tabla similar en Bigtable.

En cada tabla que quieras importar, ejecuta el siguiente comando para copiar el esquema de HBase a Bigtable.

java \
 -Dgoogle.bigtable.project.id=$PROJECT_ID \
 -Dgoogle.bigtable.instance.id=$BIGTABLE_INSTANCE_ID \
 -Dgoogle.bigtable.table.filter=TABLE_NAME \
 -Dhbase.zookeeper.quorum=$ZOOKEEPER_QUORUM \
 -Dhbase.zookeeper.property.clientPort=$ZOOKEEPER_PORT \
 -jar $TRANSLATE_JAR

Sustituye TABLE_NAME por el nombre de la tabla de HBase que vas a importar. La herramienta Traducción de esquemas usa este nombre para la nueva tabla de Bigtable.

También puedes sustituir TABLE_NAME por una expresión regular, como ".*", que capture todas las tablas que quieras crear y, a continuación, ejecutar el comando solo una vez.

Hacer capturas de tablas de HBase e importarlas a Bigtable

Complete los siguientes pasos para cada tabla que quiera migrar a Bigtable.

  1. Ejecuta el siguiente comando:

    echo "snapshot 'HBASE_TABLE_NAME', 'HBASE_SNAPSHOT_NAME'" | hbase shell -n

    Haz los cambios siguientes:

    • HBASE_TABLE_NAME: el nombre de la tabla de HBase a la que vas a migrar los datos de Bigtable.
    • HBASE_SNAPSHOT_NAME: nombre único de la nueva instantánea.

  2. Importa la instantánea ejecutando el siguiente comando:

    gcloud dataproc jobs submit hadoop \
    --cluster $DATAPROC_CLUSTER_ID \
    --region $REGION \
    --project $PROJECT_ID \
    --jar $MAPREDUCE_JAR \
    -- \
    import-snapshot \
    -Dgoogle.bigtable.project.id=$PROJECT_ID \
    -Dgoogle.bigtable.instance.id=$BIGTABLE_INSTANCE_ID \
    HBASE_SNAPSHOT_NAME \
    $MIGRATION_SOURCE_DIRECTORY \
    BIGTABLE_TABLE_NAME \
    $MIGRATION_SOURCE_TMP_DIRECTORY

    Haz los cambios siguientes:

    • HBASE_SNAPSHOT_NAME: el nombre que has asignado a la instantánea de la tabla que vas a importar
    • BIGTABLE_TABLE_NAME: el nombre de la tabla de Bigtable a la que vas a importar

    Después de ejecutar el comando, la herramienta restaura la instantánea de HBase en el clúster de origen y, a continuación, la importa. El proceso de restauración de la instantánea puede tardar varios minutos en completarse, en función del tamaño de la instantánea.

Cuando importes los datos, tendrás las siguientes opciones adicionales:

  • Define los tiempos de espera basados en el cliente para las solicitudes de mutación almacenadas en búfer (el valor predeterminado es 600.000 ms). Consulta el siguiente ejemplo:

    -Dgoogle.bigtable.rpc.use.timeouts=true
-Dgoogle.bigtable.mutate.rpc.timeout.ms=600000

  • Considera la posibilidad de usar la limitación basada en la latencia, que puede reducir el impacto que la tarea de importación por lotes puede tener en otras cargas de trabajo. Debes probar la limitación de la velocidad en tu caso práctico de migración. Consulta el siguiente ejemplo:

    -Dgoogle.bigtable.buffered.mutator.throttling.enable=true
-Dgoogle.bigtable.buffered.mutator.throttling.threshold.ms=100

  • Modifica el número de tareas de mapa que leen una sola región de HBase (el valor predeterminado es 2 tareas de mapa por región). Consulta el siguiente ejemplo:

    -Dgoogle.bigtable.import.snapshot.splits.per.region=3

  • Defina configuraciones adicionales de MapReduce como propiedades. Consulta el siguiente ejemplo:

    -Dmapreduce.map.maxattempts=4
-Dmapreduce.map.speculative=false
-Dhbase.snapshot.thread.pool.max=20

Ten en cuenta los siguientes consejos al importar:

  • Para mejorar el rendimiento de la carga de datos, asegúrese de tener suficientes trabajadores del clúster de Dataproc para ejecutar tareas de importación de mapas en paralelo. De forma predeterminada, un trabajador de Dataproc n1-standard-8 ejecutará ocho tareas de importación. Si hay suficientes trabajadores, la tarea de importación tendrá suficiente potencia de cálculo para completarse en un plazo razonable, pero no tanta como para sobrecargar la instancia de Bigtable.
    • Si no usas la instancia de Bigtable para otra carga de trabajo, multiplica el número de nodos de tu instancia de Bigtable por 3 y, después, divide el resultado entre 8 (con el trabajador de Dataproc n1-standard-8). Usa result como número de trabajadores de Dataproc.
    • Si usas la instancia para otra carga de trabajo al mismo tiempo que importas tus datos de HBase, reduce el valor de los trabajadores de Dataproc o aumenta el número de nodos de Bigtable para cumplir los requisitos de las cargas de trabajo.
  • Durante la importación, debes monitorizar el uso de CPU de la instancia de Bigtable. Si la utilización de la CPU en la instancia de Bigtable es demasiado alta, puede que tengas que añadir más nodos. Si añades nodos, el uso de la CPU mejorará de inmediato, pero el clúster puede tardar hasta 20 minutos en alcanzar un rendimiento óptimo después de que se hayan añadido los nodos.

Para obtener más información sobre cómo monitorizar la instancia de Bigtable, consulta Monitorizar una instancia de Bigtable.

Validar los datos importados en Bigtable

A continuación, valida la migración de datos realizando una comparación de hash entre la tabla de origen y la de destino para comprobar la integridad de los datos migrados. Primero, ejecuta el trabajo hash-table para generar los hashes de los intervalos de filas de la tabla de origen. A continuación, completa la validación ejecutando el sync-table para calcular y comparar los hashes de Bigtable con la fuente.

  1. Para crear los hashes que se usarán en la validación, ejecuta el siguiente comando para cada tabla que vayas a migrar:

    gcloud dataproc jobs submit hadoop \
  --project $PROJECT_ID \
  --cluster $DATAPROC_CLUSTER_ID \
  --region $REGION \
  --jar $MAPREDUCE_JAR \
  -- \
  hash-table \
  -Dhbase.zookeeper.quorum=$ZOOKEEPER_QUORUM_AND_PORT \
  HBASE_TABLE_NAME \
  $STORAGE_DIRECTORY/HBASE_TABLE_NAME/hash-output/

    Sustituye HBASE_TABLE_NAME por el nombre de la tabla de HBase para la que has creado la instantánea.

  2. Ejecuta lo siguiente en el shell de comandos:

    gcloud dataproc jobs submit hadoop \
  --project $PROJECT_ID \
  --cluster $DATAPROC_CLUSTER_ID \
  --region $REGION \
 --jar $MAPREDUCE_JAR \
 -- \
 sync-table \
 --sourcezkcluster=$ZOOKEEPER_QUORUM_AND_PORT:/hbase \
 --targetbigtableproject=$PROJECT_ID \
 --targetbigtableinstance=$BIGTABLE_INSTANCE_ID \
 $STORAGE_DIRECTORY/HBASE_TABLE_NAME/hash-output/ \
 HBASE_TABLE_NAME \
 BIGTABLE_TABLE_NAME

    Haz los cambios siguientes:

    • HBASE_TABLE_NAME: el nombre de la tabla de HBase de la que vas a importar datos
    • BIGTABLE_TABLE_NAME: el nombre de la tabla de Bigtable a la que vas a importar

Si quieres habilitar la sincronización entre la fuente y el destino para los intervalos de hash divergentes, puedes añadir --dryrun=false al comando.

Cuando se complete el trabajo de sync-table, los contadores del trabajo se mostrarán en la consola Google Cloud donde se haya ejecutado el trabajo. Si el trabajo de importación importa correctamente todos los datos, el valor de HASHES_MATCHED tendrá un valor y el de HASHES_NOT_MATCHED será 0.

Si HASHES_NOT_MATCHED muestra un valor, puede volver a ejecutar sync-table en modo de depuración para emitir los intervalos divergentes y los detalles a nivel de celda, como Source missing cell, Target missing cell o Different values. Para habilitar el modo de depuración, configure --properties mapreduce.map.log.level=DEBUG. Una vez que se haya ejecutado el trabajo, usa Cloud Logging y busca la expresión jsonPayload.class="org.apache.hadoop.hbase.mapreduce.SyncTable" para revisar las celdas que divergen.

Puedes volver a intentar la importación o usar SyncTable para sincronizar las tablas de origen y de destino configurando dryrun=false. Consulta HBase SyncTable y otras opciones de configuración antes de continuar.

Resultados de SyncTable en Cloud Logging

Actualizar la aplicación para que envíe lecturas y escrituras a Bigtable

Una vez que hayas validado los datos de cada tabla del clúster, puedes configurar tus aplicaciones para que dirijan todo su tráfico a Bigtable y, a continuación, retirar el clúster de HBase.

Cuando se haya completado la migración, puedes eliminar las copias de seguridad.

Siguientes pasos