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 dei motivi per cui potresti scegliere questo percorso di migrazione:

Puoi lasciare dove è attualmente eseguito il deployment dell'applicazione client, cambiando solo la configurazione della connessione.
I tuoi dati rimangono nell'ecosistema Google Cloud.
Se vuoi, puoi continuare a utilizzare l'API HBase. Il report Cloud Bigtable Client HBase per Java è un'estensione completamente supportata dello standard Apache libreria HBase per Java.
Vuoi usufruire dei vantaggi di utilizzare un servizio gestito per archiviare i 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 è cambiare, esaminare i concetti esposti in Progetta lo schema prima di eseguire la migrazione dei dati.

Preparazione e test

Prima di eseguire la migrazione dei dati, assicurati di aver compreso le differenze tra HBase e Bigtable. Ti consigliamo di dedicare un po' di tempo all'apprendimento di come configurare la connessione per collegare la tua applicazione a Bigtable. Inoltre, potresti vuoi eseguire test funzionali e di sistema prima della migrazione 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 descritti in dettaglio nelle prossime sezioni.

Interrompi l'invio di scritture in HBase.
Crea tabelle di destinazione in Bigtable.
Crea snapshot HBase e importali 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 e archiviare 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 delle l'indirizzo ZooKeeper Quorum e l'URI Namenode del cluster HBase, richiesti per gli script di migrazione.
Crea un cluster Dataproc versione 1.x sulla stessa rete del cluster HBase di origine. Utilizzi questo 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
Scarica lo strumento Traduzione 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, procedi nel seguente modo:
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 l'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'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 che l'istanza Bigtable si trova
- REGION: la regione che contiene Cluster Dataproc che eseguirà i job di importazione e convalida.
Bigtable:
- BIGTABLE_INSTANCE_ID: l'identificatore del Istanza Bigtable in cui stai importando i dati
Dataproc:
- DATAPROC_CLUSTER_ID: l'ID di Dataproc cluster 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 di ZooKeeper, che lo strumento si connetterà, nel formato host1.myownpersonaldomain.com
- MIGRATION_SOURCE_NAMENODE_URI: l'URI Namenode del 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 di il file JAR bigtable hbase mapreduce che hai scaricato da Maven. Il valore dovrebbe avere il seguente aspetto: 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 delle scritture a 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 in Bigtable per ogni tabella HBase di cui esegui la migrazione. Utilizza un account con autorizzazionebigtable.tables.create per l'istanza.

Questa guida utilizza lo strumento BigQuery Schema Translation, 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 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.

Facoltativamente, puoi anche sostituire TABLE_NAME con un un'espressione regolare, ad esempio ".*", che acquisisce tutte le tabelle che vuoi create ed esegui il comando una sola volta.

Crea 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 che stai eseguendo 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 alla un'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 sull'origine cluster e quindi 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 l'esempio che segue:
```
-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 il tuo caso d'uso per la 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à mappa che leggono una singola regione HBase (mappa predefinita 2 attività per regione). Vedi il seguente esempio:
```
-Dgoogle.bigtable.import.snapshot.splits.per.region=3
```

Imposta configurazioni MapReduce aggiuntive come proprietà. Consulta le nell'esempio seguente:

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

Durante l'importazione, tieni presente i seguenti suggerimenti:

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 delle mappe in parallelo. Per impostazione predefinita, un worker Dataproc n1-standard-8 eseguirà otto attività di importazione. La presenza di un numero sufficiente di worker garantisce che il job di importazione abbia risorse di calcolo sufficienti di completamento in un tempo ragionevole, ma non talmente tanto da sovraccarica 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, quindi dividi per 8 (con worker dataproc n1-standard-8). Utilizza le funzionalità di come risultato del numero di worker Dataproc.
- Se utilizzi l'istanza per un altro carico di lavoro contemporaneamente stai importando i tuoi dati HBase, riduci il valore di dei worker Dataproc o di aumentare il numero I nodi Bigtable per soddisfare le esigenze i tuoi requisiti.
Durante l'importazione, devi monitorare l'utilizzo della CPU dell'istanza Bigtable. Se l'utilizzo della CPU nell'istanza Bigtable è troppo alta, potresti dover aggiungere nodi aggiuntivi. L'aggiunta di nodi migliora immediatamente l'utilizzo della CPU, possono trascorrere fino a 20 minuti dopo l'aggiunta dei nodi affinché il cluster raggiunga delle prestazioni.

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

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 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 di HBase tabella da cui esegui 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.

Una volta completato il job sync-table, i contatori per il job vengono visualizzati in 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 ha un valore e il valore di HASHES_NOT_MATCHED è 0.

Se HASHES_NOT_MATCHED mostra un valore, puoi eseguire nuovamente sync-table nel 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 il esegui il job, utilizza Cloud Logging e cerca l'espressione jsonPayload.class="org.apache.hadoop.hbase.mapreduce.SyncTable" da rivedere 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 per ogni tabella nel cluster, puoi configurare le applicazioni per instradare il proprio traffico a Bigtable e quindi deprecare il cluster HBase.

Al termine della migrazione, puoi eliminare gli snapshot.