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 cercano un servizio di database su Google Cloud simile ad Aerospike. Questo tutorial presuppone la conoscenza degli schemi dei database, dei tipi di dati, delle nozioni di base di NoSQL e dei 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 su scala petabyte completamente gestito per carichi di lavoro analitici e operativi di grandi dimensioni. Puoi usarlo come motore di archiviazione per il tuo servizio a bassa latenza e con scalabilità nell'ordine dei petabyte, con disponibilità e durabilità maggiori. 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 Internet of Things (IoT) implementati con database NoSQL come AeroSpike o Cassandra. Se cerchi un servizio gestito da NoSQL, usa 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.

Nel diagramma precedente, i dati vengono migrati da un ambiente on-premise utilizzando Aerospike a Bigtable su Google Cloud utilizzando due metodi diversi. Il primo metodo esegue la migrazione dei dati mediante l'elaborazione batch. Per prima cosa, sposta i dati di backup di Aerospike in un bucket Cloud Storage. Quando i dati di backup arrivano in Cloud Storage, attiva Cloud Functions per l'avvio di un processo ETL (Extract, Transform, Load) in batch utilizzando Dataflow. Il job Dataflow converte i dati di backup in un formato compatibile con Bigtable e importa i dati nell'istanza Bigtable.

Il secondo metodo esegue la migrazione dei dati utilizzando l'elaborazione dei flussi. Con questo metodo, ti connetti ad Aerospike utilizzando una coda di messaggi, come Kafaka, 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 in tempo reale dal job di flusso Dataflow per convertire e importare i dati nell'istanza Bigtable.

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

Confronto tra Aerospike e Bigtable

Prima di avviare la migrazione dei dati, è fondamentale comprendere le differenze di modello dei dati tra 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 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 raggruppa gli attributi correlati in una famiglia di colonne, mentre Aerospike raggruppa gli attributi in un set. 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 elaborati per la maggior parte degli scopi.

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

Migrazione degli scaffali

L'app BookShe è 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 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, eseguirai la migrazione dei dati dall'app scaffale utilizzando Aerospike a 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:

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

1. Esegui il backup dei dati sui libri dall'attuale database Aerospike e trasferisci i dati in un bucket Cloud Storage.
2. Quando carichi i dati di backup nel bucket, il job Dataflow as2bt viene attivato automaticamente tramite le notifiche di aggiornamento di Cloud Storage utilizzando la funzione Cloud Function.
3. Dopo che la migrazione dei dati è stata completata dal job Dataflow di as2bt, modifichi il backend del database da Aerospike a Bigtable in modo che l'applicazione scaffale carichi i dati dei libri dal cluster Bigtable.

Obiettivi

• Esegui il deployment di un ambiente tutorial per la migrazione da Aerospike a Bigtable.
• Creare un set di dati di backup dell'app di esempio da Aerospike in Cloud Storage.
• Usa Dataflow per trasferire lo schema dei dati e migrarlo in Bigtable.
• Modifica la configurazione dell'app di esempio in modo da utilizzare Bigtable come backend.
• Verifica che l'app BookSheet funzioni correttamente con Bigtable.

Costi

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

• Compute Engine
• Bigtable
• Pub/Sub
• Cloud Storage
• Dataflow

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 per Bigtable si basano sul numero di ore nodo, la quantità di dati archiviati e la 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 del Calcolatore prezzi di esempio utilizza tre nodi Bigtabley invece di un nodo singolo. Il costo totale stimato nell'esempio precedente è superiore 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.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the 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 utilizza l'API Cloud Resource Manager per abilitare le API richieste per questo tutorial.

4. Nella console Google Cloud, attiva Cloud Shell.

   Attiva 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 gsutil
• Lo strumento a riga di comando di Bigtable, cbt
• Terraform
• Apache Maven

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

Configura il progetto

1. In Cloud Shell, controlla l'ID progetto che Cloud Shell configura automaticamente. Il prompt dei comandi è aggiornato per riflettere il 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 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 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. 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 da Terraform, disegna dei 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 a comprendere quali componenti sono configurati nell'ambiente.

Verifica l'ambiente del tutorial

1. In Cloud Shell, verifica l'istanza di Compute Engine bookshelf-aerospike:

   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 viene utilizzata come destinazione della migrazione per i passaggi successivi.

3. Verifica che il bucket Cloud Storage bookshelf sia nel job della pipeline Dataflow:

   gsutil ls -b gs://bookshelf-*
   

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

   Sostituisci IP_ADDRESS con l'indirizzo IP esterno che hai copiato nel 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 viene utilizzato per verificare che l'app Book quadro utilizzi Aerospike come spazio di 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.

   

6. In Cloud Shell, utilizza SSH per connetterti all'istanza bookshelf-aerospike:

   gcloud compute ssh bookshelf-aerospike
   

7. Dalla sessione dell'istanza bookshelf-aerospike, verifica che sia stato creato un nuovo libro 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 la procedura 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] | .[]' \
       | gsutil cp - $(gsutil ls -b gs://bookshelf-*)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 nel formato JSON Piuttostoprint.
   • Rimuove le prime due intestazioni dall'output e converte i dati nel formato JSON delimitato da nuova riga (ndjson) utilizzando jq, un processore JSON a riga di comando.
   • Utilizza lo strumento a riga di comando gsutil 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:

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

3. (Facoltativo) Esamina i contenuti dei file di backup dal bucket Cloud Storage:

   gsutil 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 di Dataflow per eseguire la migrazione di dati compatibili con uno schema di Bigtable.

Configura il job di migrazione 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="$(gsutil 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 della console Google Cloud.

   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"
  

  Nota: l'ID libro Aerospike-example viene invertito da 10000 a 00001 per evitare problemi relativi all'hotspot.

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}in modo da utilizzare Bigtable per l'archiviazione. Quando imposti questa configurazione, i nuovi libri vengono salvati nelle istanze Bigtable.

Modificare la configurazione dell'app Book {/4}

1. In Cloud Shell, utilizza SSH per connetterti all'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. 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 l'ID libro dalla barra degli indirizzi nel browser.

4. In Cloud Shell, cerca i dati del libro Bigtable-example 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 hai modificato la configurazione dello scaffale per connetterti al backend di 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

Attenzione: l'eliminazione di un progetto ha i seguenti effetti:
• L'intero contenuto del progetto viene eliminato. Se hai utilizzato un progetto esistente per le attività in questo documento, quando lo elimini elimini anche qualsiasi altro lavoro svolto nel progetto.
• Gli ID progetto personalizzati non sono più disponibili. Quando hai creato questo progetto, potresti aver creato un ID progetto personalizzato che vuoi utilizzare in futuro. Per conservare gli URL che utilizzano l'ID progetto, ad esempio un URL appspot.com, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero 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

• Scopri come progettare il tuo schema Bigtable.
• Leggi come avviare la migrazione a Google Cloud.
• Imposta una pipeline CI/CD per il flusso di lavoro di elaborazione dati.
• Scopri le strategie a tua disposizione per trasferire grandi set di dati.
• Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Visita il nostro Cloud Architecture Center.