Partager via

Tutoriel : Implémenter la mise en cache avec des intégrations .NET.NET Aspire

  • Article

Les applications natives cloud nécessitent souvent différents types de solutions de mise en cache évolutives pour améliorer les performances. Les intégrations de .NET Aspire simplifient le processus de connexion à des services de mise en cache populaires tels que Redis. Dans cet article, vous allez apprendre à :

  • Créez une application de base ASP.NET principale configurée pour utiliser .NET Aspire.
  • Ajoutez des intégrations .NET Aspire pour vous connecter à Redis et implémenter la mise en cache.
  • Configurez les intégrations .NET.NET Aspire pour répondre à des exigences spécifiques.

Cet article explique comment utiliser deux types de mise en cache de ASP.NET Core différents à l’aide de .NET Aspire et de Redis:

  • mise en cache de sortie: méthode de mise en cache configurable et extensible pour stocker les réponses HTTP entières pour les requêtes futures.
  • mise en cache distribuée: cache partagé par plusieurs serveurs d’applications qui vous permet de mettre en cache des éléments de données spécifiques. Un cache distribué est généralement géré en tant que service externe aux serveurs d’applications qui y accèdent et peut améliorer les performances et l’extensibilité d’une application ASP.NET Core.

Conditions préalables

Pour utiliser .NET.NET Aspire, vous avez besoin de l’installation locale suivante :

Pour plus d’informations, consultez la configuration et les outils .NET.NET Aspire, et le SDK .NET.NET Aspire.

Créer le projet

  1. En haut de Visual Studio, accédez à Fichier>Nouveau projet...>.
  2. Dans la fenêtre de boîte de dialogue, entrez .NET Aspire dans la zone de recherche du modèle de projet, puis sélectionnez .NET.NET Aspire Application de démarrage. Choisissez suivant.
  3. Dans l’écran Configurer votre nouveau projet :
    • Entrez un nom de projet de AspireRedis.
    • Laissez la rest des valeurs par défaut, puis sélectionnez Suivant .
  4. Sur l'écran Informations supplémentaires :
    • Vérifiez que .NET 9,0 est sélectionnée.
    • Décochez Utiliser Redis pour mettre en cache. Vous allez implémenter votre propre configuration de mise en cache.
    • Sélectionnez Créer.

Visual Studio crée une nouvelle solution de .NET Aspire comprenant les projets suivants :

  • AspireRedis.Web : projet d’interface utilisateur Blazor avec des configurations de .NET Aspire par défaut.
  • AspireRedis.ApiService : API minimale avec des configurations de .NET.NET Aspire par défaut qui fournissent le front-end avec des données.
  • AspireRedis.AppHost : projet d’orchestrateur conçu pour connecter et configurer les différents projets et services de votre application.
  • AspireRedis.ServiceDefaults - Un projet partagé .NET.NET Aspire pour gérer les configurations réutilisées dans les projets de votre solution en lien avec résilience, de découverte de service et de télémétrie.

Configurer le projet Hôte d’application

  1. Ajoutez le package NuGet 📦Aspire.Hosting.Redis au projet AspireRedis.AppHost :

    dotnet add package Aspire.Hosting.Redis

    Pour plus d’informations, consultez dotnet add package ou Gérer les dépendances de package dans les applications .NET.

  2. Mettez à jour le fichier Program.cs du projet AspireRedis.AppHost pour qu’il corresponde au code suivant :

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

Le code précédent crée une instance de conteneur Redis locale et configure l’interface utilisateur et l’API pour utiliser l’instance automatiquement pour la sortie et la mise en cache distribuée. Le code configure également la communication entre l’interface utilisateur frontale et l’API back-end à l’aide de la découverte de service. Avec la découverte implicite du service de .NET.NET Aspire, la configuration et la gestion des connexions de service sont simplifiées pour la productivité des développeurs. Dans le contexte de ce didacticiel, la fonctionnalité simplifie la façon dont vous vous connectez à Redis.

Traditionnellement, vous devez spécifier manuellement la chaîne de connexion Redis dans le fichier appsettings.json de chaque projet :

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

La configuration de la chaîne de connexion avec cette méthode, tout en étant fonctionnelle, nécessite de dupliquer la chaîne de connexion sur plusieurs projets, ce qui peut être fastidieux et sujette aux erreurs.

Configurer l’interface utilisateur avec la mise en cache de sortie

  1. Ajoutez les packages d’intégration de la mise en cache de sortie Stack Exchange .NET AspireRedis à votre application AspireRedis.Web.

    dotnet add package Aspire.StackExchange.Redis.OutputCaching

  2. Dans le fichier Program.cs du projet AspireRedis.WebBlazor, immédiatement après la ligne var builder = WebApplication.CreateBuilder(args);, ajoutez un appel à la méthode d’extension AddRedisOutputCache :

    builder.AddRedisOutputCache("cache");

    Cette méthode effectue les tâches suivantes :

    • Configurez la mise en cache de ASP.NET Core pour utiliser une instance de Redis avec le nom de connexion spécifié.
    • Active automatiquement les vérifications d’intégrité, la journalisation et la télémétrie correspondantes.

  3. Remplacez le contenu du fichier Home.razor du projet AspireRedis.WebBlazor par les éléments suivants :

    @page "/"
@attribute [OutputCache(Duration = 10)]

<PageTitle>Home</PageTitle>

<h1>Hello, world!</h1>

Welcome to your new app on @DateTime.Now

    L’intégration inclut l’attribut [OutputCache], qui met en cache l’intégralité de la réponse rendue. La page inclut également un appel à @DateTime.Now pour vous aider à vérifier que la réponse est mise en cache.

Configurer l’API avec la mise en cache distribuée

  1. Ajoutez les packages d’intégration de mise en cache distribuée Stack Exchange à votre application :

    dotnet add package Aspire.StackExchange.Redis.DistributedCaching

  2. En haut du fichier Program.cs, ajoutez un appel à AddRedisDistributedCache:

    builder.AddRedisDistributedCache("cache");

  3. Dans le fichier Program.cs, ajoutez les instructions using suivantes :

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

  4. Dans le fichier Program.cs, remplacez le code de point de terminaison /weatherforecast existant par les éléments suivants :

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

Tester l’application localement

Testez le comportement de mise en cache de votre application en procédant comme suit :

  1. Exécutez l’application à l’aide de Visual Studio en appuyant sur F5.
  2. Si la boîte de dialogue Démarrer Docker Desktop s’affiche, sélectionnez Oui pour démarrer le service.
  3. Le tableau de bord .NET.NET Aspire se charge dans le navigateur et répertorie les projets d’interface utilisateur et d’API.

Testez le cache de sortie :

  1. Dans la page projets, dans la ligne webfrontend , cliquez sur le lien dans la colonne Points de terminaison pour ouvrir l’interface utilisateur de votre application.
  2. L’application affiche l’heure actuelle sur la page d’accueil.
  3. Actualisez le navigateur toutes les quelques secondes pour voir la même page retournée par la mise en cache de sortie. Après 10 secondes, le cache expire et la page se recharge avec l'heure mise à jour.

Testez le cache distribué :

  1. Accédez à la page Météo de l’interface utilisateur de Blazor pour charger une table des données météorologiques aléatoires.
  2. Actualisez le navigateur toutes les quelques secondes pour afficher les mêmes données météorologiques retournées par la mise en cache de sortie. Après 10 secondes, le cache expire et la page recharge avec les données météorologiques mises à jour.

Félicitations! Vous avez configuré une application ASP.NET Core pour utiliser la sortie et la mise en cache distribuée avec .NET Aspire.