Fala Galera,
Neste post vou falar sobre o Azure Cosmos DB, um novo serviço de base de dados NoSQL na nuvem da Microsoft. Mas o que seria o Azure Cosmos DB ?
O Azure Cosmos DB é um serviço de banco de dados que foi desenvolvido para ser elástico, de fácil escalabilidade, globalmente distribuído e multimodelo. Ser multimodelo é uma característica que faz esse banco de dados ser diferente dos demais bancos NoSQL, no qual podemos escolher variações do modo de armazenamento, que são:
- Table API
- DocumentDB API
- MongoDB API
- Graph API
Hoje o serviço do Cosmos DB suporta diversos tipos de tecnologia com sua SDK nativa como Java, Python, C# e NodeJs.
Agora que entendemos um pouco sobre o Azure Cosmos DB, vamos criar uma aplicação com exemplo de utilização deste banco de dados.
Criando o Cosmos DB no portal do Azure.
Para assinar o serviço do Azure Cosmos DB, entre no portal de gerenciamento do Azure (http://portal.azure.com) com suas credenciais.
Após isso, clique em Novo (New) e escolha Cosmos DB conforme imagem abaixo:
Após isso você será redirecionado para uma blade (tela) para inserir as informações do endereço do banco de dados, modelo de API e etc.
Neste exemplo eu escolhi o modelo do SQL (Documents) API conforme imagem abaixo:
Clique em Criar e espere a implantação do serviço, após isso você será redirecionado para uma tela semelhante a imagem abaixo:
Agora vamos configurar a replicação dos dados, para isso clique no mapa escolha a região de sua preferência, lembrando que cada região tem característica diferenciadas como storage, throughput e etc.
Veja na imagem abaixo:
Feito isso, nosso serviço já esta configurado para ser geograficamente replicado, clique em Cadeia de Conexão (Connection String) e veja as informações de acesso conforme figura abaixo:
Agora já temos todas as informações para criar nossa primeira aplicação utilizando Cosmos DB.
Criando um ASP.NET Core Web API utilizando Cosmos DB
Com o Cosmos DB já configurado, vamos criar um Web API para isso abra o Visual Studio 2017 e clique em Novo Projeto (New Project) conforme figura abaixo:
Escolha a opção ASP.NET Core WebAPI conforme figura abaixo:
Vamos criar uma classe chamada Cliente, outra classe chamada Telefone e uma outra classe chamada Endereço, conforme código abaixo:
public class Cliente
{
[JsonProperty(PropertyName = "id")]
public Guid Id { get; set; }
[JsonProperty(PropertyName = "nome")]
public string Nome { get; set; }
[JsonProperty(PropertyName = "dataNascimento")]
public DateTime DataNascimento { get; set; }
[JsonProperty(PropertyName = "sexo")]
public string Sexo { get; set; }
[JsonProperty(PropertyName = "email")]
public string Email { get; set; }
[JsonProperty(PropertyName = "telefones")]
public List Telefones { get; set; }
[JsonProperty(PropertyName = "enderecos")]
public List Enderecos { get; set; }
}
public class Telefone
{
[JsonProperty(PropertyName = "DDD")]
public string DDD { get; set; }
[JsonProperty(PropertyName = "numero")]
public string Numero { get; set; }
}
public class Endereco
{
[JsonProperty(PropertyName = "logradouro")]
public string Logradouro { get; set; }
[JsonProperty(PropertyName = "complemento")]
public string Complemento { get; set; }
[JsonProperty(PropertyName = "bairro")]
public string Bairro { get; set; }
[JsonProperty(PropertyName = "cidade")]
public string Cidade { get; set; }
[JsonProperty(PropertyName = "estado")]
public string Estado { get; set; }
}
Com o nosso modelo criado vamos criar o repositório que será responsável pela manutenção do Cliente no Azure Cosmos DB.
Antes disso, devemos adicionar a referência do Microsoft.AzureDocumentDB.Core, ele pode ser adicionado via NuGet através do comando abaixo:
- Install-Package Microsoft.AzureDocumentDB.Core
Com a referência adicionada, vamos criar nosso repositório, através do código abaixo:
public class ClienteRepository
{
public string Endpoint = @"https://xxxxxx.documents.azure.com:443/";
public string Key = "xxxxx==";
public string DatabaseId = "AzureSampleDB";
public string CollectionId = "ClienteCollection";
public DocumentClient DocumentClient;
public ClienteRepository()
{
this.DocumentClient = new DocumentClient(new Uri(Endpoint)
,Key);
DocumentClient.CreateDatabaseIfNotExistsAsync(
new Microsoft.Azure.Documents.Database() { Id = DatabaseId })
.Wait();
DocumentClient.CreateDocumentCollectionIfNotExistsAsync(UriFactory.CreateDatabaseUri(DatabaseId),
new DocumentCollection() { Id = CollectionId },
new RequestOptions()
{
OfferThroughput = 1000
})
.Wait();
}
public async Task Save(Cliente model)
{
await this.DocumentClient.CreateDocumentAsync(
UriFactory.CreateDocumentCollectionUri(DatabaseId, CollectionId), model);
}
public async Task Remove(Guid id)
{
await this.DocumentClient.DeleteDocumentAsync(
UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id.ToString()));
}
public async Task Update(Guid id, Cliente model)
{
await this.DocumentClient.ReplaceDocumentAsync(
UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id.ToString()), model);
}
public async Task<Cliente> Get(Guid id)
{
try
{
Document doc = await this.DocumentClient.ReadDocumentAsync(
UriFactory.CreateDocumentUri(DatabaseId, CollectionId, id.ToString()));
return JsonConvert.DeserializeObject<Cliente>(doc.ToString());
}
catch (DocumentClientException e)
{
if (e.StatusCode == System.Net.HttpStatusCode.NotFound)
return null;
else
throw;
}
}
public async Task<IEnumerable<Cliente>> GetAll()
{
var documents = this.DocumentClient.CreateDocumentQuery<Cliente>
(UriFactory.CreateDocumentCollectionUri(
DatabaseId, CollectionId),
new FeedOptions { MaxItemCount = -1 })
.AsDocumentQuery();
List<Cliente> result = new List<Cliente>();
while (documents.HasMoreResults)
result.AddRange(await documents.ExecuteNextAsync<Cliente>());
return result;
}
}
Vamos criar um WebApiController, adicione o código abaixo:
[Route("api/[controller]")]
public class ClienteController : Controller
{
private ClienteRepository Repository = new ClienteRepository();
[HttpGet]
public async Task<IActionResult> Get()
{
return Ok(await this.Repository.GetAll());
}
[HttpGet("{id}")]
public async Task<IActionResult> Get(Guid id)
{
return Ok(await this.Repository.Get(id));
}
[HttpPost]
public async Task<IActionResult> Post([FromBody]Cliente model)
{
await this.Repository.Save(model);
return Ok();
}
[HttpPut("{id}")]
public async Task<IActionResult> Put(Guid id, [FromBody]Cliente model)
{
await this.Repository.Update(id, model);
return Ok();
}
[HttpDelete("{id}")]
public async Task<IActionResult> Delete(Guid id)
{
await this.Repository.Remove(id);
return Ok();
}
}
Nosso WebAPI está pronto! Para testar nosso WebAPI, vou abrir o postman e fazer as requisições necessárias, conforme imagem abaixo:
Note que o WebAPI retornou 200 OK gravando com sucesso o nosso novo cliente.
Abrindo o Data Explorer no Azure, podemos ver que nosso cliente foi gravado, conforme figura abaixo:
Assim, chegamos ao fim do artigo, como podemos ver o Azure Cosmos DB é um serviço de banco de dados perfeito para todos os tipos de cenários.
O código deste artigo encontra-se no meu GitHub através deste link
Não deixem de comentar!
Abs e até a próxima!