BT

Início Artigos Cache distribuído com o ASP.NET Core

Cache distribuído com o ASP.NET Core

Favoritos

Pontos Principais

  • O ASP.NET Core possui uma interface embutida de cache distribuído.
  • Desempenho, dados compartilhados e durabilidade são os principais benefícios do armazenamento em cache distribuído.
  • O Couchbase Server é um banco de dados de memória que é ótimo para o uso como um cache distribuído.
  • Os pacotes do NuGet facilitam a inclusão do Couchbase Server em seu aplicativo.
  • O uso da interface "IDistrubutedCache" abstrai os detalhes e facilita a interação com o cache em seus controladores ASP.NET Core.

Com o lançamento do .NET Core 2.0, a Microsoft possui uma nova versão principal da plataforma com propósito geral, modular, multiplataforma e de código aberto que foi lançada inicialmente em 2016. O .NET Core foi criado para ter muitas das APIs que estão disponíveis na versão atual do .NET Framework. Ele foi inicialmente criado para permitir a próxima geração de soluções ASP.NET, mas agora impulsiona e é a base para muitos outros cenários, incluindo IoT, nuvem e soluções móveis de próxima geração. Nesta segunda série, abrangendo o .NET Core, exploraremos mais alguns benefícios do .NET Core e como ele pode beneficiar não apenas desenvolvedores tradicionais de .NET, mas também todos os tecnólogos que precisam levar soluções robustas, eficazes e econômicas ao mercado.

O cache pode ajudar a melhorar o desempenho de um aplicativo ASP.NET Core. Cache distribuído é útil ao trabalhar com uma aplicação ASP.NET implantado em um farm de servidores ou em um ambiente de nuvem escalonável. A documentação da Microsoft contém exemplos de como fazer isso com o SQL Server ou o Redis, mas, neste post, será mostrado uma alternativa. O Couchbase Server é um banco de dados distribuído com uma arquitetura em que o armazenamento ocorre primeiramente na memória(ou opcionalmente somente memória), o que o torna ideal para armazenamento em cache. Ao contrário do Redis, ele possui um conjunto de recursos mais avançados que pode ser usado mais tarde, conforme os casos de uso e o produto se expande. Mas para este post do blog, os recursos se concentraram no cache e na integração com o ASP.NET Core. É possível acompanhar todos os exemplos de código no Github.

Benefícios do armazenamento em cache distribuído

  1. Performance. Um cache armazena dados na RAM para recuperação rápida e fácil. Geralmente, será mais rápido recuperar dados desse cache, em vez de usar a fonte original todas as vezes.
  2. Dados de cache compartilhados. Caso esteja usando uma implantação de vários servidores para sua aplicação ASP.NET Core, um balanceador de carga poderá direcionar o usuário para qualquer um dos servidores ASP.NET Core. Se os dados em cache estiverem nos próprios servidores da Web, será necessário ativar sessões fixas para garantir que o usuário seja sempre direcionado para o mesmo servidor ASP.NET Core. Isso pode levar a cargas irregulares e outros problemas de rede - veja esta resposta do Stack Overflow para obter mais detalhes).
  3. Durabilidade. Se um servidor da web do ASP.NET Core ficar inativo ou precisar reiniciá-lo por algum motivo, isso não afetará os dados armazenados em cache. Ainda estará armazenado no cache distribuído após o reinício.

Não importa qual ferramenta esteja usando como cache distribuído (Couchbase, Redis ou SQL Server), o ASP.NET Core fornece uma interface consistente para qualquer tecnologia de cache que deseja usar.

Instalando o Couchbase

O primeiro passo é obter o servidor de cache distribuído em execução. Escolha o método de instalação mais conveniente. É possível utilizar o Docker, ou um provedor de nuvem, ou instalá-lo em sua máquina local (que foi utilizado para essa postagem do blog). O download é gratuito e pode ainda usar a edição gratuita da Comunidade Couchbase. (A Enterprise Edition também é gratuita e ilimitada para uso em pré-produção, mas será usada a Community Edition nesta postagem).

Ao instalar o Couchbase, é preciso abrir o navegador da Web e passar por um breve assistente. A configuração padrão é boa para este post.

Depois de instalar o Couchbase, crie um "bucket". É aqui que os dados em cache serão armazenados. Para este exemplo, o bucket foi nomeado como, "infoqcache". Foi criado um bucket "efêmero" (que é uma opção somente de memória). Também é possível usar um bucket "Couchbase" (que armazenará os dados na memória primeiro e persistirá no disco de forma assíncrona).

A última etapa da configuração do Couchbase é a segurança. Adicione um usuário do Couchbase com as permissões apropriadas para esse bucket. O usuário foi nomeado "infoq" e sua senha "password" (use algo mais forte na produção!). Na edição Enterprise, há diversos papeis para escolher, mas, para esse caso de uso simples, não são necessários. "Bucket Full Access" para o cache do infoq é suficiente.

