Freigeben über

® .NET AspireRedis* Integration der Ausgabezwischenspeicherung

  • Artikel

umfasst:Hostingintegration und Client Integration

Erfahren Sie, wie Sie die Ausgabezwischenspeicherung-Integration von .NET AspireRedis verwenden. Die Aspire.StackExchange.Redis.OutputCachingclient-Integration wird verwendet, um einen ASP.NET Core Output-Caching-Anbieter zu registrieren, der von einem Redisserver mit dem docker.io/library/redis-Containerimageunterstützt wird.

Erfahren Sie, wie Sie die Integration der Ausgabezwischenspeicherung mit .NET AspireRedis verwenden. Die Aspire.StackExchange.Redis.OutputCachingclient-Integration wird verwendet, um einen ASP.NET Core Ausgabezwischenspeicherung Anbieter zu registrieren, der von einem Garnet-server mit dem ghcr.io/microsoft/garnet Containerimageunterstützt wird.

Erfahren Sie, wie Sie die Integration der .NET AspireRedis Ausgabezwischenspeicherung verwenden. Die Aspire.StackExchange.Redis.OutputCachingclient-Integration wird verwendet, um einen ASP.NET Core Ausgabezwischenspeicherung sanbieter zu registrieren, der von einem Valkey-server mit dem docker.io/valkey/valkey Containerimageunterstützt wird.

Hosting-Integration

Die Redis Hostintegration modelliert eine Redis Ressource als RedisResource Typ. Um auf diesen Typ und die APIs zuzugreifen, die es Ihnen ermöglichen, ihn zu Ihrem 📦Aspire.Hosting.Redis NuGet-Paket im App-Host Projekt hinzuzufügen.

dotnet add package Aspire.Hosting.Redis

Weitere Informationen finden Sie unter dotnet add package oder Paketabhängigkeiten in .NET Anwendungen verwalten.

Die Ressource Redis hinzufügen

Rufen Sie AddRedis auf der builder-Instanz in Ihrem App-Hostprojekt auf, um eine Redis-Ressource hinzuzufügen.

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache");

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Wenn .NET.NET Aspire dem App-Host ein Containerimage hinzufügt, wie im vorherigen Beispiel mit dem docker.io/Redis/Redis-Image gezeigt, wird eine neue Redis Instanz auf dem lokalen Computer erstellt. Zum ExampleProjectwird ein Verweis auf die Redis Ressource (die Variable cache) hinzugefügt.

Die WithReference-Methode konfiguriert eine Verbindung im ExampleProject namens "cache". Weitere Informationen finden Sie unter Lebenszyklus der Containerressource.

Tipp

Wenn Sie lieber eine Verbindung mit einer vorhandenen Redis Instanz herstellen möchten, rufen Sie stattdessen AddConnectionString auf. Weitere Informationen finden Sie unter Referenzieren vorhandener Ressourcen.

Fügen Sie Redis Ressource mit Redis Insights hinzu

Rufen Sie die WithRedisInsight-Methode auf, um die Redis Insights zur Ressource Redis hinzuzufügen.

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache")
                   .WithRedisInsight();

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Redis Insights ist eine kostenlose grafische Oberfläche zur Analyse von Redis-Daten auf allen Betriebssystemen und in allen Redis-Bereitstellungen mithilfe unseres KI-Assistenten, Redis Copilot. .NET .NET Aspire fügt dem App-Host, der die Commander-App ausführt, ein weiteres Containerimage docker.io/redis/redisinsight hinzu.

Anmerkung

Um den Hostport für die RedisInsightResource-Kette zu konfigurieren, führen Sie einen Aufruf an die WithHostPort-API durch und geben Sie die gewünschte Portnummer an.

Füge Ressource Redis mit Commander Redis hinzu

Rufen Sie zum Hinzufügen des Redis Commander zur ressource Redis die WithRedisCommander-Methode auf:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache")
                   .WithRedisCommander();

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Redis Commander ist eine Node.js Webanwendung, die zum Anzeigen, Bearbeiten und Verwalten einer Redis Datenbank verwendet wird. .NET .NET Aspire fügt dem Anwendungs-Host, der die Commander-App ausführt, ein weiteres Container-Image docker.io/rediscommander/redis-commander hinzu.

Trinkgeld

Um den Hostport für die RedisCommanderResource-Verkettung zu konfigurieren, führen Sie einen Aufruf der WithHostPort-API durch und stellen Sie die gewünschte Portnummer bereit.

Fügen Sie die Redis-Ressource mit Datenvolumen hinzu

