Aspire Azure Cache for Redis®^* integrering

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

Azure Cache for Redis tillhandahåller ett minnesinternt datalager baserat på Redis programvara. Redis förbättrar prestanda och skalbarhet för ett program som använder serverdelsdatalager kraftigt. Den kan bearbeta stora mängder programbegäranden genom att lagra data som används ofta i serverminnet, som kan skrivas till och läsas från snabbt. Redis ger en viktig datalagringslösning med låg svarstid och datalagring med högt dataflöde till moderna program.

Azure Cache for Redis erbjuder både Redis öppen källkod (OSS Redis) och en kommersiell produkt från Redis Inc. (Redis Enterprise) som en hanterad tjänst. Tillhandahåller säkra och dedikerade Redis-serverinstanser och fullständig Redis API-kompatibilitet. Microsoft driver tjänsten, som finns på Azureoch kan användas av alla program inom eller utanför Azure.

Med AspireAzure Cache for Redis integrering kan du ansluta till befintliga Azure Cache for Redis-instanser eller skapa nya instanser eller köra som en container lokalt från .NET med docker.io/library/redis containeravbildningen.

Värdintegrering

Integreringslösningen för AspireAzure Cache for Redis modellerar en AzureRedis resurs som typen AzureRedisCacheResource. Om du vill komma åt den här typen och API:er för att uttrycka dem som resurser i ditt AppHost-projekt lägger du till 📦Aspire. Hosting.Azure.Redis NuGet-paket:

dotnet add package Aspire.Hosting.Azure.Redis

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

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

Lägg till AzureAzure Cache for Redis resurs

I ditt AppHost-projekt anropar du AddAzureRedis instansen builder för att lägga till en AzureAzure Cache for Redis resurs, som du ser i följande exempel:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddAzureRedis("azcache");

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

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

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

Ansluta till en befintlig AzureAzure Cache for Redis

Du kanske har en befintlig AzureAzure Cache for Redis resurs som du vill ansluta till. Du kan kedja en anropning för att annotera att din AzureRedisCacheResource är en befintlig resurs:

var builder = DistributedApplication.CreateBuilder(args);

var existingRedisName = builder.AddParameter("existingRedisName");
var existingRedisResourceGroup = builder.AddParameter("existingRedisResourceGroup");

var cache = builder.AddAzureRedis("azcache")
                   .AsExisting(existingRedisName, existingRedisResourceGroup);

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

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

Mer information om hur du behandlar AzureAzure Cache for Redis resurser som befintliga resurser finns i Använd befintliga Azure resurser.

Kör AzureAzure Cache for Redis resurs som en container

Den Azure Cache for Redis värdintegrering stöder körning av Redis-servern som en lokal container. Detta är fördelaktigt för situationer där du vill köra Redis-servern lokalt i utvecklings- och testsyfte, så att du inte behöver etablera en Azure resurs eller ansluta till en befintlig Azure Cache for Redis server.

Om du vill använda docker.io/library/redis containeravbildningen och köra AzureAzure Cache for Redis-instansen som en container lokalt, kedjar du ett anrop till RunAsContainer, som du ser i följande exempel:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddAzureRedis("azcache")
                   .RunAsContainer();

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

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

Föregående kod konfigurerar den Redis resursen så att den körs lokalt i en container.

Konfigurera den AzureAzure Cache for Redis resursen för att använda åtkomstnyckelautentisering

Som standard är den AzureAzure Cache for Redis resursen konfigurerad för att använda Microsoft Entra-ID autentisering. Om du vill använda lösenordsautentisering (rekommenderas inte) kan du konfigurera servern att använda lösenordsautentisering genom att anropa metoden WithAccessKeyAuthentication:

var builder = DistributedApplication.CreateBuilder(args);

var cache = builder.AddAzureRedis("azcache")
                   .WithAccessKeyAuthentication();

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

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

Föregående kod konfigurerar AzureAzure Cache for Redis resursen för att använda åtkomstnyckelautentisering. Detta ändrar den genererade Bicep för att använda åtkomstnyckelautentisering i stället för Microsoft Entra-ID-autentisering. Med andra ord innehåller anslutningssträngen ett lösenord och kommer att läggas till som en Azure Key Vault-hemlighet.

Konfigurationsgenererad Bicep

Om du är ny på Bicepär det ett domänspecifikt språk för att definiera Azure resurser. Med Aspirebehöver du inte skriva Bicep för hand, i stället genererar etablerings-API:erna Bicep åt dig. När du publicerar din app genereras den genererade Bicep tillsammans med manifestfilen. När du lägger till en AzureAzure Cache for Redis resurs genereras följande Bicep:

@description('The location for the resource(s) to be deployed.')
param location string = resourceGroup().location

resource redis 'Microsoft.Cache/redis@2024-11-01' = {
  name: take('redis-${uniqueString(resourceGroup().id)}', 63)
  location: location
  properties: {
    sku: {
      name: 'Basic'
      family: 'C'
      capacity: 1
    }
    enableNonSslPort: false
    disableAccessKeyAuthentication: true
    minimumTlsVersion: '1.2'
    redisConfiguration: {
      'aad-enabled': 'true'
    }
  }
  tags: {
    'aspire-resource-name': 'redis'
  }
}

