Migra desde HBase en Google Cloud

En esta página, se describen las consideraciones y los procesos para migrar a Bigtable desde un clúster de Apache HBase que está alojado en un servicio de Google Cloud, como Dataproc o Compute Engine.

Para obtener orientación sobre cómo migrar de un entorno externo de Apache HBase a Bigtable, consulta Migra datos de HBase a Bigtable. Para obtener más información sobre la migración en línea, consulta Cómo replicar de HBase a Bigtable.

Por qué migrar de HBase en Google Cloud a Bigtable

Estos son algunos de los motivos por los que puedes elegir esta ruta de migración:

  • Puedes dejar tu aplicación cliente donde está implementada y cambiar solo la configuración de conexión.
  • Tus datos permanecen en el ecosistema de Google Cloud.
  • Puedes seguir usando la API de HBase si lo deseas. El cliente HBase de Cloud Bigtable para Java es una extensión completamente compatible de la biblioteca de Apache HBase para Java.
  • Quieres los beneficios de usar un servicio administrado para almacenar tus datos.

Consideraciones

En esta sección, se sugieren algunos aspectos que se deben revisar y considerar antes de comenzar la migración.

Diseño de esquema de Bigtable

En la mayoría de los casos, puedes usar el mismo diseño de esquema en Bigtable que en HBase. Si deseas cambiar tu esquema o si tu caso de uso está cambiando, revisa los conceptos presentados en Diseña tu esquema antes de migrar tus datos.

Preparación y pruebas

Antes de migrar tus datos, asegúrate de comprender 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, es posible que desees realizar pruebas del sistema y funcionales antes de la migración para validar la aplicación o el servicio.

Pasos para la migración

Para migrar tus datos de HBase a Bigtable, toma una instantánea de HBase y, luego, 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. Deja de enviar operaciones de escritura a HBase.
  2. Crear tablas de destino en Bigtable
  3. Tomar instantáneas de HBase y, luego, importarlas a Bigtable
  4. Valida los datos importados.
  5. Actualiza la aplicación para enviar lecturas y escrituras a Bigtable.

imagen

