Esercitazione: Implementare la memorizzazione nella cache con integrazioni di .NET.NET Aspire

Articolo
12/14/2024

Le app native del cloud spesso richiedono vari tipi di soluzioni di memorizzazione nella cache scalabili per migliorare le prestazioni. .NET Aspire le integrazioni semplificano il processo di connessione ai servizi di cache più diffusi, come Redis. In questo articolo si apprenderà come:

Creare un'applicazione di base ASP.NET core impostata per utilizzare .NET Aspire.
Aggiungere .NET Aspire integrazioni per connettersi a Redis e implementare la memorizzazione nella cache.
Configurare le integrazioni .NET.NET Aspire per soddisfare requisiti specifici.

Questo articolo spiega come usare due diversi tipi di caching di ASP.NET Core usando .NET Aspire e Redis:

memorizzazione nella cache dell'output: metodo configurabile ed estendibile di memorizzazione nella cache per l'archiviazione di intere risposte HTTP per le richieste future.
cache distribuita: cache condivisa da più server app che consente di memorizzare nella cache parti di dati specifiche. Una cache distribuita viene in genere gestita come servizio esterno ai server app che vi accedono e può migliorare le prestazioni e la scalabilità di un'app ASP.NET Core.

Prerequisiti

Per usare .NET.NET Aspire, è necessario che il codice seguente sia installato in locale:

.NET 8.0 o .NET 9.0
Un runtime conforme a OCI per contenitori, ad esempio:
- Docker Desktop o Podman. Per altre informazioni, vedere Runtime del container.
Un ambiente di sviluppo integrato (IDE) o un editor di codice, ad esempio:
- Visual Studio 2022 versione 17.9 o successiva (opzionale)
- Visual Studio Code (facoltativo)
  - C# Dev Kit: Estensione (facoltativo)
- JetBrains Rider con il plug-in .NET.NET Aspire (facoltativo)

Per altre informazioni, vedere .NET.NET Aspire configurazione e strumentie .NET.NET Aspire SDK.

Creare il progetto

Nella parte superiore di Visual Studio, passare a File>Nuovo Progetto>....
Nella finestra di dialogo immettere .NET Aspire nella casella di ricerca del modello di progetto e selezionare .NET.NET Aspire Applicazione Iniziale. Scegliere Avanti.
Nella schermata Configura il tuo nuovo progetto:
- Immettere un nome di progetto di Aspiraredis.
- Lasciare i valori di rest ai predefiniti e selezionare Avanti.
Nella schermata Informazioni aggiuntive :
- Assicurarsi che sia selezionato .NET 9.0.
- Deselezionare Usare Redis per la memorizzazione nella cache. Implementerai la tua impostazione di memorizzazione nella cache.
- Selezionare Crea.

Visual Studio crea una nuova soluzione .NET Aspire costituita dai progetti seguenti:

AspireRedis.Web - progetto UI di Blazor con configurazioni predefinite .NET Aspire.
aspiraredis.ApiService : API minima con configurazioni predefinite di .NET.NET Aspire che forniscono al front-end i dati.
AspireRedis.AppHost - Un progetto di orchestrazione progettato per connettere e configurare i diversi progetti e servizi dell'applicazione.
AspireRedis.ServiceDefaults - Un progetto condiviso .NET.NET Aspire per gestire le configurazioni riutilizzate nei progetti della tua soluzione relativi alla resilienza , all'individuazione del servizio e alla telemetria .

Configurare il progetto host dell'app

Aggiungere il 📦Aspire.Hosting.Redis pacchetto NuGet al progetto AspireRedis.AppHost.
- .NET interfaccia della riga di comando
- PackageReference
```
dotnet add package Aspire.Hosting.Redis
```
```
<PackageReference Include="Aspire.Hosting.Redis"
                  Version="*" />
```
Per altre informazioni, vedere dotnet add package o Gestire le dipendenze dei pacchetti nelle applicazioni .NET.

Aggiornare il file Program.cs del progetto AspireRedis.AppHost in modo che corrisponda al codice seguente:

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