Rufen Sie die WithDataVolume-Methode für die Redis-Ressource auf, um der Redis-Ressource ein Datenvolume hinzuzufügen:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache")
                   .WithDataVolume(isReadOnly: false);

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Das Datenvolume wird verwendet, um die Redis Daten außerhalb des Lebenszyklus des Containers zu speichern. Das Datenvolumen wird im Container Redis an dem Pfad /data bereitgestellt, und wenn kein name-Parameter angegeben wird, wird der Name zufällig generiert. Weitere Informationen zu Datenträgern und Details, warum sie gegenüber Bind-Mountsbevorzugt werden, finden Sie in der Docker-Dokumentation: Volumes.

Hinzufügen Redis Ressource mit Datenbindungs-Bereitstellung

Rufen Sie die WithDataBindMount-Methode auf, um der Redis-Ressource eine Datenbindung hinzuzufügen:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache")
                   .WithDataBindMount(
                       source: @"C:\Redis\Data",
                       isReadOnly: false);

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Wichtig

Daten Bind-Mounts verfügen über eingeschränkte Funktionalität im Vergleich zu Volumes, die bessere Leistung, Portabilität und Sicherheit bieten und daher besser für Produktionsumgebungen geeignet sind. Bind-Mounts ermöglichen jedoch direkten Zugriff und Änderung von Dateien auf dem Hostsystem, ideal für Entwicklung und Tests, bei denen Echtzeitänderungen vorgenommen werden müssen.

Datenbindungs-Bereitstellungen basieren auf dem Dateisystem des Hostcomputers, um die Redis Daten über Containerneustarts hinweg beizubehalten. Die Daten-Bind-Mount wird auf dem C:\Redis\Data-Pfad unter Windows (oder /Redis/Data auf Unix) auf dem Hostrechner im Container Redis bereitgestellt. Weitere Informationen zu Bind-Mounts finden Sie unter Docker Docs: Bind-Mounts.

Hinzufügen der Redis-Ressource mit Persistenz

Rufen Sie zum Hinzufügen der Persistenz zur Ressource Redis die Methode WithPersistence entweder mit dem Datenvolume oder dem Datenbind-Mount auf.

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddRedis("cache")
                   .WithDataVolume()
                   .WithPersistence(
                       interval: TimeSpan.FromMinutes(5),
                       keysChangedThreshold: 100);

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Der vorhergehende Code fügt der Ressource Redis Persistenz hinzu, indem Momentaufnahmen der Daten von Redis in einem angegebenen Intervall und bei einem bestimmten Schwellenwert erstellt werden. Der interval ist die Zeit zwischen Momentaufnahme-Exporten und keysChangedThreshold ist die Anzahl der Schlüsseländerungsvorgänge, die zum Auslösen einer Momentaufnahme erforderlich sind. Weitere Informationen zur Persistenz finden Sie unter Redis Docs: Persistenz.

Die Garnet-Hostingintegration modelliert eine Garnet-Ressource als GarnetResource-Typ. Um auf diesen Typ und diese APIs zuzugreifen, mit denen Sie sie Ihrem 📦Aspire.Hosting.Garnet NuGet-Paket im App-Host Projekt hinzufügen können.

dotnet add package Aspire.Hosting.Garnet

Weitere Informationen finden Sie unter dotnet add package oder Verwalten von Paketabhängigkeiten in .NET Anwendungen.

Garnet-Ressource hinzufügen

Rufen Sie in Ihrem App-Hostprojekt AddGarnet in der builder Instanz auf, um eine Garnet-Ressource hinzuzufügen:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddGarnet("cache");

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Wenn .NET.NET Aspire dem App-Host ein Containerimage hinzufügt, wie anhand des vorherigen Beispiels mit dem ghcr.io/microsoft/garnet-Image gezeigt, wird eine neue Garnet-Instanz auf dem lokalen Computer erstellt. Dem ExampleProjectwird ein Verweis auf Ihre Garnet-Ressource hinzugefügt (die cache-Variable).

Die WithReference-Methode konfiguriert eine Verbindung im ExampleProject namens "cache". Weitere Informationen finden Sie unter Container-Ressourcenlebenszyklus.

Tipp

Wenn Sie lieber eine Verbindung mit einer vorhandenen Garnet-Instanz herstellen möchten, rufen Sie stattdessen AddConnectionString auf. Weitere Informationen finden Sie unter Referenzieren vorhandener Ressourcen.

Hinzufügen einer Garnet-Ressource mit Datenvolume

