Migre do Aerospike para o Bigtable

Last reviewed 2024-10-16 UTC

---

Este tutorial descreve como migrar dados do Aerospike para o Bigtable. O tutorial explica as diferenças entre o Aerospike e o Bigtable, e como transformar a sua carga de trabalho para ser executada no Bigtable. Destina-se a profissionais de bases de dados que procuram um serviço de base de dados semelhante ao Aerospike. Google Cloud Este tutorial pressupõe que tem conhecimentos sobre esquemas de bases de dados, tipos de dados, os fundamentos do NoSQL e sistemas de bases de dados relacionais. Este tutorial baseia-se na execução de tarefas predefinidas para realizar uma migração de exemplo. Depois de concluir o tutorial, pode modificar o código e os passos fornecidos para corresponderem ao seu ambiente.

O Bigtable é um serviço de base de dados NoSQL totalmente gerido à escala de petabytes para grandes cargas de trabalho analíticas e operacionais. Pode usá-lo como um motor de armazenamento para o seu serviço de baixa latência e escala de petabytes com maior disponibilidade e durabilidade. Pode analisar dados no Bigtable através de Google Cloud serviços de estatísticas de dados como o Dataproc e o BigQuery.

O Bigtable é ideal para tecnologia de publicidade (ad tech), tecnologia financeira (fintech) e serviços da Internet das Coisas (IdC) que são implementados com bases de dados NoSQL, como o AeroSpike ou o Cassandra. Se procura um serviço gerido de NoSQL, use o Bigtable.

Arquitetura

O diagrama de arquitetura de referência seguinte mostra os componentes comuns que pode usar para migrar dados do Aerospike para o Bigtable.

No diagrama anterior, os dados são migrados de um ambiente no local com o Aerospike para o Bigtable no Google Cloud através de dois métodos diferentes. O primeiro método migra os dados através do processamento em lote. Começa por mover os dados da cópia de segurança do Aerospike para um contentor do Cloud Storage. Quando os dados de cópia de segurança chegam ao Cloud Storage, acionam funções do Cloud Run para iniciar um processo de extração, transformação e carregamento (ETL) em lote através do Dataflow. A tarefa do Dataflow converte os dados de cópia de segurança num formato compatível com o Bigtable e importa os dados para a instância do Bigtable.

O segundo método migra os dados através do processamento de streaming. Neste método, estabelece ligação ao Aerospike através de 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, é processada pelo trabalho de streaming do Dataflow em tempo real para converter e importar os dados para a instância do Bigtable.

Com o processamento em lote, pode migrar grandes blocos de dados de forma eficiente. No entanto, requer frequentemente um tempo de inatividade de transição suficiente durante a migração e a atualização do serviço para novas bases de dados. Se quiser minimizar o tempo de inatividade da transição, pode considerar usar o processamento de streaming para migrar os dados gradualmente após o primeiro processamento em lote, de modo a manter a consistência dos dados de cópia de segurança até à conclusão da transição gradual. Neste documento, pode migrar do Aerospike através do processamento em lote com aplicações de exemplo, incluindo o processo de transição.

Comparar o Aerospike e o Bigtable

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

O modelo de dados do Bigtable é um mapa de chaves-valores distribuído, multidimensional e ordenado com linhas e famílias de colunas. Por outro lado, o modelo de dados do Aerospike é uma base de dados orientada por linhas, em que cada registo é identificado exclusivamente por uma chave. A diferença entre os modelos reside na forma como agrupam os atributos de uma entidade. O Bigtable agrupa os atributos relacionados numa família de colunas, enquanto o Aerospike agrupa os atributos num conjunto. O Aerospike suporta mais tipos de dados em comparação com o Bigtable. Por exemplo, o Aerospike suporta números inteiros, strings, listas e mapas. O Bigtable trata todos os dados como strings de bytes não processados para a maioria dos fins.

