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á.

Use o armazenamento em cache para reduzir a demanda do banco de dados

Visão geral do

Você pode usar o armazenamento em cache como uma estratégia eficaz para ajudar a reduzir os custos de suas aplicações .NET. Muitas aplicações usam bancos de dados de backend, como o SQL Server, quando as aplicações exigem acesso frequente aos dados. O custo de manter esses serviços de backend para lidar com a demanda pode ser alto, mas você pode usar uma estratégia eficaz de armazenamento em cache para reduzir a carga nos bancos de dados de backend, reduzindo os requisitos de dimensionamento e escalabilidade. Isso pode ajudar a reduzir os custos e a melhorar a performance de suas aplicações.

O armazenamento em cache é uma técnica útil para economizar nos custos relacionados à leitura de workloads pesadas que usam recursos mais caros, como o SQL Server. É importante usar a técnica certa para sua workload. Por exemplo, o armazenamento em cache local não é escalável e exige que você mantenha um cache local para cada instância de uma aplicação. Você deve ponderar o impacto na performance em comparação com os possíveis custos, para que o menor custo da fonte de dados subjacente compense quaisquer custos adicionais relacionados ao mecanismo de armazenamento em cache.

Impacto do custo

O SQL Server exige que você leve em consideração as solicitações de leitura ao dimensionar seu banco de dados. Isso pode afetar os custos, pois talvez seja necessário introduzir réplicas de leitura para acomodar a carga. Se você estiver usando réplicas de leitura, é importante entender que elas estão disponíveis somente na edição SQL Server Enterprise. Essa edição exige uma licença mais cara do que a edição SQL Server Standard.

O diagrama a seguir foi projetado para ajudar você a entender a eficácia do armazenamento em cache. Ele mostra o Amazon RDS para SQL Server com quatro nós db.m4.2xlarge executando a edição SQL Server Enterprise. Ele é implantado em uma configuração multi-AZ com uma réplica de leitura. O tráfego de leitura exclusivo (por exemplo, consultas SELECT) é direcionado às réplicas de leitura. Em comparação, o Amazon DynamoDB usa um cluster r4.2xlarge de dois nós do DynamoDB Accelerator (DAX).

O gráfico a seguir mostra os resultados da remoção da exigência de réplicas de leitura dedicadas que lidem com alto tráfego de leitura.

Você pode obter economias de custo significativas usando o armazenamento em cache local sem réplicas de leitura ou introduzindo o DAX lado a lado com o SQL Server no Amazon RDS como uma camada de armazenamento em cache. Essa camada é descarregada do SQL Server e reduz o tamanho do SQL Server necessário para executar o banco de dados.

Recomendações de otimização de custos

Armazenamento em cache local

O armazenamento em cache local é uma das formas mais usadas de armazenar conteúdo em cache para aplicações hospedadas em ambientes on-premises ou na nuvem. Isso ocorre porque é relativamente fácil e intuitivo de implementar. O armazenamento em cache local envolve pegar conteúdo de um banco de dados ou de outra fonte e armazenar em cache localmente na memória ou no disco para acesso mais rápido. Essa abordagem, embora fácil de implementar, não é ideal para alguns casos de uso. Por exemplo, isso inclui casos de uso em que o conteúdo do armazenamento em cache precisa persistir ao longo do tempo, como preservar o estado da aplicação ou do usuário. Outro caso de uso é quando o conteúdo em cache precisa ser acessado de outras instâncias da aplicação.

O diagrama abaixo ilustra um cluster do SQL Server altamente disponível com quatro nós e duas réplicas de leitura.

Com o armazenamento em cache local, talvez seja necessário balancear a carga do tráfego em várias EC2 instâncias. Cada instância deve manter seu próprio cache local. Se o cache armazenar informações com estado, é necessário que haja commits regulares no banco de dados, e talvez os usuários precisem ser encaminhados para a mesma instância em cada solicitação subsequente (sessão persistente). Isso representa um desafio ao tentar escalar aplicações, pois algumas instâncias podem ser superutilizadas, enquanto outras são subutilizadas devido à distribuição desigual do tráfego.

Você pode usar o armazenamento em cache local, na memória ou usando armazenamento local, para aplicações .NET. Para fazer isso, você pode adicionar funcionalidade para armazenar objetos em disco e recuperá-los quando necessário, ou consultar dados do banco de dados e persisti-los na memória. Para realizar o armazenamento em cache local na memória e no armazenamento local de dados de um SQL Server em C#, por exemplo, você pode usar uma combinação das bibliotecas MemoryCache e LiteDB. A MemoryCache fornece armazenamento em cache em memória, enquanto a LiteDB é um banco de dados NoSQL incorporado baseado em disco que é rápido e leve.

