Buforowanie rozproszone w ASP.NET Core

Przez Mohsin Nasir i smandia

Rozproszona pamięć podręczna to pamięć podręczna współużytkowana przez wiele serwerów aplikacji, 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 aplikacja jest hostowana przez usługę w chmurze lub farmę serwerów.

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 (spójna ) między żądaniami na wielu serwerach.
• Przetrwa ponowne uruchomienie 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 innych firm, takie jak NCache (NCache w usłudze GitHub), Cosmos DB i Postgres. Niezależnie od wybranej implementacji aplikacja współdziała z pamięcią podręczną przy użyciu interfejsu IDistributedCache .

Wyświetl lub pobierz przykładowy kod (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:

• W przypadku rozproszonej pamięci podręcznej Redis Microsoft.Extensions.Caching.StackExchangeRedis.
• W przypadku programu SQL Server Microsoft.Extensions.Caching.SqlServer.
• W przypadku bazy danych Postgres, Microsoft.Extensions.Caching.Postgres.
• W przypadku usługi Cosmos DB Microsoft.Extensions.Caching.Cosmos.
• W przypadku rozproszonej pamięci podręcznej NCache NCache.Microsoft.Extensions.Caching.OpenSource.

Interfejs 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 byte[] tablicę) do pamięci podręcznej przy użyciu klucza ciągu.
• 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 ciągu.

Ustanawianie rozproszonych usług buforowania

Zarejestruj implementację elementu IDistributedCache w pliku Program.cs. Implementacje dostarczane przez platformę opisane w tym temacie obejmują:

• Rozproszona pamięć podręczna Redis
• Rozproszona pamięć podręczna pamięci
• Rozproszona pamięć podręczna programu SQL Server
• Rozproszona pamięć podręczna Postgres
• Rozproszona pamięć podręczna NCache
• Rozproszona pamięć podręczna usługi Azure Cosmos DB

Rozproszona pamięć podręczna Redis Cache

Zalecamy używanie rozproszonej pamięci podręcznej Redis Cache w środowisku produkcyjnym, ponieważ jest to najbardziej wydajne. Aby uzyskać więcej informacji, zobacz Zalecenia.

Redis to magazyn danych typu open source w pamięci, 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.

Aplikacja konfiguruje implementację pamięci podręcznej przy użyciu wystąpienia, wywołując metodę RedisCacheAddStackExchangeRedisCache. W przypadku buforowania danych wyjściowych użyj polecenia AddStackExchangeRedisOutputCache.

1. Tworzenie usługi Azure Cache for Redis.
2. Skopiuj parametry połączenia podstawową (StackExchange.Redis) do konfiguracji.
   • Programowanie lokalne: zapisz parametry połączenia za pomocą programu Secret Manager.
   • Azure: zapisywanie parametry połączenia w bezpiecznym magazynie, takim jak usługa 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 parametry połączenia primary (StackExchange.Redis) został zapisany w konfiguracji z nazwą MyRedisConStrklucza .

Aby uzyskać więcej informacji, zobacz Pamięć podręczna Azure Cache for Redis.

Zobacz ten problem z usługą GitHub, aby zapoznać się z omówieniem alternatywnych podejść do lokalnej pamięci podręcznej Redis Cache.

Rozproszona pamięć podręczna pamięci

Rozproszona pamięć podręczna (AddDistributedMemoryCache) to implementacja IDistributedCache zapewniana przez platformę, która przechowuje elementy w pamięci. Rozproszona pamięć podręczna nie jest rzeczywistą rozproszoną pamięcią podręczną. Buforowane elementy są przechowywane przez wystąpienie aplikacji na serwerze, na którym działa aplikacja.

Rozproszona pamięć podręczna to przydatna implementacja:

• W scenariuszach tworzenia i testowania.
• Jeśli pojedynczy serwer jest używany w środowisku produkcyjnym, a zużycie pamięci nie jest problemem. Implementowanie rozproszonej pamięci podręcznej abstrakcji buforowanego magazynu danych. 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 jest uruchamiana w środowisku programistycznym w Program.csprogramie :

builder.Services.AddDistributedMemoryCache();

Rozproszona pamięć podręczna programu SQL Server

Implementacja rozproszonej pamięci podręcznej programu SQL Server (AddDistributedSqlServerCache) umożliwia rozproszonej pamięci podręcznej używanie bazy danych programu SQL Server jako magazynu zapasowego. Aby utworzyć tabelę elementów buforowanych programu SQL Server w wystąpieniu programu SQL Server, możesz użyć sql-cache tego narzędzia. 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

Komunikat jest rejestrowany, aby wskazać, że narzędzie zakończyło się pomyślnie:

Table and index were created successfully.

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

Note

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

Przykładowa aplikacja implementuje SqlServerCache w środowisku nieprogramowania w programie Program.cs:

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

Note

