Verwenden von AWS DynamoDB in Go: Eine vollständige Anleitung

Zitat:

Moderne Anwendungen erfordern leistungsstarke, zuverlässige, skalierbare und latenzarme Datenbanklösungen. Bei der Datenbankauswahl sind viele Faktoren zu berücksichtigen, wie z. B. Leistung, Wert, Skalierbarkeit und mehr. AWS DynamoDB ist eine vollständig verwaltete, nicht relationale Datenbank, die für die Verarbeitung von Big-Data-Sammlungen im Internetmaßstab entwickelt wurde und niedrige Latenz sowie skalierbare Speicher- und Abruffunktionen bietet. In diesem Artikel werfen wir einen detaillierten Blick auf AWS DynamoDB und konzentrieren uns dabei auf die Verwendung in der Go-Sprache.

1. Einführung in DynamoDB

AWS DynamoDB ist Teil des AWS-Cloud-Service und eine vollständig verwaltete, nicht relationale Datenbank, die große Datensammlungen nahtlos verarbeiten kann. Seine praktische API-Schnittstelle, geringe Latenz und hohe Durchsatzfähigkeiten, die bei Bedarf erweitert werden können, ermöglichen die Nutzung durch jede Anwendung. Der größte Vorteil von DynamoDB gegenüber anderen Datenbankanbietern ist die Geschwindigkeit, mit der Daten gespeichert und gelesen werden. Es verwendet SSD (Solid State Drive) als Standardspeichermethode, was das Lesen und Schreiben sehr schnell macht.

DynamoDB verfügt über eine einfache Schnittstelle und unterstützt eine große Anzahl von Programmiersprachen und Plattformen wie Java, JavaScript, Python, Ruby usw., einschließlich der Go-Sprache. DynamoDB unterstützt Datenspeicherung und Abfragevorgänge mithilfe mehrerer Datenmodelle basierend auf Dokumenten, Schlüsselwerten, Diagrammen usw. Die Datenspeicherung von DynamoDB erfolgt in Form von Tabellen. Jede Tabelle kann mehrere Projekte enthalten und jedes Projekt kann mehrere Attribute enthalten.

DynamoDB kann mit Hilfe der AWS Management Console oder des AWS SDK verwendet werden. Für die Ausführung des AWS SDK müssen Sie Ihre eigenen AWS-Zugangsdaten in den Code einfügen oder unsichere Umgebungsvariablen verwenden. Diese Schreibweise birgt Sicherheitsrisiken und ist für die Teamentwicklung nicht geeignet. Daher können wir mit dem AWS SDK for Go entwickeln, was eine elegantere und sicherere Lösung bietet.

2. Verwenden Sie AWS SDK für Go, um eine Verbindung zu DynamoDB herzustellen

Führen Sie den folgenden Befehl im Terminal aus, um das AWS SDK für Go zu installieren:

$ go get -u github.com/aws/aws-sdk-go

2

Bevor Sie eine Verbindung zu DynamoDB herstellen, müssen Sie den AWS-Zugriffsschlüssel und die Region konfigurieren, die vom AWS SDK for Go verwendet werden. Fügen Sie dazu den folgenden Code zu Ihrem Code hinzu:

sess := session.Must(session.NewSession(&aws.Config{
    Region: aws.String("us-west-2"),
    Credentials: credentials.NewStaticCredentials(
        "YOUR_ACCESS_KEY_ID", "YOUR_SECRET_ACCESS_KEY", ""),
}))

wobei Region und Anmeldeinformationen erforderliche Optionen sind. In der Region-Eigenschaft können Sie die AWS-Region angeben. Anmeldeinformationen sind ein Authentifizierungsmechanismus, der zum Herstellen einer Verbindung zu AWS-Diensten verwendet wird. Wenn Ihnen kein AWS-Zugriffszertifikat zugewiesen ist, können Sie auf der Seite „AWS-Verwaltung“ ein neues erstellen.

3. Tabellen erstellen und löschen

In DynamoDB ist eine Tabelle eine Sammlung von Elementen mit denselben Attributen, die zum Speichern und Abrufen von Daten verwendet werden können. Um eine neue Tabelle zu erstellen, müssen Attribute wie Tabellenname, Primärschlüssel und Kapazitätseinheiten bestimmt werden. Der folgende Code zeigt, wie Sie mit AWS SDK for Go eine DynamoDB-Tabelle erstellen:

svc := dynamodb.New(sess)

