Kurz: Implementace ukládání do mezipaměti pomocí integrace .NET.NET Aspire

Článek
12/12/2024

Aplikace nativní pro cloud často vyžadují různé typy škálovatelných řešení ukládání do mezipaměti, aby se zlepšil výkon. integrace .NET Aspire zjednodušují proces připojování k oblíbeným službám ukládání do mezipaměti, jako je Redis. V tomto článku se dozvíte, jak:

Vytvořte základní aplikaci ASP.NET, která je nastavená tak, aby používala .NET Aspire.
Přidejte integrace .NET Aspire pro připojení k Redis a implementujte ukládání do mezipaměti.
Nakonfigurujte integrace .NET.NET Aspire tak, aby splňovaly konkrétní požadavky.

Tento článek popisuje, jak používat dva různé typy ASP.NET Core ukládání do mezipaměti pomocí .NET Aspire a Redis:

ukládání výstupu do mezipaměti: Konfigurovatelná, rozšiřitelná metoda ukládání do mezipaměti pro ukládání celých odpovědí HTTP pro budoucí požadavky.
Distribuované ukládání do mezipaměti: Mezipaměť sdílená více aplikačními servery, která umožňuje ukládat určité části dat do mezipaměti. Distribuovaná mezipaměť se obvykle udržuje jako externí služba pro aplikační servery, které k ní přistupují, a může zlepšit výkon a škálovatelnost aplikace ASP.NET Core.

Požadavky

Pokud chcete pracovat s .NET.NET Aspire, potřebujete místně nainstalovat následující:

.NET 8.0 nebo .NET 9.0
Modul runtime kontejneru kompatibilní s OCI, například:
- Docker Desktop nebo Podman. Další informace najdete v tématu běhové prostředí kontejneru.
Integrované vývojové prostředí (IDE) nebo editor kódu, například:
- Visual Studio 2022 verze 17.9 nebo novější (volitelné)
- Visual Studio Code (volitelné)
  - C# Dev Kit: Rozšíření (volitelné)
- JetBrains Rider s .NET.NET Aspire pluginem (volitelné)

Další informace najdete v tématu .NET.NET Aspire nastavení a nástrojea .NET.NET Aspire SDK.

Vytvoření projektu

V horní části Visual Studiopřejděte na Soubor>Nový projekt>....
V dialogovém okně zadejte .NET Aspire do vyhledávacího pole šablony projektu a vyberte .NET.NET Aspire Startovací aplikace. Zvolte Další.
Na obrazovce Konfigurujte nový projekt:
- Zadejte název projektu AspireRedis .
- Ponechte rest hodnot ve výchozím nastavení a vyberte Další.
Na obrazovce Další informace:
- Ujistěte se, že je vybraná .NET 9.0.
- Zrušte zaškrtnutí Použít Redis pro ukládání do mezipaměti. Implementujete vlastní nastavení ukládání do mezipaměti.
- Vyberte Vytvořit.

Visual Studio vytvoří nové .NET Aspire řešení, které se skládá z následujících projektů:

AspireRedis.Web – projekt uživatelského rozhraní Blazor s výchozími konfiguracemi .NET Aspire.
AspireRedis.ApiService – minimální API s výchozími konfiguracemi .NET.NET Aspire, které poskytuje data frontendu.
AspireRedis.AppHost – projekt orchestrátoru navržený pro připojení a konfiguraci různých projektů a služeb vaší aplikace.
AspireRedis.ServiceDefaults – sdílený projekt .NET.NET Aspire ke správě konfigurací, které se znovu používají napříč projekty ve vašem řešení související s odolností, zjišťování služby a telemetrií.

Konfigurace projektu Hostitele aplikace

Přidejte 📦Aspire.Hostování.Redis balíček NuGet do projektu AspireRedis.AppHost.
- .NET rozhraní příkazového řádku
- PackageReference
```
dotnet add package Aspire.Hosting.Redis
```
```
<PackageReference Include="Aspire.Hosting.Redis"
                  Version="*" />
```
Další informace najdete v tématech dotnet add package nebo Správa závislostí balíčků v aplikacích .NET.

Aktualizujte soubor Program.cs projektu AspireRedis.AppHost tak, aby odpovídal následujícímu kódu:

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();

