Esegui la migrazione da Aerospike a Bigtable

Last reviewed 2024-10-16 UTC

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. È rivolto ai 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 il codice e i passaggi forniti in base al tuo ambiente.

Bigtable è un servizio completamente gestito sull'ordine dei petabyte Database NoSQL per grandi carichi di lavoro analitici e operativi. Puoi utilizzarlo come motore di archiviazione per il tuo servizio a bassa latenza e su larga scala con una maggiore disponibilità e 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), la tecnologia finanziaria (fintech) e i servizi IoT (Internet of Things) implementati con database NoSQL come AeroSpike o Cassandra. Se stai cercando un servizio gestito NoSQL, utilizza 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, la migrazione dei dati da un ambiente on-premise che utilizza Aerospike a Bigtable su Google Cloud avviene utilizzando due metodi diversi. Il primo metodo esegue la migrazione dei dati utilizzando l'elaborazione batch. Si inizia spostando i dati di backup di Aerospike in un bucket Cloud Storage. Quando viene eseguito quando arrivano i dati in Cloud Storage, attiva le funzioni Cloud Run 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 in streaming. In questo metodo, ti colleghi ad Aerospike utilizzando una coda di messaggi, ad esempio Kafka, tramite Aerospike Connect e trasferisci i messaggi in tempo reale a Pub/Sub su Google Cloud. Quando il messaggio arriva in un argomento Pub/Sub, viene elaborato dal job di streaming Dataflow in tempo reale per convertire e importare i dati nell'istanza Bigtable.

Con l'elaborazione batch, puoi eseguire la migrazione di grandi blocchi di dati in modo efficiente. 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 di dati di Bigtable è una 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 i modelli è il modo in cui raggruppano gli attributi di un'entità. Bigtable agrupa gli attributi correlati in una famiglia di colonne, mentre Aerospike li raggruppa 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 (ID) del libro per cercare le 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 esegui la migrazione dei dati dall'app libreria che utilizza Aerospike a Bigtable. Dopo la migrazione, puoi 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 avviene 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, viene attivato automaticamente il job Dataflow as2bt tramite le notifiche di aggiornamento di Cloud Storage utilizzando la funzione Cloud Run.
  3. Una volta completata la migrazione dei dati dal job as2bt Dataflow, cambia il backend del database da Aerospike a Bigtable in modo che l'app libreria carichi i dati dei libri dal 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.
  • Utilizza Dataflow per trasferire lo schema dei dati ed eseguirne la migrazione in Bigtable.
  • Modifica la configurazione dell'app di esempio per utilizzare Bigtable come backend.
  • Verifica che l'app scaffale funzioni correttamente con Bigtable.

Costi

In questo documento utilizzi 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. Per stimare il costo del cluster Bigtable e di altre risorse, puoi utilizzare il calcolatore prezzi. La configurazione di esempio del calcolatore dei prezzi utilizza tre nodi Bigtable anziché un singolo nodo. Il costo totale stimato nell'esempio precedente è superiore al costo totale effettivo di questo tutorial.

Al termine delle attività descritte in questo documento, puoi evitare la fatturazione continua eliminando le risorse che hai creato. Per ulteriori informazioni, consulta la sezione 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. Make sure that billing is enabled for your Google Cloud project.

  3. Enable the Cloud Resource Manager API.

    Enable the API

    Terraform utilizza l'API Cloud Resource Manager per abilitare le API richieste per questo tutorial.

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

    Activate Cloud Shell

preparazione dell'ambiente

Per preparare l'ambiente per la migrazione da Aerospike a Bigtable, esegui 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 configurato automaticamente da Cloud Shell. 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 l'ID del tuo progetto Google Cloud.

  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 di Terraform:

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

  3. Configura le 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. Esamina 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 da Terraform, disegna i grafici:

    terraform graph | dot -Tsvg > graph.svg

  6. Esegui il provisioning dell'ambiente del tutorial:

    terraform apply

Verifica dell'ambiente del tutorial e dell'app Bookshelf

Dopo aver eseguito il provisioning dell'ambiente e prima di avviare il job di migrazione dei dati, devi verificare che tutte le risorse siano state implementate e configurate. Questa sezione spiega come verificare la procedura di provisioning e ti aiuta a capire quali componenti sono configurati nell'ambiente.

Verificare l'ambiente del tutorial

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

    gcloud compute instances list

    L'output mostra che l'istanza è dipiattata 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 viene utilizzata come destinazione della migrazione per i 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, viene creato il nome del bucket 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é ti servirà 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 e poi fai clic su Salva:

    • Nel campo Title (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 all'istanzabookshelf-aerospike:

    gcloud compute ssh bookshelf-aerospike

  7. Dalla sessione dell'istanza bookshelf-aerospike, verifica che sia stato creato un nuovo libro con l'ID 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 i passaggi per aggiungere un nuovo libro.

Trasferimento dei dati di backup da Aerospike a Cloud Storage

  1. In Cloud Shell, dalla sessione dell'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

    Questo comando elabora i dati e crea un file di backup tramite la seguente procedura:

    • Seleziona le informazioni sul libro da Aerospike e le stampa il formato JSON clip-print.
    • Rimuove le prime due intestazioni dall'output e converte i dati in formato JSON delimitato da un carattere di nuova riga (ndjson) utilizzando jq, un elaboratore JSON a riga di comando.
    • Utilizza l'interfaccia a riga di comando gcloud 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'istanza Bigtable. Questa sezione spiega come utilizzare Pipeline Dataflow per eseguire la migrazione di dati compatibili con Schema di 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 è 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 della libreria 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 la configurazione attuale 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 Raccolta 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 libreria utilizzi il backend Bigtable

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

  2. Aggiungi 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 i dati del Bigtable-example libro 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 la migrazione dei dati da Aerospike a Bigtable e hai modificato la configurazione della libreria per connetterti a un backend Bigtable.

Esegui la pulizia

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

Elimina il progetto

  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.

Passaggi successivi