El SDK AWS móvil para Unity ahora está incluido en AWS SDK para .NET. Esta guía hace referencia a la versión archivada de Mobile SDK para Unity. Para obtener más información, consulte [¿Qué es el SDK AWS móvil para Unity?](what-is-unity-plugin.md)
Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.
# Amazon DynamoDB
[Amazon DynamoDB](https://aws.amazon.com/dynamodb/) es un servicio de base de datos no relacional rentable y rápido, de alta disponibilidad y de alta escalabilidad. DynamoDB elimina las limitaciones tradicionales de escalabilidad del almacenamiento de datos y, al mismo tiempo, mantiene una baja latencia y un desempeño previsible. Para obtener más información acerca de DynamoDB, consulte [Amazon DynamoDB](https://aws.amazon.com/dynamodb/).
AWS Mobile SDK para Unity proporciona una biblioteca de alto nivel para trabajar con DynamoDB. También se pueden realizar solicitudes directamente en la API de DynamoDB de bajo nivel, pero para la mayoría de los casos de uso se recomienda trabajar con la biblioteca de alto nivel. AmazonDynamoDBClient Es una parte especialmente útil de la biblioteca de alto nivel. Con esta clase, puede realizar varias operaciones de creación, lectura, actualización y eliminación (CRUD, Create, Read, Update and Delete) y ejecutar consultas.
**nota**
Algunos de los ejemplos de este documento asumen el uso de una variable de cuadro de texto llamada ResultText para mostrar el resultado del rastreo.
## Integración de Amazon DynamoDB
Para utilizar DynamoDB en una aplicación de Unity, tendrá que añadir el SDK de Unity al proyecto. Si aún no lo ha hecho, [descargue el SDK de Unity](https://aws.amazon.com/mobile/sdk/) y siga las instrucciones que se detallan en [Configurar el AWS Mobile SDK para Unity](setup-unity.md). Le recomendamos que utilice Amazon Cognito Identity para proporcionar credenciales temporales de AWS para sus aplicaciones. Estas credenciales permiten a la aplicación obtener acceso a los servicios y recursos de AWS.
Para utilizar DynamoDB en una aplicación, debe definir los permisos correctos. La siguiente política de IAM permite al usuario eliminar, obtener, colocar, examinar y actualizar elementos en una tabla de DynamoDB, que se identifica mediante un [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"
}]
}
```
Esta política se debe aplicar a los roles asignados al grupo de identidades de Cognito, pero debe sustituir el valor de **`Resource`** por el ARN correcto para su tabla de DynamoDB. Cognito crea automáticamente un rol para el nuevo grupo de identidades y el usuario puede aplicar las políticas a ese rol en la [consola de IAM](https://console.aws.amazon.com/iam/).
Debe añadir o eliminar acciones permitidas en función de las necesidades de su aplicación. Para obtener más información acerca de las políticas de IAM, consulte [cómo usar IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_Introduction.html). Para obtener más información acerca de las políticas específicas de DynamoDB, consulte [cómo usar IAM para controlar el acceso a los recursos de DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/UsingIAMWithDDB.html).
## Creación de una tabla de DynamoDB
Ahora que tenemos los permisos y las credenciales configurados, vamos a crear una tabla de DynamoDB para su aplicación. Para crear una tabla, vaya a la [consola de DynamoDB](https://console.aws.amazon.com/dynamodb/home) y siga estos pasos:
1. Haga clic en **Create Table (Crear tabla)**.
1. Escriba `Bookstore` como nombre de la tabla.
1. Seleccione **Hash (Hash)** como tipo de clave principal.
1. Seleccione **Number (Número)** y escriba `id` en el nombre del atributo hash. Haga clic en **Continue (Continuar)**.
1. Haga clic de nuevo en **Continue (Continuar)** para omitir la adición de índices.
1. Establezca la capacidad de lectura en `10` y la capacidad de escritura en `5`. Haga clic en **Continue (Continuar)**.
1. Escriba un correo electrónico de notificación y haga clic en **Continue (Continuar)** para crear alarmas de rendimiento.
1. Haga clic en **Crear**. DynamoDB creará la base de datos.
## Creación de un cliente de DynamoDB
Para que la aplicación interactúe con una tabla de DynamoDB, necesitamos un cliente. Podemos crear un cliente predeterminado de DynamodDB de la siguiente forma:
```
var credentials = new CognitoAWSCredentials(IDENTITY_POOL_ID, RegionEndpoint.USEast1);
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials);
DynamoDBContext Context = new DynamoDBContext(client);
```
La AmazonDynamo DBClient clase es el punto de entrada a la API de DynamoDB. La clase proporciona métodos de instancia para crear, describir, actualizar y eliminar tablas, entre otras operaciones. Context añade una nueva capa de abstracción en el cliente y permite utilizar funcionalidades adicionales como el modelo de persistencia de objetos.
## Descripción de una tabla
Para obtener una descripción de la tabla de DynamoDB, podemos utilizar el código siguiente:
```
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);
}
```
En este ejemplo, creamos un cliente y un DescribeTableRequest objeto, asignamos el nombre de nuestra tabla a la **`TableName`**propiedad y, a continuación, pasamos el objeto de solicitud al DescribeTableAsync método del objeto. AmazonDynamo DBClient DescribeTableAsync también utiliza un delegado al que se llamará cuando se complete la operación asíncrona.
**nota**
Todos los métodos asíncronos de la operación asíncrona AmazonDynamo DBClient toman delegados que se invocan cuando se completa la operación asíncrona.
## Guardar un objeto
Para guardar un objeto en DynamoDB, utilice SaveAsync el método del objeto, donde T es AmazonDynamo DBClient el tipo de objeto que va a guardar.
Hemos llamado a la base de datos "Bookstore" y en consonancia con ese tema vamos a implementar un modelo de datos que registra atributos relacionados con libros. Estas son las clases que definen nuestro modelo de datos.
```
[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; }
}
```
Por supuesto, en una aplicación de librería real necesitaríamos campos adicionales para cosas como el autor y el precio. La clase Book está decorada con el atributo [DynamoDBTable], que define en qué tabla de base de datos se escribirán los objetos de tipo Book. La clave de cada instancia de la clase Book se identifica mediante el atributo [Dynamo DBHash Key]. Las propiedades se identifican con el atributo [DynamoDBProperty], que especifica la columna de la tabla de la base de datos en la que se escribirá la propiedad. Con el modelo configurado, podemos escribir algunos métodos para crear, recuperar, actualizar y eliminar objetos Book.
## Creación de un objeto Book
```
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";
});
}
```
## Recuperación de un objeto Book
```
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);
}
```
## Actualización de un objeto Book
```
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");
});
}
});
}
```
## Eliminación de un objeto Book
```
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");
});
}
});
}
```