Écriture par lots efficace dans DynamoDB avec Python : un guide étape par étape

Ce guide démontre l'insertion efficace de données dans AWS DynamoDB à l'aide de Python, en se concentrant sur de grands ensembles de données. Nous couvrirons : la création de tables (si nécessaire), la génération de données aléatoires et l'écriture par lots pour des performances optimales et des économies de coûts. La bibliothèque boto3 est obligatoire ; installez-le en utilisant pip install boto3.

1. Configuration de la table DynamoDB :

Tout d'abord, nous établissons une session AWS et définissons la région de la table DynamoDB :

import boto3
from botocore.exceptions import ClientError

dynamodb = boto3.resource('dynamodb', region_name='us-east-1')
table_name = 'My_DynamoDB_Table_Name'

La fonction create_table_if_not_exists() vérifie l'existence de la table et la crée avec une clé primaire (id) si absente :

def create_table_if_not_exists():
    try:
        table = dynamodb.Table(table_name)
        table.load()
        print(f"Table '{table_name}' exists.")
        return table
    except ClientError as e:
        if e.response['Error']['Code'] == 'ResourceNotFoundException':
            print(f"Creating table '{table_name}'...")
            table = dynamodb.create_table(
                TableName=table_name,
                KeySchema=[{'AttributeName': 'id', 'KeyType': 'HASH'}],
                AttributeDefinitions=[{'AttributeName': 'id', 'AttributeType': 'S'}],
                ProvisionedThroughput={'ReadCapacityUnits': 5, 'WriteCapacityUnits': 5}
            )
            table.meta.client.get_waiter('table_exists').wait(TableName=table_name)
            print(f"Table '{table_name}' created.")
            return table
        else:
            print(f"Error: {e}")
            raise

2. Génération de données aléatoires :

Nous générerons des exemples d'enregistrements avec id, name, timestamp et value :

import random
import string
from datetime import datetime

def generate_random_string(length=10):
    return ''.join(random.choices(string.ascii_letters + string.digits, k=length))

def generate_record():
    return {
        'id': generate_random_string(16),
        'name': generate_random_string(8),
        'timestamp': str(datetime.utcnow()),
        'value': random.randint(1, 1000)
    }

3. Écriture de données par lots :

La fonction batch_write() utilise batch_writer() de DynamoDB pour une insertion groupée efficace (jusqu'à 25 éléments par lot) :

def batch_write(table, records):
    with table.batch_writer() as batch:
        for record in records:
            batch.put_item(Item=record)

4. Flux de travail principal :

La fonction principale orchestre la création de tables, la génération de données et l'écriture par lots :

def main():
    table = create_table_if_not_exists()
    records_batch = []
    for i in range(1, 1001):
        record = generate_record()
        records_batch.append(record)
        if len(records_batch) == 25:
            batch_write(table, records_batch)
            records_batch = []
            print(f"Wrote {i} records")
    if records_batch:
        batch_write(table, records_batch)
        print(f"Wrote remaining {len(records_batch)} records")

if __name__ == '__main__':
    main()

5. Conclusion :

Ce script exploite l'écriture par lots pour optimiser les interactions DynamoDB pour des volumes de données importants. N'oubliez pas d'ajuster les paramètres (taille du lot, nombre d'enregistrements, etc.) en fonction de vos besoins spécifiques. Pensez à explorer les fonctionnalités avancées de DynamoDB pour améliorer davantage les performances.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!