Migrazione da Aerospike a Bigtable

Questo tutorial descrive come eseguire la migrazione dei dati da Aerospike a Bigtable. Il tutorial spiega le differenze tra Aerospike e Bigtable e come trasformare il carico di lavoro per l'esecuzione in Bigtable. È per i professionisti di database che alla ricerca di un servizio di database su Google Cloud simile ad Aerospike. Questo tutorial presuppone che tu abbia familiarità con gli schemi, i tipi di dati e i concetti fondamentali di NoSQL e sistemi di database. Questo tutorial si basa sull'esecuzione di attività predefinite per eseguire degli esempi di migrazione. Al termine del tutorial, puoi modificare codice e i passaggi necessari per adattarli al tuo ambiente.

Bigtable è un database su scala petabyte Database NoSQL per grandi carichi di lavoro analitici e operativi. Puoi utilizzarlo come di archiviazione per il tuo servizio a bassa latenza e su scala petabyte con la disponibilità e la durabilità. Puoi analizzare i dati in Bigtable utilizzando i servizi di analisi dei dati di Google Cloud, Dataproc e BigQuery.

Bigtable è ideale per la tecnologia pubblicitaria (ad tech), i servizi finanziari tecnologie (fintech) e i servizi Internet of Things (IoT) che sono implementato con database NoSQL come AeroSpike o Cassandra. Se stai cercando per i servizi gestiti da NoSQL, usa Bigtable.

Architettura

Il seguente diagramma dell'architettura di riferimento mostra i componenti comuni per eseguire la migrazione dei dati da Aerospike a Bigtable.

Componenti del processo di trasferimento dei dati da Aerospike a Bigtable.

Nel diagramma precedente, i dati vengono migrati da un ambiente on-premise da Aerospike a Bigtable su Google Cloud tramite due metodi diversi. La il primo metodo di migrazione esegue la migrazione dei dati con l'elaborazione batch. Si inizia spostando i dati di backup di Aerospike in un bucket Cloud Storage. Quando viene eseguito quando arrivano dati in Cloud Storage, attiva Cloud Functions avviare un'estrazione in batch, il processo di trasformazione e caricamento (ETL) con Dataflow. La Il job Dataflow converte esegue il backup dei dati in un formato compatibile con Bigtable e importa i nell'istanza Bigtable.

Il secondo metodo esegue la migrazione dei dati utilizzando l'elaborazione dei flussi. In questo , ti connetti ad Aerospike utilizzando una coda di messaggi, come Kafaka utilizzando Aerospike Connect e trasferire i messaggi in tempo reale Pub/Sub su Google Cloud. Quando il messaggio arriva in un Pub/Sub viene elaborato dal job di flusso Dataflow in tempo reale per la conversione e l'importazione inserire i dati nell'istanza Bigtable.

Con l'elaborazione batch, puoi eseguire in modo efficiente la migrazione di grandi blocchi di dati. Tuttavia, richiede spesso un tempo di inattività sufficiente durante la migrazione e l'aggiornamento per i nuovi database. Per ridurre al minimo il tempo di inattività del cutover, valuta la possibilità di utilizzare l'elaborazione dei flussi per migrare i dati gradualmente dopo il primo batch per mantenere la coerenza dei dati di backup fino al completamento dell'elaborazione il cutover. In questo documento, puoi eseguire la migrazione da Aerospike utilizzando l'elaborazione con applicazioni di esempio, incluso il processo di cutover.

Confronto tra Aerospike e Bigtable

Prima di iniziare la migrazione dei dati, è fondamentale comprendere il differenze di modello dei dati tra Aerospike e Bigtable.

Il modello dei dati Bigtable è un mappa chiave-valore distribuita, multidimensionale e ordinata con righe e famiglie di colonne. Al contrario, il modello dei dati Aerospike un database orientato alle righe, in cui ogni record è identificato in modo univoco da una chiave. La differenza tra è il modo in cui raggruppano gli attributi di un'entità. Bigtable raggruppa attributi correlati in una famiglia di colonne, mentre i gruppi Aerospike attributi in un insieme. Aerospike supporta più tipi di dati rispetto a Bigtable. Per Ad esempio, Aerospike supporta numeri interi, stringhe, elenchi e mappe. Bigtable tratta tutti i dati come stringhe di byte non elaborati per la maggior parte degli scopi.

