Esta página foi traduzida pela API Cloud Translation.

Migre do HBase alojado no Google Cloud

Esta página descreve as considerações e os processos para migrar para o Bigtable a partir de um cluster do Apache HBase alojado num Google Cloud serviço, como o Dataproc ou o Compute Engine.

Para orientações sobre a migração offline de um ambiente Apache HBase externo para o Bigtable, consulte o artigo Migrar dados do HBase para o Bigtable offline. Para a migração online, consulte o artigo Replique do HBase para o Bigtable.

Porquê migrar do HBase no Google Cloud para o Bigtable

Seguem-se alguns dos motivos pelos quais pode optar por este caminho de migração:

Pode deixar a aplicação cliente onde está atualmente implementada, alterando apenas a configuração da ligação.
Os seus dados permanecem no Google Cloud ecossistema.
Se quiser, pode continuar a usar a API HBase. O cliente HBase do Cloud Bigtable para Java é uma extensão totalmente suportada da biblioteca HBase do Apache para Java.
Quer as vantagens de usar um serviço gerido para armazenar os seus dados.

Considerações

Esta secção sugere alguns aspetos a rever e a ter em conta antes de iniciar a migração.

Design do esquema do Bigtable

Na maioria dos casos, pode usar o mesmo esquema de design no Bigtable que usa no HBase. Se quiser alterar o seu esquema ou se o seu exemplo de utilização estiver a mudar, reveja os conceitos apresentados em Conceber o seu esquema antes de migrar os seus dados.

Preparação e testes

Antes de migrar os seus dados, certifique-se de que compreende as diferenças entre o HBase e o Bigtable. Deve dedicar algum tempo a saber como configurar a sua ligação para ligar a sua aplicação ao Bigtable. Além disso, recomendamos que faça testes funcionais e de sistema antes da migração para validar a aplicação ou o serviço.

Passos de migração

Para migrar os seus dados do HBase para o Bigtable, tira uma captura de ecrã do HBase e importa os dados diretamente do cluster do HBase para o Bigtable. Estes passos destinam-se a um único cluster do HBase e são descritos detalhadamente nas próximas secções.

Pare de enviar gravações para o HBase.
Crie tabelas de destino no Bigtable.
Tire instantâneos do HBase e importe-os para o Bigtable.
Valide os dados importados.
Atualize a aplicação para enviar leituras e escritas para o Bigtable.

imagem

Antes de começar

Instale a CLI do Google Cloud ou use o Cloud Shell.
Crie um contentor do Cloud Storage para armazenar os dados de saída da validação. Crie o contentor na mesma localização em que planeia executar a tarefa do Dataproc.
Identifique o cluster Hadoop a partir do qual está a migrar. Tem de executar as tarefas para a migração num cluster do Dataproc 1.x que tenha conetividade de rede com o Namenode e os Datanodes do cluster do HBase. Tome nota do endereço do quórum do ZooKeeper e do URI do nó de nomes do cluster do HBase, que são necessários para os scripts de migração.
Crie um cluster do Dataproc versão 1.x na mesma rede que o cluster HBase de origem. Use este cluster para executar as tarefas de importação e validação.
Crie uma instância do Bigtable para armazenar as novas tabelas. Pelo menos, um cluster na instância do Bigtable também tem de estar na mesma região que o cluster do Dataproc. Exemplo: us-central1
Obtenha a ferramenta de tradução de esquemas:
```
wget BIGTABLE_HBASE_TOOLS_URL
```
Substitua BIGTABLE_HBASE_TOOLS_URL pelo URL da JAR with dependencies mais recente disponível no repositório Maven da ferramenta. O nome do ficheiro é semelhante 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.

Para encontrar o URL ou transferir manualmente o JAR, faça o seguinte:
1. Aceda ao repositório.
2. Clique em Procurar para ver os ficheiros do repositório.
3. Clique no número da versão mais recente.
4. Identifique o JAR with dependencies file (normalmente, na parte superior).
5. Clique com o botão direito do rato e copie o URL ou clique para transferir o ficheiro.
Obtenha a ferramenta MapReduce, que usa para as tarefas de importação e validação:
```
wget BIGTABLE_MAPREDUCE_URL
```
Substitua BIGTABLE_MAPREDUCE_URL pelo URL da shaded-byo JAR mais recente disponível no repositório Maven da ferramenta. O nome do ficheiro é semelhante 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.

