DynamoDB naar Redshift: drie methoden om data te migreren

Vereisten en setup

Deze tutorial gaat ervan uit dat deelnemers het volgende hebben:

• Eerdere ervaring met AWS en aanverwante tools en technieken. 
• Basiskennis van relationele en NoSQL-databases. 
• Bekendheid met SQL.
• Kennis van minimaal één programmeertaal is een plus.

De migratiemethoden maken gebruik van enkele kernservices van AWS, waaronder:

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

De cursus AWS Cloud Technology and Services helpt je op weg als je nieuw bent met AWS.

Het grootste deel van de procedure wordt uitgevoerd in de AWS Management Console. De stappen in deze tutorial kunnen echter ook worden uitgevoerd met de AWS command line interface (CLI) of een AWS software development kit (SDK). Je kunt de datamigratie uitvoeren in de werkomgeving van jouw voorkeur.

DynamoDB voorbereiden op datamigratie

Bij de voorbereiding op migratie is het belangrijk om de componenten van DynamoDB-tabellen te begrijpen en hoe deze verschillen van die in relationele databases:

• De bouwstenen van DynamoDB-tabellen zijn items (vergelijkbaar met rijen in relationele databases). 
• Items bevatten één of meerdere attributen, die elk één data-element vertegenwoordigen. 
• Net als relationele tabellen hebben DynamoDB-tabellen primaire sleutels, die als unieke identificatie voor elk item dienen. Een primaire sleutel kan bestaan uit een enkele partition key of een combinatie van een partition key en een sort key.
• Een belangrijk kenmerk van DynamoDB-tabellen is dat ze schemaloos zijn, wat betekent dat elk item unieke attributen kan hebben.

De tutorial gebruikt een eenvoudige tabel Products om de datamigratie te demonstreren. Hieronder staat de data in JSON-formaat: 

	{
    	"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"
	}Mogelijk gemaakt door

Er zijn twee belangrijke punten om op te letten:

• De product_id fungeert als de primaire sleutel.
• De attributen in de twee items zijn niet gelijk, omdat in het eerste item het attribuut description ontbreekt.

Deze data wordt als onderdeel van de setup toegevoegd aan een tabel in DynamoDB.

DynamoDB-tabelitems. Afbeelding door de auteur

Amazon Redshift instellen

De volgende stap is een tabel in Redshift opzetten die de data uit de DynamoDB-tabel zal ontvangen. 

1. Ga naar de Redshift-console en kies “Create cluster”.

AWS laat je diverse parameters definiëren voordat de cluster wordt opgestart. Voor deze tutorial ligt de nadruk op de instellingen die nodig zijn om de datamigratie mogelijk te maken.

Een Redshift-cluster maken in de Redshift Console. Afbeelding door de auteur

2. Kies het node-type en het aantal nodes dat past bij de hoeveelheid data die je gaat analyseren.

Voor het migreren van de tabel Products kun je met minimale CPU-capaciteit volstaan en slechts één node gebruiken.

De configuratie van het Redshift-cluster aanpassen. Afbeelding door de auteur

3. Kies de admin-gebruikersnaam en het wachtwoord voor deze cluster.

Bewaar de inloggegevens op een veilige plek, want je hebt ze nodig om via andere AWS-services toegang te krijgen tot deze cluster.

De configuratie van het Redshift-cluster aanpassen. Afbeelding door de auteur

4. Wijs ten slotte een IAM-rol toe aan de cluster.

De IAM-rol heeft policies nodig die de cluster toestaan om DynamoDB-tabellen te lezen en tabellen in Redshift te maken. 

Een IAM-rol toewijzen aan de Redshift-cluster. Afbeelding door de auteur

5. Ga, zodra de cluster is aangemaakt, naar de query editor en maak de tabel die de data uit de DynamoDB-tabel zal bevatten met het commando 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
);Mogelijk gemaakt door

Pas het bovenstaande commando aan op basis van de gewenste data en houd rekening met eventuele extra constraints die moeten worden toegepast.

Dat is het! Je bent klaar om data over te zetten.

