O AWS Mobile SDK for Unity agora está incluído no AWS SDK para .NET. Este guia faz referência à versão arquivada do Mobile SDK para Unity. Para obter mais informações, consulte [O que é o SDK AWS móvel para Unity?](what-is-unity-plugin.md).
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Amazon DynamoDB
[O Amazon DynamoDB](https://aws.amazon.com/dynamodb/) é um serviço de banco de dados rápido, altamente disponível, altamente escalável, econômico e não relacional. O DynamoDB remove limitações de escalabilidade tradicionais sobre armazenamento de dados, mantendo, ao mesmo tempo, a baixa latência e o desempenho previsível. Para obter informações sobre o DynamoDB, consulte [Amazon DynamoDB](https://aws.amazon.com/dynamodb/).
O AWS Mobile SDK para Unity fornece uma biblioteca de alto nível para trabalhar em conjunto com o DynamoDB. Você também pode fazer solicitações diretamente com base na API de nível inferior do DynamoDB, mas, na maioria dos casos de uso, é recomendável o uso da biblioteca de nível superior. AmazonDynamoDBClient É uma parte especialmente útil da biblioteca de alto nível. Usando essa classe, você pode realizar várias operações de criação, leitura, atualização e exclusão (CRUD) e executar consultas.
**nota**
Alguns dos exemplos neste documento pressupõem o uso de uma variável de caixa de texto chamada ResultText para exibir a saída de rastreamento.
## Integração ao Amazon DynamoDB
Para usar o DynamoDB em um aplicativo Unity, você precisará adicionar o Unity SDK ao projeto. Se você ainda não tiver feito isso, [faça download do SDK para Unity](https://aws.amazon.com/mobile/sdk/) e siga as instruções em [Configurar o AWS Mobile SDK para Unity](setup-unity.md). É recomendável o uso do Amazon Cognito Identity para fornecer credenciais temporárias da AWS para seus aplicativos. Essas credenciais permitem que o aplicativo acessar recursos e serviços da AWS.
Para usar o DynamoDB em um aplicativo, defina as permissões corretas. A seguinte política do IAM permite que o usuário exclua, obtenha, insira, verifique e atualize itens em uma tabela específica do DynamoDB, que é identificada pelo [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"
}]
}
```
Essa política deve ser aplicada às funções atribuídas ao grupo de identidades do Cognito, mas você precisará substituir o valor ** `Resource` ** pelo ARN correto da tabela do DynamoDB. O Cognito cria automaticamente uma função para o novo grupo de identidades, e você pode aplicar políticas a essa função no [console do IAM](https://console.aws.amazon.com/iam/).
Você deve adicionar ou remover ações permitidas com base nas necessidades do seu aplicativo. Para saber mais sobre as políticas do IAM, consulte [Usar o IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/IAM_Introduction.html). Para saber mais sobre as políticas específicas do DynamoDB, consulte [Usar o IAM para controlar o acesso aos recursos do DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/UsingIAMWithDDB.html).
## Criação de uma tabela do DynamoDB
Agora que as permissões e credenciais estão configuradas, vamos criar uma tabela do DynamoDB para o aplicativo. Para criar uma tabela, acesse o [console do DynamoDB](https://console.aws.amazon.com/dynamodb/home) e siga estas etapas:
1. Clique em **Create Table (Criar tabela)**.
1. Insira `Bookstore` como nome da tabela.
1. Selecione **Hash** como tipo de chave primária.
1. Selecione **Number (Número)** e insira `id` como o nome do atributo de hash. Clique em **Continue**.
1. Clique em **Continue (Continuar)** novamente para ignorar a adição de índices.
1. Defina a capacidade de leitura para `10` e a capacidade de gravação para `5`. Clique em **Continue**.
1. Insira um e-mail de notificação e clique em **Continue (Continuar)** para criar alarmes de taxa de transferência.
1. Clique em **Criar**. O DynamoDB criará seu banco de dados.
## Criação de um cliente DynamoDB
Para que o aplicativo interaja com uma tabela do DynamoDB, precisamos de um cliente. Podemos criar um cliente DynamodDB padrão da seguinte forma:
```
var credentials = new CognitoAWSCredentials(IDENTITY_POOL_ID, RegionEndpoint.USEast1);
AmazonDynamoDBClient client = new AmazonDynamoDBClient(credentials);
DynamoDBContext Context = new DynamoDBContext(client);
```
A AmazonDynamo DBClient classe é o ponto de entrada para a API do DynamoDB. A classe fornece métodos de instância para criação, descrição, atualização e exclusão de tabelas, entre outras operações. O contexto adiciona uma camada adicional de abstração sobre o cliente e permite que você use funcionalidades adicionais, como o modelo de persistência de objeto.
## Descrição de uma tabela
Para obtermos uma descrição da tabela do DynamoDB, podemos usar o seguinte código:
```
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);
}
```
Neste exemplo, criamos um cliente e um DescribeTableRequest objeto, atribuímos o nome da nossa tabela à **`TableName`**propriedade e, em seguida, passamos o objeto de solicitação para o DescribeTableAsync método no AmazonDynamo DBClient objeto. DescribeTableAsync também recebe um delegado que será chamado quando a operação assíncrona for concluída.
**nota**
Todos os métodos assíncronos no AmazonDynamo DBClient take delegam que são chamados quando a operação assíncrona é concluída.
## Salvar um objeto
Para salvar um objeto no DynamoDB, use SaveAsync o método do objeto, em que T é AmazonDynamo DBClient o tipo de objeto que você está salvando.
Chamamos o banco de dados "Bookstore" e, de acordo com esse tema, implementaremos um modelo de dados que registra atributos relacionados a livros. Aqui estão as classes que definem nosso modelo de dados.
```
[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; }
}
```
É claro que, para um aplicativo de livraria real, precisaríamos de campos adicionais para itens como autor e preço. A classe Book é decorada com o atributo [DynamoDBTable], que define os objetos da tabela de banco de dados do tipo Book em que serão gravados. A chave para cada instância da classe Book é identificada usando o atributo [DBHashChave do Dynamo]. As propriedades são identificadas com o atributo [DynamoDBProperty] e especificam a coluna na tabela do banco de dados na qual a propriedade será gravada. Com o modelo implementado, podemos gravar alguns métodos para criar, recuperar, atualizar e excluir os objetos Book.
## Criação de um livro
```
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";
});
}
```
## Recuperação de um livro
```
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);
}
```
## Atualização de um livro
```
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");
});
}
});
}
```
## Exclusão de um livro
```
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");
});
}
});
}
```