Övning – Cachelagrade data i Redis

10 minuter

I den här övningen lägger du till cachelagring i den delvis slutförda molnbaserade appen för din återförsäljare av utomhusutrustning. Du lägger till Redis i AppHost-projektet och implementerar sedan cachelagring av utdata i WebApp-projektet och distribuerad cachelagring i Catalog.API-projektet .

Installationskrav

Förutsättningarna för .NET Aspire är:

.NET 8
Förhandsversion av Visual Studio 2022
Docker Desktop
.NET Aspire-arbetsbelastning i Visual Studio

Om du redan har installerat dessa paket kan du gå vidare och börja arbeta med en Redis-cache.

Installera .NET 8

Följ den här .NET 8-länken och välj rätt installationsprogram för operativsystemet. Om du till exempel använder Windows 11 och en modern processor väljer du X64 .NET 8 SDK för Windows.

När nedladdningen är klar kör du installationsprogrammet och följer anvisningarna. I ett terminalfönster kör du följande kommando för att kontrollera att installationen lyckades:

dotnet --version

Du bör se versionsnumret för .NET SDK som du har installerat. Till exempel:

8.0.300-preview.24203.14

Installera Visual Studio 2022 Preview

Följ den här Visual Studio 2022 Preview-länken och välj Ladda ned förhandsversion. När nedladdningen är klar kör du installationsprogrammet och följer anvisningarna.

Installera Docker Desktop

Följ den här Docker Desktop-länken och välj rätt installationsprogram för operativsystemet. När nedladdningen är klar kör du installationsprogrammet och följer anvisningarna. Använd WSL 2-serverdelen för bästa prestanda och kompatibilitet.

Öppna Docker Desktop-programmet och godkänn tjänstavtalet.

Installera .NET Aspire-arbetsbelastningen i Visual Studio

Installera .NET Aspire-arbetsbelastningen med .NET CLI:

Öppna en terminal.

Uppdatera .NET-arbetsbelastningar med det här kommandot:

dotnet workload update

Du bör se ett meddelande om att arbetsbelastningarna har uppdaterats.

No workloads installed for this feature band. To update workloads installed with earlier SDK versions, include the --from-previous-sdk option.
Updated advertising manifest microsoft.net.sdk.ios.
Updated advertising manifest microsoft.net.workload.mono.toolchain.net6.
Updated advertising manifest microsoft.net.sdk.android.
Updated advertising manifest microsoft.net.workload.emscripten.net7.
Updated advertising manifest microsoft.net.workload.emscripten.net6.
Updated advertising manifest microsoft.net.sdk.macos.
Updated advertising manifest microsoft.net.workload.emscripten.current.
Updated advertising manifest microsoft.net.workload.mono.toolchain.current.
Updated advertising manifest microsoft.net.sdk.maui.
Updated advertising manifest microsoft.net.workload.mono.toolchain.net7.
Updated advertising manifest microsoft.net.sdk.maccatalyst.
Updated advertising manifest microsoft.net.sdk.tvos.
Updated advertising manifest microsoft.net.sdk.aspire.
No workloads installed for this feature band. To update workloads installed with earlier SDK versions, include the --from-previous-sdk option.

Successfully updated workload(s): .

Installera .NET Aspire-arbetsbelastningen med det här kommandot:

dotnet workload install aspire

Du bör se ett meddelande om att Aspire-arbetsbelastningen har installerats.

Installing Aspire.Hosting.Sdk.Msi.x64 ...... Done
Installing Aspire.ProjectTemplates.Msi.x64 ..... Done
Installing Aspire.Hosting.Orchestration.win-x64.Msi.x64 ............. Done
Installing Aspire.Hosting.Msi.x64 ..... Done
Installing Aspire.Dashboard.Sdk.win-x64.Msi.x64 ....... Done

Successfully installed workload(s) aspire.

Kontrollera att .NET Aspire-arbetsbelastningen är installerad med det här kommandot:

dotnet workload list

Du bör se information om arbetsbelastningen aspire .

Installed Workload Id      Manifest Version      Installation Source
---------------------------------------------------------------------------------------------
aspire                     8.0.0/8.0.100         SDK 8.0.300-preview.24203, VS 17.10.34902.84

Use `dotnet workload search` to find additional workloads to install.

Klona och ändra exempelappen

