Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui la 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 in 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 su Google Cloud a Bigtable.

Prima di iniziare questa migrazione, devi considerare le implicazioni sul rendimento, il design dello schema Bigtable, il tuo approccio all'autenticazione e all'autorizzazione e il set di funzionalità di Bigtable.

Considerazioni preliminari alla migrazione

Questa sezione suggerisce alcuni aspetti da esaminare e considerare prima di iniziare la migrazione.

Prestazioni

In un carico di lavoro tipico, Bigtable offre prestazioni molto prevedibili. Assicurati di aver compreso i fattori che influenzano Prestazioni di Bigtable prima della migrazione dei dati.

Progettazione dello schema di Bigtable

Nella maggior parte dei casi, puoi utilizzare lo stesso design dello schema in Bigtable come faresti in HBase. Se vuoi modificare lo schema o se il tuo caso d'uso è cambiare, esaminare i concetti esposti in Progetta lo schema prima di eseguire la migrazione dei dati.

Autenticazione e autorizzazione

Prima di progettare il controllo degli accessi per Bigtable, esamina le procedure di autenticazione e autorizzazione HBase esistenti.

Bigtable utilizza i meccanismi standard di Google Cloud per l'autenticazione e la gestione di identità e accessi per fornire il controllo degli accessi, quindi puoi convertire l'autorizzazione esistente su HBase in IAM. Puoi mappare i gruppi Hadoop esistenti che forniscono meccanismi di controllo dell'accesso per HBase a diversi account di servizio.

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

Esegui la migrazione di HBase a Bigtable

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

Interrompi l'invio delle scritture al cluster HBase.
Acquisisci istantanee delle tabelle del cluster HBase.
Esporta i file degli snapshot in Cloud Storage.
Calcola gli hash ed esportali in Cloud Storage.
Creare tabelle di destinazione in Bigtable.
Importa i dati HBase da Cloud Storage in Bigtable.
Convalida i dati importati.
Instrada le scritture a Bigtable.

Prima di iniziare

Crea un bucket Cloud Storage per e archiviare gli snapshot. Crea il bucket nella stessa località in cui prevedi di eseguire il job Dataflow.
Crea un'istanza Bigtable per archiviare le nuove tabelle.
Identifica il cluster Hadoop che stai esportando. Puoi eseguire i job per la migrazione direttamente sul cluster HBase o su un cluster Hadoop separato con connettività di rete ai Namenode e ai Datanode del cluster HBase.
Installa e configura il connettore Cloud Storage su ogni nodo del cluster Hadoop e sull'host da cui viene avviato il job. Per i passaggi di installazione dettagliati, consulta Installare il connettore Cloud Storage.
Apri una shell di comando su un host in grado di connettersi al tuo cluster HBase progetto Bigtable. Qui completerai i passaggi successivi.
Ottieni lo strumento di traduzione dello schema:
```
wget BIGTABLE_HBASE_TOOLS_URL
```
Sostituisci BIGTABLE_HBASE_TOOLS_URL con l'URL dell'JAR with dependencies più recente 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 file JAR, procedi nel seguente modo:
1. Vai al repository.
2. Fai clic sul numero della versione più recente.
3. Individua il pulsante JAR with dependencies file (di solito in alto).
4. Fai clic con il tasto destro del mouse e copia l'URL oppure fai clic per scaricare il file.
Scarica lo strumento di importazione:
```
wget BIGTABLE_BEAM_IMPORT_URL
```
Sostituisci BIGTABLE_BEAM_IMPORT_URL con l'URL dell'shaded JAR più recente 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 file JAR, procedi nel seguente modo: le seguenti:
1. Vai al repository.
2. Fai clic sul numero della versione più recente.
3. Fai clic su Download.
4. Passa il mouse sopra shaded.jar.
5. Fai clic con il tasto destro del mouse e copia l'URL oppure fai clic per scaricare il file.
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 del Istanza Bigtable in cui stai importando i dati
- REGION: una regione che contiene uno dei cluster in la tua istanza Bigtable. Esempio: northamerica-northeast2
- CLUSTER_NUM_NODES: il numero di nodi nell'istanza Bigtable
- TRANSLATE_JAR: il nome e il numero di versione del file JAR bigtable hbase tools che hai scaricato da Maven. Il valore dovrebbe avere il seguente aspetto: bigtable-hbase-1.x-tools-1.24.0-jar-with-dependencies.jar.
- IMPORT_JAR: il nome e il numero di versione del file JAR bigtable-beam-import che hai scaricato da Maven. Il valore dovrebbe avere un aspetto simile a bigtable-beam-import-1.24.0-shaded.jar.
- BUCKET_NAME: il nome del bucket Cloud Storage in cui memorizzi gli snapshot
- ZOOKEEPER_QUORUM: il custode che ospita lo strumento si connetterà, nel formato host1.myownpersonaldomain.com
- MIGRATION_SOURCE_DIRECTORY: la directory sull'hosting HBase che contiene i dati di cui vuoi eseguire la migrazione, nel formatohdfs://host1.myownpersonaldomain.com:8020/hbase
(Facoltativo) Per verificare che le variabili siano impostate correttamente, esegui la printenv per visualizzare tutte le variabili di ambiente.

