Migrar do HBase no Google Cloud

Nesta página, descrevemos as considerações e os processos para migrar para o Bigtable de um cluster do Apache HBase hospedado em um serviço do Google Cloud, como o Dataproc ou o Compute Engine.

Para orientações sobre como migrar de um ambiente Apache HBase externo para o Bigtable, consulte Como migrar dados do HBase para o Bigtable. Para saber mais sobre a migração on-line, consulte Replicar do HBase do HBase para o Bigtable.

Por que migrar do HBase no Google Cloud para o Bigtable?

Os motivos para você escolher esse caminho de migração incluem os seguintes motivos:

  • É possível manter o aplicativo cliente no local em que ele está implantado, alterando a configuração de conexão.
  • Seus dados permanecem no ecossistema do Google Cloud.
  • É possível continuar usando a API HBase, se quiser. O cliente HBase do Cloud Bigtable para Java é uma extensão totalmente compatível da biblioteca HBase Apache para Java.
  • Você quer os benefícios de usar um serviço gerenciado para armazenar seus dados.

Considerações

Nesta seção, oferecemos algumas considerações e considerações antes de iniciar a migração.

Projeto de esquema do Bigtable

Na maioria dos casos, é possível usar o mesmo design de esquema usado no Bigtable. Se você quiser alterar seu esquema ou se seu caso de uso for alterado, revise os conceitos descritos em Como projetar seu esquema antes de migrar seus dados.

Preparação e testes

Antes de migrar os dados, entenda as diferenças entre o HBase e o Bigtable. Passe algum tempo aprendendo a configurar sua conexão para conectar seu aplicativo ao Bigtable. Além disso, é possível executar testes funcionais e do sistema antes da migração para validar o aplicativo ou serviço.

Etapas da migração

Para migrar os dados do HBase para o Bigtable, crie um snapshot do HBase e importe os dados diretamente do cluster do HBase para o Bigtable. Essas etapas são para um único cluster HBase e são descritas em detalhes nas próximas seções.

  1. Parar de enviar gravações para o HBase
  2. Crie tabelas de destino no Bigtable.
  3. Tirar snapshots do HBase e importá-los para o Bigtable.
  4. Validar os dados importados.
  5. Atualizar o aplicativo para enviar leituras e gravações ao Bigtable.

imagem