Para encontrar o URL ou transferir manualmente o JAR, faça o seguinte:
1. Aceda ao repositório.
2. Clique no número da versão mais recente.
3. Clique em Transferências.
4. Passe o cursor do rato sobre shaded-byo-hadoop.jar.
5. Clique com o botão direito do rato e copie o URL ou clique para transferir o ficheiro.
Defina as seguintes variáveis de 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
```
Substitua os marcadores de posição pelos valores da sua migração.

Google Cloud:
- PROJECT_ID: o projeto Google Cloud em que se encontra a sua instância do Bigtable
- REGION: a região que contém o cluster do Dataproc que vai executar as tarefas de importação e validação.
Bigtable:
- BIGTABLE_INSTANCE_ID: o identificador da instância do Bigtable para a qual está a importar os dados
Dataproc:
- DATAPROC_CLUSTER_ID: o ID do cluster do Dataproc que vai executar as tarefas de importação e validação
Cloud Storage:
- BUCKET_NAME: o nome do contentor do Cloud Storage onde está a armazenar as suas capturas de ecrã
HBase:
- ZOOKEEPER_QUORUM: o anfitrião do ZooKeeper ao qual a ferramenta se vai ligar, no formato host1.myownpersonaldomain.com
- MIGRATION_SOURCE_NAMENODE_URI: o URI do Namenode do cluster do HBase, no formato hdfs://host1.myownpersonaldomain.com:8020
Ficheiros JAR
- TRANSLATE_JAR: o nome e o número da versão do ficheiro JAR bigtable hbase tools que transferiu do Maven. O valor deve ter um aspeto semelhante a bigtable-hbase-1.x-tools-2.6.0-jar-with-dependencies.jar.
- MAPREDUCE_JAR: o nome e o número da versão do ficheiro JAR bigtable hbase mapreduce que transferiu do Maven. O valor deve ter um aspeto semelhante a bigtable-hbase-1.x-mapreduce-2.6.0-shaded-byo-hadoop.jar.
(Opcional) Para confirmar que as variáveis foram definidas corretamente, execute o comando printenv para ver todas as variáveis de ambiente.

Pare de enviar gravações para o HBase

Antes de tirar instantâneos das suas tabelas HBase, pare de enviar gravações para o seu cluster HBase.

Crie tabelas de destino no Bigtable

O passo seguinte é criar uma tabela de destino na instância do Bigtable para cada tabela do HBase que está a migrar. Use uma conta com autorização bigtable.tables.create para a instância.

Este guia usa a ferramenta de tradução do esquema do Bigtable, que cria automaticamente a tabela para si. No entanto, se não quiser que o esquema do Bigtable corresponda exatamente ao esquema do HBase, pode criar uma tabela através da CLI cbt ou da consola Google Cloud .

A ferramenta de tradução de esquemas do Bigtable captura o esquema da tabela do HBase, incluindo o nome da tabela, as famílias de colunas, as políticas de recolha de lixo e as divisões. Em seguida, cria uma tabela semelhante no Bigtable.

Para cada tabela que quer importar, execute o seguinte comando para copiar o esquema do HBase para o 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

Substitua TABLE_NAME pelo nome da tabela HBase que está a importar. A ferramenta de tradução de esquemas usa este nome para a nova tabela do Bigtable.

Também pode substituir opcionalmente TABLE_NAME por uma expressão regular, como ".*", que capture todas as tabelas que quer criar e, em seguida, executar o comando apenas uma vez.

Tire instantâneos de tabelas do HBase e importe-os para o Bigtable

Conclua os passos seguintes para cada tabela que planeia migrar para o Bigtable.

Execute o seguinte comando:
```
echo "snapshot 'HBASE_TABLE_NAME', 'HBASE_SNAPSHOT_NAME'" | hbase shell -n
```
Substitua o seguinte:
- HBASE_TABLE_NAME: o nome da tabela do HBase para a qual está a migrar para o Bigtable.
- HBASE_SNAPSHOT_NAME: o nome exclusivo do novo instantâneo
Importe a captura de ecrã executando o seguinte 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
```
Substitua o seguinte:
- HBASE_SNAPSHOT_NAME: o nome que atribuiu à imagem da tabela que está a importar
- BIGTABLE_TABLE_NAME: o nome da tabela do Bigtable para a qual está a importar
Depois de executar o comando, a ferramenta restaura a cópia instantânea do HBase no cluster de origem e, em seguida, importa-a. O processo de restauro da captura de ecrã pode demorar vários minutos a ser concluído, consoante o tamanho da captura de ecrã.

As seguintes opções adicionais estão disponíveis quando importa os dados:

