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, a tolleranza di errore e altamente scalabile che supporta le transazioni. Se utilizzi in modo coerente le tabelle Amazon DynamoDB, 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 passare ad altri servizi NoSQL, come Datastore o Firestore.
Questo tutorial presuppone la conoscenza degli schemi di database, dei tipi di dati, delle nozioni di base di NoSQL e dei sistemi di database relazionali. Il tutorial si basa sull'esecuzione di attività predefinite per eseguire una migrazione di esempio. Dopo il tutorial, puoi modificare il codice e i passaggi forniti per adattare il 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.
- Creare ed esportare 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:
Gli addebiti di 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, che vengono ripulite alla fine. Per scenari reali, stima i requisiti di velocità effettiva e archiviazione, quindi utilizza la documentazione sulle istanze Spanner per determinare la quantità di capacità di calcolo necessaria.
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 in modo da evitare addebiti non necessari. Utilizza il Calcolatore prezzi AWS per stimare questi costi.
Per generare una stima dei costi in base all'utilizzo previsto, utilizza il Calcolatore prezzi.
Prima di iniziare
- 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.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API Spanner, Pub/Sub, Compute Engine, and Dataflow.
-
In the Google Cloud console, on the project selector page, select or create a Google Cloud project.
-
Assicurati che la fatturazione sia attivata per il tuo progetto Google Cloud.
-
Abilita le API Spanner, Pub/Sub, Compute Engine, and Dataflow.
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 dà accesso alla riga di comando in Google Cloud e include Google Cloud CLI e altri strumenti necessari per lo sviluppo in Google Cloud. L'inizializzazione di Cloud Shell può richiedere diversi minuti.
-
Nella console Google Cloud, 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.
- Imposta la zona Compute Engine predefinita. Ad esempio,
us-central1-b
. gcloud config set compute/zone us-central1-b - Clona il repository GitHub contenente il codice campione. git clone https://github.com/GoogleCloudPlatform/dynamodb-spanner-migration.git
- Vai alla directory clonata. cd dynamodb-spanner-migration
- Crea un ambiente virtuale Python. pip3 installa virtualenv virtualenv env
- Attiva l'ambiente virtuale: source env/bin/activate
- Installare i moduli Python richiesti. pip3 install -r requirements.txt
Configura l'accesso 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 test 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 AWS Lambda utilizza in un passaggio successivo del tutorial.
- Nella console AWS, vai alla sezione IAM, fai clic su Ruoli e seleziona Crea ruolo.
- In Tipo di entità attendibile, assicurati che sia selezionato Servizio AWS.
- In Caso d'uso, seleziona Lambda e poi fai clic su Avanti.
- Nella casella del filtro Criteri di autorizzazione, inserisci
AWSLambdaDynamoDBExecutionRole
e premiReturn
per eseguire la ricerca. - Seleziona la casella di controllo AWSLambdaDynamoDBExecutionRole e fai clic su Avanti.
- 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 verranno utilizzate durante il tutorial.
- Mentre ti trovi nella sezione IAM della console AWS, fai clic su Utenti e seleziona Aggiungi utenti.
- Nella casella Nome utente, inserisci
dynamodb-spanner-migration
. In Tipo di accesso, seleziona la casella di controllo a sinistra di Chiave di accesso - Accesso programmatico.
Fai clic su Successivo: Autorizzazioni.
Fai clic su Collega direttamente le norme esistenti e utilizza la casella di ricerca per filtrare seleziona la casella di controllo accanto a ognuno dei tre criteri seguenti:
AmazonDynamoDBFullAccess
AmazonS3FullAccess
AWSLambda_FullAccess
Fai clic su Successivo: Tag, quindi su Successivo: esamina, quindi fai clic su Crea utente.
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. Lascia aperta questa finestra per il momento perché sono necessarie le credenziali nella sezione seguente. Archivia queste credenziali in modo sicuro perché ti consentono di 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
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
eSECRET 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.
- Inserisci i valori
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 come vengono mappati i tipi di dati di Amazon DynamoDB 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. |
String | String |
Booleano | BOOL |
Null | Nessun tipo esplicito. Le colonne possono contenere valori nulli. |
Proprietà binaria | Bytes |
Set | Array |
Mappa ed elenco | Determina se la struttura è coerente e può essere descritta utilizzando la sintassi DDL delle tabelle. |
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 di 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 tabella Spanner. In seguito, nella sezione sulle tabelle con interleaving, crei un modello di 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 primaria. Prendi nota degli eventuali indici secondari nella tabella Amazon DynamoDB in modo da poterli creare nella tabella Spanner, che verrà trattato 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/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.
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
Verifica che lo stato della tabella sia
ACTIVE
.aws dynamodb describe-table --table-name Migration \ --query 'Table.TableStatus'
Compila la tabella con dati di esempio.
python3 make-fake-data.py --table Migration --items 25000
Creazione di un database Spanner
Puoi creare un'istanza Spanner con la capacità di calcolo più ridotta possibile: 100 unità di elaborazione. Questa capacità di calcolo è sufficiente per l'ambito di questo tutorial. Per un deployment di produzione, consulta la documentazione sulle istanze di Spanner per determinare la capacità di calcolo adeguata per soddisfare i requisiti di prestazioni del database.
In questo esempio, viene creato uno schema della tabella in contemporanea con il database. Inoltre, è comune eseguire aggiornamenti dello schema dopo aver creato il database.
Creare 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"
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.
Trasmetti modifiche in Pub/Sub
Utilizzi una funzione AWS Lambda per trasmettere le modifiche al database in Pub/Sub.
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
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].
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].
Creare un'associazione di criteri IAM in modo che l'account di servizio abbia l'autorizzazione a 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:spanner-migration@solution-z.iam.gserviceaccount.com role: roles/pubsub.publisher
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]
Prepara la funzione AWS Lambda e pacchettizzala 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
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)
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" ] }
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)
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
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
In Cloud Shell, crea una variabile per il nome di un bucket che utilizzerai in diverse delle sezioni seguenti.
BUCKET=${DEVSHELL_PROJECT_ID}-dynamodb-spanner-export
Crea un bucket Amazon S3 per ricevere l'esportazione di DynamoDB.
aws s3 mb s3://${BUCKET}
Nella console di gestione AWS, vai a DynamoDB e fai clic su Tables.
Fai clic sulla tabella
Migration
.Nella scheda Esportazioni e stream, fai clic su Esporta in S3.
Se richiesto, abilita
point-in-time-recovery
(PITR).Fai clic su Sfoglia S3 per scegliere il bucket S3 che hai creato in precedenza.
Fai clic su Esporta.
Fai clic sull'icona Aggiorna per aggiornare lo stato del job di esportazione. Il completamento dell'esportazione del job richiede alcuni minuti.
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 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
Eseguire la migrazione
Ora che la consegna Pub/Sub è attiva, puoi eseguire il push di tutte le modifiche apportate alla tabella dopo l'esportazione.
Copia la tabella esportata in Cloud Storage
In Cloud Shell, crea un bucket Cloud Storage per ricevere i file esportati da Amazon S3.
gsutil mb gs://${BUCKET}
Sincronizza i file di Amazon S3 in Cloud Storage. Per la maggior parte delle operazioni di copia, viene utilizzato il comando
rsync
. Se i file di esportazione sono di grandi dimensioni (vari 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 i dati in batch
Per scrivere i dati dai file esportati nella tabella Spanner, esegui un job Dataflow con il 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"
Per osservare l'avanzamento del job di importazione, vai a Dataflow nella console Google Cloud.
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.
Fai clic su ogni fase per vedere quanti elementi sono stati elaborati. L'importazione è completa quando tutte le fasi riportano la dicitura Riuscito. Lo stesso numero di elementi creati nella tabella Amazon DynamoDB elaborati in ogni fase.
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
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
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 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 le nuove modifiche
Una volta completato il job di importazione batch, puoi configurare un job di flussi di dati per scrivere aggiornamenti in corso dalla tabella di origine in Spanner. Puoi abbonarti agli 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.
Creare 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].
Per trasmettere in flusso le 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"
Come per il passaggio del caricamento in batch, per osservare l'avanzamento del job vai a Dataflow nella console Google Cloud.
Fai clic sul job il cui stato è In esecuzione.
Il grafico di elaborazione mostra un output simile a quello di prima, ma ogni elemento elaborato viene conteggiato nella finestra di stato. Il tempo di attesa del sistema è una stima approssimativa del ritardo previsto prima che le modifiche vengano visualizzate nella tabella di Spanner.
Il job Dataflow eseguito nella fase di caricamento batch era un insieme infinito di input, noto anche come set di dati delimitato. Questo job Dataflow utilizza Pub/Sub come origine di flusso ed è considerato illimitato. Per ulteriori informazioni su questi due tipi di fonti, consulta la sezione sulle PCollection nella guida alla programmazione di Apache Beam. Il job Dataflow in questo passaggio deve rimanere attivo, in modo che non venga interrotto al termine. Il job Dataflow in modalità flusso rimane nello stato Running anziché nello stato Riuscito.
Verifica replica
Apporta alcune modifiche alla tabella di origine per verificare che le modifiche vengano replicate alla tabella Spanner.
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.
Crea un record in Amazon DynamoDB con la stessa chiave che hai utilizzato nella query di 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}}'
Esegui di nuovo la stessa query per verificare che la riga si trovi 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:
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 } } }
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 viene visualizzato come segue:
Username PointsEarned ReminderDate Subscribed Zipcode my-test-username 4500 None True
Elimina l'elemento di test dalla tabella di origine Amazon DynamoDB.
aws dynamodb delete-item \ --table-name Migration \ --key '{"Username": {"S":"my-test-username"}}'
Verifica che la riga corrispondente venga eliminata dalla tabella di 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 interleaving
Spanner supporta il concetto di tabelle interfolianti. Si tratta di un modello di progettazione in cui un elemento di primo livello ha diversi elementi nidificati correlati a quell'elemento, ad esempio un cliente e i suoi ordini o un giocatore e i 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 tabella con interfoliazione come mostrato nel diagramma seguente. Questa struttura consente di eseguire query sulla tabella con interfoliazione durante l'unione dei campi nella tabella padre.
Applica indici secondari
Una best practice consiste nell'applicare indici secondari alle tabelle Spanner dopo aver caricato i dati. Ora che la replica funziona, puoi configurare un indice secondario per velocizzare le query. Come le tabelle Spanner, gli indici secondari di Spanner sono completamente coerenti. Non a coerenza finale, che è 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, dato un determinato valore di colonna. Questa è una query comune in Amazon DynamoDB per l'efficienza del database.
Vai a Spanner.
Fai clic su Spanner Studio.
Nel campo Query, inserisci la seguente query, quindi 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 differenze tra Righe analizzate e Righe restituite. Senza un indice, Spanner analizza l'intera tabella per restituire un piccolo sottoinsieme di dati che corrispondono alla query.
Se si tratta di una query frequente, crea un indice composto nelle colonne Subscribed e TasksDate. Nella console di Spanner, seleziona il riquadro di navigazione a sinistra Indici, quindi fai clic su Crea indice.
Inserisci la definizione dell'indice nella casella di testo.
CREATE INDEX SubscribedDateDesc ON Migration ( Subscribed, ReminderDate DESC )
Per iniziare a creare il database in background, fai clic su Crea.
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. Il valore Righe restituite in 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 si trovano alla base della gerarchia del database e utilizzano gli indici allo stesso modo di un database convenzionale. Un indice con interleaving è nel contesto della sua riga con interleaving. Consulta le opzioni di indice per ulteriori dettagli su dove applicare gli indici con interleaving.
Adattare il modello dei dati
Per adattare la parte di questo tutorial sulla migrazione al tuo caso, modifica i file di origine Apache Beam. È importante non modificare lo schema di origine durante l'attuale finestra di migrazione, altrimenti potresti perdere dati.
Per analizzare il file JSON in entrata e le mutazioni della build, utilizza GSON. Modifica la definizione JSON in modo che corrisponda ai tuoi dati.
Modifica il mapping JSON corrispondente.
Nei passaggi precedenti, hai modificato il codice sorgente di 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, gli schemi e gli indici di creazione delle tabelle del database di destinazione di 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
- Nella console Google Cloud, vai alla pagina Gestisci risorse.
- Nell'elenco dei progetti, seleziona il progetto che vuoi eliminare, quindi fai clic su Elimina.
- 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, presta attenzione quando elimini le seguenti risorse:
- Elimina la tabella DynamoDB denominata Migrazione.
- Elimina il bucket Amazon S3 e la funzione Lambda che hai creato durante la procedura di migrazione.
- Infine, elimina l'utente IAM AWS che hai creato durante questo tutorial.
Passaggi successivi
- Scopri come ottimizzare lo schema Spanner.
- Scopri come utilizzare Dataflow per situazioni più complesse.