Migrar do Aerospike para o Bigtable

Last reviewed 2024-10-16 UTC

Neste tutorial, descrevemos como migrar dados do Aerospike para o Bigtable. Neste tutorial, explicamos as diferenças entre o Aerospike e o Cloud Bigtable e como transformar a carga de trabalho para ser executada no Cloud Bigtable. Ele é destinado a profissionais de banco de dados que estão procurando por um serviço de banco de dados no Google Cloud semelhante ao Aerospike. Neste tutorial, pressupomos que você tenha familiaridade com esquemas de banco de dados, tipos de dados, os fundamentos do NoSQL e sistemas de bancos de dados relacionais. O tutorial depende da execução de tarefas predefinidas para realizar um exemplo de migração. Depois de concluir o tutorial, é possível modificar o código e as etapas fornecidas para corresponder ao seu ambiente.

O Bigtable é um serviço de banco de dados NoSQL totalmente gerenciado em escala de petabytes para grandes cargas de trabalho analíticas e operacionais. Você pode usá-lo como um mecanismo de armazenamento para seu serviço de baixa latência e em escala de petabytes com maior disponibilidade e durabilidade. Analise dados no Bigtable usando serviços de análise de dados do Google Cloud, como o Dataproc e o BigQuery.

O Bigtable é ideal para serviços de tecnologia publicitária (ad tech), tecnologia financeira (fintech) e de Internet das Coisas (IoT) implementados com bancos de dados NoSQL, como o AeroSpike ou o Cassandra. Se você quiser um serviço gerenciado pelo NoSQL, use o Bigtable.

Arquitetura

O diagrama de arquitetura de referência a seguir mostra componentes comuns que podem ser usados para migrar dados do Aerospike para o Bigtable.

Componentes do processo de transferência de dados do Aerospike para o Bigtable.

No diagrama anterior, os dados migram de um ambiente local usando o Aerospike para o Bigtable no Google Cloud usando dois métodos diferentes. O primeiro método migra os dados usando o processamento em lote. Ele começa movendo os dados de backup do Aerospike para um bucket do Cloud Storage. Quando os dados de backup chegam ao Cloud Storage, o Cloud Run inicia um processo de extração, transformação e carregamento (ETL) em lote usando o Dataflow. O job do Dataflow converte os dados de backup em um formato compatível com o Bigtable e importa essas informações para a instância do Bigtable.

O segundo método migra os dados usando o processamento de stream. Nesse método, você se conecta ao Aerospike com uma fila de mensagens, como o Kafka, usando o Aerospike Connect, e transfere mensagens em tempo real para o Pub/Sub no Google Cloud. Quando a mensagem chega a um tópico do Pub/Sub, ela é processada pelo job de streaming do Dataflow em tempo real para converter e importar os dados para a instância do Bigtable.

Com o processamento em lote, você pode migrar com eficiência grandes blocos de dados. No entanto, isso geralmente exige tempo de inatividade da transição suficiente durante a migração e a atualização do serviço para novos bancos de dados. Se você quiser minimizar o tempo de inatividade da transição, considere usar o processamento de stream para migrar dados gradualmente após o primeiro processamento em lote para manter a consistência dos dados de backup até concluir a transição normal. Neste documento, é possível migrar do Aerospike usando o processamento em lote com aplicativos de exemplo, incluindo o processo de transição.

Comparação entre o Aerospike e o Bigtable

Antes de iniciar a migração de dados, é fundamental que você entenda as diferenças do modelo de dados entre o Aerospike e o Bigtable.

O modelo de dados do Bigtable é um mapa de chave-valor distribuído, multidimensional e classificado com linhas e grupos de colunas. Por outro lado, o modelo de dados do Aerospike é um banco de dados orientado por linhas, em que cada registro é identificado exclusivamente por uma chave. A diferença entre os modelos é como eles agrupam os atributos de uma entidade. O Bigtable agrupa atributos relacionados em um grupo de colunas, enquanto o Aerospike agrupa atributos em um conjunto. O Aerospike é compatível com mais tipos de dados em comparação com o Cloud Bigtable. Por exemplo, o Aerospike é compatível com números inteiros, strings, listas e mapas. Na maioria dos casos, o Bigtable trata todos os dados como strings de bytes brutos.

