Dela via

Aspire Redis®* integrering

Inkluderar:Värdintegrering ingår Värdintegrering &–& integrering ingår integration

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

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

Valkey är en Redis förgrening och uppfyller serialiseringsprotokolletRedis (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 AspireRedis kan du ansluta till befintliga Valkey-instanser eller skapa nya instanser från .NET med containeravbildningendocker.io/valkey/valkey.

Värdintegrering

Redis som är värd för integrering modellerar en Redis resurs som RedisResource typ. Om du vill komma åt den här typen och API:er för att representera dem som resurser i ditt AppHost-projekt lägger du till 📦Aspire.Hosting.Redis NuGet-paket:

dotnet add package Aspire.Hosting.Redis

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

Lägga till Redis resurs

I ditt AppHost-projekt anropar du AddRedis instansen builder 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 Aspire lägger till en containeravbildning i AppHost, som du ser i föregående exempel med avbildningen docker.io/Redis/Redis, skapas en ny instans av Redis på din lokala dator. 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 Insikter i resursen Redis anropar du WithRedisInsight metoden:

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. Aspire lägger till en annan containeravbildning docker.io/redis/redisinsight till AppHost som kör commander-appen.

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 WithRedisCommander metoden:

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. Aspire lägger till ytterligare en containerbild docker.io/rediscommander/redis-commander i AppHost som kör appen Commander.

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å /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 bindningsmonteringar finns i Docker dokument: 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

Databindningsmonteringar 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: Bindningsmonteringar.

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 en resurs av typen GarnetResource. För att komma åt den här typen och API:er som låter dig lägga till den i ditt 📦Aspire.Hosting.Garnet NuGet-paket i projektet AppHost.

dotnet add package Aspire.Hosting.Garnet

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

Lägg till Garnet-resurs

I ditt AppHost-projekt anropar du AddGarnet instansen builder 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 Aspire lägger till en containeravbildning i AppHost, som i det tidigare exemplet med avbildningen ghcr.io/microsoft/garnet, skapas en ny Garnet-instans på din lokala maskin. 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 en parameter name inte anges genereras namnet slumpmässigt. Mer information om datavolymer och information om varför de föredras framför bindningsmonteringar finns i Docker dokument: Volymer.

Lägg till Garnet-resurs med monterad databindningspunkt

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

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

Databindmonteringar förlitar sig på värddatorns filsystem för att bevara Garnet-data mellan containeromstarter. Databindningens inbindningspunkt monteras på platsen C:\Garnet\Data på Windows (eller /Garnet/Data på Unix) på värddatorn i Garnet-containern. Mer information om databindningsmonteringar finns i Docker dokument: Bindningsmonteringar.

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 ditt 📦Aspire.Hosting.Valkey NuGet-paket i AppHost-projektet.

dotnet add package Aspire.Hosting.Valkey

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

Lägg till Valkey-resurs

I ditt AppHost-projekt anropar du AddValkey instansen builder 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 Aspire lägger till en containeravbildning i AppHost, som visas i föregående exempel med avbildningen docker.io/valkey/valkey, skapar det 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. 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 information om varför de föredras framför bindningsmonteringar finns i Docker dokument: Volymer.

Lägg till Valkey-resurs med databindningsfäste

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

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

Databindmonteringar förlitar sig på värddatorns filsystem för att bevara Valkey-data mellan återstarter av containrar. Data bind mounten monteras på sökvägen C:\Valkey\Data i Windows (eller /Valkey/Data på Unix) på värddatorn i Valkey-containern. Mer information om databindningsmonteringar finns i Docker dokument: Bindningsmonteringar.

Lägg 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ärdtjänstintegration

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

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

Använda med icke-program.NET

Värdintegrering Redis kan användas med alla programteknik, inte bara .NET program. När du använder WithReference för att referera till en Redis resurs matas anslutningsinformation automatiskt in som miljövariabler i det refererande programmet.

För program som inte använder klientintegrering kan du komma åt anslutningsinformationen via miljövariabler. Här är ett exempel på hur du konfigurerar miljövariabler för ett icke-program.NET :

var builder = DistributedApplication.CreateBuilder(args);

var redis = builder.AddRedis("cache")
    .WithLifetime(ContainerLifetime.Persistent);

// Example: Configure a non-.NET application with Redis access  
var app = builder.AddExecutable("my-app", "python", "app.py", ".")
    .WithReference(redis) // Provides ConnectionStrings__cache
    .WithEnvironment(context =>
    {
        // Additional individual connection details as environment variables
        context.EnvironmentVariables["REDIS_HOST"] = redis.Resource.PrimaryEndpoint.Property(EndpointProperty.Host);
        context.EnvironmentVariables["REDIS_PORT"] = redis.Resource.PrimaryEndpoint.Property(EndpointProperty.Port);
    });

builder.Build().Run();

var builder = DistributedApplication.CreateBuilder(args);

var garnet = builder.AddGarnet("cache")
    .WithLifetime(ContainerLifetime.Persistent);

// Example: Configure a non-.NET application with Garnet access  
var app = builder.AddExecutable("my-app", "python", "app.py", ".")
    .WithReference(garnet) // Provides ConnectionStrings__cache
    .WithEnvironment(context =>
    {
        // Additional individual connection details as environment variables
        context.EnvironmentVariables["REDIS_HOST"] = garnet.Resource.PrimaryEndpoint.Property(EndpointProperty.Host);
        context.EnvironmentVariables["REDIS_PORT"] = garnet.Resource.PrimaryEndpoint.Property(EndpointProperty.Port);
    });

builder.Build().Run();

var builder = DistributedApplication.CreateBuilder(args);

var valkey = builder.AddValkey("cache")
    .WithLifetime(ContainerLifetime.Persistent);

// Example: Configure a non-.NET application with Valkey access  
var app = builder.AddExecutable("my-app", "python", "app.py", ".")
    .WithReference(valkey) // Provides ConnectionStrings__cache
    .WithEnvironment(context =>
    {
        // Additional individual connection details as environment variables
        context.EnvironmentVariables["REDIS_HOST"] = valkey.Resource.PrimaryEndpoint.Property(EndpointProperty.Host);
        context.EnvironmentVariables["REDIS_PORT"] = valkey.Resource.PrimaryEndpoint.Property(EndpointProperty.Port);
    });

builder.Build().Run();

Den här konfigurationen ger icke-programmet.NET flera miljövariabler:

  • ConnectionStrings__cache: Den fullständiga anslutningssträngen för Redis/Garnet/Valkey
  • REDIS_HOST: Serverns värdnamn/IP-adress
  • REDIS_PORT: Portnumret som servern lyssnar på

Ditt icke-program.NET kan sedan läsa dessa miljövariabler för att ansluta till cachen med hjälp av lämpligt Redis klientbibliotek för den tekniken (till exempel redis-py för Python, redis för Node.jseller go-redis för Go).

Client integrering

Kom igång med Aspire Stack Exchange-klientintegrering Redis genom att 📦Aspireinstallera . StackExchange.Redis NuGet-paketet i det klientkrävande projektet, dvs. projektet för det program som använder Redis klienten. Klientintegrering Redis registrerar en IConnectionMultiplexer-instans som du kan använda för att interagera med Redis.

dotnet add package Aspire.StackExchange.Redis

Lägg till Redis klient

I Program.cs-filen för ditt klientförbrukande projekt anropar du AddRedisClient-tilläggsmetoden på alla IHostApplicationBuilder för att registrera en IConnectionMultiplexer för användning via beroendehanteringscontainern. Metoden tar en parameter för anslutningsnamn.

builder.AddRedisClient(connectionName: "cache");

Tips

Parametern connectionName måste matcha det namn som används när du lägger till resursen Redis i AppHost-projektet. 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 AppHost-projektet. 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 AppHost-projektet. Mer information finns i Lägg till Valkey-resurs.

Du kan sedan hämta IConnection-instansen genom 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 kodad Redis-klient

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-instanserna 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 beroendeinmatning: Nyckelade tjänster.

Konfiguration

Klientintegrering Aspire Stack Exchange Redis innehåller flera alternativ för att konfigurera Redis-anslutningen baserat på kraven och konventionerna i ditt projekt.

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

Använda konfigurationsprovidrar

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": {
        "ConfigurationOptions": {
          "ConnectTimeout": 3000,
          "ConnectRetry": 2
        },
        "DisableHealthChecks": true,
        "DisableTracing": false
      }
    }
  }
}

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

