Distribuované ukládání do mezipaměti v ASP.NET Core

Mohsin Nasir a smandia

Distribuovaná mezipaměť je mezipaměť sdílená více aplikačními servery, obvykle udržovaná jako externí služba pro aplikační servery, které k ní přistupují. Distribuovaná mezipaměť může zlepšit výkon a škálovatelnost aplikace ASP.NET Core, zejména pokud je aplikace hostovaná cloudovou službou nebo serverovou farmou.

Distribuovaná mezipaměť má oproti jiným scénářům ukládání do mezipaměti několik výhod, kdy jsou data uložená v mezipaměti na jednotlivých aplikačních serverech.

Při distribuci dat uložených v mezipaměti jsou data následující:

• Je koherentní (konzistentní) napříč požadavky na více serverů.
• Přežije restartování serveru a nasazení aplikací.
• Nepoužívá místní paměť.

Konfigurace distribuované mezipaměti je specifická pro implementaci. Tento článek popisuje, jak nakonfigurovat distribuované mezipaměti SQL Serveru a Redis. K dispozici jsou také implementace třetích stran, jako je NCache (NCache na GitHubu). Bez ohledu na to, kterou implementaci vyberete, aplikace komunikuje s mezipamětí pomocí IDistributedCache rozhraní.

Zobrazení nebo stažení ukázkového kódu (postup stažení)

Požadavky

Přidání odkazu na balíček pro zprostředkovatele distribuované mezipaměti použitého:

• Pro distribuovanou mezipaměť Redis microsoft.Extensions.Ukládání do mezipaměti. StackExchangeRedis.
• Pro SQL Server Microsoft.Extensions.Ukládání do mezipaměti. SqlServer.
• Pro distribuovanou mezipaměť NCache NCache.Microsoft.Extensions.Ukládání do mezipaměti. OpenSource.

IDistributedCache – rozhraní

Rozhraní IDistributedCache poskytuje následující metody pro manipulaci s položkami v implementaci distribuované mezipaměti:

• Get, GetAsync: Přijme klíč řetězce a načte položku uloženou byte[] v mezipaměti jako pole, pokud se nachází v mezipaměti.
• Set, SetAsync: Přidá položku (jako byte[] pole) do mezipaměti pomocí klíče řetězce.
• Refresh, RefreshAsync: Aktualizuje položku v mezipaměti na základě jeho klíče, resetuje klouzavý časový limit vypršení platnosti (pokud existuje).
• Remove, RemoveAsync: Odebere položku mezipaměti na základě jejího klíče řetězce.

Vytvoření distribuovaných služeb ukládání do mezipaměti

Zaregistrujte implementaci IDistributedCache in Program.cs. Implementace poskytované architekturou popsané v tomto tématu zahrnují:

• Distribuovaná mezipaměť Redis
• Distribuovaná mezipaměť paměti
• Distribuovaná mezipaměť SQL Serveru
• Distribuovaná mezipaměť NCache
• Distribuovaná mezipaměť Azure CosmosDB

Distribuovaná mezipaměť Redis Cache

Produkční aplikace používají distribuovanou mezipaměť Redis Cache, protože je nejvýkonnější. Další informace najdete v tématu Doporučení.

Redis je opensourcové úložiště dat v paměti, které se často používá jako distribuovaná mezipaměť. Azure Cache for Redis můžete nakonfigurovat pro aplikaci Azure hostované ASP.NET Core a použít Azure Cache for Redis pro místní vývoj.

Aplikace nakonfiguruje implementaci mezipaměti pomocí RedisCache instance voláním AddStackExchangeRedisCache. Pro ukládání výstupu do mezipaměti použijte AddStackExchangeRedisOutputCache.

1. Vytvořte Azure Cache for Redis.
2. Zkopírujte primární připojovací řetězec (StackExchange.Redis) do konfigurace.
   • Místní vývoj: Uložte připojovací řetězec pomocí nástroje Secret Manager.
   • Azure: Uložte připojovací řetězec v konfiguraci služby App Service nebo jiném zabezpečeném úložišti.

