Självstudie: Implementera cachelagring med .NET.NET Aspire-integreringar

Artikel
12/15/2024

Molnbaserade appar kräver ofta olika typer av skalbara cachelagringslösningar för att förbättra prestanda. .NET Aspire integreringar förenklar anslutningsprocessen till populära cachelagringstjänster, till exempel Redis. I den här artikeln får du lära dig att:

Skapa en grundläggande ASP.NET kärnapp som är konfigurerad att använda .NET Aspire.
Lägg till .NET Aspire integreringar för att ansluta till Redis och implementera cachelagring.
Konfigurera .NET.NET Aspire-integreringarna så att de uppfyller specifika krav.

I den här artikeln beskrivs hur du använder två olika typer av ASP.NET Core cachelagring med hjälp av .NET Aspire och Redis:

Cachelagring av utdata: En konfigurerbar, utökningsbar cachelagringsmetod för lagring av hela HTTP-svar för framtida begäranden.
Distribuerad cachelagring: En cache som delas av flera appservrar som gör att du kan cachelagra specifika datadelar. En distribuerad cache underhålls vanligtvis som en extern tjänst till de appservrar som har åtkomst till den och kan förbättra prestanda och skalbarhet för en ASP.NET Core app.

Förutsättningar

Om du vill arbeta med .NET.NET Aspirebehöver du följande installerat lokalt:

.NET 8,0 eller .NET 9,0
En OCI-kompatibel containerkörtid, till exempel:
- Docker Desktop eller Podman. Mer information finns i Container Runtime.
En IDE (Integrated Developer Environment) eller kodredigerare, till exempel:
- Visual Studio 2022 version 17.9 eller senare (valfritt)
- Visual Studio Code (valfritt)
  - C# Dev Kit: Tillägg (valfritt)
- JetBrains Rider med .NET.NET Aspire plugin (valfritt)

Mer information finns i .NET.NET Aspire installation och verktygoch .NET.NET Aspire SDK.

Skapa projektet

Överst i Visual Studionavigerar du till File>New>Project....
I dialogrutan anger du .NET Aspire i sökrutan för projektmallen och väljer .NET.NET Aspire Startprogram. Välj Nästa.
På skärmen Konfigurera ditt nya projekt:
- Ange ett projektnamn av AspireRedis.
- Låt värdenas rest vara som standard och välj Nästa.
På skärmen Ytterligare information:
- Kontrollera att .NET 9.0 är markerat.
- Avmarkera Använd Redis för cachelagring. Du implementerar din egen cachelagringskonfiguration.
- Välj Skapa.

Visual Studio skapar en ny .NET Aspire lösning som består av följande projekt:

AspireRedis.Web – ett Blazor UI-projekt med standardkonfigurationer för .NET Aspire.
AspireRedis.ApiService – Ett minimalt API med standardkonfigurationer för .NET.NET Aspire som tillhandahåller klientdelen med data.
AspireRedis.AppHost – ett orkestreringsprojekt som är utformat för att ansluta och konfigurera de olika projekten och tjänsterna i din app.
AspireRedis.ServiceDefaults – ett .NET.NET Aspire delat projekt för att hantera konfigurationer som återanvänds i projekten i din lösning som rör motståndskraft, tjänstidentifieringoch telemetri.

Konfigurera apphostingprojektet

Lägg till 📦Aspire.Hosting.Redis NuGet-paket till AspireRedis.AppHost-projektet:
- .NET CLI
- PackageReference
```
dotnet add package Aspire.Hosting.Redis
```
```
<PackageReference Include="Aspire.Hosting.Redis"
                  Version="*" />
```
För mer information, se dotnet add package eller Hantera paketberoenden i .NET applikationer.

Uppdatera Program.cs-filen för AspireRedis.AppHost-projektet så att den matchar följande kod:

var builder = DistributedApplication.CreateBuilder(args);

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

var apiservice = builder.AddProject<Projects.AspireRedis_ApiService>("apiservice")
    .WithReference(redis);

builder.AddProject<Projects.AspireRedis_Web>("webfrontend")
    .WithExternalHttpEndpoints()
    .WithReference(apiservice)
    .WithReference(redis);

builder.Build().Run();

Föregående kod skapar en lokal Redis containerinstans och konfigurerar användargränssnittet och API:et för att använda instansen automatiskt för både utdata och distribuerad cachelagring. Koden konfigurerar även kommunikation mellan klientdelsgränssnittet och serverdels-API:et med hjälp av tjänstidentifiering. Med .NET.NET Aspireimplicita tjänstidentifiering effektiviseras konfigurationen och hanteringen av tjänstanslutningar för utvecklares produktivitet. I den här självstudien förenklar funktionen det sätt på vilket du ansluter till Redis.