Uno schema in Aerospike è flessibile e i valori dinamici contenitori possono avere diversi tipi. App che usano Aerospike o Bigtable offre flessibilità e amministrazione dei dati simili responsabilità: le app gestiscono i tipi di dati e i vincoli di integrità, anziché basandosi sul motore del database.

Migrazione degli scaffali

La App BookShell è un'app web in cui gli utenti possono memorizzare informazioni sui libri e visualizzare l'elenco di tutti i libri attualmente memorizzati nel database. L'app utilizza un identificatore del libro (ID) per cercare informazioni sul libro. L'app o il database automaticamente genera questi ID. Quando un utente seleziona l'immagine di un libro, il backend dell'app carica i dettagli del libro dal database.

In questo tutorial, eseguirai la migrazione dei dati dall'app scaffale utilizzando Aerospike per Bigtable. Dopo la migrazione, potrai accedere ai libri da Bigtable.

Il seguente diagramma mostra come viene eseguita la migrazione dei dati da Aerospike a Bigtable:

Passaggi per la migrazione dei dati.

Nel diagramma precedente, la migrazione dei dati viene eseguita nel seguente modo:

  1. Esegui il backup dei dati relativi ai libri dell'attuale database Aerospike e trasferire i dati in un bucket Cloud Storage.
  2. Quando carichi i dati di backup nel bucket, attiva il job Dataflow as2bt tramite Notifiche di aggiornamento di Cloud Storage mediante la Cloud Function.
  3. Al termine della migrazione dei dati da parte dell'as2bt Job Dataflow, modifichi il backend del database da Aerospike a Bigtable in modo che l'app scaffale carichi i dati dei libri il cluster Bigtable.

Obiettivi

  • Esegui il deployment di un ambiente tutorial per la migrazione da Aerospike a Bigtable.
  • Crea un set di dati di backup dell'app di esempio da Aerospike in di archiviazione ideale in Cloud Storage.
  • Usa Dataflow per trasferire lo schema dei dati ed eseguirne la migrazione a Bigtable.
  • Modifica la configurazione dell'app di esempio in modo da utilizzare Bigtable di un backend cloud.
  • Verifica che l'app scaffale funzioni correttamente con Bigtable.

Costi

In questo documento vengono utilizzati i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi. I nuovi utenti di Google Cloud potrebbero essere idonei per una prova gratuita.

Gli addebiti di Bigtable si basano sul numero di ore nodo, quantità di dati archiviati e quantità di larghezza di banda di rete utilizzata. A stimare il costo del cluster Bigtable e di altre risorse, puoi utilizzare Calcolatore prezzi. La configurazione del Calcolatore prezzi di esempio utilizza tre Bigtable di nodi anziché di un singolo nodo. Il costo totale stimato nell'intervallo di date precedente rispetto al costo totale effettivo di questo tutorial.

Una volta completate le attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la pagina Pulizia.

Prima di iniziare

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

    Go to project selector

  2. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

  3. Attiva Cloud Resource Manager API.

    Abilita l'API

    Terraform usa l'API Cloud Resource Manager per abilitare le API richiesta per questo tutorial.

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

    Activate Cloud Shell

preparazione dell'ambiente

prepara l'ambiente per il passaggio da Aerospike a Bigtable. eseguirai i seguenti strumenti direttamente da Cloud Shell:

  • Google Cloud CLI
  • Lo strumento a riga di comando di Bigtable, cbt
  • Terraform
  • Apache Maven

Questi strumenti già disponibile in Cloud Shell, in modo da non doverli installare di nuovo.

Configura il progetto

  1. In Cloud Shell, controlla l'ID progetto Cloud Shell esegue la configurazione automatica. Il tuo prompt dei comandi è aggiornato in modo da riflettere il progetto attualmente attivo e la relativa visualizzazione formato: USERNAME@cloudshell:~ (PROJECT_ID)$

    Se l'ID progetto non è configurato correttamente, puoi configurarlo manualmente:

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

    Sostituisci PROJECT_ID con il tuo progetto Google Cloud ID.

  2. Configura us-east1 come regione e us-east1-b come zona:

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

    Per ulteriori informazioni su regioni e zone, consulta Area geografica e regioni.