Methode 1: Data overzetten van DynamoDB naar Redshift met het COPY-commando

Amazon Redshift biedt het COPY-commando, waarmee data vanuit een AWS-databron in een tabel wordt geladen.

1. Voer de datamigratie uit met het COPY-commando. 

De syntaxis van het commando is als volgt:

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

Om data uit de tabel Products in DynamoDB toe te voegen aan de tabel Products in Redshift, kan het commando als volgt worden aangepast:

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

Voordelen van het COPY-commando

Het COPY-commando is een van de meest rechttoe-rechtaan methoden om data van DynamoDB naar Redshift te verplaatsen. Het vereist minimale setup, en door de eenvoud is het vooral toegankelijk voor wie minder ervaring heeft met het bouwen van ETL-pijplijnen. 

Bovendien is er door de directe overdracht geen noodzaak om andere AWS-services te betrekken.

Nadelen van het COPY-commando

Het grootste nadeel is dat je niet kunt configureren hoe de attributen in de DynamoDB-tabel worden gemapt op de velden in de Redshift-tabel. Dit gebrek aan flexibiliteit kan ertoe leiden dat het COPY-commando velden in de Redshift-tabel onjuist overslaat of verkeerd mappt. 

Daarnaast wordt alle data in één batch overgezet. Als sommige records al eerder naar Redshift zijn verplaatst, kan dit inefficiënt zijn en leiden tot dubbele overdrachten, met extra verwerkingstijd en opslagkosten als gevolg.

Methode 2: Data overzetten van DynamoDB naar Redshift met AWS Glue

AWS Glue is een service voor het bouwen van extract-, transform- en load (ETL)-pijplijnen. Je kunt data van DynamoDB naar Redshift verplaatsen door een ETL-job te maken.

Ben je nieuw met Glue? Volg dan de tutorial Getting Started with AWS Glue.

In deze handleiding lezen we de tabel Products in DynamoDB, slaan de resultaten op in een S3-bucket als CSV-bestand en sturen die data vervolgens naar de tabel Products in Redshift. 

1. Ga naar de S3-console en maak een bucket aan voor het CSV-bestand.

AWS S3-console. Afbeelding door de auteur

2. Ga naar de AWS Glue-console en kies in het linkerpaneel “ETL jobs” om je job te maken. 

AWS Glue-console. Afbeelding door de auteur

3. Kies de modus voor het maken van een ETL-job.

AWS biedt drie job-modi: Visual ETL, Notebook en Script editor. Elke modus bedient een ander ervaringsniveau, zodat je je voorkeursmethode kunt kiezen—of dat nu een drag-and-dropinterface is (Visual ETL), een interactieve ontwikkelomgeving (Notebook) of raw code (Script Editor).

Glue-jobs kunnen handmatig worden gecodeerd met Python of Spark. Voor wie minder vaardig is in deze talen, is Visual ETL een geschikte keuze omdat je jobs kunt configureren door alleen te klikken.

De Glue-job in deze tutorial wordt in een code-editor in Python geschreven, maar wie geïnteresseerd is in de Visual ETL-optie, kan terecht in de AWS-documentatie.

4. Wijs een IAM-rol toe aan deze job. 

De IAM-rol moet toegang hebben tot DynamoDB, Redshift en S3 om deze tutorial succesvol te kunnen uitvoeren. 

Een IAM-rol toewijzen aan de Glue-job. Afbeelding door de auteur

5. Ga na het maken van de job naar het tabblad “Job details” en vul de basisinstellingen in.

Glue-jobdetails invullen. Afbeelding door de auteur

In deze sectie kun je de toegewezen data processing units (DPU’s), het aantal retries en de timeout voor de job instellen. Voor deze tutorial houden we de standaardwaarden aan, maar het is aan te raden deze parameters te finetunen naar de behoeften van je job. 

6. Ga naar het tabblad “Script” en schrijf je logica. 

De ETL-job die de data in de tabel Products migreert, voert de volgende code uit:

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()Mogelijk gemaakt door

Laten we stap voor stap bekijken wat dit script doet:

