Esegui la migrazione da DynamoDB a Cloud Spanner

Questo tutorial descrive come eseguire la migrazione da Amazon DynamoDB a SPANer. È principalmente rivolto ai proprietari di app che vogliono passare da un sistema NoSQL a Spanner, un sistema di database SQL completamente relazionale a tolleranza di errore che supporta le transazioni. Se hai un utilizzo costante della tabella Amazon DynamoDB, in termini di tipi e layout, la mappatura a Spanner è semplice. Se le tue tabelle Amazon DynamoDB contengono tipi e valori arbitrari di dati, potrebbe essere più semplice passare ad altri servizi NoSQL, come Datastore o Firestore.

Questo tutorial presuppone che tu conosca gli schemi di database, i tipi di dati, i concetti fondamentali di NoSQL e i sistemi di database relazionali. Il tutorial si basa sull'esecuzione di attività predefinite per eseguire una migrazione di esempio. Dopo aver completato il tutorial, puoi modificare il codice fornito e i passaggi per corrispondere al tuo ambiente.

Il seguente diagramma dell'architettura illustra i componenti utilizzati nel tutorial per eseguire la migrazione dei dati:

Diagramma dell'architettura dei componenti della migrazione

Obiettivi

  • Esegui la migrazione dei dati da Amazon DynamoDB a Spanner.
  • Creare un database Spanner e una tabella di migrazione.
  • Mappare uno schema NoSQL a uno schema relazionale.
  • Crea ed esporta un set di dati di esempio che utilizza Amazon DynamoDB.
  • Trasferisci i dati tra Amazon S3 e Cloud Storage.
  • Utilizza Dataflow per caricare i dati in Spanner.

Costi

Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:

Gli addebiti per Spanner si basano sulla quantità di capacità di calcolo nella tua istanza e sulla quantità di dati archiviati durante il ciclo di fatturazione mensile. Durante il tutorial, utilizzi una configurazione minima di queste risorse, che vengono pulite alla fine. Per scenari reali, fai una stima dei requisiti di velocità effettiva e di archiviazione e usa la documentazione sulle istanze Spanner per determinare la quantità di capacità di calcolo di cui hai bisogno.

Oltre alle risorse di Google Cloud, questo tutorial utilizza le seguenti risorse di Amazon Web Services (AWS):

  • AWS Lambda
  • Amazon S3
  • Amazon DynamoDB

Questi servizi sono necessari solo durante il processo di migrazione. Alla fine del tutorial, segui le istruzioni per pulire tutte le risorse per evitare addebiti non necessari. Per stimare questi costi, utilizza il Calcolatore prezzi di AWS.

Per generare una stima dei costi basata sull'utilizzo previsto, utilizza il Calcolatore prezzi.

Prima di iniziare

  1. Accedi al tuo account Google Cloud. Se non conosci Google Cloud, crea un account per valutare le prestazioni dei nostri prodotti in scenari reali. I nuovi clienti ricevono anche 300 $di crediti gratuiti per l'esecuzione, il test e il deployment dei carichi di lavoro.
  2. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  3. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  4. Abilita le API Spanner, Pub/Sub, Compute Engine, and Dataflow.

    Abilita le API

  5. Nella pagina del selettore dei progetti in Google Cloud Console, seleziona o crea un progetto Google Cloud.

    Vai al selettore progetti

  6. Assicurati che la fatturazione sia attivata per il tuo progetto Cloud. Scopri come verificare se la fatturazione è abilitata su un progetto.

  7. Abilita le API Spanner, Pub/Sub, Compute Engine, and Dataflow.

    Abilita le API

Al termine di questo tutorial, puoi evitare una fatturazione continua eliminando le risorse che hai creato. Per scoprire di più, vedi Pulizia.

prepara l'ambiente

In questo tutorial, verranno eseguiti i comandi in Cloud Shell. Cloud Shell ti consente di accedere alla riga di comando in Google Cloud e include l'interfaccia a riga di comando di Google Cloud e altri strumenti necessari per lo sviluppo da parte di Google Cloud. L'inizializzazione di Cloud Shell può richiedere alcuni minuti.

  1. Attiva Cloud Shell.

    Attiva Cloud Shell

  2. Imposta la zona Compute Engine predefinita. Ad esempio, us-central1-b.

    gcloud config set compute/zone us-central1-b
    
  3. Clona il repository GitHub contenente il codice di esempio.

    git clone https://github.com/GoogleCloudPlatform/dynamodb-spanner-migration.git
    
  4. Vai alla directory clonata.

    cd dynamodb-spanner-migration
    
  5. Crea un ambiente virtuale Python.

    pip3 install virtualenv
    virtualenv env
    
  6. Attiva l'ambiente virtuale.

    source env/bin/activate
    
  7. Installa i moduli Python richiesti.

    pip3 install -r requirements.txt
    

