Elosztott gyorsítótárazás a ASP.NET Core-ban

Készítette: Mohsin Nasir és smandia

Az elosztott gyorsítótár egy több alkalmazáskiszolgáló által megosztott gyorsítótár. A gyorsítótárat általában külső szolgáltatásként tartják fenn a hozzá hozzáférő alkalmazáskiszolgálók számára. Az elosztott gyorsítótár javíthatja a ASP.NET Core-alkalmazások teljesítményét és méretezhetőségét, különösen akkor, ha egy felhőszolgáltatás vagy egy kiszolgálófarm üzemelteti az alkalmazást.

Az elosztott gyorsítótár számos előnnyel rendelkezik más gyorsítótárazási forgatókönyvekkel szemben, amikor a gyorsítótárazott adatokat az egyes alkalmazáskiszolgálókon tárolják.

A gyorsítótárazott adatok elosztásakor az adatok:

• Koherens (konzisztens) a több kiszolgálóra irányuló kérelmek között.
• Túléli a kiszolgáló újraindítását és az alkalmazások üzembe helyezését.
• Nem használ helyi memóriát.

Az elosztott gyorsítótár konfigurációja implementációspecifikus. Ez a cikk az SQL Server, a Redis vagy a Postgres elosztott gyorsítótárainak konfigurálását ismerteti. Nem Microsoft implementációk is elérhetők, például NCache (NCache on GitHub), Azure Cosmos DB és Postgres. Függetlenül attól, hogy melyik implementáció van kiválasztva, az alkalmazás a felület használatával kommunikál a IDistributedCache gyorsítótárral.

Mintakód megtekintése vagy letöltése (hogyan töltsd le)

Warning

Ez a cikk egy helyi adatbázist használ, amely nem igényli a felhasználó hitelesítését. A termelésben használt alkalmazásoknak az elérhető legbiztonságosabb hitelesítési folyamatot kell használniuk. Az üzembe helyezett teszt- és éles alkalmazások hitelesítéséről további információt Biztonságos hitelesítési folyamatokcímű témakörben talál.

Prerequisites

Adjon hozzá egy csomaghivatkozást a használt elosztott gyorsítótár-szolgáltatóhoz:

• Redis elosztott gyorsítótár esetén : Microsoft.Extensions.Caching.StackExchangeRedis.
• SQL Server esetén Microsoft.Extensions.Caching.SqlServer.
• A Postgreshez a Microsoft.Extensions.Caching.Postgres-t használjuk.
• Az Azure Cosmos DB Microsoft.Extensions.Caching.Cosmos.
• Az NCache elosztott gyorsítótár esetében az NCache.Microsoft.Extensions.Caching.OpenSource.

Az IDistributedCache felület használata

Az IDistributedCache interfész az alábbi módszereket kínálja az elosztott gyorsítótár-implementáció elemeinek módosításához:

• Get, GetAsync: Elfogad egy sztringkulcsot, és ha megtalálja a gyorsítótárban, tömbként kér le egy gyorsítótárazott elemet.
• Set, SetAsync: Egy elemet (tömbként byte[] ) ad hozzá a gyorsítótárhoz egy sztringkulcs használatával.
• Refresh, RefreshAsync: Frissíti a gyorsítótár egy elemét a kulcs alapján, visszaállítva az expirációs időkorlátot (ha van ilyen).
• Remove, RemoveAsync: Eltávolít egy gyorsítótár-elemet a karakterlánc kulcs alapján.

Elosztott gyorsítótárazási szolgáltatások létrehozása

Regisztrálja a(z) IDistributedCache implementációját a Program.cs fájlban. A következő keretrendszer által biztosított implementációkat ismertetjük ebben a cikkben:

• Elosztott Redis-gyorsítótár
• Elosztott memória gyorsítótára
• Elosztott SQL Server-gyorsítótár
• Elosztott Postgres-gyorsítótár
• Elosztott NCache-gyorsítótár
• Elosztott Azure Cosmos DB-gyorsítótár

Elosztott Redis-gyorsítótár

Az elosztott Redis-gyorsítótár a legjobb teljesítményt nyújtja, és éles alkalmazásokhoz ajánlott. A Redis egy nyílt forráskódú memóriabeli adattár, amelyet gyakran elosztott gyorsítótárként használnak. Konfigurálhat egy Azure Cache for Redist egy Azure-ban üzemeltetett ASP.NET Core-alkalmazáshoz, és használhat egy Azure Cache for Redist a helyi fejlesztéshez. További információ: Gyorsítótár-javaslatok áttekintése.

Az alkalmazás a RedisCache metódus meghívásával konfigurálja a gyorsítótár implementációját egy AddStackExchangeRedisCache példánnyal. A kimeneti gyorsítótárazáshoz használja a AddStackExchangeRedisOutputCache metódust.

1. Hozzon létre egy Azure Cache for Redis-példányt.

2. Másolja az elsődleges kapcsolati karakterláncot (StackExchange.Redis) a Configuration részhez.

   • A helyi fejlesztéshez: Mentse a kapcsolati karakterláncot a Secret Manager használatával.

   • Az Azure esetében: Mentse a kapcsolat karakterláncát egy biztonságos tárolóba, például Azure Key Vault-ba.

