Använd Azure Cosmos DB som en ASP.NET-sessionstillstånd och cachelagringsprovider

  • Artikel
  • 4 minuter för att läsa

GÄLLER FÖR: SQL API

Med Azure Cosmos DB-sessions- och cacheprovidern kan du använda Azure Cosmos DB och utnyttja dess funktioner för kort svarstid och global skalning för lagring av sessionstillståndsdata och som en distribuerad cache i ditt program.

Vad är sessionstillstånd?

Sessionstillstånd är användardata som spårar en användare som bläddrar genom en webbapp under en viss tidsperiod i samma webbläsare. Sessionstillståndet upphör att gälla och är begränsat till de interaktioner som en viss webbläsare har som inte sträcker sig över webbläsare. Den anses vara tillfälliga data, och om den inte finns kommer den inte att bryta programmet. Men när den finns gör det upplevelsen snabbare för användaren eftersom webbappen inte behöver hämta den på varje webbläsarbegäran för samma användare.

Det backas ofta upp av en viss lagringsmekanism, som i vissa fall kan vara utanför den aktuella webbservern och aktivera belastningsutjämningsbegäranden i samma webbläsare på flera webbservrar för att uppnå högre skalbarhet.

Den enklaste sessionstillståndsprovidern är den minnesblandade providern som endast lagrar data på det lokala webbserverminnet och kräver att programmet använder routning av programbegäran. Detta gör att webbläsarsessionen fästs på en viss webbserver (alla begäranden för den webbläsaren måste alltid landa på samma webbserver). Leverantören fungerar bra i enkla scenarier, men kravet på kvarhet kan medföra belastningsutjämningsproblem när webbprogram skalas.

Det finns många externa lagringsproviders som kan lagra sessionsdata på ett sätt som kan läsas och användas av flera webbservrar utan att sessionerna behöver vara kvar och aktivera en högre skala.

Sessionstillståndsscenarier

Cosmos DB kan användas som sessionstillståndsprovider via tilläggspaketet Microsoft.Extensions.Cachelagring. Cosmos använder Azure Cosmos DB .NET SDKmed hjälp av en container som en effektiv sessionslagring baserat på en nyckel/värde-metod där nyckeln är sessionsidentifieraren.

När paketet har lagts till kan du använda AddCosmosCache som en del av startprocessen (tjänster. AddSession och app. UseSession är vanliga initieringssteg som krävs för alla sessionstillståndsprovider:

public void ConfigureServices(IServiceCollection services)
{
  /* Other service configurations */
  services.AddCosmosCache((CosmosCacheOptions cacheOptions) =>
  {
      CosmosClientBuilder clientBuilder = new CosmosClientBuilder("myConnectionString")
        .WithApplicationRegion("West US");
      cacheOptions.ContainerName = "myContainer";
      cacheOptions.DatabaseName = "myDatabase";
      cacheOptions.ClientBuilder = clientBuilder;
      /* Creates the container if it does not exist */
      cacheOptions.CreateIfNotExists = true; 
  });

  services.AddSession(options =>
  {
      options.IdleTimeout = TimeSpan.FromSeconds(3600);
      options.Cookie.IsEssential = true;
  });
  /* Other service configurations */
}

public void Configure(IApplicationBuilder app, IWebHostEnvironment env)
{
    /* Other configurations */

    app.UseSession();

    /* app.UseEndpoints and other configurations */
}

Där du anger databasen och containern som du vill att sessionstillståndet ska lagras och om du vill kan du skapa dem om de inte finns.

Du kan anpassa SDK-klientkonfigurationen med hjälp av eller, om ditt program redan använder en för andra åtgärder med Cosmos DB, kan du också mata in CosmosClientBuilder CosmosClient den i providern:

services.AddCosmosCache((CosmosCacheOptions cacheOptions) =>
{
    cacheOptions.ContainerName = "myContainer";
    cacheOptions.DatabaseName = "myDatabase";
    cacheOptions.CosmosClient = preExistingClient;
    /* Creates the container if it does not exist */
    cacheOptions.CreateIfNotExists = true; 
});

Därefter kan du använda ASP.NET Core som med andra provider och använda objektet HttpContext.Session. Tänk på att alltid försöka läsa in sessionsinformationen asynkront enligt rekommendationerna ASP.NET .

Scenarier för distribuerad cache

Med tanke på att Cosmos DB-providern implementerar IDistributedCache-gränssnittetför att fungera som en distribuerad cacheprovider kan den också användas för alla program som kräver distribuerad cache, inte bara för webbprogram som kräver en leverantör av presterande och distribuerat sessionstillstånd.

Distribuerade cacheminnen kräver datakonsekvens för att tillhandahålla oberoende instanser för att kunna dela cachelagrade data. När du Cosmos DB providern kan du:

  • Använd ditt Cosmos DB i sessionskonsekvens om du kan aktivera routning av programbegäran och göra begäranden fäst vid en viss instans.
  • Använd ditt Cosmos DB föråldrigt eller stark konsekvens utan att kräva att begäran blir kvar. Detta ger den största skalning när det gäller belastningsfördelning mellan dina instanser.

Om du Cosmos DB providern som en distribuerad cache måste den registreras i ConfiguredService med services.AddCosmosCache -anropet. När det är klart kan alla konstruktorer i programmet fråga efter cachen genom att referera till och den tar emot den instans som matas in av beroende IDistributedCache injection som ska användas:

public class MyBusinessClass
{
    private readonly IDistributedCache cache;

    public MyBusinessClass(IDistributedCache cache)
    {
        this.cache = cache;
    }
    
    public async Task SomeOperationAsync()
    {
        string someCachedValue = await this.cache.GetStringAsync("someKey");
        /* Use the cache */
    }
}

Felsökning och diagnostisering

GÄLLER FÖR: SQL API

Eftersom Cosmos DB använder .NET SDK under, gäller alla befintliga prestandariktlinjer och felsökningsguider för att förstå eventuella problem. Observera att det finns ett distinkt sätt att få åtkomst till diagnostiken från de underliggande Cosmos DB eftersom de inte kan exponeras via IDistributedCache-API:erna.

Genom att registrera den valfria diagnostikdelegaten kan du samla in och villkorligt logga diagnostik för att felsöka fall som hög svarstid:

void captureDiagnostics(CosmosDiagnostics diagnostics)
{
    if (diagnostics.GetClientElapsedTime() > SomePredefinedThresholdTime)
    {
        Console.WriteLine(diagnostics.ToString());
    }
}

services.AddCosmosCache((CosmosCacheOptions cacheOptions) =>
{
    cacheOptions.DiagnosticsHandler = captureDiagnostics;
    /* other options */
});

Nästa steg