DynamoDB-Transaktionen

Auf der re:Invent 2018 hat AWS die Unterstützung von Amazon DynamoDB für Transaktionen veröffentlicht. DynamoDB-Transaktionen werden im AWS News Blog beschrieben. Transaktionen sorgen für Atomarität, Konsistenz, Isolierung und Dauerhaftigkeit (ACID) in DynamoDB, so dass Sie die Datenkorrektheit in Ihren Anwendungen einfacher aufrechterhalten können. Mithilfe von Transaktionen können Sie anspruchsvolle Workflows und Geschäftslogik unterstützen, die das Hinzufügen, Aktualisieren oder Löschen mehrerer Elemente als eine einzige Alles-oder-Nichts-Operation erfordern. Schauen wir uns das mal an!

Neue Operationen

Um DynamoDB-Transaktionen zu unterstützen, hat AWS zwei neue Operationen zur API hinzugefügt:

• TransactWriteItems: eine Batch-Operation, die ein Schreibset mit einer oder mehreren PutItem-, UpdateItem- und DeleteItem-Operationen enthält. TransactWriteItems kann optional auf Vorbedingungen prüfen, die erfüllt sein müssen, bevor Aktualisierungen vorgenommen werden. Diese Bedingungen können sich auf die gleichen oder andere Elemente beziehen als die in der Schreibmenge. Wenn eine Bedingung nicht erfüllt ist, wird die Transaktion abgelehnt.
• TransactGetItems: eine Batch-Operation, die einen Lesesatz mit einer oder mehreren GetItem-Operationen enthält. Wenn eine TransactGetItems-Anfrage für ein Element gestellt wird, das Teil einer aktiven Schreibtransaktion ist, wird die Lesetransaktion abgebrochen. Um den zuvor bestätigten Wert zu erhalten, können Sie einen Standard-Lesevorgang verwenden.

Beispiel

Das folgende Beispiel verwendet die Go-API und schreibt mit der TransactWriteItems-API in die Tabellen Owner und Cats. Nach erfolgreichem Schreiben liest ein TransactGetItems-API-Aufruf aus denselben beiden Tabellen und schreibt das Ergebnis in die Konsole.

package main

import (
    "fmt"
    "github.com/aws/aws-sdk-go/aws"
    "github.com/aws/aws-sdk-go/aws/session"
    "github.com/aws/aws-sdk-go/service/dynamodb"
    "github.com/aws/aws-sdk-go/service/dynamodb/dynamodbattribute"
    "log"
)

type Cat struct {
    ID      string
    Name    string
    Age     int
    OwnerID string
}

type Owner struct {
    ID     string
    Name   string
    Age    int
    CatIds []string
}

func CreateDynamoDBClient(region string) (*dynamodb.DynamoDB, error) {
    sess, err := session.NewSession()
    if err != nil {
        return nil, err
    }
    svc := dynamodb.New(sess, aws.NewConfig().WithRegion(region))
    return svc, nil
}

func main() {
    owner := Owner{
        ID:     "1",
        Name:   "Dennis",
        Age:    42,
        CatIds: []string{"1", "2"},
    }
    elsa := Cat{
        ID:      "1",
        Name:    "Elsa",
        Age:     16,
        OwnerID: "1",
    }
    tijger := Cat{
        ID:      "2",
        Name:    "Tijger",
        Age:     12,
        OwnerID: "1",
    }
    OwnerAV, err := dynamodbattribute.MarshalMap(owner)
    if err != nil {
        log.Fatal(err)
    }
    ElsaAV, err2 := dynamodbattribute.MarshalMap(elsa)
    if err2 != nil {
        log.Fatal(err)
    }
    TijgerAV, err3 := dynamodbattribute.MarshalMap(tijger)
    if err != nil {
        log.Fatal(err3)
    }
    svc, err := CreateDynamoDBClient("eu-west-1")
    if err != nil {
        log.Fatal(err)
    }
    _, err4 := svc.TransactWriteItems(&dynamodb.TransactWriteItemsInput{
        TransactItems: []*dynamodb.TransactWriteItem{
            {
                Put: &dynamodb.Put{
                    TableName: aws.String("Owners"),
                    Item:      OwnerAV,
                },
            },
            {
                Put: &dynamodb.Put{
                    TableName: aws.String("Cats"),
                    Item:      ElsaAV,
                },
            },
            {
                Put: &dynamodb.Put{
                    TableName: aws.String("Cats"),
                    Item:      TijgerAV,
                },
            },
        },
    })
    if err != nil {
        log.Fatal(err4)
    }
    res, err5 := svc.TransactGetItems(&dynamodb.TransactGetItemsInput{
        TransactItems: []*dynamodb.TransactGetItem{
            {
                Get: &dynamodb.Get{
                    TableName: aws.String("Cats"),
                    Key: map[string]*dynamodb.AttributeValue{
                        "ID": {
                            S: aws.String("1"),
                        },
                    },
                },
            },
            {
                Get: &dynamodb.Get{
                    TableName: aws.String("Cats"),
                    Key: map[string]*dynamodb.AttributeValue{
                        "ID": {
                            S: aws.String("2"),
                        },
                    },
                },
            },
            {
                Get: &dynamodb.Get{
                    TableName: aws.String("Owners"),
                    Key: map[string]*dynamodb.AttributeValue{
                        "ID": {
                            S: aws.String("1"),
                        },
                    },
                },
            },
        },

    })
    if err != nil {
        log.Fatal(err5)
    }

    for _, item := range res.Responses {
        fmt.Print(item.Item)
    }
}

Fazit

DynamoDB Transactions wird durch die Operationen TransactWriteItems und TransactGetItems bereitgestellt. Durch die ACID-Garantien kann DynamoDB verwendet werden, um zwei oder mehr Regionstabellen konsistent zu halten, und ebnet den Weg für neue Cloud-Datenarchitekturen mit DynamoDB.