Následující kód povolí Azure Cache for Redis:

builder.Services.AddStackExchangeRedisCache(options =>
 {
     options.Configuration = builder.Configuration.GetConnectionString("MyRedisConStr");
     options.InstanceName = "SampleInstance";
 });

Předchozí kód předpokládá, že primární připojovací řetězec (StackExchange.Redis) byl uložen v konfiguraci s názvem MyRedisConStrklíče .

Další informace najdete v článku, který se věnuje službě Azure Cache for Redis.

V tomto problému na GitHubu najdete diskuzi o alternativních přístupech k místní mezipaměti Redis.

Distribuovaná mezipaměť paměti

Distribuovaná mezipaměť paměti (AddDistributedMemoryCache) je implementace IDistributedCache poskytovaná architekturou, která ukládá položky do paměti. Mezipaměť distribuované paměti není skutečnou distribuovanou mezipamětí. Položky uložené v mezipaměti jsou uloženy instancí aplikace na serveru, na kterém je aplikace spuštěná.

Mezipaměť distribuované paměti je užitečná implementace:

• Ve scénářích vývoje a testování.
• Pokud se v produkčním prostředí používá jeden server a spotřeba paměti není problém. Implementace mezipaměti distribuované paměti abstrahuje úložiště dat uložených v mezipaměti. Umožňuje implementovat skutečné distribuované řešení ukládání do mezipaměti v budoucnu, pokud bude potřeba více uzlů nebo odolnosti proti chybám.

Ukázková aplikace využívá mezipaměť distribuované paměti při spuštění aplikace ve vývojovém prostředí v Program.cs:

builder.Services.AddDistributedMemoryCache();

Distribuovaná mezipaměť SQL Serveru

Implementace distribuované mezipaměti SYSTÉMU SQL Server (AddDistributedSqlServerCache) umožňuje distribuované mezipaměti používat databázi SQL Serveru jako záložní úložiště. Pokud chcete vytvořit tabulku položek uložených v mezipaměti SQL Serveru v instanci SQL Serveru, můžete použít nástroj sql-cache . Nástroj vytvoří tabulku s názvem a schématem, které zadáte.

Spuštěním sql-cache create příkazu vytvořte tabulku v SQL Serveru. Zadejte instanci SQL Serveru (), databázi (Data SourceInitial Catalog), schéma (napříkladdbo) a název tabulky (napříkladTestCache):

dotnet sql-cache create "Data Source=(localdb)/MSSQLLocalDB;Initial Catalog=DistCache;Integrated Security=True;" dbo TestCache

Zpráva se zaprotokoluje a značí, že nástroj byl úspěšný:

Table and index were created successfully.

Tabulka vytvořená nástrojem sql-cache má následující schéma:

Poznámka:

Aplikace by měla manipulovat s hodnotami mezipaměti pomocí instance , IDistributedCachenikoli .SqlServerCache

Ukázková aplikace se implementuje SqlServerCache v prostředí bez vývoje Program.csv:

builder.Services.AddDistributedSqlServerCache(options =>
{
    options.ConnectionString = builder.Configuration.GetConnectionString(
        "DistCache_ConnectionString");
    options.SchemaName = "dbo";
    options.TableName = "TestCache";
});

Poznámka:

A ConnectionString (a volitelně SchemaName a TableName) jsou obvykle uloženy mimo správu zdrojového kódu (například uložené správcem tajných kódů nebo v appsettings.json/appsettings.{Environment}.json souborech). Připojovací řetězec může obsahovat přihlašovací údaje, které by se měly uchovávat mimo systémy správy zdrojového kódu.

Distribuovaná mezipaměť NCache