Antes de começar

  1. Instale a Google Cloud CLI ou use o Cloud Shell.

  2. Crie um bucket do Cloud Storage para armazenar os dados de saída de validação. Crie o bucket no mesmo local em que você planeja executar o job do Dataproc.

  3. Identifique o cluster do Hadoop de onde você está migrando. É preciso executar os jobs da migração em um cluster do Dataproc 1.x que tenha conectividade de rede com o Namenode e Datanodes do cluster do HBase. Anote o endereço Quorum do ZooKeeper e o URI do Namenode, que são obrigatórios para os scripts de migração.

  4. Crie um cluster do Dataproc versão 1.x na mesma rede que o cluster do HBase de origem. Use esse cluster para executar os jobs de importação e validação.

  5. Crie uma instância do Bigtable para armazenar suas novas tabelas. Pelo menos um cluster na instância do Bigtable também precisa estar na mesma região do cluster do Dataproc. Exemplo: us-central1

  6. Instale a ferramenta Schema Translation:

    wget BIGTABLE_HBASE_TOOLS_URL

    Substitua BIGTABLE_HBASE_TOOLS_URL pelo URL do JAR with dependencies mais recente disponível no repositório Maven da ferramenta. O nome do arquivo é 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 fazer o download manual do JAR, faça o seguinte:

    1. Acesse o repositório.
    2. Clique em Procurar para ver os arquivos do repositório.
    3. Clique no número da versão mais recente.
    4. Identifique o JAR with dependencies file (geralmente na parte superior).
    5. Clique com o botão direito do mouse e copie o URL ou clique para fazer o download do arquivo.

  7. Encontre a ferramenta MapReduce, que você usa para os jobs de importação e validação:

    wget BIGTABLE_MAPREDUCE_URL

    Substitua BIGTABLE_MAPREDUCE_URL pelo URL do shaded-byo JAR mais recente disponível no repositório Maven da ferramenta. O nome do arquivo é 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 fazer o download manual do JAR, faça o seguinte:

    1. Acesse o repositório.
    2. Clique no número da versão mais recente.
    3. Clique em Downloads.
    4. Passe o mouse sobre shaded-byo-hadoop.jar.
    5. Clique com o botão direito do mouse e copie o URL ou clique para fazer o download do arquivo.

  8. Configure as variáveis de ambiente a seguir:

    #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 pelos valores da sua migração.

    Google Cloud:

    • PROJECT_ID: o projeto do Google Cloud em que a instância Bigtable está.
    • REGION: a região que contém o cluster do Dataproc que executará os jobs de importação e validação.

    Bigtable:

    • BIGTABLE_INSTANCE_ID: o identificador da instância do Bigtable para a qual você está importando os dados;

    Dataproc:

    • DATAPROC_CLUSTER_ID: o ID do cluster do Dataproc que executará os jobs de importação e validação

    Cloud Storage:

    • BUCKET_NAME: o nome do bucket do Cloud Storage em que você está armazenando os snapshots

    HBase:

    • ZOOKEEPER_QUORUM: o host do ZooKeeper a que a ferramenta se conectará, no formato host1.myownpersonaldomain.com
    • MIGRATION_SOURCE_NAMENODE_URI: o URI do Namenode do cluster do HBase, no formato hdfs://host1.myownpersonaldomain.com:8020

    Arquivos JAR

    • TRANSLATE_JAR: o nome e o número da versão do arquivo JAR bigtable hbase tools que você baixou do Maven. O valor será 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 arquivo JAR bigtable hbase mapreduce que você baixou do Maven. O valor será semelhante a bigtable-hbase-1.x-mapreduce-2.6.0-shaded-byo-hadoop.jar.

  9. (Opcional) Para confirmar se as variáveis foram definidas corretamente, execute o comando printenv para visualizar todas as variáveis de ambiente.

Parar de enviar gravações para o HBase

Antes de tirar snapshots das tabelas do HBase, pare de enviar gravações para o cluster do HBase.

Criar tabelas de destino no Bigtable

A próxima etapa é criar uma tabela de destino na instância do Bigtable para cada tabela do HBase que você estiver migrando. Use uma conta que tenha permissão bigtable.tables.create para a instância.

Neste guia, usamos a ferramenta de tradução de esquema do Bigtable, que cria automaticamente a tabela para você. No entanto, se você não quiser que o esquema do Bigtable corresponda exatamente ao esquema do HBase, crie uma tabela usando a CLI cbt ou o Console do Google Cloud.

A ferramenta Bigtable Schema Translation captura o esquema da tabela do HBase, incluindo o nome da tabela, os grupos de colunas, as políticas de coleta de lixo e as divisões. Em seguida, ele cria uma tabela semelhante no Bigtable.

Para cada tabela que você quer importar, execute o código a seguir 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 você está importando. A ferramenta Schema Translation usa esse nome para a nova tabela do Bigtable.

Outra opção é substituir TABLE_NAME por uma expressão regular, como ".*", que captura todas as tabelas que você quer criar e executa o comando apenas uma vez.

Tirar snapshots de tabelas do HBase e importá-los para o Bigtable

Preencha as seguintes informações para cada tabela que você planeja migrar para o Bigtable.

  1. Execute este comando:

    echo "snapshot 'HBASE_TABLE_NAME', 'HBASE_SNAPSHOT_NAME'" | hbase shell -n

    Substitua:

    • HBASE_TABLE_NAME: o nome da tabela do HBase que você está migrando para o Bigtable.
    • HBASE_SNAPSHOT_NAME: o nome do novo snapshot

  2. Importe o snapshot 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:

    • HBASE_SNAPSHOT_NAME: o nome que você atribuiu ao snapshot da tabela que está sendo importada.
    • BIGTABLE_TABLE_NAME: o nome da tabela do Bigtable para onde você está importando

    Depois de executar o comando, a ferramenta restaura o snapshot do HBase no cluster de origem e, em seguida, o importa. Pode levar vários minutos para que o processo de restauração do snapshot seja concluído, dependendo do tamanho do snapshot.

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

  • Definir tempos limite baseados no cliente para as solicitações de mutações em buffer (600.000 ms padrão). Veja o exemplo a seguir:

    -Dgoogle.bigtable.rpc.use.timeouts=true
