Condividi tramite

® integrazione .NET AspireRedis*

  • Articolo

include:integrazione dell'hosting e integrazione di Client

Redis è la piattaforma dati più veloce al mondo per la memorizzazione nella cache, la ricerca vettoriale e i database NoSQL. L'integrazione .NET AspireRedis consente di connettersi alle istanze Redis esistenti o di creare nuove istanze da .NET utilizzando l'immagine contenitore docker.io/library/redis.

Garnet è un archivio cache ad alte prestazioni di Microsoft Research ed è conforme al protocollo di serializzazione Redis (RESP). L'integrazione .NET AspireRedis consente di connettersi alle istanze di Garnet esistenti o di creare nuove istanze da .NET con l'immagine del contenitore ghcr.io/microsoft/garnet.

Valkey è un fork ed è conforme al (RESP) del protocollo di serializzazione . Si tratta di un archivio dati chiave/valore ad alte prestazioni che supporta un'ampia gamma di carichi di lavoro, ad esempio memorizzazione nella cache, code di messaggi e può fungere da database primario. L'integrazione .NET AspireRedis ti consente di connetterti alle istanze Valkey esistenti, o di creare nuove istanze da .NET utilizzando l'immagine del container docker.io/valkey/valkey.

Integrazione dell'hosting

L'integrazione di hosting Redis modella una risorsa Redis come il tipo RedisResource. Per accedere a questo tipo e alle API che consentono di aggiungerlo al pacchetto NuGet 📦Aspire.Hosting.Redis nel progetto host dell'app .

dotnet add package Aspire.Hosting.Redis

Per altre informazioni, vedere dotnet add package o Gestire le dipendenze dei pacchetti nelle applicazioni .NET.

Aggiungere risorsa Redis

Nel progetto host della tua app, chiama AddRedis sull'istanza builder per aggiungere una risorsa Redis:

var builder = DistributedApplication.CreateBuilder(args);

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

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

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

Quando .NET.NET Aspire aggiunge un'immagine del contenitore all'host dell'app, come illustrato nell'esempio precedente con l'immagine docker.io/Redis/Redis, crea una nuova istanza Redis nel computer locale. Viene aggiunto un riferimento alla risorsa Redis (la variabile cache) alla ExampleProject.

Il metodo WithReference configura una connessione nel ExampleProject denominato "cache". Per ulteriori informazioni, vedere il ciclo di vita delle risorse del contenitore .

Suggerimento

Se preferisci connetterti a un'istanza di Redis esistente, chiama AddConnectionString. Per altre informazioni, vedere Fare riferimento alle risorse esistenti.

Aggiungere Redis risorsa con Redis Insights

Per aggiungere il Redis Insights alla risorsa Redis, chiamare il metodo WithRedisInsight.

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 è un'interfaccia grafica gratuita per l'analisi dei dati Redis in tutti i sistemi operativi e le distribuzioni di Redis con l'aiuto dell'assistente di intelligenza artificiale, Redis Copilot. .NET .NET Aspire aggiunge un'altra immagine del contenitore docker.io/redis/redisinsight all'host dell'app che esegue l'app comandante.

Nota

Per configurare la porta host per la catena di RedisInsightResource, è necessario fare una chiamata all'API WithHostPort e specificare il numero di porta desiderato.

Aggiungere la risorsa Redis con il comandante Redis

Per aggiungere il Redis Comandante alla risorsa Redis, chiamare il metodo WithRedisCommander:

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 è un'applicazione Web Node.js usata per visualizzare, modificare e gestire un database Redis. .NET .NET Aspire aggiunge un'altra immagine del container docker.io/rediscommander/redis-commander all'host dell'app che esegue l'app di comando.

Suggerimento

Per configurare la porta host per la catena di RedisCommanderResource, effettuare una chiamata all'API WithHostPort e fornire il numero di porta desiderato.

Aggiungere la risorsa Redis con volume di dati

Per aggiungere un volume di dati alla risorsa Redis, chiamare il metodo WithDataVolume nella risorsa Redis:

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

Il volume di dati viene usato per rendere persistenti i dati Redis all'esterno del ciclo di vita del contenitore. Il volume di dati viene montato nel percorso /data nel contenitore Redis e quando non viene specificato un parametro name, il nome viene generato in modo casuale. Per ulteriori informazioni sui volumi di dati e sui motivi per cui sono preferiti rispetto ai montaggi associati , vedere la documentazione Docker: Volumi.

