Esegui la 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, un sistema di database SQL completamente relazionale, tollerante ai guasti e altamente scalabile che supporta le transazioni. Se hai una disponibilità di servizio Amazon coerente Utilizzo della tabella DynamoDB, in termini di tipi e layout, mappatura a Spanner è semplice. Se le tue tabelle Amazon DynamoDB contengono tipi e valori di dati arbitrari, potrebbe essere più semplice passare ad altri servizi NoSQL, come Datastore o Firestore.

Questo tutorial presuppone che tu abbia familiarità con gli schemi, i tipi di dati e le basi di NoSQL e dei sistemi di database relazionale. Il tutorial si basa sull'esecuzione di attività predefinite per una migrazione di esempio. Al termine del tutorial, puoi modificare il codice e i passaggi forniti per adattarli al tuo ambiente.

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

Obiettivi

• Esegui la migrazione dei dati da Amazon DynamoDB a Spanner.
• Crea 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 dati tra Amazon S3 e Cloud Storage.
• Usa Dataflow per caricare i dati in Spanner.

Costi

Questo tutorial utilizza i seguenti componenti fatturabili di Google Cloud:

• Pub/Sub
• Cloud Storage
• Dataflow

I costi di Spanner si basano sulla quantità di capacità di calcolo in dell'istanza e la quantità di dati archiviati durante il ciclo di fatturazione mensile. Durante il tutorial, utilizzerai una configurazione minima di queste risorse, che sono ripulito alla fine. Per gli scenari reali, stima i requisiti di throughput e spazio di archiviazione, quindi utilizza la documentazione delle istanze 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 la procedura di migrazione. Alla fine segui le istruzioni per eseguire la pulizia di tutte le risorse ed evitare inutili. Utilizza il Calcolatore prezzi di AWS per stimare questi costi.

Per generare una stima dei costi in base all'utilizzo previsto, utilizza i prezzi calcolatrice.

Prima di iniziare

1. Sign in to your Google Cloud account. If you're new to Google Cloud, create an account to evaluate how our products perform in real-world scenarios. New customers also get $300 in free credits to run, test, and deploy workloads.

2. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

3. Make sure that billing is enabled for your Google Cloud project.

4. Enable the Spanner, Pub/Sub, Compute Engine, and Dataflow APIs.

   Enable the APIs

5. In the Google Cloud console, on the project selector page, select or create a Google Cloud project.

   Note: If you don't plan to keep the resources that you create in this procedure, create a project instead of selecting an existing project. After you finish these steps, you can delete the project, removing all resources associated with the project.

   Go to project selector

6. Make sure that billing is enabled for your Google Cloud project.

7. Enable the Spanner, Pub/Sub, Compute Engine, and Dataflow APIs.

   Enable the APIs

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 i comandi in Cloud Shell. Cloud Shell ti consente di accedere alla riga di comando in Google Cloud e include Google Cloud CLI e altri strumenti necessari per lo sviluppo su Google Cloud. L'inizializzazione di Cloud Shell può richiedere diversi minuti.

1. In the Google Cloud console, activate Cloud Shell.

   Activate Cloud Shell

   At the bottom of the Google Cloud console, a Cloud Shell session starts and displays a command-line prompt. Cloud Shell is a shell environment with the Google Cloud CLI already installed and with values already set for your current project. It can take a few seconds for the session to initialize.

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. Installare i moduli Python richiesti. pip3 install -r requirements.txt

Configura l'accesso AWS

In questo tutorial crei ed elimini tabelle Amazon DynamoDB, bucket Amazon S3 e altre risorse. Per accedere a queste risorse, devi prima creare le autorizzazioni IAM (Identity and Access Management) di AWS necessarie. Puoi usare un account AWS di prova o sandbox per evitare problemi nello stesso account risorse di produzione.

Crea un ruolo AWS IAM per AWS Lambda

In questa sezione creerai un ruolo AWS IAM che AWS Lambda utilizzerà in un passaggio successivo. nel tutorial.

1. Nella console AWS, vai alla sezione IAM, fai clic su Ruoli e poi seleziona Crea ruolo.
2. In Tipo di entità attendibile, assicurati che sia selezionato Servizio AWS.
3. In Caso d'uso, seleziona Lambda e poi fai clic su Avanti.
4. Nella casella di filtro Norme relative alle autorizzazioni, inserisci AWSLambdaDynamoDBExecutionRole e premi Return per eseguire la ricerca.
5. Seleziona la casella di controllo AWSLambdaDynamoDBExecutionRole e poi fai clic su Avanti.
6. Nella casella Nome ruolo, inserisci dynamodb-spanner-lambda-role e poi fai clic su Crea ruolo.

Creare 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 ti trovi nella sezione IAM della console AWS, fai clic su Utenti, quindi 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 Access key - Accesso programmatico.

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

4. Fai clic su Successivo: autorizzazioni.

