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

By Mohsin Nasir a smandia

Distribuovaná mezipaměť je mezipaměť sdílená více aplikačními servery. Mezipaměť se obvykle udržuje 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 když cloudová služba nebo serverová farma hostuje aplikaci.

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, Redis nebo Postgres. K dispozici jsou také implementace, které nejsou Microsoft, například NCache (NCache na GitHub), Azure Cosmos DB a Postgres. 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í)

Warning

Tento článek používá místní databázi, která nevyžaduje ověření uživatele. Produkční aplikace by měly používat nejbezpečnější dostupný tok ověřování. Další informace o ověřování nasazených testovacích a produkčních aplikacích naleznete v Bezpečné autentizační toky.

Prerequisites

Přidejte odkaz na balíček pro zprostředkovatele distribuované mezipaměti použitý:

• Pro distribuovanou mezipaměť Redis je to Microsoft.Extensions.Caching.StackExchangeRedis.
• Pro SQL Server, Microsoft.Extensions.Caching.SqlServer.
• Pro Postgres , Microsoft.Extensions.Caching.Postgres.
• Pro Azure Cosmos DB Microsoft.Extensions.Caching.Cosmos.
• Pro distribuovanou mezipaměť NCache NCache.Microsoft.Extensions.Caching.OpenSource.

Použití rozhraní IDistributedCache

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

• Get, GetAsync: Přijme řetězcový klíč a načte položku uloženou v mezipaměti jako pole byte[], pokud se nachází v mezipaměti.
• Set, SetAsync: Přidá položku (jako pole byte[]) do mezipaměti pomocí řetězcového klíče.
• 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 v souboru Program.cs . Následující implementace poskytované rámcem jsou popsány v tomto článku:

• Distribuovaná mezipaměť Redis
• Distribuovaná paměťová mezipaměť
• Distribuovaná mezipaměť SQL Serveru
• Distribuovaná mezipaměť Postgres
• Distribuovaná mezipaměť NCache
• Distribuovaná mezipaměť Azure Cosmos DB

Distribuovaná mezipaměť Redis

Distribuovaná mezipaměť Redis poskytuje nejlepší výkon a doporučuje se pro produkční aplikace. 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. Další informace najdete v Kontrola doporučení mezipaměti.

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

1. Vytvořte instanci Azure Cache for Redis.

2. Zkopírujte primární připojovací řetězec (StackExchange.Redis) do Konfigurace.

   • Pro místní vývoj: Uložte připojovací řetězec pomocí Secret Manager.

   • For Azure: Uložte připojovací řetězec do zabezpečeného úložiště, například Azure Key Vault.

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) je uložen v konfiguraci s klíčovým názvem MyRedisConStr.

Další informace najdete v tématu Azure Managed Redis.

Diskuzi o alternativních přístupech k místní mezipaměti Redis najdete v tématu GitHub /dotnet/aspnetcore problém #19542.

Distribuovaná cache paměti

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

Mezipaměť distribuované paměti je užitečná implementace pro scénáře vývoje a testování. Je také užitečné pro jeden server v produkčním scénáři, kdy spotřeba paměti není problémem. Implementace distribuované cache abstraktuje ukládání dat 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 v Development prostředí v souboru Program.cs .

builder.Services.AddDistributedMemoryCache();

Distribuovaná mezipaměť SQL Server

Implementace distribuované mezipaměti SQL Server (AddDistributedSqlServerCache) umožňuje distribuované mezipaměti používat SQL Server databázi 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

Po úspěšném dokončení nástroje se zaprotokoluje zpráva:

Table and index were created successfully.

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

Note

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

Ukázková aplikace implementuje SqlServerCache třídu v neprodukčním (Development) prostředí v souboru Program.cs :

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

Note

Vlastnosti jako ConnectionString (a volitelně SchemaName a TableName) se obvykle ukládají mimo správu zdrojového kódu. Například soubor Správce tajemství nebo appsettings.json nebo appsettings.{Environment}.json může ukládat vlastnosti. Connection string může obsahovat přihlašovací údaje, které by se měly uchovávat mimo systémy správy zdrojového kódu.

Další informace najdete v tématu SQL Database on Azure.

Distribuovaná mezipaměť Postgres

Azure Database for PostgreSQL je možné použít jako záložní úložiště distribuované mezipaměti prostřednictvím IDistributedCache rozhraní. Azure Database for PostgreSQL je plně spravovaná nabídka DBaaS (Database as a Service) připravená na AI, která je založená na opensourcovém modulu PostgreSQL. Návrh podporuje klíčové úlohy s předvídatelným výkonem, robustním zabezpečením, vysokou dostupností a bezproblémovou škálovatelností.

Po instalaci balíčku NuGet Microsoft.Extensions.Caching.Postgres nakonfigurujte distribuovanou mezipaměť následujícím způsobem:

1. Zaregistrujte službu.

   using Microsoft.Extensions.DependencyInjection;
   
   var builder = WebApplication.CreateBuilder(args);
   
   // Register the Postgres distributed cache.
   builder.Services.AddDistributedPostgresCache(options => {
      options.ConnectionString = builder.Configuration.GetConnectionString("PostgresCache");
      options.SchemaName = builder.Configuration.GetValue<string>("PostgresCache:SchemaName", "public");
      options.TableName = builder.Configuration.GetValue<string>("PostgresCache:TableName", "cache");
      options.CreateIfNotExists = builder.Configuration.GetValue<bool>("PostgresCache:CreateIfNotExists", true);
      options.UseWAL = builder.Configuration.GetValue<bool>("PostgresCache:UseWAL", false);
   
      // Optional: Configure expiration settings.
   
      var expirationInterval = builder.Configuration.GetValue<string>("PostgresCache:ExpiredItemsDeletionInterval");
      if (!string.IsNullOrEmpty(expirationInterval) && TimeSpan.TryParse(expirationInterval, out var interval)) {
          options.ExpiredItemsDeletionInterval = interval;
      }
   
      var slidingExpiration = builder.Configuration.GetValue<string>("PostgresCache:DefaultSlidingExpiration");
      if (!string.IsNullOrEmpty(slidingExpiration) && TimeSpan.TryParse(slidingExpiration, out var sliding)) {
          options.DefaultSlidingExpiration = sliding;
      }
   });
   
   var app = builder.Build();
   

2. Použijte mezipaměť.

   public class MyService {
       private readonly IDistributedCache _cache; 
   
       public MyService(IDistributedCache cache) {
           _cache = cache;
       }
   
       public async Task<string> GetDataAsync(string key) {
           var cachedData = await _cache.GetStringAsync(key);
   
           if (cachedData == null) {
   
               // Fetch the data from source.
               var data = await FetchDataFromSource();
   
               // Cache the data with options.
               var options = new DistributedCacheEntryOptions {
                  AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(30),
                  SlidingExpiration = TimeSpan.FromMinutes(5)
               };
   
               await _cache.SetStringAsync(key, data, options);
               return data;
           }
   
           return cachedData;
       }
   }
   

Distribuovaná mezipaměť NCache

NCache je opensourcová distribuovaná mezipaměť v paměti vyvinutá nativně v .NET. 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.

Konfigurace NCache:

1. Nainstalujte balíček NCache SDK NuGet, který podporuje open-source NCache pro aplikace .NET Framework a .NET Core.

2. Nakonfigurujte cluster mezipaměti v konfiguraci klienta (soubor 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 Cosmos DB

Azure Cosmos DB lze nakonfigurovat v ASP.NET Core jako zprostředkovatele stavu relace pomocí rozhraní IDistributedCache. 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.Caching.Cosmos balíček NuGet nakonfigurujte Azure Cosmos DB distribuovanou mezipaměť. Můžete použít existujícího klienta Azure Cosmos DB nebo vytvořit nový, jak je popsáno v následujících částech.

Další informace najdete v souboru README úložiště GitHub balíčku NuGet Rozšíření ukládání do mezipaměti Microsoft s využitím Azure Cosmos DB.

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

Nejjednodušší způsob, jak nakonfigurovat distribuovanou mezipaměť, je opětovné použití existujícího klienta Azure Cosmos DB. V takovém případě instance CosmosClient není uvolněna, 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ě je instance uvolněna při CosmosClient odstranění poskytovatele.

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

K použití rozhraní IDistributedCache požádejte v aplikaci o instanci IDistributedCache. Instanci poskytuje injektáž závislostí (DI).

Při spuštění IDistributedCache ukázkové aplikace se instance vloží do souboru Program.cs . Aktuální čas se ukládá do mezipaměti pomocí IHostApplicationLifetime rozhraní. (Další informace najdete v tématu .NET 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 vloží IDistributedCache instanci do objektu IndexModel pro použití na stránce Index.

Pokaždé, když se načte indexová stránka, je pomocí metody OnGetAsync kontrolována mezipaměť pro uložený čas. 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 zpráva Čas vypršení mezipaměti.

Okamžitě aktualizujte čas v mezipaměti na aktuální čas výběrem možnosti Obnovit čas v mezipaměti . Tato akce spouští metodu obslužné rutiny OnPostResetCachedTime.

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();
    }
}

Note

Pro instance s integrovanou implementací nemusíte používat životnost IDistributedCache Singleton nebo Scoped.

Můžete také vytvořit instanci IDistributedCache všude, kde ji možná budete potřebovat, místo použití DI. Vytvoření instance v kódu však může znesnadnit testování kódu a porušení zásady explicitních závislostí.

Přehled doporučení týkajících se mezipaměti

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

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

Řešení cache obvykle spoléhají na in-memory úložiště, aby poskytovala rychlé načítání dat uložených v mezipaměti, ale paměť je omezená a její rozšíření je nákladné. 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. Doporučuje se provádět srovnávací testy pro určení charakteristik výkonu strategií ukládání do mezipaměti.

Pokud je SQL Server podkladovým úložištěm distribuované mezipaměti a úložiště a načítání dat aplikace používají stejnou databázi, výkon může být snížen. Doporučeným přístupem je použití vyhrazené instance SQL Server pro záložní úložiště distribuované mezipaměti.

Související obsah

• Redis Cache na Azure
• SQL Database na Azure
• Azure Database for PostgreSQL
• ASP.NET Core poskytovatel IDistributedCache pro NCache ve webových farmách (NCache na GitHubu)
• Soubor README repozitáře pro Microsoft.Extensions.Caching.Cosmos
• Detekce změn pomocí tokenů změn v ASP.NET Core
• Pomocník značek mezipaměti v ASP.NET Core MVC
• Pomocník značek distribuované mezipaměti v ASP.NET Core
• Hostování ASP.NET Core ve webové farmě