Um esquema no Aerospike é flexível, e os valores dinâmicos nos mesmos agrupamentos podem ter tipos diferentes. Aplicativos que usam o Aerospike ou o Bigtable têm flexibilidade e responsabilidade de administração de dados semelhantes. Os apps lidam com os tipos de dados e restrições de integridade, em vez de depender do mecanismo de banco de dados.

Migração do Bookshelf

O app Bookshelf é um app da Web em que os usuários podem armazenar informações sobre livros e conferir a lista de todos os livros armazenados no banco de dados no momento. O aplicativo usa um identificador de livro (ID) para pesquisar informações de livros. O aplicativo ou o banco de dados gera esses IDs automaticamente. Quando um usuário seleciona a imagem de um livro, o back-end do aplicativo carrega os detalhes sobre esse livro do banco de dados.

Neste tutorial, você migra dados do app Bookshelf usando o Aerospike para o Bigtable. Após a migração, é possível acessar os livros no Bigtable.

O diagrama a seguir mostra como os dados são migrados do Aerospike para o Bigtable:

Etapas da migração de dados.

No diagrama anterior, os dados são migrados da seguinte forma:

  1. Você faz backup de dados sobre livros do banco de dados atual do Aerospike e os transfere para um bucket do Cloud Storage.
  2. Quando você faz upload dos dados de backup para o bucket, ele automaticamente aciona o job as2bt do Dataflow por meio de Notificações de atualização do Cloud Storage usando a função do Cloud Run.
  3. Depois que a migração de dados é concluída pelo job as2bt do Dataflow, você altera o back-end do banco de dados do Aerospike para o Cloud Bigtable para que o app Bookshelf carregue dados de livros do cluster do Cloud Bigtable.

Objetivos

  • Implantar um ambiente de tutorial para a migração do Aerospike para o Bigtable.
  • Criar um exemplo de conjunto de dados de backup do aplicativo do Aerospike no Cloud Storage.
  • Usar o Dataflow para transferir o esquema de dados e migrá-lo para o Bigtable.
  • Alterar a configuração de app de exemplo para usar o Bigtable como back-end.
  • Verificar se o app Bookshelf está sendo executado corretamente com o Bigtable.

Custos

Neste documento, você usará os seguintes componentes faturáveis do Google Cloud:

Para gerar uma estimativa de custo baseada na projeção de uso deste tutorial, use a calculadora de preços. Novos usuários do Google Cloud podem estar qualificados para uma avaliação gratuita.

As cobranças do Bigtable são baseadas no número de horas do nó, na quantidade de dados armazenados e na quantidade de largura de banda de rede usada. Para estimar o custo do cluster do Bigtable e de outros recursos, use a calculadora de preços. A configuração da calculadora de preços de exemplo usa três nós do Bigtable em vez de um único nó. O custo total estimado no exemplo anterior é maior do que o custo total real deste tutorial.

Ao concluir as tarefas descritas neste documento, é possível evitar o faturamento contínuo excluindo os recursos criados. Saiba mais em Limpeza.

Antes de começar

  1. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

    Go to project selector

  2. Verifique se a cobrança está ativada para o seu projeto do Google Cloud.

  3. Enable the Cloud Resource Manager API.

    Enable the API

    O Terraform usa a API Resource Manager para ativar as APIs necessárias para este tutorial.

  4. In the Google Cloud console, activate Cloud Shell.

    Activate Cloud Shell

Como preparar o ambiente

Para preparar o ambiente da migração do Aerospike para o Bigtable, execute as seguintes ferramentas diretamente do Cloud Shell:

  • A Google Cloud CLI
  • A ferramenta de linha de comando do Bigtable, cbt
  • Terraform
  • Apache Maven

Essas ferramentas já estão disponíveis no Cloud Shell. Portanto, não é necessário instalá-las novamente.

Configurar seu projeto

  1. No Cloud Shell, inspecione o ID do projeto que o Cloud Shell configura automaticamente. O prompt de comando é atualizado para refletir seu projeto ativo no momento e é exibido neste formato: USERNAME@cloudshell:~ (PROJECT_ID)$

    Se o ID do projeto não estiver configurado corretamente, configure-o manualmente:

    gcloud config set project <var>PROJECT_ID</var>

    Substitua PROJECT_ID pelo ID do projeto do Google Cloud.

  2. Configure us-east1 como a região e us-east1-b como a zona:

    gcloud config set compute/region us-east1
gcloud config set compute/zone us-east1-b

    Para mais informações sobre regiões e zonas, consulte Geografia e regiões.

