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 in modo che venga eseguito in Bigtable. È rivolto a professionisti del database che cercano un servizio di database su Google Cloud simile ad Aerospike. Questo tutorial presuppone che tu abbia familiarità con gli schemi di database, i tipi di dati, i fondamenti di NoSQL e i sistemi di database relazionali. Questo tutorial si basa sull'esecuzione di attività predefinite per eseguire una migrazione di esempio. Al termine del tutorial, puoi modificare il codice e i passaggi forniti in base al tuo ambiente.

Bigtable è un servizio di database NoSQL completamente gestito su scala petabyte per carichi di lavoro analitici e operativi di grandi dimensioni. 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 come 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 che puoi utilizzare 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. Inizia spostando i dati di backup di Aerospike in un bucket Cloud Storage. Quando i dati del backup arrivano in Cloud Storage, vengono attivate le funzioni Cloud Run per avviare un processo ETL (estrazione, trasformazione e caricamento) batch utilizzando Dataflow. Il job Dataflow converte i dati di backup in un formato compatibile con Bigtable e li importa 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, spesso richiede tempi di inattività sufficienti per il cutover, durante la migrazione e l'aggiornamento del servizio per i nuovi database. Se vuoi ridurre al minimo i tempi di inattività del cutover, potresti considerare l'utilizzo dell'elaborazione in streaming per eseguire la migrazione dei dati gradualmente dopo la prima elaborazione in batch, in modo da mantenere la coerenza con i dati di backup fino al completamento del cutover graduale. In questo documento puoi eseguire la migrazione da Aerospike utilizzando l'elaborazione batch con applicazioni di esempio, inclusa la procedura di passaggio.

Confronto tra Aerospike e Bigtable

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

Il modello dei dati Bigtable è una mappa chiave/valore distribuita, multidimensionale e ordinata con famiglie di righe e colonne. Al contrario, il modello dei dati Aerospike è un database orientato alle righe, dove 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. Ad esempio, Aerospike supporta numeri interi, stringhe, elenchi e mappe. Bigtable tratta tutti i dati come stringhe di byte non elaborate per la maggior parte delle finalità.

Uno schema in Aerospike è flessibile e i valori dinamici negli stessi bin possono avere tipi diversi. Le app che utilizzano Aerospike o Bigtable hanno una flessibilità e una responsabilità di amministrazione dei dati simili: le app gestiscono i tipi di dati e i vincoli di integrità, anziché fare affidamento sul motore del database.

Migrazione della sezione Libri

L'app Libreria è un'app web in cui gli utenti possono archiviare informazioni sui libri e visualizzare l'elenco di tutti i libri attualmente archiviati nel database. L'app utilizza un identificatore (ID) del libro per cercare le informazioni sul libro. L'app o il database genera automaticamente 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 sui libri dall'attuale database Aerospike e li trasferisci 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 di tutorial per la migrazione da Aerospike a Bigtable.
  • Crea un set di dati di backup dell'app di esempio da Aerospike 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 libreria funzioni correttamente con Bigtable.

Costi

In questo documento utilizzi i seguenti componenti fatturabili di Google Cloud:

Per generare una stima dei costi in base all'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 di nodo, sulla quantità di dati archiviati e sulla 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 Bigtable, cbt
  • Terraform
  • Apache Maven

Questi strumenti sono già disponibili in Cloud Shell, quindi non è necessario installarli di nuovo.

Configura il tuo progetto

  1. In Cloud Shell, controlla l'ID progetto configurato automaticamente da Cloud Shell. Il prompt dei comandi viene aggiornato in base al progetto attualmente attivo e viene visualizzato in questo 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 saperne di più su regioni e zone, consulta Geografia 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 Raccolta

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 dipiattate 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 l'istanza bookshelf-aerospike 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 sia nel job della pipeline Dataflow:

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

    Poiché i nomi dei bucket Cloud Storage devono essere univoci a livello mondiale, 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, recupera l'indirizzo IP esterno dell'istanzabookshelf-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 Scaffale, vai ahttp://IP_ADDRESS:8080 in un browser web.

    Sostituisci IP_ADDRESS con l'indirizzo IP esterno 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 di oggi.
    • Nel campo Descrizione, inserisci Aerospike-example.

    Questo libro viene utilizzato per verificare che l'app Bookshelf utilizzi Aerospike come spazio di archiviazione dei libri.

  5. Nell'URL dell'app Bookshelf, 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 sui libri da Aerospike e le stampa nel formato JSON prettyprint.
    • 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 lgcloud 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 dal 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 le pipeline Dataflow per eseguire la migrazione dei dati compatibili con uno schema Bigtable.

Configura il job di migrazione di Dataflow

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

    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 all'istanza Bigtable:

    ./run_oncloud_json.sh

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

    Vai a Job

    Attendi il completamento del job. Al termine del 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 Bookshelf in modo da utilizzare Bigtable per l'archiviazione. Quando configuri questa configurazione, i nuovi libri vengono salvati nelle istanze Bigtable.

Modificare la configurazione dell'app Bookshelf

  1. In Cloud Shell, utilizza SSH per connetterti all'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 impostata su bigtable:

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

    L'output è il seguente:

    DATA_BACKEND = 'bigtable'

  5. Riavvia l'app Bookshelf 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 chiamato Bigtable-example.

  3. Per verificare che il libro Bigtable-example sia stato creato in un'istanza Bigtable dall'app Bookshelf, copia l'ID libro dalla barra degli indirizzi del 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 le singole risorse.

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