Um esquema no Aerospike é flexível e os valores dinâmicos nos mesmos contentores podem ter tipos diferentes. As apps que usam o Aerospike ou o Bigtable têm uma flexibilidade e uma responsabilidade de administração de dados semelhantes: as apps processam os tipos de dados e as restrições de integridade, em vez de dependerem do motor da base de dados.

Migração da estante

A app Bookshelf é uma app Web onde os utilizadores podem armazenar informações sobre livros e ver a lista de todos os livros atualmente armazenados na base de dados. A app usa um identificador de livro (ID) para pesquisar informações sobre o livro. A app ou a base de dados gera automaticamente estes IDs. Quando um utilizador seleciona a imagem de um livro, o back-end da app carrega os detalhes sobre esse livro a partir da base de dados.

Neste tutorial, vai migrar dados da app de estante de livros que usa o Aerospike para o Bigtable. Após a migração, pode aceder aos livros a partir do Bigtable.

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

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

1. Faz uma cópia de segurança dos dados sobre livros da base de dados Aerospike atual e transfere os dados para um contentor do Cloud Storage.
2. Quando carrega os dados da cópia de segurança para o contentor, aciona automaticamente a tarefa do Dataflow através de notificações de atualização do Cloud Storage com a função do Cloud Run.as2bt
3. Depois de a migração de dados ser concluída pela tarefa do Dataflow, altera o back-end da base de dados de Aerospike para Bigtable, para que a app Bookshelf carregue os dados dos livros a partir do cluster do Bigtable.as2bt

Objetivos

• Implemente um ambiente de tutorial para a migração do Aerospike para o Bigtable.
• Crie um conjunto de dados de cópia de segurança de apps de exemplo a partir do Aerospike no Cloud Storage.
• Use o Dataflow para transferir o esquema de dados e migrá-lo para o Bigtable.
• Altere a configuração da app de exemplo para usar o Bigtable como um back-end.
• Confirme se a app de estante está a ser executada corretamente com o Bigtable.

Custos

Neste documento, usa os seguintes componentes faturáveis do Google Cloud:

• Compute Engine
• Bigtable
• Pub/Sub
• Cloud Storage
• Dataflow

Para gerar uma estimativa de custos com base na sua utilização projetada, use a calculadora de preços.

Os novos Google Cloud utilizadores podem ser elegíveis para uma avaliação gratuita.

As cobranças do Bigtable baseiam-se no número de horas de nós, na quantidade de dados armazenados e na quantidade de largura de banda da rede que usa. Para estimar o custo do cluster do Bigtable e de outros recursos, pode usar 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 é superior ao custo total real deste tutorial.

Quando terminar as tarefas descritas neste documento, pode evitar a faturação contínua eliminando os recursos que criou. Para mais informações, consulte o artigo Limpe.

Antes de começar

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

   Roles required to select or create a project

   • Select a project: Selecting a project doesn't require a specific IAM role—you can select any project that you've been granted a role on.
   • Create a project: To create a project, you need the Project Creator (roles/resourcemanager.projectCreator), which contains the resourcemanager.projects.create permission. Learn how to grant roles.
   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

2. Verify that billing is enabled for your Google Cloud project.