Implantar o ambiente do tutorial

  1. No Cloud Shell, clone o repositório de código:

     git clone https://github.com/fakeskimo/as2bt.git/

  2. No Cloud Shell, inicialize o diretório de trabalho do Terraform:

    cd "$HOME"/as2bt/bookshelf/terraform
terraform init

  3. Configure as variáveis de ambiente do Terraform para implantação:

    export TF_VAR_gce_vm_zone="$(gcloud config get-value compute/zone)"
export TF_VAR_gcs_bucket_location="$(gcloud config get-value compute/region)"

  4. Analise o plano de execução do Terraform:

    terraform plan

    A resposta será semelhante a:

    Terraform will perform the following actions:
# google_bigtable_instance.bookshelf_bigtable will be created
+ resource "google_bigtable_instance" "bookshelf_bigtable" {
  + display_name  = (known after apply)
  + id            = (known after apply)
  + instance_type = "DEVELOPMENT"
  + name          = "bookshelf-bigtable"
  + project       = (known after apply)
  + cluster {
      + cluster_id   = "bookshelf-bigtable-cluster"
      + storage_type = "SSD"
      + zone         = "us-east1-b"
    }
}

  5. Opcional: para visualizar quais recursos com dependências são implantados pelo Terraform, crie gráficos:

    terraform graph | dot -Tsvg > graph.svg

  6. Provisione o ambiente do tutorial:

    terraform apply

Como verificar o ambiente do tutorial e o aplicativo Bookshelf

Depois de provisionar o ambiente e antes de iniciar o job de migração de dados, é necessário verificar se todos os recursos foram implantados e configurados. Nesta seção, explicamos como verificar o processo de provisionamento e entender quais componentes estão configurados no ambiente.

Verificar o ambiente do tutorial

  1. No Cloud Shell, verifique a instância bookshelf-aerospike do Compute Engine:

    gcloud compute instances list

    A saída mostra que a instância foi implantada na zona us-east1-b:

    NAME                 ZONE        MACHINE_TYPE   PREEMPTIBLE  INTERNAL_IP  EXTERNAL_IP  STATUS
bookshelf-aerospike  us-east1-b  n1-standard-2               10.142.0.4   34.74.72.3   RUNNING

  2. Verifique a instância do Bigtable bookshelf-bigtable:

    gcloud bigtable instances list

    O resultado será assim:

    NAME                DISPLAY_NAME        STATE
bookshelf-bigtable  bookshelf-bigtable  READY

    Esta instância do Bigtable é usada como destino da migração etapas posteriores.

  3. Verifique se o bucket bookshelf do Cloud Storage está no job do pipeline do Dataflow:

    gcloud storage ls gs://bookshelf-* --buckets

    Como os nomes dos buckets do Cloud Storage precisam ser exclusivos globalmente, o nome do bucket é criado com um sufixo aleatório. A resposta será semelhante a:

    gs://bookshelf-616f60d65a3abe62/

Adicionar um livro ao app Bookshelf

  1. No Cloud Shell, consiga o endereço IP externo da instância bookshelf-aerospike:

    gcloud compute instances list --filter="name:bookshelf-aerospike" \
    --format="value(networkInterfaces[0].accessConfigs.natIP)"

    Anote o endereço IP porque ele será necessário na próxima etapa.

  2. Para abrir o aplicativo Bookshelf em um navegador da Web, acesse http://IP_ADDRESS:8080.

    Substitua IP_ADDRESS pelo endereço IP externo que você copiou na etapa anterior.

  3. Para criar um novo livro, clique em Adicionar livro.

  4. Na janela Adicionar livro, preencha os campos a seguir e clique em Salvar:

    • No campo Título, insira Aerospike-example.
    • No campo Autor, insira Aerospike-example.
    • No campo Data de publicação, insira a data de hoje.
    • No campo Descrição, use Aerospike-example.

    Esse livro é usado para verificar se o app Bookshelf está usando o Aerospike como armazenamento.

  5. No URL do aplicativo Bookshelf, anote o ID do livro. Por exemplo, se o URL for 34.74.80.160:8080/books/10000, o ID do livro será 10000.

    ID do livro no URL.

  6. No Cloud Shell, use o SSH para se conectar à instância bookshelf-aerospike:

    gcloud compute ssh bookshelf-aerospike

  7. Na sessão da instância bookshelf-aerospike, verifique se um novo livro foi criado com o ID do livro que você anotou anteriormente:

    aql -c 'select * from bookshelf.books where id = "BOOK_ID"'

    A resposta será semelhante a:

    +----------------------+----------------------+---------------+----------------------+----------+---------+
