Dela via

.NET Aspire Redis®* integrering

  • Artikel

omfattar:Hosting-integrering och integration av Client

Redis är världens snabbaste dataplattform för cachelagring, vektorsökning och NoSQL-databaser. Med integreringen .NET AspireRedis kan du ansluta till befintliga Redis-instanser eller skapa nya instanser från .NET med docker.io/library/redis containeravbildningen.

Garnet är ett cachelager med höga prestanda från Microsoft Research och uppfyller Redis serialiseringsprotokollet (RESP). Med integreringen .NET AspireRedis kan du ansluta till befintliga Garnet-instanser eller skapa nya instanser från .NET med ghcr.io/microsoft/garnet containeravbildningen.

Valkey är en Redis förgrening och uppfyller Redis serialiseringsprotokollet (RESP). Det är ett nyckel-/värdedatalager med höga prestanda som stöder en mängd olika arbetsbelastningar, till exempel cachelagring, meddelandeköer och kan fungera som en primär databas. Med integreringen .NET AspireRedis kan du ansluta till befintliga Valkey-instanser eller skapa nya instanser från .NET med docker.io/valkey/valkey containeravbildningen.

Värdintegrering

Redis som är värd för integrering 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 ditt 📦Aspire.Hosting.Redis NuGet-paket i appvärd projekt.

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

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ägg 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 kommandoappen.

Notis

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 värden för appen som kör kommandorappen.

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. För mer information om datavolymer och varför de föredras framför bindningsmonteringar, se Docker dokumentationen: Volymer.

Lägg till Redis resurs med montering för databindning

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.

Databindningsmonteringar förlitar sig på värddatorns filsystem för att bevara Redis data mellan omstarter av containrar. Databindning är monterad vid sökväg C:\Redis\Data på Windows (eller /Redis/Data på Unix) på värddatorn i containern Redis. Mer information om databindningsmonteringar finns i Docker dokument: Bind monteringar.

Lägg till Redis-resurs med beständighet

Om du vill lägga till beständighet för resursen Redis, anropar du metoden WithPersistence, antingen med en datavolym eller en 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.

Garnet-integrationen 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 den i ditt 📦Aspire.Hosting.Garnet NuGet-paket i värdappen projektet.

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 containerbild till applikationsvärden, som visas i föregående exempel med ghcr.io/microsoft/garnet-bilden, skapar den en ny Garnet-instans på den lokala datorn. 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-behållaren och när parameter name inte anges genereras namnet slumpmässigt. Mer information om datavolymer och varför de föredras framför bindmonteringarfinns i Docker dokumentation: 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 bindmonteringar för data finns i dokumentationen Docker: 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-hostingintegration modellerar en Valkey-resurs som typen ValkeyResource. 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. Host.Valkey NuGet-paketet i appvärd projektet.

dotnet add package Aspire.Hosting.Valkey

Mer information finns i 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 för appvärden, som visas i föregående exempel med docker.io/valkey/valkey-bilden, skapar den en ny Valkey-instans på din lokala maskin. 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. Datavolym monteras på /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 bind mountsfinns i dokumentationen Docker: Volymer.

Lägga till Valkey-resurs med databindningsmontering

Om du vill lägga till en data bind mount 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.

Databindningsmonteringar förlitar sig på värddatorns filsystem för att bevara Valkey-data mellan 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. Mer information om databindningsfästen finns i Docker dokumentation: Bindningsfästen.

Lägga till Valkey-resurs med beständighet

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.

Hälsokontroller för värdintegrering

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

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

Client integrering

Om du vill komma igång med .NET Aspire Stack Exchange Redisclient-integreringen, installerar du 📦Aspire.StackExchange.Redis NuGet-paketet i det client-användande projektet, dvs. projektet för programmet som använder Redisclient. Redis client-integreringen registrerar en IConnectionMultiplexer instans som du kan använda för att interagera med Redis.

dotnet add package Aspire.StackExchange.Redis

Lägg till Redisclient

I den Program.cs-filen i ditt projekt som använder clientanropar du tilläggsmetoden AddRedisClient på alla IHostApplicationBuilder för att registrera en IConnectionMultiplexer för användning via beroendeinsprutningsbehållaren. Metoden tar en parameter för anslutningsnamn.

builder.AddRedisClient(connectionName: "cache");

Tips

Parametern connectionName måste matcha namnet som användes när resursen Redis lades till i värdprojektet för appen. Mer information finns i 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. Mer information finns i Lägg till Valkey-resurs.

Du kan sedan hämta IConnection-instansen med hjälp av beroendeinjektion. Om du till exempel vill hämta anslutningen från en exempeltjänst:

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

Mer information om beroendeinmatning finns i .NET beroendeinmatning.

Lägg till nycklade Redisclient

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

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

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

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

Mer information om nyckelade tjänster finns i .NET beroendeinjektion: Nyckelade tjänster.

Konfiguration

Integreringen .NET Aspire Stack Exchange Redisclient innehåller flera alternativ för att konfigurera Redis-anslutningen baserat på kraven och konventionerna i projektet.

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 AddRedis:

builder.AddRedis("cache");

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

builder.AddGarnet("cache");

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

builder.AddValkey("cache");

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-integration stöder Microsoft.Extensions.Configuration. Den läser in StackExchangeRedisSettings från konfigurationen med hjälp av nyckeln Aspire:StackExchange:Redis. 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 inlinedelegater

Du kan också skicka Action<StackExchangeRedisSettings>-delegaten för att ställa in vissa eller alla alternativ direkt, till exempel för att konfigurera DisableTracing:

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

Client hälsokontroller för integrering

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 Aspire Stack Exchange Redis hanterar följande:

  • Lägger till en hälsokontroll då StackExchangeRedisSettings.DisableHealthChecks är false, vilket försöker ansluta till containerinstansen.
  • Integrerar med /health HTTP-slutpunkt, som anger att samtliga registrerade hälsokontroller måste godkännas för att appen ska anses vara redo att acceptera trafik.

Observerbarhet och telemetri

.NET .NET Aspire integreringar konfigurerar automatiskt konfigurationer för loggning, spårning och mått, som ibland kallas grundpelarna 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 Aspire Stack Exchange Redis använder följande loggkategorier:

  • Aspire.StackExchange.Redis

Spårning

Integreringen .NET Aspire Stack Exchange Redis genererar följande spårningsaktiviteter med hjälp av OpenTelemetry:

  • OpenTelemetry.Instrumentation.StackExchangeRedis

Mått

Integreringen .NET Aspire Stack Exchange Redis stöder för närvarande inte mått som standard på grund av begränsningar med StackExchange.Redis-biblioteket.

Azure Redis värdtjänstintegrering

Om du vill distribuera dina Redis resurser till Azureinstallerar du 📦Aspire.Hosting.Azure.Redis NuGet-paket:

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 resurs för att 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 Redisclient

När du anropar AddAzureRedis i din Redis värdintegrering konfigureras som standard 📦 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.AddRedisClient("cache", configureOptions: options =>
{
    options.Defaults = configurationOptions.Defaults;
});

Mer information finns i 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?