Az alábbi kód lehetővé teszi az Azure Cache for Redis használatát:

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

Az előző kód feltételezi, hogy a rendszer az elsődleges kapcsolat karakterláncot (StackExchange.Redis) a konfigurációban felmenti a MyRedisConStr kulcsnévvel.

További információ: Azure Managed Redis.

A helyi Redis Cache alternatív megközelítéséről a GitHub /dotnet/aspnetcore probléma #19542 című témakörben olvashat.

Elosztott memória gyorsítótára

Az elosztott memóriagyorsítótár (AddDistributedMemoryCache) a keretrendszer biztosította olyan implementáció, amely az elemeket a memóriában tárolja. Az elosztott memóriagyorsítótár azonban nem tényleges elosztott gyorsítótár. Az alkalmazáspéldány a gyorsítótárazott elemeket azon a kiszolgálón tárolja, amelyen az alkalmazás fut.

Az elosztott memóriagyorsítótár hasznos implementáció fejlesztési és tesztelési forgatókönyvekhez. Egyetlen szerver esetén is hasznos egy üzemi forgatókönyvben, ahol a memóriahasználat nem jelent problémát. Az elosztott memóriagyorsítótár implementálása absztrahálja a gyorsítótárazott adattárolást. Lehetővé teszi egy valódi elosztott gyorsítótárazási megoldás implementálását a jövőben, ha több csomópontra vagy hibatűrésre van szükség.

A mintaalkalmazás az elosztott memóriagyorsítótárat használja, amikor az alkalmazás a Development környezetben fut a Program.cs fájlban.

builder.Services.AddDistributedMemoryCache();

Elosztott SQL Server gyorsítótár

Az elosztott SQL Server gyorsítótár implementálása (AddDistributedSqlServerCache) lehetővé teszi, hogy az elosztott gyorsítótár háttértárként egy SQL Server adatbázist használjon. Ha egy gyorsítótárazott elemtáblát szeretne létrehozni egy SQL Server példányban, akkor az sql-cache eszközt használhatja. Az eszköz létrehoz egy táblát a megadott névvel és sémával.

Hozzon létre egy táblát az SQL Serveren a sql-cache create parancs futtatásával. Adja meg az SQL Server-példányt (Data Source), az adatbázist (Initial Catalog), a sémát (például dbo), és a tábla nevét (például TestCache: ):

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

Ha az eszköz sikeres, a rendszer naplózza az üzenetet:

Table and index were created successfully.

Az eszköz által sql-cache létrehozott táblázat a következő sémával rendelkezik:

Note

Az alkalmazásnak a gyorsítótár értékeit a IDistributedCache példány használatával kell módosítania, nem pedig a SqlServerCache példánnyal.

A mintaalkalmazás egy nem fejlesztési (SqlServerCache) környezetben implementálja az Development osztályt a Program.cs fájlban:

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

Note

Az olyan tulajdonságok, mint ConnectionString (és opcionálisan SchemaName és TableName), általában a forrásvezérlőn kívül vannak tárolva. Például a Secret Manager vagy az appsettings.json, illetve az appsettings.{Environment}.json fájl tárolhatja a tulajdonságokat. A kapcsolati karakterlánc tartalmazhatnak olyan hitelesítő adatokat, amelyeket a forrásvezérlő rendszereken kívül kell tartani.

További információ: SQL Database on Azure.

Elosztott Postgres-gyorsítótár

Az Azure Database for PostgreSQL elosztott gyorsítótár-háttértárként használható a IDistributedCache felületen keresztül. Azure Database for PostgreSQL egy teljes mértékben felügyelt, AI-ready Database-as-a-Service (DBaaS) ajánlat, amely a nyílt forráskódú PostgreSQL-motorra épül. A kialakítás kiszámítható teljesítménnyel, robusztus biztonsággal, magas rendelkezésre állással és zökkenőmentes méretezhetőséggel támogatja a kritikus fontosságú számítási feladatokat.

A Microsoft.Extensions.Caching.Postgres NuGet-csomag telepítése után konfigurálja az elosztott gyorsítótárat az alábbiak szerint:

1. Regisztrálja a szolgáltatást.

   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. Használja a gyorsítótárat.

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

Elosztott NCache-gyorsítótár

Az NCache egy nyílt forráskódú, memórián belüli elosztott gyorsítótár, amelyet natív módon fejlesztettek ki a .NET-ben. Az NCache helyileg és elosztott gyorsítótárfürtként is működik az Azure-ban vagy más üzemeltetési platformokon futó ASP.NET Core-alkalmazásokhoz.

Az NCache helyi gépen való telepítéséhez és konfigurálásához tekintse meg az első lépéseket ismertető útmutatót.

Az NCache konfigurálása:

1. Telepítse a NCache SDK NuGet-csomagot, amely támogatja az NCache Opensource-t .NET Keretrendszerhez és .NET Core-alkalmazásokhoz.

2. Konfigurálja a gyorsítótárfürtöt az ügyfélkonfigurációban (a client.ncconf fájlt).

