Dela via

.NET Aspire Redis * integration med distribuerad cachelagring

  • Artikel

omfattar:Som värd för integrering och Client integration

Lär dig hur du använder .NET AspireRedis distribuerad cachelagringsintegrering. Aspire.StackExchange.Redis.DistributedCaching-biblioteket används för att registrera en IDistributedCache--provider som backas upp av en Redisserver med docker.io/library/redis containeravbildningen.

Lär dig hur du använder .NET AspireRedis distribuerad cachelagringsintegrering. Aspire.StackExchange.Redis.DistributedCaching-biblioteket används för att registrera en IDistributedCache--provider som stöds av en Garnet-server med ghcr.io/microsoft/garnet containeravbildningen.

Lär dig hur du använder .NET AspireRedis distribuerad cachelagringsintegrering. Aspire.StackExchange.Redis.DistributedCaching-biblioteket används för att registrera en IDistributedCache--provider som stöds av en Valkey-server med docker.io/valkey/valkey containerbilden.

Värdintegrering

Redis-värdintegrationen modellerar en Redis-resurs som RedisResource-typ. För att komma åt den här typen och API:er som gör att du kan lägga till den i din 📦Aspire.Hosting.Redis NuGet-paket i applikationsvärdprojekt.

dotnet add package Aspire.Hosting.Redis

Mer information finns i dotnet add package eller Hantera paketberoenden i .NET applikationer.

Lägga till Redis resurs

I ditt appvärdprojekt anropar du AddRedis på builder-instansen för att lägga till en Redis-resurs.

var builder = DistributedApplication.CreateBuilder(args);

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

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

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

När .NET.NET Aspire lägger till en containeravbildning i appvärden, som du ser i föregående exempel med docker.io/Redis/Redis avbildningen, skapar den en ny Redis instans på den lokala datorn. En referens till din Redis resurs (variabeln cache) läggs till i ExampleProject.

Metoden WithReference konfigurerar en anslutning i ExampleProject med namnet "cache". Mer information finns i Livscykel för containerresurser.

Tips

Om du hellre vill ansluta till en befintlig Redis instans anropar du AddConnectionString i stället. Mer information finns i Referera till befintliga resurser.

Lägga till Redis resurs med Redis Insights

Om du vill lägga till Redis Insights- till resursen Redis anropar du metoden 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 är ett kostnadsfritt grafiskt gränssnitt för att analysera Redis data i alla operativsystem och Redis distributioner med hjälp av vår AI-assistent, Redis Copilot. .NET .NET Aspire lägger till ytterligare en containerbild docker.io/redis/redisinsight till appvärden som kör kommandörappen.

Not

För att konfigurera värdporten för RedisInsightResource kedja ett anrop till WithHostPort-API:et och ange önskat portnummer.

Lägg till Redis resurs med Redis Commander

Om du vill lägga till Redis Commander- i resursen Redis anropar du metoden 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 är ett Node.js webbprogram som används för att visa, redigera och hantera en Redis-databas. .NET .NET Aspire lägger till ytterligare en containerbild docker.io/rediscommander/redis-commander till appvärden som kör kommandorapp.

Tips

För att konfigurera värdporten för RedisCommanderResource kedja ett anrop till WithHostPort-API:et och ange önskat portnummer.

Lägga till Redis resurs med datavolym

Om du vill lägga till en datavolym i resursen Redis anropar du metoden WithDataVolume på den Redis resursen:

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

Datavolymen används för att bevara Redis data utanför containerns livscykel. Datavolymen monteras på den /data sökvägen i containern Redis och när en name parameter inte anges genereras namnet slumpmässigt. Mer information om datavolymer och information om varför de föredras framför bindningsmonteringarfinns i Docker dokument: Volymer.

Lägg till Redis-resursen med data-bindmontering

Om du vill lägga till en databindningsmontering till den Redis resursen anropar du metoden 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...

Viktig

Data bindningsmonteringar har begränsade funktioner jämfört med volymer, vilket ger bättre prestanda, portabilitet och säkerhet, vilket gör dem mer lämpliga för produktionsmiljöer. Bindningsmonteringar tillåter dock direkt åtkomst och ändring av filer i värdsystemet, perfekt för utveckling och testning där realtidsändringar behövs.

Bindmonteringar av data förlitar sig på värddatorns filsystem för att Redis-data ska bevaras mellan omstarter av containrar. Databindningen monteras på sökvägen C:\Redis\Data på Windows (eller /Redis/Data på Unix) på värddatorn i Redis-containern. Mer information om bindningspunkter för data finns i Docker dokumentation: Bindningspunkter.

Lägga till Redis resurs med beständighet

Om du vill lägga till beständighet för den Redis-resursen anropar du metoden WithPersistence med antingen datavolymen eller databindningspunkt:

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

