Migrazione da DynamoDB a Spanner

Questo tutorial descrive come eseguire la migrazione da Amazon DynamoDB a Spanner. È destinato principalmente ai proprietari di app che vogliono passare da un sistema NoSQL a Spanner a Spanner, un sistema di database SQL completamente relazionale, a tolleranza di errore e ad alta scalabilità che supporta le transazioni. Se utilizzi le tabelle Amazon DynamoDB coerenti, in termini di tipi e layout, la mappatura a Spanner è semplice. Se le tabelle Amazon DynamoDB contengono tipi di dati e valori arbitrari, potrebbe essere più semplice eseguire lo spostamento ad altri servizi NoSQL, ad esempio Datastore o Firestore.

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. Il tutorial si basa sull'esecuzione di attività predefinite per eseguire una migrazione di esempio. Dopo il tutorial, potrai modificare il codice e i passaggi forniti in modo che corrisponda al tuo ambiente.

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

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.
• Trasferimento di dati tra Amazon S3 e Cloud Storage.
• Utilizza Dataflow per caricare dati in Spanner.

Costi

Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:

• Pub/Sub
• Cloud Storage
• Dataflow

Gli addebiti per Spanner si basano sulla quantità di capacità di calcolo nell'istanza e sulla quantità di dati archiviati durante il ciclo di fatturazione mensile. Durante il tutorial, utilizzerai una configurazione minima di queste risorse, ripulite alla fine. Per scenari reali, stima i requisiti di velocità effettiva e archiviazione, poi utilizza la documentazione sulle istanze di Spanner per determinare la quantità di capacità di calcolo di cui hai bisogno.

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

• AWS Lambda
• Amazon S3
• Amazon DynamoDB

Questi servizi sono necessari solo durante il processo di migrazione. Al termine del tutorial, segui le istruzioni per eseguire la pulizia di tutte le risorse ed evitare addebiti non necessari. Utilizza il Calcolatore prezzi di AWS per una stima di questi costi.

Per generare una stima dei costi in base all'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 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

3. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

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

   Abilita le API

5. 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

6. Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.

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

   Abilita le API

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.

prepara l'ambiente

In questo tutorial eseguirai comandi in Cloud Shell. Cloud Shell ti dà accesso alla riga di comando in Google Cloud e include Google Cloud CLI e altri strumenti di cui hai bisogno per lo sviluppo in Google Cloud. L'inizializzazione di Cloud Shell può richiedere diversi minuti.

1. Nella console Google Cloud, attiva Cloud Shell.

   Attiva Cloud Shell

   Nella parte inferiore della console Google Cloud viene avviata una sessione di Cloud Shell che mostra un prompt della riga di comando. Cloud Shell è un ambiente shell con Google Cloud CLI già installato e con valori già impostati per il progetto attuale. L'inizializzazione della sessione può richiedere alcuni secondi.

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

   <pre class="devsite-click-to-copy">
   gcloud config set compute/zone us-central1-b
   </pre></li>
   

3. Clonare il repository GitHub contenente il codice campione.

   <pre class="devsite-click-to-copy">
   git clone https://github.com/GoogleCloudPlatform/dynamodb-spanner-migration.git
   </pre></li>
   

4. Vai alla directory clonata.

   <pre class="devsite-click-to-copy">
   cd dynamodb-spanner-migration
   </pre></li>
   

5. Crea un ambiente virtuale Python.

   <pre class="devsite-click-to-copy">
   pip3 install virtualenv
   virtualenv env
   </pre></li>
   

6. Attiva l'ambiente virtuale:

   <pre class="devsite-click-to-copy">
   source env/bin/activate
   </pre></li>
   

7. Installa i moduli Python richiesti.

   <pre class="devsite-click-to-copy">
   pip3 install -r requirements.txt
   </pre></li>
   

Configura l'accesso AWS

In questo tutorial, creerai ed elimini 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) necessarie. Puoi utilizzare un account AWS di test o sandbox per evitare di influire sulle risorse di produzione nello stesso account.

Crea un ruolo AWS IAM per AWS Lambda

In questa sezione creerai un ruolo AWS IAM che AWS Lambda utilizza 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 Servizio AWS.
3. In Caso d'uso, seleziona Lambda e fai clic su Avanti.
4. Nella casella di filtro Criteri di autorizzazione, inserisci AWSLambdaDynamoDBExecutionRole e premi Return per cercare.
5. Seleziona la casella di controllo AWSLambdaDynamoDBExecutionRole e 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 utilizzate durante il tutorial.

