Serialisering av tokencachen

När Microsofts autentiseringsbibliotek (MSAL) har hämtat en token lagrar det den i cacheminnet. Offentliga klientprogram (skrivbords- och mobilappar) bör försöka hämta en token från cacheminnet innan en token hämtas med en annan metod. Anskaffningsmetoder för konfidentiella klientprogram hanterar själva cachen. I den här artikeln beskrivs standard- och anpassad serialisering av tokencachen i MSAL.NET.

Sammanfattning

Rekommendationen är:

• När du skriver mobilappar är cachelagring redan förkonfigurerad av MSAL.
• När du skriver ett skrivbordsprogram använder du plattformsoberoende tokencache enligt beskrivningen i skrivbordsappar.
• När du skriver nya konfidentiella klientprogram (webbappar, webb-API:er eller tjänst-till-tjänst- eller daemon-appar använder du Microsoft. Identity.Web som ett API på högre nivå. Det erbjuder integrering med ASP.NET Core, ASP.NET Classic och fungerar även fristående.
• Befintliga konfidentiella klientprogram som utnyttjar MSAL.NET direkt kan fortsätta att göra det.
• Webbappar och webb-API:er bör använda en distribuerad tokencache (t.ex. Redis, SQL Server, Azure Cosmos DB) tillsammans med en begränsad minnescache.
• Kryptering i vila kan valfritt konfigureras med ASP.NET Core Data Protection.
• Webbappar kan också förlita sig på sessionscookies. Det här alternativet rekommenderas dock inte på grund av cookiestorleken.
• Tjänst-till-tjänst- och daemon-appar kan endast förlita sig på minnescachelagring. Om din app betjänar många klienter konfigurerar du en borttagningsprincip.
• Hanterade identitetstoken cachelagras endast i minnet.

Konfidentiella klienter som använder Microsoft. Identity.Web

NuGet-paketet Microsoft.Identity.Web.TokenCache tillhandahåller serialisering av tokencache i biblioteket Microsoft.Identity.Web. Biblioteket innehåller integrering med både ASP.NET Core och ASP.NET Classic, och dess abstraktioner kan användas för att driva andra webbappar eller API-ramverk.

Note

Exemplen nedan är för ASP.NET Core. För ASP.NET koden är liknande, se webbappexemplet ms-identity-aspnet-wepapp-openidconnect för en referensimplementering.

Tilläggsmetod	Description
AddInMemoryTokenCaches	Skapar en tillfällig cache i minnet för tokenlagring och hämtning. Minnesinterna tokencacheminnen är snabbare än andra cachetyper, men deras token sparas inte mellan programomstarter och du kan inte styra cachestorleken. Minnesbaserade cacheminnen är bra för appar som inte kräver att token sparas mellan omstarter av appen. Använd en minnesintern tokencache i appar som deltar i dator-till-dator-autentiseringsscenarier som tjänster, daemoner och andra som använder AcquireTokenForClient (klientautentiseringsuppgifterna beviljar). Token-cacheminnen i arbetsminnet är också bra för exempelappar och vid lokal apputveckling. Microsoft.Identity.Web-versionerna 1.19.0+ delar en minnesintern tokencache mellan alla programinstanser.
AddSessionTokenCaches	Tokencachen är bunden till användarsessionen. Det här alternativet är inte idealiskt om ID-token innehåller många anspråk eftersom cookien blir för stor.
AddDistributedTokenCaches	Tokencachen är en adapter för ASP.NET Core IDistributedCache-implementeringen. Det gör att du kan välja mellan en distribuerad minnescache, en Redis-cache, en distribuerad NCache eller en SQL Server cache. Mer information om implementeringarna finns i IDistributedCacheDistribuerad minnescache.

Internminnesbaserad cache för token

Här är ett exempel på kod som använder minnesintern cache i metoden ConfigureServices i startklassen i ett ASP.NET Core program:

using Microsoft.Identity.Web;

public class Startup
{
 const string scopesToRequest = "user.read";
  
  public void ConfigureServices(IServiceCollection services)
  {
   // code before
   services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
           .AddMicrosoftIdentityWebApp(Configuration)
             .EnableTokenAcquisitionToCallDownstreamApi(new string[] { scopesToRequest })
                .AddInMemoryTokenCaches();
   // code after
  }
  // code after
}

AddInMemoryTokenCaches kan användas i produktion om du endast begär apptokenar. Om du använder användartoken bör du överväga att använda en distribuerad tokencache.

Konfigurationskoden för token-cachen är likartad i ASP.NET Core-webbappar och webb-API:er.

Cacheminnen för distribuerad token

Här är exempel på möjliga distribuerade cacheminnen:

// or use a distributed Token Cache by adding
   services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
           .AddMicrosoftIdentityWebApp(Configuration)
             .EnableTokenAcquisitionToCallDownstreamApi(new string[] { scopesToRequest }
               .AddDistributedTokenCaches();

// Distributed token caches have a L1/L2 mechanism.
// L1 is in memory, and L2 is the distributed cache
// implementation that you will choose below.
// You can configure them to limit the memory of the 
// L1 cache, encrypt, and set eviction policies.
services.Configure<MsalDistributedTokenCacheAdapterOptions>(options => 
  {
    // Optional: Disable the L1 cache in apps that don't use session affinity
    //                 by setting DisableL1Cache to 'true'.
    options.DisableL1Cache = false;
    
    // Or limit the memory (by default, this is 500 MB)
    options.L1CacheOptions.SizeLimit = 1024 * 1024 * 1024; // 1 GB

    // You can choose if you encrypt or not encrypt the cache
    options.Encrypt = false;

    // And you can set eviction policies for the distributed
    // cache.
    options.SlidingExpiration = TimeSpan.FromHours(1);
  });

// Then, choose your implementation of distributed cache
// -----------------------------------------------------

// good for prototyping and testing, but this is NOT persisted and it is NOT distributed - do not use in production
services.AddDistributedMemoryCache();

// Or a Redis cache
// Requires the Microsoft.Extensions.Caching.StackExchangeRedis NuGet package
services.AddStackExchangeRedisCache(options =>
{
 options.Configuration = "localhost";
 options.InstanceName = "SampleInstance";
});

// You can even decide if you want to repair the connection
// with Redis and retry on Redis failures. 
services.Configure<MsalDistributedTokenCacheAdapterOptions>(options => 
{
  options.OnL2CacheFailure = (ex) =>
  {
    if (ex is StackExchange.Redis.RedisConnectionException)
    {
      // action: try to reconnect or something
      return true; //try to do the cache operation again
    }
    return false;
  };
});

// Or even a SQL Server token cache
// Requires the Microsoft.Extensions.Caching.SqlServer NuGet package
services.AddDistributedSqlServerCache(options =>
{
 options.ConnectionString = _config["DistCache_ConnectionString"];
 options.SchemaName = "dbo";
 options.TableName = "TestCache";
});

// Or an Azure Cosmos DB cache
// Requires the Microsoft.Extensions.Caching.Cosmos NuGet package
services.AddCosmosCache((CosmosCacheOptions cacheOptions) =>
{
    cacheOptions.ContainerName = Configuration["CosmosCacheContainer"];
    cacheOptions.DatabaseName = Configuration["CosmosCacheDatabase"];
    cacheOptions.ClientBuilder = new CosmosClientBuilder(Configuration["CosmosConnectionString"]);
    cacheOptions.CreateIfNotExists = true;
});

Mer information finns i:

• Kryptering av distribuerad cache och andra avancerade alternativ
• Hantera borttagning av L2-cache
• Konfigurera en Redis-cache i Docker
• Troubleshooting

Användningen av distribuerad cache finns i självstudiekursen för ASP.NET Core webbapp i tokencache för fas 2-2.

Konfidentiella klienter som använder MSAL.NET

För konfidentiella .NET-klienter rekommenderas att använda Microsoft.Identity.Web, som bygger på MSAL.NET, eftersom API:er på högre nivå kan hantera komplexa scenarier direkt (t.ex. gästanvändare, kontinuerlig åtkomstutvärdering och Proof-of-Possession-token). Program som behöver åtkomst till Azure API:er bör använda Azure SDKs, vilket utnyttjar MSAL internt.

Följande material är relevant om du använder MSAL.NET direkt.

Tillgängliga cachelagringstekniker

• Minnescache utan borttagning
• Minnescache med borttagning
• Kombinerade distribuerade cachear och minnescachear

Minnescache utan borttagning

Använd .WithCacheOptions(CacheOptions.EnableSharedCacheOptions) när du skapar ett tjänst-till-tjänst-program – AcquireTokenForClient som inte riktar sig mot många (fler än 100 000) klienter.

Important

Det finns inget sätt att styra cachens storlek med det här alternativet. Om du utvecklar en webbplats, ett webb-API eller en flerklientapp för tjänst-till-tjänst-kommunikation, se då avsnittet Memory cache with eviction.

    // Create the confidential client application
    app= ConfidentialClientApplicationBuilder.Create(clientId)
       // Alternatively to the certificate, you can use .WithClientSecret(clientSecret)
       .WithCertificate(cert)
       .WithLegacyCacheCompatibility(false)
       .WithCacheOptions(CacheOptions.EnableSharedCacheOptions)
       .WithAuthority(authority)
       .Build();

WithCacheOptions(CacheOptions.EnableSharedCacheOptions) gör att den interna MSAL-tokencachen delas mellan MSAL-klientprograminstanser. Det går snabbare att dela en tokencache än att använda någon serialisering av tokencachen, men den interna minnesbaserade tokencachen har inga utrensningsprinciper. Befintliga token uppdateras på plats, men hämtning av token för olika användare, klienter och resurser gör att cachen växer i enlighet med detta.

Minnescache med borttagning

Referera till Microsoft. Identity.Web.TokenCache NuGet-paketet till projektet.

Följande kod visar hur du lägger till en minnesintern cache med borttagning:

using Microsoft.Identity.Web;
using Microsoft.Identity.Client;
using Microsoft.Extensions.DependencyInjection;

public static async Task<AuthenticationResult> GetTokenAsync(string clientId, X509Certificate cert, string authority, string[] scopes)
 {
     // Create the confidential client application
     app= ConfidentialClientApplicationBuilder.Create(clientId)       
       .WithCertificate(cert)
       .WithLegacyCacheCompatibility(false)
       .WithAuthority(authority)
       .Build();

     // Add a static in-memory token cache and set an eviction policy
     app.AddInMemoryTokenCache(services =>
     {
         // Configure the memory cache options
         services.Configure<MemoryCacheOptions>(options =>
         {
              options.SizeLimit = 500 * 1024 * 1024; // in bytes (500 MB)
         });
      });
  }

Distribuerade cacheminnen

Om du använder app.AddDistributedTokenCache är tokencachen en adapter till implementeringen i .NET IDistributedCache. Så du kan välja mellan en SQL Server cache, en Redis-cache, en Azure Cosmos DB cache eller någon annan cache som implementerar IDistributedCache-gränssnittet.

I testsyfte kan du använda services.AddDistributedMemoryCache(), en minnesintern implementering av IDistributedCache.

Här är koden för en SQL Server cache:

     // SQL Server token cache
     app.AddDistributedTokenCache(services =>
     {
      services.AddDistributedSqlServerCache(options =>
      {
       
       // Requires to reference Microsoft.Extensions.Caching.SqlServer
       options.ConnectionString = @"Data Source=(localdb)\MSSQLLocalDB;Initial Catalog=TestCache;Integrated Security=True;Connect Timeout=30;Encrypt=False;TrustServerCertificate=False;ApplicationIntent=ReadWrite;MultiSubnetFailover=False";
       options.SchemaName = "dbo";
       options.TableName = "TestCache";

       // You don't want the SQL token cache to be purged before the access token has expired. Usually
       // access tokens expire after 1 hour (but this can be changed by token lifetime policies), whereas
       // the default sliding expiration for the distributed SQL database is 20 mins. 
       // Use a value above 60 mins (or the lifetime of a token in case of longer-lived tokens)
       options.DefaultSlidingExpiration = TimeSpan.FromMinutes(90);
      });
     });

Här är koden för en Redis-cache:

    // Redis token cache
    app.AddDistributedTokenCache(services =>
    {
      // Requires to reference Microsoft.Extensions.Caching.StackExchangeRedis
       services.AddStackExchangeRedisCache(options =>
       {
         options.Configuration = "localhost";
         options.InstanceName = "Redis";
       });

      // You can even decide if you want to repair the connection
      // with Redis and retry on Redis failures. 
      services.Configure<MsalDistributedTokenCacheAdapterOptions>(options => 
      {
        options.OnL2CacheFailure = (ex) =>
        {
          if (ex is StackExchange.Redis.RedisConnectionException)
          {
            // action: try to reconnect or something
            return true; //try to do the cache operation again
          }
          return false;
        };
      });
    });

Här är koden för en Azure Cosmos DB cache:

      // Azure Cosmos DB token cache
      app.AddDistributedTokenCache(services =>
      {
        // Requires to reference Microsoft.Extensions.Caching.Cosmos
        services.AddCosmosCache((CosmosCacheOptions cacheOptions) =>
        {
          cacheOptions.ContainerName = Configuration["CosmosCacheContainer"];
          cacheOptions.DatabaseName = Configuration["CosmosCacheDatabase"];
          cacheOptions.ClientBuilder = new CosmosClientBuilder(Configuration["CosmosConnectionString"]);
          cacheOptions.CreateIfNotExists = true;
        });
       });

Mer information om distribuerade cacheminnen finns i:

• Kryptering av distribuerad cache och avancerade alternativ
• Hantera borttagning av L2-cache
• Konfigurera en Redis-cache i Docker
• Troubleshooting

Inaktivera en äldre tokencache

MSAL har viss intern kod specifikt för att aktivera interaktion med äldre Microsofts autentiseringsbibliotek (ADAL)-cache. När MSAL och ADAL inte används sida vid sida används inte den äldre cachen och den relaterade äldre koden är onödig. MSAL 4.25.0 lägger till möjligheten att inaktivera äldre ADAL-cachekod och förbättra prestanda för cacheanvändning. En prestandajämförelse före och efter inaktivering av den äldre cachen finns i GitHub pull-begäran 2309.

Anropa .WithLegacyCacheCompatibility(false) på en applikationsbyggare som i följande kod.

var app = ConfidentialClientApplicationBuilder
	.Create(clientId)
	.WithClientSecret(clientSecret)
	.WithLegacyCacheCompatibility(false)
	.Build();

Samples

• Följande exempel är en ASP.NET webbapp: Använd OpenID Connect för att logga in användare för att Microsofts identitetsplattform.

Skrivbordsappar

I skrivbordsapplikationer rekommenderar vi att du använder det plattformsoberoende token-cacheminnet. MSAL.NET tillhandahåller plattformsoberoende tokencachen i ett separat bibliotek med namnet Microsoft. Identity.Client.Extensions.MSAL.

Referera till NuGet-paketet

Lägg till Microsoft. Identity.Client.Extensions.Msal NuGet-paketet i projektet.

Konfigurera tokencachen

I följande exempel visas hur du använder en plattformsoberoende tokencache:

 var storageProperties =
     new StorageCreationPropertiesBuilder(Config.CacheFileName, Config.CacheDir)
     .WithLinuxKeyring(
         Config.LinuxKeyRingSchema,
         Config.LinuxKeyRingCollection,
         Config.LinuxKeyRingLabel,
         Config.LinuxKeyRingAttr1,
         Config.LinuxKeyRingAttr2)
     .WithMacKeyChain(
         Config.KeyChainServiceName,
         Config.KeyChainAccountName)
     .Build();

 IPublicClientApplication pca = PublicClientApplicationBuilder.Create(clientId)
    .WithAuthority(Config.Authority)
    .WithRedirectUri("http://localhost")  // make sure to register this redirect URI for the interactive login 
    .Build();
    

// This hooks up the cross-platform cache into MSAL
var cacheHelper = await MsalCacheHelper.CreateAsync(storageProperties );
cacheHelper.RegisterCache(pca.UserTokenCache);    

Reservläge för oformaterad text

Den plattformsoberoende tokencachen gör att du kan lagra okrypterade token i en ACL-begränsad oformaterad textfil. Detta är användbart i de fall där kryptering av lagrad data misslyckas, vilket ibland sker av miljörelaterade skäl. Du kan använda återställningsläget för oformaterad text med hjälp av följande kodmönster:

storageProperties =
    new StorageCreationPropertiesBuilder(
        Config.CacheFileName + ".plaintext",
        Config.CacheDir)
    .WithUnprotectedFile()
    .Build();

var cacheHelper = await MsalCacheHelper.CreateAsync(storageProperties).ConfigureAwait(false);

Mobilappar

MSAL.NET tillhandahåller en minnesintern tokencache som standard. Serialisering tillhandahålls som standard för MAUI-mobilmål.

Skriva din egen cache

Om du vill skriva en egen tokencache-serialiserare tillhandahåller MSAL.NET anpassad tokencache-serialisering i .NET Framework- och .NET Core-underplatformerna. Händelser utlöses när cachen används. Appar kan välja om cachen ska serialiseras eller deserialiseras.

I konfidentiella klientprogram som hanterar användare (webbappar som loggar in användare och anropar webb-API:er och webb-API:er som anropar underordnade webb-API:er) kan det finnas många användare. Användarna bearbetas parallellt. Av säkerhetsskäl och prestandaskäl rekommenderar vi att du serialiserar en cache per användare. Serialiseringshändelser beräknar en cachenyckel baserat på den bearbetade användarens identitet och serialiserar eller deserialiserar en tokencache för den användaren.

Kom ihåg att anpassad serialisering inte är tillgänglig på mobila plattformar. MSAL definierar redan en säker och högpresterande serialiseringsmekanism för dessa plattformar. .NET skrivbords- och .NET Core-program har dock olika arkitekturer. Och MSAL kan inte implementera en generell serialiseringsmekanism.

Webbplatser kan till exempel välja att lagra token i en Redis-cache, eller så kan skrivbordsappar lagra token i en krypterad fil. Alltså ingår inte serialisering som standard. Om du vill ha ett beständigt tokencacheprogram i .NET skrivbord eller .NET Core anpassar du serialiseringen.

Följande klasser och gränssnitt används i tokencachens serialisering:

• ITokenCache definierar händelser för att prenumerera på tokencachens serialiseringsbegäranden och metoder för att serialisera eller deserialisera cachen i olika format (MSAL 2.x och MSAL 3.x).
• TokenCacheCallback är ett återanrop som skickas till händelserna så att du kan hantera serialiseringen. De anropas med argument av typen TokenCacheNotificationArgs.
• TokenCacheNotificationArgs innehåller ClientId bara programmets värde och en referens till den användare som token är tillgänglig för.

Important

MSAL.NET skapar tokencachar för dig. Den tillhandahåller cachen IToken när du anropar ett programs UserTokenCache- och AppTokenCache-egenskaper. Du ska inte implementera gränssnittet själv.

Det är ditt ansvar, när du implementerar en anpassad serialisering av tokencachen, att reagera på BeforeAccess- och AfterAccess-händelser (eller deras Async-varianter). Ombudet BeforeAccess ansvarar för att deserialisera cachen, medan den AfterAccess ansvarar för serialisering av cacheminnet. Delar av dessa händelser lagrar eller läser in blobar, som skickas via händelseargumentet till vilken lagring du vill.

Strategierna skiljer sig beroende på om du skriver en tokencache-serialisering för ett offentligt klientprogram (skrivbord) eller ett konfidentiellt klientprogram (webbapp, webb-API, daemon-app).

Anpassad tokencache för en webbapp eller ett webb-API (konfidentiellt klientprogram)

Om du vill skriva en egen serialiserare för tokencache för konfidentiella klientapplikationer rekommenderar vi att du ärver från Microsoft.Identity.Web.MsalAbstractTokenCacheProvider och åsidosätter metoderna WriteCacheBytesAsync och ReadCacheBytesAsync.

Exempel på tokencache-serialiserare finns i Microsoft. Identity.Web/TokenCacheProviders.

Anpassad tokencache för en skrivbords- eller mobilapp (offentligt klientprogram)

MSAL.NET v2.x och senare versioner innehåller flera alternativ för serialisering av tokencachen för en offentlig klient. Du kan endast serialisera cacheminnet till MSAL.NET format (cacheminnet för enhetligt format är vanligt mellan MSAL och plattformarna).
Anpassning av tokencachens serialisering för att dela tillståndet för enkel inloggning mellan ADAL.NET 3.x, ADAL.NET 5.x och MSAL.NET förklaras i en del av följande exempel: active-directory-dotnet-v1-to-v2.

Enkel serialisering av token-cache (endast MSAL)

Följande kod är ett exempel på en naiv implementering av anpassad serialisering av en tokencache för skrivbordsprogram. Här är cacheminnet för användartoken en fil i samma mapp som programmet.

När du har skapat programmet aktiverar du serialiseringen genom att anropa TokenCacheHelper.EnableSerialization() metoden och skicka programmets UserTokenCache egenskap.

app = PublicClientApplicationBuilder.Create(ClientId)
    .Build();
TokenCacheHelper.EnableSerialization(app.UserTokenCache);

Hjälpklassen TokenCacheHelper definieras som:

static class TokenCacheHelper
 {
  public static void EnableSerialization(ITokenCache tokenCache)
  {
   tokenCache.SetBeforeAccess(BeforeAccessNotification);
   tokenCache.SetAfterAccess(AfterAccessNotification);
  }

  /// <summary>
  /// Path to the token cache. Note that this could be something different, for instance, for MSIX applications:
  /// private static readonly string CacheFilePath =
  /// $"{Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData)}\{AppName}\msalcache.bin";
  /// </summary>
  public static readonly string CacheFilePath = System.Reflection.Assembly.GetExecutingAssembly().Location + ".msalcache.bin3";

  private static readonly object FileLock = new object();


  private static void BeforeAccessNotification(TokenCacheNotificationArgs args)
  {
   lock (FileLock)
   {
    args.TokenCache.DeserializeMsalV3(File.Exists(CacheFilePath)
            ? ProtectedData.Unprotect(File.ReadAllBytes(CacheFilePath),
                                      null,
                                      DataProtectionScope.CurrentUser)
            : null);
   }
  }

  private static void AfterAccessNotification(TokenCacheNotificationArgs args)
  {
   // if the access operation resulted in a cache update
   if (args.HasStateChanged)
   {
    lock (FileLock)
    {
     // reflect changes in the persistent store
     File.WriteAllBytes(CacheFilePath,
                         ProtectedData.Protect(args.TokenCache.SerializeMsalV3(),
                                                 null,
                                                 DataProtectionScope.CurrentUser)
                         );
    }
   }
  }
 }

En filbaserad serialiserare för tokencache av produktionskvalitet för offentliga klientapplikationer (för skrivbordsapplikationer som körs på Windows, Mac och Linux) finns tillgänglig i biblioteket med öppen källkod Microsoft.Identity.Client.Extensions.Msal. Du kan inkludera det i dina program från följande NuGet-paket: Microsoft. Identity.Client.Extensions.Msal.

Övervaka cacheträffar och cacheprestanda

MSAL exponerar viktiga mått som en del av AuthenticationResult.AuthenticationResultMetadata-objektet . Du kan logga dessa mått för att utvärdera hälsotillståndet för ditt program.

Metric	Meaning	När utlöser du ett larm?
DurationTotalInMs	Total tid i MSAL, inklusive nätverksanrop och cacheminne.	Larm om övergripande långa svarstider (> 1 sekund). Värdet beror på tokenkällan. Från cachen: en cacheåtkomst. Från Microsoft Entra ID: två cacheåtkomster plus ett HTTP-anrop. Första samtalet (per process) tar längre tid på grund av ett extra HTTP-anrop.
DurationInCacheInMs	Tid som läggs på att läsa in eller spara tokencachen, som apputvecklaren har anpassat (till exempel att spara i Redis).	Larm vid toppar.
DurationInHttpInMs	Tid som ägnas åt att göra HTTP-anrop till Microsoft Entra ID.	Larm vid toppar.
TokenSource	Tokens källa. Token hämtas från cachen mycket snabbare (till exempel ~100 ms jämfört med ~700 ms). Kan användas för att övervaka och larma cacheträffförhållandet.	Använd med DurationTotalInMs.
CacheRefreshReason	Orsak till att hämta åtkomsttoken från identitetsprovidern.	Använd med TokenSource.

Storleksimimeringar

När du använder en tokencache är det viktigt att tänka på cachens potentiella storlek, särskilt för program med hög tillgänglighet och distribuerade program. När användarna loggar in kommer det att finnas en cachepost för varje användare, cirka 7 KB i storlek. Storleken blir större om du anropar flera underordnade API:er. För tjänst-till-tjänst-autentisering kommer det att finnas en cachepost för varje klientorganisation och underordnat API, på cirka 2 kB.

Detaljerade uppskattningar visas nedan.

Programflöden (AcquireTokenForClient, AcquireTokenForManagedIdentity)

• Endast åtkomsttoken cachelagras. En token på cirka 2–3 kB vid lagring. Det kommer att finnas 1 token per appklient-ID * klientorganisationer * underordnade resurser. En app med flera klientorganisationer som betjänar 1 000 klienter och som behöver token för Graph och SharePoint använder till exempel: 3 KB * 1 000 * 2 d.v.s. cirka 6 MB.

Webbplats som anropar underordnat webb-API (AcquireTokenByAuthCode)

• Åtkomsttoken – 4 KB; 1 token per appklient-ID * användare * klient * underordnad resurs.
• Uppdateringstoken – 2 KB; 1 token per klientapps-ID * användare.
• ID-token – 2 KB; 1 token per klientapp-ID * användare * antal klienter där användaren loggar in.

Note

Vi rekommenderar starkt att du använder API:er på högre nivå från Microsoft.Identity.Web för detta och inte MSAL direkt. Övervägandena för cachelagring är desamma.

Webb-API som anropar annat webb-API (AcquireTokenOnBehalfOf)

Samma som för webbplatsscenario, men det kommer att finnas 1 nod för varje session, inte för varje användare. Som standard identifierar MSAL en session genom att hashkoda uppströmsassertionen, men detta kan ändras. Se Långvariga OBO-processer.

Note

Vi rekommenderar starkt att du använder API:er på högre nivå från Microsoft.Identity.Web för detta och inte MSAL direkt. Övervägandena för cachelagring är desamma.

Typer av tokencache

MSAL.NET fungerar med två typer av tokencacheminnen – användare och program.

Cacheminnet för programtoken som innehåller åtkomsttoken för det här programmet. Den underhålls och uppdateras tyst när du anropar AcquireTokenForClient.

Cacheminnet för användartoken innehåller ID-token, åtkomsttoken och uppdateringstoken för konton MSAL.NET interagerar med. Den används och uppdateras tyst om det behövs när du anropar AcquireTokenSilent. Den uppdateras av varje tokenanskaffningsmetod, med undantag för AcquireTokenForClient som endast använder programcachen.

Nästa steg

Följande exempel illustrerar tokencachens serialisering.

Sample	Platform	Description
active-directory-dotnet-desktop-msgraph-v2	Desktop (WPF)	Windows Desktop .NET-program (WPF) som anropar Microsoft Graph API.
active-directory-dotnet-v1-to-v2	Skrivbord (konsolen)	En uppsättning Visual Studio-lösningar som illustrerar migreringen av Azure AD v1.0-applikationer (med ADAL.NET) till applikationer för Microsofts identitetsplattform (med MSAL.NET).
ms-identity-aspnet-webapp-openidconnect	ASP.NET (net472)	Exempel på tokencache-serialisering i ett ASP.NET MVC-program (med MSAL.NET).