Verifique que concluiu todas essas etapas de instalação antes de prosseguir para o ASP.NET Core. Aqui estão os passos com links para uma documentação mais detalhada.

  1. Instação do Couchbase (siga as instruções na página de downloads)
  2. Configuração do Couchbase (Explore a Configuração do Servidor)
  3. Criação de um bucket (Criando um bucket)
  4. Criação de um usuário com permissão para o bucket. (Criando e gerenciando usuários com a interface do usuário)

Criar um novo aplicativo ASP.NET Core

Será criado um exemplo de aplicação do ASP.NET Core API para mostrar os recursos de armazenamento em cache distribuídos do ASP.NET Core. Esta será uma aplicação pequena e simples com dois pontos finais.

Usaremos o Visual Studio 2017. A partir daí, selecione File→New→Web→ASP.NET Core Web Application.

O próximo passo é selecionar o tipo de modelo de projeto do ASP.NET Core a ser usado. Estou usando uma "API" simples, sem autenticação e sem suporte do Docker.

Este projeto tem um arquivo ValuesController.cs. Iremos substituir a maior parte do código desta classe pelo meu próprio código. Aqui está o primeiro endpoint que será criado. Ele não usa nenhum armazenamento em cache e tem um Thread.Sleep para simular o acesso aos dados de alta latência (imagine a substituição do Thread.Sleep por uma chamada para um serviço da web lento ou uma consulta de banco de dados complexa).

[Route("api/get")]
public string Get()
{
    // generate a new string
    var myString = Guid.NewGuid() + " " + DateTime.Now;

    // wait 5 seconds (simulate a slow operation)
   Thread.Sleep(5000);

    // return this value
    return myString;
}

Inicie o website (Ctrl + F5 no Visual Studio). Também é possível usar uma ferramenta como o Postman para interagir com o endpoint. Mas para este exemplo, um navegador é bom o suficiente. No projeto de amostra, o site será iniciado para localhost: 64921 e foi configurado o nó de extremidade com uma rota de api/get. Então, em um navegador vamos para localhost: 64921/api/get:

Este é um exemplo trivial, mas mostra que este endpoint é: a) obter um valor único de string, e b) demorar muito para fazê-lo. Toda vez que atualizar, haverá pelo menos uma espera de 5 segundos. Esse seria um ótimo lugar para introduzir o cache para melhorar a latência e o desempenho.

Integração do ASP.NET Core com o Couchbase

Agora temos uma aplicação ASP.NET Core que precisa de armazenamento em cache e uma instância do Couchbase Server que deseja ajudar. Vamos levá-los a trabalhar juntos.

O primeiro passo é instalar um pacote do NuGet. Para isso, pode usar a interface do usuário do NuGet para procurar pelo Couchbase.Extensions.Caching ou pode executar esse comando no Console do Gerenciador de Pacotes: Install-Package Couchbase.Extensions.Caching -Version 1.0.1. Este é um projeto de código aberto, e o código fonte completo está disponível no Github.

O NuGet irá instalar todos os pacotes que necessários para a sua aplicação ASP.NET Core conversar com o Couchbase Server e integrar com os recursos de cache distribuídos do ASP.NET Core.

Agora abra o arquivo Startup.cs no projeto. É preciso adicionar um código de configuração ao método ConfigureServices.

services.AddCouchbase(opt =>
{
    opt.Servers = new List<Uri>
    {
        new Uri("http://localhost:8091")
    };
    opt.Username = "infoq";
    opt.Password = "password";
});

services.AddDistributedCouchbaseCache("infoqcache", opt => { });

(Eu também adicionei usando Couchbase.Extensions.Caching; e usando Couchbase.Extensions.DependencyInjection; no topo do arquivo, mas eu uso o ReSharper para identificar e adicionar aqueles para mim automaticamente).

No código acima, os métodos de extensão AddCouchbase e AddDistributedCouchbaseCache são adicionados à interface integrada do ASP.NET Core IServiceCollection.

Com o AddCouchbase, estou dizendo ao ASP.NET Core como se conectar ao Couchbase, dando a ele o usuário/senha mencionado anteriormente na postagem.

Com o AddDistributedCouchbaseCache, estou dizendo ao ASP.NET Core para usar o Couchbase como um cache distribuído, especificando o nome do bucket mencionado anteriormente na postagem.

A documentação desta extensão está disponível no Github. Não se esqueça de adicionar o código de limpeza/remoção no método ConfigureServices.

Usando o cache distribuído do ASP.NET Core

Agora que configuramos o ASP.NET Core para saber como armazenar em cache, vamos colocá-lo em uso, em um exemplo simples.

A coisa mais simples que podemos fazer com o cache distribuído é injetar no ValuesController e usar um IDistributedCachedirectly.

Primeiro, adicione IDistributedCacheas como um parâmetro ao construtor.

public ValuesController(IDistributedCachecache)
{
    _cache = cache;
}

