Migrer depuis HBase sur Google Cloud

Cette page décrit les différents points à prendre en compte et les processus à suivre pour migrer vers Bigtable à partir d'un cluster Apache HBase hébergé sur un service Google Cloud, tel que Dataproc ou Compute Engine.

Pour savoir comment migrer d'un environnement Apache HBase externe vers Bigtable, consultez la page Migrer des données de HBase vers Bigtable. Pour en savoir plus sur la migration en ligne, consultez la page Répliquer de HBase depuis HBase vers Bigtable.

Pourquoi migrer de HBase sur Google Cloud vers Bigtable

Voici les raisons pour lesquelles vous pouvez choisir ce chemin de migration :

Vous pouvez quitter votre application cliente où elle est actuellement déployée, en ne modifiant que la configuration de la connexion.
Vos données restent dans l'écosystème Google Cloud.
Vous pouvez continuer à utiliser l'API HBase si vous le souhaitez. Le client Cloud Bigtable HBase pour Java est une extension entièrement compatible de la bibliothèque Apache HBase pour Java.
Vous souhaitez bénéficier des avantages liés à l'utilisation d'un service géré pour stocker vos données.

Points à prendre en compte

Cette section suggère considérations à prendre en compte avant de commencer votre migration.

Conception de schéma Bigtable

Dans la plupart des cas, vous pouvez utiliser la même conception de schéma dans Bigtable que dans HBase. Si vous souhaitez modifier votre schéma ou si votre cas d'utilisation évolue, consultez les concepts exposés dans la section Concevoir votre schéma avant de migrer vos données.

Préparation et tests

Avant de migrer vos données, assurez-vous de bien comprendre les différences entre HBase et Bigtable. Prenez le temps de configurer la connexion pour connecter votre application à Bigtable. En outre, vous pouvez effectuer des tests système et fonctionnels avant la migration pour valider l'application ou le service.

Procédure de migration

Pour migrer vos données de HBase vers Bigtable, vous devez prendre un instantané HBase, puis importer les données directement depuis le cluster HBase dans Bigtable. Ces étapes concernent un seul cluster HBase et sont décrites en détail dans les sections suivantes.

Arrêter l'envoi d'écritures à HBase
Créer des tables de destination dans Bigtable
Prendre des instantanés HBase et les importer dans Bigtable.
Valider les données importées
Mettre à jour l'application pour envoyer des lectures et des écritures à Bigtable.

Avant de commencer

Installez Google Cloud CLI ou utilisez Cloud Shell.
Créez un bucket Cloud Storage pour stocker vos données de sortie de validation. Créez le bucket dans le même emplacement que celui où vous prévoyez d'exécuter votre tâche Dataflow.
Identifiez le cluster Hadoop à partir duquel vous effectuez la migration. Vous devez exécuter les tâches de votre migration sur un cluster Dataproc 1.x disposant d'une connectivité réseau au Namenode et aux Datanodes du cluster HBase. Notez l'adresse de ZooKeeper Quorum et de l'URI de Namenode du cluster HBase, qui sont nécessaires pour les scripts de migration.
Créez un cluster Dataproc version 1.x sur le même réseau que le cluster HBase source. Vous utiliserez ce cluster pour exécuter les tâches d'importation et de validation.
Créez une instance Bigtable pour stocker vos nouvelles tables. Au moins un cluster de l'instance Bigtable doit également se trouver dans la même région que le cluster Dataproc. Exemple : us-central1
Obtenez l'outil de traduction de schéma :
```
wget BIGTABLE_HBASE_TOOLS_URL
```
Remplacez BIGTABLE_HBASE_TOOLS_URL par l'URL de la dernière version de JAR with dependencies disponible dans le dépôt Maven de l'outil. Le nom du fichier est semblable à 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.

Pour trouver l'URL ou télécharger manuellement le fichier JAR, procédez comme suit :
1. Accéder au dépôt
2. Cliquez sur Parcourir pour afficher les fichiers du dépôt.
3. Cliquez sur le numéro de version le plus récent.
4. Identifiez la valeur JAR with dependencies file (généralement en haut).
5. Effectuez un clic droit et copiez l'URL, ou cliquez pour télécharger le fichier.
Obtenez l'outil MapReduce, que vous utilisez pour les tâches d'importation et de validation :
```
wget BIGTABLE_MAPREDUCE_URL
```
Remplacez BIGTABLE_MAPREDUCE_URL par l'URL de la dernière version de shaded-byo JAR disponible dans le dépôt Maven de l'outil. Le nom du fichier est semblable à 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.

Pour trouver l'URL ou télécharger manuellement le fichier JAR, procédez comme suit :
1. Accéder au dépôt
2. Cliquez sur le numéro de version le plus récent.
3. Cliquez sur Téléchargements.
4. Passez la souris sur shaded-byo-hadoop.jar.
5. Effectuez un clic droit et copiez l'URL, ou cliquez pour télécharger le fichier.
Définissez les variables d'environnement suivantes :
```
#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
```
Remplacez les espaces réservés par les valeurs de votre migration.

