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, amely általában külső szolgáltatásként van fenntartva 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 az alkalmazást felhőszolgáltatás vagy kiszolgálófarm üzemelteti.

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. Külső implementációk is elérhetők, például az NCache (NCache a GitHubon), a Cosmos DB és a Postgres. Függetlenül attól, hogy melyik implementáció van kiválasztva, az alkalmazás a felületen keresztül 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.
• A Cosmos DB esetében a Microsoft.Extensions.Caching.Cosmos.
• Az NCache elosztott gyorsítótár esetében az NCache.Microsoft.Extensions.Caching.OpenSource.

IDistributedCache felület

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

Egy IDistributedCache regisztrálása a(z) Program.cs-ben. Az ebben a témakörben ismertetett keretrendszeralapú implementációk a következők:

• Elosztott Redis-gyorsítótár
• Elosztott memóriagyorsítótár
• 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 Cache

Azt javasoljuk, hogy az éles alkalmazások az Elosztott Redis Cache-t használják, mert ez a legmegfelelőbb. További információ: Javaslatok.

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.

Az alkalmazás RedisCache példány használatával konfigurálja a gyorsítótár implementációját, meghívva AddStackExchangeRedisCache. A kimeneti gyorsítótárazáshoz használja a következőtAddStackExchangeRedisOutputCache: .

1. Hozzon létre egy Azure Cache for Redis-t.
2. Másolja az elsődleges kapcsolati sztringet (StackExchange.Redis) a Konfigurációba.
   • Helyi fejlesztés: Mentse a kapcsolati sztringet a Secret Manager használatával.
   • Azure: Mentse a kapcsolati sztringet egy biztonságos tárolóban, például az Azure Key Vaultban

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 az elsődleges kapcsolati lánc (StackExchange.Redis) a kulcsnévvel MyRedisConStr rendelkező konfigurációban lett mentve.

További információ: Azure Cache for Redis.

Lásd ezt a GitHub feladatot a helyi Redis gyorsítótár alternatív megközelítéseivel kapcsolatos megbeszéléshez.

Elosztott memóriagyorsítótár

Az Elosztott memóriagyorsítótár (AddDistributedMemoryCache) egy keretrendszer által biztosított IDistributedCache implementáció, amely a memóriában tárolja az elemeket. Az elosztott memóriagyorsítótár nem tényleges elosztott gyorsítótár. A gyorsítótárazott elemeket az alkalmazás példánya tárolja azon a kiszolgálón, ahol az alkalmazás fut.

Az elosztott memóriagyorsítótár egy hasznos megvalósítás.

• Fejlesztési és tesztelési forgatókönyvekben.
• Ha egyetlen kiszolgálót használnak az éles környezetben, és 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 akkor használja az Elosztott memóriagyorsítótárat, ha az alkalmazás a következő fejlesztési környezetben Program.csfut:

builder.Services.AddDistributedMemoryCache();

Elosztott SQL Server-gyorsítótár

Az Elosztott SQL Server Cache implementáció (AddDistributedSqlServerCache) lehetővé teszi az elosztott gyorsítótár számára, hogy az SQL Server-adatbázist használja háttértárként. 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

A rendszer egy üzenetet naplóz, amely jelzi, hogy az eszköz sikeres volt:

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 egy IDistributedCache példány használatával kell módosítania, nem pedig egy SqlServerCache.

A mintaalkalmazás nem fejlesztési környezetben implementálja a SqlServerCache a Program.cs-ban/-ben.

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

Note

Az ConnectionString (és opcionálisan a SchemaName és TableName) elemeket általában a forrásvezérlésen kívül tárolják (például a Secret Manager tárolja őket, vagy appsettings.json/appsettings.{Environment}.json fájlokban). A kapcsolati sztring tartalmazhat olyan hitelesítő adatokat, amelyeket ki kell tartani a forrásvezérlő rendszerekből.

Elosztott PostgreSQL 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. Az Azure Database for PostgreSQL a nyílt forráskódú PostgreSQL-motorra épülő, teljes körűen felügyelt, AI-kész adatbázis-as-a-service (DBaaS) ajánlat, amely 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. A szolgáltatás regisztrálása

using Microsoft.Extensions.DependencyInjection;

var builder = WebApplication.CreateBuilder(args);

// Register 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. A gyorsítótár használata

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 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 cache

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 a Windows & Linux első lépéseit ismertető útmutatót.

Az NCache konfigurálása:

1. Telepítse az NCache nyílt forráskódú NuGet-et.
2. Konfigurálja a gyorsítótárfürtöt a client.ncconf fájlban.
3. Adja hozzá a következő kódot a Program.cs:

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

Elosztott Azure Cosmos DB Cache

Az Azure Cosmos DB a ASP.NET Core-ban használható munkamenet-állapotszolgáltatóként az IDistributedCache interfész használatával. 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 az alábbiak szerint:

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 megsemmisül, amikor a szolgáltató megsemmisül.

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.

Amikor a mintaalkalmazás elindul, IDistributedCache be van szúrva a Program.cs-be. Az aktuális idő tárolva van IHostApplicationLifetime (további információkért lásd: Általános gazdagép: 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-t a IndexModel-be injektálja az Index oldal általi használatra.

Minden alkalommal, amikor az indexoldal betöltődik, a gyorsítótár ellenőrzésre kerül a gyorsítótárban lévő tárolási idővel OnGetAsync. Ha a gyorsítótárban tárolt idő érvényessége nem járt le, megjelenik az idő. Ha 20 másodperc telt el a gyorsítótárazott idő legutóbbi elérése óta (a lap utolsó betöltésekor), a lapon megjelenik a gyorsítótárazási idő lejárt.

A gyorsítótárazott idő visszaállítása gombra kattintva azonnal frissítse a gyorsítótárazott időt az aktuális időpontra . A gomb 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();
    }
}

A beépített implementációkat használó példányok esetében nincs szükség Singleton vagy Scoped élettartam alkalmazására.

A DI használata helyett bárhol létrehozhat egy IDistributedCache példányt, ahol szüksége van rá, de egy példány létrehozása a kódban megnehezítheti a kód tesztelését, és megsérti a Kifejezett függőségek elvét.

Recommendations

Amikor eldönti, hogy melyik implementáció IDistributedCache a legjobb az alkalmazás számára, vegye figyelembe az alábbiakat:

• 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 az SQL Servert elosztott gyorsítótár-háttértárként használják, ugyanazon adatbázis használata a gyorsítótárhoz, valamint az alkalmazás szokásos adattárolása és lekérése negatívan befolyásolhatja mindkettő teljesítményét. Javasoljuk, hogy az elosztott cache háttértárolóhoz használjon dedikált SQL Server-példányt.

További erőforrások

• 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
• Memóriabeli gyorsítótárazás ASP.NET Core
• Változások észlelése változási tokenekkel az ASP.NET Core
• Válasz gyorsítótárazása az ASP.NET Core-ban
• Response Caching Middleware 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