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.
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:
No diagrama anterior, os dados são migrados da seguinte forma:
- Você faz backup de dados sobre livros do banco de dados atual do Aerospike e os transfere para um bucket do Cloud Storage.
- 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. - 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.
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
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Verifique se a cobrança está ativada para o seu projeto do Google Cloud.
-
Enable the Cloud Resource Manager API.
O Terraform usa a API Resource Manager para ativar as APIs necessárias para este tutorial.
-
In the Google Cloud console, 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
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.Configure
us-east1
como a região eus-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
No Cloud Shell, clone o repositório de código:
git clone https://github.com/fakeskimo/as2bt.git/
No Cloud Shell, inicialize o diretório de trabalho do Terraform:
cd "$HOME"/as2bt/bookshelf/terraform terraform init
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)"
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" } }
Opcional: para visualizar quais recursos com dependências são implantados pelo Terraform, crie gráficos:
terraform graph | dot -Tsvg > graph.svg
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
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
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.
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
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.
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.Para criar um novo livro, clique em
Adicionar livro.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.
- No campo Título, insira
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
.No Cloud Shell, use o SSH para se conectar à instância
bookshelf-aerospike
:gcloud compute ssh bookshelf-aerospike
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
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.
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
(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"}
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
No Cloud Shell, acesse o diretório
dataflow
no repositório de código de exemplo:cd "$HOME"/as2bt/dataflow/
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)"
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
No Cloud Shell, migre os dados do Cloud Storage para a instância do Bigtable:
./run_oncloud_json.sh
Para monitorar o job de migração de dados de backup, acesse a página Jobs no console do Google Cloud.
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
No Cloud Shell, use SSH para se conectar ao aplicativo
bookshelf-aerospike
:gcloud compute ssh bookshelf-aerospike
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'
Altere a configuração
DATA_BACKEND
deaerospike
parabigtable
:sudo sed -i "s/DATA_BACKEND =.*/DATA_BACKEND = 'bigtable'/g" /opt/app/bookshelf/config.py
Verifique se a configuração
DATA_BACKEND
foi alterada parabigtable
:grep DATA_BACKEND /opt/app/bookshelf/config.py
A saída é esta:
DATA_BACKEND = 'bigtable'
Reinicie o aplicativo Bookshelf que usa a nova configuração de back-end
bigtable
:sudo supervisorctl restart bookshelf
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
- Em um navegador, acesse
http://IP_ADDRESS:8080
. Adicione um novo livro chamado
Bigtable-example
.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.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
- In the Google Cloud console, go to the Manage resources page.
- In the project list, select the project that you want to delete, and then click Delete.
- In the dialog, type the project ID, and then click Shut down to delete the project.
A seguir
- Saiba como projetar seu esquema do Bigtable.
- Leia sobre como iniciar a migração para o Google Cloud.
- Configure um pipeline de CI/CD para seu fluxo de trabalho de processamento de dados
- Entenda quais estratégias você tem para transferir grandes conjuntos de dados.
- Confira arquiteturas de referência, diagramas e práticas recomendadas do Google Cloud. Confira o Centro de arquitetura do Cloud.