Google Cloud :
- PROJECT_ID : projet Google Cloud dans lequel se trouve votre instance Bigtable.
- REGION : région contenant le cluster Dataproc qui exécutera les tâches d'importation et de validation.
Bigtable :
- BIGTABLE_INSTANCE_ID : identifiant de l'instance Bigtable dans laquelle vous importez vos données
Dataproc :
- DATAPROC_CLUSTER_ID : ID du cluster Dataproc qui exécutera les tâches d'importation et de validation
Cloud Storage :
- BUCKET_NAME : nom du bucket Cloud Storage dans lequel vous stockez vos instantanés.
HBase :
- ZOOKEEPER_QUORUM : hôte Zookeeper auquel l'outil se connectera, au format host1.myownpersonaldomain.com
- MIGRATION_SOURCE_NAMENODE_URI : URI du Namenode de votre cluster HBase, au format hdfs://host1.myownpersonaldomain.com:8020.
Fichiers JAR
- TRANSLATE_JAR : nom et numéro de version du fichier JAR bigtable hbase tools que vous avez téléchargé à partir de Maven. La valeur doit être semblable à : bigtable-hbase-1.x-tools-2.6.0-jar-with-dependencies.jar.
- MAPREDUCE_JAR : nom et numéro de version du fichier JAR bigtable hbase mapreduce que vous avez téléchargé à partir de Maven. La valeur doit être semblable à : bigtable-hbase-1.x-mapreduce-2.6.0-shaded-byo-hadoop.jar.
(Facultatif) Pour vérifier que les variables ont été correctement définies, exécutez la commande printenv pour afficher toutes les variables d'environnement.

Arrêter l'envoi d'écritures à HBase

Avant de prendre des instantanés de vos tables HBase, arrêtez d'envoyer des écritures vers votre cluster HBase.

Créer des tables de destination dans Bigtable

L'étape suivante consiste à créer une table de destination dans votre instance Bigtable pour chaque table HBase que vous migrez. Utilisez un compte disposant de l'autorisation bigtable.tables.create pour l'instance.

Ce guide utilise l'outil de traduction de schéma Bigtable, qui crée automatiquement la table pour vous. Toutefois, si vous ne souhaitez pas que votre schéma Bigtable corresponde exactement au schéma HBase, vous pouvez créer une table à l'aide de la CLI cbt ou de la console Google Cloud.

L'outil Bigtable de traduction de schéma capture le schéma de la table HBase, y compris le nom de la table, les familles de colonnes, les stratégies de récupération de mémoire et les divisions. Une table similaire est ensuite créée dans Bigtable.

Pour chaque table que vous souhaitez importer, exécutez la commande suivante pour copier le schéma de HBase vers 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

Remplacez TABLE_NAME par le nom de la table HBase que vous importez. L'outil de traduction de schéma utilise ce nom pour votre nouvelle table Bigtable.

Vous pouvez également remplacer TABLE_NAME par une expression régulière (telle que ".*"), qui capture toutes les tables que vous souhaitez créer, puis n'exécuter la commande qu'une seule fois.

Prendre des instantanés de table HBase et les importer dans Bigtable

Renseignez les sections suivantes pour chaque table que vous prévoyez de migrer vers Bigtable.

Exécutez la commande ci-dessous.
```
echo "snapshot 'HBASE_TABLE_NAME', 'HBASE_SNAPSHOT_NAME'" | hbase shell -n
```
Remplacez les éléments suivants :
- HBASE_TABLE_NAME : nom de la table HBase que vous migrez vers Bigtable.
- HBASE_SNAPSHOT_NAME : nom unique du nouvel instantané
Importez l'instantané en exécutant la commande suivante :
```
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
```
Remplacez les éléments suivants :
- HBASE_SNAPSHOT_NAME : nom que vous avez attribué à l'instantané de la table que vous importez.
- BIGTABLE_TABLE_NAME : nom de la table Bigtable dans laquelle vous effectuez l'importation
Une fois la commande exécutée, l'outil restaure l'instantané HBase sur le cluster source, puis l'importe. La restauration de l'instantané peut prendre plusieurs minutes, en fonction de sa taille.

Les options supplémentaires suivantes sont disponibles lorsque vous importez les données :

