Compartilhar via

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

  • Artigo

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

  • Crie um aplicativo principal básico ASP.NET que esteja configurado para usar .NET Aspire.
  • Adicione integrações de .NET Aspire para se conectar a Redis e implementar o cache.
  • Configure as integrações de .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 compartilhado por vários servidores de aplicativos que permite armazenar em cache partes específicas de dados. 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 Aspirede instalação e ferramentas e .NET.NET Aspiredo SDK.

Criar o projeto

  1. No topo de Visual Studio, navegue até Arquivo>Novo Projeto>....
  2. Na janela da caixa de diálogo, insira .NET Aspire na caixa de pesquisa de modelo de projeto e selecione .NET.NET Aspire Aplicativo Inicial. Escolha Próximo.
  3. Na tela Configurar seu novo projeto:
    • Insira um de nome do Projeto de AspireRedis.
    • Deixe o rest dos valores no padrão e selecione Próximo.
  4. Na tela Informações adicionais:
    • Verifique se .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 .NET Aspire que consiste nos seguintes projetos:

  • AspireRedis.Web – um projeto de interface do usuário Blazor com configurações de .NET Aspire padrão.
  • AspireRedis.ApiService – uma API mínima com configurações de .NET.NET Aspire padrão que fornece o front-end com dados.
  • AspireRedis.AppHost – um projeto de orquestrador projetado para conectar e configurar os diferentes projetos e serviços do seu aplicativo.
  • AspireRedis.ServiceDefaults – um projeto compartilhado para gerenciar configurações reutilizadas nos projetos em sua solução relacionadas ade resiliência , de descoberta de serviço e de telemetria.

Configurar o projeto do Host do Aplicativo

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

    dotnet add package Aspire.Hosting.Redis

    Para obter mais informações, consulte dotnet add package ou Gerenciar dependências de pacotes em .NET aplicações.

  2. Atualize o arquivo 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 contêiner local Redis e configura o UI e a API para usar a instância automaticamente tanto para a saída quanto para o cache distribuído. O código também configura a comunicação entre a interface do usuário de front-end e a API de 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, o recurso simplifica como você se conecta ao Redis.

Tradicionalmente, você especificaria 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 o 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");

    Esse método realiza as seguintes tarefas:

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

  3. Substitua o conteúdo do arquivo Home.razor 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 os pacotes de integração de cache distribuído do Stack Exchange às suas aplicações .NET AspireRedisAspireRedis.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 for apresentada, escolha Sim para iniciar o serviço.
  3. O painel .NET.NET Aspire é carregado no navegador e exibe os projetos de UI e API.

Teste o cache de saída:

  1. Na página projetos, na linha de webfrontend, clique no link na coluna pontos de extremidade para abrir a interface do usuário do aplicativo.
  2. O aplicativo exibirá a hora atual na home page.
  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 o tempo atualizado.

Teste o cache distribuído:

  1. Navegue até a página Clima na interface do usuário Blazor para carregar uma tabela de dados climáticos 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 distribuído e de saída com .NET Aspire.