1. Gebruik de bibliotheek awsglue om de job klaar te zetten voor uitvoering
2. Benader de DynamoDB-tabel met boto3, de Python-SDK voor AWS
3. Schrijf de tabelitems in het geheugen en exporteer ze als CSV naar de aangemaakte S3-bucket
4. Benader de Redshift-cluster met boto3
5. Schrijf en voer een COPY-commando uit dat de data in het CSV-bestand in de Redshift-tabel invoegt

Let op: de voorbeeldcode schetst één manier om de migratie te faciliteren. AWS Glue is flexibel en biedt meerdere mogelijkheden om een ETL-pijplijn te bouwen. Je kunt dus een job creëren die precies is afgestemd op jouw behoeften. 

7. Als de code klaar is, sla je de wijzigingen op en klik je op “Run” om de job uit te voeren.

Scripteditor voor de Glue-job. Afbeelding door de auteur

8. Volg de voortgang van de job in het tabblad “Runs”, waar eventuele fouten of problemen worden weergegeven. 

Controleer de status van de job en bekijk de logs om te verifiëren dat alles naar verwachting is uitgevoerd.

Tabblad Runs in AWS Glue met een voltooide job. Afbeelding door de auteur

Zodra de job succesvol is, kun je deze on demand draaien of volgens schema, waardoor je migratieproces efficiënter en meer geautomatiseerd wordt.

Voordelen van Glue

AWS Glue biedt uitgebreide maatwerkmogelijkheden, zodat je jobs kunt afstemmen op jouw behoeften. Je kunt jobs ook periodiek inplannen (bijv. dagelijks), wat automatisering mogelijk maakt. Bovendien is Glue geïntegreerd met veel andere services, waardoor interacties met andere databronnen dan DynamoDB eenvoudig zijn als dat nodig is. 

Nadelen van Glue

Een ETL-job in Glue configureren vergt vaak de nodige inspanning en tijd. Hoewel programmeerkennis niet strikt vereist is, is die wel nodig om bepaalde features van Glue te benutten, zoals de AWSGlue-bibliotheek en een SDK. 

Verder is de kans klein dat een Glue-job in één keer slaagt, dus houd rekening met tijd voor troubleshooting. Tot slot kunnen de kosten snel oplopen als je jobs niet goed beheert; voorzie daarom alleen de benodigde resources. 

Methode 3: Data overzetten van DynamoDB naar Redshift met DynamoDB Streams

DynamoDB Streams is een feature die wijzigingen in DynamoDB-tabellen realtime bijhoudt. Door DynamoDB Streams te benutten, kun je je Redshift-tabel automatisch bijwerken wanneer er een wijziging plaatsvindt in de brondata in DynamoDB. 

Lees de AWS-documentatie voor meer informatie over het gebruik van DynamoDB Streams.

Voor deze oplossing heb je toegang nodig tot AWS DynamoDB, Redshift en Lambda. In deze aanpak wordt een Lambda-functie getriggerd wanneer een item in de tabel Products in DynamoDB wordt toegevoegd of gewijzigd. 

Volg deze stappen: 

1. Ga naar de Lambda-console en kies “Create Function”.

AWS Lamba-console. Afbeelding door de auteur

2. Vul de basisinformatie voor de functie in, waaronder de programmeertaal en de IAM-rol.

De rol moet toegang hebben tot Lambda, DynamoDB en Redshift.

De Lambda-functie configureren. Afbeelding door de auteur

3. Voeg na het aanmaken van de functie de DynamoDB-tabel (in ons geval de tabel Products) toe als trigger.

Het diagram zou er nu als volgt uit moeten zien:

Een trigger toevoegen aan de Lambda-functie. Afbeelding door de auteur

4. Ga naar het tabblad Configuration en wijs voldoende geheugen en runtime toe, want de standaardwaarden zijn vaak onvoldoende.

De trigger voor de Lambda-functie configureren. Afbeelding door de auteur

5. Schrijf op het tabblad “Code” de logica voor de datamigratie in de taal van jouw keuze.