Använda namngiven konfiguration

Stack Exchange-integreringen AspireRedis stöder namngiven konfiguration, vilket gör att du kan konfigurera flera instanser av samma resurstyp med olika inställningar. Den namngivna konfigurationen använder anslutningsnamnet som en nyckel under huvudkonfigurationsavsnittet.

{
  "Aspire": {
    "StackExchange": {
      "Redis": {
        "cache1": {
          "ConfigurationOptions": {
            "ConnectTimeout": 3000,
            "ConnectRetry": 2
          },
          "DisableHealthChecks": true
        },
        "cache2": {
          "ConfigurationOptions": {
            "ConnectTimeout": 5000,
            "ConnectRetry": 3
          },
          "DisableTracing": true
        }
      }
    }
  }
}

I det här exemplet kan anslutningsnamnen cache1 och cache2 användas när du anropar AddKeyedRedisClient:

builder.AddKeyedRedisClient("cache1");
builder.AddKeyedRedisClient("cache2");

Den namngivna konfigurationen har företräde framför konfigurationen på den översta nivån. Om båda anges åsidosätter inställningarna från den namngivna konfigurationen inställningarna på den översta nivån.

Använd inline-delegater

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 Aspire har klientintegreringarhälsokontroller aktiverade för alla tjänster. På samma sätt möjliggör många Aspirehostingintegrationer även hälsokontrolländpunkter. Mer information finns i:

Integreringen 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 den /health HTTP-slutpunkt som anger att alla registrerade hälsokontroller måste godkännas för att appen ska anses redo att ta emot trafik.

Observerbarhet och telemetri

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 Aspire översikten över 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 Konfiguration .

Skogsavverkning

Integreringen Aspire Stack Exchange Redis använder följande loggkategorier:

  • Aspire.StackExchange.Redis

Spårning

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

  • OpenTelemetry.Instrumentation.StackExchangeRedis

Mått

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

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. Vill du gå tillbaka till toppen?