Questa pagina è stata tradotta dall'API Cloud Translation.

Esegui la migrazione da HBase ospitato su Google Cloud

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

Per indicazioni sulla migrazione offline da un ambiente Apache HBase esterno a Bigtable, consulta Eseguire la migrazione dei dati da HBase a Bigtable offline. Per la migrazione online, consulta Eseguire la replica da HBase a Bigtable.

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

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

Puoi lasciare l'applicazione client dove è attualmente implementata, 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 dati.

Considerazioni

Questa sezione suggerisce alcune cose da rivedere e su cui riflettere prima di iniziare la migrazione.

Progettazione dello schema di Bigtable

Nella maggior parte dei casi, puoi utilizzare lo stesso schema di progettazione in Bigtable come in HBase. Se vuoi modificare lo schema o se il tuo caso d'uso sta cambiando, rivedi i concetti illustrati 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. Devi dedicare un po' di tempo a imparare a configurare la connessione per connettere l'applicazione a Bigtable. Inoltre, potresti eseguire test funzionali e di sistema 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 HBase e importa i dati direttamente dal cluster HBase in Bigtable. Questi passaggi riguardano un singolo cluster HBase e sono descritti in dettaglio nelle sezioni successive.

Interrompi l'invio di scritture a HBase.
Crea tabelle di destinazione in Bigtable.
Acquisire snapshot HBase e importarli in Bigtable.
Convalida i dati importati.
Aggiorna l'applicazione per inviare letture e scritture a Bigtable.

immagine

Prima di iniziare

Installa Google Cloud CLI o utilizza Cloud Shell.
Crea un bucket Cloud Storage per archiviare i dati di output della convalida. Crea il bucket nella stessa posizione 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 a Namenode e Datanode del cluster HBase. Prendi nota dell'indirizzo del quorum di ZooKeeper e dell'URI Namenode del cluster HBase, che sono necessari per gli script di migrazione.
Crea un cluster Dataproc versione 1.x sulla stessa rete del cluster HBase di origine. Utilizzi 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 nella stessa regione del cluster Dataproc. Esempio: us-central1
Scarica lo strumento di traduzione dello schema:
```
wget BIGTABLE_HBASE_TOOLS_URL
```
Sostituisci BIGTABLE_HBASE_TOOLS_URL con l'URL dell'ultima versione di 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 file JAR:
1. Vai al repository.
2. Fai clic su Sfoglia per visualizzare i file del repository.
3. Fai clic sul numero dell'ultima versione.
4. Identifica il 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.
Scarica lo strumento MapReduce, che utilizzi per i job di importazione e convalida:
```
wget BIGTABLE_MAPREDUCE_URL
```
Sostituisci BIGTABLE_MAPREDUCE_URL con l'URL dell'ultima versione di 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 file JAR:
1. Vai al repository.
2. Fai clic sul numero di 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 della 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 importare 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 connetterà lo strumento, nel formato host1.myownpersonaldomain.com
- MIGRATION_SOURCE_NAMENODE_URI: l'URI del Namenode del tuo cluster HBase, nel formato hdfs://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 state impostate correttamente, esegui il comando printenv per visualizzare tutte le variabili di ambiente.

Interrompere l'invio di scritture a HBase

Prima di acquisire snapshot delle tabelle HBase, interrompi l'invio di 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 che stai migrando. Utilizza un account con l'autorizzazione bigtable.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 Bigtable corrisponda esattamente allo schema 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 che vuoi 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 di traduzione dello schema utilizza questo nome per la nuova tabella Bigtable.

Puoi anche sostituire facoltativamente TABLE_NAME con un'espressione regolare, ad esempio ".*", che acquisisce tutte le tabelle che vuoi creare, quindi esegui il comando una sola volta.

Acquisire snapshot delle tabelle HBase e importarli in Bigtable

Completa i seguenti passaggi 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 esegui la migrazione a Bigtable.
- HBASE_SNAPSHOT_NAME: il nome univoco del nuovo snapshot

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 che hai assegnato allo snapshot della tabella che stai importando
BIGTABLE_TABLE_NAME: il nome della tabella Bigtable in cui stai importando i dati

Dopo aver eseguito il comando, lo strumento ripristina lo snapshot HBase sul 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 sul client per le richieste di mutatore bufferizzato (valore predefinito 600000 ms). Vedi il seguente esempio:
```
-Dgoogle.bigtable.rpc.use.timeouts=true
-Dgoogle.bigtable.mutate.rpc.timeout.ms=600000
```
Valuta 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 della 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 mapping che leggono una singola regione HBase (per impostazione predefinita 2 attività di mapping per regione). Vedi il seguente esempio:
```
-Dgoogle.bigtable.import.snapshot.splits.per.region=3
```

Imposta configurazioni MapReduce aggiuntive come proprietà. Vedi il seguente esempio:

-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 avere un numero sufficiente di worker del cluster Dataproc per eseguire le attività di importazione della mappa in parallelo. Per impostazione predefinita, un worker Dataproc n1-standard-8 eseguirà otto attività di importazione. Un numero sufficiente di worker garantisce che il job di importazione disponga di potenza di calcolo sufficiente per essere completato in un periodo di tempo ragionevole, ma non così tanta da sovraccaricare l'istanza Bigtable.
- Se non utilizzi l'istanza Bigtable anche per un altro carico di lavoro, moltiplica il numero di nodi nell'istanza Bigtable per 3, 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 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 nell'istanza Bigtable è troppo elevato, potrebbe essere necessario aggiungere altri nodi. L'aggiunta di nodi migliora immediatamente l'utilizzo della CPU, ma possono essere necessari fino a 20 minuti dopo l'aggiunta dei nodi prima che il cluster raggiunga prestazioni ottimali.

Per ulteriori informazioni sul monitoraggio dell'istanza Bigtable, consulta Monitorare 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 verificare l'integrità dei dati migrati. Innanzitutto, esegui il job hash-table per generare gli hash degli 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.

Per creare hash da utilizzare per la convalida, esegui il seguente comando per ogni tabella che stai migrando:

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 questo comando 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 importare i dati
BIGTABLE_TABLE_NAME: il nome della tabella Bigtable in cui importi i dati

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 contatori del job vengono visualizzati nella console Google Cloud in cui è stato eseguito il job. Se il job di importazione importa correttamente tutti i dati, il valore di HASHES_MATCHED è un valore e quello di HASHES_NOT_MATCHED è 0.

Se HASHES_NOT_MATCHED mostra un valore, puoi eseguire di nuovo sync-table in modalità di debug per generare 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'espressione jsonPayload.class="org.apache.hadoop.hbase.mapreduce.SyncTable" per esaminare le celle divergenti.

Puoi riprovare a eseguire il job di importazione o utilizzare SyncTable per sincronizzare le tabelle di origine e di destinazione impostando dryrun=false. Prima di procedere, rivedi HBase SyncTable e le opzioni di configurazione aggiuntive.

Risultati di SyncTable in Cloud Logging

Aggiorna l'applicazione per inviare letture e scritture a Bigtable

Dopo aver convalidato i dati per ogni tabella del cluster, puoi configurare le applicazioni per indirizzare tutto il traffico a Bigtable e poi ritirare il cluster HBase.

Una volta completata la migrazione, puoi eliminare gli snapshot.

Passaggi successivi

Replica da HBase a Bigtable