3. Enable the Cloud Resource Manager API.

   Roles required to enable APIs

   To enable APIs, you need the Service Usage Admin IAM role (roles/serviceusage.serviceUsageAdmin), which contains the serviceusage.services.enable permission. Learn how to grant roles.

   Enable the API

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

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

   Activate Cloud Shell

   Preparar o seu ambiente

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

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

   Estas ferramentas já estão disponíveis no Cloud Shell, pelo que não precisa de as instalar novamente.

   Configure o seu projeto

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

      Se o ID do projeto não estiver configurado corretamente, pode configurá-lo manualmente:

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

      Substitua PROJECT_ID pelo ID do seu Google Cloud projeto.

   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 o artigo Geografia e regiões.

   Implemente 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 a implementaçã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. Reveja o plano de execução do Terraform:

      terraform plan
      

      O resultado é semelhante ao seguinte:

      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 os recursos com dependências implementados pelo Terraform, desenhe gráficos:

      terraform graph | dot -Tsvg > graph.svg
      

   6. Aprovisione o ambiente do tutorial:

      terraform apply
      

   Validar o ambiente do tutorial e a app de livros

   Depois de aprovisionar o ambiente e antes de iniciar a tarefa de migração de dados, tem de verificar se todos os recursos foram implementados e configurados. Esta secção explica como validar o processo de aprovisionamento e ajuda a compreender que componentes estão configurados no ambiente.

   Valide o ambiente do tutorial

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

      gcloud compute instances list
      

      O resultado mostra que a instância está implementada 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. Valide a instância do bookshelf-bigtable Bigtable:

      gcloud bigtable instances list
      

      O resultado é semelhante ao seguinte:

      NAME                DISPLAY_NAME        STATE
      bookshelf-bigtable  bookshelf-bigtable  READY
      

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

   3. Verifique se o contentor do bookshelf Cloud Storage está no trabalho do pipeline do Dataflow:

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

      Uma vez que os nomes dos contentores do Cloud Storage têm de ser exclusivos a nível global, o nome do contentor é criado com um sufixo aleatório. O resultado é semelhante ao seguinte:

      gs://bookshelf-616f60d65a3abe62/
      

   Adicione um livro à app Bookshelf

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

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

      Tome nota do endereço IP, pois é necessário no passo seguinte.

   2. Para abrir a app Bookshelf, num navegador de Internet, aceda a http://IP_ADDRESS:8080.

      Substitua IP_ADDRESS pelo endereço IP externo que copiou do passo anterior.

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

   4. Na janela Adicionar livro, preencha os seguintes campos e, de seguida, clique em Guardar:

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

      Este livro é usado para validar se a app Bookshelf está a usar o Aerospike como armazenamento de livros.

   5. No URL da app Bookshelf, tome nota do ID do livro. Por exemplo, se o URL for 34.74.80.160:8080/books/10000, o ID do livro é 10000.

      

   6. No Cloud Shell, use o SSH para estabelecer ligação à instância bookshelf-aerospike:

      gcloud compute ssh bookshelf-aerospike
      

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

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

      O resultado é semelhante ao seguinte:

      +----------------------+----------------------+---------------+----------------------+----------+---------+
      | 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 os passos para adicionar um novo livro.

   Transferir dados de cópia de segurança do Aerospike para o Cloud Storage

   1. No Cloud Shell, na sessão da instância bookshelf-aerospike, crie um ficheiro de cópia de segurança 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
      

      Este comando processa os dados e cria um ficheiro de cópia de segurança através do seguinte processo:

      • Seleciona informações de livros do Aerospike e imprime-as no formato JSON prettyprint.
      • Remove os dois primeiros cabeçalhos da saída e converte os dados no formato JSON delimitado por newline (ndjson) usando jq, um processador JSON de linha de comandos.
      • Usa a CLI gcloud para carregar os dados para o contentor do Cloud Storage.

   2. Verifique se o ficheiro de cópia de segurança do Aerospike foi carregado e existe no contentor do Cloud Storage:

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

   3. (Opcional) Reveja o conteúdo do ficheiro de cópia de segurança a partir do contentor do Cloud Storage:

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

      O resultado é semelhante ao seguinte:

      {"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 regresse ao Cloud Shell:

      exit
      

   Migrar os dados da cópia de segurança para o Bigtable através do Dataflow

   Agora, pode migrar os dados da cópia de segurança do Cloud Storage para uma instância do Bigtable. Esta secção explica como usar pipelines do Dataflow para migrar dados compatíveis com um esquema do Bigtable.

   Configure a tarefa de migração do Dataflow

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

      cd "$HOME"/as2bt/dataflow/
      

   2. Configure variáveis de ambiente para uma tarefa 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, o resultado é semelhante ao seguinte:

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

   Execute a tarefa do Dataflow

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

      ./run_oncloud_json.sh
      

   2. Para monitorizar a tarefa de migração de dados de cópia de segurança, na Google Cloud consola, aceda à página Tarefas.

      Aceda a Empregos

      Aguarde até que a tarefa seja concluída com êxito. Quando a tarefa for concluída com êxito, a saída no Cloud Shell é semelhante à seguinte:

      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] ------------------------------------------------------------------------
      

   Verifique os resultados da tarefa de migração

   • No Cloud Shell, verifique se os dados da cópia de segurança foram transferidos corretamente para o Bigtable:

     cbt -instance bookshelf-bigtable lookup books 00001
     

     O resultado é semelhante ao seguinte:

       ----------------------------------------
     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"
     

     Nota: o ID do livro Aerospike-example foi invertido de 10000 para 00001 para evitar problemas com os pontos de acesso.

   Alteração da base de dados da estante de livros do Aerospike para o Bigtable

   Depois de migrar com êxito os dados do Aerospike para o Bigtable, pode alterar a configuração da app Bookshelf para usar o Bigtable para armazenamento. Quando configura esta opção, os novos livros são guardados nas instâncias do Bigtable.

   Altere a configuração da app Bookshelf

   1. No Cloud Shell, use o SSH para estabelecer ligação à app bookshelf-aerospike:

      gcloud compute ssh bookshelf-aerospike
      

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

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

      O resultado é o seguinte:

      DATA_BACKEND = 'aerospike'
      

   3. Altere a configuração de 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
      

      O resultado é o seguinte:

      DATA_BACKEND = 'bigtable'
      

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

      sudo supervisorctl restart bookshelf
      

   6. Verifique se a app Bookshelf foi reiniciada e está a ser executada corretamente:

      sudo supervisorctl status bookshelf
      

      O resultado é semelhante ao seguinte:

      bookshelf  RUNNING   pid 18318, uptime 0:01:00
      

   Verifique se a app de estante está a usar o back-end do Bigtable

   1. Num navegador, aceda a http://IP_ADDRESS:8080.

   2. Adiciona um novo livro denominado Bigtable-example.

   3. Para verificar se o livro Bigtable-example foi criado numa instância do Bigtable a partir da app Bookshelf, copie o ID do livro da barra de endereço no navegador.

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

      cbt -instance bookshelf-bigtable lookup books 7406950188
      

      O resultado é semelhante ao seguinte:

      ----------------------------------------
      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"
      

   Migrou com êxito os dados do Aerospike para o Bigtable e alterou a configuração da estante para se ligar a um back-end do Bigtable.

   Limpar

   A forma mais fácil de eliminar a faturação é eliminar o Google Cloud projeto que criou para o tutorial. Em alternativa, pode eliminar os recursos individuais.

   Elimine o projeto

   Atenção: a eliminação de um projeto tem os seguintes efeitos:
   • Tudo no projeto é eliminado. Se usou um projeto existente para as tarefas neste documento, quando o elimina, também elimina qualquer outro trabalho que tenha feito no projeto.
   • Os IDs dos projetos personalizados são perdidos. Quando criou este projeto, pode ter criado um ID do projeto personalizado que quer usar no futuro. Para preservar os URLs que usam o ID do projeto, como um URL appspot.com, elimine os recursos selecionados no projeto em vez de eliminar o projeto inteiro.
   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.

   O que se segue?

   • Saiba como criar o seu esquema do Bigtable.
   • Leia sobre como iniciar a sua migração para o Google Cloud.
   • Compreenda que estratégias tem para transferir grandes conjuntos de dados.
   • Explore arquiteturas de referência, diagramas e práticas recomendadas sobre o Google Cloud. Consulte o nosso Centro de arquitetura na nuvem.