Föregående kod lägger till beständighet för den Redis resursen genom att ta ögonblicksbilder av Redis data med ett angivet intervall och tröskelvärde. interval är tiden mellan ögonblicksbildexporter och keysChangedThreshold är antalet viktiga ändringsåtgärder som krävs för att utlösa en ögonblicksbild. Mer information om beständighet finns i Redis dokument: Beständighet.

Integrering av Garnet hosting modellerar en Garnet-resurs som typen GarnetResource. För att komma åt den här typen och API:er som gör att du kan lägga till det i ditt 📦Aspire.Hosting.Garnet NuGet-paket i projektet för appvärd .

dotnet add package Aspire.Hosting.Garnet

Mer information finns i dotnet add package eller Hantera paketberoenden i .NET applikationer.

Lägg till Garnet-resurs

I appvärdprojektet anropar du AddGarnet på builder-instansen för att lägga till en Garnet-resurs:

var builder = DistributedApplication.CreateBuilder(args);

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

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

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

När .NET.NET Aspire lägger till en containeravbildning till app-värden, som visas i föregående exempel med avbildningen ghcr.io/microsoft/garnet, skapar den en ny Garnet-instans på din lokala dator. En referens till din Garnet-resurs (variabeln cache) läggs till i ExampleProject.

Metoden WithReference konfigurerar en anslutning i ExampleProject med namnet "cache". Mer information finns i Livscykel för containerresurser.

Tips

Om du hellre vill ansluta till en befintlig Garnet-instans anropar du AddConnectionString i stället. Mer information finns i Referera till befintliga resurser.

Lägg till Garnet-resurs med datavolym

Om du vill lägga till en datavolym i Garnet-resursen anropar du metoden AddGarnet på Garnet-resursen:

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

Datavolymen används för att bevara Garnet-data utanför containerns livscykel. Datavolymen monteras på sökvägen /data i Garnet-containern och när en name-parameter inte anges genereras namnet slumpmässigt. Mer information om datavolymer och varför de föredras framför bindmonteringarfinns i Docker dokument: Volymer.

Lägg till Garnet-resurs med databindningsmontering

Om du vill lägga till en databindningsmontering till Garnet-resursen anropar du metoden 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...

Viktig

Data bindningsmonteringar har begränsade funktioner jämfört med volymer, vilket ger bättre prestanda, portabilitet och säkerhet, vilket gör dem mer lämpliga för produktionsmiljöer. Bindningsmonteringar tillåter dock direkt åtkomst och ändring av filer i värdsystemet, perfekt för utveckling och testning där realtidsändringar behövs.

Databindningsmonteringar förlitar sig på värddatorns filsystem för att bevara Garnet-data mellan omstarter av containrar. Databindningsmonteringen monteras på sökvägen C:\Garnet\Data i Windows (eller /Garnet/Data på Unix) på värddatorn i Garnet-containern. Mer information om databindningspunkter finns i Docker dokumentation: Bindmonteringar.

Lägg till Garnet-resurs med beständighet

Om du vill lägga till beständighet i Garnet-resursen anropar du metoden WithPersistence med antingen datavolymen eller databindningsmonteringen:

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

Föregående kod lägger till beständighet för den Redis resursen genom att ta ögonblicksbilder av Garnet-data med ett angivet intervall och tröskelvärde. interval är tiden mellan ögonblicksbildexporter och keysChangedThreshold är antalet viktiga ändringsåtgärder som krävs för att utlösa en ögonblicksbild. Mer information om beständighet finns i Redis dokument: Beständighet.

Valkey-värdintegreringen modellerar en Valkey-resurs som en typ ValkeyResource. För att komma åt den här typen och API:er som gör att du kan lägga till den i ditt 📦Aspire.Hosting.Valkey NuGet-paket i projektet för apputformning.

dotnet add package Aspire.Hosting.Valkey

För mer information, se dotnet add package eller Hantera paketberoenden i .NET-applikationer.

Lägg till Valkey-resurs

I appvärdprojektet anropar du AddValkey på builder-instansen för att lägga till en Valkey-resurs:

var builder = DistributedApplication.CreateBuilder(args);

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

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

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

När .NET.NET Aspire lägger till en containeravbildning till programvärden, som visas i det tidigare exemplet med docker.io/valkey/valkey-avbildningen, skapar den en ny Valkey-instans på din lokala dator. En referens till valkey-resursen (variabeln cache) läggs till i ExampleProject.

Metoden WithReference konfigurerar en anslutning i ExampleProject med namnet "cache". Mer information finns i Livscykel för containerresurser.

Tips

Om du hellre vill ansluta till en befintlig Valkey-instans anropar du AddConnectionString i stället. Mer information finns i Referera till befintliga resurser.

Lägga till Valkey-resurs med datavolym