Traditionellt skulle du manuellt ange Redis anslutningssträngen i varje projekts appsettings.json-fil:

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

För att konfigurera anslutningssträngen med den här metoden, även om den fungerar, krävs duplicering av anslutningssträngen i flera projekt, vilket kan vara besvärligt och felbenäget.

Konfigurera användargränssnittet med cachelagring av utdata

Lägg till .NET Aspire Stack Exchange Redis cachelagring av utdata integrationspaket i din AspireRedis.Web-app:
```
dotnet add package Aspire.StackExchange.Redis.OutputCaching
```
Lägg till ett anrop till Program.cs-tilläggsmetoden direkt efter raden AspireRedis.Webi Blazor-filen i var builder = WebApplication.CreateBuilder(args);AddRedisOutputCache-projektet:
```
builder.AddRedisOutputCache("cache");
```
Den här metoden utför följande uppgifter:
- Konfigurerar cachelagring av ASP.NET Core utdata för att använda en Redis-instans med det angivna anslutningsnamnet.
- Aktiverar automatiskt motsvarande hälsokontroller, loggning och telemetri.
Ersätt innehållet i filen Home.razor i AspireRedis.WebprojektetBlazor med följande:
```
@page "/"
@attribute [OutputCache(Duration = 10)]

<PageTitle>Home</PageTitle>

<h1>Hello, world!</h1>

Welcome to your new app on @DateTime.Now
```
Integreringen omfattar attributet [OutputCache], som cachelagrar hela det renderade svaret. Sidan innehåller också ett anrop till @DateTime.Now för att kontrollera att svaret cachelagras.

Konfigurera API:et med distribuerad cachelagring

Lägg till .NET Aspire Stack Exchange Redis integreringspaket för distribuerad caching i din AspireRedis.ApiService-app:
```
dotnet add package Aspire.StackExchange.Redis.DistributedCaching
```
Överst i filen Program.cs lägger du till ett anrop till AddRedisDistributedCache:
```
builder.AddRedisDistributedCache("cache");
```

I filen Program.cs lägger du till följande using-instruktioner:

using System.Text;
using System.Text.Json;
using Microsoft.Extensions.Caching.Distributed;

I filen Program.cs ersätter du den befintliga /weatherforecast slutpunktskoden med följande:

app.MapGet("/weatherforecast", async (IDistributedCache cache) =>
{
    var cachedForecast = await cache.GetAsync("forecast");

    if (cachedForecast is null)
    {
        var summaries = new[] { "Freezing", "Bracing", "Chilly", "Cool", "Mild", "Warm", "Balmy", "Hot", "Sweltering", "Scorching" };
        var forecast = Enumerable.Range(1, 5).Select(index =>
        new WeatherForecast
        (
            DateOnly.FromDateTime(DateTime.Now.AddDays(index)),
            Random.Shared.Next(-20, 55),
            summaries[Random.Shared.Next(summaries.Length)]
        ))
        .ToArray();

        await cache.SetAsync("forecast", Encoding.UTF8.GetBytes(JsonSerializer.Serialize(forecast)), new ()
        {
            AbsoluteExpiration = DateTime.Now.AddSeconds(10)
        }); ;

        return forecast;
    }

    return JsonSerializer.Deserialize<IEnumerable<WeatherForecast>>(cachedForecast);
})
.WithName("GetWeatherForecast");

Testa appen lokalt

Testa appens cachelagringsbeteende med hjälp av följande steg:

Kör appen med Visual Studio genom att trycka på F5.
Om dialogrutan Starta Docker Desktop visas väljer du Ja för att starta tjänsten.
Instrumentpanelen .NET.NET Aspire laddas i webbläsaren och listar UI- och API-projekten.

Testa utdatacachen:

På projektsidan i webfrontend-raden klickar du på länken localhost i kolumnen Slutpunkter för att öppna appens användargränssnitt.
Programmet visar den aktuella tiden på startsidan.
Uppdatera webbläsaren med några sekunder för att se samma sida som returneras av cachelagring av utdata. Efter 10 sekunder upphör cacheminnet att gälla och sidan laddas om med en uppdaterad tid.

Testa den distribuerade cachen:

Gå till sidan Väder i användargränssnittet för Blazor för att läsa in en tabell med slumpmässiga väderdata.
Uppdatera webbläsaren med några sekunder för att se samma väderdata som returneras av cachelagring av utdata. Efter 10 sekunder upphör cacheminnet att gälla och sidan laddas om med uppdaterade väderdata.

Grattis! Du har konfigurerat en ASP.NET Core app för att använda utdata och distribuerad cachelagring med .NET Aspire.

Dela via