NCache je opensourcová distribuovaná mezipaměť v paměti vyvinutá nativně v .NET a .NET Core. Služba NCache funguje místně i nakonfigurovaně jako cluster distribuované mezipaměti pro aplikaci ASP.NET Core běžící v Azure nebo na jiných hostitelských platformách.

Pokud chcete nainstalovat a nakonfigurovat službu NCache na místním počítači, přečtěte si příručku Začínáme pro Windows (.NET a .NET Core).

Konfigurace NCache:

1. Nainstalujte open source NuGet NCache.
2. Nakonfigurujte cluster mezipaměti v client.ncconf.
3. Do souboru Program.cs přidejte následující kód:

builder.Services.AddNCacheDistributedCache(configuration =>
{
    configuration.CacheName = "democache";
    configuration.EnableLogs = true;
    configuration.ExceptionsEnabled = true;
});

Distribuovaná mezipaměť Azure CosmosDB

Azure Cosmos DB je možné použít ve službě ASP.NET Core jako zprostředkovatele stavu relace pomocí IDistributedCache rozhraní. Azure Cosmos DB je plně spravovaná noSQL a relační databáze pro moderní vývoj aplikací, která nabízí přístup k datům s vysokou dostupností, škálovatelností a nízkou latencí pro klíčové aplikace.

Po instalaci microsoft.Extensions.Ukládání do mezipaměti. Balíček NuGet cosmos, nakonfigurujte distribuovanou mezipaměť Azure Cosmos DB následujícím způsobem:

Opakované použití existujícího klienta

Nejjednodušší způsob, jak nakonfigurovat distribuovanou mezipaměť, je opětovné použití existujícího klienta služby Azure Cosmos DB. V takovém případě nebude instance uvolněna, CosmosClient když je poskytovatel uvolněn.

services.AddCosmosCache((CosmosCacheOptions cacheOptions) =>
{
    cacheOptions.ContainerName = Configuration["CosmosCacheContainer"];
    cacheOptions.DatabaseName = Configuration["CosmosCacheDatabase"];
    cacheOptions.CosmosClient = existingCosmosClient;
    cacheOptions.CreateIfNotExists = true;
});

Vytvoření nového klienta

Alternativně vytvořte instanci nového klienta. V tomto případě se instance zlikviduje, CosmosClient když je zprostředkovatel uvolněn.

services.AddCosmosCache((CosmosCacheOptions cacheOptions) =>
{
    cacheOptions.ContainerName = Configuration["CosmosCacheContainer"];
    cacheOptions.DatabaseName = Configuration["CosmosCacheDatabase"];
    cacheOptions.ClientBuilder = new CosmosClientBuilder(Configuration["CosmosConnectionString"]);
    cacheOptions.CreateIfNotExists = true;
});

Použití distribuované mezipaměti

Pokud chcete rozhraní použít IDistributedCache , požádejte o instanci IDistributedCache aplikace. Instanci poskytuje injektáž závislostí (DI).

Při spuštění IDistributedCache ukázkové aplikace se vloží do Program.cssouboru . Aktuální čas se ukládá do mezipaměti pomocí IHostApplicationLifetime (další informace najdete v tématu Obecný hostitel: IHostApplicationLifetime):

app.Lifetime.ApplicationStarted.Register(() =>
{
    var currentTimeUTC = DateTime.UtcNow.ToString();
    byte[] encodedCurrentTimeUTC = System.Text.Encoding.UTF8.GetBytes(currentTimeUTC);
    var options = new DistributedCacheEntryOptions()
        .SetSlidingExpiration(TimeSpan.FromSeconds(20));
    app.Services.GetService<IDistributedCache>()
                              .Set("cachedTimeUTC", encodedCurrentTimeUTC, options);
});

Ukázková aplikace se vloží IDistributedCache do IndexModel stránky indexu pro použití.

Při každém načtení indexové stránky se v mezipaměti zkontroluje čas OnGetAsyncv mezipaměti . Pokud nevypršela platnost času v mezipaměti, zobrazí se čas. Pokud uplynulo 20 sekund od posledního přístupu k času uloženému v mezipaměti (při posledním načtení této stránky), zobrazí se na stránce čas vypršení platnosti mezipaměti.

