Bewährte Methoden für die Implementierung der Versionskontrolle in DynamoDB - Amazon DynamoDB
Wann dieses Muster verwendet werden sollteMusterdesignVerwenden des Musters

Die vorliegende Übersetzung wurde maschinell erstellt. Im Falle eines Konflikts oder eines Widerspruchs zwischen dieser übersetzten Fassung und der englischen Fassung (einschließlich infolge von Verzögerungen bei der Übersetzung) ist die englische Fassung maßgeblich.

Bewährte Methoden für die Implementierung der Versionskontrolle in DynamoDB

In verteilten Systemen wie DynamoDB verhindert die Elementversionskontrolle mithilfe einer optimistischen Sperre widersprüchliche Aktualisierungen. Durch die Nachverfolgung von Elementversionen und die Verwendung bedingter Schreibvorgänge können Anwendungen gleichzeitige Änderungen verwalten und so die Datenintegrität in Umgebungen mit hoher Parallelität sicherstellen.

Die optimistische Sperre ist eine Strategie, mit der sichergestellt werden soll, dass Datenänderungen korrekt und ohne Konflikte angewendet werden. Anstatt Daten beim Lesen zu sperren (wie bei der pessimistischen Sperre), prüft die optimistische Sperre, ob sich Daten geändert haben, bevor sie zurückgeschrieben werden. In DynamoDB wird dies durch eine Form der Versionskontrolle erreicht, bei der jedes Element einen Bezeichner enthält, der mit jeder Aktualisierung erhöht wird. Beim Aktualisieren eines Elements ist der Vorgang nur erfolgreich, wenn dieser Bezeichner mit dem von Ihrer Anwendung erwarteten übereinstimmt.

Wann dieses Muster verwendet werden sollte

Diese Funktion ist in den folgenden Szenarien nützlich:

  • Möglicherweise versuchen mehrere Benutzer oder Prozesse, dasselbe Element gleichzeitig zu aktualisieren.

  • Die Sicherstellung der Datenintegrität und -konsistenz ist von größter Bedeutung.

  • Der Aufwand und die Komplexität der Verwaltung verteilter Sperren müssen vermieden werden.

Zu den Beispielen gehören:

  • E-Commerce-Anwendungen, bei denen die Lagerbestände häufig aktualisiert werden

  • Plattformen für die Zusammenarbeit, auf denen mehrere Benutzer dieselben Daten bearbeiten

  • Finanzsysteme, in denen Transaktionsaufzeichnungen konsistent bleiben müssen

Kompromisse

Optimistische Sperren und bedingte Prüfungen sorgen zwar für eine robuste Datenintegrität, sind jedoch mit den folgenden Kompromissen verbunden:

Konflikte im Zusammenhang mit der Parallelität

In Umgebungen mit hoher Parallelität steigt die Wahrscheinlichkeit von Konflikten, was zu mehr Wiederholungen und höheren Schreibkosten führen kann

Komplexität der Implementierung

Das Hinzufügen von Versionskontrollen zu Elementen und die Handhabung bedingter Prüfungen können die Anwendungslogik komplexer machen.

Zusätzlicher Speicher-Overhead

Das Speichern von Versionsnummern für jedes Element erhöht den Speicherbedarf geringfügig.

Musterdesign

Um dieses Muster zu implementieren, sollte das DynamoDB-Schema für jedes Element ein Versionsattribut enthalten. Hier ist ein einfacher Schemaentwurf:

  • Partitionsschlüssel – ein eindeutiger Bezeichner für jedes Element (z. B ItemId)

  • Attribute:

    • ItemId – der eindeutige Bezeichner für das Element

    • Version – eine Ganzzahl, die die Versionsnummer des Elements darstellt

    • QuantityLeft – der verbleibende Bestand des Elements

Wenn ein Element zum ersten Mal erstellt wird, wird das Attribut Version auf 1 gesetzt. Mit jeder Aktualisierung wird die Versionsnummer um 1 erhöht.