| title                | author               | publishedDate | description          | imageUrl | id      |
+----------------------+----------------------+---------------+----------------------+----------+---------+
| " Aerospike-example" | " Aerospike-example" | "2000-01-01"  | " Aerospike-example" | ""       | "10000" |
+----------------------+----------------------+---------------+----------------------+----------+---------+
1 row in set (0.001 secs)

    Se o ID do livro não estiver listado, repita as etapas para adicionar um novo livro.

Como transferir dados de backup do Aerospike para o Cloud Storage

  1. No Cloud Shell, na sessão da instância bookshelf-aerospike, crie um arquivo de backup do Aerospike:

    aql -c "select * from bookshelf.books" --timeout=-1 --outputmode=json \`
    | tail -n +2 | jq -c '.[0] | .[]' \
    | gcloud storage cp - $(gcloud storage ls gs://bookshelf-* --buckets)bookshelf-backup.json

    Esse comando processa os dados e cria um arquivo de backup por meio do seguinte processo:

    • Seleciona as informações do livro no Aerospike e exibe-as no estilo de formatação JSON.
    • Remove os dois primeiros títulos da saída e converte os dados no formato JSON delimitado por nova linha (ndjson) usando jq, um processador JSON de linha de comando.
    • Usa a CLI gcloud para fazer upload dos dados para o do bucket do Cloud Storage.

  2. Verifique se o arquivo de backup do Aerospike foi enviado e existe no bucket do Cloud Storage:

    gcloud storage ls gs://bookshelf-*/bookshelf-*\
    gs://bookshelf-616f60d65a3abe62/bookshelf-backup.json

  3. (Opcional) Verifique o conteúdo do arquivo de backup no bucket do Cloud Storage:

    gcloud storage cat -r 0-1024 gs://bookshelf-*/bookshelf-backup.json | head -n 2

    A resposta será semelhante a:

    {"title":"book_2507","author":"write_2507","publishedDate":"1970-01-01","imageUrl":"https://storage.googleapis.com/aerospike2bt-bookshelf/The_Home_Edit-2019-06-24-044906.jpg","description":"test_2507","createdBy":"write_2507","createdById":"2507_anonymous","id":"2507"}
{"title":"book_3867","author":"write_3867","publishedDate":"1970-01-01","imageUrl":"https://storage.googleapis.com/aerospike2bt-bookshelf/The_Home_Edit-2019-06-24-044906.jpg","description":"test_3867","createdBy":"write_3867","createdById":"3867_anonymous","id":"3867"}

  4. Saia da sessão SSH e retorne ao Cloud Shell:

    exit

Como migrar dados de backup para o Bigtable usando o Dataflow

Agora é possível migrar os dados de backup do Cloud Storage para uma instância do Bigtable. Nesta seção, explicamos como usar os pipelines do Dataflow para migrar dados compatíveis com um esquema do Bigtable.

Configurar o job de migração do Dataflow

  1. No Cloud Shell, acesse o diretório dataflow no repositório de código de exemplo:

    cd "$HOME"/as2bt/dataflow/

  2. Configure variáveis de ambiente para um job do Dataflow:

    export BOOKSHELF_BACKUP_FILE="$(gcloud storage ls
gs://bookshelf*/bookshelf-backup.json)"
export BOOKSHELF_DATAFLOW_ZONE="$(gcloud config get-value compute/zone)"

  3. Verifique se as variáveis de ambiente estão configuradas corretamente:

    env | grep BOOKSHELF

    Se as variáveis de ambiente estiverem configuradas corretamente, a saída será semelhante a:

    BOOKSHELF_BACKUP_FILE=gs://bookshelf-616f60d65a3abe62/bookshelf-backup.json
BOOKSHELF_DATAFLOW_ZONE=us-east1-b

Executar o job do Dataflow

  1. No Cloud Shell, migre os dados do Cloud Storage para a instância do Bigtable:

    ./run_oncloud_json.sh

  2. Para monitorar o job de migração de dados de backup, acesse a página Jobs no console do Google Cloud.

    Acessar "Jobs"

    Aguarde o job ser concluído com sucesso. Quando o job for concluído, a saída no Cloud Shell será semelhante a esta:

    Dataflow SDK version: 2.13.0
Submitted job: 2019-12-16_23_24_06-2124083021829446026
[INFO] ------------------------------------------------------------------------
[INFO] BUILD SUCCESS
[INFO] ------------------------------------------------------------------------
[INFO] Total time:  08:20 min
[INFO] Finished at: 2019-12-17T16:28:08+09:00
[INFO] ------------------------------------------------------------------------

Verificar os resultados do job de migração

  • No Cloud Shell, verifique se os dados de backup foram transferidos corretamente para o Bigtable:

    cbt -instance bookshelf-bigtable lookup books 00001

    O resultado será assim:

      ----------------------------------------
00001
  info:author                              @ 2019/12/17-16:26:04.434000
    "Aerospike-example"
  info:description                         @ 2019/12/17-16:26:04.434000
    "Aerospike-example"
  info:id                                  @ 2019/12/17-16:26:04.434000
    "00001"
  info:imageUrl                            @ 2019/12/17-16:26:04.434000
    ""
  info:publishedDate                       @ 2019/12/17-16:26:04.434000
    "2019-10-01"
  info:title                               @ 2019/12/17-16:26:04.434000
    "Aerospike-example"

Como alterar o banco de dados do Bookshelf de Aerospike para o Bigtable

Depois de migrar os dados do Aerospike para o Bigtable, é possível alterar a configuração do app Bookshelf para usar o Bigtable para armazenamento. Quando você define essa configuração, novos livros são salvos nas instâncias do Bigtable.

Alterar a configuração do aplicativo Bookshelf

  1. No Cloud Shell, use SSH para se conectar ao aplicativo bookshelf-aerospike:

    gcloud compute ssh bookshelf-aerospike

  2. Verifique se a configuração atual de DATA_BACKEND é aerospike:

    grep DATA_BACKEND /opt/app/bookshelf/config.py

    A saída é esta:

    DATA_BACKEND = 'aerospike'

  3. Altere a configuração DATA_BACKEND de aerospike para bigtable:

    sudo sed -i "s/DATA_BACKEND =.*/DATA_BACKEND = 'bigtable'/g" /opt/app/bookshelf/config.py

  4. Verifique se a configuração DATA_BACKEND foi alterada para bigtable:

    grep DATA_BACKEND /opt/app/bookshelf/config.py

    A saída é esta:

    DATA_BACKEND = 'bigtable'

  5. Reinicie o aplicativo Bookshelf que usa a nova configuração de back-end bigtable:

    sudo supervisorctl restart bookshelf

  6. Verifique se o aplicativo Bookshelf foi reiniciado e está em execução corretamente:

    sudo supervisorctl status bookshelf

    A resposta será semelhante a:

    bookshelf  RUNNING   pid 18318, uptime 0:01:00

Verificar se o app Bookshelf está usando o back-end do Bigtable

  1. Em um navegador, acesse http://IP_ADDRESS:8080.

  2. Adicione um novo livro chamado Bigtable-example.

  3. Para verificar se o livro Bigtable-example foi criado em uma instância do Cloud Bigtable do app Bookshelf, copie o ID do livro da barra de endereços do navegador.

  4. No Cloud Shell, procure os dados do livro Bigtable-example de uma instância do Bigtable:

    cbt -instance bookshelf-bigtable lookup books 7406950188

    A resposta será semelhante a:

    ----------------------------------------
7406950188
  info:author                              @ 2019/12/17-17:28:25.592000
    "Bigtable-example"
  info:description                         @ 2019/12/17-17:28:25.592000
    "Bigtable-example"
  info:id                                  @ 2019/12/17-17:28:25.592000
    "7406950188"
  info:image_url                           @ 2019/12/17-17:28:25.592000
    ""
  info:published_date                      @ 2019/12/17-17:28:25.592000
    "2019-10-01"
  info:title                               @ 2019/12/17-17:28:25.592000
    "Bigtable-example"

Você executou uma migração de dados do Aerospike para o Bigtable e alterou a configuração do Bookshelf para se conectar a um back-end do Bigtable.

Limpar

A maneira mais fácil de eliminar o faturamento é excluir o projeto do Google Cloud que você criou para o tutorial. A outra opção é excluir os recursos individuais.

Exclua o projeto

  1. In the Google Cloud console, go to the Manage resources page.

    Go to Manage resources

  2. In the project list, select the project that you want to delete, and then click Delete.
  3. In the dialog, type the project ID, and then click Shut down to delete the project.

A seguir