Questa pagina è stata tradotta dall'API Cloud Translation.

Eseguire la migrazione da HBase su Google Cloud

Questa pagina descrive 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 Eseguire la migrazione dei dati da HBase a Bigtable. Per scoprire di più sulla migrazione online, consulta Eseguire la replica 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 dipiattamata, 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 Cloud Bigtable HBase per Java è un'estensione completamente supportata della libreria Apache HBase per Java.
Vuoi usufruire dei vantaggi dell'utilizzo di un servizio gestito per archiviare i tuoi dati.

Considerazioni

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

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 sta cambiando, esamina 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 conoscere le differenze tra HBase e Bigtable. Ti consigliamo di dedicare un po' di tempo a scoprire come configurare la connessione per collegare la tua applicazione a Bigtable. Inoltre, ti consigliamo di 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, acquisisci uno snapshot di HBase e importa i dati direttamente dal cluster HBase in Bigtable. Questi passaggi si riferiscono a un singolo cluster HBase e sono descritti in dettaglio nelle sezioni successive.

Interrompi l'invio di scritture ad HBase.
Crea tabelle di destinazione in Bigtable.
Esegui snapshot di HBase e importali in Bigtable.
Convalida i dati importati.
Aggiorna l'applicazione in modo da inviare letture e scritture a Bigtable.

immagine

Prima di iniziare

Installa Google Cloud CLI o utilizza Cloud Shell.
Crea un bucket Cloud Storage per memorizzare i dati di output della convalida. Crea il bucket nella stessa località in cui prevedi di eseguire il job Dataproc.
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 Namenode e ai Datanode del cluster HBase. Prendi nota dell'indirizzo del quorum ZooKeeper e dell'URI del nome del nodo del cluster HBase, che sono obbligatori per gli script di migrazione.
Crea un cluster Dataproc della versione 1.x sulla stessa rete del cluster HBase di origine. Utilizza questo cluster per eseguire i job di importazione e convalida.
Crea un'istanza Bigtable per archiviare le nuove tabelle. Almeno un cluster nell'istanza Bigtable deve trovarsi anche nella stessa regione del cluster Dataproc. Esempio: us-central1
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/2.6.0/bigtable-hbase-1.x-tools-2.6.0-jar-with-dependencies.jar.

Per trovare l'URL o scaricare manualmente il file JAR:
1. Vai al repository.
2. Fai clic su Sfoglia per visualizzare i file del repository.
3. Fai clic sul numero della versione più recente.
4. Individua il pulsante JAR with dependencies file (di solito in alto).
5. Fai clic con il tasto destro del mouse e copia l'URL oppure fai clic per scaricare il file.
Ottieni lo strumento MapReduce, che utilizzi per i job di importazione e convalida:
```
wget BIGTABLE_MAPREDUCE_URL
```
Sostituisci BIGTABLE_MAPREDUCE_URL con l'URL dell'shaded-byo 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-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 file JAR:
1. Vai al repository.
2. Fai clic sul numero della versione più recente.
3. Fai clic su Download.
4. Passa il mouse sopra shaded-byo-hadoop.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 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 la tua 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 memorizzi gli snapshot
HBase:
- ZOOKEEPER_QUORUM: l'host ZooKeeper a cui si collegherà lo strumento, nel formato host1.myownpersonaldomain.com
- MIGRATION_SOURCE_NAMENODE_URI: l'URI del NameNode del tuo cluster HBase, nel formatohdfs://host1.myownpersonaldomain.com:8020
File JAR
- TRANSLATE_JAR: il nome e il numero di versione del file JAR bigtable hbase tools che hai scaricato da Maven. Il valore dovrebbe avere un aspetto simile a bigtable-hbase-1.x-tools-2.6.0-jar-with-dependencies.jar.
- MAPREDUCE_JAR: il nome e il numero di versione del file JAR bigtable hbase mapreduce che hai scaricato da Maven. Il valore dovrebbe avere un aspetto simile a bigtable-hbase-1.x-mapreduce-2.6.0-shaded-byo-hadoop.jar.
(Facoltativo) Per verificare che le variabili siano impostate correttamente, esegui il comando printenv per visualizzare tutte le variabili di ambiente.

Interrompi l'invio di scritture in HBase

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

Creare tabelle di destinazione in Bigtable

Il passaggio successivo consiste nel creare una tabella di destinazione nell'istanza Bigtable per ogni tabella HBase di cui stai eseguendo la migrazione. 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 la CLI 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. Poi 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=$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 di traduzione dello 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.

