Migrazione dei dati da HBase a Bigtable

Questa pagina descrive considerazioni e procedure per la migrazione dei dati da un cluster Apache HBase a un'istanza Bigtable su Google Cloud.

Per eseguire la migrazione dei dati a Bigtable da un cluster HBase ospitato su un servizio Google Cloud, come Dataproc o Compute Engine, consulta Migrazione di HBase da Google Cloud a Bigtable.

Prima di iniziare questa migrazione, devi valutare le implicazioni in termini di prestazioni, la progettazione dello schema di Bigtable, il tuo approccio all'autenticazione e all'autorizzazione e il set di funzionalità di Bigtable.

Considerazioni pre-migrazione

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

Prestazioni

In un carico di lavoro tipico, Bigtable offre prestazioni altamente prevedibili. Assicurati di comprendere i fattori che influiscono sulle prestazioni di Bigtable prima di eseguire la migrazione dei dati.

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.

autentica e autorizza

Prima di progettare controllo dell'accesso per Bigtable, esamina i processi di autenticazione e autorizzazione HBase esistenti.

Bigtable utilizza i meccanismi standard di Google Cloud per l'autenticazione e Identity and Access Management per fornire controllo dell'accesso dell'accesso, in modo da convertire l'autorizzazione esistente su HBase in IAM. Puoi mappare i gruppi Hadoop esistenti che forniscono meccanismi di controllo dell'accesso per HBase ad account di servizio diversi.

Bigtable consente di controllare l'accesso a livello di progetto, istanza e tabella. Per ulteriori informazioni, vedi Controllo dell'accesso.

Migrazione di HBase a Bigtable

Per eseguire la migrazione dei dati da HBase a Bigtable, devi esportare uno snapshot HBase per ogni tabella in Cloud Storage e quindi importare i dati in Bigtable. Questi passaggi riguardano un singolo cluster HBase e sono descritti dettagliatamente nelle sezioni successive.

  1. Interrompi l'invio di scritture al cluster HBase.
  2. Acquisisci snapshot delle tabelle del cluster HBase.
  3. Esporta i file di snapshot in Cloud Storage.
  4. Calcola gli hash ed esportali in Cloud Storage.
  5. Creare tabelle di destinazione in Bigtable.
  6. Importare i dati HBase da Cloud Storage in Bigtable.
  7. Convalida i dati importati.
  8. Instrada le scritture a Bigtable.

Prima di iniziare

  1. Crea un bucket Cloud Storage per archiviare gli snapshot. Crea il bucket nella stessa località in cui prevedi di eseguire il job Dataflow.

  2. Crea un'istanza Bigtable per archiviare le nuove tabelle.

  3. Identifica il cluster Hadoop che stai esportando. Puoi eseguire i job per la migrazione direttamente sul cluster HBase o su un cluster Hadoop separato che dispone della connettività di rete ai nodi Namenode e Datanodes del cluster HBase.

  4. Installa e configura il connettore Cloud Storage su ogni nodo nel cluster Hadoop, nonché sull'host da cui viene avviato il job. Per la procedura dettagliata di installazione, consulta Installazione del connettore Cloud Storage.

  5. Apri una shell di comando su un host in grado di connettersi al cluster HBase e al progetto Bigtable. Qui potrai completare i passaggi successivi.

  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/1.24.0/bigtable-hbase-1.x-tools-1.24.0-jar-with-dependencies.jar.

    Per trovare l'URL o scaricare manualmente il JAR:

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

  7. Scarica lo strumento di importazione:

    wget BIGTABLE_BEAM_IMPORT_URL

    Sostituisci BIGTABLE_BEAM_IMPORT_URL con l'URL del più recente shaded JAR disponibile nel repository Maven dello strumento. Il nome del file è simile a https://repo1.maven.org/maven2/com/google/cloud/bigtable/bigtable-beam-import/1.24.0/bigtable-beam-import-1.24.0-shaded.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.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 INSTANCE_ID=INSTANCE_ID
export REGION=REGION
export CLUSTER_NUM_NODES=CLUSTER_NUM_NODES

#JAR files

export TRANSLATE_JAR=TRANSLATE_JAR
export IMPORT_JAR=IMPORT_JAR

#Cloud Storage

export BUCKET_NAME="gs://BUCKET_NAME"
export MIGRATION_DESTINATION_DIRECTORY="$BUCKET_NAME/hbase-migration-snap"

#HBase