Vi använder git för att hämta en exempelapp som skapats med .NET Aspire. Appen har ännu inte konfigurerat cachelagring:

På kommandoraden bläddrar du till en mapp där du kan arbeta med kod.

Kör följande kommando för att klona exempelprogrammet Northern Mountains eShop :

git clone -b aspire-cache https://github.com/MicrosoftDocs/mslearn-aspire-starter

Starta Visual Studio och välj sedan Öppna ett projekt eller en lösning.
Bläddra till mappen där du klonade eShop, öppna startmappen och välj filen eShop.rediscache.sln och välj sedan Öppna.
I Solution Explorer bläddrar du till WebApp/Components/Pages och dubbelklickar sedan på Catalog.razor.

Leta upp följande kodrad:

<SectionContent SectionName="page-header-subtitle">Start the season with the latest in clothing and equipment.</SectionContent>

Ersätt den raden med följande kod:

<SectionContent SectionName="page-header-subtitle">Start the season with the latest in clothing and equipment. It's @DateTime.Now</SectionContent>

Starta appen genom att trycka på F5 eller välja Felsökning>Starta felsökning.
Om dialogrutan Starta Docker Desktop visas väljer du Ja.
När instrumentpanelen eShop .NET Aspire visas väljer du en av slutpunkterna för webbappsresursen:
Slutpunkten visar startsidan för Northern Mountains. Inklusive tiden på servern:
Tryck på F5 för att uppdatera sidan. Eftersom sidan inte cachelagras ändras tiden som visas varje gång du uppdaterar den, så länge den andra har ändrats.
Ändra till webbläsarfliken som visar instrumentpanelen .NET Aspire och välj sedan Spårningar i det vänstra navigeringsfönstret.
Spårningar med namnet webapp: GET / är begäranden för startsidan. Anteckna den typiska varaktigheten för dessa begäranden och välj sedan Visa i kolumnen Information för en av dem:
Observera att webbappen anropar flera mikrotjänster för att konstruera svaret i tidslinjevyn.
Stäng startsidan för Northern Mountains och instrumentpanelen .NET Aspire.
Om du vill sluta felsöka i Visual Studio trycker du på SKIFT – F5 eller väljer Felsöka > sluta felsöka.

Lägga till en säkerhetskopieringstjänst för cachelagring

Nu när du har sett hur startsidan fungerar utan cachelagring ska vi lägga till cachelagring av utdata för att se om den förbättrar svarstiden. Börja med att lägga till cachelagringskomponenten för utdata i AppHost-projektet :

Högerklicka på projektet eShop.AppHost i Solution Explorer i Visual Studio, välj Lägg till och välj sedan .NET Aspire-paketet.
I söktextrutan skriver du Redis i slutet av den befintliga texten.
Välj Aspire.Hosting.Redis-paketet .
I listan Version väljer du den senaste versionen 8.0.0 och väljer sedan Installera.
Om dialogrutan Förhandsgranskningsändringar visas väljer du Använd.
I dialogrutan Godkännande av licens väljer du Jag accepterar.
Expandera AppHost-projektet i Solution Explorer och dubbelklicka sedan på Program.cs.

Leta upp följande kodrader:

// Databases

var postgres = builder.AddPostgres("postgres").WithPgAdmin();
var catalogDb = postgres.AddDatabase("CatalogDB");

Omedelbart efter dessa rader lägger du till följande kod:
```
// Cache
var redis = builder.AddRedis("cache");
```

Leta upp följande kodrad, som lägger till Catalog API-projektet i .NET Aspire-orkestrering:

var catalogApi = builder.AddProject<Catalog_API>("catalog-api")
    .WithReference(catalogDb);

Om du vill skicka Redis-cachen till katalog-API-projektet ersätter du koden med följande rader:
```
var catalogApi = builder.AddProject<Catalog_API>("catalog-api")
    .WithReference(catalogDb)
    .WithReference(redis);
```
Kommentar

Vi använder cachen i katalog-API:et för att utföra distribuerad cachelagring.
Leta upp följande kodrad, som lägger till WebApp-projektet i .NET Aspire-orkestrering:
```
builder.AddProject<WebApp>("webapp")
    .WithReference(catalogApi);
```
Om du vill skicka Redis-cachen till WebApp-projektet ersätter du koden med följande rader:
```
builder.AddProject<WebApp>("webapp")
    .WithReference(catalogApi)
    .WithReference(redis);
```
Kommentar