Předchozí kód vytvoří místní instanci kontejneru Redis a nakonfiguruje uživatelské rozhraní a rozhraní API tak, aby používalo instanci automaticky pro výstupní i distribuované ukládání do mezipaměti. Kód také konfiguruje komunikaci mezi front-endovým uživatelským rozhraním a back-endovým rozhraním API pomocí zjišťování služeb. Díky implicitní zjišťování služby .NET.NET Aspireje nastavení a správa připojení služeb zjednodušená pro produktivitu vývojářů. V kontextu tohoto kurzu tato funkce zjednodušuje připojení k Redis.

Tradičně byste ručně zadali připojovací řetězec Redis v souboru appsettings.json každého projektu:

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

Konfigurace připojovacího řetězce s touto metodou, zatímco funkční, vyžaduje duplikování připojovacího řetězce napříč více projekty, což může být náročné a náchylné k chybám.

Konfigurace uživatelského rozhraní s ukládáním výstupu do mezipaměti

Přidejte do aplikace ukládání výstupu do mezipaměti integrační balíčky Stack Exchange:
```
dotnet add package Aspire.StackExchange.Redis.OutputCaching
```
V Program.cs souboru projektu AspireRedis.WebBlazor bezprostředně za řádek var builder = WebApplication.CreateBuilder(args);přidejte volání metody rozšíření AddRedisOutputCache:
```
builder.AddRedisOutputCache("cache");
```
Tato metoda provádí následující úlohy:
- Nakonfiguruje ukládání výstupu v mezipaměti ASP.NET Core tak, aby používalo instanci Redis se zadaným názvem připojení.
- Automaticky povolí odpovídající kontroly stavu, protokolování a telemetrii.
Obsah souboru Home.razor projektu AspireRedis.WebBlazor nahraďte následujícím kódem:
```
@page "/"
@attribute [OutputCache(Duration = 10)]

<PageTitle>Home</PageTitle>

<h1>Hello, world!</h1>

Welcome to your new app on @DateTime.Now
```
Součástí integrace je atribut [OutputCache], který ukládá celou vykreslenou odpověď do mezipaměti. Stránka také obsahuje volání @DateTime.Now, které vám pomůže ověřit, že odpověď je uložená v mezipaměti.

Konfigurace rozhraní API s distribuovaným ukládáním do mezipaměti

Přidejte do aplikace distribuované ukládání do mezipaměti integrační balíčky Stack Exchange:
```
dotnet add package Aspire.StackExchange.Redis.DistributedCaching
```
Do horní části souboru Program.cs přidejte volání na AddRedisDistributedCache:
```
builder.AddRedisDistributedCache("cache");
```

Do souboru Program.cs přidejte následující příkazy using:

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

V souboru Program.cs nahraďte stávající kód koncového bodu /weatherforecast následujícím kódem:

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");

Místní testování aplikace

Otestujte chování aplikace při ukládání do mezipaměti pomocí následujícího postupu:

Spusťte aplikaci pomocí Visual Studio stisknutím klávesy F5.
Pokud se zobrazí dialogové okno Start Docker Desktop, výběrem Ano spusťte službu.
Řídicí panel .NET.NET Aspire se načte v prohlížeči a zobrazí seznam projektů uživatelského rozhraní a rozhraní API.

Otestujte výstupní mezipaměť:

Na stránce projektů v řádku webfrontend klikněte na odkaz localhost ve sloupci Koncové body, čímž se otevře uživatelské rozhraní vaší aplikace.
Aplikace zobrazí aktuální čas na domovské stránce.
Aktualizujte prohlížeč každých několik sekund, aby se zobrazila stejná stránka vrácená ukládáním výstupu do mezipaměti. Po 10 sekundách vyprší platnost mezipaměti a stránka se znovu načte s aktualizovaným časem.

Otestujte distribuovanou mezipaměť:

Přejděte na stránku Počasí v uživatelském rozhraní Blazor a načtěte tabulku náhodných dat o počasí.
Aktualizujte prohlížeč každých několik sekund, abyste viděli stejná data o počasí vrácená ukládáním výstupu do mezipaměti. Po 10 sekundách vyprší platnost mezipaměti a stránka se znovu načte s aktualizovanými daty o počasí.

Blahopřejeme! Nakonfigurovali jste aplikaci ASP.NET Core tak, aby používala výstup a distribuované ukládání do mezipaměti s .NET Aspire.

Sdílet prostřednictvím