Okamžitě aktualizujte čas v mezipaměti na aktuální čas výběrem tlačítka Obnovit čas v mezipaměti. Tlačítko aktivuje metodu OnPostResetCachedTime obslužné rutiny.

public class IndexModel : PageModel
{
    private readonly IDistributedCache _cache;

    public IndexModel(IDistributedCache cache)
    {
        _cache = cache;
    }

    public string? CachedTimeUTC { get; set; }
    public string? ASP_Environment { get; set; }

    public async Task OnGetAsync()
    {
        CachedTimeUTC = "Cached Time Expired";
        var encodedCachedTimeUTC = await _cache.GetAsync("cachedTimeUTC");

        if (encodedCachedTimeUTC != null)
        {
            CachedTimeUTC = Encoding.UTF8.GetString(encodedCachedTimeUTC);
        }

        ASP_Environment = Environment.GetEnvironmentVariable("ASPNETCORE_ENVIRONMENT");
        if (String.IsNullOrEmpty(ASP_Environment))
        {
            ASP_Environment = "Null, so Production";
        }
    }

    public async Task<IActionResult> OnPostResetCachedTime()
    {
        var currentTimeUTC = DateTime.UtcNow.ToString();
        byte[] encodedCurrentTimeUTC = Encoding.UTF8.GetBytes(currentTimeUTC);
        var options = new DistributedCacheEntryOptions()
            .SetSlidingExpiration(TimeSpan.FromSeconds(20));
        await _cache.SetAsync("cachedTimeUTC", encodedCurrentTimeUTC, options);

        return RedirectToPage();
    }
}

Pro instance s předdefinovanými implementacemi není nutné používat životnost IDistributedCache Singleton nebo Scoped.

Instanci můžete vytvořit IDistributedCache také všude, kde ho budete potřebovat místo použití distance, ale vytvoření instance v kódu může znesnadnit testování a porušení zásady explicitních závislostí.

Doporučení

Při rozhodování o tom, která implementace IDistributedCache je pro vaši aplikaci nejvhodnější, zvažte následující:

• Existující infrastruktura
• Požadavky na výkon
• Náklady
• Týmové prostředí

Ukládání do mezipaměti řešení obvykle spoléhají na úložiště v paměti, aby poskytovala rychlé načítání dat uložených v mezipaměti, ale paměť je omezený a nákladný pro rozšíření. Ukládejte pouze běžně používaná data do mezipaměti.

U většiny aplikací poskytuje mezipaměť Redis vyšší propustnost a nižší latenci než mezipaměť SQL Serveru. Srovnávací testy se ale doporučuje určit charakteristiky výkonu strategií ukládání do mezipaměti.

Pokud se SQL Server používá jako záložní úložiště distribuované mezipaměti, může použití stejné databáze pro mezipaměť a běžného úložiště dat a načítání aplikace negativně ovlivnit výkon obou. Pro záložní úložiště distribuované mezipaměti doporučujeme použít vyhrazenou instanci SQL Serveru.

Další materiály

• Redis Cache v Azure
• SQL Database v Azure
• ASP.NET zprostředkovatel core IDistributedCache pro NCache ve webových farmách (NCache na GitHubu)
• Soubor README úložiště pro Microsoft.Extensions. Ukládání do mezipaměti. Cosmos
• Ukládání do mezipaměti v paměti v ASP.NET Core
• Detekce změn pomocí tokenů změn v ASP.NET Core
• Ukládání odpovědí do mezipaměti v ASP.NET Core
• Middleware odpovědi Ukládání do mezipaměti v ASP.NET Core
• Pomocná rutina značek mezipaměti v ASP.NET Core MVC
• Pomocná rutina značek distribuované mezipaměti v ASP.NET Core
• Hostování ASP.NET Core ve webové farmě