Het volgende fragment is een voorbeeld van hoe een Lambda-functie in Python eruit kan zien:

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'
	}Mogelijk gemaakt door

Kort gezegd leest de functie het log met toegevoegde of gewijzigde items dat door DynamoDB Streams wordt vastgelegd, en past dit toe op de Redshift-tabel door een SQL-query uit te voeren met een Redshift API-client. 

Uit veiligheidsoverwegingen worden sleutelwaarden (bijv. de Redshift-cluster-id) opgeslagen in omgevingsvariabelen in plaats van hardcoded in het script.

Lees meer over het gebruik van omgevingsvariabelen in Lambda in de AWS-documentatie.

6. Deploy de functie na het afronden van de code en test op eventuele fouten. 

Afhankelijk van de use-case is het de moeite waard om eigen testcases voor de functie te ontwerpen. 

Resultaten van het uitvoeren van de Lambda-functie. Afbeelding door de auteur

Als de Lambda-functie operationeel is, moeten we de DynamoDB-tabel configureren om deze functie uit te voeren wanneer een item in de tabel wordt toegevoegd of gewijzigd.

7. Selecteer de DynamoDB-tabel en ga naar het tabblad “Exports and streams”.

Tabblad Exports and streams in de DynamoDB-console. Afbeelding door de auteur

8. Scroll naar de dynamoDB stream details en kies “Turn on”.

Tabblad Exports and streams in de DynamoDB-console. Afbeelding door de auteur

9. Kies, wanneer hierom wordt gevraagd, het type informatie dat in DynamoDB Streams moet worden vastgelegd.

Scherm met streamdetails van DynamoDB. Afbeelding door de auteur

10. Nadat je de stream hebt ingeschakeld, scroll je op dezelfde pagina omlaag om de trigger te maken.

Een trigger maken om een Lambda-functie in DynamoDB aan te roepen. Afbeelding door de auteur

11. Selecteer bij het configureren van de trigger de eerder gemaakte Lambda-functie en kies daarna “Create trigger”.

Een Lambda-functie selecteren om te triggeren. Afbeelding door de auteur

Met deze oplossing worden wijzigingen in de DynamoDB-tabel automatisch toegepast op de tabel in Redshift, waardoor realtime dataconsistentie is gewaarborgd. 

Voordelen van DynamoDB Streams

DynamoDB Streams zorgt voor realtime synchronisatie tussen DynamoDB en Redshift. Hierdoor blijven Redshift-tabellen up-to-date zonder handmatige tussenkomst. 

Daardoor kunnen Redshift-tabellen frequent worden bijgewerkt, wat op zijn beurt applicaties mogelijk maakt die hoge datadoorvoer vereisen (bijv. realtime dashboards). Deze oplossing verkleint ook de kans op menselijke fouten bij elke iteratie. 

Nadelen van DynamoDB Streams

Het opzetten van deze oplossing vereist het configureren van meerdere AWS-services, wat tijdrovend kan zijn. 

Omdat Lambda een Function as a Service (FaaS)-tool is, heb je een goede beheersing van minstens één programmeertaal nodig. Bovendien vereist elke synchronisatie-iteratie meerdere API-calls, waardoor de totale kosten snel kunnen oplopen, zeker bij frequente updates. Tot slot is deze oplossing geschikter voor kleinere wijzigingen in Redshift-tabellen dan voor volledige tabelmigraties. 

Datamigratie verifiëren

Datavalidatie is een essentiële stap na het bouwen van de migratie-oplossing. Zelfs als de AWS-services probleemloos draaien, kunnen er toch fouten in het migratieproces sluipen. Deze kunnen voortkomen uit logische inconsistenties, onjuiste mapping van attributen of onvolledige overdrachten. 

De gemigreerde data moet vrij zijn van dit soort fouten om latere analyses in Redshift succesvol te maken.

In deze sectie behandelen we enkele checks en technieken om gemigreerde data te controleren, met de tabel Products als voorbeeld. 

Kolomstructuur en datatypes valideren