1. 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.

   Nota: non abilitare l'accesso alla console di gestione, poiché non utilizzerai questo utente IAM per accedere alla console.

4. Fai clic su Successivo: Autorizzazioni.

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

   • AmazonDynamoDBFullAccess
   • AmazonS3FullAccess
   • AWSLambda_FullAccess

6. Fai clic su Avanti: tag e Successivo: esamina, quindi fai clic su Crea utente.

7. Fai clic su Mostra per visualizzare le credenziali. L'ID della chiave di accesso e la chiave di accesso del secret vengono visualizzati per l'utente appena creato. Per il momento lascia questa finestra aperta perché sono necessarie le credenziali nella sezione seguente. Archivia queste credenziali in modo sicuro perché, con esse, puoi apportare modifiche al tuo account e influire sull'ambiente. Al termine di questo tutorial potrai eliminare l'utente IAM.

Configura l'interfaccia a riga di comando AWS

1. In Cloud Shell, configura l'interfaccia a riga di comando (CLI) 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 ACCESS KEY ID e SECRET ACCESS KEY dell'account AWS IAM che hai creato.
   • Nel campo Nome regione predefinito, inserisci us-west-2. Lascia invariati i valori predefiniti degli altri campi.

2. Chiudi la finestra della console AWS IAM.

Comprendere il modello dei dati

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

Tipi di dati

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

Amazon DynamoDB	Spanner
Numero	A seconda della precisione o dell'utilizzo previsto, potrebbe essere mappato a INT64, FLOAT64, TIMESTAMP o DATE.
Stringa	Stringa
Booleano	BOOL
Null	Nessun tipo esplicito. Le colonne possono contenere valori nulli.
Programma binario	Byte
Set	Array
Mappa ed elenco	Stabilisci se la struttura è coerente e può essere descritta utilizzando la sintassi DDL delle tabelle.

Chiave primaria

Una chiave primaria Amazon DynamoDB stabilisce l'unicità e può essere una chiave hash o una combinazione di una chiave hash e una chiave di intervallo. Questo tutorial inizia dimostrando la migrazione di una tabella Amazon DynamoDB la cui chiave primaria è una chiave hash. Questa chiave hash diventa la chiave primaria della tabella Spanner. Più avanti, nella sezione sulle tabelle con interleaving, modellerai 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 chiave non principale. Prendi nota di eventuali indici secondari nella tabella Amazon DynamoDB per poterli creare nella tabella Spanner, di cui parleremo in una sezione successiva di questo tutorial.

Tabella di esempio

Per facilitare 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, creerai una tabella di origine Amazon DynamoDB e la completerai con i dati.

1. In Cloud Shell, crea una tabella Amazon DynamoDB che utilizzi 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 dati di esempio.

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

   Nota: se vengono creati record leggermente inferiori al numero di record richiesti, puoi ignorare la discrepanza. Se sono stati generati nomi utente di esempio duplicati, potrebbero essere creati meno record.

Creazione di un database Spanner

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

In questo esempio, creerai uno schema della tabella contemporaneamente al database. Inoltre, è possibile eseguire aggiornamenti dello schema dopo aver creato il database.

Nota: Amazon DynamoDB e Spanner supportano l'utilizzo di indici secondari. Le best practice per il caricamento collettivo consigliamo di creare indici secondari dopo il caricamento dei dati iniziali. Potrai configurare un indice secondario più avanti in questo tutorial.

1. Creare un'istanza Spanner nella stessa regione in cui imposti la zona Compute Engine predefinita. Ad esempio, us-central1.

   gcloud beta spanner instances create spanner-migration \
       --config=regional-us-central1 --processing-units=100 \
       --description="Migration Demo"
   

2. Creare un database nell'istanza 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)"
   

Prepara la migrazione

Le sezioni successive 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.

Nota: se le modifiche al database non sono idempotenti e non è sicuro scrivere gli stessi dati più di una volta, ti consigliamo di eseguire i passaggi seguenti durante un periodo di manutenzione, quando puoi mettere in pausa le modifiche apportate all'app alla tabella.