Om du vill lägga till en datavolym i Valkey-resursen anropar du metoden AddValkey på Valkey-resursen:

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

Datavolymen används för att bevara Valkey-data utanför containerns livscykel. Datavolymen monteras på den /data sökvägen i Valkey-containern och när en name parameter inte anges genereras namnet slumpmässigt. Mer information om datavolymer och varför de föredras framför bindningspunkterfinns i Docker dokument: Volymer.

Lägga till Valkey-resurs med databindningsmontering

Om du vill lägga till en databindningsmontering till Valkey-resursen anropar du metoden 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...

Viktig

Data bindningsmonteringar har begränsade funktioner jämfört med volymer, vilket ger bättre prestanda, portabilitet och säkerhet, vilket gör dem mer lämpliga för produktionsmiljöer. Bindningsmonteringar tillåter dock direkt åtkomst och ändring av filer i värdsystemet, perfekt för utveckling och testning där realtidsändringar behövs.

Databindningar förlitar sig på värddatorns filsystem för att bevara Valkey-data vid omstarter av containrar. Databindningsmonteringen monteras på sökvägen C:\Valkey\Data i Windows (eller /Valkey/Data på Unix) på värddatorn i Valkey-containern. För mer information om databindningsfästen, se Docker dokumentation: Bind-fästen.

Lägg till Valkey-resurs med persistens

Om du vill lägga till beständighet i Valkey-resursen anropar du metoden WithPersistence med antingen datavolymen eller databindningsmonteringen:

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

Föregående kod lägger till beständighet för den Redis resursen genom att ta ögonblicksbilder av Valkey-data med ett angivet intervall och tröskelvärde. interval är tiden mellan ögonblicksbildexporter och keysChangedThreshold är antalet viktiga ändringsåtgärder som krävs för att utlösa en ögonblicksbild. Mer information om beständighet finns i Redis dokument: Beständighet.

Värd för hälsokontroller för integrering

Redis värdintegrering lägger automatiskt till en hälsokontroll för lämplig resurstyp. Hälsokontrollen verifierar att server är igång och att en anslutning kan upprättas till den.

Värdintegrering förlitar sig på 📦 AspNetCore.HealthChecks.Redis NuGet-paketet.

Client integration

Kom igång med .NET AspireRedis distribuerad cacheintegrering genom att installera 📦Aspire. StackExchange.Redis. DistributedCaching NuGet-paketet i användarprojektet client, dvs. projektet för applikationen som använder Redis distribuerad cachelagring client.

dotnet add package Aspire.StackExchange.Redis.DistributedCaching

Lägg till Redisclient

I Program.cs-filen för ditt client-förbrukande projekt anropar du AddRedisDistributedCache-tillägget för att registrera de tjänster som krävs för distribuerad cachelagring och lägga till en IDistributedCache för användning via containern för beroendeinmatning.

builder.AddRedisDistributedCache(connectionName: "cache");

Tips

Parametern connectionName måste matcha namnet som används när man lägger till Redis-resursen i appvärdprojektet. För mer information, se Lägg till Redis resurs.

Tips

Parametern connectionName måste matcha namnet som används när du lägger till Garnet-resursen i appvärdprojektet. Mer information finns i Lägg till Garnet-resurs.

Tips

Parametern connectionName måste matcha namnet som används när du lägger till Valkey-resursen i appvärdprojektet. För mer information, se Lägg till Valkey-resurs.

Du kan sedan hämta instansen IDistributedCache med hjälp av beroendeinjektion. Om du till exempel vill hämta cacheminnet från en tjänst:

public class ExampleService(IDistributedCache cache)
{
    // Use cache...
}

Mer information om beroendeinmatning finns i .NET beroendeinmatning.

Lägg till med taggen Redisclient

Det kan finnas situationer där du vill registrera flera IDistributedCache instanser med olika anslutningsnamn. Om du vill registrera nyckelade Redis klienter anropar du metoden AddKeyedRedisDistributedCache:

builder.AddKeyedRedisDistributedCache(name: "chat");
builder.AddKeyedRedisDistributedCache(name: "product");

Sedan kan du hämta IDistributedCache instanser med hjälp av beroendeinjektion. Om du till exempel vill hämta anslutningen från en exempeltjänst:

public class ExampleService(
    [FromKeyedServices("chat")] IDistributedCache chatCache,
    [FromKeyedServices("product")] IDistributedCache productCache)
{
    // Use caches...
}

För mer information om nyckeltjänster, se .NET beroendeinjektion: Nyckeltjänster.

Konfiguration

Den distribuerade .NET AspireRedis cacheintegreringen erbjuder flera alternativ för att konfigurera Redis-anslutningen utifrån projektets krav och konventioner.

Använda en anslutningssträng