Aggiungere la risorsa Redis con il bind mount dei dati

Per aggiungere un montaggio di bind dati alla risorsa Redis, chiamare il metodo WithDataBindMount:

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

Importante

I di binding dei dati hanno funzionalità limitate rispetto ai volumi , che offrono prestazioni, portabilità e sicurezza migliori, rendendole più adatte per gli ambienti di produzione. Tuttavia, i montaggi bind consentono l'accesso diretto e la modifica diretta dei file nel sistema host, ideali per lo sviluppo e il test in cui sono richieste modifiche in tempo reale.

I montaggi di associazione dati si basano sul file system del computer host per rendere persistenti i dati Redis tra i riavvii del contenitore. Il montaggio di bind dei dati è effettuato sul percorso C:\Redis\Data su Windows (o /Redis/Data sul percorso di Unix) sulla macchina host nel contenitore Redis. Per ulteriori informazioni sui bind mount di dati, consultare la documentazione Docker: Bind mounts.

Aggiungi la risorsa Redis con persistenza

Per aggiungere la persistenza alla risorsa Redis, chiamare il metodo WithPersistence con il volume di dati o il montaggio dell'associazione dati:

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

Il codice precedente aggiunge la persistenza alla risorsa Redis eseguendo snapshot dei dati Redis a un intervallo e una soglia specificati. Il interval è il tempo tra le esportazioni di snapshot e il keysChangedThreshold è il numero di operazioni di modifica della chiave necessarie per attivare uno snapshot. Per altre informazioni sulla persistenza, vedere i documenti Redis: Persistenza.

L'integrazione di hosting di Garnet modella una risorsa Garnet come il tipo GarnetResource. Per accedere a questo tipo e alle API che consentono di aggiungerlo al pacchetto NuGet 📦Aspire.Hosting.Garnet nell'host dell'app del progetto.

dotnet add package Aspire.Hosting.Garnet

Per altre informazioni, vedere dotnet add package o Manage package dependencies in .NET applications.

Aggiungere una risorsa Garnet

Nel progetto host dell'app, chiama AddGarnet sull'istanza builder per aggiungere una risorsa Garnet.

var builder = DistributedApplication.CreateBuilder(args);

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

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

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

Quando .NET.NET Aspire aggiunge un'immagine del container all'host dell'app, come illustrato nell'esempio precedente con l'immagine ghcr.io/microsoft/garnet, crea una nuova istanza Garnet sul computer locale. Un riferimento alla risorsa Garnet (variabile cache) viene aggiunto al ExampleProject.

Il metodo WithReference configura una connessione nel ExampleProject denominato "cache". Per altre informazioni, vedere ciclo di vita delle risorse contenitore.

Suggerimento

Se invece si preferisce connettersi a un'istanza Garnet esistente, chiamare AddConnectionString. Per altre informazioni, vedere Fare riferimento alle risorse esistenti.

Aggiungere una risorsa Garnet con un volume di dati

Per aggiungere un volume di dati alla risorsa Garnet, chiamare il metodo AddGarnet nella risorsa Garnet:

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

Il volume di dati viene usato per rendere persistenti i dati Garnet all'esterno del ciclo di vita del contenitore. Il volume di dati viene montato nel percorso /data nel contenitore Garnet e quando non viene specificato un parametro name, il nome viene generato in modo casuale. Per altre informazioni sui volumi di dati e sui motivi per cui sono preferiti rispetto a associare i montaggi, vedere la documentazione Docker: Volumi.

Aggiungere una risorsa Garnet con il montaggio di associazione dati

Per aggiungere un montaggio di associazione dati alla risorsa Garnet, chiamare il metodo WithDataBindMount:

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

Importante

Il bind mount dei dati ha funzionalità limitate rispetto ai volumi , che offrono prestazioni, portabilità e sicurezza migliori, rendendoli più adatti per gli ambienti di produzione. Tuttavia, i bind mounts consentono l'accesso e la modifica dei file nel sistema host, ideale per lo sviluppo e il test, dove sono necessarie modifiche a tempo reale.