5. Fai clic su Collega direttamente i criteri esistenti e utilizza la casella Cerca per filtrare. seleziona la casella di controllo accanto a ognuna delle seguenti tre norme:

   • AmazonDynamoDBFullAccess
   • AmazonS3FullAccess
   • AWSLambda_FullAccess

6. Fai clic su Successivo: Tag, quindi su Successivo: esamina, quindi fai clic su Crea utente.

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

Configura l'interfaccia a riga di comando 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 ACCESS KEY ID e SECRET ACCESS KEY dall'account IAM AWS 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 sezione seguente 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 tabella seguente descrive come 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'uso previsto, potrebbe essere mappato a INT64, FLOAT64, TIMESTAMP o DATE.
Stringa	Stringa
Booleano	BOOL
Null	Nessun tipo esplicito. Le colonne possono contenere valori null.
Binario	Byte
Set	Array
Mappa ed elenco	Stabilisci se la struttura è coerente e può essere descritta utilizzando una tabella Sintassi DDL.

Chiave primaria

Una chiave primaria Amazon DynamoDB stabilisce l'univocità e può essere una chiave hash o una combinazione di una chiave hash più una chiave intervallo. Questo tutorial inizia mostrando la migrazione di una tabella Amazon DynamoDB la cui chiave primaria è una chiave hash. Questa chiave hash diventa la chiave primaria della tua tabella Spanner. In seguito, nella sezione sulle tabelle interlacciate, modella 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 chiave non primaria. Prendi nota di eventuali indici secondari nella tua Amazon DynamoDB in modo da poterli creare nella tabella Spanner, ed è trattato in più avanti 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/a
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 utilizza tabella di esempio attributi.

   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. Compila la tabella con dati di esempio.

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

   Nota: se viene creato un numero leggermente inferiore a quello richiesto, puoi ignorare la discrepanza. Se i record sono duplicati, potrebbero essere creati meno record sono stati generati nomi utente di esempio.

Creazione di un database Spanner

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

In questo esempio, crei uno schema di tabella contemporaneamente al database. it è anche possibile, e comune, effettuare aggiornamenti dello schema dopo aver creato il database.

Nota: sia Amazon DynamoDB sia Spanner supportano l'uso di indici secondari. Le best practice per il caricamento collettivo di Spanner consigliano di creare indici secondari dopo aver caricato i dati iniziali. Configura un indice secondario più avanti in questo tutorial.

1. Crea un'istanza Spanner nella stessa regione in cui hai impostato 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. Crea un database nell'istanza Spanner insieme a la 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 imposta la replica Pub/Sub per acquisire eventuali modifiche al database che si verificano durante l'esportazione.

Nota: se le modifiche al database non vengono idempotente e non è sicuro scrivere gli stessi dati più di una volta, è meglio eseguire i seguenti passaggi durante un periodo di manutenzione in cui puoi mettere in pausa le modifiche alle app alla tabella.

Trasmetti modifiche in Pub/Sub

Usi una funzione AWS Lambda per trasmettere in flusso le modifiche al database in 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 inviare gli aggiornamenti della tabella 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. Creare un'associazione di criteri IAM in modo che l'account di servizio dispone 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 la funzione AWS Lambda e pacchettizzala per eseguire il push della tabella Amazon DynamoDB modifiche apportate 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 risorsa Amazon (ARN) di Lambda ruolo di esecuzione 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. Create a variable to capture the ARN of the Amazon DynamoDB stream for your table.

   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 alla fine del comando precedente, che attiva la funzione ogni volta creare, aggiornare o eliminare 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 molte delle sezioni seguenti.

   BUCKET=${DEVSHELL_PROJECT_ID}-dynamodb-spanner-export
   

2. Crea un bucket Amazon S3 per ricevere l'esportazione di DynamoDB.

   aws s3 mb s3://${BUCKET}
   

3. Nella 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, abilita point-in-time-recovery (PITR).

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

8. Fai clic su Esporta.

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

   Al termine del processo, esamina il bucket di output.

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

   Questo passaggio richiede 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 il caricamento Pub/Sub è stato eseguito, puoi inoltrare eventuali modifiche alle tabelle avvenute dopo l'esportazione.

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

Copia la tabella esportata in Cloud Storage

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

   gcloud storage buckets create 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 Cloud Storage per gestire il trasferimento in background.

   gcloud storage rsync s3://${BUCKET} gs://${BUCKET} --recursive --delete-unmatched-destination-objects
   

Importa i dati in batch

1. Per scrivere i dati dai file esportati nell'istanza Spanner, esegui un job Dataflow con un esempio del codice Apache Beam.

   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 monitorare l'avanzamento del job di importazione, vai a Dataflow nella console Google Cloud.

      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.

      

2. Fai clic su ogni fase per vedere quanti elementi sono stati elaborati. L'importazione è completata quando tutte le fasi indicano Riuscito. Lo stesso numero di elementi creati nella tabella Amazon DynamoDB viene visualizzato come elaborato in ogni 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 sui metadati della tabella 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 Spanner si basa su una query 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 voci casuali in ogni tabella per garantire la coerenza dei dati.

   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 per i dati campione per configurare un 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
           }
       }
   }
   

