Migrazione da HBase su Google Cloud

In questa pagina vengono descritte considerazioni e procedure per la migrazione a Bigtable da un cluster Apache HBase ospitato su un servizio Google Cloud, come Dataproc o Compute Engine.

Per indicazioni sulla migrazione da un ambiente Apache HBase esterno a Bigtable, consulta Migrazione dei dati da HBase a Bigtable. Per saperne di più sulla migrazione online, vedi Replica da HBase da HBase a Bigtable.

Perché eseguire la migrazione da HBase su Google Cloud a Bigtable

Ecco alcuni motivi per cui potresti scegliere questo percorso di migrazione:

  • Puoi lasciare l'applicazione client dove è attualmente eseguito il deployment, modificando solo la configurazione della connessione.
  • I tuoi dati rimangono nell'ecosistema Google Cloud.
  • Se vuoi, puoi continuare a utilizzare l'API HBase. Il client HBase di Cloud Bigtable per Java è un'estensione completamente supportata della libreria Apache HBase per Java.
  • Vuoi usufruire dei vantaggi di utilizzare un servizio gestito per archiviare i tuoi dati.

Considerazioni

Questa sezione suggerisce alcuni aspetti da rivedere e riflettere prima di iniziare la migrazione.

Progettazione dello schema Bigtable

Nella maggior parte dei casi, in Bigtable puoi utilizzare lo stesso design dello schema che in HBase. Se vuoi modificare lo schema o il tuo caso d'uso sta cambiando, rivedi i concetti descritti in Progettazione dello schema prima di eseguire la migrazione dei dati.

Preparazione e test

Prima di eseguire la migrazione dei dati, assicurati di comprendere le differenze tra HBase e Bigtable. Dedica un po' di tempo a imparare a configurare la connessione per connettere la tua applicazione a Bigtable. Inoltre, potresti voler eseguire test di sistema e funzionali prima della migrazione per convalidare l'applicazione o il servizio.

Passi per la migrazione

Per eseguire la migrazione dei dati da HBase a Bigtable, devi creare uno snapshot HBase e importare i dati direttamente dal cluster HBase in Bigtable. Questi passaggi riguardano un singolo cluster HBase e sono descritti dettagliatamente nelle sezioni successive.

  1. Interrompi l'invio di scritture a HBase.
  2. Crea tabelle di destinazione in Bigtable.
  3. Acquisisci snapshot HBase e importali in Bigtable.
  4. Convalida i dati importati.
  5. Aggiorna l'applicazione per inviare letture e scritture a Bigtable.

immagine

Prima di iniziare

  1. Installa Google Cloud CLI o utilizza Cloud Shell.

  2. Crea un bucket Cloud Storage per archiviare i dati di output di convalida. Crea il bucket nella stessa località in cui prevedi di eseguire il job di Dataproc.

  3. Identifica il cluster Hadoop da cui esegui la migrazione. Devi eseguire i job per la migrazione su un cluster Dataproc 1.x con connettività di rete ai nodi Namenode e Datanode del cluster HBase. Prendi nota dell'indirizzo del Quorum e dell'URI del nodo dei nomi del cluster HBase, necessari per gli script di migrazione.

  4. Crea un cluster Dataproc versione 1.x sulla stessa rete del cluster HBase di origine. Puoi utilizzare questo cluster per eseguire i job di importazione e convalida.

  5. Crea un'istanza Bigtable per archiviare le nuove tabelle. Almeno un cluster nell'istanza Bigtable deve trovarsi nella stessa regione del cluster Dataproc. Esempio: us-central1

  6. Scarica lo strumento di traduzione degli schemi:

    wget BIGTABLE_HBASE_TOOLS_URL

    Sostituisci BIGTABLE_HBASE_TOOLS_URL con l'URL del più recente JAR with dependencies disponibile nel repository Maven dello strumento. Il nome del file è simile 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.

    Per trovare l'URL o scaricare manualmente il JAR:

    1. Vai al repository.
    2. Fai clic su Sfoglia per visualizzare i file di repository.
    3. Fai clic sul numero della versione più recente.
    4. Identifica JAR with dependencies file (di solito in alto).
    5. Fai clic con il pulsante destro del mouse e copia l'URL oppure fai clic per scaricare il file.

  7. Scarica lo strumento MapReduce, che utilizzi per i job di importazione e convalida:

    wget BIGTABLE_MAPREDUCE_URL

    Sostituisci BIGTABLE_MAPREDUCE_URL con l'URL del più recente shaded-byo JAR disponibile nel repository Maven dello strumento. Il nome del file è simile 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.

    Per trovare l'URL o scaricare manualmente il JAR:

    1. Vai al repository.
    2. Fai clic sul numero della versione più recente.
    3. Fai clic su Download.
    4. Passa il mouse su shaded-byo-hadoop.jar.
    5. Fai clic con il pulsante destro del mouse e copia l'URL oppure fai clic per scaricare il file.

  8. Imposta le seguenti variabili di ambiente:

    #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

    Sostituisci i segnaposto con i valori per la migrazione.

    Google Cloud:

    • PROJECT_ID: il progetto Google Cloud in cui si trova l'istanza Bigtable
    • REGION: la regione che contiene il cluster Dataproc che eseguirà i job di importazione e convalida.

    Bigtable:

    • BIGTABLE_INSTANCE_ID: l'identificatore dell'istanza Bigtable in cui stai importando i dati

    Dataproc:

    • DATAPROC_CLUSTER_ID: l'ID del cluster Dataproc che eseguirà i job di importazione e convalida

    Cloud Storage:

    • BUCKET_NAME: il nome del bucket Cloud Storage in cui vengono archiviati gli snapshot

    HBase:

    • ZOOKEEPER_QUORUM: l'host ZooKeeper a cui si connetterà lo strumento, nel formato host1.myownpersonaldomain.com
    • MIGRATION_SOURCE_NAMENODE_URI: l'URI del nodo del cluster HBase, nel formato hdfs://host1.myownpersonaldomain.com:8020

    File JAR

    • TRANSLATE_JAR: nome e numero di versione del file JAR bigtable hbase tools che hai scaricato da Maven. Il valore deve essere simile a bigtable-hbase-1.x-tools-2.6.0-jar-with-dependencies.jar.
    • MAPREDUCE_JAR: nome e numero di versione del file JAR bigtable hbase mapreduce che hai scaricato da Maven. Il valore deve essere simile a bigtable-hbase-1.x-mapreduce-2.6.0-shaded-byo-hadoop.jar.

  9. (Facoltativo) Per confermare che le variabili sono state impostate correttamente, esegui il comando printenv per visualizzare tutte le variabili di ambiente.