Implementierung von Musterdesigns für Versionsattribute

Verwenden des Musters

Gehen Sie in Ihrem Anwendungsfluss wie folgt vor, um dieses Muster zu implementieren:

  1. Die aktuelle Version des Elements.

    Rufen Sie das aktuelle Element aus DynamoDB ab und lesen Sie seine Versionsnummer.

    def get_document(item_id):
    response = table.get_item(Key={'ItemID': item_id})
    return response['Item']

document = get_document('Bananas')
current_version = document['Version']

  2. Erhöhen Sie die Versionsnummer in Ihrer Anwendungslogik. Dies wird die erwartete Version für die Aktualisierung sein.

    new_version = current_version + 1

  3. Versuchen Sie, das Element mithilfe eines bedingten Ausdrucks zu aktualisieren, um sicherzustellen, dass die Versionsnummer übereinstimmt.

    def update_document(item_id, qty_bought, current_version):
    try:
        response = table.update_item(
            Key={'ItemID': item_id},
            UpdateExpression="set #qty = :qty, Version = :v",
            ConditionExpression="Version = :expected_v",
            ExpressionAttributeNames={
                '#qty': 'QuantityLeft'
            },
            ExpressionAttributeValues={
                ':qty': qty_bought,
                ':v': current_version + 1,
                ':expected_v': current_version
            },
            ReturnValues="UPDATED_NEW"
        )
        return response
    except ClientError as e:
        if e.response['Error']['Code'] == 'ConditionalCheckFailedException':
            print("Update failed due to version conflict.")
        else:
            print("Unexpected error: %s" % e)
        return None

update_document('Bananas', 2, new_version)

    Wenn das Update erfolgreich ist, wird der Wert QuantityLeft für den Artikel um 2 reduziert.

    Wenn das Update erfolgreich ist, wird der Wert QuantityLeft für den Artikel um 2 reduziert.

  4. Behandeln Sie eventuell auftretende Konflikte.

    Wenn ein Konflikt auftritt (z. B. weil ein anderer Prozess das Element aktualisiert hat, seit Sie es zuletzt gelesen haben), gehen Sie angemessen mit dem Konflikt um, z. B. indem Sie den Vorgang wiederholen oder den Benutzer benachrichtigen.

    Da für jede Wiederholung ein zusätzliches Lesen des Elements erforderlich ist, sollten Sie die Gesamtzahl der zulässigen Wiederholungen begrenzen, bevor die Anforderungsschleife vollständig fehlschlägt.

    def update_document_with_retry(item_id, new_data, retries=3):
    for attempt in range(retries):
        document = get_document(item_id)
        current_version = document['Version']
        
        result = update_document(item_id, qty_bought, current_version)
        
        if result is not None:
            print("Update succeeded.")
            return result
        else:
            print(f"Retrying update... ({attempt + 1}/{retries})")
            
    print("Update failed after maximum retries.")
    return None

update_document_with_retry('Bananas', 2)

    Die Implementierung der Elementversionskontrolle mithilfe von DynamoDB mit optimistischen Sperren und bedingten Prüfungen ist ein leistungsstarkes Muster zur Sicherstellung der Datenintegrität in verteilten Anwendungen. Es bringt zwar eine gewisse Komplexität und potenzielle Leistungseinbußen mit sich, ist aber in Szenarien, die eine robuste Parallelitätskontrolle erfordern, von unschätzbarem Wert. Durch den sorgfältigen Entwurf des Schemas und die Implementierung der erforderlichen Prüfungen in Ihrer Anwendungslogik können Sie gleichzeitige Aktualisierungen effektiv verwalten und die Datenkonsistenz aufrechterhalten.

    Weitere Anleitungen und Strategien zur Implementierung der Versionskontrolle für Ihre DynamoDB-Daten finden Sie im AWS Database Blog.