Zorg dat alle kolommen uit de DynamoDB-tabel aanwezig zijn in de Redshift-tabel en dat ze het juiste datatype hebben gekregen. 

SELECT column_name, data_type
FROM information_schema.columns
WHERE table_name = Products;Mogelijk gemaakt door

Het aantal rijen verifiëren

Bevestig dat de overdracht is voltooid door het aantal rijen in de Redshift-tabel te vergelijken met dat van de bron. 

SELECT COUNT(*) FROM your_table_name;Mogelijk gemaakt door

Data previewen

Een alternatief voor het expliciet identificeren van kolommen en datatypes is om de data simpelweg te previewen. Je kunt afwijkingen of anomalieën vaak al snel spotten. 

SELECT product_id, category, price FROM your_table_name LIMIT 5;Mogelijk gemaakt door

Complexe businesslogica valideren

Data valideren met previews of counts is niet voor alle datasets voldoende. Als je data op complexere criteria moet evalueren, kun je views maken.  

Stel bijvoorbeeld dat de tabel Products nooit een lage voorraad elektronica zou mogen hebben. Dat kun je monitoren met de volgende 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;Mogelijk gemaakt door

Performance optimaliseren in Redshift

Het optimaliseren van queryperformance is essentieel om efficiënt en kosteneffectief inzichten te halen uit data. Queries schrijven die zuinig omgaan met geheugen en de runtijd verkorten, wordt extra belangrijk naarmate de dataset bij elke migratie groeit. 

In deze sectie behandelen we enkele methoden om query’s te optimaliseren, met de tabel Products als referentie. 

Kies een distributiesleutel

In Redshift bepalen distributiesleutels hoe data over de nodes in een cluster wordt verdeeld. De juiste sleutel kiezen kan de runtijd van queries verkorten. 

Als de tabel Products bijvoorbeeld met andere tabellen wordt gejoined op het veld product_id, is het zinvol om product_id als distributiesleutel te gebruiken bij het aanmaken van de tabel. 

CREATE TABLE products (
	product_id VARCHAR(100),
	category VARCHAR(100),
	description VARCHAR(100),
	price INT,
	stock_quantity INT
)
DISTKEY(product_id);Mogelijk gemaakt door

Kies een sorteringssleutel

De juiste sorteringssleutel versterkt veelvoorkomende SQL-bewerkingen zoals filters en joins. In Redshift kun je handmatig een sorteringssleutel kiezen of deze automatisch laten kiezen. Sortkeys vallen in twee categorieën: compound en interleaved. De beste sleutel hangt af van de queries die je op de data wilt draaien. 

CREATE TABLE products (
	product_id VARCHAR(100),
	category VARCHAR(100),
	description VARCHAR(100),
	price INT,
	stock_quantity INT
)
COMPOUND SORTKEY(category, product_id);Mogelijk gemaakt door

Voor meer informatie over sortkeys, bekijk de AWS-documentatie. 

Gebruik compressie

Compressie houdt in dat data met minder bits wordt gecodeerd. Dit resulteert in een tabel die minder opslagruimte gebruikt maar alle informatie behoudt. 

Als je niet zeker weet welk type compressie het beste is voor jouw data, kan Redshift een compressie-analyse uitvoeren om de beste codering per veld te vinden met het volgende commando:

ANALYZE COMPRESSION <table_name>;Mogelijk gemaakt door

Conclusie en volgende stappen

Door data van DynamoDB naar Redshift te migreren, kun je profiteren van de OLAP-mogelijkheden van Redshift voor complexere data-analyses. 

In deze tutorial zijn drie verschillende migratiemethoden behandeld, elk met eigen voor- en nadelen. Kies de beste aanpak door je analysecasus, datalimieten en budget zorgvuldig te evalueren, zodat je de meest effectieve oplossing voor jouw use-case vindt.

Een mooie volgende stap is om te starten met de cursus Introduction to Redshift, om basisconcepten te leren of op te frissen. De cursus AWS Security and Cost Management is een ander goed alternatief om concepten te leren die voor iedereen die met AWS werkt belangrijk zijn.