I montaggi di associazione dei dati si basano sul sistema di file del computer host per rendere persistenti i dati Garnet tra i riavvii dei container. Il montaggio del data bind è eseguito nel percorso C:\Garnet\Data su Windows (o /Garnet/Data su Unix) sul computer host all'interno del contenitore Garnet. Per altre informazioni sui montaggi di associazione dati, vedere Docker docs: Bind mounts.

Aggiungere una risorsa Garnet con persistenza

Per aggiungere la persistenza alla risorsa Garnet, chiamare il metodo WithPersistence con il volume di dati o il bind mount dei dati.

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

Il codice precedente aggiunge la persistenza alla risorsa Redis eseguendo snapshot dei dati Garnet a un intervallo e una soglia specificati. Il interval è il tempo tra le esportazioni di snapshot e il keysChangedThreshold è il numero di operazioni di modifica della chiave necessarie per attivare uno snapshot. Per altre informazioni sulla persistenza, vedere Redis docs: Persistenza.

L'integrazione hosting di Valkey modella una risorsa Valkey come tipo ValkeyResource. Per accedere a questo tipo e alle API che consentono di aggiungerlo al pacchetto NuGet 📦Aspire.Hosting.Valkey nel progetto host dell'app.

dotnet add package Aspire.Hosting.Valkey

Per altre informazioni, consultare dotnet add package o Gestire le dipendenze dei pacchetti nelle applicazioni .NET.

Aggiungere una risorsa Valkey

Nel progetto host dell'app chiamare AddValkey nell'istanza di builder per aggiungere una risorsa Valkey:

var builder = DistributedApplication.CreateBuilder(args);

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

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

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

Quando .NET.NET Aspire aggiunge un'immagine del container all'host dell'app, come illustrato nell'esempio precedente con l'immagine docker.io/valkey/valkey, crea una nuova istanza Valkey nel computer locale. Un riferimento alla risorsa Valkey (la variabile cache) viene aggiunto al ExampleProject.

Il metodo WithReference configura una connessione nel ExampleProject denominato "cache". Per altre informazioni, vedere il ciclo di vita delle risorse dei contenitori.

Consiglio

Preferisci invece connetterti a un'istanza Valkey esistente, chiama AddConnectionString. Per altre informazioni, vedere Fare riferimento alle risorse esistenti.

Aggiungere una risorsa Valkey con un volume di dati

Per aggiungere un volume di dati alla risorsa Valkey, chiamare il metodo AddValkey nella risorsa Valkey:

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

Il volume di dati viene usato per rendere persistenti i dati Valkey all'esterno del ciclo di vita del contenitore. Il volume di dati viene montato nel percorso /data nel contenitore Valkey e quando non viene specificato un parametro name, il nome viene generato in modo casuale. Per ulteriori informazioni sui volumi e sui motivi per cui sono preferiti rispetto ai mount di collegamento , consultare la documentazione Docker: Volumi.

Aggiungere una risorsa Valkey con il montaggio dell'associazione dati

Per aggiungere un montaggio di associazione dati alla risorsa Valkey, chiamare il metodo WithDataBindMount:

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

Importante

I di binding dei dati hanno funzionalità limitate rispetto ai volumi , che offrono prestazioni, portabilità e sicurezza migliori, rendendole più adatte per gli ambienti di produzione. Tuttavia, i bind mounts consentono l'accesso diretto e la modifica dei file nel sistema host, ideale per lo sviluppo e il test in cui sono necessarie modifiche in tempo reale.

I montaggi di associazione dati si basano sul file system del computer host per rendere persistenti i dati Valkey tra i riavvii del contenitore. Il punto di montaggio dati è montato nel percorso C:\Valkey\Data su Windows (o /Valkey/Data nel percorso Unix) sul computer host nel contenitore Valkey. Per altre informazioni sui montaggi di associazione dati, vedere Docker docs: Bind mounts.

Aggiungi una risorsa Valkey con persistenza

Per aggiungere la persistenza alla risorsa Valkey, chiamare il metodo WithPersistence con il volume dati o il bind mount dei dati:

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

Il codice precedente aggiunge la persistenza alla risorsa Redis eseguendo snapshot dei dati Valkey a un intervallo e una soglia specificati. Il interval è il tempo tra le esportazioni di snapshot e il keysChangedThreshold è il numero di operazioni di modifica della chiave necessarie per attivare uno snapshot. Per ulteriori informazioni sulla persistenza, consulta Redis docs: Persistenza.

