Använda en Redis-distribuerad cache

7 minuter

I en molnbaserad app skapar separata team mikrotjänster med önskad teknik enligt sina egna scheman. Mikrotjänsterna fungerar vanligtvis helt oberoende av varandra. De kan dra nytta av cachelagring, men om de kör separata cacheminnen kanske de inte kan uppnå den optimala prestandaförbättringen. Om du tillhandahåller en enda cache för flera mikrotjänster kan dessa tjänster hämta information från cacheminnet som har lagrats av en annan mikrotjänst.

Anta att du arbetar för en återförsäljare av utomhusutrustning. Du har bestämt dig för att implementera cachelagring med hjälp av en Redis-server i din kundvagnsmikrotjänst. Men du vill också se till att andra mikrotjänster kan dra nytta av den information du cachelagrar.

I den här lektionen får du lära dig hur en distribuerad Redis-cache kan optimera prestanda för flera mikrotjänster i din app. Du ser också hur .NET Aspire gör det enkelt att implementera en distribuerad cache.

Vad är distribuerad cachelagring?

En distribuerad cache är en cache som delas mellan flera anropande tjänster. I ett molnbaserat program är de anropande tjänsterna vanligtvis mikrotjänster. När du lagrar viss information, till exempel information om en populär produkt i katalogen, i den distribuerade cachen, kan alla mikrotjänster i din app potentiellt använda den och få ut av prestandaförbättringen.

Konfigurera distribuerad cachelagring i .NET Aspire

Om du vill använda distribuerad cachelagring krävs ändringar i både appvärdprojektet och de mikrotjänster som använder cachen.

Konfigurera appvärden

I lösningens programvärdprojekt börjar du med att installera värdkomponenten för distribuerad cachelagring:

dotnet add package Aspire.Hosting.Redis --prerelease

Du kan också använda genvägen Lägg till > .NET Aspire-komponent i Visual Studio för att installera komponenten från NuGet-pakethanteraren:

När värdkomponenten har installerats registrerar kod i appvärdens Program.cs-fil cachen och skickar den till projekt som använder cachen:

// Register the cache
var redis = builder.AddRedis("redis");

// Initiate the consuming project and pass the cache
builder.AddProject<Projects.ConsumingProject>()
       .WithReference(redis);

Konfigurera de förbrukande projekten

Om du vill installera komponenten .NET Aspire Distributed Cache i en mikrotjänst använder du ett kommando som det här i dina .NET Aspire-projekt:

dotnet add package Aspire.StackExchange.Redis.DistributedCache --prerelease

Du kan också välja att använda NuGet-pakethanteraren för att installera komponenten:

Använda en distribuerad cache

I alla projekt där du vill använda cacheminnet måste du hämta ett distribuerat cacheobjekt som representerar anslutningen till Redis. I filen Program.cs registrerar den här koden den distribuerade cachen:

builder.AddRedisDistributedCache("cache")

När cachen har registrerats i det förbrukande projektet kan du hämta den distribuerade cachen när du behöver den med hjälp av beroendeinmatning:

public class MyService(IDistributedCache cache)
{
   public async Task InitializeAsync()
   {
      // Check if there is cached content
      var cachedInfo = await cache.GetAsync("myinfo")

      if (cachedInfo is null)
      {
         // There's no content in the cache so formulate it here
         // For example, query databases.

        // Store the content in the cache
        await cache.SetAsync("myinfo", cachedInformation, new()
           { AbsoluteExpiration = DateTime.Now.AddSeconds(60) }
        );
      }
   }
}

Konfiguration

För att mikrotjänsterna ska kunna ansluta till redis-distribuerade cacheminnet måste du tala om för dem var det finns genom att ange en anslutningssträng. Ovanstående anrop till AddRedisDistributedCache() metoden angav en anslutningssträng med namnet redis.

Använd ett ConnectionStrings avsnitt i konfigurationsfilen, till exempel i appsettings.json, för att konfigurera anslutningssträng:

{
  "ConnectionStrings": {
    "redis": "redis.contoso.com:6379"
  }
}

Du kan också använda appsettings.json för att konfigurera beteendet för den distribuerade cachelagringskomponenten. Den här koden konfigurerar till exempel anslutningen till timeout efter fem sekunder och försöker igen tre gånger:

{
  "Aspire": {
    "StackExchange": {
      "Redis": {
        "ConfigurationOptions": {
          "ConnectTimeout": 5000,
          "ConnectRetry": 3
        }
      }
    }
  }
}

Du kan också konfigurera anslutningen med hjälp av infogade ombud för AddRedisDistributedCache() metoden. Den här koden konfigurerar samma egenskaper som föregående JSON-exempel:

builder.AddRedisDistributedCache(
   "redis",
   configureOptions: options => options.ConnectTimeout = 5000
);