Interrompi invio di scritture a HBase

Prima di creare snapshot delle tabelle HBase, interrompi l'invio delle scritture al cluster HBase.

Crea tabelle di destinazione in Bigtable

Il passaggio successivo consiste nel creare una tabella di destinazione nell'istanza Bigtable per ogni tabella HBase di cui esegui la migrazione. Utilizza un account con autorizzazione bigtable.tables.create per l'istanza.

Questa guida utilizza lo strumento Bigtable Schema Translation, che crea automaticamente la tabella. Tuttavia, se non vuoi che lo schema di Bigtable corrisponda esattamente allo schema HBase, puoi creare una tabella utilizzando l'interfaccia a riga di comando cbt o la console Google Cloud.

Lo strumento Bigtable Schema Translation acquisisce lo schema della tabella HBase, che include il nome della tabella, le famiglie di colonne, i criteri di garbage collection e le suddivisioni. Viene quindi creata una tabella simile in Bigtable.

Per ogni tabella da importare, esegui il comando seguente per copiare lo schema da 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

Sostituisci TABLE_NAME con il nome della tabella HBase che stai importando. Lo strumento Traduzione schemi utilizza questo nome per la nuova tabella Bigtable.

Facoltativamente, puoi sostituire TABLE_NAME con un'espressione regolare, come ".*", che acquisisce tutte le tabelle da creare, quindi eseguire il comando una sola volta.

Acquisisci snapshot di tabelle HBase e importali in Bigtable

Completa quanto segue per ogni tabella di cui prevedi di eseguire la migrazione a Bigtable.

  1. Esegui questo comando:

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

    Sostituisci quanto segue:

    • HBASE_TABLE_NAME: il nome della tabella HBase che esegui la migrazione a Bigtable.
    • HBASE_SNAPSHOT_NAME: nome univoco del nuovo snapshot

  2. Importa lo snapshot eseguendo questo 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

    Sostituisci quanto segue:

    • HBASE_SNAPSHOT_NAME: il nome assegnato all'istantanea della tabella che stai importando
    • BIGTABLE_TABLE_NAME: il nome della tabella Bigtable in cui stai eseguendo l'importazione

    Dopo aver eseguito il comando, lo strumento ripristina lo snapshot HBase nel cluster di origine e lo importa. Il completamento del processo di ripristino dello snapshot può richiedere diversi minuti, a seconda delle dimensioni dello snapshot.