Controlli di integrità per l'integrazione di hosting

L'integrazione dell'hosting Redis aggiunge automaticamente un controllo di integrità per il tipo di risorsa appropriato. Il controllo di integrità verifica che il server sia operativo e che sia possibile stabilire una connessione.

L'integrazione dell'hosting si basa sul pacchetto NuGet AspNetCore.HealthChecks. 📦.Redis

integrazione Client

Per iniziare a usare l'integrazione di .NET Aspire Stack Exchange Redisclient, installare il pacchetto NuGet 📦Aspire.StackExchange.Redis nel progetto che usa client, ovvero il progetto per l'applicazione che usa il Redisclient. L'integrazione Redisclient registra un'istanza di IConnectionMultiplexer che puoi usare per interagire con Redis.

dotnet add package Aspire.StackExchange.Redis

Aggiungere Redisclient

Nel file Program.cs del progetto client-consuming, chiama il metodo di estensione AddRedisClient su qualsiasi IHostApplicationBuilder per registrare un IConnectionMultiplexer da usare tramite il contenitore per l'iniezione delle dipendenze. Il metodo accetta un parametro del nome di connessione.

builder.AddRedisClient(connectionName: "cache");

Consiglio

Il parametro connectionName deve corrispondere al nome usato quando si aggiunge la risorsa Redis nel progetto host dell'app. Per altre informazioni, vedere Aggiungere Redis risorsa.

Mancia

Il parametro connectionName deve corrispondere al nome usato quando si aggiunge la risorsa Garnet nel progetto host dell'app. Per altre informazioni, vedere Aggiungere una risorsa Garnet.

Consiglio

Il parametro connectionName deve corrispondere al nome usato quando si aggiunge la risorsa Valkey nel progetto host dell'app. Per altre informazioni, vedere Aggiungere una risorsa Valkey.

È quindi possibile ottenere l'istanza di IConnection utilizzando l'iniezione delle dipendenze. Ad esempio, per recuperare la connessione da un servizio di esempio:

public class ExampleService(IConnectionMultiplexer connectionMux)
{
    // Use connection multiplexer...
}

Per ulteriori informazioni sull'iniezione di dipendenze, vedere .NET iniezione di dipendenze.

Aggiungere Redisclient con chiave

In alcuni casi potrebbe essere necessario registrare più istanze di IConnectionMultiplexer con nomi di connessione diversi. Per registrare i client Redis con chiave, chiamare il metodo AddKeyedRedisClient:

builder.AddKeyedRedisClient(name: "chat");
builder.AddKeyedRedisClient(name: "queue");

È quindi possibile recuperare le istanze di IConnectionMultiplexer usando l'iniezione delle dipendenze. Ad esempio, per recuperare la connessione da un servizio di esempio:

public class ExampleService(
    [FromKeyedServices("chat")] IConnectionMultiplexer chatConnectionMux,
    [FromKeyedServices("queue")] IConnectionMultiplexer queueConnectionMux)
{
    // Use connections...
}

Per ulteriori informazioni sui servizi chiave, vedere .NET iniezione delle dipendenze: Servizi chiave.

Configurazione

L'integrazione Redisclient.NET Aspire Stack Exchange offre più opzioni per configurare la connessione Redis in base ai requisiti e alle convenzioni del progetto.

Usare una stringa di connessione

Quando si usa una stringa di connessione dalla sezione di configurazione ConnectionStrings, è possibile specificare il nome della stringa di connessione quando si chiama AddRedis:

builder.AddRedis("cache");

Quando si usa una stringa di connessione dalla sezione di configurazione ConnectionStrings, è possibile specificare il nome della stringa di connessione quando si chiama AddGarnet:

builder.AddGarnet("cache");

Quando si usa una stringa di connessione dalla sezione di configurazione ConnectionStrings, è possibile specificare il nome della stringa di connessione quando si chiama AddValkey:

builder.AddValkey("cache");

La stringa di connessione verrà quindi recuperata dalla sezione di configurazione ConnectionStrings:

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

Per ulteriori informazioni su come formattare questa stringa di connessione, consultare la documentazione sulla configurazionedi Stack Exchange .

Utilizzare i fornitori di configurazione

L'integrazione RedisRedis stack di .NET Aspire supporta Microsoft.Extensions.Configuration. Carica il StackExchangeRedisSettings dalla configurazione usando la chiave Aspire:StackExchange:Redis. Esempio appsettings.json che configura alcune delle opzioni:

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