Vi använder cachen i WebApp för att utföra cachelagring av utdata.
Om du vill spara filen Program.cs trycker du på CTRL – S eller väljer Spara fil > Program.cs.

Använda cachelagring av utdata i WebApp-projektet

Nu ska vi använda Redis-cachen i WebApp-projektet för att cachelagrat startsidans utdata:

Högerklicka på WebApp-projektet i Solution Explorer i Visual Studio, välj Lägg till och välj sedan .NET Aspire-paketet.
I söktextrutan skriver du Redis i slutet av den befintliga texten.
Välj Aspire.StackExchange.Redis.OutputCaching-paketet .
I listan Version väljer du den senaste versionen 8.0.0 och väljer sedan Installera.
Om dialogrutan Förhandsgranskningsändringar visas väljer du Använd.
I dialogrutan Godkännande av licens väljer du Jag accepterar.
När installationen är klar expanderar du WebApp i Solution Explorer och dubbelklickar sedan på Program.cs.

Leta upp följande kodrad:

var builder = WebApplication.CreateBuilder(args);

Lägg till den här koden direkt efter den raden för att lägga till utdatacachen i projektet:
```
builder.AddRedisOutputCache("cache");
```
Leta upp följande kodrad:
```
var app = builder.Build();
```
Lägg till den här koden omedelbart efter den raden för att lägga till cachelagringsmellanprogrammet i begärandepipelinen:
```
app.UseOutputCache();
```
I Solution Explorer expanderar du WebApp > Components > Pages och dubbelklickar sedan på Catalog.razor.
Leta upp följande kodrad:
```
@attribute [StreamRendering]
```
Lägg till följande kod direkt efter raden för att cachelagras på startsidan:
```
@attribute [Microsoft.AspNetCore.OutputCaching.OutputCache(Duration = 10)]
```

Testa cachelagring av utdata

Cachelagring av utdata implementeras nu på startsidan för Northern Mountains. Nu ska vi testa det:

I Visual Studio startar du appen genom att trycka på F5 eller välja Felsöka > Starta felsökning.
När instrumentpanelen eShop .NET Aspire visas väljer du en av slutpunkterna för webbappsresursen:
Slutpunkten visar startsidan för Northern Mountains, inklusive tiden på servern.
Tryck på F5 för att uppdatera sidan. Eftersom sidan cachelagras i 10 sekunder ändras den tid som visas endast när den är mer än 10 sekunder efter den cachelagrade begäran.
Ändra till webbläsarfliken som visar instrumentpanelen .NET Aspire och välj sedan Spårningar i det vänstra navigeringsfönstret.
Spårningar med namnet webapp: GET / är begäranden för startsidan. Vissa begäranden till startsidan, som inte kunde uppfyllas från cacheminnet, har liknande tidsinställningar som de varaktigheter som du antecknade tidigare. Andra begäranden, som returneras från cacheminnet, har dock betydligt kortare varaktigheter.
För en av de kortare begäran väljer du Visa i kolumnen Information . Observera att begäran hämtades från Redis-cachen:
Stäng startsidan för Northern Mountains och instrumentpanelen .NET Aspire.
Om du vill sluta felsöka i Visual Studio trycker du på SKIFT – F5 eller väljer Felsöka > sluta felsöka.

Använda distribuerad cachelagring

Vi kan också använda Redis för att utföra distribuerad cachelagring i catalog.API-projektet :

Högerklicka på projektet Catalog.API i Solution Explorer i Visual Studio, välj Lägg till och välj sedan .NET Aspire-paketet.
I söktextrutan skriver du Redis i slutet av den befintliga texten.
Välj Aspire.StackExchange.Redis.DistributedCaching-paketet .
I listan Version väljer du den senaste versionen 8.0.0 och väljer sedan Installera.
Om dialogrutan Förhandsgranskningsändringar visas väljer du Använd.
I dialogrutan Godkännande av licens väljer du Jag accepterar.
När installationen är klar expanderar du Catalog.API i Solution Explorer och dubbelklickar sedan på Program.cs.

Leta upp följande kodrad:

var builder = WebApplication.CreateBuilder(args);

Lägg till den här koden direkt efter den raden för att lägga till utdatacachen i projektet:
```
builder.AddRedisDistributedCache("cache");
```
I Solution Explorer expanderar du Catalog.API > Apis och dubbelklickar sedan på CatalogApi.cs.