-Dgoogle.bigtable.mutate.rpc.timeout.ms=600000

  • Considere a limitação com base na latência, que pode reduzir o impacto que o job de importação em lote pode ter em outras cargas de trabalho. A limitação precisa ser testada para seu caso de uso de migração. Veja o exemplo a seguir:

    -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 (duas tarefas de mapa padrão por região). Veja o exemplo a seguir:

    -Dgoogle.bigtable.import.snapshot.splits.per.region=3

  • Defina outras configurações do MapReduce como propriedades. Veja o exemplo a seguir:

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

Lembre-se destas dicas:

  • Para melhorar o desempenho do carregamento de dados, verifique se há workers de cluster do Dataproc suficientes para executar tarefas de importação de mapas em paralelo. Por padrão, um worker do Dataproc n1-standard-8 executará oito tarefas de importação. Ter workers suficientes garante que o job de importação tenha poder de computação suficiente para ser concluído em um tempo razoável, mas não tanto que sobrecarregue a instância do Bigtable.
    • Se você também não estiver usando 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 divida por 8 (com worker n1-standard-8 dataproc). Use o resultado como o número de workers do Dataproc.
    • Se você estiver usando a instância para outra carga de trabalho ao mesmo tempo que está importando os dados do HBase, reduza o valor de workers do Dataproc ou aumente o número de nós do Bigtable para atender aos requisitos das cargas de trabalho.
  • Durante a importação, monitore o uso da CPU da instância Bigtable. Se a utilização da CPU na instância do Bigtable for muito alta, talvez seja necessário adicionar nós. A adição de nós melhora a utilização da CPU imediatamente, mas pode levar até 20 minutos após a adição deles para que o cluster alcance o desempenho ideal.

Para mais informações sobre o monitoramento da instância do Bigtable, consulte Como monitorar uma instância do Bigtable.

Validar os dados importados no Bigtable

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

  1. Para criar hashes para validação, execute o seguinte comando para cada tabela que você está 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/

    Substitua HBASE_TABLE_NAME pelo nome da tabela HBase para a qual você criou o snapshot.

  2. Execute estes comandos no shell de 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

    Substitua:

    • HBASE_TABLE_NAME: o nome da tabela HBase que você está importando
    • BIGTABLE_TABLE_NAME: o nome da tabela do Bigtable em que você está importando.

Como alternativa, adicione --dryrun=false ao comando se você quiser ativar a sincronização entre a origem e o destino para separar intervalos de hash.

Quando o job sync-table for concluído, os contadores para o job serão exibidos no console do Google Cloud em que o job foi executado. Se o job de importação importar todos os dados com êxito, o valor de HASHES_MATCHED terá um valor, e o valor de HASHES_NOT_MATCHED será 0.

Se HASHES_NOT_MATCHED mostrar um valor, é possível executar novamente sync-table no modo de depuração para emitir os intervalos divergentes e detalhes no 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 do job, use o Cloud Logging e pesquise a expressão jsonPayload.class="org.apache.hadoop.hbase.mapreduce.SyncTable" para analisar as células divergentes.

Tente o job de importação novamente ou use SyncTable para sincronizar as tabelas de origem e de destino definindo dryrun=false. Verifique o HBase SyncTable e outras opções de configuração antes de continuar.

Resultados da SyncTable no Cloud Logging

Atualizar o aplicativo para enviar leituras e gravações para o Bigtable

Depois de validar os dados de cada tabela no cluster, é possível configurar aplicativos para rotear todo o tráfego para o Bigtable e suspender o uso do cluster do HBase.

Quando a migração estiver concluída, será possível excluir os snapshots.

A seguir