Effizientes Batch-Schreiben in DynamoDB mit Python: Eine Schritt-für-Schritt-Anleitung

Diese Anleitung demonstriert die effiziente Dateneinfügung in AWS DynamoDB mit Python und konzentriert sich dabei auf große Datensätze. Wir behandeln: Tabellenerstellung (falls erforderlich), zufällige Datengenerierung und Batch-Schreiben für optimale Leistung und Kosteneinsparungen. Die boto3-Bibliothek ist erforderlich; Installieren Sie es mit pip install boto3.

1. DynamoDB-Tabellen-Setup:

Zuerst richten wir eine AWS-Sitzung ein und definieren die Region der DynamoDB-Tabelle:

<code class="language-python">import boto3
from botocore.exceptions import ClientError

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

Die create_table_if_not_exists()-Funktion prüft, ob die Tabelle vorhanden ist, und erstellt sie mit einem Primärschlüssel (id), falls dieser nicht vorhanden ist:

<code class="language-python">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</code>

2. Zufällige Datengenerierung:

Wir generieren Beispieldatensätze mit id, name, timestamp und value:

<code class="language-python">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)
    }</code>

3. Schreiben von Stapeldaten:

Die batch_write()-Funktion nutzt DynamoDBs batch_writer() für eine effiziente Masseneinfügung (bis zu 25 Artikel pro Stapel):

<code class="language-python">def batch_write(table, records):
    with table.batch_writer() as batch:
        for record in records:
            batch.put_item(Item=record)</code>

4. Hauptworkflow:

Die Hauptfunktion orchestriert die Tabellenerstellung, Datengenerierung und Batch-Schreiben:

<code class="language-python">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()</code>

5. Fazit:

Dieses Skript nutzt Batch-Schreiben, um DynamoDB-Interaktionen für große Datenmengen zu optimieren. Denken Sie daran, die Parameter (Stapelgröße, Datensatzanzahl usw.) an Ihre spezifischen Anforderungen anzupassen. Erwägen Sie die Erkundung erweiterter DynamoDB-Funktionen für weitere Leistungsverbesserungen.

Das obige ist der detaillierte Inhalt vonEffizientes Batch-Schreiben in DynamoDB mit Python: Eine Schritt-für-Schritt-Anleitung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!