Leta upp följande kod, som deklarerar GetAllItems metoden:

public static async Task<Results<Ok<PaginatedItems<CatalogItem>>, BadRequest<string>>> GetAllItems(
    [AsParameters] PaginationRequest paginationRequest,
    [AsParameters] CatalogServices services)
{

Om du vill hämta Redis-cachen via beroendeinmatning ändrar du koden för att lägga till en ny parameter i metoden:

public static async Task<Results<Ok<PaginatedItems<CatalogItem>>, BadRequest<string>>> GetAllItems(
    [AsParameters] PaginationRequest paginationRequest,
    [AsParameters] CatalogServices services,
    IDistributedCache cache)
{

Ta bort hela innehållet i GetAllItems metoden och ersätt den med följande kod:

var pageSize = paginationRequest.PageSize;
var pageIndex = paginationRequest.PageIndex;

var totalItems = await services.DbContext.CatalogItems
    .LongCountAsync();

// Check that there are cached items
var cachedItems = await cache.GetAsync("catalogItems");

if (cachedItems is null)
{
    // There are no items in the cache. Get them from the database
    var itemsOnPage = await services.DbContext.CatalogItems
        .OrderBy(c => c.Name)
        .Skip(pageSize * pageIndex)
        .Take(pageSize)
        .AsNoTracking()
        .ToListAsync();

    // Store the items in the cache for 10 seconds
    await cache.SetAsync("catalogItems", Encoding.UTF8.GetBytes(System.Text.Json.JsonSerializer.Serialize(itemsOnPage)), new()
    {
        AbsoluteExpiration = DateTime.Now.AddSeconds(10)
    });

    ChangeUriPlaceholder(services.Options.Value, itemsOnPage);
    return TypedResults.Ok(new PaginatedItems<CatalogItem>(pageIndex, pageSize, totalItems, itemsOnPage));

}
else
{
    // There are items in the cache. Deserialize them to display.
    var itemsOnPage = System.Text.Json.JsonSerializer.Deserialize<List<CatalogItem>>(cachedItems);
    // Make sure itemsOnPage is not null
    if (itemsOnPage is null)
    {
        itemsOnPage = new List<CatalogItem>();
    }

    ChangeUriPlaceholder(services.Options.Value, itemsOnPage);
    return TypedResults.Ok(new PaginatedItems<CatalogItem>(pageIndex, pageSize, totalItems, itemsOnPage));
}

Testa distribuerad cachelagring

Distribuerad cachelagring implementeras nu i projektet Catalog.API . Nu ska vi testa det:

I Visual Studio startar du appen genom att trycka på F5 eller välja Felsöka > Starta felsökning.
När instrumentpanelen eShop .NET Aspire visas väljer du slutpunkten för resursen catalog-api:
Slutpunkten visar Swagger-gränssnittet för katalog-API-mikrotjänsten. Bredvid metoden /api/v1/catalog/items väljer du GET.
Välj Prova och välj sedan Kör. Resultaten visas i fönstret Svarstext :
Klicka på Kör flera gånger till för att anropa API:et igen. Dessa begäranden bör hämta objekten från cacheminnet, så länge begäran är mindre än 10 sekunder efter den första.
Ändra till webbläsarfliken som visar instrumentpanelen .NET Aspire och välj sedan Spårningar i det vänstra navigeringsfönstret.
Spårningar med namnet catalog-api: GET /api/v1/catalog/items är begäranden för objektmetoden för katalog-API:et. Observera att den första begäran till den metoden tar längre tid att formulera efterföljande begäranden, som API:et hämtar objekten från Redis-cachen:
Stäng Swagger-sidan och .NET Aspire-instrumentpanelen.
Om du vill sluta felsöka i Visual Studio trycker du på SKIFT – F5 eller väljer Felsöka > sluta felsöka.

Övning – Cachelagrade data i Redis

Installationskrav

Installera .NET 8

Installera Visual Studio 2022 Preview

Installera Docker Desktop

Installera .NET Aspire-arbetsbelastningen i Visual Studio

Klona och ändra exempelappen

Lägga till en säkerhetskopieringstjänst för cachelagring

Använda cachelagring av utdata i WebApp-projektet

Testa cachelagring av utdata

Använda distribuerad cachelagring

Testa distribuerad cachelagring

Feedback