Acquisisci snapshot delle tabelle HBase e importali in Bigtable

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

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 di cui stai eseguendo la migrazione a Bigtable.
- HBASE_SNAPSHOT_NAME: il nome univoco del nuovo snapshot
Importa lo snapshot eseguendo il seguente 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 allo screenshot 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 poi lo importa. Il completamento del processo di recupero 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 sul client per le richieste di modificatori in buffer (valore predefinito 600000 ms). Vedi il seguente esempio:
```
-Dgoogle.bigtable.rpc.use.timeouts=true
-Dgoogle.bigtable.mutate.rpc.timeout.ms=600000
```
Valuta la possibilità di utilizzare la limitazione in base alla latenza, che può ridurre l'impatto del job batch di importazione su altri carichi di lavoro. La limitazione deve essere testata per il tuo caso d'uso di migrazione. Vedi il seguente esempio:
```
-Dgoogle.bigtable.buffered.mutator.throttling.enable=true
-Dgoogle.bigtable.buffered.mutator.throttling.threshold.ms=100
```
Modifica il numero di attività di mappatura che leggono una singola regione HBase (per impostazione predefinita 2 attività di mappatura per regione). Vedi il seguente esempio:
```
-Dgoogle.bigtable.import.snapshot.splits.per.region=3
```

Imposta configurazioni MapReduce aggiuntive come proprietà. Vedi l'esempio di seguito:

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

Tieni presente i seguenti suggerimenti durante l'importazione:

Per migliorare il rendimento del caricamento dei dati, assicurati di disporre di un numero sufficiente di worker del cluster Dataproc per eseguire le attività di importazione delle mappe in parallelo. Per impostazione predefinita, un worker Dataproc n1-standard-8 eseguirà otto attività di importazione. Avere un numero sufficiente di worker garantisce che il job di importazione abbia una potenza di calcolo sufficiente per essere completato in un periodo di tempo ragionevole, ma non così tanta da sopraffare l'istanza Bigtable.
- Se non utilizzi l'istanza Bigtable anche per un altro carico di lavoro, moltiplica il numero di nodi dell'istanza Bigtable per 3 e poi 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 contemporaneamente all'importazione dei 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 in tutta l'istanza Bigtable è troppo elevato, potresti dover aggiungere nodi aggiuntivi. L'aggiunta di nodi migliora immediatamente l'utilizzo della CPU, ma possono essere necessari fino a 20 minuti dopo l'aggiunta dei nodi affinché il cluster raggiunga le prestazioni ottimali.

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

Convalida i dati importati in Bigtable

Poi, convalida la migrazione dei dati eseguendo un confronto di hash tra la tabella di origine e quella di destinazione per verificare l'integrità dei dati migrati. Innanzitutto, esegui il job hash-table per generare hash di intervalli di righe nella tabella di origine. Quindi, completa la convalida eseguendo il sync-table job per calcolare e abbinare gli hash di Bigtable con l'origine.

Per creare gli hash da utilizzare per la convalida, esegui il seguente comando per ogni tabella di cui esegui 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.

Esegui quanto segue nella shell di comando:

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

Se vuoi attivare la sincronizzazione tra l'origine e la destinazione per intervalli di hash divergenti, puoi aggiungere facoltativamente --dryrun=false al comando.

Al termine del job sync-table, i relativi contatori vengono visualizzati nella console Google Cloud in cui è stato eseguito. Se il job di importazione importa correttamente tutti i dati, il valore di HASHES_MATCHED è impostato e il valore di HASHES_NOT_MATCHED è 0.

Se HASHES_NOT_MATCHED mostra un valore, puoi eseguire di nuovo sync-table in modalità di debug per emettere gli intervalli divergenti e i dettagli a livello di cella, ad esempio 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'espressionejsonPayload.class="org.apache.hadoop.hbase.mapreduce.SyncTable" per esaminare le celle divergenti.

Puoi riprovare il job di importazione o utilizzare SyncTable per sincronizzare le tabelle di origine e di destinazione impostando dryrun=false. Prima di continuare, esamina HBase SyncTable e altre opzioni di configurazione.

Risultati di SyncTable in Cloud Logging

Aggiorna l'applicazione per inviare letture e scritture a Bigtable

Dopo aver convalidato i dati di ogni tabella del cluster, puoi configurare le tue applicazioni in modo che indirizzino tutto il loro traffico a Bigtable e poi ritirare il cluster HBase.

Al termine della migrazione, puoi eliminare gli snapshot.