Element ConnectionString (i opcjonalnie SchemaNameTableNamei ) są zwykle przechowywane poza kontrolą źródła (na przykład przechowywane przez menedżera wpisów tajnych lub w appsettings.json/appsettings.{Environment}.json plikach). Parametry połączenia może zawierać poświadczenia, które powinny być przechowywane poza systemami kontroli źródła.

Rozproszona pamięć podręczna PostgreSQL

Usługa Azure Database for PostgreSQL może służyć jako magazyn kopii zapasowych rozproszonej pamięci podręcznej za pośrednictwem interfejsu IDistributedCache . Usługa Azure Database for PostgreSQL to w pełni zarządzana, gotowa do użycia sztuczna inteligencja oferta database-as-a-Service (DBaaS) oparta na akompilowaniu typu open source PostgreSQL, która jest przeznaczona do obsługi obciążeń o znaczeniu krytycznym 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. Rejestrowanie usługi

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. Korzystanie z 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 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 typu open source opracowana natywnie na platformie .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 Wprowadzenie — przewodnik po systemie Windows i Linux.

Aby skonfigurować usługę NCache:

1. Zainstaluj pakiet NuGet typu open source NCache.
2. Skonfiguruj klaster pamięci podręcznej w pliku 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 bazy danych Azure Cosmos DB

Usługi Azure Cosmos DB można używać w usłudze ASP.NET Core jako dostawcy stanu sesji przy użyciu interfejsu IDistributedCache . 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ą usługi Azure Cosmos DB w następujący sposób:

Ponowne używanie istniejącego klienta

Najprostszym sposobem skonfigurowania rozproszonej pamięci podręcznej jest ponowne użycie istniejącego klienta usługi Azure Cosmos DB. W takim przypadku CosmosClient wystąpienie nie zostanie usunięte po usunięciu dostawcy.

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

Tworzenie nowego klienta

Alternatywnie utwórz wystąpienie nowego klienta. W takim przypadku CosmosClient wystąpienie zostanie usunięte po usunięciu dostawcy.

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. Wystąpienie jest udostępniane przez iniekcję zależności (DI).

Po uruchomieniu IDistributedCache przykładowej aplikacji zostanie wstrzyknięta do Program.cselementu . Bieżący czas jest buforowany przy użyciu IHostApplicationLifetime (aby uzyskać więcej informacji, zobacz Ogólny 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.GetService<IDistributedCache>()
                              .Set("cachedTimeUTC", encodedCurrentTimeUTC, options);
});

Przykładowa aplikacja wprowadza dane IDistributedCache do elementu do IndexModel użycia przez stronę Indeks.

Za każdym razem, gdy strona Indeks jest ładowana, pamięć podręczna jest sprawdzana pod kątem buforowanego czasu w pliku 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 pamięci podręcznej (czas ostatniego załadowania tej strony), na stronie zostanie wyświetlony czas wygaśnięcia pamięci podręcznej.

Natychmiast zaktualizuj buforowany czas do bieżącej godziny, wybierając przycisk Resetuj czas buforowany . Przycisk wyzwala metodę OnPostResetCachedTime obsługi.

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

używać okresu istnienia pojedynczego lub zakresu.

Możesz również utworzyć IDistributedCache wystąpienie, w którym może być potrzebne jedno, zamiast użyć di, ale utworzenie wystąpienia w kodzie może utrudnić testowanie kodu i naruszyć zasadę jawnych zależności.

Recommendations

Podczas podejmowania decyzji o najlepszej implementacji IDistributedCache 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.

Gdy program SQL Server jest używany jako magazyn kopii zapasowych rozproszonej pamięci podręcznej, użycie tej samej bazy danych dla pamięci podręcznej i zwykłego magazynu danych i pobierania aplikacji może negatywnie wpłynąć na wydajność obu tych elementów. Zalecamy użycie dedykowanego wystąpienia programu SQL Server dla magazynu kopii zapasowych rozproszonej pamięci podręcznej.

Dodatkowe zasoby

• Pamięć podręczna Redis Cache na platformie Azure
• Usługa SQL Database na platformie Azure
• Azure Database for PostgreSQL
• dostawca usługi ASP.NET Core IDistributedCache dla usługi NCache w farmach sieci Web (NCache w usłudze GitHub)
• Plik README repozytorium microsoft.Extensions.Caching.Cosmos
• Buforowanie w pamięci w ASP.NET Core
• Wykrywanie zmian za pomocą tokenów zmian w programie ASP.NET Core
• Buforowanie odpowiedzi na platformie ASP.NET Core
• Oprogramowanie pośredniczące buforowania odpowiedzi w programie ASP.NET Core
• Pomocnik tagów pamięci podręcznej w ASP.NET Core MVC
• Pomocnik tagów rozproszonej pamięci podręcznej w ASP.NET Core
• Hostowanie aplikacji ASP.NET Core na farmie internetowej