Introdução ao Azure Cosmos DB

19 fev

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!

Deixe uma resposta

O seu endereço de e-mail não será publicado. Campos obrigatórios são marcados com *