Configura l'accesso ad AWS

In questo tutorial, imparerai a creare ed eliminare tabelle Amazon DynamoDB, bucket Amazon S3 e altre risorse. Per accedere a queste risorse, devi prima creare le autorizzazioni AWS Identity and Access Management (IAM) richieste. Puoi utilizzare un account AWS di prova o sandbox per evitare di influire sulle risorse di produzione dello stesso account.

Crea un ruolo AWS IAM per AWS Lambda

In questa sezione creerai un ruolo AWS IAM che sarà utilizzato da AWS Lambda in un passaggio successivo del tutorial.

  1. Nella console AWS, vai alla sezione IAM, fai clic su Ruoli e seleziona Crea ruolo.
  2. In Tipo di entità attendibile, assicurati che sia selezionato il servizio AWS.
  3. In Caso d'uso, seleziona Lambda, quindi fai clic su Avanti.
  4. Nella casella dei filtri Criteri di autorizzazione, inserisci AWSLambdaDynamoDBExecutionRole e premi Return per cercare.
  5. Seleziona la casella di controllo AWSLambdaDynamoDBExecutionRole, quindi fai clic su Avanti.
  6. Nella casella Nome ruolo, inserisci dynamodb-spanner-lambda-role e fai clic su Crea ruolo.

Crea un utente AWS IAM

Segui questi passaggi per creare un utente AWS IAM con accesso programmatico alle risorse AWS, che vengono utilizzate durante il tutorial.

  1. Mentre sei ancora nella sezione IAM della console AWS, fai clic su Utenti e seleziona Aggiungi utenti.
  2. Nella casella Nome utente, inserisci dynamodb-spanner-migration.
  3. In Tipo di accesso, seleziona la casella di controllo a sinistra di Chiave di accesso - Accesso programmatico.

  4. Fai clic su Successivo: autorizzazioni.

  5. Fai clic su Collega i criteri esistenti e utilizzando la casella Cerca per filtrare, seleziona la casella di controllo accanto a ciascuno dei seguenti tre criteri:

    • AmazonDynamoDBFullAccess
    • AmazonS3FullAccess
    • AWSLambda_FullAccess
  6. Fai clic su Successivo: tag, quindi su Successivo: esamina e poi su Crea utente.

  7. Fai clic su Show (Mostra) per visualizzare le credenziali. L'ID chiave di accesso e la chiave di accesso segreta vengono visualizzati per l'utente appena creato. Per il momento lascia aperta la finestra perché le credenziali sono necessarie nella sezione seguente. Archivia queste credenziali in modo sicuro perché, con loro, puoi apportare modifiche al tuo account e incidere sull'ambiente. Alla fine di questo tutorial, puoi eliminare l'utente IAM.

Configura l'interfaccia a riga di comando di AWS

  1. In Cloud Shell, configura l'interfaccia a riga di comando (CLI) di AWS.

    aws configure
    

    Viene visualizzato il seguente output:

    AWS Access Key ID [None]: PASTE_YOUR_ACCESS_KEY_ID
    AWS Secret Access Key [None]: PASTE_YOUR_SECRET_ACCESS_KEY
    Default region name [None]: us-west-2
    Default output format [None]:
    
    • Inserisci i valori ACCESS KEY ID e SECRET ACCESS KEY dell'account AWS IAM che hai creato.
    • Nel campo Default region name (Nome regione predefinito), inserisci us-west-2. Lascia invariati i valori predefiniti degli altri campi.
  2. Chiudi la finestra della console AWS IAM.

Informazioni sul modello dei dati

La seguente sezione illustra le similitudini e le differenze tra tipi di dati, chiavi e indici per Amazon DynamoDB e Spanner.

Tipi di dati

Spanner utilizza tipi di dati SQL standard. La tabella seguente descrive in che modo i tipi di dati di Amazon DynamoDB vengono mappati ai tipi di dati di Spanner.

DinamoDB Amazon Dispositivo di scorrimento
Numero A seconda della precisione o dell'utilizzo previsto, potrebbe essere mappato a INT64, FLOAT64, TIMESTAMP o DATE.
Stringa Stringa
Booleano BOOL
Nullo Nessun tipo esplicito. Le colonne possono contenere valori nulli.
Autorizzazione Byte
Set Array
Mappa ed elenco Indica se la struttura è coerente e può essere descritta utilizzando la sintassi DDL della tabella.

