Buforowanie rozproszone w ASP.NET Core

Przez Mohsin Nasir i smandia

Note

Nie jest to najnowsza wersja tego artykułu. Aby zapoznać się z bieżącą wersją, zobacz wersję .NET 11 tego artykułu.

Rozproszona pamięć podręczna to pamięć podręczna dzielona przez wiele serwerów aplikacji. Pamięć podręczna jest zwykle utrzymywana jako usługa zewnętrzna dla serwerów aplikacji, które uzyskują do niej dostęp. Rozproszona pamięć podręczna może zwiększyć wydajność i skalowalność aplikacji ASP.NET Core, zwłaszcza gdy usługa w chmurze lub farma serwerów hostuje aplikację.

Rozproszona pamięć podręczna ma kilka zalet w przypadku innych scenariuszy buforowania, w których buforowane dane są przechowywane na poszczególnych serwerach aplikacji.

Gdy buforowane dane są dystrybuowane, dane:

  • Jest spójna (zgodna) między żądaniami dla wielu serwerów.
  • Przetrwa restarty serwera i wdrożenia aplikacji.
  • Nie używa pamięci lokalnej.

Konfiguracja rozproszonej pamięci podręcznej jest specyficzna dla implementacji. W tym artykule opisano sposób konfigurowania rozproszonych pamięci podręcznych sql Server, Redis lub Postgres. Dostępne są również implementacje inne niż Microsoft, takie jak NCache (NCache w GitHub), Azure Cosmos DB i Postgres. Niezależnie od wybranej implementacji aplikacja współdziała z pamięcią podręczną przy użyciu interfejsu IDistributedCache .

Wyświetlanie lub pobieranie przykładowego kodu (jak pobrać)

Warning

W tym artykule jest używana lokalna baza danych, która nie wymaga uwierzytelnienia użytkownika. Aplikacje produkcyjne powinny korzystać z najbezpieczniejszego dostępnego przepływu uwierzytelniania. Aby uzyskać więcej informacji na temat uwierzytelniania dla wdrożonych aplikacji testowych i produkcyjnych, zobacz Bezpieczne przepływy uwierzytelniania.

Prerequisites

Dodaj odwołanie do pakietu dla używanego dostawcy rozproszonej pamięci podręcznej:

Korzystanie z interfejsu IDistributedCache

Interfejs IDistributedCache udostępnia następujące metody manipulowania elementami w implementacji rozproszonej pamięci podręcznej:

  • Get, GetAsync: akceptuje klucz ciągu i pobiera buforowany element jako tablicę byte[] , jeśli zostanie znaleziony w pamięci podręcznej.
  • Set, SetAsync: Dodaje element (jako tablicę byte[]) do pamięci podręcznej przy użyciu klucza ciągu znaków.
  • Refresh, RefreshAsync: odświeża element w pamięci podręcznej na podstawie jego klucza, resetując jego przesuwany limit czasu wygaśnięcia (jeśli istnieje).
  • Remove, RemoveAsync: usuwa element pamięci podręcznej na podstawie klucza tekstowego.

Przechowywanie obiektów innych niż tablice bajtów

IDistributedCache przechowuje wartości jako byte[] tablice. Aby buforować inne typy, najpierw je serializuj. Następujące metody rozszerzenia używają System.Text.Json do przechowywania dowolnego typu z możliwością serializacji jako formatu JSON UTF-8:

using System.Text.Json;
using Microsoft.Extensions.Caching.Distributed;

public static class DistributedCacheExtensions
{
    public static Task SetAsync<T>(this IDistributedCache cache, string key, T value,
        DistributedCacheEntryOptions options, CancellationToken token = default) =>
        cache.SetAsync(key, JsonSerializer.SerializeToUtf8Bytes(value), options, token);

    public static async Task<T?> GetAsync<T>(this IDistributedCache cache, string key,
        CancellationToken token = default)
    {
        var bytes = await cache.GetAsync(key, token);
        return bytes is null ? default : JsonSerializer.Deserialize<T>(bytes);
    }
}