Antes de comenzar

  1. Instala Google Cloud CLI o usa Cloud Shell.

  2. Crea un bucket de Cloud Storage para almacenar tus datos de salida de validación. Crea el bucket en la misma ubicación en la que planeas ejecutar tu trabajo de Dataproc.

  3. Identifica el clúster Hadoop desde el que realizas la migración. Debes ejecutar los trabajos para tu migración en un clúster de Dataproc 1.x que tenga conectividad de red al Namenode y Datanodes del clúster de HBase. Toma nota de la dirección de ZooKeeper Quorum y del URI de Namenode 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. Debes usar este clúster para ejecutar los trabajos de importación y validación.

  5. Crea una instancia de Bigtable para almacenar tus tablas nuevas. 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 de traducción de esquema:

    wget BIGTABLE_HBASE_TOOLS_URL

    Reemplaza BIGTABLE_HBASE_TOOLS_URL por la URL del 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 de forma manual, haz lo siguiente:

    1. Ir al repositorio.
    2. Haz clic en Explorar para ver los archivos del repositorio.
    3. Haz clic en el número de versión más reciente.
    4. Identifica JAR with dependencies file (por lo general, 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 los trabajos de importación y validación:

    wget BIGTABLE_MAPREDUCE_URL

    Reemplaza BIGTABLE_MAPREDUCE_URL por la URL del 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 de forma manual, haz lo siguiente:

    1. Ir al repositorio.
    2. Haz clic en el número de versión más reciente.
    3. Presiona Descargas.
    4. Desplaza el mouse 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. Configura las siguientes variables del 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

    Reemplaza los marcadores de posición por los valores para tu migración.

    Google Cloud:

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

    Bigtable:

    • BIGTABLE_INSTANCE_ID: el identificador de la instancia de Bigtable a la que deseas importar tus datos

    Dataproc:

    • DATAPROC_CLUSTER_ID: El ID del clúster de Dataproc que ejecutará los trabajos de importación y validación

    Cloud Storage:

    • BUCKET_NAME: Es el nombre del bucket de Cloud Storage en el que almacenas las instantáneas.

    HBase:

    • ZOOKEEPER_QUORUM: Es el host de ZooKeeper al que se conectará la herramienta, en el formato host1.myownpersonaldomain.com.
    • MIGRATION_SOURCE_NAMENODE_URI: Es el URI del Namenode del clúster de HBase, en 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 descargaste 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 descargaste de Maven. El valor debe ser similar a bigtable-hbase-1.x-mapreduce-2.6.0-shaded-byo-hadoop.jar.

  9. Si deseas confirmar que las variables se configuraron de forma correcta, ejecuta el comando printenv para ver todas las variables de entorno (opcional).

Deja de enviar operaciones de escritura a HBase

Antes de tomar instantáneas de las tablas de HBase, deja de enviar operaciones de escritura al clúster de HBase.

Crea 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 estés migrando. 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 automáticamente la tabla por ti. Sin embargo, si no deseas que tu esquema de Bigtable coincida de manera exacta 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 recolección de elementos no utilizados y las divisiones. Luego, crea una tabla similar en Bigtable.

En cada tabla que desees importar, ejecuta el siguiente comando para copiar el esquema de HBase en 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

Reemplaza TABLE_NAME por el nombre de la tabla de HBase que deseas importar. La herramienta de traducción de esquemas usa este nombre para tu nueva tabla de Bigtable.

De forma opcional, también puedes reemplazar TABLE_NAME por una expresión regular, como “.*”, que capture todas las tablas que deseas crear y, luego, ejecute el comando solo una vez.

Toma instantáneas de la tabla de HBase y, luego, impórtalas a Bigtable

Completa la siguiente información para cada tabla que planees migrar a Bigtable.

  1. Ejecuta el siguiente comando:

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

    Reemplaza lo siguiente:

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

  2. Ejecuta el siguiente comando para importar la instantánea:

    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

    Reemplaza lo siguiente:

    • HBASE_SNAPSHOT_NAME: el nombre que asignaste a la instantánea de la tabla que deseas importar.
    • BIGTABLE_TABLE_NAME: Es el nombre de la tabla de Bigtable a la que deseas importar.

    Después de ejecutar el comando, la herramienta restablece la instantánea de HBase en el clúster de origen y, luego, la importa. El proceso de restablecimiento de la instantánea puede tardar varios minutos en finalizar, según el tamaño de la instantánea.

Las siguientes opciones adicionales están disponibles cuando importas los datos:

  • Establece tiempos de espera basados en el cliente para las solicitudes de mutador almacenadas en búfer (el valor predeterminado es de 600,000 ms). Consulta el siguiente ejemplo:

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

  • Considera la limitación basada en la latencia, que puede reducir el impacto que el trabajo de importación por lotes puede tener en otras cargas de trabajo. Se debe probar la regulación para tu caso de uso de migración. Consulta el siguiente ejemplo:

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

  • Modifica la cantidad de tareas en mapas que leen una sola región de HBase (opción predeterminada 2 tareas de mapa por región). Consulta el siguiente ejemplo:

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

  • Establece configuraciones adicionales de MapReduce como propiedades. Observa el siguiente ejemplo:

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

Cuando realices una importación, ten en cuenta las siguientes sugerencias:

  • Para mejorar el rendimiento de la carga de datos, asegúrate de tener suficientes trabajadores del clúster de Dataproc para ejecutar tareas de importación de mapas en paralelo. Según la configuración predeterminada, un trabajador n1-standard-8 de Dataproc ejecutará ocho tareas de importación. Tener suficientes trabajadores garantiza que el trabajo de importación tenga suficiente capacidad de procesamiento para completarse en un tiempo razonable, pero no tanta capacidad como para sobrecargar la instancia de Bigtable.
    • Si no estás usando la instancia de Bigtable para otra carga de trabajo, multiplica la cantidad de nodos en tu instancia de Bigtable por 3 y, luego, divide el resultado por 8 (con n1-standard-8 dataproc worker). Usa el resultado como la cantidad 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 la cantidad de nodos de Bigtable para cumplir con los requisitos de las cargas de trabajo.
  • Durante la importación, debes supervisar el uso de la CPU de la instancia de Bigtable. Si el uso de CPU en la instancia de Bigtable es demasiado alto, es posible que debas agregar nodos adicionales. Agregar nodos mejora el uso de CPU de inmediato, pero pueden pasar hasta 20 minutos después de que se agregan los nodos para que el clúster alcance un rendimiento óptimo.

Para obtener más información sobre la supervisión de la instancia de Bigtable, consulta Cómo supervisar una instancia de Bigtable.

Valida los datos importados en Bigtable

A continuación, valida la migración de datos mediante una comparación de hash entre la tabla de origen y de destino para ganar confianza en la integridad de los datos migrados. Primero, ejecuta el trabajo hash-table para generar hashes de rangos de filas en la tabla de origen. Luego, completa la validación mediante la ejecución del trabajo sync-table para calcular y hacer coincidir los hashes de Bigtable con la fuente.

  1. Si deseas crear hashes para usarlos en la validación, ejecuta el siguiente comando en cada tabla que migres:

    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/

    Reemplaza HBASE_TABLE_NAME por el nombre de la tabla de HBase para la que creaste la instantánea.

  2. Ejecuta lo siguiente en la 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

    Reemplaza lo siguiente:

    • HBASE_TABLE_NAME: Es el nombre de la tabla de HBase desde la que importas.
    • BIGTABLE_TABLE_NAME: Es el nombre de la tabla de Bigtable a la que deseas importar.

De manera opcional, puedes agregar --dryrun=false al comando si deseas habilitar la sincronización entre la fuente y el destino para los rangos de hash divergentes.

Cuando se completa el trabajo sync-table, sus contadores se muestran en la consola de Google Cloud donde se ejecutó el trabajo. Si el trabajo de importación importa todos los datos de forma correcta, el valor de HASHES_MATCHED tiene un valor, y el de HASHES_NOT_MATCHED es 0.

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

Puedes intentar volver a realizar el trabajo de importación o usar SyncTable para sincronizar las tablas de origen y destino mediante la configuración de dryrun=false. Revisa HBase SyncTable y las opciones de configuración adicionales antes de continuar.

Resultados de SyncTable en Cloud Logging

Actualiza la aplicación para enviar operaciones de lectura y escritura a Bigtable

Una vez que hayas validado los datos de cada tabla del clúster, podrás configurar tus aplicaciones para enrutar todo su tráfico a Bigtable y, luego, dar de baja el clúster de HBase.

Cuando se complete la migración, podrás borrar las instantáneas.

¿Qué sigue?