Chiave primaria

Una chiave primaria Amazon DynamoDB stabilisce l'unicità e può essere una chiave hash o una combinazione di una chiave hash più una chiave di intervallo. Questo tutorial mostra la migrazione di una tabella Amazon DynamoDB la cui chiave primaria è una chiave hash. Questa chiave hash diventa la chiave primaria della tabella Spanner. Successivamente, nella sezione sulle tabelle con interfoliazione, si crea una situazione in cui una tabella Amazon DynamoDB utilizza una chiave primaria composta da una chiave hash e una chiave di intervallo.

Indici secondari

Sia Amazon DynamoDB che Spanner supportano la creazione di un indice su un attributo della chiave non principale. Prendi nota di tutti gli indici secondari nella tabella Amazon DynamoDB in modo da poterli creare nella tabella Spanner, trattata in una sezione successiva di questo tutorial.

Tabella di esempio

Per semplificare questo tutorial, esegui la migrazione della seguente tabella di esempio da Amazon DynamoDB a Spanner:

Amazon DynamoDB Spanner
Nome tabella Migration Migration
Chiave primaria "Username" : String "Username" : STRING(1024)
Tipo di chiave Hash n/d
Altri campi Zipcode: Number Subscribed: Boolean ReminderDate: String PointsEarned: Number Zipcode: INT64 Subscribed: BOOL ReminderDate: DATE PointsEarned: INT64

Prepara la tabella Amazon DynamoDB

Nella sezione seguente, puoi creare una tabella di origine Amazon DynamoDB e compilarla con i dati.

  1. In Cloud Shell, crea una tabella Amazon DynamoDB che utilizza gli attributi della tabella di esempio.

    aws dynamodb create-table --table-name Migration \
        --attribute-definitions AttributeName=Username,AttributeType=S \
        --key-schema AttributeName=Username,KeyType=HASH \
        --provisioned-throughput ReadCapacityUnits=75,WriteCapacityUnits=75
    
  2. Verifica che lo stato della tabella sia ACTIVE.

    aws dynamodb describe-table --table-name Migration \
        --query 'Table.TableStatus'
    
  3. Completa la tabella con i dati di esempio.

    python3 make-fake-data.py --table Migration --items 25000
    

Creazione di un database Spanner

Crei un'istanza di Spanner con la capacità di calcolo minima possibile: 100 unità di elaborazione. Questa capacità di calcolo è sufficiente per l'ambito di questo tutorial. Per un deployment di produzione, consulta la documentazione relativa alle istanze Spanner per determinare la capacità di computing adeguata per soddisfare i requisiti di prestazioni del database.

In questo esempio, crei uno schema di tabella contemporaneamente al database. È inoltre possibile e comune eseguire aggiornamenti dello schema dopo aver creato il database.

  1. Crea un'istanza di Spanner nella stessa area geografica in cui hai impostato la zona predefinita di Compute Engine. Ad esempio, us-central1.

    gcloud beta spanner instances create spanner-migration \
        --config=regional-us-central1 --processing-units=100 \
        --description="Migration Demo"
    
  2. Crea un database nell'istanza di Spanner insieme alla tabella di esempio.

    gcloud spanner databases create migrationdb \
        --instance=spanner-migration \
        --ddl "CREATE TABLE Migration ( \
                Username STRING(1024) NOT NULL, \
                PointsEarned INT64, \
                ReminderDate DATE, \
                Subscribed BOOL, \
                Zipcode INT64, \
             ) PRIMARY KEY (Username)"
    

Preparare la migrazione

Le sezioni seguenti mostrano come esportare la tabella di origine Amazon DynamoDB e impostare la replica Pub/Sub per acquisire eventuali modifiche al database che si verificano durante l'esportazione.

Trasmetti modifiche a Pub/Sub