Définissez les délais avant expiration basés sur le client pour les requêtes de mutation mises en mémoire tampon (600 000 ms par défaut). Consultez l'exemple ci-dessous :
```
-Dgoogle.bigtable.rpc.use.timeouts=true
-Dgoogle.bigtable.mutate.rpc.timeout.ms=600000
```
Envisagez d'utiliser une limitation basée sur la latence, qui peut réduire l'impact de la tâche d'importation par lot sur d'autres charges de travail. La limitation doit être testée pour votre cas d'utilisation de la migration. Consultez l'exemple ci-dessous :
```
-Dgoogle.bigtable.buffered.mutator.throttling.enable=true
-Dgoogle.bigtable.buffered.mutator.throttling.threshold.ms=100
```
Modifiez le nombre de tâches de mappage qui lisent une seule région HBase (2 tâches de mappage par défaut par région). Consultez l'exemple ci-dessous :
```
-Dgoogle.bigtable.import.snapshot.splits.per.region=3
```
Définissez des configurations MapReduce supplémentaires en tant que propriétés. Consultez l'exemple ci-dessous :
```
-Dmapreduce.map.maxattempts=4
-Dmapreduce.map.speculative=false
-Dhbase.snapshot.thread.pool.max=20
```

Pour l'importation, tenez compte des conseils suivants :

Pour améliorer les performances du chargement des données, assurez-vous de disposer de suffisamment de nœuds de calcul de cluster Dataproc pour exécuter des tâches d'importation de mappage en parallèle. Par défaut, un nœud de calcul Dataproc n1-standard-8 exécute huit tâches d'importation. Un nombre suffisant de nœuds de calcul garantit que la tâche d'importation dispose de la puissance de calcul nécessaire pour être terminée dans un délai raisonnable, mais pas au point de surcharger l'instance Bigtable.
- Si vous n'utilisez pas également l'instance Bigtable pour une autre charge de travail, multipliez le nombre de nœuds de votre instance Bigtable par 3, puis divisez le nombre par 8 (avec un nœud de calcul Dataproc n1-standard-8). Utilisez le résultat en tant que nombre de nœuds de calcul Dataproc.
- Si vous utilisez l'instance pour une autre charge de travail en même temps que vous importez vos données HBase, réduisez la valeur des nœuds de calcul Dataproc ou augmentez le nombre de nœuds Bigtable pour répondre aux exigences des charges de travail.
Pendant l'importation, vous devez surveiller l'utilisation du processeur sur l'instance Bigtable. Si l'utilisation du processeur sur l'instance Bigtable est trop élevée, vous devrez peut-être ajouter des nœuds supplémentaires. L'ajout de nœuds améliore immédiatement l'utilisation du processeur, mais un délai de 20 minutes peut s'écouler avant que le cluster n'atteigne des performances optimales.

Pour plus d'informations sur la surveillance de l'instance Bigtable, consultez la page Surveiller une instance Bigtable.

Valider les données importées dans Bigtable

Vous pouvez ensuite valider la migration des données en effectuant une comparaison de hachage entre la table source et la table de destination pour garantir l'intégrité des données migrées. Tout d'abord, exécutez le job hash-table pour générer des hachages de plages de lignes sur la table source. Effectuez ensuite la validation en exécutant le job sync-table pour calculer et faire correspondre les hachages de Bigtable avec la source.

Pour créer des hachages à utiliser pour la validation, exécutez la commande suivante pour chaque table que vous migrez :

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/

Remplacez HBASE_TABLE_NAME par le nom de la table HBase pour laquelle vous avez créé l'instantané.

Exécutez la commande suivante dans la ligne de commande :

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

Remplacez les éléments suivants :

HBASE_TABLE_NAME : nom de la table HBase à partir de laquelle vous importez les données
BIGTABLE_TABLE_NAME : nom de la table Bigtable dans laquelle vous effectuez l'importation

Vous pouvez éventuellement ajouter --dryrun=false à la commande si vous souhaitez activer la synchronisation entre la source et la cible pour les plages de hachage divergentes.

Une fois la tâche sync-table terminée, les compteurs de la tâche s'affichent dans la console Google Cloud où la tâche a été exécutée. Si la tâche d'importation parvient à importer toutes les données, la valeur de HASHES_MATCHED possède une valeur et celle de HASHES_NOT_MATCHED est 0.

Si HASHES_NOT_MATCHED affiche une valeur, vous pouvez réexécuter sync-table en mode débogage pour émettre les plages divergentes et les détails au niveau de la cellule tels que Source missing cell, Target missing cell ou Different values. Pour activer le mode de débogage, configurez --properties mapreduce.map.log.level=DEBUG. Une fois la tâche exécutée, utilisez Cloud Logging et recherchez l'expression jsonPayload.class="org.apache.hadoop.hbase.mapreduce.SyncTable" pour examiner les cellules différentes.

Vous pouvez relancer la tâche d'importation ou utiliser SyncTable pour synchroniser les tables source et cible en définissant dryrun=false. Consultez la page HBase SyncTable et les options de configuration supplémentaires avant de continuer.

Résultats de SyncTable dans Cloud Logging

Mettre à jour l'application pour envoyer des lectures et des écritures à Bigtable.

Après avoir validé les données de chaque table du cluster, vous pouvez configurer vos applications pour qu'elles acheminent tout leur trafic vers Bigtable, puis abandonner l'instance HBase.

Une fois la migration terminée, vous pouvez supprimer les instantanés.