Utilisation d'AWS DynamoDB dans Go : un guide complet

Citation :

Les applications modernes nécessitent des solutions de bases de données puissantes, fiables, évolutives et à faible latence. De nombreux facteurs doivent être pris en compte lors de la sélection d'une base de données, tels que les performances, la valeur, l'évolutivité, etc. AWS DynamoDB est une base de données non relationnelle entièrement gérée, conçue pour gérer les collections de Big Data à l'échelle Internet, offrant des capacités de stockage et de récupération à faible latence et évolutives. Dans cet article, nous examinerons en profondeur AWS DynamoDB, en nous concentrant sur la façon de l'utiliser dans le langage Go.

1. Introduction à DynamoDB

AWS DynamoDB fait partie du service cloud AWS et est une base de données non relationnelle entièrement gérée qui peut gérer de manière transparente des collections de données à grande échelle. Son interface API pratique, sa faible latence et ses capacités de débit élevé qui peuvent être étendues à la demande permettent à n'importe quelle application de l'utiliser. Le plus grand avantage de DynamoDB par rapport aux autres fournisseurs de bases de données réside dans la vitesse à laquelle il stocke et lit les données. Il utilise le SSD (Solid State Drive) comme méthode de stockage par défaut, ce qui le rend très rapide en lecture et en écriture.

DynamoDB possède une interface simple et prend en charge un grand nombre de langages et de plateformes de programmation, tels que Java, JavaScript, Python, Ruby, etc., y compris le langage Go. DynamoDB prend en charge les opérations de stockage de données et de requêtes à l'aide de plusieurs modèles de données basés sur des documents, des valeurs-clés, des graphiques, etc. Le stockage des données de DynamoDB se présente sous la forme de tables. Chaque table peut contenir plusieurs projets et chaque projet peut contenir plusieurs attributs.

DynamoDB peut être utilisé à l'aide d'AWS Management Console ou du SDK AWS L'exécution du SDK AWS nécessite de placer vos propres informations d'identification d'accès AWS dans le code ou d'utiliser des variables d'environnement non sécurisées. Cette façon d’écrire comporte des risques de sécurité et n’est pas pratique pour le développement d’une équipe. Par conséquent, nous pouvons développer à l'aide du kit AWS SDK for Go, qui offre une solution plus élégante et plus sécurisée.

2. Utilisez AWS SDK for Go pour vous connecter à DynamoDB

1 Installez AWS SDK for Go

Exécutez la commande suivante dans le terminal pour installer AWS SDK for Go :

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

2.

avant de vous connecter à DynamoDB, vous devez configurer la clé d'accès AWS et la région utilisées par le kit AWS SDK for Go. Pour ce faire, ajoutez le code suivant à votre code :

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

où Région et Informations d'identification sont des options obligatoires. Dans la propriété Region, vous pouvez spécifier la région AWS. Les informations d'identification sont un mécanisme d'authentification utilisé pour se connecter aux services AWS. Si aucun certificat d'accès AWS n'est attribué, vous pouvez en créer un nouveau sur la page de gestion AWS.

3. Créer et supprimer des tables

Dans DynamoDB, une table est une collection d'éléments avec les mêmes attributs qui peuvent être utilisés pour stocker et récupérer des données. Afin de créer une nouvelle table, des attributs tels que le nom de la table, la clé primaire et les unités de capacité doivent être déterminés. Le code suivant montre comment utiliser le kit AWS SDK for Go pour créer une table DynamoDB :

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)

Une fois la création réussie, vous pouvez afficher la table nouvellement créée dans la console DynamoDB. Si vous souhaitez supprimer la table, veuillez utiliser le code suivant :

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. Ajouter, lire et supprimer des données

1 Ajouter des données

Le code suivant montre comment utiliser AWS SDK for Go pour ajouter des données à une DynamoDB. table :

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 Dans l'interface PutItemInput, la propriété Item est utilisée pour spécifier l'élément à ajouter à la table et la propriété TableName est utilisée pour spécifier le nom de la table.

2. Lire les données

Le code suivant montre comment utiliser AWS SDK for Go pour lire les données d'une table DynamoDB :

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,
    )
}

Dans l'interface GetItemInput, l'attribut Key est utilisé pour spécifier les éléments récupérés de la table, et l'attribut TableName est utilisé sur le nom de table spécifié. Les données obtenues sont stockées dans la propriété Item du résultat renvoyé. Vous pouvez utiliser une boucle pour parcourir les données obtenues et les imprimer.

3. Supprimer des données

Le code suivant montre comment utiliser AWS SDK for Go pour supprimer des données dans une table DynamoDB :

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
}

Dans DeleteItemInput, l'attribut Key est utilisé pour spécifier l'élément à supprimer et l'attribut TableName. est utilisé pour spécifier le nom de la table.

5. Utiliser des expressions conditionnelles

AWS DynamoDB est assez puissant et prend en charge l'utilisation d'expressions conditionnelles pour interroger, mettre à jour et supprimer des données. Les expressions conditionnelles utilisent des opérateurs logiques tels que l'opérateur AND, l'opérateur OR, l'opérateur relationnel, la fonction, etc. pour créer des conditions. Le code suivant montre comment utiliser AWS SDK for Go pour interroger des données dans une table DynamoDB en fonction de conditions spécifiques :

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)
}

Dans l'interface QueryInput, KeyConditionExpression est utilisé pour spécifier les conditions de la requête, ExpressionAttributeValues ​​​​est utilisé pour spécifier les valeur de la condition et l'attribut TableName spécifie le nom de la table.

6. Utilisation du contrôle des transactions dans DynamoDB

AWS DynamoDB fournit des fonctions de contrôle des transactions pour garantir l'intégrité des unités logiques des transactions dans les états de lecture et d'écriture. Les transactions DynamoDB doivent répondre aux caractéristiques suivantes :

Traitement des opérations de validation ou d'annulation de manière atomique et réussie
1. Les opérations pour exécuter la transaction doivent être effectuées dans la même table ;

Le code suivant montre comment utiliser les transactions dans Go :

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)

Dans le code ci-dessus, nous créons d'abord le client DynamoDB et spécifions la table à traiter. Ensuite, une opération de transaction est définie qui supprime l'enregistrement de données produit avec la clé "1". Enfin, définissez un objet de contexte de transaction DynamoDB et transmettez les opérations de transaction à effectuer à la méthode TransactWriteItems.

7. Utilisez DynamoDB pour mettre à jour les données de manière conditionnelle

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

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 示例。

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!