Puoi utilizzare una funzione AWS Lambda per trasmettere in streaming le modifiche del database a Pub/Sub.

  1. In Cloud Shell, abilita i flussi Amazon DynamoDB nella tabella di origine.

    aws dynamodb update-table --table-name Migration \
        --stream-specification StreamEnabled=true,StreamViewType=NEW_AND_OLD_IMAGES
    
  2. Configura un argomento Pub/Sub per ricevere le modifiche.

    gcloud pubsub topics create spanner-migration
    

    Viene visualizzato il seguente output:

    Created topic [projects/your-project/topics/spanner-migration].
    
  3. Crea un account di servizio IAM per eseguire il push degli aggiornamenti delle tabelle all'argomento Pub/Sub.

    gcloud iam service-accounts create spanner-migration \
        --display-name="Spanner Migration"
    

    Viene visualizzato il seguente output:

    Created service account [spanner-migration].
    
  4. Crea un'associazione di criteri IAM in modo che l'account di servizio disponga dell'autorizzazione per pubblicare su Pub/Sub. Sostituisci GOOGLE_CLOUD_PROJECT con il nome del tuo progetto Google Cloud.

    gcloud projects add-iam-policy-binding GOOGLE_CLOUD_PROJECT \
        --role roles/pubsub.publisher \
        --member serviceAccount:spanner-migration@GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com
    

    Viene visualizzato il seguente output:

    bindings:
    (...truncated...)
    - members:
      - serviceAccount:spanner-migration@solution-z.iam.gserviceaccount.com
      role: roles/pubsub.publisher
    
  5. Crea le credenziali per l'account di servizio.

    gcloud iam service-accounts keys create credentials.json \
        --iam-account spanner-migration@GOOGLE_CLOUD_PROJECT.iam.gserviceaccount.com
    

    Viene visualizzato il seguente output:

    created key [5e559d9f6bd8293da31b472d85a233a3fd9b381c] of type [json] as [credentials.json] for [spanner-migration@your-project.iam.gserviceaccount.com]
    
  6. Prepara e pacchettizza la funzione AWS Lambda per eseguire il push delle modifiche alla tabella Amazon DynamoDB all'argomento Pub/Sub.

    pip3 install --ignore-installed --target=lambda-deps google-cloud-pubsub
    cd lambda-deps; zip -r9 ../pubsub-lambda.zip *; cd -
    zip -g pubsub-lambda.zip ddbpubsub.py
  7. Crea una variabile per acquisire il nome della risorsa Amazon (ARN) del ruolo di esecuzione Lambda che hai creato in precedenza.

    LAMBDA_ROLE=$(aws iam list-roles \
        --query 'Roles[?RoleName==`dynamodb-spanner-lambda-role`].[Arn]' \
        --output text)
    
  8. Utilizza il pacchetto pubsub-lambda.zip per creare la funzione AWS Lambda.

    aws lambda create-function --function-name dynamodb-spanner-lambda \
        --runtime python3.9 --role ${LAMBDA_ROLE} \
        --handler ddbpubsub.lambda_handler --zip fileb://pubsub-lambda.zip \
        --environment Variables="{SVCACCT=$(base64 -w 0 credentials.json),PROJECT=GOOGLE_CLOUD_PROJECT,TOPIC=spanner-migration}"
    

    Viene visualizzato il seguente output:

    {
        "FunctionName": "dynamodb-spanner-lambda",
        "LastModified": "2022-03-17T23:45:26.445+0000",
        "RevisionId": "e58e8408-cd3a-4155-a184-4efc0da80bfb",
        "MemorySize": 128,
    ... truncated output... "PackageType": "Zip", "Architectures": [ "x86_64" ] }

  9. Crea una variabile per acquisire l'ARN del flusso Amazon DynamoDB per la tua tabella.

    STREAMARN=$(aws dynamodb describe-table \
        --table-name Migration \
        --query "Table.LatestStreamArn" \
        --output text)
    
  10. Collega la funzione Lambda alla tabella Amazon DynamoDB.

    aws lambda create-event-source-mapping --event-source ${STREAMARN} \
        --function-name dynamodb-spanner-lambda --enabled \
        --starting-position TRIM_HORIZON
    
  11. Per ottimizzare la reattività durante il test, aggiungi --batch-size 1 alla fine del comando precedente, che attiva la funzione ogni volta che crei, aggiorni o elimini un elemento.

    Vedrai un output simile al seguente:

    {
        "UUID": "44e4c2bf-493a-4ba2-9859-cde0ae5c5e92",
        "StateTransitionReason": "User action",
        "LastModified": 1530662205.549,
        "BatchSize": 100,
        "EventSourceArn": "arn:aws:dynamodb:us-west-2:accountid:table/Migration/stream/2018-07-03T15:09:57.725",
        "FunctionArn": "arn:aws:lambda:us-west-2:accountid:function:dynamodb-spanner-lambda",
        "State": "Creating",
        "LastProcessingResult": "No records processed"
    ... truncated output...
    

Esporta la tabella Amazon DynamoDB in Amazon S3

  1. In Cloud Shell, crea una variabile per il nome di un bucket che utilizzi in diverse sezioni seguenti.

    BUCKET=${DEVSHELL_PROJECT_ID}-dynamodb-spanner-export
    
  2. Crea un bucket Amazon S3 per ricevere l'esportazione DynamoDB.

    aws s3 mb s3://${BUCKET}
    
  3. In AWS Management Console (Console di gestione AWS), vai a DynamoDB e fai clic su Tables.

  4. Fai clic sulla tabella Migration.

  5. Nella scheda Esportazioni e stream, fai clic su Esporta in S3.

  6. Se richiesto, attiva point-in-time-recovery (PITR).

  7. Fai clic su Sfoglia S3 per scegliere il bucket S3 che hai creato in precedenza.

  8. Fai clic su Esporta.

  9. Fai clic sull'icona Aggiorna per aggiornare lo stato del job di esportazione. Il completamento del job richiede diversi minuti.

    Al termine del processo, esamina il bucket di output.

    aws s3 ls --recursive s3://${BUCKET}
    

    Questa operazione dovrebbe richiedere circa 5 minuti. Al termine, vedrai un output simile al seguente:

    2022-02-17 04:41:46          0 AWSDynamoDB/01645072900758-ee1232a3/_started
    2022-02-17 04:46:04     500441 AWSDynamoDB/01645072900758-ee1232a3/data/xygt7i2gje4w7jtdw5652s43pa.json.gz
    2022-02-17 04:46:17        199 AWSDynamoDB/01645072900758-ee1232a3/manifest-files.json
    2022-02-17 04:46:17         24 AWSDynamoDB/01645072900758-ee1232a3/manifest-files.md5
    2022-02-17 04:46:17        639 AWSDynamoDB/01645072900758-ee1232a3/manifest-summary.json
    2022-02-17 04:46:18         24 AWSDynamoDB/01645072900758-ee1232a3/manifest-summary.md5
    

Eseguire la migrazione

Ora che la pubblicazione Pub/Sub è attiva, puoi trasferire le modifiche della tabella effettuate dopo l'esportazione.

Copia la tabella esportata in Cloud Storage

  1. In Cloud Shell, crea un bucket Cloud Storage per ricevere i file esportati da Amazon S3.

    gsutil mb gs://${BUCKET}
    
  2. Sincronizza i file da Amazon S3 in Cloud Storage. Per la maggior parte delle operazioni di copia, il comando rsync è efficace. Se i file di esportazione sono di grandi dimensioni (diversi GB o più), utilizza il servizio di trasferimento di Cloud Storage per gestire il trasferimento in background.

    gsutil rsync -d -r s3://${BUCKET} gs://${BUCKET}
    

Importare i dati in gruppo

  1. Per scrivere i dati dai file esportati nella tabella Spanner, esegui un job Dataflow con codice Apache di esempio.

    cd dataflow
    mvn compile
    mvn exec:java \
    -Dexec.mainClass=com.example.spanner_migration.SpannerBulkWrite \
    -Pdataflow-runner \
    -Dexec.args="--project=GOOGLE_CLOUD_PROJECT \
                 --instanceId=spanner-migration \
                 --databaseId=migrationdb \
                 --table=Migration \
                 --importBucket=$BUCKET \
                 --runner=DataflowRunner \
                 --region=us-central1"
    
    1. Per controllare l'avanzamento del job di importazione, in Google Cloud Console vai a Dataflow.

      Vai a Dataflow

    2. Durante l'esecuzione del job, puoi guardare il grafico di esecuzione per esaminare i log. Fai clic sul job che mostra lo Stato In esecuzione.

      Esecuzione del job di importazione in corso...

  2. Fai clic su ogni fase per vedere quanti elementi sono stati elaborati. L'importazione è completa quando tutte le fasi indicano il messaggio Riuscito. Lo stesso numero di elementi creati nella tabella Amazon DynamoDB viene visualizzato come elaborato in ogni fase.

    Fasi di esito positivo del job di importazione

  3. Verifica che il numero di record nella tabella Spanner di destinazione corrisponda al numero di elementi nella tabella Amazon DynamoDB.

    aws dynamodb describe-table --table-name Migration --query Table.ItemCount
    gcloud spanner databases execute-sql migrationdb \ --instance=spanner-migration --sql="select count(*) from Migration"

    Viene visualizzato il seguente output:

    $ aws dynamodb describe-table --table-name Migration --query Table.ItemCount
    25000
    $ gcloud spanner databases execute-sql migrationdb --instance=spanner-migration --sql="select count(*) from Migration"
    25000
    
  4. Inserisci voci casuali di esempio in ogni tabella per assicurarti che i dati siano coerenti.

    gcloud spanner databases execute-sql migrationdb \
        --instance=spanner-migration \
        --sql="select * from Migration limit 1"
    

    Viene visualizzato il seguente output:

     Username: aadams4495
     PointsEarned: 5247
     ReminderDate: 2022-03-14
     Subscribed: True
     Zipcode: 58057
    
  5. Esegui una query sulla tabella Amazon DynamoDB con lo stesso Username restituito dalla query Spanner nel passaggio precedente. Ad esempio, aallen2538. Il valore è specifico dei dati di esempio nel database.

    aws dynamodb get-item --table-name Migration \
        --key '{"Username": {"S": "aadams4495"}}'
    

    I valori degli altri campi devono corrispondere a quelli dell'output di Spanner. Viene visualizzato il seguente output:

    {
        "Item": {
            "Username": {
                "S": "aadams4495"
            },
            "ReminderDate": {
                "S": "2018-06-18"
            },
            "PointsEarned": {
                "N": "1606"
            },
            "Zipcode": {
                "N": "17303"
            },
            "Subscribed": {
                "BOOL": false
            }
        }
    }
    

Replica nuove modifiche

Una volta completato il job di importazione in batch, configuri un job di flusso per scrivere gli aggiornamenti in corso dalla tabella di origine in Spanner. Puoi iscriverti agli eventi da Pub/Sub e scriverli in Spark

La funzione Lambda che hai creato è configurata in modo da acquisire le modifiche alla tabella Amazon DynamoDB e pubblicarle in Pub/Sub.

  1. Crea una sottoscrizione all'argomento Pub/Sub a cui AWS Lambda invia gli eventi.

    gcloud pubsub subscriptions create spanner-migration \
        --topic spanner-migration
    

    Viene visualizzato il seguente output:

    Created subscription [projects/your-project/subscriptions/spanner-migration].
    
  2. Per avviare il flusso delle modifiche in Pub/Sub da scrivere nella tabella Spanner, esegui il job Dataflow da Cloud Shell.

    mvn exec:java \
    -Dexec.mainClass=com.example.spanner_migration.SpannerStreamingWrite \
    -Pdataflow-runner \
    -Dexec.args="--project=GOOGLE_CLOUD_PROJECT \
                 --instanceId=spanner-migration \
                 --databaseId=migrationdb \
                 --table=Migration \
                 --experiments=allow_non_updatable_job \
    --subscription=projects/GOOGLE_CLOUD_PROJECT/subscriptions/spanner-migration \
    --runner=DataflowRunner \
    --region=us-central1"
    
    1. Come per il passaggio caricamento in gruppo, in Google Cloud Console, per controllare l'avanzamento del job, vai a Dataflow.

      Vai a Dataflow

    2. Fai clic sul job con lo stato In esecuzione.

      Esecuzione job

      Il grafico di elaborazione mostra un output simile a quello precedente, ma ogni elemento elaborato viene conteggiato nella finestra di stato. Il tempo di attesa fornito dal sistema è una stima approssimativa del ritardo previsto prima della visualizzazione delle modifiche nella tabella Spanner.

      Processi in esecuzione a causa di tempi di attesa

Il job Dataflow eseguito nella fase di caricamento collettivo era un insieme finale di input, noto anche come set di dati bounded. Questo job Dataflow utilizza Pub/Sub come origine di streaming ed è considerato senza limiti. Per ulteriori informazioni su questi due tipi di fonti, consulta la sezione sulle raccolte nella guida alla programmazione Apache. Il job Dataflow in questo passaggio deve rimanere attivo, quindi non termina al termine. Il job di Dataflow in modalità flusso rimane in stato In esecuzione, anziché in stato Riuscito.

Verifica replica

Devi apportare alcune modifiche alla tabella di origine per verificare che le modifiche siano state replicate nella tabella Spanner.

  1. Esegui una query su una riga inesistente in Spanner.

    gcloud spanner databases execute-sql migrationdb \
        --instance=spanner-migration \
        --sql="SELECT * FROM Migration WHERE Username='my-test-username'"
    

    L'operazione non restituirà risultati.

  2. Crea un record in Amazon DynamoDB con la stessa chiave utilizzata nella query su Spanner. Se il comando viene eseguito correttamente, non ci sono output.

    aws dynamodb put-item \
        --table-name Migration \
        --item '{"Username" : {"S" : "my-test-username"}, "Subscribed" : {"BOOL" : false}}'
    
  3. Esegui di nuovo la stessa query per verificare che la riga sia ora in Spanner.

    gcloud spanner databases execute-sql migrationdb \
        --instance=spanner-migration \
        --sql="SELECT * FROM Migration WHERE Username='my-test-username'"
    

    L'output mostra la riga inserita:

    Username: my-test-username
    PointsEarned: None
    ReminderDate: None
    Subscribed: False
    Zipcode:
    
  4. Modifica alcuni attributi nell'elemento originale e aggiorna la tabella Amazon DynamoDB.

    aws dynamodb update-item \
        --table-name Migration \
        --key '{"Username": {"S":"my-test-username"}}' \
        --update-expression "SET PointsEarned = :pts, Subscribed = :sub" \
        --expression-attribute-values '{":pts": {"N":"4500"}, ":sub": {"BOOL":true}}'\
        --return-values ALL_NEW
    

    Vedrai un output simile al seguente:

    {
        "Attributes": {
            "Username": {
                "S": "my-test-username"
            },
            "PointsEarned": {
                "N": "4500"
            },
            "Subscribed": {
                "BOOL": true
            }
        }
    }
    
  5. Verifica che le modifiche siano propagate nella tabella Spanner.

    gcloud spanner databases execute-sql migrationdb \
        --instance=spanner-migration \
        --sql="SELECT * FROM Migration WHERE Username='my-test-username'"
    

    L'output viene visualizzato nel seguente modo:

    Username          PointsEarned  ReminderDate  Subscribed  Zipcode
    my-test-username  4500          None          True
    
  6. Elimina l'elemento di test dalla tabella di origine di Amazon DynamoDB.

    aws dynamodb delete-item \
        --table-name Migration \
        --key '{"Username": {"S":"my-test-username"}}'
    
  7. Verifica che la riga corrispondente sia stata eliminata dalla tabella Spanner. Quando la modifica viene propagata, il seguente comando restituisce zero righe:

    gcloud spanner databases execute-sql migrationdb \
        --instance=spanner-migration \
        --sql="SELECT * FROM Migration WHERE Username='my-test-username'"
    

Utilizza tabelle con interfoliazione

Spanner supporta il concetto di tabella delle intersezioni. Si tratta di un modello di progettazione in cui un elemento di primo livello presenta diversi elementi nidificati che riguardano l'elemento di primo livello, ad esempio un cliente e i suoi ordini, oppure un giocatore e i suoi punteggi dei giochi. Se la tabella di origine Amazon DynamoDB utilizza una chiave primaria composta da una chiave hash e una chiave di intervallo, puoi modellare uno schema di tabelle con interfoliazione come mostrato nel diagramma seguente. Questa struttura ti consente di eseguire query in modo efficiente sulla tabella con interfoliazione durante l'unione dei campi nella tabella principale.

Tabella utenti confrontata con la tabella degli ordini

Applica indici secondari

Una best practice consiste nell'applicare gli indici secondari alle tabelle Spanner dopo aver caricato i dati. Ora che la replica funziona, configuri un indice secondario per velocizzare le query. Come le tabelle Spanner, gli indici secondari Spanner sono completamente coerenti. Non non sono a coerenza finale, comune in molti database NoSQL. Questa funzionalità può aiutarti a semplificare la progettazione della tua app

Esegui una query che non utilizzi indici. Stai cercando le occorrenze di N principali, in base a un determinato valore della colonna. Si tratta di una query comune in Amazon DynamoDB per l'efficienza dei database.

  1. Vai a Spanner.

    Vai a Spanner

  2. Fai clic su Query.

    Pulsante Query

  3. Nel campo Query, inserisci la seguente query e fai clic su Esegui query.

    SELECT Username,PointsEarned
      FROM Migration
     WHERE Subscribed=true
       AND ReminderDate > DATE_SUB(DATE(current_timestamp()), INTERVAL 14 DAY)
     ORDER BY ReminderDate DESC
     LIMIT 10
    

    Dopo aver eseguito la query, fai clic su Spiegazione e prendi nota delle righe Righe scansionate e Righe restituite. Senza un indice, Spanner esegue la scansione dell'intera tabella per restituire un piccolo sottoinsieme di dati che corrisponde alla query.

    Righe scansionate rispetto alle righe restituite

  4. Se si tratta di una query frequente, crea un indice composto nelle colonne Iscrizioni e PromemoriaDate. Nella console console, seleziona Indice riquadro di navigazione a sinistra, quindi fai clic su Crea indice.

  5. Inserisci la definizione di indice nella casella di testo.

    CREATE INDEX SubscribedDateDesc
    ON Migration (
      Subscribed,
      ReminderDate DESC
    )
    
  6. Per iniziare a creare il database in background, fai clic su Crea.

    Aggiornamento dello schema in corso

  7. Dopo aver creato l'indice, esegui di nuovo la query e aggiungi l'indice.

    SELECT Username,PointsEarned
      FROM Migration@{FORCE_INDEX=SubscribedDateDesc}
     WHERE Subscribed=true
       AND ReminderDate > DATE_SUB(DATE(current_timestamp()), INTERVAL 14 DAY)
     ORDER BY ReminderDate DESC
     LIMIT 10
    

    Esamina di nuovo la spiegazione della query. Nota che il numero di righe scansionate è diminuito. Le Righe restituite a ogni passaggio corrispondono al numero restituito dalla query.

    Spiegazione della query

Indici con interfoliazione

In Spanner puoi configurare indici interlacciati. Gli indici secondari discussi nella sezione precedente si trovano alla base della gerarchia di database e utilizzano gli indici come un database convenzionale. Un indice con interfoliazione si trova nel contesto della rispettiva riga con interfoliazione. Consulta le opzioni di indice per maggiori dettagli su dove applicare gli indici con interfoliazione.

Modificare il modello dei dati

Per adattare la parte della migrazione di questo tutorial alla tua situazione, modifica i file di origine di Apache Beam. È importante non modificare lo schema di origine durante la finestra di migrazione effettiva, altrimenti potresti perdere dati.

  1. Per analizzare il codice JSON in arrivo e creare mutazioni, utilizza GSON. Modifica la definizione JSON in modo che corrisponda ai dati.

    public static class Record implements Serializable {
    
      private Item Item;
    
    }
    
    public static class Item implements Serializable {
    
      private Username Username;
      private PointsEarned PointsEarned;
      private Subscribed Subscribed;
      private ReminderDate ReminderDate;
      private Zipcode Zipcode;
    
    }
    
    public static class Username implements Serializable {
    
      private String S;
    
    }
    
    public static class PointsEarned implements Serializable {
    
      private String N;
    
    }
    
    public static class Subscribed implements Serializable {
    
      private String BOOL;
    
    }
    
    public static class ReminderDate implements Serializable {
    
      private String S;
    
    }
    
    public static class Zipcode implements Serializable {
    
      private String N;
    
    }
  2. Modifica la mappatura JSON corrispondente.

    mutation.set("Username").to(record.Item.Username.S);
    
    Optional.ofNullable(record.Item.Zipcode).ifPresent(x -> {
      mutation.set("Zipcode").to(Integer.parseInt(x.N));
    });
    
    Optional.ofNullable(record.Item.Subscribed).ifPresent(x -> {
      mutation.set("Subscribed").to(Boolean.parseBoolean(x.BOOL));
    });
    
    Optional.ofNullable(record.Item.ReminderDate).ifPresent(x -> {
      mutation.set("ReminderDate").to(Date.parseDate(x.S));
    });
    
    Optional.ofNullable(record.Item.PointsEarned).ifPresent(x -> {
      mutation.set("PointsEarned").to(Integer.parseInt(x.N));
    });

Nei passaggi precedenti hai modificato il codice sorgente di Apache Beam per l'importazione collettiva. Modifica il codice sorgente della parte dello stream della pipeline in una modalità simile. Infine, regola gli script di creazione della tabella, gli schemi e gli indici del tuo database di destinazione Spanner.

Esegui la pulizia

Per evitare che al tuo account Google Cloud vengano addebitati costi relativi alle risorse utilizzate in questo tutorial, elimina il progetto che le contiene oppure mantieni il progetto ed elimina le singole risorse.

Elimina il progetto

  1. In Cloud Console, vai alla pagina Gestisci risorse.

    Vai a Gestisci risorse

  2. Nell'elenco dei progetti, seleziona il progetto da 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.

Elimina risorse AWS

Se il tuo account AWS viene utilizzato al di fuori di questo tutorial, fai attenzione quando elimini le seguenti risorse:

  1. Elimina la tabella DynamoDB chiamata Migrazione.
  2. Elimina il bucket Amazon S3 e la funzione Lambda creata durante i passaggi della migrazione.
  3. Infine, elimina l'utente AWS IAM che hai creato durante questo tutorial.

Passaggi successivi