När du använder en anslutningssträng från ConnectionStrings konfigurationsavsnittet kan du ange namnet på anslutningssträngen när du anropar builder.AddRedisDistributedCache:

builder.AddRedisDistributedCache("cache");

Och sedan hämtas anslutningssträngen från ConnectionStrings-konfigurationsavsnittet:

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

Mer information om hur du formaterar den här anslutningssträngen finns i Stack Exchange Redis konfigurationsdokument.

Använda konfigurationsprovidrar

.NET Aspire Stack Exchange Redis-integreringen stöder Microsoft.Extensions.Configuration. Den läser in StackExchangeRedisSettings från konfigurationen med hjälp av Aspire:StackExchange:Redis-nyckeln. Exempel appsettings.json som konfigurerar några av alternativen:

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

Det fullständiga Redisclient integrationsschemat JSON finns i Aspire. StackExchange.Redis/ConfigurationSchema.json.

Använd inbäddade delegerade

Du kan också använda delegeringen Action<StackExchangeRedisSettings> för att ställa in vissa eller alla alternativ direkt i koden, till exempel för att konfigurera DisableTracing:

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

Du kan också konfigurera ConfigurationOptions med hjälp av parametern Action<ConfigurationOptions> configureOptions delegate för metoden AddRedisDistributedCache. Om du till exempel vill ange tidsgränsen för anslutningen:

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

Hälsokontroller

Som standard aktiverar .NET.NET Aspire integreringar hälsokontroller för alla tjänster. Mer information finns i översikten över .NET.NET Aspire integreringar.

Integreringen .NET AspireRedis distribuerad cachelagring hanterar följande:

  • Lägger till StackExchange.Redis hälsokontroll, försöker öppna anslutningen och genererar när den misslyckas.
  • Integreras med /health HTTP-slutpunkt, som anger att alla registrerade hälsokontroller måste passera för att appen ska anses vara redo att ta emot trafik.

Observerbarhet och telemetri

.NET .NET Aspire integreringar ställer automatiskt in konfigurationer för loggning, spårning och mätvärden, som ibland kallas de grundläggande pelarna för observerbarhet. Mer information om integreringsobservabilitet och telemetri finns i översikten över .NET.NET Aspire integreringar. Beroende på säkerhetskopieringstjänsten kanske vissa integreringar bara stöder vissa av dessa funktioner. Vissa integreringar stöder till exempel loggning och spårning, men inte mått. Telemetrifunktioner kan också inaktiveras med hjälp av de tekniker som visas i avsnittet Configuration.

Skogsavverkning

Integreringen .NET AspireRedis distribuerad cachelagring använder följande loggkategorier:

  • Aspire.StackExchange.Redis
  • Microsoft.Extensions.Caching.StackExchangeRedis

Spårning

Integreringen av distribuerad cachelagring .NET AspireRedis genererar följande spårningsaktiviteter och använder OpenTelemetry:

  • OpenTelemetry.Instrumentation.StackExchangeRedis

Mått

Integreringen .NET AspireRedis distribuerad cachelagring stöder för närvarande inte mått som standard på grund av begränsningar i StackExchange.Redis-biblioteket.

Azure Redis värdintegrering

Om du vill distribuera dina Redis-resurser till Azure, installerar du 📦Aspire.Hosting.Azure.Redis NuGet-paketet:

dotnet add package Aspire.Hosting.Azure.Redis

Lägg till Azure Cache for Redisserver resurs

När du har installerat .NET Aspire som värd för AzureRedis-paketet anropar du AddAzureRedis-tilläggsmetoden i appvärdprojektet:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddAzureRedis("azcache")

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

Föregående anrop till AddAzureRedis konfigurerar Redisserver-resursen så att den distribueras som en Azure Cache for Redis.

Viktig

Som standard konfigurerar AddAzureRedisMicrosoft Entra-ID autentisering. Detta kräver ändringar i program som behöver ansluta till dessa resurser, till exempel client integreringar.

Lägg till Azure Cache for Redis distribuerade client

Som standard, när du anropar AddAzureRedis i din Redis värdintegration, konfigurerar den 📦 Microsoft.Azure.StackExchangeRedis NuGet-paket för att aktivera autentisering:

dotnet add package Microsoft.Azure.StackExchangeRedis

Den Redis anslutningen kan användas med hjälp av client-integreringen och Microsoft.Azure.StackExchangeRedis. Överväg följande konfigurationskod:

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

För mer information, se Microsoft.Azure.StackExchangeRedis repo.

Se även

*: Redis är ett registrerat varumärke som tillhör Redis Ltd. Alla rättigheter däri är reserverade för Redis Ltd. All användning av Microsoft är endast i referenssyfte och anger inte någon sponsring, bekräftelse eller anknytning mellan Redis och Microsoft. Återgå till?