Verteiltes Zwischenspeichern in ASP.NET Core

Von Mohsin Nasir und smandia

Note

Dies ist nicht die neueste Version dieses Artikels. Die aktuelle Version finden Sie in der .NET 11-Version dieses Artikels.

Ein verteilter Cache ist ein Von mehreren App-Servern gemeinsam genutzter Cache. Der Cache wird in der Regel als externer Dienst für die App-Server verwaltet, die darauf zugreifen. Ein verteilter Cache kann die Leistung und Skalierbarkeit einer ASP.NET Core-App verbessern, insbesondere, wenn ein Clouddienst oder eine Serverfarm die App hosten.

Ein verteilter Cache hat mehrere Vorteile gegenüber anderen Zwischenspeicherungsszenarien, in denen zwischengespeicherte Daten auf einzelnen App-Servern gespeichert werden.

Wenn zwischengespeicherte Daten verteilt werden, gilt für sie Folgendes:

  • Sie sind kohärent (konsistent) für Anforderungen an mehrere Server.
  • Sie überleben Serverneustarts und App-Bereitstellungen.
  • Es verwendet keinen lokalen Arbeitsspeicher.

Die Konfiguration des verteilten Cache ist implementierungsspezifisch. In diesem Artikel wird beschrieben, wie Sie verteilte SQL Server-, Redis- oder Postgres-Caches konfigurieren. Nicht Microsoft Implementierungen sind auch verfügbar, z. B. NCache (NCache für GitHub), Azure Cosmos DB und Postgres. Unabhängig davon, welche Implementierung ausgewählt ist, interagiert die App mithilfe der IDistributedCache Schnittstelle mit dem Cache.

Anzeigen oder Herunterladen von Beispielcode (Vorgehensweise zum Herunterladen)

Warning

In diesem Artikel wird eine lokale Datenbank verwendet, für die keine Authentifizierung des Benutzers erforderlich ist. Produktions-Apps sollten den sichersten verfügbaren Ablauf für die Authentifizierung verwenden. Weitere Informationen zur Authentifizierung für bereitgestellte Test- und Produktions-Apps finden Sie unter Sichere Authentifizierungsflows.

Prerequisites

Fügen Sie einen Paketverweis für den verwendeten verteilten Cacheanbieter hinzu:

Verwenden der IDistributedCache-Schnittstelle

Die IDistributedCache-Schnittstelle bietet die folgenden Methoden zum Bearbeiten von Elementen bei der Implementierung des verteilten Cache:

  • Get, : GetAsyncAkzeptiert einen Zeichenfolgenschlüssel und ruft ein zwischengespeichertes Element als byte[] Array ab, wenn es im Cache gefunden wird.
  • Set, SetAsync: Fügt dem Cache mithilfe eines Zeichenfolgenschlüssels ein Element (als byte[] Array) hinzu.
  • Refresh, RefreshAsync: Aktualisiert ein Element im Cache anhand seines Schlüssels und setzt dabei das Zeitlimit für den gleitenden Ablauf zurück (falls vorhanden).
  • Remove, RemoveAsync: Entfernt ein Cacheelement basierend auf seinem Zeichenfolgenschlüssel.

Andere Objekte als Byte-Arrays speichern

IDistributedCache speichert Werte als byte[] Arrays. Um andere Typen zwischenzuspeichern, serialisieren Sie sie zuerst. Die folgenden Erweiterungsmethoden verwenden System.Text.Json , um jeden serialisierbaren Typ als UTF-8 JSON zu speichern:

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> gibt den Standardwert des Typs zurück, z. B. null, wenn sich der Schlüssel nicht im Cache befindet.

Tipp

Die HybridCache-Bibliothek serialisiert Werte für Sie und ergänzt den verteilten Cache um einen primären In-Process-Cache sowie einen Schutz vor Cache-Stampedes.

Einrichten verteilter Zwischenspeicherdienste

Registrieren Sie eine Implementierung IDistributedCache in der datei Program.cs . Die folgenden framework-bereitgestellten Implementierungen werden in diesem Artikel beschrieben:

Verteilter Redis-Cache

