Da DynamoDB a Redshift: tre metodi per migrare i dati

Prerequisiti e configurazione

Questo tutorial presuppone che i partecipanti abbiano quanto segue:

• Esperienza pregressa con AWS e altri strumenti e tecniche correlate. 
• Una conoscenza di base di database relazionali e NoSQL. 
• Familiarità con SQL.
• Conoscere almeno un linguaggio di programmazione è utile.

I metodi di migrazione dei dati includeranno alcuni servizi AWS principali, tra cui:

• Identity and Access Management (IAM)
• DynamoDB
• Redshift
• S3
• Glue
• Lambda

Il corso AWS Cloud Technology and Services può aiutarti a iniziare se sei alle prime armi con AWS.

La maggior parte della procedura verrà eseguita dalla console di gestione AWS. Tuttavia, i passaggi trattati nel tutorial possono essere eseguiti anche con la command line interface (CLI) di AWS o con un software development kit (SDK) AWS. Puoi eseguire la migrazione dei dati nell’ambiente di lavoro che preferisci.

Preparare DynamoDB per la migrazione dei dati

Quando ci si prepara a una migrazione dei dati, è importante considerare i componenti delle tabelle DynamoDB e come differiscono da quelli dei database relazionali:

• I mattoni fondamentali delle tabelle DynamoDB sono gli item (simili alle righe nei database relazionali). 
• Gli item contengono uno o più attributi, ciascuno dei quali rappresenta un elemento di dato. 
• Come le tabelle relazionali, le tabelle DynamoDB hanno chiavi primarie, che fungono da identificatori univoci per ogni item. Una chiave primaria può consistere in una singola partition key o in una combinazione di partition key e sort key.
• Una caratteristica chiave delle tabelle DynamoDB è che sono schemaless, cioè ogni item può avere attributi unici.

Il tutorial utilizzerà una semplice tabella Products per dimostrare la migrazione dei dati. Di seguito i dati in formato JSON: 

	{
    	"product_id": "P001",
    	"category": "Electronics",
    	"price": 700,
    	"product_name": "Phone"
	},
	{
    	"product_id": "P002",
    	"category": "Electronics",
    	"description": "The laptop is a Macbook.",
    	"price": 1000,
    	"product_name": "Laptop"
	}Offerto da

Ci sono due aspetti importanti da notare:

• Il product_id fungerà da chiave primaria.
• Gli attributi nei due item non sono uguali, poiché al primo item manca l’attributo description.

Questi dati vengono aggiunti a una tabella in DynamoDB come parte della configurazione.

Elementi della tabella DynamoDB. Immagine dell’autore

Configurare Amazon Redshift

Il passo successivo è configurare una tabella in Redshift che riceverà i dati della tabella DynamoDB. 

1. Vai alla console Redshift e seleziona “Create cluster”.

AWS consente di definire vari parametri prima di avviare il cluster. Per il tutorial, l’enfasi sarà posta su quelli necessari a facilitare la migrazione dei dati.

Creazione di un cluster Redshift nella console Redshift. Immagine dell’autore

2. Seleziona il tipo di nodo e il numero di nodi adatti al volume di dati da analizzare.

Per migrare la tabella Products, puoi utilizzare una capacità CPU minima e avere un solo nodo.

Personalizzazione della configurazione del cluster Redshift. Immagine dell’autore

3. Scegli nome utente e password di amministratore per questo cluster.

Conserva le credenziali in un luogo sicuro: serviranno per accedere al cluster tramite altri servizi AWS.

Personalizzazione della configurazione del cluster Redshift. Immagine dell’autore

4. Infine, assegna un ruolo IAM al cluster.

Il ruolo IAM avrà bisogno di policy che consentano al cluster di leggere tabelle DynamoDB e creare tabelle in Redshift. 

Assegnazione di un ruolo IAM al cluster Redshift. Immagine dell’autore

5. Una volta creato il cluster, vai al query editor e crea la tabella che ospiterà i dati della tabella DynamoDB usando il comando CREATE:

CREATE TABLE Products (
	product_id VARCHAR(50) PRIMARY KEY,
	category VARCHAR(50),
	description VARCHAR(100),
	price INT,
	product_name VARCHAR(50),
	stock_quantity INT
);Offerto da