Interrompi l'invio di scritture in HBase

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

Acquisisci snapshot delle tabelle HBase

Quando il tuo 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'impronta di archiviazione minima sul cluster HBase, ma con il tempo potrebbe raggiungere le stesse dimensioni della tabella originale. L'istantanea non consuma risorse della CPU.

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

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

Sostituisci quanto segue:

TABLE_NAME: il nome della tabella HBase che hai da cui esporta i dati.
SNAPSHOT_NAME: il nome del nuovo snapshot

Esportare 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 le altre risorse HBase per assicurarti che i cluster rimangano in buono stato.

Per ogni snapshot che vuoi 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 in esporta.

Calcola ed esporta hash

Successivamente, 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 sulla tabella di destinazione per abbinare gli hash e acquisire la certezza dell'integrità dei dati sottoposti a migrazione.

Esegui il seguente 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 di cui hai creato e 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 autorizzazionebigtable.tables.create per l'istanza.

Questa guida utilizza lo strumento di traduzione dello schema Bigtable, che crea automaticamente la tabella. Tuttavia, se non vuoi che lo schema di Bigtable corrisponda esattamente a quello di HBase, puoi creare una tabella utilizzando lo strumento a riga di comando cbt o la console Google Cloud.

Lo strumento di traduzione dello schema Bigtable acquisisce lo schema della tabella HBase, inclusi il nome della tabella, le famiglie di colonne, i criteri di garbage collection e le suddivisioni. Quindi crea una tabella simile in Bigtable.

Per ogni tabella da importare, esegui il seguente comando 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 di traduzione schema utilizza questo nome per la nuova tabella Bigtable.

Se vuoi, puoi anche sostituire TABLE_NAME con un'espressione regolare, ad esempio ".*", che acquisisca tutte le tabelle che vuoi creare, quindi eseguire il comando una sola volta.

Importa i dati di HBase in Bigtable utilizzando Dataflow

Dopo aver creato una tabella in cui eseguire la migrazione dei dati, puoi procedere con l'importazione e la convalida dei dati.

Tabelle non compresse

Se le tabelle HBase non sono compresse, esegui il seguente comando 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 schema assegna questo nome la nuova tabella Bigtable. I nuovi nomi delle tabelle non sono supportati.
SNAPSHOT_NAME: il nome assegnato allo screenshot della tabella che stai importando

Dopo aver eseguito il comando, lo strumento ripristina lo snapshot HBase nel tuo bucket Cloud Storage e avvia il job di importazione. L'operazione può richiedere diverse minuti per il completamento del processo di ripristino dello snapshot, a seconda del le dimensioni dello snapshot.

Tieni presente i seguenti suggerimenti durante l'importazione:

Per migliorare le prestazioni del caricamento dei dati, assicurati di impostare maxNumWorkers. Questo valore contribuisce a garantire che il job di importazione abbia potenza di calcolo sufficiente per da completare in un periodo di tempo ragionevole, ma non così tanto da sovraccaricare o l'istanza Bigtable.
- Se non utilizzi anche l'istanza Bigtable per un'altra istanza per il carico di lavoro, moltiplica il numero di nodi nel tuo istanza per 3 e usa questo numero per maxNumWorkers.
- Se utilizzi l'istanza per un altro carico di lavoro contemporaneamente stai importando i tuoi 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 L'istanza Bigtable è troppo alta, potresti dover aggiungere altre nodi. Possono essere necessari fino a 20 minuti prima che il cluster fornisca le prestazioni vantaggio di nodi aggiuntivi.

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

Tabelle compresse rapide

Se importi tabelle compresse Snappy, devi utilizzare un container personalizzato immagine in la pipeline Dataflow. L'immagine container personalizzata che utilizzi per importare dati compressi in Bigtable Supporto delle librerie di compressione native di Hadoop. Devi disporre dell'SDK Apache Beam versione 2.30.0 o successiva per utilizzare Dataflow Runner v2, ed è necessario versione 2.3.0 o successiva della libreria client HBase per Java.

Per importare tabelle compresse Snappy, esegui lo stesso comando che 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 della tabella Hash calcolato in precedenza.

Per eseguire il job sync-table, esegui quanto segue 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.

Una volta completato il job sync-table, apri la pagina Dettagli job Dataflow e esamina la sezione Contatori personalizzati per il job. Se il job di importazione importa correttamente tutti i dati, il valore di ranges_matched ha un valore e il valore di ranges_not_matched è 0.

Contatori personalizzati Dataflow

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

Log dei worker Dataflow

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

Instrada le scritture a Bigtable

Dopo aver convalidato i dati per ogni tabella nel cluster, puoi configurare le applicazioni per instradare il traffico verso Bigtable, quindi deprecare l'istanza HBase.

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

Passaggi successivi

Consulta le altre parti della guida alla migrazione di Hadoop:
- Panoramica
- Guida alla migrazione dei dati
- Guida alla migrazione dei job
- Scopri di più su Cloud Storage.