Der verteilte Redis-Cache bietet die beste Leistung und wird für Produktions-Apps empfohlen. Redis ist ein Open Source In-Memory-Datenspeicher, der häufig als verteilter Cache verwendet wird. Sie können eine Azure Cache for Redis-Instanz für eine von Azure gehostete ASP.NET Core-App konfigurieren und eine Azure Cache for Redis-Instanz für die lokale Entwicklung verwenden. Weitere Informationen finden Sie unter "Überprüfen von Cacheempfehlungen".

Eine App konfiguriert die Cacheimplementierung mit einer RedisCache Instanz durch Aufrufen der AddStackExchangeRedisCache Methode. Verwenden Sie für Ausgabecaching die AddStackExchangeRedisOutputCache Methode.

  1. Erstellen Sie eine Instanz von Azure Cache for Redis.

  2. Kopieren Sie die primäre Verbindungszeichenfolge (StackExchange.Redis) in Configuration.

    • Für die lokale Entwicklung: Speichern Sie die Verbindungszeichenfolge mit dem Geheimnis-Manager.

    • Für Azure: Speichern Sie Verbindungszeichenfolge in einem sicheren Speicher wie Azure Key Vault.

Der folgende Code aktiviert Azure Cache for Redis:

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

Der vorangehende Code geht davon aus, dass die primäre Verbindungszeichenfolge (StackExchange.Redis) in der Konfiguration mit dem Schlüsselnamen MyRedisConStr gespeichert ist.

Weitere Informationen finden Sie unter Azure Managed Redis.

Eine Diskussion zu alternativen Ansätzen für einen lokalen Redis-Cache finden Sie unter GitHub /dotnet/aspnetcore Issue #19542.

Verteilter Speichercache

Der verteilte Speichercache (AddDistributedMemoryCache) ist eine vom Framework bereitgestellte Implementierung, die IDistributedCache Elemente im Arbeitsspeicher speichert. Der verteilte Speichercache ist jedoch kein tatsächlich verteilter Cache. Die App-Instanz speichert die zwischengespeicherten Elemente auf dem Server, auf dem die App ausgeführt wird.

Der verteilte Speichercache ist eine nützliche Implementierung für Entwicklungs- und Testszenarien. Es ist auch nützlich für einen einzelnen Server in einem Produktionsszenario, bei dem die Arbeitsspeichernutzung kein Problem ist. Durch implementieren des verteilten Speichercaches werden zwischengespeicherte Datenspeicher abstrahiert. Dies ermöglicht die Implementierung einer echten verteilten Zwischenspeicherungslösung in der Zukunft, wenn mehrere Knoten oder Fehlertoleranz erforderlich werden.

Die Beispiel-App verwendet den verteilten Speichercache, wenn die App in der Umgebung in der Developmentdatei Program.cs ausgeführt wird.

builder.Services.AddDistributedMemoryCache();

Verteilter SQL Server-Cache

Die Implementierung des verteilten SQL Server Caches (AddDistributedSqlServerCache) ermöglicht dem verteilten Cache die Verwendung einer SQL Server Datenbank als Sicherungsspeicher. Um eine zwischengespeicherte SQL Server.Elementtabelle in einer SQL Server-Instanz zu erstellen, können Sie das Tool sql-cache verwenden. Das Tool erstellt eine Tabelle mit dem von Ihnen angegebenen Namen und Schema.

Erstellen Sie eine Tabelle in SQL Server, indem Sie den Befehl sql-cache create ausführen. Geben Sie die SQL Server-Instanz (Data Source), die Datenbank (Initial Catalog), das Schema (z. B. dbo) und den Tabellennamen (z. B. TestCache) an:

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

Wenn das Tool erfolgreich ist, wird eine Nachricht protokolliert:

Table and index were created successfully.

Die vom sql-cache-Tool erstellte Tabelle weist das folgende Schema auf:

Screenshot des Schemas einer SQL Server Cachetabelle, die mit dem Befehl

Alternativ können Sie die Tabelle und den Index direkt mithilfe von T-SQL erstellen, z. B. über SQL Server Management Studio- oder Datenbankmigrationsskripts:

CREATE TABLE [dbo].[TestCache](
    [Id] nvarchar(449) COLLATE SQL_Latin1_General_CP1_CS_AS NOT NULL,
    [Value] varbinary(max) NOT NULL,
    [ExpiresAtTime] datetimeoffset NOT NULL,
    [SlidingExpirationInSeconds] bigint NULL,
    [AbsoluteExpiration] datetimeoffset NULL,
    PRIMARY KEY (Id)
);

CREATE NONCLUSTERED INDEX Index_ExpiresAtTime ON [dbo].[TestCache](ExpiresAtTime);

Note

Idist mit einer maximalen Länge von 449 Zeichen konfiguriert, um sicherzustellen, dass der Primärschlüssel innerhalb des Indexlimits von 900 Byte SQL Server verbleibt und die SQL_Latin1_General_CP1_CS_AS Sortierung verwendet, um zwischen Groß- und Kleinschreibung unterschiedene Cacheschlüssel beizubehalten. Der Index_ExpiresAtTime nicht gruppierte Index ermöglicht das effiziente Löschen abgelaufener Cacheeinträge.

Note

Eine App sollte Cachewerte mittels einer Instanz von IDistributedCache manipulieren, nicht mit einer Instanz von SqlServerCache.

Die Beispiel-App implementiert die SqlServerCache Klasse in einer Nichtentwicklungsumgebung (Development) in der datei Program.cs :

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

Note

Eigenschaften wie ConnectionString (und optional SchemaNameTableName) werden normalerweise außerhalb der Quellcodeverwaltung gespeichert. Beispielsweise der geheime Manager oder die appsettings.json oder appsettings.{ Environment}.json Datei speichert möglicherweise die Eigenschaften. Die Verbindungszeichenfolge kann Anmeldeinformationen enthalten, die aus Quellcodeverwaltungssystemen herausgehalten werden sollen.

Weitere Informationen finden Sie unter SQL-Datenbank auf Azure.

Verteilter Postgres-Cache

Azure Database for PostgreSQL kann über die IDistributedCache Schnittstelle als Backingspeicher für einen verteilten Cache verwendet werden. Azure Database for PostgreSQL ist ein vollständig verwaltetes, AI-ready Database-as-a-Service (DBaaS)-Angebot, das auf dem Open-Source-PostgreSQL-Modul basiert. Das Design unterstützt unternehmenskritische Workloads mit vorhersehbarer Leistung, robuster Sicherheit, hoher Verfügbarkeit und nahtloser Skalierbarkeit.

Konfigurieren Sie nach der Installation des Pakets "Microsoft.Extensions.Caching.Postgres NuGet" den verteilten Cache wie folgt:

  1. Registrieren Sie den Dienst.

    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. Verwenden Sie den Cache.

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

Verteilter NCache-Cache

NCache ist ein Open Source In-Memory-Distributed-Cache, der nativ in .NET entwickelt wurde. NCache funktioniert sowohl lokal als auch als verteilter Cachecluster für eine ASP.NET Core-App, die in Azure oder auf anderen Hostingplattformen ausgeführt wird.

Informationen zum Installieren und Konfigurieren von NCache auf Ihrem lokalen Computer finden Sie im Handbuch für erste Schritte.

So konfigurieren Sie NCache:

  1. Installieren Sie das NCache SDK NuGet-Paket, das NCache Opensource für .NET Framework und .NET Core-Apps unterstützt.

  2. Konfigurieren Sie den Cachecluster in der Clientkonfiguration (die Datei "client.ncconf ").

  3. Fügen Sie der datei Program.cs den folgenden Code hinzu:

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

Verteilter Azure Cosmos DB-Cache

Azure Cosmos DB können mithilfe der IDistributedCache Schnittstelle in ASP.NET Core als Sitzungszustandsanbieter konfiguriert werden. Azure Cosmos DB ist eine vollständig verwaltete NoSQL- und relationale Datenbank für die moderne Anwendungsentwicklung, die hohe Verfügbarkeit, Skalierbarkeit und Zugriff auf Daten mit geringer Latenz für unternehmenskritische Anwendungen bietet.