GetAsync<T> Zwraca wartość domyślną typu, taką jak null, gdy klucz nie znajduje się w pamięci podręcznej.

Tip

HybridCache biblioteka serializuje wartości za Ciebie i dodaje główną pamięć podręczną w procesie oraz ochronę przed stampede cache opartą na rozproszonej pamięci podręcznej.

Ustanawianie rozproszonych usług buforowania

Zarejestruj implementację IDistributedCache pliku Program.cs . W tym artykule opisano następujące implementacje dostarczane przez platformę:

Rozproszona pamięć podręczna Redis

Rozproszona pamięć podręczna Redis cache zapewnia najlepszą wydajność i jest zalecana w przypadku aplikacji produkcyjnych. Redis to magazyn danych w pamięci typu open source, który jest często używany jako rozproszona pamięć podręczna. Możesz skonfigurować usługę Azure Cache for Redis dla hostowanej na platformie Azure aplikacji ASP.NET Core i użyć usługi Azure Cache for Redis na potrzeby programowania lokalnego. Aby uzyskać więcej informacji, zobacz Przejrzyj zalecenia dotyczące pamięci podręcznej.

Aplikacja konfiguruje implementację pamięci podręcznej z wystąpieniem RedisCache przez wywołanie metody AddStackExchangeRedisCache. Użyj metody do AddStackExchangeRedisOutputCache.

  1. Utwórz instancję Azure Cache for Redis.

  2. Skopiuj podstawowy ciąg połączenia (StackExchange.Redis) do Configuration.

    • W przypadku programowania lokalnego: zapisz parametry połączenia za pomocą programu Secret Manager.

    • W przypadku Azure: zapisz parametry połączenia w bezpiecznym magazynie, takim jak Azure Key Vault.

Poniższy kod umożliwia korzystanie z usługi Azure Cache for Redis:

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

Powyższy kod zakłada, że podstawowy łańcuch połączeniowy (StackExchange.Redis) jest zapisany w konfiguracji pod nazwą klucza MyRedisConStr.

Aby uzyskać więcej informacji, zobacz Azure Managed Redis.

Aby zapoznać się z omówieniem alternatywnych podejść do lokalnej pamięci podręcznej Redis, zobacz GitHub /dotnet/aspnetcore issue #19542.

Rozproszona pamięć podręczna

Rozproszona pamięć podręczna (AddDistributedMemoryCache) to implementacja IDistributedCache oferowana przez framework, która przechowuje elementy w pamięci. Jednak pamięć podręczna w trybie rozproszonym nie jest rzeczywistą pamięcią rozproszoną. Wystąpienie aplikacji przechowuje buforowane elementy na serwerze, na którym działa aplikacja.

Rozproszona pamięć podręczna to przydatna implementacja w scenariuszach tworzenia i testowania. Jest to również przydatne w przypadku pojedynczego serwera w scenariuszu produkcyjnym, w którym zużycie pamięci nie jest problemem. Implementowanie rozproszonej pamięci podręcznej abstrahuje przechowywanie danych w pamięci podręcznej. Umożliwia implementację prawdziwego rozproszonego rozwiązania buforowania w przyszłości, jeśli konieczne będzie zastosowanie wielu węzłów lub odporności na uszkodzenia.

Przykładowa aplikacja korzysta z rozproszonej pamięci podręcznej, gdy aplikacja działa w Development środowisku w pliku Program.cs .

builder.Services.AddDistributedMemoryCache();

Rozproszona pamięć podręczna SQL Server

Implementacja rozproszonej pamięci podręcznej SQL Server (AddDistributedSqlServerCache) umożliwia rozproszonej pamięci podręcznej używanie bazy danych SQL Server jako magazynu zapasowego. Aby utworzyć tabelę elementów buforowanych w wystąpieniu programu SQL Server, możesz użyć narzędzia sql-cache. Narzędzie tworzy tabelę o określonej nazwie i schemacie.

