Utiliser un cache distribué Redis
Dans une application native cloud, les équipes distinctes créent des microservices avec leurs technologies préférées selon leurs propres planifications. Les microservices fonctionnent généralement de manière totalement indépendante. Ils peuvent bénéficier de la mise en cache, mais s’ils utilisent des caches séparés, ils risquent de ne pas pouvoir bénéficier d’une amélioration optimale des performances. Si vous fournissez un seul cache pour plusieurs microservices, ces services peuvent récupérer dans le cache des informations stockées par un autre microservice.
Imaginez que vous travaillez pour un détaillant d’équipements extérieurs. Vous avez décidé d’implémenter la mise en cache à l’aide d’un serveur Redis dans votre microservice de panier d’achat. Toutefois, vous souhaitez également vous assurer que d’autres microservices peuvent tirer parti des informations que vous mettez en cache.
Dans cette unité, vous allez découvrir comment un cache Redis distribué peut optimiser les performances de plusieurs microservices dans votre application. Vous verrez également comment .NET Aspire facilite l’implémentation d’un cache distribué.
Qu’est-ce que la mise en cache distribuée ?
Un cache distribué est un cache partagé entre plusieurs services appelants. Dans une application native cloud, les services appelants sont généralement des microservices. Lorsque vous stockez des informations, par exemple les détails d’un produit populaire dans votre catalogue, dans le cache distribué, tous les microservices de votre application peuvent potentiellement les utiliser et bénéficier de l’amélioration des performances.
Configuration de la mise en cache distribuée dans .NET Aspire
Pour utiliser la mise en cache distribuée, des modifications sont requises dans le projet hôte de l’application et les microservices qui utilisent le cache.
Configurer l’hôte de l’application
Dans le projet hôte de l’application de votre solution, commencez par installer le composant d’hébergement de mise en cache distribuée :
dotnet add package Aspire.Hosting.Redis --prerelease
Vous pouvez également utiliser le raccourci Ajouter > Composant Aspire .NET dans Visual Studio pour installer le composant à partir du gestionnaire de package NuGet :
Une fois le composant d’hébergement installé, le code dans le fichier Program.cs de l’hôte d’application inscrit le cache et le transmet aux projets qui utilisent le cache :
// Register the cache
var redis = builder.AddRedis("redis");
// Initiate the consuming project and pass the cache
builder.AddProject<Projects.ConsumingProject>()
.WithReference(redis);
Configurer les projets consommateurs
Pour installer le composant de cache distribué .NET Aspire dans un microservice, utilisez une commande semblable à celle-ci dans vos projets .NET Aspire :
dotnet add package Aspire.StackExchange.Redis.DistributedCache --prerelease
Là encore, vous pouvez choisir d’utiliser le gestionnaire de package NuGet pour installer le composant :
Utilisation d’un cache distribué
Dans n’importe quel projet dans lequel vous souhaitez utiliser le cache, vous devez obtenir un objet de cache distribué, qui représente la connexion à Redis. Dans le fichier Program.cs, ce code inscrit le cache distribué :
builder.AddRedisDistributedCache("cache")
Une fois le cache inscrit dans le projet consommateur, vous pouvez récupérer le cache distribué chaque fois que vous en avez besoin à l’aide de l’injection de dépendances :
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) }
);
}
}
}
Configuration
Pour que les microservices se connectent au cache distribué Redis, vous devez leur indiquer où il se trouve en fournissant une chaîne de connexion. L’appel ci-dessus à la méthode AddRedisDistributedCache() a spécifié une chaîne de connexion appelée redis.
Utilisez une section ConnectionStrings dans votre fichier de configuration, par exemple dans appsettings.json, pour configurer la chaîne de connexion :
{
"ConnectionStrings": {
"redis": "redis.contoso.com:6379"
}
}
Vous pouvez également utiliser appsettings.json pour configurer le comportement du composant de mise en cache distribuée. Par exemple, ce code configure la connexion pour qu’elle expire après cinq secondes et qu’elle soit réessayée trois fois :
{
"Aspire": {
"StackExchange": {
"Redis": {
"ConfigurationOptions": {
"ConnectTimeout": 5000,
"ConnectRetry": 3
}
}
}
}
}
Vous pouvez également configurer la connexion à l’aide de délégués inlined sur la méthode AddRedisDistributedCache(). Ce code configure les mêmes propriétés que l’exemple JSON précédent :
builder.AddRedisDistributedCache(
"redis",
configureOptions: options => options.ConnectTimeout = 5000
);