Le SDK AWS mobile pour Unity est désormais inclus dans le AWS SDK pour .NET. Ce guide fait référence à la version archivée du SDK mobile pour Unity. Pour de plus amples informations, veuillez consulter [Qu'est-ce que le SDK AWS mobile pour Unity ?](what-is-unity-plugin.md).
Les traductions sont fournies par des outils de traduction automatique. En cas de conflit entre le contenu d'une traduction et celui de la version originale en anglais, la version anglaise prévaudra.
# Amazon DynamoDB
[Amazon DynamoDB](https://aws.amazon.com/dynamodb/) est un service de base de données non relationnelle rapide, économique, très évolutif et hautement disponible. DynamoDB permet de s'affranchir des limites habituelles du dimensionnement de stockage de données, tout en conservant une faible latence et des performances prévisibles. Pour plus d'informations sur DynamoDB, consultez la page [Amazon DynamoDB](https://aws.amazon.com/dynamodb/).
Le kit SDK AWS Mobile pour Unity fournit une bibliothèque de haut niveau pour l'utilisation de DynamoDB. Vous pouvez également envoyer des requêtes directement à l'API DynamoDB de bas niveau, mais pour la plupart des cas d'utilisation, il est recommandée d'utiliser la bibliothèque de haut niveau. AmazonDynamoDBClient Il s'agit d'une partie particulièrement utile de la bibliothèque de haut niveau. Cette classe vous permet d'effectuer diverses opérations de création, de lecture, de mise à jour et de suppression, et d'exécuter des requêtes.
**Note**
Certains des exemples présentés dans ce document supposent l'utilisation d'une variable de zone de texte appelée ResultText pour afficher le résultat du suivi.
## Intégration d'Amazon DynamoDB
Pour utiliser DynamoDB dans une application Unity, vous devez ajouter le kit SDK pour Unity dans votre projet. Si ce n'est pas encore fait, [téléchargez le kit SDK pour Unity](https://aws.amazon.com/mobile/sdk/) et suivez les instructions fournies à la section [Configurer le kit SDK AWS Mobile pour Unity](setup-unity.md). Nous vous conseillons d'utiliser Amazon Cognito Identity pour fournir des informations d'identification AWS temporaires à vos applications. Ces informations permettent à votre application d'accéder aux ressources et services AWS.
Pour utiliser DynamoDB dans une application, vous devez définir les autorisations appropriées. La stratégie IAM suivante permet à l'utilisateur de supprimer, d'obtenir, de placer, d'analyser et de mettre à jour des éléments dans une table DynamoDB, qui est identifiée par son [ARN](https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html) :
```
{
"Statement": [{
"Effect": "Allow",
"Action": [
"dynamodb:DeleteItem",
"dynamodb:GetItem",
"dynamodb:PutItem",
"dynamodb:Scan",
"dynamodb:UpdateItem"
],
"Resource": "arn:aws:dynamodb:us-west-2:123456789012:table/MyTable"
}]
}
```
Cette stratégie doit être appliquée aux rôles assignés au groupe d'identités Cognito, mais vous devez remplacer la valeur ** `Resource` ** par l'ARN approprié pour votre table DynamoDB. Cognito crée automatiquement un rôle pour votre nouveau groupe d'identités. Vous pouvez lui appliquer des stratégies via la [console IAM](https://console.aws.amazon.com/iam/).
Ajoutez ou supprimez ensuite des actions autorisées selon les besoins de votre application. Pour plus d'informations sur les stratégies IAM, consultez [Utilisation d'IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_Introduction.html). Pour en savoir plus sur les stratégies DynamoDB, consultez la page [Utilisation d'IAM pour contrôler l'accès aux ressources DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/UsingIAMWithDDB.html).
## Créer une table DynamoDB
Maintenant que les autorisations et les informations d'identification sont définies, nous allons créer une table DynamoDB pour notre application. Pour créer une table, accédez à la [console DynamoDB](https://console.aws.amazon.com/dynamodb/home) et procédez comme suit :
1. Cliquez sur **Créer une table**.
1. Entrez `Bookstore` comme nom de la table.
1. Sélectionnez **Hachage** comme type de clé primaire.
1. Sélectionnez **Nombre** et entrez `id` comme nom d'attribut de hachage. Cliquez sur **Continuer**.
1. Cliquez à nouveau sur **Continuer** pour ne pas ajouter d'index.
1. Définissez la capacité en lecture à `10` et la capacité en écriture à `5`. Cliquez sur **Continuer**.
1. Saisissez un e-mail de notification et cliquez sur **Continuer** pour créer des alarmes relatives au débit.
1. Cliquez sur **Create**. DynamoDB crée alors votre base de données.
## Créer un client DynamoDB
Pour que notre application interagisse avec une table DynamoDB, nous avons besoin d'un client. Nous pouvons créer un client DynamodDB par défaut comme suit :
```
var credentials = new CognitoAWSCredentials(IDENTITY_POOL_ID, RegionEndpoint.USEast1);
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials);
DynamoDBContext Context = new DynamoDBContext(client);
```
La AmazonDynamo DBClient classe est le point d'entrée de l'API DynamoDB. La classe fournit des méthodes d'instanciation pour créer, décrire, mettre à jour et supprimer des tables, entre autres opérations. Le contexte ajoute une nouvelle couche d'abstraction au client et vous permet d'utiliser des fonctionnalités supplémentaires, telles que le modèle de persistance des objets.
## Décrire une table
Pour obtenir la description de notre table DynamoDB, nous pouvons utiliser le code suivant :
```
resultText.text +=("\n*** Retrieving table information ***\n");
var request = new DescribeTableRequest
{
TableName = @"ProductCatalog"
};
Client.DescribeTableAsync(request, (result) =>
{
if (result.Exception != null)
{
resultText.text += result.Exception.Message;
Debug.Log(result.Exception);
return;
}
var response = result.Response;
TableDescription description = response.Table;
resultText.text += ("Name: " + description.TableName + "\n");
resultText.text += ("# of items: " + description.ItemCount + "\n");
resultText.text += ("Provision Throughput (reads/sec): " +
description.ProvisionedThroughput.ReadCapacityUnits + "\n");
resultText.text += ("Provision Throughput (reads/sec): " +
description.ProvisionedThroughput.WriteCapacityUnits + "\n");
}, null);
}
```
Dans cet exemple, nous créons un client et un DescribeTableRequest objet, attribuons le nom de notre table à la **`TableName`**propriété, puis transmettons l'objet de requête à la DescribeTableAsync méthode de l' AmazonDynamoDBClient objet. DescribeTableAsync prend également un délégué qui sera appelé lorsque l'opération asynchrone sera terminée.
**Note**
Toutes les méthodes asynchrones des délégués de AmazonDynamo DBClient prise qui sont appelées lorsque l'opération asynchrone est terminée.
## Enregistrer un objet
Pour enregistrer un objet dans DynamoDB, utilisez SaveAsync la méthode de l'objet, où T est AmazonDynamo DBClient le type d'objet que vous enregistrez.
Nous avons appelé notre base de données « Bookstore » (« Librairie »), et en accord avec ce thème, nous allons mettre en place un modèle de données qui enregistre les attributs liés aux livres. Voici les classes qui définissent notre modèle de données.
```
[DynamoDBTable("ProductCatalog")]
public class Book
{
[DynamoDBHashKey] // Hash key.
public int Id { get; set; }
[DynamoDBProperty]
public string Title { get; set; }
[DynamoDBProperty]
public string ISBN { get; set; }
[DynamoDBProperty("Authors")] // Multi-valued (set type) attribute.
public List BookAuthors { get; set; }
}
```
Bien entendu, pour une application de librairie réelle, nous aurions besoin de champs supplémentaires pour renseigner des données comme l'auteur et le prix. La classe Book est décorée avec l'attribut [DynamoDBTable], qui définit les objets de table de base de données du type Book dans lesquels seront écrits les objets. La clé de chaque instance de la classe Book est identifiée à l'aide de l'attribut [Dynamo DBHash Key]. Les propriétés sont identifiées par l'attribut [DynamoDBProperty], qui indique la colonne de la table de base de données dans laquelle la propriété sera écrite. Une fois le modèle en place, nous pouvons enregistrer certaines méthodes pour créer, extraire, mettre à jour et supprimer des objets Livre.
## Créer un livre
```
private void PerformCreateOperation()
{
Book myBook = new Book
{
Id = bookID,
Title = "object persistence-AWS SDK for.NET SDK-Book 1001",
ISBN = "111-1111111001",
BookAuthors = new List { "Author 1", "Author 2" },
};
// Save the book.
Context.SaveAsync(myBook,(result)=>{
if(result.Exception == null)
resultText.text += @"book saved";
});
}
```
## Récupérer un livre
```
private void RetrieveBook()
{
this.displayMessage += "\n*** Load book**\n";
Context.LoadAsync(bookID,
(AmazonDynamoResult result) =>
{
if (result.Exception != null)
{
this.displayMessage += ("LoadAsync error" +result.Exception.Message);
Debug.LogException(result.Exception);
return;
}
_retrievedBook = result.Response;
this.displayMessage += ("Retrieved Book: " +
"\nId=" + _retrievedBook.Id +
"\nTitle=" + _retrievedBook.Title +
"\nISBN=" + _retrievedBook.ISBN);
string authors = "";
foreach(string author in _retrievedBook.BookAuthors)
authors += author + ",";
this.displayMessage += "\nBookAuthor= "+ authors;
this.displayMessage += ("\nDimensions= "+ _retrievedBook.Dimensions.Length + " X " +
_retrievedBook.Dimensions.Height + " X " +
_retrievedBook.Dimensions.Thickness);
}, null);
}
```
## Mettre à jour un livre
```
private void PerformUpdateOperation()
{
// Retrieve the book.
Book bookRetrieved = null;
Context.LoadAsync(bookID,(result)=>
{
if(result.Exception == null )
{
bookRetrieved = result.Result as Book;
// Update few properties.
bookRetrieved.ISBN = "222-2222221001";
// Replace existing authors list with this
bookRetrieved.BookAuthors = new List { "Author 1", "Author x" };
Context.SaveAsync(bookRetrieved,(res)=>
{
if(res.Exception == null)
resultText.text += ("\nBook updated");
});
}
});
}
```
## Supprimer un livre
```
private void PerformDeleteOperation()
{
// Delete the book.
Context.DeleteAsync(bookID,(res)=>
{
if(res.Exception == null)
{
Context.LoadAsync(bookID,(result)=>
{
Book deletedBook = result.Result;
if(deletedBook==null)
resultText.text += ("\nBook is deleted");
});
}
});
}
```