Um der Garnet-Ressource ein Datenvolume hinzuzufügen, rufen Sie die AddGarnet-Methode für die Garnet-Ressource auf:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddGarnet("cache")
                   .WithDataVolume(isReadOnly: false);

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Das Datenvolume wird verwendet, um die Garnet-Daten außerhalb des Lebenszyklus des Containers zu speichern. Das Datenvolumen wird am Pfad /data im Garnet-Container bereitgestellt und wenn kein name-Parameter angegeben wird, wird der Name zufällig generiert. Weitere Informationen zu Volumes und Details, warum sie gegenüber Bind-Mountsbevorzugt werden, finden Sie in der Docker-Dokumentation: 'Volumes'.

Hinzufügen einer Garnet-Ressource mit Datenbindungs-Bereitstellung

Rufen Sie zum Hinzufügen einer Datenbindungs-Bereitstellung zur Garnet-Ressource die WithDataBindMount-Methode auf:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddGarnet("cache")
                   .WithDataBindMount(
                       source: @"C:\Garnet\Data",
                       isReadOnly: false);

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Wichtig

Daten Binden von Bereitstellungen mit eingeschränkter Funktionalität im Vergleich zu Volumes, die eine bessere Leistung, Portabilität und Sicherheit bieten, wodurch sie für Produktionsumgebungen besser geeignet sind. Jedoch erlauben Bind-Mounts direkten Zugriff und die Änderung von Dateien auf dem Hostsystem, was ideal für Entwicklung und Tests ist, bei denen Echtzeitänderungen benötigt werden.

Datenbindungs-Bereitstellungen basieren auf dem Dateisystem des Hostcomputers, um die Garnet-Daten über Containerneustarts hinweg zu speichern. Die Datenbindemontage wird im Garnet-Container auf dem Hostcomputer auf dem Pfad C:\Garnet\Data unter Windows (oder /Garnet/Data auf Unix) eingehängt. Weitere Informationen zu Bind-Mounts der Daten finden Sie in der Docker Dokumentation: Bind-Mounts.

Hinzufügen einer Garnetressource mit Persistenz

Um der Garnet-Ressource Persistenz hinzuzufügen, rufen Sie die WithPersistence-Methode entweder mit dem Datenvolume oder dem Datenbindungs-Mount auf:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddGarnet("cache")
                   .WithDataVolume()
                   .WithPersistence(
                       interval: TimeSpan.FromMinutes(5),
                       keysChangedThreshold: 100);

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Der vorangegangene Code fügt der Redis Ressource Persistenz hinzu, indem Momentaufnahmen der Garnet-Daten in einem angegebenen Intervall und bei einem Schwellenwert erstellt werden. Die interval ist die Zeit zwischen den Schnappschuss-Exporten, und die keysChangedThreshold ist die Anzahl der Schlüsseländerungsvorgänge, die zum Auslösen eines Schnappschusses erforderlich sind. Weitere Informationen zur Persistenz finden Sie unter Redis Dokumente: Persistenz.

Die Valkey-Hostingintegration modelliert eine Valkey-Ressource als den Typ ValkeyResource. Um auf diesen Typ und die APIs zuzugreifen, die es Ihnen ermöglichen, es zu Ihrem 📦Aspire.Hosting.Valkey--NuGet-Paket im -App-Host--Projekt hinzuzufügen.

dotnet add package Aspire.Hosting.Valkey

Weitere Informationen finden Sie unter dotnet add package oder Verwalten von Paketabhängigkeiten in .NET applications.

Valkey-Ressource hinzufügen

Rufen Sie in Ihrem App-Hostprojekt AddValkey an der builder-Instanz auf, um eine Valkey-Ressource hinzuzufügen.

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddValkey("cache");

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Wenn .NET.NET Aspire dem Anwendungshost ein Containerimage hinzufügt, wie im vorherigen Beispiel mit dem docker.io/valkey/valkey-Image gezeigt, wird eine neue Valkey-Instanz auf dem lokalen Computer erstellt. Ein Verweis auf die Valkey-Ressource (die cache Variable) wird dem ExampleProjecthinzugefügt.

Die WithReference-Methode konfiguriert eine Verbindung im ExampleProject namens "cache". Weitere Informationen finden Sie unter Lebenszyklus von Containerressourcen.

Tipp

Wenn Sie lieber eine Verbindung mit einer vorhandenen Valkey-Instanz herstellen möchten, rufen Sie stattdessen AddConnectionString auf. Weitere Informationen finden Sie unter Referenzieren vorhandener Ressourcen.