Trasmetti le 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. Creare 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. Creando un'associazione di criteri IAM in modo che l'account di servizio disponga dell'autorizzazione per pubblicare in 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:[e-mail]
     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 [[e-mail]]
   

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 l'Amazon Resource Name (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 dello stream 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 i test, aggiungi --batch-size 1 alla fine del comando precedente, che attiva la funzione ogni volta che crei, aggiorni o elimini un elemento.

    Verrà visualizzato 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 da utilizzare in diverse delle 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, 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 job richiede diversi minuti per completare l'esportazione.

   Al termine del processo, osserva il bucket di output.

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

   Questo passaggio richiede circa 5 minuti. Al termine, verrà visualizzato un output come il 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
   

Esegui la migrazione

Ora che la distribuzione Pub/Sub è attiva, puoi posticipare le modifiche apportate alla tabella dopo l'esportazione.

Nota: se hai messo in pausa le scritture sul database prima dell'esportazione, è il momento di riattivare le scritture nel database.

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 a Cloud Storage. Per la maggior parte delle operazioni di copia, è efficace il comando rsync. 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}
   

Importa in gruppo i dati

1. Per scrivere nella tabella Spanner i dati dei file esportati, esegui un job Dataflow con codice Apache Beam 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 osservare l'avanzamento del job di importazione, vai a Dataflow nella console Google Cloud.

      Vai a Dataflow

   2. Mentre il job è in esecuzione, puoi osservare il grafico di esecuzione per esaminare i log. Fai clic sul job che mostra lo stato In esecuzione.

      

2. Fai clic su ogni fase per vedere quanti elementi sono stati elaborati. L'importazione è completata quando tutte le fasi indicano Riuscito. Viene visualizzato lo stesso numero di elementi creati nella tabella Amazon DynamoDB come elaborati in ciascuna fase.

   

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"
   

   Nota: poiché il conteggio degli elementi di Amazon DynamoDB si basa su metadati della tabella che vengono aggiornati solo ogni sei ore, l'output di questo comando potrebbe non riflettere immediatamente il numero totale di elementi nella tabella. Il conteggio degli elementi di Spanner si basa su una query di tabella e riflette con precisione il numero di righe nella tabella quando esegui la query.

   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. Campiona le voci casuali 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 nella tabella Amazon DynamoDB con lo stesso Username restituito dalla query Spanner nel passaggio precedente. Ad esempio, aallen2538. Il valore è specifico per i dati campione 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 le nuove modifiche

Quando il job di importazione batch è completo, configuri un job di inserimento flussi per scrivere gli aggiornamenti continui dalla tabella di origine in Spanner. Puoi sottoscrivere gli eventi da Pub/Sub e scriverli in Spanner

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

1. Creare una sottoscrizione all'argomento Pub/Sub a cui AWS Lambda invia 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 trasmettere il flusso delle modifiche in arrivo in Pub/Sub per 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"
   

   Nota: per migliorare la reattività durante il test, puoi impostare Windowing su 5 secondi aggiungendo --window 5 alla fine di questo comando. Il valore predefinito è impostato su 60 secondi.

   1. Analogamente al passaggio per il caricamento in batch, per osservare l'avanzamento del job vai a Dataflow nella console Google Cloud.

      Vai a Dataflow

   2. Fai clic sul job che ha lo stato In esecuzione.

      

      Il grafico dell'elaborazione mostra un output simile a prima, ma ogni elemento elaborato viene conteggiato nella finestra di stato. Il tempo di attesa di sistema è una stima approssimativa del ritardo previsto prima che le modifiche vengano visualizzate nella tabella Spanner.

      

Il job Dataflow che eseguivi nella fase di caricamento batch era un insieme finito di input, chiamato anche set di dati limitato. Questo job Dataflow utilizza Pub/Sub come origine di inserimento di flussi ed è considerato senza limitazioni. Per ulteriori informazioni su questi due tipi di origini, consulta la sezione sulle PCollection della guida alla programmazione di Apache Beam. Il job Dataflow in questo passaggio deve rimanere attivo, quindi non termina una volta completato. Il job Dataflow rimane nello stato In esecuzione, anziché Riuscito.

Verifica replica

Apporta alcune modifiche alla tabella di origine per verificare che siano replicate nella tabella Spanner.

Nota: le modifiche sono asincrone e potrebbero essere necessari diversi secondi prima che vengano visualizzate in Spanner. Attendi qualche minuto prima di ogni passaggio.

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à alcun risultato.