Como já configuramos o cache distribuído em Startup.cs, o ASP.NET Core sabe como definir esse parâmetro (usando a injeção de dependência). Agora, _cache está disponível em ValuesController para obter/definir valores no cache. Foi criado outro endpoint chamado GetUsingCache. Isso será exatamente como endpoint Get, mas usará o cache. Após a primeira chamada, ele armazenará o valor e as chamadas subsequentes não alcançarão mais o Thread.Sleep.

[Route("api/getfast")]
public string GetUsingCache()
{
    // is the string already in the cache?
    var myString = _cache.GetString("CachedString1");
    if (myString == null)
    {
        // string is NOT in the cache

        // generate a new string
        myString = Guid.NewGuid() + " " + DateTime.Now;

        // wait 5 seconds (simulate a slow operation)
       Thread.Sleep(5000);

        // put the string in the cache
       _cache.SetString("CachedString1", myString);

        // cache only for 5 minutes
        /*
        _cache.SetString("CachedString1", myString,
          new DistributedCacheEntryOptions { SlidingExpiration = TimeSpan.FromMinutes(5)});
        */
    }

    return myString;
}

A primeira solicitação para /api/getfast ainda será lenta, mas atualize a página e os próximos pedidos serão extraídos do cache. Volte para o console do Couchbase, clique em "Buckets" no menu e verá que o bucket"infoqcache" agora tem 1 item.

Uma coisa importante a ser destacada no ValuesController é nada, se ele estiver diretamente acoplado a qualquer biblioteca do Couchbase. Tudo depende das bibliotecas do ASP.NET Core. Essa interface comum oferece a capacidade de usar o cache distribuído do Couchbase em qualquer outro local que use as bibliotecas padrão do Microsoft ASP.NET Core. Além disso, tudo é encapsulado por trás da interface IDistributedCache, o que facilita a gravação de testes.

No exemplo acima, os dados em cache ficarão no cache indefinidamente. Mas você também pode especificar uma expiração para o cache. No exemplo abaixo, o nó de extremidade armazenará dados em cache por 5 minutos (em uma expiração variável).

_cache.SetString("CachedString1", myString,
 new DistributedCacheEntryOptions { SlidingExpiration = TimeSpan.FromMinutes(5)});

Resumo

O ASP.NET Core pode trabalhar lado a lado com o Couchbase Server para armazenamento em cache distribuído. A interface de cache distribuído padrão do ASP.NET Core facilita o trabalho com o cache. Em seguida, atualize seus aplicativos distribuídos do ASP.NET Core com o cache.

Caso tenha dúvidas ou comentários sobre o projeto Couchbase.Extensions.Caching, certifique-se de verificar o repositório do GitHub ou os fóruns do Couchbase .NET SDK.

Sobre o autor

Matthew D. Groves é um cara que adora codificar. Não importa se é C #, jQuery ou PHP: ele enviará solicitações para qualquer coisa. Ele tem codificado profissionalmente desde que escreveu um aplicativo de ponto de venda QuickBASIC para a pizzaria de seus pais nos anos 90. Ele atualmente trabalha como um desenvolvedor advogado para Couchbase. Ele é autor de AOP in .NET (publicado por Manning) e também é MVP da Microsoft.

 

Com o lançamento do .NET Core 2.0, a Microsoft tem a próxima versão principal da plataforma de propósito geral, modular, multiplataforma e de código aberto que foi lançada inicialmente em 2016. O .NET Core foi criado para ter muitas das APIs que estão disponíveis na versão atual do .NET Framework. Ele foi inicialmente criado para permitir a próxima geração de soluções ASP.NET, mas agora impulsiona, e é a base para muitos outros cenários, incluindo IoT, nuvem e soluções móveis de próxima geração. Nesta segunda série, abrangendo o .NET Core, exploraremos mais alguns benefícios do .NET Core e como ele pode beneficiar não apenas desenvolvedores tradicionais de .NET, mas também todos os tecnólogos que precisam levar soluções robustas, eficazes e econômicas ao mercado.

Avalie esse artigo

Relevância
Estilo/Redação

Olá visitante

Você precisa cadastrar-se no InfoQ Brasil ou para enviar comentários. Há muitas vantagens em se cadastrar.

Obtenha o máximo da experiência do InfoQ Brasil.

HTML é permitido: a,b,br,blockquote,i,li,pre,u,ul,p

Comentários da comunidade

HTML é permitido: a,b,br,blockquote,i,li,pre,u,ul,p

HTML é permitido: a,b,br,blockquote,i,li,pre,u,ul,p

BT

Seu cadastro no InfoQ está atualizado? Poderia rever suas informações?

Nota: se você alterar seu email, receberá uma mensagem de confirmação

Nome da empresa:
Cargo/papel na empresa:
Tamanho da empresa:
País:
Estado:
Você vai receber um email para validação do novo endereço. Esta janela pop-up fechará em instantes.