Hinzufügen einer Valkey-Ressource mit Datenvolume

Um der Valkey-Ressource ein Datenvolume hinzuzufügen, rufen Sie die AddValkey-Methode für die Valkey-Ressource auf:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddValkey("cache")
                   .WithDataVolume(isReadOnly: false);

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Das Datenvolume wird verwendet, um die Valkey-Daten außerhalb des Lebenszyklus des Containers zu speichern. Das Datenvolumen wird im Valkey-Container am /data-Pfad bereitgestellt, und wenn kein name-Parameter angegeben wird, generiert sich der Name zufällig. Weitere Informationen zu Datenvolumes und Details dazu, warum sie gegenüber Bind-Mountsbevorzugt werden, finden Sie in der Docker-Dokumentation: Volumes.

Hinzufügen einer Valkey-Ressource mit Datenbindungs-Bereitstellung

Rufen Sie die WithDataBindMount-Methode auf, um der Valkey-Ressource eine Datenbindungs-Bereitstellung hinzuzufügen:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddValkey("cache")
                   .WithDataBindMount(
                       source: @"C:\Valkey\Data",
                       isReadOnly: false);

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Wichtig

Daten--Bind-Mounts- haben eine eingeschränkte Funktionalität im Vergleich zu -Volumes-, die eine bessere Leistung, Portabilität und Sicherheit bieten und somit besser für Produktionsumgebungen geeignet sind. Bind-Einhängepunkte ermöglichen jedoch direkten Zugriff und die Änderung von Dateien auf dem Hostsystem, ideal für Entwicklung und Testen, bei denen Änderungen in Echtzeit erforderlich sind.

Datenbindungs-Bereitstellungen basieren auf dem Dateisystem des Hostcomputers, um die Valkey-Daten über Containerneustarts hinweg beizubehalten. Das Daten-Bindemount ist auf dem C:\Valkey\Data unter Windows (oder /Valkey/Data auf Unix) Pfad auf dem Hostcomputer im Valkey-Container bereitgestellt. Weitere Informationen zu Datenbindungseinbindungen finden Sie unter Docker Docs: Bindungsanleitungen.

Hinzufügen einer Valkey-Ressource mit Persistenz

Rufen Sie zum Hinzufügen der Persistenz zur Valkey-Ressource die WithPersistence-Methode entweder mit dem Datenvolume oder dem Datenbindungs-Mount auf:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddValkey("cache")
                   .WithDataVolume()
                   .WithPersistence(
                       interval: TimeSpan.FromMinutes(5),
                       keysChangedThreshold: 100);

builder.AddProject<Projects.ExampleProject>()
       .WithReference(cache);

// After adding all resources, run the app...

Der vorangehende Code fügt der Redis-Ressource Persistenz hinzu, indem Momentaufnahmen der Valkey-Daten in einem angegebenen Intervall und Schwellenwert erstellt werden. Die interval ist die Zeit zwischen den Snapshot-Exporten und keysChangedThreshold ist die Anzahl der Schlüsseländerungsvorgänge, die zum Auslösen eines Snapshots erforderlich sind. Weitere Informationen zur Persistenz finden Sie in der Redis Dokumentation: Persistenz.

Durchführen von Integrations-Gesundheitsprüfungen

Die Redis Hostingintegration fügt automatisch eine Integritätsprüfung für den entsprechenden Ressourcentyp hinzu. Die Gesundheitsprüfung überprüft, ob die server ausgeführt wird und ob eine Verbindung hergestellt werden kann.

Die Hostingintegration basiert auf den 📦 AspNetCore.HealthChecks.Redis NuGet-Paketen.

Client Integration

Um mit dem .NET Aspire Stack Exchange Redis Ausgabezwischenspeicherung client Integration zu beginnen, installieren Sie die 📦Aspire. StackExchange.Redis. OutputCaching NuGet-Paket im client-verbrauchenden Projekt, d. h. das Projekt für die Anwendung, das die Ausgabezwischenspeicherung verwendet, client.

dotnet add package Aspire.StackExchange.Redis.OutputCaching

Ausgabe-Cache hinzufügen

Rufen Sie in der Datei Program.cs Ihres client-verwendenden Projekts die AddRedisOutputCache-Erweiterungsmethode bei jedem IHostApplicationBuilder auf, um die erforderlichen Dienste für die Ausgabezwischenspeicherung zu registrieren.

builder.AddRedisOutputCache(connectionName: "cache");

