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. È rivolto ai professionisti di database che cercano un servizio di database su Google Cloud simile ad Aerospike. Questo tutorial presuppone che tu conosca gli schemi di database, i tipi di dati, le nozioni di base 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 modo che corrispondano 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 scala petabyte con disponibilità e durabilità superiori. Puoi analizzare i dati in Bigtable utilizzando i servizi di analisi dei dati di Google Cloud come Dataproc e BigQuery.

Bigtable è ideale per i servizi di tecnologia pubblicitaria (ad tech), di tecnologia finanziaria (fintech) e di internet of Things (IoT) implementati con database NoSQL come AeroSpike o Cassandra. Se stai cercando 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 utilizzando 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 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 importa i dati nell'istanza Bigtable.

Il secondo metodo esegue la migrazione dei dati utilizzando l'elaborazione dei flussi di dati. Con questo metodo, puoi connetterti ad Aerospike utilizzando una coda di messaggi, come Kafaka, utilizzando Aerospike Connect, e trasferire i messaggi in tempo reale su Pub/Sub su Google Cloud. Quando il messaggio arriva in un argomento Pub/Sub, viene elaborato in tempo reale dal job di inserimento di flussi di Dataflow in tempo reale per convertire e importare i dati nell'istanza Bigtable.

Grazie all'elaborazione batch, puoi migrare in modo efficiente grandi blocchi di dati. Tuttavia, spesso richiede tempi di inattività sufficienti per il cutover, durante la migrazione e l'aggiornamento del servizio per i nuovi database. Per ridurre al minimo i tempi di inattività del cutover, potresti considerare l'utilizzo dell'elaborazione dei flussi di dati per eseguire la migrazione graduale dei dati dopo la prima elaborazione batch, in modo da mantenere la coerenza dei dati di backup fino al completamento della cutover. In questo documento puoi eseguire la migrazione da Aerospike utilizzando l'elaborazione batch con applicazioni di esempio, incluso il processo del cutover.

Confronto tra Aerospike e Bigtable

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

Il modello dei dati di 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à di amministrazione dei dati simili: le app gestiscono tipi di dati e vincoli di integrità, invece di fare affidamento sul motore del database.

Migrazione degli scaffali

L'app BookSheet è un'app web in cui gli utenti possono archiviare 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 sui libri. L'app o il database generano 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 BookSheet 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 li trasferisci in un bucket Cloud Storage.
2. Quando carichi i dati di backup nel bucket, il job Dataflow di 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 as2bt, modifichi il backend del database da Aerospike a Bigtable in modo che l'app scaffale carichi i dati del libro 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 delle app di esempio da Aerospike in Cloud Storage.
• Utilizza Dataflow per trasferire lo schema di dati ed eseguirne la migrazione a 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 vengono utilizzati 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 possono essere idonei a una prova senza costi aggiuntivi.

Gli addebiti di Bigtable si basano sul numero di ore 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. L'esempio di configurazione del Calcolatore prezzi utilizza tre nodi Bigtable anziché uno solo. 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. Nella pagina del selettore di progetti della console Google Cloud, seleziona o crea un progetto Google Cloud.

   Nota: se non prevedi di conservare le risorse create in questa procedura, crea un progetto anziché selezionarne uno esistente. Dopo aver completato questi passaggi, puoi eliminare il progetto, rimuovendo tutte le risorse associate.

   Vai al selettore progetti

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 necessarie 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, quindi non è necessario installarli di nuovo.

Configura il progetto

1. In Cloud Shell, esamina l'ID progetto configurato automaticamente da Cloud Shell. Il prompt dei comandi è stato 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 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 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 tutorial:

   terraform apply
   

Verifica dell'ambiente tutorial e dell'applicazione BookSheet

Dopo aver eseguito il provisioning dell'ambiente e prima di avviare il job di migrazione dei dati, devi verificare che sia stato eseguito il deployment e configurato tutte le risorse. Questa sezione spiega come verificare il processo di provisioning e ti aiuta a capire 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, recupera 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é è necessario nel passaggio successivo.

2. Per aprire l'app Bookshield, 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 Title (Titolo), inserisci Aerospike-example.
   • Nel campo Author (Autore), inserisci Aerospike-example.
   • Nel campo Data di pubblicazione, inserisci la data odierna.
   • Nel campo Descrizione, inserisci Aerospike-example.

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

5. Prendi nota dell'ID libro nell'URL dell'app Bookshield. 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 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 il tuo 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 bookshelf-aerospike dell'istanza, 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 il seguente processo:

   • Seleziona le informazioni del libro da Aerospike e le stampa nel formato JSONBE.
   • Rimuove le prime due intestazioni dall'output e converte i dati nel formato JSON delimitato da una nuova riga (ndjson) utilizzando jq, un processore JSON della 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 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 del 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 a 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 di dati compatibili con uno schema 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 nella console Google Cloud.

   Vai a Job

   Attendi il completamento del job correttamente. Una volta completato il job, l'output in Cloud Shell sarà 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 prevenire i problemi relativi all'hot spot.

Modifica del database degli scaffali da Aerospike a Bigtable

Dopo aver eseguito correttamente la migrazione dei dati da Aerospike a Bigtable, puoi modificare la configurazione dell'app BookSheet in modo da utilizzare Bigtable per l'archiviazione. Quando imposti questa configurazione, i nuovi libri vengono salvati nelle istanze Bigtable.

Modifica della configurazione dell'app Bookshield

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. Cambia 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 venga modificata in bigtable:

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

   L'output è il seguente:

   DATA_BACKEND = 'bigtable'
   

5. Riavvia l'app Bookshield che utilizza la nuova configurazione di backend bigtable:

   sudo supervisorctl restart bookshelf
   

6. Verifica che l'app Bookshield sia stata riavviata e che sia in esecuzione correttamente:

   sudo supervisorctl status bookshelf
   

   L'output è simile al seguente:

   bookshelf  RUNNING   pid 18318, uptime 0:01:00
   

Verifica che l'app Bookshield utilizzi il backend Bigtable

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

2. Aggiungi un nuovo libro intitolato Bigtable-example.

3. Per verificare che il libro Bigtable-example sia stato creato in un'istanza Bigtable dall'app BookSheet, copia l'ID libro dalla barra degli indirizzi del 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 la connessione a un 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 lo schema di Bigtable.
• Scopri come avviare la migrazione a Google Cloud.
• Configura una pipeline CI/CD per il flusso di lavoro di elaborazione dati.
• Scopri quali strategie hai a disposizione per il trasferimento di set di dati di grandi dimensioni.
• Esplora le architetture di riferimento, i diagrammi e le best practice su Google Cloud. Visita il nostro Cloud Architecture Center.