Modifica il comando in base ai dati di interesse e considera eventuali vincoli aggiuntivi da applicare.

Fatto! Sei pronto per iniziare a trasferire i dati.

Metodo 1: trasferire dati da DynamoDB a Redshift usando il comando COPY

Amazon Redshift offre il comando COPY, che carica dati da una sorgente dati AWS indicata in una tabella.

1. Esegui la migrazione dei dati usando il comando COPY. 

La sintassi del comando è la seguente:

COPY <table_name>
FROM <dynamo_db_table_path>
IAM_ROLE 'arn:aws:iam::<aws-account-id>:role/<role-name>'
REGION <region_name>';Offerto da

Per aggiungere i dati dalla tabella Products in DynamoDB alla tabella Products in Redshift, il comando può essere modificato come segue:

COPY Products
FROM 'dynamodb://Products'
IAM_ROLE  'arn:aws:iam::<1234567890>:role/<dynamo_db_redshift_role>'
REGION ‘us-east-1’Offerto da

Pro dell’uso del comando COPY

Il comando COPY è uno dei metodi più semplici per spostare dati da DynamoDB a Redshift. Richiede una configurazione minima e la sua facilità d’uso lo rende particolarmente accessibile a chi ha meno esperienza nella costruzione di pipeline ETL. 

Inoltre, poiché il trasferimento dei dati avviene direttamente, non è necessario integrare altri servizi AWS.

Contro dell’uso del comando COPY

Il principale svantaggio di questo metodo è che non è possibile configurare come gli attributi nella tabella DynamoDB vengono mappati ai campi nella tabella Redshift. Questa mancanza di flessibilità può portare il comando COPY a omettere erroneamente o mappare in modo impreciso i campi nella tabella Redshift. 

Inoltre, poiché il comando trasferisce tutti i dati in un unico batch, l’operazione può essere inefficiente se alcuni record sono già stati trasferiti in Redshift in precedenza. In questi scenari si avrebbero trasferimenti ridondanti, aumentando i tempi di elaborazione e i costi di storage.

Metodo 2: trasferire dati da DynamoDB a Redshift usando AWS Glue

AWS Glue è un servizio progettato per creare pipeline di estrazione, trasformazione e caricamento (ETL). Gli utenti possono trasferire i dati da DynamoDB a Redshift creando un job ETL.

Se sei nuovo su Glue, valuta di seguire il tutorial Getting Started with AWS Glue.

In questa guida, leggeremo la tabella Products in DynamoDB, salveremo i risultati in un bucket S3 come file CSV e poi invieremo quei dati alla tabella Products in Redshift. 

1. Vai alla console S3 e crea un bucket che ospiti il file CSV.

Console AWS S3. Immagine dell’autore

2. Vai alla console AWS Glue e, dal pannello a sinistra, seleziona “ETL jobs” per iniziare a creare il job. 

Console AWS Glue. Immagine dell’autore

3. Seleziona la modalità per creare un job ETL.

AWS offre tre modalità di creazione job: Visual ETL, Notebook e Script editor. Ogni modalità si adatta a diversi livelli di esperienza, consentendo di scegliere il metodo preferito—che sia un’interfaccia drag-and-drop (Visual ETL), un ambiente di sviluppo interattivo (Notebook) o codice puro (Script Editor).

I job Glue possono essere codificati manualmente utilizzando Python o Spark. Per chi ha meno dimestichezza con questi linguaggi, Visual ETL è una scelta adatta, poiché consente di configurare i job con soli clic.

Il job Glue in questo tutorial sarà scritto in un editor di codice in Python, ma per chi è interessato all’opzione Visual ETL, consulta la documentazione AWS.

4. Assegna un ruolo IAM a questo job. 

Il ruolo IAM dovrà avere accesso a DynamoDB, Redshift e S3 affinché questo tutorial venga eseguito correttamente. 

Assegnazione di un ruolo IAM al job Glue. Immagine dell’autore

5. Dopo aver creato il job, passa alla scheda “Job details” e compila le proprietà di base.

Compilazione dei dettagli del job Glue. Immagine dell’autore