Trinkgeld

Der parameter connectionName muss mit dem Namen übereinstimmen, der beim Hinzufügen der Redis-Ressource im App-Hostprojekt verwendet wird. Weitere Informationen finden Sie unter Hinzufügen der Redis-Ressource.

Trinkgeld

Der parameter connectionName muss mit dem Namen übereinstimmen, der beim Hinzufügen der Garnet-Ressource im App-Hostprojekt verwendet wird. Weitere Informationen finden Sie unter Hinzufügen einer Garnetressource.

Trinkgeld

Der parameter connectionName muss mit dem Namen übereinstimmen, der beim Hinzufügen der Valkey-Ressource im App-Hostprojekt verwendet wird. Weitere Informationen finden Sie unter Hinzufügen der Valkey-Ressource.

Fügen Sie die Middleware zur Anforderungsverarbeitungspipeline hinzu, indem Sie UseOutputCache(IApplicationBuilder)aufrufen:

var app = builder.Build();

app.UseOutputCache();

Konfigurieren Sie für minimalen API-Appseinen Endpunkt, um Caching durchzuführen, durch Aufrufen von CacheOutputoder Anwenden der OutputCacheAttribute, wie in den folgenden Beispielen gezeigt.

app.MapGet("/cached", () => "Hello world!")
   .CacheOutput();

app.MapGet(
    "/attribute",
    [OutputCache] () => "Hello world!");

Wenden Sie für Apps mit Controllern das attribut [OutputCache] auf die Aktionsmethode an. Wenden Sie für Razor Pages-Apps das Attribut auf die Razor-Seitenklasse an.

Konfiguration

Die .NET Aspire Stack Exchange Redis Ausgabezwischenspeicherungsintegration bietet mehrere Optionen zum Konfigurieren der Redis Verbindung basierend auf den Anforderungen und Konventionen Ihres Projekts.

Verbindungszeichenfolge verwenden

Wenn Sie eine Verbindungszeichenfolge aus dem Konfigurationsabschnitt ConnectionStrings verwenden, können Sie beim Aufrufen von AddRedisOutputCacheden Namen der Verbindungszeichenfolge angeben:

builder.AddRedisOutputCache(connectionName: "cache");

Anschließend wird die Verbindungszeichenfolge aus dem Konfigurationsabschnitt ConnectionStrings abgerufen:

{
  "ConnectionStrings": {
    "cache": "localhost:6379"
  }
}

Weitere Informationen zum Formatieren dieser Verbindungszeichenfolge finden Sie in den Stack Exchange Redis-Konfigurationsdokumenten.

Verwenden Sie Konfigurationsanbieter

Die .NET Aspire Stack Exchange Redis-Integration unterstützt Microsoft.Extensions.Configuration. Sie lädt die StackExchangeRedisSettings mithilfe des Aspire:StackExchange:Redis Schlüssels aus der Konfiguration. Beispiel appsettings.json, das einige der Optionen konfiguriert:

{
  "Aspire": {
    "StackExchange": {
      "Redis": {
        "ConnectionString": "localhost:6379",
        "DisableHealthChecks": true,
        "DisableTracing": false
      }
    }
  }
}

Die vollständige Redisclient Integration des JSON Schemas sehen Sie unter Aspire.StackExchange.Redis/ConfigurationSchema.json.

Verwenden von Inline-Delegaten

Sie können auch den Delegaten Action<StackExchangeRedisSettings> configurationSettings übergeben, um einige oder alle Optionen direkt im Code einzurichten, z. B. um Gesundheitsprüfungen aus dem Code zu deaktivieren.

builder.AddRedisOutputCache(
    "cache",
    static settings => settings.DisableHealthChecks  = true);

Sie können die ConfigurationOptions- auch mithilfe des Action<ConfigurationOptions> configureOptions Delegatparameters der AddRedisOutputCache-Methode einrichten. Beispiel: Festlegen des Verbindungstimeouts:

builder.AddRedisOutputCache(
    "cache",
    static settings => settings.ConnectTimeout = 3_000);

Gesundheitschecks

Standardmäßig aktivieren .NET.NET Aspire Integrationen Gesundheitsprüfungen für alle Dienste. Weitere Informationen finden Sie unter .NET.NET Aspire Integrationsübersicht.

Die .NET Aspire Stack Exchange Redis Ausgabe-Cache-Integration behandelt Folgendes:

  • Fügt die StackExchange.Redis Integritätsprüfung hinzu, versucht, die Verbindung zu öffnen und wird ausgelöst, wenn sie fehlschlägt.
  • Integriert in den /health HTTP-Endpunkt, der angibt, dass alle registrierten Integritätsprüfungen bestehen müssen, damit die App als bereit für die Annahme des Datenverkehrs gilt.