Utwórz tabelę w programie SQL Server, uruchamiając sql-cache create polecenie . Podaj wystąpienie programu SQL Server (), bazę danych (Data SourceInitial Catalog), schemat (na przykład dbo), i nazwę tabeli (na przykład TestCache):

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

Po pomyślnym zakończeniu działania narzędzia zostanie zarejestrowany komunikat:

Table and index were created successfully.

Tabela utworzona przez narzędzie sql-cache ma następujący schemat:

Zrzut ekranu przedstawiający schemat tabeli pamięci podręcznej SQL Server utworzonej za pomocą polecenia

Note

Aplikacja powinna manipulować wartościami pamięci podręcznej przy użyciu wystąpienia klasy IDistributedCache, a nie wystąpienia klasy SqlServerCache.

Przykładowa aplikacja implementuje klasę SqlServerCache w środowisku nondevelopment (Development) w pliku Program.cs :

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

Note

Właściwości takie jak ConnectionString (i opcjonalnie SchemaName i TableName) są zwykle przechowywane poza kontrolą źródła. Na przykład Menedżer Tajemnic lub plik appsettings.json lub appsettings.{Środowisko}.json może przechowywać właściwości. Connection string może zawierać poświadczenia, które powinny być przechowywane poza systemami kontroli źródła.

Aby uzyskać więcej informacji, zobacz SQL Database on Azure .

Rozproszona pamięć podręczna Postgres

Azure Database for PostgreSQL może być używana jako bazowy magazyn dla rozproszonej pamięci podręcznej za pośrednictwem interfejsu IDistributedCache. Azure Database for PostgreSQL to w pełni zarządzana usługa Database-as-a-Service (DBaaS) gotowa na sztuczną inteligencję, oparta na silniku PostgreSQL typu open source. Projekt obsługuje obciążenia o krytycznym znaczeniu z przewidywalną wydajnością, niezawodnymi zabezpieczeniami, wysoką dostępnością i bezproblemową skalowalnością.

Po zainstalowaniu pakietu NuGet Microsoft.Extensions.Caching.Postgres skonfiguruj rozproszoną pamięć podręczną w następujący sposób:

  1. Zarejestruj usługę.

    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. Użyj pamięci podręcznej.

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

Rozproszona pamięć podręczna NCache

NCache to rozproszona pamięć podręczna open source działająca w pamięci, opracowana natywnie w środowisku .NET. Usługa NCache działa zarówno lokalnie, jak i skonfigurowana jako rozproszony klaster pamięci podręcznej dla aplikacji ASP.NET Core działającej na platformie Azure lub na innych platformach hostingu.

Aby zainstalować i skonfigurować usługę NCache na komputerze lokalnym, zobacz Przewodnik wprowadzenie.

Aby skonfigurować usługę NCache:

  1. Zainstaluj pakiet NuGet zestawu SDK NCache, który obsługuje oprogramowanie NCache Opensource dla platformy .NET Framework i aplikacji .NET Core.

  2. Skonfiguruj klaster pamięci podręcznej w konfiguracji klienta (plik client.ncconf ).

  3. Dodaj następujący kod do pliku Program.cs :

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

Rozproszona pamięć podręczna Azure Cosmos DB

Azure Cosmos DB można skonfigurować w ASP.NET Core jako dostawca stanu sesji przy użyciu interfejsuIDistributedCache. Usługa Azure Cosmos DB to w pełni zarządzana baza danych NoSQL i relacyjna baza danych na potrzeby nowoczesnego tworzenia aplikacji, która zapewnia wysoką dostępność, skalowalność i małe opóźnienia dostępu do danych dla aplikacji o znaczeniu krytycznym.

Po zainstalowaniu pakietu NuGet Microsoft.Extensions.Caching.Cosmos, skonfiguruj rozproszoną pamięć podręczną w Azure Cosmos DB. Możesz użyć istniejącego klienta Azure Cosmos DB lub utworzyć nowy, zgodnie z opisem w poniższych sekcjach.