In questa sezione puoi definire le unità di elaborazione dati (DPU) allocate, il numero di retry e il timeout del job. Il job di questo tutorial manterrà i valori predefiniti, ma si consiglia di adattare questi parametri alle esigenze del job. 

6. Passa alla scheda “Script” e scrivi la logica. 

Il job ETL che migra i dati nella tabella Products eseguirà il seguente codice:

import boto3
import csv
import time
import os
from awsglue.context import GlueContext
from awsglue.job import Job
from pyspark.context import SparkContext
from awsglue.utils import getResolvedOptions
import sys
# initialize Glue context
args = getResolvedOptions(sys.argv, ["JOB_NAME"])
sc = SparkContext()
glueContext = GlueContext(sc)
job = Job(glueContext)
job.init(args["JOB_NAME"], args)
# initialize DynamoDB client and scan the table
dynamodb = boto3.client('dynamodb', region_name=os.getenv('AWS_REGION'))
response = dynamodb.scan(TableName=os.getenv('DYNAMODB_TABLE'))
# extract and write data to a CSV file
items = response['Items']
csv_file = '/tmp/products.csv'
# write each row in the table
with open(csv_file, mode='w', newline='') as file:
	writer = csv.writer(file)
	writer.writerow(['product_id', 'category', 'description', 'product_name', 'stock_quantity', 'price'])
	for item in items:
    	writer.writerow([
        	item.get('product_id', {}).get('S', ''),
        	item.get('category', {}).get('S', ''),
        	item.get('description', {}).get('S', ''),
        	item.get('product_name', {}).get('S', ''),
        	item.get('stock_quantity', {}).get('N', 0),
        	item.get('price', {}).get('N', 0)
    	])
# upload the csv file to S3
s3 = boto3.client('s3', region_name=os.getenv('AWS_REGION'))
bucket_name = os.getenv('S3_BUCKET_NAME')
s3_key = 'products/products.csv'
s3.upload_file(csv_file, bucket_name, s3_key)
# wait for the file to upload before continuing
time.sleep(10)
# load data into Redshift using the COPY command
redshift = boto3.client('redshift', region_name=os.getenv('AWS_REGION'))
copy_command = f"""
	COPY Products FROM 's3://{bucket_name}/{s3_key}'
	IAM_ROLE 'arn:aws:iam::{os.getenv('AWS_ACCOUNT_ID')}:role/{os.getenv('REDSHIFT_ROLE')}'
	FORMAT AS CSV
	IGNOREHEADER 1;
"""
cluster_id = os.getenv('REDSHIFT_CLUSTER_ID')
database = os.getenv('REDSHIFT_DATABASE')
db_user = os.getenv('REDSHIFT_DB_USER')
# execute the copy statement
response = redshift.execute_statement(
	ClusterIdentifier=cluster_id,
	Database=database,
	DbUser=db_user,
	Sql=copy_command
)
# Commit the job
job.commit()Offerto da

Vediamo in breve cosa fa questo script, passo dopo passo:

1. Usa la libreria awsglue per impostare il job per l’esecuzione
2. Accede alla tabella DynamoDB con boto3, l’SDK Python per AWS
3. Scrive gli item della tabella in memoria ed esporta il tutto come file CSV nel bucket S3 creato
4. Accede al cluster Redshift con boto3
5. Scrive ed esegue un comando COPY che inserisce i dati del file CSV nella tabella Redshift

Nota: lo snippet di codice di esempio illustra un modo per facilitare la migrazione dei dati. AWS Glue è flessibile e offre vari modi per costruire una pipeline ETL. Pertanto, puoi creare un job su misura per le tue esigenze. 

7. Una volta scritto il codice, salva le modifiche e fai clic sul pulsante “Run” per eseguire il job.

Editor script per il job Glue. Immagine dell’autore

8. Monitora l’avanzamento del job nella scheda “Runs”, dove verranno mostrati eventuali errori o problemi. 

Verifica lo stato del job e consulta i log per assicurarti che tutto sia stato eseguito come previsto.

Scheda Runs di AWS Glue con un job completato. Immagine dell’autore

Una volta che il job è andato a buon fine, può essere eseguito on demand o pianificato secondo necessità, rendendo il processo di migrazione più efficiente e automatizzato.