Il codice precedente crea un'istanza del contenitore Redis locale e configura l'interfaccia utente e l'API per l'uso automatico dell'istanza per la memorizzazione nella cache distribuita e di output. Il codice configura anche la comunicazione tra l'interfaccia utente front-end e l'API back-end usando l'individuazione dei servizi. Con l'individuazione implicita dei servizi di .NET.NET Aspire, la configurazione e la gestione delle connessioni al servizio è semplificata per la produttività degli sviluppatori. Nel contesto di questa esercitazione, la funzionalità semplifica la connessione a Redis.

In genere, è necessario specificare manualmente la stringa di connessione Redis nel file di appsettings.json di ogni progetto:

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

La configurazione della stringa di connessione con questo metodo, mentre funzionale, richiede la duplicazione della stringa di connessione tra più progetti, che può essere complessa e soggetta a errori.

Configurare l'interfaccia utente con la memorizzazione nella cache dell'output

Aggiungere i pacchetti di integrazione di .NET Aspire Stack Exchange Redis di output all'app AspireRedis.Web:
```
dotnet add package Aspire.StackExchange.Redis.OutputCaching
```
Nel file Program.cs del progetto AspireRedis.WebBlazor, subito dopo la riga var builder = WebApplication.CreateBuilder(args);, aggiungere una chiamata al metodo esteso AddRedisOutputCache.
```
builder.AddRedisOutputCache("cache");
```
Questo metodo esegue le attività seguenti:
- Configura la cache dell'output di ASP.NET Core per utilizzare un'istanza di Redis con il nome di connessione specificato.
- Abilita automaticamente i controlli di integrità, la registrazione e i dati di telemetria corrispondenti.
Sostituire il contenuto del file Home.razor del progetto con quanto segue:
```
@page "/"
@attribute [OutputCache(Duration = 10)]

<PageTitle>Home</PageTitle>

<h1>Hello, world!</h1>

Welcome to your new app on @DateTime.Now
```
L'integrazione include l'attributo [OutputCache], che memorizza nella cache l'intera risposta renderizzata. La pagina include anche una chiamata a @DateTime.Now per verificare che la risposta sia memorizzata nella cache.

Configurare l'API con la memorizzazione nella cache distribuita

Aggiungere Stack Exchange i pacchetti di integrazione della cache distribuita all'app :Add the Stack Exchange distributed cachingd packages to your app:
```
dotnet add package Aspire.StackExchange.Redis.DistributedCaching
```
Nella parte superiore del file Program.cs aggiungere una chiamata a AddRedisDistributedCache:
```
builder.AddRedisDistributedCache("cache");
```

Nel file Program.cs aggiungere le istruzioni using seguenti:

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

Nel file Program.cs sostituire il codice endpoint /weatherforecast esistente con il codice seguente:

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

Testare l'app localmente

Testare il comportamento di memorizzazione nella cache dell'app attenendosi alla procedura seguente:

Eseguire l'app usando Visual Studio premendo F5.
Se viene visualizzata la finestra di dialogo Start Docker Desktop, selezionare Sì per avviare il servizio.
Il dashboard .NET.NET Aspire viene caricato nel browser ed elenca i progetti di interfaccia utente e API.

Testare la cache di output:

Nella riga webfrontend della pagina dei progetti, fai clic sul link localhost nella colonna Endpoints per aprire l'UI della tua app.
L'applicazione visualizzerà l'ora corrente nella home page.
Aggiornare il browser ogni pochi secondi per visualizzare la stessa pagina restituita dalla memorizzazione nella cache dell'output. Dopo 10 secondi la cache scade e la pagina viene ricaricata con il tempo aggiornato.

Testare la cache distribuita:

Vai alla pagina meteo sull'interfaccia utente Blazor per caricare una tabella di dati meteorologici casuali.
Aggiorna il browser ogni qualche secondo per visualizzare gli stessi dati meteo restituiti dalla cache dell'output. Dopo 10 secondi la cache scade e la pagina viene ricaricata con i dati meteo aggiornati.

Felicitazioni! Hai configurato un'app ASP.NET Core per usare l'output e la memorizzazione nella cache distribuita con .NET Aspire.

Condividi tramite