Observability und Telemetrie

.NET .NET Aspire Integrationen richten automatisch Protokollierungs-, Ablaufverfolgungs- und Metrikkonfigurationen ein, die manchmal als die Säulen der Beobachtbarkeitbezeichnet werden. Weitere Informationen zur Integrationsbeobachtbarkeit und Telemetrie finden Sie unter .NET.NET Aspire Übersicht über Integrationen. Abhängig vom Unterstützungsdienst könnten einige Integrationen nur einige dieser Funktionen unterstützen. Beispielsweise unterstützen einige Integrationen Protokollierung und Ablaufverfolgung, aber keine Metriken. Telemetrie-Features können auch mithilfe der Techniken deaktiviert werden, die im Abschnitt Configuration dargestellt werden.

Protokollierung

Die Integration von .NET Aspire Stack Exchange Redis Ausgabezwischenspeicherung verwendet die folgenden Protokollkategorien:

  • Aspire.StackExchange.Redis
  • Microsoft.AspNetCore.OutputCaching.StackExchangeRedis

Nachverfolgung

Die Integration der Ausgabezwischenspeicherung von .NET Aspire Stack Exchange Redis wird die folgenden Tracing-Aktivitäten unter Verwendung von OpenTelemetryausgeben:

  • OpenTelemetry.Instrumentation.StackExchangeRedis

Metriken

Die .NET AspireRedis-Integration der Ausgabezwischenspeicherung unterstützt standardmäßig keine Metriken, aufgrund von Einschränkungen der StackExchange.Redis-Bibliothek.

Azure Redis Hostingintegration

Um Ihre Redis-Ressourcen bei Azurebereitzustellen, installieren Sie das -📦-Aspire.Hosting-Azure-Redis--NuGet-Paket:

dotnet add package Aspire.Hosting.Azure.Redis

Ressource Azure Cache for Redisserver hinzufügen

Rufen Sie nach der Installation des .NET Aspire Hosting-AzureRedis Pakets die AddAzureRedis Erweiterungsmethode in Ihrem App-Host-Projekt auf.

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddAzureRedis("azcache")

var exampleProject = builder.AddProject<Projects.ExampleProject>()
                            .WithReference(cache);

Der vorherige Aufruf von AddAzureRedis konfiguriert die Redis-server-Ressource, um als Azure Cache for Redisbereitgestellt zu werden.

Wichtig

Standardmäßig konfiguriert AddAzureRedisMicrosoft Entra ID Authentifizierung. Dies erfordert Änderungen an Anwendungen, die eine Verbindung mit diesen Ressourcen herstellen müssen, z. B. client-Integrationen.

Azure Cache for Redis Ausgabe client hinzufügen

Wenn Sie AddAzureRedis in Ihrer Redis Hostingintegration aufrufen, wird standardmäßig 📦 Microsoft konfiguriert.Azure. StackExchangeRedis NuGet-Paket zum Aktivieren der Authentifizierung:

dotnet add package Microsoft.Azure.StackExchangeRedis

Die Redis-Verbindung kann über die client-Integration und Microsoft.Azure.StackExchangeRedisgenutzt werden. Berücksichtigen Sie den folgenden Konfigurationscode:

var azureOptionsProvider = new AzureOptionsProvider();

var configurationOptions = ConfigurationOptions.Parse(
    builder.Configuration.GetConnectionString("cache") ?? 
    throw new InvalidOperationException("Could not find a 'cache' connection string."));

if (configurationOptions.EndPoints.Any(azureOptionsProvider.IsMatch))
{
    await configurationOptions.ConfigureForAzureWithTokenCredentialAsync(
        new DefaultAzureCredential());
}

builder.AddRedisOutputCache("cache", configureOptions: options =>
{
    options.Defaults = configurationOptions.Defaults;
});

Weitere Informationen finden Sie im Microsoft.Azure. StackExchangeRedis Repository.

Siehe auch

*: Redis ist eine eingetragene Marke der Redis Ltd. Alle dort enthaltenen Rechte sind Redis Ltd. vorbehalten. Jede Verwendung durch Microsoft dient nur zu referenziellen Zwecken und bedeutet keine Unterstützung, Bestätigung oder Zugehörigkeit zwischen Redis und Microsoft. Zum Anfang zurückkehren?