export ZOOKEEPER_QUORUM=ZOOKEPER_QUORUM
export ZOOKEEPER_PORT=2181
export ZOOKEEPER_QUORUM_AND_PORT="$ZOOKEEPER_QUORUM:$ZOOKEEPER_PORT"
export MIGRATION_SOURCE_DIRECTORY=MIGRATION_SOURCE_DIRECTORY

    Sostituisci quanto segue:

    • PROJECT_ID: il progetto Google Cloud in cui si trova l'istanza
    • INSTANCE_ID: l'identificatore dell'istanza Bigtable in cui stai importando i dati
    • REGION: una regione che contiene uno dei cluster nell'istanza Bigtable. Esempio: northamerica-northeast2
    • CLUSTER_NUM_NODES: il numero di nodi nell'istanza Bigtable
    • 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-1.24.0-jar-with-dependencies.jar.
    • IMPORT_JAR: nome e numero di versione del file JAR bigtable-beam-import che hai scaricato da Maven. Il valore deve essere simile a bigtable-beam-import-1.24.0-shaded.jar.
    • BUCKET_NAME: il nome del bucket Cloud Storage in cui vengono archiviati gli snapshot
    • ZOOKEEPER_QUORUM: l'host del guardiano dello zoo a cui si collegherà lo strumento, nel formato host1.myownpersonaldomain.com
    • MIGRATION_SOURCE_DIRECTORY: la directory sul tuo host HBase che contiene i dati di cui vuoi eseguire la migrazione, nel formato hdfs://host1.myownpersonaldomain.com:8020/hbase

  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.

Acquisisci snapshot delle tabelle HBase

Quando il cluster HBase non importa più dati, acquisisci uno snapshot di ogni tabella di cui prevedi di eseguire la migrazione a Bigtable.

Inizialmente, uno snapshot ha un ingombro di archiviazione minimo sul cluster HBase, ma nel tempo potrebbe raggiungere le stesse dimensioni della tabella originale. Lo snapshot non consuma alcuna risorsa della CPU.

Esegui questo comando per ogni tabella, utilizzando un nome univoco per ogni snapshot:

echo "snapshot 'TABLE_NAME', 'SNAPSHOT_NAME'" | hbase shell -n

Sostituisci quanto segue:

  • TABLE_NAME: il nome della tabella HBase da cui stai esportando i dati.
  • SNAPSHOT_NAME: il nome del nuovo snapshot

Esporta gli snapshot HBase in Cloud Storage

Dopo aver creato gli snapshot, devi esportarli. Quando esegui job di esportazione su un cluster HBase di produzione, monitora il cluster e altre risorse HBase per assicurarti che i cluster rimangano in uno stato buono.

Per ogni snapshot da esportare, esegui questo comando:

hbase org.apache.hadoop.hbase.snapshot.ExportSnapshot \
-Dhbase.zookeeper.quorum=$ZOOKEEPER_QUORUM_AND_PORT -snapshot SNAPSHOT_NAME \
    -copy-from $MIGRATION_SOURCE_DIRECTORY \
    -copy-to $MIGRATION_DESTINATION_DIRECTORY/data

Sostituisci SNAPSHOT_NAME con il nome dello snapshot da esportare.

Calcolare ed esportare gli hash

Poi, crea gli hash da utilizzare per la convalida al termine della migrazione. HashTable è uno strumento di convalida fornito da HBase che calcola gli hash per gli intervalli di righe e li esporta in file. Puoi eseguire un job sync-table nella tabella di destinazione in modo da associare gli hash e acquisire fiducia nell'integrità dei dati di cui è stata eseguita la migrazione.

Esegui questo comando per ogni tabella esportata:

hbase org.apache.hadoop.hbase.mapreduce.HashTable --batchsize=32000 --numhashfiles=20 \
TABLE_NAME $MIGRATION_DESTINATION_DIRECTORY/hashtable/TABLE_NAME

Sostituisci quanto segue:

  • TABLE_NAME: il nome della tabella HBase per cui hai creato ed esportato uno snapshot

Crea tabelle di destinazione

Il passaggio successivo consiste nel creare una tabella di destinazione nell'istanza Bigtable per ogni snapshot esportato. 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 lo strumento 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=$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.

Importa i dati HBase in Bigtable utilizzando Dataflow

Quando una tabella è pronta per la migrazione dei dati, puoi importare e convalidare i dati.

Tabelle non compresse

Se le tabelle HBase non sono compresse, esegui il comando seguente per ogni tabella di cui vuoi eseguire la migrazione:

java -jar $IMPORT_JAR importsnapshot \
    --runner=DataflowRunner \
    --project=$PROJECT_ID \
    --bigtableInstanceId=$INSTANCE_ID \
    --bigtableTableId=TABLE_NAME \
    --hbaseSnapshotSourceDir=$MIGRATION_DESTINATION_DIRECTORY/data \
    --snapshotName=SNAPSHOT_NAME \
    --stagingLocation=$MIGRATION_DESTINATION_DIRECTORY/staging \
    --tempLocation=$MIGRATION_DESTINATION_DIRECTORY/temp \
    --maxNumWorkers=$(expr 3 \* $CLUSTER_NUM_NODES) \
    --region=$REGION