Pro dell’uso di Glue

AWS Glue offre ampie opzioni di personalizzazione, permettendo di adattare i job alle proprie esigenze. Offre anche la possibilità di pianificare questi job a intervalli periodici (ad esempio, giornalieri), abilitando l’automazione. Inoltre, Glue è integrato con molti altri servizi, facilitando l’interazione con sorgenti dati diverse da DynamoDB, se necessario. 

Contro dell’uso di Glue

Configurare un job ETL in Glue spesso richiede impegno e tempo di setup. Sebbene la programmazione non sia obbligatoria per usare il servizio, è necessaria per sfruttare alcune funzionalità offerte da Glue, come la libreria AWSGlue e un SDK. 

Inoltre, è improbabile che i job Glue vadano a buon fine al primo tentativo, quindi occorre mettere in conto tempo per il troubleshooting. Infine, i costi possono crescere rapidamente se i job non sono gestiti correttamente: è essenziale allocare solo le risorse necessarie. 

Metodo 3: trasferire dati da DynamoDB a Redshift usando DynamoDB Streams

DynamoDB Streams è una funzionalità che traccia in tempo reale le modifiche apportate alle tabelle DynamoDB. Sfruttando DynamoDB Streams, puoi aggiornare automaticamente la tabella Redshift ogni volta che viene apportata una modifica alla sorgente dati in DynamoDB. 

Consulta la documentazione AWS per maggiori informazioni su come usare DynamoDB Streams.

Questa soluzione richiede accesso ad AWS DynamoDB, Redshift e Lambda. In questo approccio, una funzione Lambda verrà attivata quando un item viene aggiunto o modificato nella tabella Products in DynamoDB. 

Ecco i passaggi: 

1. Vai alla console Lambda e seleziona “Create Function”.

Console AWS Lamba. Immagine dell’autore

2. Fornisci le informazioni di base per la funzione, incluso il linguaggio di programmazione e il ruolo IAM.

Il ruolo deve avere accesso a Lambda, DynamoDB e Redshift.

Configurazione della funzione Lambda. Immagine dell’autore

3. Dopo aver creato la funzione, aggiungi la tabella DynamoDB (nel nostro caso la tabella Products) come trigger.

Lo schema ora dovrebbe apparire come segue:

Aggiunta di un trigger alla funzione Lambda. Immagine dell’autore

4. Passa alla scheda di configurazione e assegna la quantità di memoria e il tempo di esecuzione necessari per la funzione, poiché i valori predefiniti sono spesso insufficienti.

Configurazione del trigger per la funzione Lambda. Immagine dell’autore

5. Nella scheda “Code”, scrivi la logica per la migrazione dei dati nel linguaggio che preferisci.

Il seguente snippet è un esempio di come può apparire una funzione Lambda in Python:

import boto3
import os
import json
def lambda_handler(event, context):
	# Initialize the Redshift Data API client
	redshift_client = boto3.client('redshift-data')
	# Redshift cluster details 
	cluster_id = os.environ['REDSHIFT_CLUSTER_ID']
	database = os.environ['REDSHIFT_DB_NAME']
	user = os.environ['REDSHIFT_USER']
	# IAM role ARN that has access to Redshift Data API
	role_arn = os.environ['REDSHIFT_ROLE_ARN']
    
	# Process DynamoDB stream records
	for record in event['Records']:
    	if record['eventName'] in ['INSERT', 'MODIFY']:
        	new_image = record['dynamodb']['NewImage']
        	product_id = new_image['product_id']['S']
        	category = new_image['category']['S']
        	description = new_image['description']['S']
        	price = float(new_image['price']['N'])
        	product_name = new_image['product_name']['S']
        	stock_quantity = int(new_image['stock_quantity']['N'])
       	 
        	# SQL query to insert data into Redshift
        	query = f"""
            	INSERT INTO products (product_id, category, description, price, product_name,   stock_quantity)
            	VALUES ('{product_id}', '{category}', '{description}', {price}, '{product_name}', {stock_quantity});
        	"""
       	 
        	# Execute the query using Redshift Data API
        	response = redshift_client.execute_statement(
            	ClusterIdentifier=cluster_id,
            	Database=database,
            	DbUser=user,
            	Sql=query
        	)
       	 
        	# Log the statement ID for tracking
        	print(f'Started SQL statement with ID: {response["Id"]}')
    
	return {
    	'statusCode': 200,
    	'body': 'SQL statements executed successfully'
	}Offerto da

