Redis Output Caching

The Redis® output caching integration is used to register an ASP.NET Core Output Caching provider backed by a Redis server with the docker.io/library/redis container image.

Hosting integration

The Redis hosting integration models a Redis resource as the RedisResource type. To access this type and APIs, add the 📦 Aspire.Hosting.Redis NuGet package in your AppHost project:

aspire add redis

The Aspire CLI is interactive, be sure to select the appropriate search result when prompted:

Select an integration to add:

> redis (Aspire.Hosting.Redis)
> Other results listed as selectable options...

#:package Aspire.Hosting.Redis@*

<PackageReference Include="Aspire.Hosting.Redis" Version="*" />

Add Redis resource

In your AppHost project, call AddRedis on the builder instance to add a Redis resource:

var builder = DistributedApplication.CreateBuilder(args);

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

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

When Aspire adds a container image to the AppHost, it creates a new Redis instance on your local machine.

Add Redis resource with data volume

To add a data volume to the Redis resource, call the WithDataVolume method:

var builder = DistributedApplication.CreateBuilder(args);

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

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

The data volume is used to persist the Redis data outside the lifecycle of its container. The data volume is mounted at the /data path in the Redis container.

Add Redis resource with persistence

To add persistence to the Redis resource, call the WithPersistence method with either the data volume or data bind mount:

var builder = DistributedApplication.CreateBuilder(args);

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

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

The preceding code adds persistence to the Redis resource by taking snapshots of the Redis data at a specified interval and threshold.

For more Redis hosting integration options, see the main Redis integration page.

Client integration

To get started with the Redis output caching integration, install the 📦 Aspire.StackExchange.Redis.OutputCaching NuGet package:

dotnet add package Aspire.StackExchange.Redis.OutputCaching

#:package Aspire.StackExchange.Redis.OutputCaching@*

<PackageReference Include="Aspire.StackExchange.Redis.OutputCaching" Version="*" />

Add output caching

In the Program.cs file of your client-consuming project, call the AddRedisOutputCache extension method to register the required services for output caching:

builder.AddRedisOutputCache(connectionName: "cache");

Add the middleware to the request processing pipeline by calling UseOutputCache:

var app = builder.Build();

app.UseOutputCache();

For minimal API apps, configure an endpoint to do caching by calling CacheOutput, or by applying the OutputCacheAttribute:

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

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

For apps with controllers, apply the [OutputCache] attribute to the action method. For Razor Pages apps, apply the attribute to the Razor page class.

Configuration

Use a connection string

When using a connection string from the ConnectionStrings configuration section:

builder.AddRedisOutputCache(connectionName: "cache");

Then the connection string will be retrieved:

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

Use configuration providers

The Redis output caching integration supports Microsoft.Extensions.Configuration. Example appsettings.json:

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

Use inline delegates

You can pass the delegate to set up options inline:

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

You can also configure the ConfigurationOptions:

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

Client integration health checks

By default, Aspire integrations enable health checks. The Redis output caching integration adds a health check that verifies the Redis instance is reachable.

Observability and telemetry

Logging

The Redis output caching integration uses standard .NET logging.

Tracing

The integration emits tracing activities using OpenTelemetry.

Metrics

The integration emits metrics using OpenTelemetry.

FAQ Collaborate Community Discuss Watch