Per lo schema completo di integrazione RedisclientJSON, consultare Aspire.StackExchange.Redis/ConfigurationSchema.json.

Usare delegati inline

È anche possibile passare il delegato Action<StackExchangeRedisSettings> per configurare alcune o tutte le opzioni in linea, ad esempio per configurare DisableTracing:

builder.AddRedisClient(
    "cache",
    static settings => settings.DisableTracing = true);

Client controlli di integrità dell'integrazione

Per impostazione predefinita, le integrazioni di .NET.NET Aspire abilitano verifiche dello stato di salute per tutti i servizi. Per altre informazioni, vedere panoramica delle integrazioni .NET.NET Aspire.

L'integrazione di .NET Aspire Stack Exchange Redis gestisce le operazioni seguenti:

  • Aggiunge il controllo di integrità quando StackExchangeRedisSettings.DisableHealthChecks è false, che tenta di connettersi all'istanza del contenitore.
  • Si integra con l'endpoint HTTP /health, che specifica che tutti i controlli di integrità registrati devono essere passati affinché l'app sia considerata pronta per accettare il traffico.

Osservabilità e telemetria

.NET .NET Aspire le integrazioni impostano automaticamente le configurazioni di registrazione, tracciamento e metriche, talvolta note come i pilastri dell'osservabilità. Per altre informazioni sull'osservabilità e la telemetria dell'integrazione, vedere panoramica delle integrazioni .NET.NET Aspire. A seconda del servizio di backup, alcune integrazioni potrebbero supportare solo alcune di queste funzionalità. Ad esempio, alcune integrazioni supportano la registrazione e la traccia, ma non le metriche. Le funzionalità di telemetria possono essere disabilitate anche usando le tecniche presentate nella sezione Configurazione .

Registrazione

L'integrazione .NET AspireRedis Stack Exchange utilizza le seguenti categorie di log:

  • Aspire.StackExchange.Redis

Tracciatura

L'integrazione .NET Aspire Stack Exchange Redis genererà le seguenti attività di tracciamento utilizzando OpenTelemetry:

  • OpenTelemetry.Instrumentation.StackExchangeRedis

Metriche

L'integrazione di .NET Aspire con Redis attualmente non supporta le metriche per impostazione predefinita a causa di limitazioni della libreria StackExchange.Redis.

integrazione di hosting con AzureRedis

Per distribuire le risorse di Redis in Azure, installare il 📦Aspire.Hosting.Azure.Redis pacchetto NuGet:

dotnet add package Aspire.Hosting.Azure.Redis

Aggiungere la risorsa Azure Cache for Redisserver

Dopo aver installato il pacchetto di hosting .NET AspireAzureRedis, richiamare il metodo di estensione AddAzureRedis nel progetto host dell'applicazione:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddAzureRedis("azcache")

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

La chiamata precedente a AddAzureRedis configura la risorsa Redisserver da distribuire come Azure Cache for Redis.

Importante

Per impostazione predefinita, AddAzureRedis configura autenticazione Microsoft Entra ID. Ciò richiede modifiche alle applicazioni che devono connettersi a queste risorse, ad esempio, integrazioni client.

Aggiungere Azure Cache for Redisclient

Per impostazione predefinita, quando si chiama AddAzureRedis nell'integrazione dell'hosting Redis, viene configurato 📦 Microsoft.Azure.StackExchangeRedis pacchetto NuGet per abilitare l'autenticazione:

dotnet add package Microsoft.Azure.StackExchangeRedis

La connessione Redis può essere fruita tramite l'integrazione client e Microsoft.Azure.StackExchangeRedis. Prendere in considerazione il codice di configurazione seguente:

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.AddRedisClient("cache", configureOptions: options =>
{
    options.Defaults = configurationOptions.Defaults;
});

Per altre informazioni, vedere il repository Microsoft.Azure.StackExchangeRedis.

Vedere anche

*: Redis è un marchio registrato di Redis Ltd. Tutti i diritti in esso contenuti sono riservati a Redis Ltd. Qualsiasi utilizzo da parte di Microsoft è solo a scopo referenziale e non indica alcuna sponsorizzazione, approvazione o affiliazione tra Redis e Microsoft. Tornare all'superiore?