Quando importi i dati, sono disponibili le seguenti opzioni aggiuntive:

  • Imposta i timeout basati su client per le richieste di mutatore con buffer (valore predefinito: 600000 ms). Vedi l'esempio che segue:

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

  • Considera la limitazione basata sulla latenza, che può ridurre l'impatto che il job batch di importazione potrebbe avere su altri carichi di lavoro. La limitazione deve essere testata per il tuo caso d'uso di migrazione. Vedi l'esempio che segue:

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

  • Modifica il numero di attività mappa che leggono una singola regione HBase (valore predefinito: 2 attività mappa per regione). Vedi l'esempio che segue:

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

  • Impostare configurazioni MapReduce aggiuntive come proprietà. Vedi l'esempio che segue:

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

Durante l'importazione, tieni presente i seguenti suggerimenti:

  • Per migliorare le prestazioni del caricamento dei dati, assicurati di disporre di un numero sufficiente di worker del cluster Dataproc per eseguire in parallelo le attività di importazione delle mappe. Per impostazione predefinita, un worker n1-standard-8 Dataproc eseguirà otto attività di importazione. Avere un numero sufficiente di worker garantisce che il job di importazione abbia una potenza di calcolo sufficiente per completare in un tempo ragionevole, ma non così tanta potenza da sovraccaricare l'istanza Bigtable.
    • Se non utilizzi l'istanza Bigtable anche per un altro carico di lavoro, moltiplica per 3 il numero di nodi nell'istanza Bigtable, quindi dividi per 8 (con il worker dataproc n1-standard-8). Utilizza il risultato come numero di worker Dataproc.
    • Se utilizzi l'istanza per un altro carico di lavoro nello stesso momento in cui importi i dati HBase, riduci il valore dei worker Dataproc o aumenta il numero di nodi Bigtable per soddisfare i requisiti dei carichi di lavoro.
  • Durante l'importazione, devi monitorare l'utilizzo della CPU dell'istanza Bigtable. Se l'utilizzo della CPU nell'istanza Bigtable è troppo elevato, potresti dover aggiungere altri nodi. L'aggiunta di nodi migliora immediatamente l'utilizzo della CPU, ma dopo l'aggiunta dei nodi al cluster può essere necessario attendere fino a 20 minuti per raggiungere prestazioni ottimali.

Per ulteriori informazioni sul monitoraggio dell'istanza Bigtable, consulta Monitoraggio di un'istanza Bigtable.

Convalida i dati importati in Bigtable

Successivamente, convalida la migrazione dei dati eseguendo un confronto hash tra la tabella di origine e quella di destinazione per acquisire fiducia nell'integrità dei dati sottoposti a migrazione. Innanzitutto, esegui il job hash-table per generare hash di intervalli di righe nella tabella di origine. Quindi, completa la convalida eseguendo il job sync-table per calcolare e abbinare gli hash di Bigtable all'origine.

  1. Per creare hash da utilizzare per la convalida, esegui questo comando per ogni tabella di cui stai eseguendo la migrazione:

    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/

    Sostituisci HBASE_TABLE_NAME con il nome della tabella HBase per cui hai creato lo snapshot.

  2. Esegui il comando seguente nella shell dei comandi:

    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

    Sostituisci quanto segue:

    • HBASE_TABLE_NAME: il nome della tabella HBase da cui stai eseguendo l'importazione
    • BIGTABLE_TABLE_NAME: il nome della tabella Bigtable in cui stai eseguendo l'importazione

Facoltativamente, puoi aggiungere --dryrun=false al comando se vuoi abilitare la sincronizzazione tra l'origine e la destinazione per la divergenza degli intervalli hash.

Quando il job sync-table è stato completato, i contatori vengono visualizzati nella console Google Cloud in cui è stato eseguito il job. Se il job di importazione importa tutti i dati correttamente, il valore di HASHES_MATCHED contiene un valore, mentre il valore di HASHES_NOT_MATCHED è 0.

Se HASHES_NOT_MATCHED mostra un valore, puoi eseguire nuovamente sync-table in modalità di debug per emettere gli intervalli divergenti e i dettagli a livello di cella come Source missing cell, Target missing cell o Different values. Per attivare la modalità di debug, configura --properties mapreduce.map.log.level=DEBUG. Dopo l'esecuzione del job, utilizza Cloud Logging e cerca l'espressione jsonPayload.class="org.apache.hadoop.hbase.mapreduce.SyncTable" per esaminare le celle di divisione.

Puoi riprovare a eseguire il job di importazione o utilizzare SyncTable per sincronizzare le tabelle di origine e di destinazione impostando dryrun=false. Esamina la tabella HBase SyncTable e le altre opzioni di configurazione prima di procedere.

Risultati di SyncTable in Cloud Logging

Aggiorna l'applicazione per inviare letture e scritture a Bigtable

Dopo aver convalidato i dati per ogni tabella nel cluster, puoi configurare le tue applicazioni per instradare tutto il traffico a Bigtable e quindi deprecare il cluster HBase.

Al termine della migrazione, puoi eliminare gli snapshot.

Passaggi successivi