Sostituisci quanto segue:

  • TABLE_NAME: il nome della tabella HBase che stai importando. Lo strumento di traduzione di schemi utilizza questo nome per la nuova tabella Bigtable. I nuovi nomi di tabella non sono supportati.
  • SNAPSHOT_NAME: il nome assegnato all'istantanea della tabella che stai importando

Dopo aver eseguito il comando, lo strumento ripristina lo snapshot HBase nel bucket Cloud Storage, quindi avvia il job di importazione. Il completamento del processo di ripristino dello snapshot può richiedere diversi minuti, a seconda delle dimensioni dello snapshot.

Durante l'importazione, tieni presente i seguenti suggerimenti:

  • Per migliorare le prestazioni del caricamento dei dati, assicurati di impostare maxNumWorkers. Questo valore aiuta a garantire che il job di importazione abbia una potenza di calcolo sufficiente per essere completato in un periodo di tempo ragionevole, ma non così tanto 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 e utilizza questo numero per maxNumWorkers.
    • Se utilizzi l'istanza per un altro carico di lavoro nello stesso momento in cui importi i dati HBase, riduci il valore di maxNumWorkers in modo appropriato.
  • Utilizza il tipo di worker predefinito.
  • Durante l'importazione, devi monitorare l'utilizzo della CPU dell'istanza Bigtable. Se l'utilizzo della CPU nell'istanza di Bigtable è troppo elevato, potresti dover aggiungere altri nodi. Possono essere necessari fino a 20 minuti prima che il cluster fornisca i vantaggi in termini di prestazioni di nodi aggiuntivi.

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

Tabelle compresse rapide

Se importi tabelle compresse da Snappy, devi utilizzare un'immagine container personalizzata nella pipeline Dataflow. L'immagine container personalizzata che utilizzi per importare dati compressi in Bigtable offre il supporto della libreria di compressione nativa Hadoop. Per utilizzare Dataflow Runner v2 devi disporre dell'SDK Apache Beam versione 2.30.0 o successiva e devi disporre della versione 2.3.0 o successiva della libreria client HBase per Java.

Per importare le tabelle compresse di Snappy, esegui lo stesso comando che esegui per le tabelle non compresse, ma aggiungi la seguente opzione:

    --enableSnappy=true

Convalida i dati importati in Bigtable

Per convalidare i dati importati, devi eseguire il job sync-table. Il job sync-table calcola gli hash per gli intervalli di righe in Bigtable, quindi li abbina all'output di HashTable che hai calcolato in precedenza.

Per eseguire il job sync-table, esegui questo comando nella shell dei comandi:

java -jar $IMPORT_JAR sync-table  \
    --runner=dataflow \
    --project=$PROJECT_ID \
    --bigtableInstanceId=$INSTANCE_ID \
    --bigtableTableId=TABLE_NAME \
    --outputPrefix=$MIGRATION_DESTINATION_DIRECTORY/sync-table/output-TABLE_NAME-$(date +"%s") \
    --stagingLocation=$MIGRATION_DESTINATION_DIRECTORY/sync-table/staging \
    --hashTableOutputDir=$MIGRATION_DESTINATION_DIRECTORY/hashtable/TABLE_NAME \
    --tempLocation=$MIGRATION_DESTINATION_DIRECTORY/sync-table/dataflow-test/temp \
    --region=$REGION

Sostituisci TABLE_NAME con il nome della tabella HBase che stai importando.

Quando il job sync-table è stato completato, apri la pagina Dettagli job Dataflow ed esamina la sezione Contatori personalizzati per il job. Se il job di importazione importa tutti i dati correttamente, il valore di ranges_matched contiene un valore, mentre il valore di ranges_not_matched è 0.

Contatori personalizzati Dataflow

Se ranges_not_matched mostra un valore, apri la pagina Log, scegli Log del worker e filtra per Mancata corrispondenza nell'intervallo. L'output leggibile di questi log viene archiviato in Cloud Storage nella destinazione di output creata nell'opzione outputPrefix della tabella di sincronizzazione.

Log dei worker Dataflow

Puoi riprovare a eseguire il job di importazione o scrivere uno script per leggere i file di output e determinare dove si sono verificate le mancate corrispondenze. Ogni riga nel file di output è un record JSON serializzato di un intervallo non corrispondente.

Route 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, quindi ritirare l'istanza HBase.

Al termine della migrazione, puoi eliminare gli snapshot nell'istanza HBase.

Passaggi successivi