input := &dynamodb.CreateTableInput{
    AttributeDefinitions: []*dynamodb.AttributeDefinition{
        {
            AttributeName: aws.String("ID"),
            AttributeType: aws.String("N"),
        },
        {
            AttributeName: aws.String("Name"),
            AttributeType: aws.String("S"),
        },
    },
    KeySchema: []*dynamodb.KeySchemaElement{
        {
            AttributeName: aws.String("ID"),
            KeyType:       aws.String("HASH"),
        },
        {
            AttributeName: aws.String("Name"),
            KeyType:       aws.String("RANGE"),
        },
    },
    ProvisionedThroughput: &dynamodb.ProvisionedThroughput{
        ReadCapacityUnits:  aws.Int64(5),
        WriteCapacityUnits: aws.Int64(5),
    },
    TableName: aws.String("TableName"),
}
result, err := svc.CreateTable(input)
if err != nil {
    fmt.Println(err)
    return
}

fmt.Println(result)

Nach erfolgreicher Erstellung können Sie die neu erstellte Tabelle in der DynamoDB-Konsole anzeigen. Wenn Sie die Tabelle löschen möchten, verwenden Sie bitte den folgenden Code:

svc := dynamodb.New(sess)

input := &dynamodb.DeleteTableInput{
    TableName: aws.String("TableName"),
}

result, err := svc.DeleteTable(input)
if err != nil {
    fmt.Println(err)
    return
}

fmt.Println(result)

IV. Daten hinzufügen, lesen und löschen

1 Daten hinzufügen

Der folgende Code zeigt, wie Sie mit dem AWS SDK für Go Daten hinzufügen DynamoDB-Tabelle:

svc := dynamodb.New(sess)

input := &dynamodb.PutItemInput{
    Item: map[string]*dynamodb.AttributeValue{
        "ID": {
            N: aws.String("123"),
        },
        "Name": {
            S: aws.String("John"),
        },
        "Age": {
            N: aws.String("29"),
        },
    },
    TableName: aws.String("TableName"),
}

_, err := svc.PutItem(input)
if err != nil {
    fmt.Println(err)
    return
}

In In der PutItemInput-Schnittstelle wird die Item-Eigenschaft verwendet, um das Element anzugeben, das der Tabelle hinzugefügt werden soll, und die TableName-Eigenschaft wird verwendet, um den Tabellennamen anzugeben.

2. Daten lesen

Der folgende Code zeigt, wie man AWS SDK for Go verwendet, um Daten aus einer DynamoDB-Tabelle zu lesen:

svc := dynamodb.New(sess)

input := &dynamodb.GetItemInput{
    Key: map[string]*dynamodb.AttributeValue{
        "ID": {
            N: aws.String("123"),
        },
        "Name": {
            S: aws.String("John"),
        },
    },
    TableName: aws.String("TableName"),
}

result, err := svc.GetItem(input)
if err != nil {
    fmt.Println(err)
    return
}

for key, value := range result.Item {
    fmt.Println(
        key,
        ":",
        value.S,
        value.N,
        value.BOOL,
    )
}

In der GetItemInput-Schnittstelle wird das Key-Attribut verwendet, um die aus der Tabelle abgerufenen Elemente anzugeben Das TableName-Attribut wird für den angegebenen Tabellennamen verwendet. Die erhaltenen Daten werden in der Item-Eigenschaft des Rückgabeergebnisses gespeichert. Sie können die erhaltenen Daten mit einer Schleife durchlaufen und ausdrucken.

3. Daten löschen

Der folgende Code zeigt, wie man AWS SDK for Go verwendet, um Daten in einer DynamoDB-Tabelle zu löschen:

svc := dynamodb.New(sess)

input := &dynamodb.DeleteItemInput{
    Key: map[string]*dynamodb.AttributeValue{
        "ID": {
            N: aws.String("123"),
        },
        "Name": {
            S: aws.String("John"),
        },
    },
    TableName: aws.String("TableName"),
}

_, err := svc.DeleteItem(input)
if err != nil {
    fmt.Println(err)
    return
}

In DeleteItemInput wird das Key-Attribut verwendet, um das zu löschende Element und das TableName-Attribut anzugeben wird verwendet, um den Tabellennamen anzugeben.

5. Bedingte Ausdrücke verwenden

AWS DynamoDB ist sehr leistungsfähig und unterstützt die Verwendung von bedingten Ausdrücken zum Abfragen, Aktualisieren und Löschen von Daten. Bedingte Ausdrücke verwenden logische Operatoren wie UND-Operator, ODER-Operator, relationalen Operator, Funktion usw., um Bedingungen zu erstellen. Der folgende Code zeigt, wie Sie AWS SDK for Go verwenden, um Daten in einer DynamoDB-Tabelle basierend auf bestimmten Bedingungen abzufragen:

svc := dynamodb.New(sess)

input := &dynamodb.QueryInput{
    KeyConditionExpression: aws.String("ID = :idval"),
    ExpressionAttributeValues: map[string]*dynamodb.AttributeValue{
        ":idval": {
            S: aws.String("123"),
        },
    },
    TableName: aws.String("TableName"),
}

result, err := svc.Query(input)
if err != nil {
    fmt.Println(err)
    return
}

for _, item := range result.Items {
    fmt.Println(item)
}

In der QueryInput-Schnittstelle wird KeyConditionExpression verwendet, um die Bedingungen der Abfrage anzugeben, ExpressionAttributeValues ​​​​wird verwendet, um die anzugeben Wert der Bedingung und das TableName-Attribut gibt den Tabellennamen an.

6. Verwendung der Transaktionskontrolle in DynamoDB

AWS DynamoDB bietet Transaktionskontrollfunktionen, um die Integrität der logischen Transaktionseinheiten im Lese- und Schreibstatus sicherzustellen. DynamoDB-Transaktionen müssen die folgenden Merkmale erfüllen:

Vorgänge atomar und erfolgreich festschreiben oder zurücksetzen

Die Vorgänge zum Ausführen der Transaktion müssen in derselben Tabelle abgeschlossen werden.
2. Der folgende Code zeigt, wie Transaktionen in Go verwendet werden:

sess := session.Must(session.NewSessionWithOptions(session.Options{
    SharedConfigState: session.SharedConfigEnable,
}))

db := dynamodb.New(sess)

tableName := aws.String("product")

txOps := []*dynamodb.TransactWriteItem{
    {
        Delete: &dynamodb.Delete{
            TableName: aws.String(*tableName),
            Key: map[string]*dynamodb.AttributeValue{
                "product_id": {N: aws.String("1")},
            },
        },
    },
}

txCtxt := &dynamodb.TransactWriteItemsInput{
    TransactItems: txOps,
}

result, err := db.TransactWriteItems(txCtxt)
if err != nil {
    fmt.Println("failed to delete product 1")
    return
}

fmt.Println(result)

Im obigen Code erstellen wir zunächst den DynamoDB-Client und geben die zu verarbeitende Tabelle an. Anschließend wird eine Transaktionsoperation definiert, die den Produktdatensatz mit Schlüssel „1“ löscht. Definieren Sie abschließend ein DynamoDB-Transaktionskontextobjekt und übergeben Sie die auszuführenden Transaktionsvorgänge an die TransactWriteItems-Methode.

7. Verwenden Sie DynamoDB, um Daten bedingt zu aktualisieren

条件更新是将新值写回项目时使用的一种机制。当特定条件被给定时，更新操作将执行。要使用条件更新，必须满足以下条件：

1. 更新目标必须存在；
2. 更新操作必须基于某个条件执行。

下面是一个条件更新的示例：

updateInput := &dynamodb.UpdateItemInput{
    TableName: aws.String("product"),
    Key: map[string]*dynamodb.AttributeValue{
        "product_id": {N: aws.String("2")},
    },
    UpdateExpression: aws.String("set productName = :n"),
    ConditionExpression: aws.String("attribute_exists(product_id)"),
    ExpressionAttributeValues: map[string]*dynamodb.AttributeValue{
        ":n": {S: aws.String("product_name_new")},
    },
}

_, err = db.UpdateItem(updateInput)
if err != nil {
    fmt.Println(err)
    return
}

上述示例是使用条件更新更新了产品ID为“2”的产品名称。在条件表达式中，我们使用了attribute_exists函数来检查该项目是否存在。

八、总结

在本文中，我们深入介绍了 DynamoDB 及其在Go语言中的使用方法。我们讨论了配置 AWS SDK for Go，创建和删除表，添加、读取和删除数据，使用条件表达式，事务控制以及条件更新数据。由于 DynamoDB 具有可伸缩性、高可用性和良好的性能，因此可以成为处理大规模数据集合的首选数据库解决方案之一。

如果您想开始使用 AWS DynamoDB 和 Go，强烈建议您参考 AWS 官方文档 以便获得更详细的信息和 API 示例。

Das obige ist der detaillierte Inhalt vonVerwenden von AWS DynamoDB in Go: Eine vollständige Anleitung. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!