output connectionString string = '${redis.properties.hostName},ssl=true'

output name string = redis.name

Föregående Bicep är en modul som provisionerar en AzureAzure Cache for Redis resurs. Dessutom skapas rolltilldelningar för resursen Azure i en separat modul:

@description('The location for the resource(s) to be deployed.')
param location string = resourceGroup().location

param redis_outputs_name string

param principalId string

param principalName string

resource redis 'Microsoft.Cache/redis@2024-11-01' existing = {
  name: redis_outputs_name
}

resource redis_contributor 'Microsoft.Cache/redis/accessPolicyAssignments@2024-11-01' = {
  name: guid(redis.id, principalId, 'Data Contributor')
  properties: {
    accessPolicyName: 'Data Contributor'
    objectId: principalId
    objectIdAlias: principalName
  }
  parent: redis
}

Förutom AzureAzure Cache for Redisskapar den även en tilldelning av åtkomstprinciper för programmets åtkomst till cache. Den genererade Bicep är en startpunkt och påverkas av ändringar i tillhandahållandeinfrastrukturen i C#. Anpassningar till Bicep-filen skrivs över direkt, så gör ändringar via C#-etablerings-API:erna för att säkerställa att de återspeglas i de genererade filerna.

Anpassa försörjningsinfrastruktur

Alla AspireAzure resurser är underklasser av den AzureProvisioningResource typen. Den här typen möjliggör anpassning av den genererade Bicep genom att tillhandahålla ett smidigt API för att konfigurera resurserna Azure med hjälp av API:et ConfigureInfrastructure<T>(IResourceBuilder<T>, Action<AzureResourceInfrastructure>). Du kan till exempel konfigurera kind, consistencyPolicy, locationsoch mycket mer. I följande exempel visas hur du anpassar AzureAzure Cache for Redis resursen:

builder.AddAzureRedis("redis")
    .WithAccessKeyAuthentication()
    .ConfigureInfrastructure(infra =>
    {
        var redis = infra.GetProvisionableResources()
                         .OfType<RedisResource>()
                         .Single();

        redis.Sku = new()
        {
            Family = RedisSkuFamily.BasicOrStandard,
            Name = RedisSkuName.Standard,
            Capacity = 1,                    
        };
        redis.Tags.Add("ExampleKey", "Example value");
    });

Föregående kod:

• Kedjar ett anrop till ConfigureInfrastructure-API:et:
  • Parametern infra är en instans av den AzureResourceInfrastructure typen.
  • De resurser som kan tillhandahållas hämtas genom att anropa metoden GetProvisionableResources().
  • Den enskilda RedisResource hämtas.
  • Sku anges med en familj med BasicOrStandard, ett namn på Standardoch en kapacitet på 1.
  • En tagg läggs till i den Redis resursen med nyckeln ExampleKey och värdet Example value.

Det finns många fler konfigurationsalternativ för att anpassa AzureAzure Cache for Redis resursen. Mer information finns i Azure.Provisioning.Redis. Mer information finns i Azure. Anpassning av tillhandahållande.

Client integrering

Kom igång med Aspire Stack Exchange Redis-klientintegrering genom att installera 📦Aspire. StackExchange.Redis NuGet-paket i det klientkrävande projektet, d.v.s. projektet för programmet 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

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

Lägg till Redis klient

I Program.cs-filen för ditt projekt som använder klient, anropa AddRedisClient-tilläggsmetoden på varje IHostApplicationBuilder för att registrera en IConnectionMultiplexer för användning via beroendeinjektionscontainern. Metoden tar en parameter för anslutningsnamn.

builder.AddRedisClient(connectionName: "cache");

Då kan du hämta upp IConnectionMultiplexer-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 AzureAzure Cache for Redis autentiserad klient

När du anropar AddAzureRedis i ditt AppHost-projekt, konfigureras som standard Microsoft Entra ID av Redis värdtjänstintegration. Om du vill aktivera autentisering i klientprogrammet lägger du till en referens till Aspire.Microsoft.Azure.StackExchangeRedis paketet och använder följande kod:

builder.AddRedisClientBuilder("cache")
       .WithAzureAuthentication();

Den här förenklade metoden konfigurerar Redis automatiskt klienten att använda Azure autentisering med lämpliga autentiseringsuppgifter.

Lägg till en nycklad 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-instanser 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...
}

För mer information om nyckeltjänster, se .NET beroendeinjektion: nyckeltjä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");

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

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": {
        "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 inbyggda delegater

Du kan också överföra Action<StackExchangeRedisSettings>-delegaten för att konfigurera 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:

• .NET app-hälsokontroller i C#
• Hälsokontroller i ASP.NET Core

Integreringen Aspire Stack Exchange Redis hanterar följande:

• Lägger till hälsokontrollen när StackExchangeRedisSettings.DisableHealthChecks är false, och försöker ansluta till containerinstansen.
• Integrerar med den /health HTTP-ändpunkt, som anger att alla registrerade hälsokontroller måste klaras för att appen ska anses vara redo att acceptera 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 Configuration.

Loggning / 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

• Azure Azure Cache for Redis dokument
• Stack Exchange Redis dokumentation
• Aspire Integrationer
• Aspire GitHub Repo

*: 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?