In parole semplici, la funzione legge il log degli item aggiunti o modificati registrato da DynamoDB Streams e li applica alla tabella Redshift eseguendo una query SQL con un client API di Redshift. 

Per sicurezza, i valori sensibili (ad esempio, l’ID del cluster Redshift) sono archiviati in variabili d’ambiente invece di essere hardcoded nello script.

Scopri di più sull’uso delle variabili d’ambiente in Lambda nella documentazione AWS.

6. Dopo aver terminato il codice, distribuisci la funzione e testala per verificare eventuali errori. 

A seconda del caso d’uso, può valere la pena progettare casi di test personalizzati per la funzione. 

Risultati di esecuzione della funzione Lambda. Immagine dell’autore

Quando la funzione Lambda è operativa, dobbiamo configurare la tabella DynamoDB per eseguire questa funzione ogni volta che un item nella tabella viene aggiunto o modificato.

7. Seleziona la tabella DynamoDB e passa alla scheda “Exports and streams”.

Scheda Exports and streams della console DynamoDB. Immagine dell’autore

8. Scorri fino ai dettagli di DynamoDB Streams e seleziona “Turn on”.

Scheda Exports and streams della console DynamoDB. Immagine dell’autore

9. Quando richiesto, seleziona il tipo di informazioni che devono essere registrate in DynamoDB Streams.

Schermata dei dettagli dello stream DynamoDB. Immagine dell’autore

10. Dopo aver attivato lo stream, scorri verso il basso nella stessa pagina per creare il trigger.

Creazione di un trigger per invocare una funzione Lambda in DynamoDB. Immagine dell’autore

11. Infine, durante la configurazione del trigger, seleziona la funzione Lambda creata e poi “Create trigger”.

Selezione di una funzione Lambda da attivare. Immagine dell’autore

Implementando questa soluzione, qualsiasi modifica apportata alla tabella DynamoDB verrà applicata automaticamente alla tabella in Redshift, garantendo la coerenza dei dati in tempo reale. 

Pro dell’uso di DynamoDB Streams

DynamoDB Streams crea una sincronizzazione in tempo reale tra DynamoDB e Redshift. Ciò consente di mantenere aggiornate le tabelle Redshift senza intervento manuale. 

Di conseguenza, le tabelle Redshift possono essere aggiornate frequentemente, alimentando applicazioni che richiedono un alto throughput di dati (ad esempio, dashboard in tempo reale). Questa soluzione riduce anche il rischio di errore umano a ogni iterazione. 

Contro dell’uso di DynamoDB Streams

Configurare questa soluzione richiede la configurazione di vari servizi AWS, operazione che può richiedere tempo. 

Poiché Lambda è uno strumento Function as a Service (FaaS), sarà necessaria una solida padronanza di un linguaggio di programmazione. Inoltre, poiché ogni iterazione di sincronizzazione dei dati richiede diverse chiamate API, il costo complessivo può aumentare rapidamente, soprattutto con aggiornamenti frequenti. Infine, questa soluzione è più adatta a piccole modifiche alle tabelle Redshift che a migrazioni dell’intera tabella. 

Verifica della migrazione dei dati

La validazione dei dati è un passaggio essenziale dopo aver costruito la soluzione di migrazione. Anche quando i servizi AWS funzionano senza problemi, potrebbero verificarsi errori nel processo di migrazione non considerati. Questi problemi possono derivare da discrepanze logiche, mappature errate degli attributi o trasferimenti di dati incompleti. 

I dati migrati devono essere privi di questi errori affinché le analisi successive in Redshift abbiano successo.

Questa sezione esplora alcuni controlli e tecniche per esaminare i dati migrati, usando come esempio la tabella Products. 

Convalidare struttura delle colonne e tipo di dato

Assicurati che tutte le colonne della tabella DynamoDB siano presenti nella tabella Redshift e che sia stato assegnato loro il tipo di dato corretto. 