Defina os limites de tempo baseados no cliente para os pedidos do mutador em buffer (predefinição: 600 000 ms). Veja o exemplo seguinte:
```
-Dgoogle.bigtable.rpc.use.timeouts=true
-Dgoogle.bigtable.mutate.rpc.timeout.ms=600000
```
Considere a limitação baseada na latência, que pode reduzir o impacto que a tarefa em lote de importação pode ter noutras cargas de trabalho. A limitação deve ser testada para o seu exemplo de utilização de migração. Veja o exemplo seguinte:
```
-Dgoogle.bigtable.buffered.mutator.throttling.enable=true
-Dgoogle.bigtable.buffered.mutator.throttling.threshold.ms=100
```
Modifique o número de tarefas de mapa que leem uma única região do HBase (predefinição de 2 tarefas de mapa por região). Veja o exemplo seguinte:
```
-Dgoogle.bigtable.import.snapshot.splits.per.region=3
```

Defina configurações adicionais do MapReduce como propriedades. Veja o exemplo seguinte:

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

Tenha em atenção as seguintes sugestões quando importar:

Para melhorar o desempenho do carregamento de dados, certifique-se de que tem trabalhadores do cluster do Dataproc suficientes para executar tarefas de importação de mapas em paralelo. Por predefinição, um worker do Dataproc n1-standard-8 executa oito tarefas de importação. Ter trabalhadores suficientes garante que a tarefa de importação tem poder de computação suficiente para ser concluída num período razoável, mas não tanto poder que sobrecarregue a instância do Bigtable.
- Se também não estiver a usar a instância do Bigtable para outra carga de trabalho, multiplique o número de nós na instância do Bigtable por 3 e, em seguida, divida por 8 (com o trabalhador do Dataproc n1-standard-8). Use o resultado como o número de trabalhadores do Dataproc.
- Se estiver a usar a instância para outra carga de trabalho ao mesmo tempo que está a importar os seus dados do HBase, reduza o valor dos trabalhadores do Dataproc ou aumente o número de nós do Bigtable para cumprir os requisitos das cargas de trabalho.
Durante a importação, deve monitorizar a utilização da CPU da instância do Bigtable. Se a utilização da CPU na instância do Bigtable for demasiado elevada, pode ter de adicionar nós adicionais. A adição de nós melhora imediatamente a utilização da CPU, mas pode demorar até 20 minutos após a adição dos nós para que o cluster alcance um desempenho ideal.

Para mais informações sobre a monitorização da instância do Bigtable, consulte o artigo Monitorizar uma instância do Bigtable.

Valide os dados importados no Bigtable

Em seguida, valide a migração de dados fazendo uma comparação de hash entre a tabela de origem e a de destino para ganhar confiança na integridade dos dados migrados. Primeiro, execute a tarefa hash-table para gerar hashes de intervalos de linhas na tabela de origem. Em seguida, conclua a validação executando a tarefa para calcular e fazer corresponder hashes do Bigtable com a origem.sync-table

Para criar hashes a usar para validação, execute o seguinte comando para cada tabela que está a migrar:

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/

Substitua HBASE_TABLE_NAME pelo nome da tabela HBase para a qual criou a captura de ecrã.

Execute o seguinte na shell de comandos:

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

Substitua o seguinte:

HBASE_TABLE_NAME: o nome da tabela HBase da qual está a importar
BIGTABLE_TABLE_NAME: o nome da tabela do Bigtable para a qual está a importar

Opcionalmente, pode adicionar --dryrun=false ao comando se quiser ativar a sincronização entre a origem e o destino para intervalos de hash divergentes.

Quando a tarefa sync-table estiver concluída, os contadores da tarefa são apresentados na consola Google Cloud onde a tarefa foi executada. Se a tarefa de importação importar com êxito todos os dados, o valor de HASHES_MATCHED tem um valor e o valor de HASHES_NOT_MATCHED é 0.

Se HASHES_NOT_MATCHED mostrar um valor, pode executar novamente sync-table no modo de depuração para emitir os intervalos divergentes e os detalhes ao nível da célula, como Source missing cell, Target missing cell ou Different values. Para ativar o modo de depuração, configure --properties mapreduce.map.log.level=DEBUG. Após a execução da tarefa, use o Cloud Logging e pesquise a expressão jsonPayload.class="org.apache.hadoop.hbase.mapreduce.SyncTable" para rever as células divergentes.

Pode tentar novamente a tarefa de importação ou usar o SyncTable para sincronizar as tabelas de origem e de destino definindo dryrun=false. Reveja HBase SyncTable e as opções de configuração adicionais antes de continuar.

Resultados da SyncTable no Cloud Logging

Atualize a aplicação para enviar leituras e escritas para o Bigtable

Depois de validar os dados de cada tabela no cluster, pode configurar as suas aplicações para encaminhar todo o respetivo tráfego para o Bigtable e, em seguida, descontinuar o cluster do HBase.

Quando a migração estiver concluída, pode eliminar as capturas instantâneas.

O que se segue?

Replique do HBase para o Bigtable