Para realizar o armazenamento em cache em memória, use a biblioteca .NET System.Runtime.MemoryCache. O exemplo de código a seguir mostra como usar a classe System.Runtime.Caching.MemoryCache para armazenar dados em cache na memória. Essa classe fornece uma forma de armazenar dados temporariamente na memória da aplicação. Isso pode ajudar a melhorar a performance de uma aplicação ao reduzir a necessidade de buscar dados de um recurso mais caro, como um banco de dados ou uma API.

Confira como o código funciona:

using System;
using System.Runtime.Caching;

public class InMemoryCache
{
    private static MemoryCache _memoryCache = new MemoryCache("dataCache");

    public static T GetData<T>(string key, Func<T> getData)
    {
        if (_memoryCache.Contains(key))
        {
            return (T)_memoryCache.Get(key);
        }

        T data = getData();
        _memoryCache.Add(key, data, DateTimeOffset.Now.AddMinutes(10));

        return data;
    }

    public static void ClearCache(string key)
    {
        _memoryCache.Remove(key);
    }
}

É possível usar o seguinte código:

public class Program
{
    public static void Main()
    {
        string cacheKey = "sample_data";

        Func<string> getSampleData = () =>
        {
            // Replace this with your data retrieval logic
            return "Sample data";
        };

        string data = InMemoryCache.GetData(cacheKey, getSampleData);
        Console.WriteLine("Data: " + data);
    }
}

O exemplo a seguir mostra como usar o LiteDB para armazenar dados em cache no armazenamento local. Você pode usar o LiteDB como alternativa ou complemento ao cache em memória. O código a seguir demonstra como usar a biblioteca LiteDB para armazenar dados em cache no armazenamento local. A classe LocalStorageCache contém as principais funções para gerenciar o cache.

using System;
using LiteDB;

public class LocalStorageCache
{
    private static string _liteDbPath = @"Filename=LocalCache.db";

    public static T GetData<T>(string key, Func<T> getData)
    {
        using (var db = new LiteDatabase(_liteDbPath))
        {
            var collection = db.GetCollection<T>("cache");
            var item = collection.FindOne(Query.EQ("_id", key));

            if (item != null)
            {
                return item;
            }
        }

        T data = getData();

        using (var db = new LiteDatabase(_liteDbPath))
        {
            var collection = db.GetCollection<T>("cache");
            collection.Upsert(new BsonValue(key), data);
        }

        return data;
    }

    public static void ClearCache(string key)
    {
        using (var db = new LiteDatabase(_liteDbPath))
        {
            var collection = db.GetCollection("cache");
            collection.Delete(key);
        }
    }
}

public class Program
{
    public static void Main()
    {
        string cacheKey = "sample_data";

        Func<string> getSampleData = () =>
        {
            // Replace this with your data retrieval logic
            return "Sample data";
        };

        string data = LocalStorageCache.GetData(cacheKey, getSampleData);
        Console.WriteLine("Data: " + data);
    }
}

Se você tem um cache ou arquivos estáticos que não mudam com frequência, é possível armazenar esses arquivos no armazenamento de objetos do Amazon Simple Storage Service (Amazon S3). A aplicação pode recuperar o arquivo de cache estático na inicialização para usar localmente. Para obter mais detalhes sobre como recuperar arquivos do Amazon S3 usando o .NET, consulte Baixar objetos na documentação do Amazon S3.

Armazenamento em cache com o DAX

Você pode usar uma camada de cache que pode ser compartilhada entre todas as instâncias da aplicação. O DynamoDB Accelerator (DAX) é um cache em memória totalmente gerenciado e altamente disponível para o DynamoDB que pode proporcionar um aumento de dez vezes na performance. Você pode usar o DAX para reduzir custos diminuindo a necessidade de superprovisionar unidades de capacidade de leitura nas tabelas do DynamoDB. Isso é especialmente útil para workloads com muita leitura e que exigem leituras repetidas para chaves individuais.

O preço do DynamoDB é baseado no modelo sob demanda ou mediante capacidade provisionada, portanto, o número de leituras e gravações por mês contribui para o custo. Se você leu workloads pesadas, os clusters do DAX podem ajudar a cortar os custos ao reduzir o número de leituras nas tabelas do DynamoDB. Para obter instruções sobre como configurar o DAX, consulte Aceleração em memória com o DynamoDB Accelerator (DAX) na documentação do DynamoDB. Para obter informações sobre a integração de aplicativos.NET, assista Integrando o Amazon DynamoDB DAX em seu aplicativo ASP.NET em. YouTube

Recursos adicionais do