3. Adja hozzá a következő kódot a Program.cs fájlhoz:

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

Elosztott Azure Cosmos DB gyorsítótár

Azure Cosmos DB a IDistributedCache interfész használatával konfigurálható ASP.NET Core munkamenet-állapotszolgáltatóként. Az Azure Cosmos DB egy teljes körűen felügyelt NoSQL- és relációs adatbázis a modern alkalmazásfejlesztéshez, amely magas rendelkezésre állást, méretezhetőséget és alacsony késésű hozzáférést biztosít a kritikus fontosságú alkalmazások adataihoz.

A Microsoft.Extensions.Caching.Cosmos NuGet-csomag telepítése után, konfiguráljon egy Azure Cosmos DB elosztott gyorsítótárat. Használhat meglévő Azure Cosmos DB-ügyfelet, vagy létrehozhat egy újat az alábbi szakaszokban leírtak szerint.

További információkért tekintse meg a Microsoft Gyorsítótárazási bővítmény használata az Azure Cosmos DB-vel oldalt, valamint a GitHub adattár README-fájlját a NuGet-csomaghoz.

Meglévő ügyfél újrafelhasználása

Az elosztott gyorsítótár konfigurálásának legegyszerűbb módja egy meglévő Azure Cosmos DB-ügyfél újbóli használata. Ebben az esetben a CosmosClient példány nem lesz megsemmisítve, amikor a szolgáltatót elidegenítik.

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

Új ügyfél létrehozása

Alternatívaként hozzon létre egy új kliens példányt. Ebben az esetben a CosmosClient példány a szolgáltató megsemmisítésekor kerül megsemmisítésre.

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

Az elosztott gyorsítótár használata

A IDistributedCache felület használatához kérjen példányt IDistributedCache az alkalmazásban. A példányt függőséginjektálás (DI) biztosítja.

A mintaalkalmazás indításakor a IDistributedCache példányt a Program.cs fájlba injektálja. Az aktuális idő gyorsítótárazva lesz az IHostApplicationLifetime interfész használatával. (További információért lásd: .NET generikus hoszt: 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);
});

A mintaalkalmazás a IDistributedCache példányt az IndexModel objektumba injektálja, hogy azt az Index oldal használhassa.

Minden alkalommal, amikor az Index lap betöltődik, a OnGetAsync metódus segítségével ellenőrizzük a gyorsítótárazott időt. Ha a gyorsítótárban lévő idő nem járt le, az idő megjelenik. Ha a gyorsítótárazott idő legutóbbi elérése óta eltelt 20 másodperc (az oldal utolsó betöltésekor), a lapon megjelenik a gyorsítótárazási idő lejárt.

Azonnal frissítse a gyorsítótárazott időt az aktuális időpontra, a Gyorsítótárazott idő visszaállítása opció kiválasztásával. Ez a művelet aktiválja a OnPostResetCachedTime kezelőmetódust.

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

A IDistributedCache beépített implementációjú példányok esetében nem kell Singleton vagy hatókörön belüli élettartamot használni.

Ahol szüksége van rá, ott DI használata helyett létrehozhat egy IDistributedCache példányt. A kódpéldányok létrehozása azonban megnehezítheti a kód tesztelését, és megsértheti az explicit függőségek elvét.

Gyorsítótár-javaslatok áttekintése

Amikor eldönti, hogy az IDistributedCache interfész melyik implementációja a legjobb az alkalmazás számára, vegye figyelembe a következő szempontokat:

• Meglévő infrastruktúra
• Teljesítménnyel kapcsolatos követelmények
• Cost
• Csapatélmény

A gyorsítótárazási megoldások általában a memóriabeli tárolásra támaszkodnak a gyorsítótárazott adatok gyors lekéréséhez, de a memória korlátozott erőforrás, és költséges a bővítés. Csak a gyakran használt adatokat tárolja gyorsítótárban.

A legtöbb alkalmazás esetében a Redis-gyorsítótár nagyobb átviteli sebességet és kisebb késést biztosít, mint egy SQL Server-gyorsítótár. A teljesítményjellemzők meghatározása érdekében azonban ajánlott a benchmarking a gyorsítótárazási stratégiák esetében.

Ha SQL Server az elosztott gyorsítótár háttértárolója, és a gyorsítótár és az alkalmazásadattár/-lekérés ugyanazt az adatbázist használja, a teljesítmény csökkenthető. Az elosztott gyorsítótár háttértárolójához ajánlott egy dedikált SQL Server-példány használata.

Kapcsolódó tartalom

• Redis Cache az Azure-ban
• SQL Database az Azure-ban
• Azure Database for PostgreSQL
• ASP.NET Core IDistributedCache szolgáltató az NCache-hez webfarmokban (NCache a GitHubon)
• A Microsoft.Extensions.Caching.Cosmos tárhely README fájlja
• Változások észlelése változási tokenekkel az ASP.NET Core
• Cache Tag Helper az ASP.NET Core MVC
• Elosztott gyorsítótár címke segédprogram az ASP.NET Core-ban
• ASP.NET Core üzemeltetése egy webfarmban