Esegui il deployment dell'ambiente del tutorial

  1. In Cloud Shell, clona il repository di codice:

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

  2. In Cloud Shell, inizializza la directory di lavoro Terraform:

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

  3. Configura Variabili di ambiente Terraform per il deployment:

    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. Rivedi il piano di esecuzione di Terraform:

    terraform plan

    L'output è simile al seguente:

    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. (Facoltativo) Per visualizzare le risorse con dipendenze di cui viene eseguito il deployment Terraform, disegna grafici:

    terraform graph | dot -Tsvg > graph.svg

  6. Esegui il provisioning dell'ambiente del tutorial:

    terraform apply

Verifica dell'ambiente del tutorial e dell'applicazione scaffale

Dopo aver eseguito il provisioning dell'ambiente e prima di avviare il job di migrazione dei dati, devi verificare che il deployment e la configurazione di tutte le risorse siano stati eseguiti. Questa sezione spiega come verificare il processo di provisioning e ti aiuta capire quali componenti sono configurati nell'ambiente.

Verifica l'ambiente del tutorial

  1. In Cloud Shell, verifica bookshelf-aerospike Istanza Compute Engine:

    gcloud compute instances list

    L'output mostra che il deployment dell'istanza è stato eseguito nella 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. Verifica l'istanza Bigtable bookshelf-bigtable:

    gcloud bigtable instances list

    L'output è simile al seguente:

    NAME                DISPLAY_NAME        STATE
bookshelf-bigtable  bookshelf-bigtable  READY

    Questa istanza Bigtable è utilizzata come destinazione della migrazione passaggi successivi.

  3. Verifica che il bucket Cloud Storage bookshelf si trovi in Job della pipeline Dataflow:

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

    Perché i nomi dei bucket Cloud Storage devono essere a livello globale univoco, il nome del bucket viene creato con un suffisso casuale. L'output è simile al seguente:

    gs://bookshelf-616f60d65a3abe62/

Aggiungere un libro all'app Bookshelf

  1. In Cloud Shell, trova l'indirizzo IP esterno Istanza bookshelf-aerospike:

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

    Prendi nota dell'indirizzo IP perché sarà necessario nel passaggio successivo.

  2. Per aprire l'app Book {/4}, in un browser web vai a http://IP_ADDRESS:8080.

    Sostituisci IP_ADDRESS con l'indirizzo IP esterno che corrisponde che hai copiato dal passaggio precedente.

  3. Per creare un nuovo libro, fai clic su Aggiungi libro.

  4. Nella finestra Aggiungi libro, compila i seguenti campi, quindi fai clic su Salva:

    • Nel campo Titolo, inserisci Aerospike-example.
    • Nel campo Author (Autore), inserisci Aerospike-example.
    • Nel campo Data di pubblicazione, inserisci la data odierna.
    • Nel campo Description (Descrizione), inserisci Aerospike-example.

    Questo libro è utilizzato per e verificare che l'app Book quadro utilizzi Aerospike come spazio per l'archiviazione dei libri.

  5. Nell'URL dell'app Book {/4}, prendi nota dell'ID libro. Ad esempio, se l'URL è 34.74.80.160:8080/books/10000, l'ID libro è 10000.

    ID libro nell&#39;URL.

  6. In Cloud Shell, utilizza SSH per connetterti Istanza bookshelf-aerospike:

    gcloud compute ssh bookshelf-aerospike

  7. Dalla sessione dell'istanza bookshelf-aerospike, verifica che un nuovo libro è stato creato con l'ID libro che hai annotato in precedenza:

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

    L'output è simile al seguente:

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

    Se l'ID libro non è presente nell'elenco, ripeti questi passaggi per aggiungi un nuovo libro.