SELECT column_name, data_type
FROM information_schema.columns
WHERE table_name = Products;Offerto da

Verificare il numero di righe

Conferma che il trasferimento dei dati sia stato completato confrontando il conteggio delle righe nella tabella Redshift con quello della sorgente dati. 

SELECT COUNT(*) FROM your_table_name;Offerto da

Pre-visualizzare i dati

Un’alternativa all’identificazione di colonne e tipi di dato è semplicemente un’anteprima dei dati. È possibile scorrere l’anteprima per individuare discrepanze o anomalie. 

SELECT product_id, category, price FROM your_table_name LIMIT 5;Offerto da

Convalidare logiche di business complesse

La convalida dei dati tramite anteprime o conteggi non è sufficiente per tutti i dataset. Quando è necessario valutare i dati in base a criteri più complessi, si possono creare viste.  

Ad esempio, supponiamo che la tabella Products non debba mai avere scorte basse di elettronica. Questo risultato può essere monitorato con la seguente query.

CREATE OR REPLACE VIEW low_stock_electronics AS
SELECT
	Product_id, product_name, category, stock_quantity, price,
FROM
	your_table_name
WHERE
	stock_quantity < 50 AND
	Category = ‘Electronics;Offerto da

Ottimizzazione delle prestazioni in Redshift

L’ottimizzazione delle prestazioni delle query è essenziale per estrarre insight in modo efficiente e a basso costo. Scrivere query che risparmiano memoria e riducono i tempi di esecuzione sarà particolarmente importante man mano che il dataset cresce a ogni migrazione. 

Questa sezione esplora alcuni metodi per migliorare l’ottimizzazione delle query, usando come riferimento la tabella Products. 

Selezionare una chiave di distribuzione

In Redshift, le chiavi di distribuzione determinano come i dati sono distribuiti sui nodi di un cluster. La scelta della chiave di distribuzione giusta in una tabella può ridurre i tempi di esecuzione delle query. 

Ad esempio, se la tabella Products deve essere unita ad altre tabelle sul campo product_id, può essere utile usare product_id come chiave di distribuzione durante la creazione della tabella. 

CREATE TABLE products (
	product_id VARCHAR(100),
	category VARCHAR(100),
	description VARCHAR(100),
	price INT,
	stock_quantity INT
)
DISTKEY(product_id);Offerto da

Selezionare una chiave di ordinamento

La scelta della giusta chiave di ordinamento rafforza operazioni SQL comuni, come filtri e join. In Redshift, puoi selezionare manualmente una chiave di ordinamento o fartela suggerire. Le sort key rientrano in due categorie: compound sort key e interleaved sort key. La scelta migliore dipende dalle query da eseguire sui dati. 

CREATE TABLE products (
	product_id VARCHAR(100),
	category VARCHAR(100),
	description VARCHAR(100),
	price INT,
	stock_quantity INT
)
COMPOUND SORTKEY(category, product_id);Offerto da

Per maggiori informazioni sulle chiavi di ordinamento, visita la documentazione AWS. 

Usare la compressione

La compressione consiste nel codificare i dati con meno bit. Il risultato è una tabella che usa meno storage ma mantiene tutte le informazioni. 

Per chi non è sicuro del tipo di compressione più adatto ai propri dati, Redshift può eseguire un’analisi della compressione per trovare la codifica migliore per ciascun campo con il seguente comando:

ANALYZE COMPRESSION <table_name>;Offerto da

Conclusioni e prossimi passi

Migrare i dati da DynamoDB a Redshift consente di sfruttare le capacità OLAP di Redshift per analisi dei dati più complesse. 

Questo tutorial ha esplorato tre diversi metodi di migrazione, ciascuno con vantaggi e svantaggi. Quando scegli l’approccio migliore, valuta con attenzione le tue esigenze di analisi, i vincoli sui dati e il budget per garantire la soluzione più efficace per il tuo caso d’uso specifico.

Un ottimo prossimo passo è iniziare il corso Introduction to Redshift, per imparare o ripassare i concetti di base. Il corso AWS Security and Cost Management è un’altra ottima alternativa per apprendere concetti che chiunque lavori con AWS dovrebbe padroneggiare.