Replicare le nuove modifiche

Una volta completato il job di importazione batch, devi configurare un job in modalità flusso per scrivere e in corso gli aggiornamenti in corso dalla tabella di origine in Spanner. Abbonati agli eventi di Pub/Sub e scrivili in Spanner

La funzione Lambda che hai creato è configurata per acquisire le modifiche all'origine la tabella Amazon DynamoDB e pubblicale in Pub/Sub.

1. crea una sottoscrizione all'argomento Pub/Sub che AWS Lambda a cui 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 eseguire lo streaming delle modifiche in arrivo 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"
   

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

   1. Come per il passaggio caricamento batch, per monitorare l'avanzamento del job, vai a Dataflow nella console Google Cloud.

      Vai a Dataflow

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

      

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

      

Il job Dataflow eseguito nella fase di caricamento batch è stato insieme finito di input, noto anche come set di dati delimitato. Questo Il job Dataflow utilizza Pub/Sub come origine di flusso e è considerata illimitata. Per ulteriori informazioni su questi due tipi di fonti, consulta la sezione su PCollection Guida alla programmazione di Apache Beam. Il job Dataflow in questo passaggio deve rimanere attivo, quindi non termina al termine. Job Dataflow in modalità flusso rimane nello stato In esecuzione anziché nello stato Riuscito.

Verifica replica

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

Nota: le modifiche sono asincrone e la loro visualizzazione 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, come 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 Amazon DynamoDB tabella.

   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 vengano propagate a Spanner tabella.

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

   L'output è 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 Spanner. Quando la modifica viene propagata, viene applicato quanto segue il 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 interleaving

Spanner supporta il concetto di tabelle interlacciate. Si tratta di un modello di progettazione in cui un elemento di primo livello ha diversi elementi nidificati che riguardano quell'elemento di primo livello, come un cliente e i suoi ordini, o un player e i punteggi delle loro partite. 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 interlacciata come mostrato nel seguente diagramma. Questa struttura consente di eseguire una query sulla tabella con interleaving durante l'unione dei campi nella tabella padre.

Applicare 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 ulteriori informazioni, consulta Gestire i dati utilizzando la console Google Cloud.

È una best practice applicare gli indici secondari alle tabelle Spanner dopo aver caricato i dati. Ora che la replica funziona, puoi configurare indice secondario per velocizzare le query. Come le tabelle Spanner, gli indici secondari di Spanner sono completamente coerenti. Non sono a coerenza finale, che è comune in molti database NoSQL. Questa funzionalità può aiutarti a semplificare il design dell'app

Esegui una query che non utilizza indici. Stai cercando i primi N di occorrenze, dato un particolare valore di colonna. Questa è una query comune in Amazon DynamoDB per l'efficienza dei database.

1. Vai a Spanner.

   Vai a Spanner

2. Fai clic su Spanner Studio.

   

3. Nel campo Query, inserisci la seguente query e poi 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 delle Righe analizzate rispetto alle Righe restituite. Senza un indice, Spanner analizza 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 composito sulle colonne Iscritto e DataRicordo. Il giorno Nella console Spanner, seleziona il riquadro di navigazione Indici a sinistra, 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. Le Righe restituite in ogni passaggio corrispondono il numero restituito dalla query.

   

Indici interlacciati

Puoi configurare gli indici con interleaving in Spanner. Secondaria degli indici trattati nell'ambito sezione precedente si trovano alla radice della gerarchia del database e usano gli indici allo stesso modo un database convenzionale. Un indice interlacciato si trova nel contesto della sua riga interlacciata. Consulta: opzioni indice per maggiori dettagli su dove applicare gli indici con interleaving.

Adattare il modello di dati

Per adattare la parte di questo tutorial sulla migrazione alla tua situazione, modificare i file sorgente Apache Beam. È importante non modificare dello schema di origine durante l'attuale finestra di migrazione, altrimenti potresti perdere dati.

1. Per analizzare il file JSON in entrata e le mutazioni della build, usa 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 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 per la parte di streaming della pipeline in modo simile. Infine, modifica gli script, gli schemi e gli indici di creazione delle tabelle Database Spanner di destinazione.

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à descritte in questo documento, quando lo elimini elimini anche tutto il 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 appspot.com URL, elimina le risorse selezionate all'interno del progetto anziché eliminare l'intero progetto.
1. In the Google Cloud console, go to the Manage resources page.

   Go to Manage resources

2. In the project list, select the project that you want to delete, and then click Delete.
3. In the dialog, type the project ID, and then click Shut down to delete the project.

Eliminare le risorse AWS

Se il tuo account AWS viene utilizzato al di fuori di questo tutorial, procedi con cautela quando elimini le seguenti risorse:

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

Passaggi successivi

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