Trasferimento dei dati di backup da Aerospike a Cloud Storage

  1. In Cloud Shell, dall'istanza bookshelf-aerospike crea un file di backup 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

    Il comando elabora i dati e crea un file di backup tramite seguente processo:

    • Seleziona le informazioni sul libro da Aerospike e le stampa il formato JSON clip-print.
    • Rimuove le prime due intestazioni dall'output e converte il valore in un file JSON delimitato da una nuova riga (ndjson) formato utilizzando jq, un processore JSON a riga di comando.
    • Utilizza gcloud CLI per caricare i dati nel bucket Cloud Storage.

  2. Verifica che il file di backup di Aerospike sia caricato e che esista nel Bucket Cloud Storage:

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

  3. (Facoltativo) Esamina i contenuti del file di backup nella Bucket Cloud Storage:

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

    L'output è simile al seguente:

    {"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. Esci dalla sessione SSH e torna a Cloud Shell:

    exit

Migrazione dei dati di backup in Bigtable utilizzando Dataflow

Ora puoi eseguire la migrazione dei dati di backup da Cloud Storage a un Bigtable. Questa sezione spiega come utilizzare Pipeline Dataflow per eseguire la migrazione di dati compatibili con Schema Bigtable.

Configura il job di migrazione Dataflow

  1. In Cloud Shell, vai alla directory dataflow nell'esempio repository di codice:

    cd "$HOME"/as2bt/dataflow/

  2. Configura le variabili di ambiente per un job Dataflow:

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

  3. Verifica che le variabili di ambiente siano configurate correttamente:

    env | grep BOOKSHELF

    Se le variabili di ambiente sono configurate correttamente, l'output viene simile al seguente:

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

esegui il job Dataflow

  1. In Cloud Shell, esegui la migrazione dei dati da Cloud Storage l'istanza Bigtable:

    ./run_oncloud_json.sh

  2. Per monitorare il job di migrazione dei dati di backup, nel Nella console Google Cloud, vai alla pagina Job.

    Vai a Job

    Attendi il completamento del job. Una volta completato il job, l'output in Cloud Shell è simile al seguente:

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

Controlla i risultati del job di migrazione

  • In Cloud Shell, verifica che i dati di backup siano stati trasferiti correttamente in Bigtable:

    cbt -instance bookshelf-bigtable lookup books 00001

    L'output è simile al seguente:

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

Modifica del database dello scaffale da Aerospike a Bigtable

Dopo aver eseguito correttamente la migrazione dei dati da Aerospike a Bigtable, puoi modificare la configurazione dell'app Book {/4}per utilizzare Bigtable per l'archiviazione. Quando imposti questa configurazione, i nuovi libri vengono salvati in delle istanze Bigtable.

Modificare la configurazione dell'app Book {/4}

  1. In Cloud Shell, utilizza SSH per connetterti App bookshelf-aerospike:

    gcloud compute ssh bookshelf-aerospike

  2. Verifica che l'attuale configurazione di DATA_BACKEND sia aerospike:

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

    L'output è il seguente:

    DATA_BACKEND = 'aerospike'

  3. Modifica la configurazione di DATA_BACKEND da aerospike a bigtable:

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

  4. Verifica che la configurazione di DATA_BACKEND sia stata modificata in bigtable:

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

    L'output è il seguente:

    DATA_BACKEND = 'bigtable'

  5. Riavvia l'app BookSheet che utilizza la nuova configurazione del backend bigtable:

    sudo supervisorctl restart bookshelf

  6. Verifica che l'app BookShe sia stata riavviata e che funzioni correttamente:

    sudo supervisorctl status bookshelf

    L'output è simile al seguente:

    bookshelf  RUNNING   pid 18318, uptime 0:01:00

Verificare che l'app scaffale utilizzi il backend Bigtable

  1. In un browser, vai a http://IP_ADDRESS:8080.

  2. Aggiungere un nuovo libro denominato Bigtable-example.

  3. Per verificare che il libro Bigtable-example sia stato creato in un'istanza Bigtable dall'app Book {/4}, copia il libro ID riportato nella barra degli indirizzi nel browser.

  4. In Cloud Shell, cerca Bigtable-example prenota i dati da un'istanza Bigtable:

    cbt -instance bookshelf-bigtable lookup books 7406950188

    L'output è simile al seguente:

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

Hai eseguito correttamente una migrazione dei dati da Aerospike a Bigtable e modificata la configurazione dello scaffale per la connessione Backend Bigtable.

Esegui la pulizia

Il modo più semplice per eliminare la fatturazione è quello di eliminare il progetto Google Cloud creato per il tutorial. In alternativa, puoi eliminare il singolo Google Cloud.

Elimina il progetto

  1. Nella console Google Cloud, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
  3. Nella finestra di dialogo, digita l'ID del progetto e fai clic su Chiudi per eliminare il progetto.

Passaggi successivi