Partilhar via

Tutorial: Implementar cache com integrações .NET.NET Aspire

  • Artigo

Os aplicativos nativos da nuvem geralmente exigem vários tipos de soluções de cache escaláveis para melhorar o desempenho. .NET Aspire integrações simplificam o processo de conexão com serviços de cache populares, como o Redis. Neste artigo, você aprenderá a:

  • Crie uma aplicação básica ASP.NET principal que esteja configurada para usar .NET Aspire.
  • Adicione integrações .NET Aspire para se conectar ao Redis e implementar o cache.
  • Configure as integrações .NET.NET Aspire para atender a requisitos específicos.

Este artigo explora como usar dois tipos diferentes de cache de ASP.NET Core usando .NET Aspire e Redis:

  • Cache de saída: Um método de cache configurável e extensível para armazenar respostas HTTP inteiras para solicitações futuras.
  • Cache distribuído: um cache partilhado por vários servidores de aplicações que permite armazenar partes específicas de dados em cache. Um cache distribuído normalmente é mantido como um serviço externo para os servidores de aplicativos que o acessam e pode melhorar o desempenho e a escalabilidade de um aplicativo ASP.NET Core.

Pré-requisitos

Para trabalhar com .NET.NET Aspire, você precisa do seguinte instalado localmente:

Para obter mais informações, consulte .NET.NET Aspire ferramentas e configuração, e .NET.NET Aspire SDK.

Criar o projeto

  1. Na parte superior do Visual Studio, navegue até Arquivo>Novo Projeto>....
  2. Na janela de diálogo, digite .NET Aspire na caixa de pesquisa de modelo de projeto e selecione .NET.NET AspireAplicativo inicial. Escolha Próximo.
  3. Na tela Configurar seu novo projeto:
    • Insira o nome do Projeto de AspireRedis.
    • Mantenha o rest dos valores nos seus valores padrão e selecione Avançar.
  4. No ecrã de Informações adicionais:
    • Certifique-se de .NET 9.0 está selecionado.
    • Desmarque Usar Redis para armazenar em cache. Você implementará sua própria configuração de cache.
    • Selecione Criar.

Visual Studio cria uma nova solução de .NET Aspire que consiste nos seguintes projetos:

  • AspireRedis.Web - Um projeto de interface do usuário Blazor com configurações .NET Aspire padrão.
  • AspireRedis.ApiService - Uma API mínima com configurações de .NET.NET Aspire padrão que fornece dados ao frontend.
  • AspireRedis.AppHost - Um projeto orquestrador projetado para conectar e configurar os diferentes projetos e serviços do seu aplicativo.
  • AspireRedis.ServiceDefaults - Um projeto partilhado .NET.NET Aspire para gerir configurações que são reutilizadas nos projetos na sua solução relacionadas com a resiliência , descoberta de serviço e telemetria .

Configurar o projeto Host do Aplicativo

  1. Adicione o 📦Aspire.Hosting.Redis pacote NuGet ao projeto AspireRedis.AppHost:

    dotnet add package Aspire.Hosting.Redis

    Para obter mais informações, consulte dotnet adicionar pacote ou Gerir dependências de pacotes em aplicações .NET.

  2. Atualize o arquivo de Program.cs do projeto AspireRedis.AppHost para corresponder ao seguinte código:

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

O código anterior cria uma instância de container local Redis e configura a UI e a API para usar a instância automaticamente tanto para cache de saída quanto para cache distribuído. O código também configura a comunicação entre a interface do usuário do frontend e a API do back-end usando a descoberta de serviço. Com a descoberta implícita de serviços do .NET.NET Aspire, a configuração e o gerenciamento de conexões de serviço são simplificados para a produtividade do desenvolvedor. No contexto deste tutorial, a funcionalidade simplifica como te conectas ao Redis.

Tradicionalmente, você especifica manualmente a cadeia de conexão Redis no arquivo appsettings.json de cada projeto:

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

Configurar a cadeia de conexão com esse método, embora funcional, requer a duplicação da cadeia de conexão em vários projetos, o que pode ser complicado e propenso a erros.

Configurar a interface do usuário com cache de saída

  1. Adicione o cache de saída do .NET Aspire Stack Exchange Redis pacotes de integração ao seu aplicativo AspireRedis.Web:

    dotnet add package Aspire.StackExchange.Redis.OutputCaching

  2. No arquivo Program.cs do projeto AspireRedis.WebBlazor, imediatamente após a linha var builder = WebApplication.CreateBuilder(args);, adicione uma chamada ao método de extensão AddRedisOutputCache:

    builder.AddRedisOutputCache("cache");

    Este método realiza as seguintes tarefas:

    • Configura a cache de saída de ASP.NET Core para utilizar a instância Redis com o nome de ligação especificado.
    • Permite automaticamente as verificações de integridade, registro e telemetria correspondentes.

  3. Substitua o conteúdo do arquivo do projeto AspireRedis.WebBlazor pelo seguinte:

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

<PageTitle>Home</PageTitle>

<h1>Hello, world!</h1>

Welcome to your new app on @DateTime.Now

    A integração inclui o atributo [OutputCache], que armazena em cache toda a resposta renderizada. A página também inclui uma chamada para @DateTime.Now para ajudar a verificar se a resposta está armazenada em cache.

Configurar a API com cache distribuído

  1. Adicione o .NET Aspire Stack Exchange Redis pacotes de integração de de cache distribuído ao seu aplicativo AspireRedis.ApiService:

    dotnet add package Aspire.StackExchange.Redis.DistributedCaching

  2. Na parte superior do arquivo Program.cs, adicione uma chamada para AddRedisDistributedCache:

    builder.AddRedisDistributedCache("cache");

  3. No arquivo Program.cs, adicione as seguintes instruções using:

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

  4. No arquivo Program.cs, substitua o código de ponto de extremidade /weatherforecast existente pelo seguinte:

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

Testar o aplicativo localmente

Teste o comportamento de cache do seu aplicativo usando as seguintes etapas:

  1. Execute o aplicativo usando Visual Studio pressionando F5.
  2. Se a caixa de diálogo Iniciar Docker Desktop aparecer, selecione Sim para iniciar o serviço.
  3. O Dashboard .NET.NET Aspire abre no navegador e lista os projetos de UI e API.

Teste o cache de saída:

  1. Na página de projetos, na linha webfrontend, clique no link na coluna Pontos de Extremidade para abrir a interface do usuário do seu aplicativo.
  2. O aplicativo exibirá a hora atual na página inicial.
  3. Atualize o navegador a cada poucos segundos para ver a mesma página retornada pelo cache de saída. Após 10 segundos, o cache expira e a página é recarregada com um tempo atualizado.

Teste o cache distribuído:

  1. Navegue até a página Weather na interface do usuário do Blazor para carregar uma tabela de dados meteorológicos aleatórios.
  2. Atualize o navegador a cada poucos segundos para ver os mesmos dados meteorológicos retornados pelo cache de saída. Após 10 segundos, o cache expira e a página é recarregada com dados meteorológicos atualizados.

Parabéns;! Você configurou um aplicativo ASP.NET Core para usar o cache de saída e o cache distribuído com .NET Aspire.