Nach der Installation des Microsoft. Extensions.Caching.Cosmos NuGet-Paket konfigurieren einen Azure Cosmos DB verteilten Cache. Sie können einen vorhandenen Azure Cosmos DB-Client verwenden oder einen neuen erstellen, wie in den folgenden Abschnitten beschrieben.

Weitere Informationen finden Sie in der Microsoft Caching-Erweiterung mit Azure Cosmos DB, der GitHub Repository-README-Datei für das NuGet-Paket.

Wiederverwenden eines vorhandenen Clients

Die einfachste Möglichkeit zum Konfigurieren eines verteilten Caches besteht darin, einen vorhandenen Azure Cosmos DB-Client erneut zu verwenden. In diesem Fall wird die CosmosClient-Instanz nicht entsorgt, wenn der Anbieter entsorgt wird.

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

Erstellen eines neuen Clients

Alternativ können Sie einen neuen Client instanziieren. In diesem Fall wird die CosmosClient Instanz freigegeben, wenn der Anbieter freigegeben wird.

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

Verwenden des verteilten Cache

Um die IDistributedCache-Schnittstelle zu verwenden, fordern Sie eine Instanz von IDistributedCache in der App an. Die Instanz wird durch Abhängigkeitsinjektion (DI) bereitgestellt.

Wenn die Beispiel-App gestartet wird, wird die IDistributedCache Instanz in die datei Program.cs eingefügt. Die aktuelle Zeit wird mithilfe der IHostApplicationLifetime Schnittstelle zwischengespeichert. (Weitere Informationen finden Sie unter .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);
});

Die Beispiel-App fügt die IDistributedCache Instanz in das IndexModel Objekt ein, das von der Indexseite verwendet werden soll.

Jedes Mal, wenn die Indexseite geladen wird, wird der Cache mithilfe der OnGetAsync Methode auf die zwischengespeicherte Zeit überprüft. Wenn die zwischengespeicherte Zeit nicht abgelaufen ist, wird die Uhrzeit angezeigt. Wenn 20 Sekunden seit dem letzten Zugriff auf die zwischengespeicherte Zeit verstrichen sind (das letzte Mal, wenn diese Seite geladen wurde), zeigt die Seite die Meldung " Zwischengespeicherte Zeit abgelaufen" an.

Aktualisieren Sie die zwischengespeicherte Zeit sofort auf die aktuelle Uhrzeit, indem Sie die Option " Zwischengespeicherte Zeit zurücksetzen " auswählen. Diese Aktion löst die OnPostResetCachedTime Handlermethode aus.

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

Für IDistributedCache-Instanzen mit einer integrierten Implementierung brauchen Sie keine Singleton oder Scoped Lebensdauer zu verwenden.

Sie können auch eine IDistributedCache Instanz erstellen, wo immer Sie eine benötigen, anstatt DI zu verwenden. Das Erstellen einer Instanz im Code kann ihren Code jedoch schwieriger testen und gegen das Explizite Abhängigkeitsprinzip verstoßen.

Überprüfen von Cacheempfehlungen

Berücksichtigen Sie bei der Entscheidung, welche Implementierung der IDistributedCache Schnittstelle für Ihre App am besten geeignet ist:

  • Vorhandene Infrastruktur
  • Leistungsanforderungen
  • Cost
  • Teamerfahrung

Zwischenspeicherlösungen basieren in der Regel auf In-Memory-Speicher, um einen schnellen Abruf von zwischengespeicherten Daten zu ermöglichen. Der Arbeitsspeicher ist jedoch nur eine begrenzte Ressource und seine Erweiterung kostspielig. Speichern Sie nur häufig verwendete Daten in einem Cache.

Für die meisten Apps bietet ein Redis-Cache einen höheren Durchsatz und eine geringere Latenz als ein SQL Server-Cache. Es wird jedoch ein Benchmarking empfohlen, um die Leistungsmerkmale von Zwischenspeicherungsstrategien zu bestimmen.

Wenn SQL Server der verteilte Cachesicherungsspeicher ist und der Cache- und App-Datenspeicher/-abruf dieselbe Datenbank verwendet, kann die Leistung reduziert werden. Der empfohlene Ansatz besteht darin, eine dedizierte SQL Server Instanz für den verteilten Cachesicherungsspeicher zu verwenden.