Aby uzyskać więcej informacji, zobacz rozszerzenie Microsoft Caching korzystające z Azure Cosmos DB; plik README pakietu NuGet w repozytorium GitHub.

Ponowne używanie istniejącego klienta

Najprostszym sposobem skonfigurowania rozproszonej pamięci podręcznej jest ponowne użycie istniejącego klienta Azure Cosmos DB. W tym przypadku wystąpienie CosmosClient nie jest zwalniane, gdy dostawca jest usuwany.

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

Tworzenie nowego klienta

Alternatywnie, stwórz instancję nowego klienta. W takim przypadku instancja CosmosClient jest zwalniana, gdy dostawca jest zwalniany.

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

Korzystanie z rozproszonej pamięci podręcznej

Aby użyć interfejsu IDistributedCache , zażądaj wystąpienia IDistributedCache w aplikacji. Obiekt jest dostarczany za pomocą iniekcji zależności (DI).

Po uruchomieniu przykładowej aplikacji, wystąpienie IDistributedCache jest wprowadzane do pliku Program.cs. Bieżący czas jest buforowany przy użyciu interfejsu IHostApplicationLifetime . (Aby uzyskać więcej informacji, zobacz .NET Generic Host: 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.GetRequiredService<IDistributedCache>()
                              .Set("cachedTimeUTC", encodedCurrentTimeUTC, options);
});

Przykładowa aplikacja wstrzykuje wystąpienie IDistributedCache do obiektu IndexModel do wykorzystania na stronie Indeks.

Za każdym razem, gdy ładuje się strona indeksu, pamięć podręczna jest sprawdzana pod kątem zbuforowanego czasu przy użyciu metody OnGetAsync. Jeśli czas buforowany nie wygasł, zostanie wyświetlony czas. Jeśli 20 sekund upłynęło od czasu ostatniego uzyskania dostępu do buforowanej godziny (czas ostatniego załadowania tej strony), na stronie zostanie wyświetlony komunikat Czas buforowany wygasł.

Natychmiast zaktualizuj buforowany czas do bieżącej godziny, wybierając opcję Resetuj czas buforowany . Ta akcja wywołuje metodę obsługi 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

Nie musisz używać zakresu istnienia Singleton lub Scoped dla wystąpień IDistributedCache z wbudowaną implementacją.

Możesz również utworzyć instancję IDistributedCache wszędzie tam, gdzie może być potrzebna, zamiast używać DI. Jednak utworzenie wystąpienia w kodzie może utrudnić testowanie kodu i naruszyć zasadę jawnych zależności.

Przegląd zaleceń dotyczących pamięci podręcznej

Podczas podejmowania decyzji, która implementacja interfejsu IDistributedCache jest najlepsza dla twojej aplikacji, należy wziąć pod uwagę następujące kwestie:

  • Istniejąca infrastruktura
  • Wymagania dotyczące wydajności
  • Cost
  • Doświadczenie zespołowe

Rozwiązania buforowania zwykle polegają na magazynie w pamięci, aby zapewnić szybkie pobieranie buforowanych danych, ale pamięć jest ograniczonym zasobem i kosztowna do rozszerzenia. Przechowuj tylko często używane dane w pamięci podręcznej.

W przypadku większości aplikacji pamięć podręczna Redis cache zapewnia większą przepływność i mniejsze opóźnienie niż pamięć podręczna programu SQL Server. Zaleca się jednak przeprowadzenie testów porównawczych w celu określenia cech wydajności strategii buforowania.

Jeśli SQL Server jest magazynem kopii zapasowych rozproszonej pamięci podręcznej, a pamięć podręczna i magazyn danych aplikacji/pobieranie używają tej samej bazy danych, wydajność można zmniejszyć. Zalecaną metodą jest użycie dedykowanego wystąpienia SQL Server dla magazynu kopii zapasowych rozproszonej pamięci podręcznej.