2. Crea un record in Amazon DynamoDB con la stessa chiave utilizzata nella query Spanner. Se il comando viene eseguito correttamente, non viene restituito alcun 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
   

   Verrà visualizzato un output simile al seguente:

   {
       "Attributes": {
           "Username": {
               "S": "my-test-username"
           },
           "PointsEarned": {
               "N": "4500"
           },
           "Subscribed": {
               "BOOL": true
           }
       }
   }
   

5. Verifica che le modifiche vengano propagate alla tabella Spanner.

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

   L'output sarà il seguente:

   Username          PointsEarned  ReminderDate  Subscribed  Zipcode
   my-test-username  4500          None          True
   

6. Elimina l'elemento di test dalla tabella di origine Amazon DynamoDB.

   aws dynamodb delete-item \
       --table-name Migration \
       --key '{"Username": {"S":"my-test-username"}}'
   

7. Verifica che la riga corrispondente venga 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'"
   

Utilizzare tabelle con interleaving

Spanner supporta il concetto di interleaving. Si tratta di un modello di progettazione in cui un elemento di primo livello ha diversi elementi nidificati correlati all'elemento di primo livello, come un cliente e i suoi ordini o un giocatore e i suoi punteggi di gioco. 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 tabella con interleaving come mostrato nel seguente diagramma. Questa struttura consente di eseguire query sulla tabella con interleaving in modo efficiente unendo i campi nella tabella padre.

Applica indici secondari

Nota: Spanner Studio (precedentemente etichettato come Query nella console Google Cloud) supporta le operazioni SQL, DML e DDL in un unico editor. Per maggiori informazioni, consulta Gestire i dati utilizzando la console Google Cloud.

Come best practice, applicare indici secondari alle tabelle Spanner dopo aver caricato i dati. Ora che la replica funziona, devi configurare un indice secondario per velocizzare le query. Come le tabelle Spanner, gli indici secondari di Spanner sono completamente coerenti. Non sono infine coerenti, cosa comune in molti database NoSQL. Questa funzionalità può aiutarti a semplificare la progettazione dell'app

Esegui una query che non utilizza indici. Stai cercando le prime N occorrenze, in base a un determinato valore di colonna. Questa è una query comune in Amazon DynamoDB per l'efficienza del database.

1. Vai a Spanner.

   Vai a Spanner

2. Fai clic su Spanner Studio.

   

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 l'esecuzione della query, fai clic su Spiegazione e prendi nota del confronto tra Righe analizzate e Righe restituite. Senza un indice, Spanner scansiona l'intera tabella per restituire un piccolo sottoinsieme di dati che corrisponde alla query.

   

4. Se si tratta di una query che si verifica di frequente, crea un indice composto nelle colonne Subscribed eReminderDate. Nella console di Spanner, seleziona il riquadro di navigazione sinistro Indici e fai clic su Crea indice.

5. Inserisci la definizione dell'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.

   

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. Tieni presente che il numero di Righe analizzate è diminuito. Il valore delle Righe restituite ad ogni passaggio corrisponde al numero restituito dalla query.

   

Indici con interleaving

Puoi configurare indici con interleaving in Spanner. Gli indici secondari discussi nella sezione precedente sono alla base della gerarchia del database e utilizzano gli indici come un database convenzionale. Un indice con interleaving si trova nel contesto della sua riga con interleaving. Consulta le opzioni indice per ulteriori dettagli su dove applicare gli indici con interleaving.

Modifica per il tuo modello dei dati

Per adattare la parte di questo tutorial sulla migrazione alla tua situazione, modifica i file di origine 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 entrata e le mutazioni della build, utilizza GSON. Modifica la definizione JSON in modo che corrisponda ai tuoi 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 il mapping 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 Apache Beam per l'importazione collettiva. Modifica il codice sorgente per la parte in modalità flusso della pipeline in modo simile. Infine, modifica gli script di creazione delle tabelle, gli schemi e gli indici del 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 contiene le risorse oppure mantieni il progetto ed elimina 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.

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 denominata Migrazione.
2. Elimina il bucket Amazon S3 e la funzione Lambda che hai creato durante la procedura di migrazione.
3. Infine, elimina l'utente AWS IAM che hai creato durante questo tutorial.

Passaggi successivi

• Scopri come ottimizzare lo schema Spanner.
• Scopri come utilizzare Dataflow per situazioni più complesse.