Esta página foi traduzida pela API Cloud Translation.

Migre do Aerospike para o Bigtable

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.

Componentes do processo de transferência de 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 para 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:

Passos de migração de dados.

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

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

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

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

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

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

(Opcional) Para visualizar os recursos com dependências implementados pelo Terraform, desenhe gráficos:
```
terraform graph | dot -Tsvg > graph.svg
```
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

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

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

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.
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.
Para criar um novo livro, clique em Adicionar livro.
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.
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.
No Cloud Shell, use o SSH para estabelecer ligação à instância bookshelf-aerospike:
```
gcloud compute ssh bookshelf-aerospike
```

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

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.

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

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

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

Já 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

No Cloud Shell, aceda ao diretório dataflow no repositório de código de exemplo:
```
cd "$HOME"/as2bt/dataflow/
```

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

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

No Cloud Shell, migre os dados do Cloud Storage para a instância do Bigtable:
```
./run_oncloud_json.sh
```

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"

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

No Cloud Shell, use o SSH para estabelecer ligação à app bookshelf-aerospike:
```
gcloud compute ssh bookshelf-aerospike
```
Verifique se a configuração DATA_BACKEND atual é aerospike:
```
grep DATA_BACKEND /opt/app/bookshelf/config.py
```
O resultado é o seguinte:
```
DATA_BACKEND = 'aerospike'
```

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

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'
```
Reinicie a app Bookshelf que usa a nova configuração de back-end bigtable:
```
sudo supervisorctl restart bookshelf
```
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

Num navegador, aceda a http://IP_ADDRESS:8080.
Adiciona um novo livro denominado Bigtable-example.
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.

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.

Migre do Aerospike para o Bigtable Mantenha tudo organizado com as coleções Salve e categorize o conteúdo com base nas suas preferências.

Arquitetura

Comparar o Aerospike e o Bigtable

Migração da estante

Preparar o seu ambiente

Configure o seu projeto

Implemente o ambiente do tutorial

Validar o ambiente do tutorial e a app de livros

Valide o ambiente do tutorial

Adicione um livro à app Bookshelf

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

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

Configure a tarefa de migração do Dataflow

Execute a tarefa do Dataflow

Verifique os resultados da tarefa de migração

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

Altere a configuração da app Bookshelf

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

Migre do Aerospike para o Bigtable