Lös problem med tokencache i Microsoft. Identity.Web

Den här artikeln hjälper dig att diagnostisera och lösa problem med tokencache i Microsoft. Identity.Web. Problem med tokencache kan orsaka autentiseringsfel, försämrad prestanda eller oväntade inloggningsprompter. En översikt över hur cachelagring av token fungerar i Microsoft. Identity.Web finns i Token cacheöversikt.

Förutsättningar

Bekräfta följande innan du felsöker:

• Du använder en version av Microsoft.Identity.Web som stöds.
• Ditt program har tokencachelagring konfigurerat i Program.cs eller Startup.cs.
• Du har åtkomst till programloggar och, om tillämpligt, din distribuerade cacheinfrastruktur.

Aktivera loggning och diagnostik för token-cache

Aktivera detaljerad loggning som ditt första diagnostiksteg. Microsoft. Identity.Web använder ASP.NET Core loggningsinfrastruktur och genererar händelser via Microsofts autentiseringsbibliotek (MSAL).

Aktivera MSAL-loggning

Ställ in loggnivån till Debug för identitetsbibliotek i din appsettings.json.

{
  "Logging": {
    "LogLevel": {
      "Default": "Information",
      "Microsoft.Identity.Web": "Debug",
      "Microsoft.IdentityModel": "Debug"
    }
  }
}

Prenumerera på MSAL-cachehändelser

Prenumerera på meddelandehändelser för MSAL-tokencache för att spåra cacheträffar, missar och serialiseringsaktivitet:

services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(Configuration)
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDistributedTokenCaches();

services.Configure<MsalDistributedTokenCacheAdapterOptions>(options =>
{
    options.OnL2CacheFailure = (ex) =>
    {
        logger.LogWarning(ex, "L2 cache failure encountered.");
        // Return true to allow the operation to continue despite the cache failure.
        // Return false to propagate the exception.
        return true;
    };
});

Övervaka cachemått

För produktionsövervakning följer du dessa nyckelmått:

• Träfffrekvens för cache – en låg träfffrekvens indikerar att token inte hämtas från cacheminnet.
• L2-cachefördröjning – hög svarstid tyder på en distribuerad cacheanslutning eller prestandaproblem.
• Cacheserialiseringsfel – fel under läsning eller skrivning indikerar korruption eller versionsinkompatibilitet.
• Minnesförbrukning – kontinuerlig tillväxt kan tyda på saknade rensningsprinciper.

Anslutningsfel för distribuerad cache (L2)

Symptom

Programloggar visar tidsgränsfel för anslutningar eller tillfälliga autentiseringsfel. Användarna får inloggningsfördröjningar och du ser undantag som:

Microsoft.Extensions.Caching.StackExchangeRedis.RedisCache:
  StackExchange.Redis.RedisConnectionException: 
  No connection is active/available to service this operation.

Eller för SQL Server distribuerad cache:

Microsoft.Data.SqlClient.SqlException:
  A network-related or instance-specific error occurred while 
  establishing a connection to SQL Server.

Orsak

Det distribuerade cachelagringsarkivet (Redis eller SQL Server) kan inte nås. Vanliga orsaker inkluderar:

• Felaktiga reťazec pripojenia eller utgångna åtkomstautentiseringsuppgifter.
• Brandväggsregler för nätverk blockerar anslutningen från appvärden.
• Cachetjänsten är nere eller under underhåll.
• Det finns en mismatch i SSL/TLS-konfigurationen mellan klienten och cacheservern.

Diagnostiksteg

Följ dessa steg för att identifiera anslutningsfelet:

1. Verifiera anslutningen. Från programvärden testar du anslutningen till Redis eller SQL Server med hjälp av Test-NetConnection (PowerShell) eller redis-cli.
2. Kontrollera anslutningssträngen. Bekräfta att reťazec pripojenia matchar cacheserverns värdnamn, port och autentiseringsuppgifter.
3. Granska brandväggsregler. I Azure kontrollerar du att apptjänsten eller det virtuella nätverket kan nå cacheresursen.
4. Kontrollera tjänstehälsa. I Azure portalen granskar du hälsotillståndet och måtten för din Azure Cache for Redis- eller SQL Database-instans.

Lösning

Steg 1: Korrigera anslutningssträngen

Kontrollera anslutningssträngen i din appsettings.json.

{
  "ConnectionStrings": {
    "Redis": "your-redis-instance.redis.cache.windows.net:6380,password=your-access-key,ssl=True,abortConnect=False"
  }
}

Steg 2: Konfigurera återförsök och återhämtning

Konfigurera callback-funktionen OnL2CacheFailure så att programmet hanterar degradering när denna distribuerade cache är tillfälligt otillgänglig.

services.Configure<MsalDistributedTokenCacheAdapterOptions>(options =>
{
    options.OnL2CacheFailure = (ex) =>
    {
        // Log the failure for monitoring and alerting.
        logger.LogWarning(ex, "Distributed token cache is unavailable. " +
            "Falling back to in-memory cache.");
        return true; // Continue without the L2 cache.
    };

    // Set a timeout to avoid blocking the request pipeline.
    options.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(12);
});

Steg 3: Öppna brandväggsregler

Om programmet körs i Azure App Service och cachen finns i ett virtuellt nätverk lägger du till utgående IP-adresser för App Service i listan över tillåtna cachebrandväggar.

cache-deserialiseringsfel

Symptom

När du har uppgraderat Microsoft. Identity.Web eller MSAL.NET genererar programmet deserialiseringsfel vid läsning från den distribuerade cachen. Användarna måste logga in igen och du ser undantag som:

System.Text.Json.JsonException:
  The JSON value could not be converted to the expected type.

Eller:

Microsoft.Identity.Client.MsalClientException:
  Error code: json_parse_failed

Orsak

Serialiseringsformatet för tokencache har ändrats mellan biblioteksversionerna. Token som cachelagras av den tidigare versionen kan inte deserialiseras av den nya versionen. Det här problemet uppstår oftast vid större versionsuppgraderingar av MSAL.NET eller Microsoft. Identity.Web.

Lösning

Alternativ A: Rensa cacheminnet

Den enklaste korrigeringen är att rensa alla poster i den distribuerade cachen. Användare autentiserar igen en gång och efterföljande token skrivs i det nya formatet.

Rensa Redis-cachen:

redis-cli FLUSHDB

Eller rensa den distribuerade SQL Server-cachetabellen:

DELETE FROM [dbo].[TokenCache];

Alternativ B: Hantera deserialiseringsfel på ett korrekt sätt

Konfigurera cachekortet så att deserialiseringsfel behandlas som cachemissar i stället för allvarliga fel:

services.Configure<MsalDistributedTokenCacheAdapterOptions>(options =>
{
    options.OnL2CacheFailure = (ex) =>
    {
        if (ex is JsonException or MsalClientException)
        {
            logger.LogWarning(ex, "Cache deserialization failed. " +
                "Treating as cache miss.");
            return true;
        }
        return false; // Propagate unexpected errors.
    };
});

Med den här metoden ersätts berörda cacheposter automatiskt när användarna autentiserar igen och ingen manuell cachespolning krävs.

Felmatchning av krypteringsnyckel mellan servrar

Symptom

Deserialiseringsfel uppstår i distributioner med flera instanser trots att den distribuerade cachen fungerar. Token som cachelagras av en serverinstans kan inte läsas av en annan. Du ser json_parse_failed eller IDW10802 fel i loggarna.

Orsak

När cachekryptering är aktiverat (options.Encrypt = true) Microsoft. Identity.Web använder ASP.NET Core Dataskydd för att kryptera cacheposter. Som standard genererar varje serverinstans sina egna dataskyddsnycklar, så en instans kan inte dekryptera poster som skrivits av en annan.

Lösning

Konfigurera ASP.NET Core Dataskydd för att dela krypteringsnycklar över alla serverinstanser.

Alternativ A: Azure Blob Storage + Azure Key Vault (rekommenderas för Azure distributioner)

using Microsoft.AspNetCore.DataProtection;
using Azure.Identity;

builder.Services.AddDataProtection()
    .PersistKeysToAzureBlobStorage(
        new Uri("https://yourstorageaccount.blob.core.windows.net/dataprotection/keys.xml"),
        new DefaultAzureCredential())
    .ProtectKeysWithAzureKeyVault(
        new Uri("https://yourkeyvault.vault.azure.net/keys/dataprotection-key"),
        new DefaultAzureCredential());

builder.Services.Configure<MsalDistributedTokenCacheAdapterOptions>(options =>
{
    options.Encrypt = true;
});

Den här konfigurationen lagrar dataskyddsnyckelringen i Azure Blob Storage och skyddar nycklarna i vila med Azure Key Vault. Alla programinstanser som har åtkomst till samma blob och nyckel kan kryptera och dekryptera varandras cacheposter.

Alternativ B: Delat filsystem med certifikatskydd

builder.Services.AddDataProtection()
    .PersistKeysToFileSystem(new DirectoryInfo(@"\\server\share\keys"))
    .ProtectKeysWithCertificate(certificate);

Minnestillväxt med minnesintern cache

Symptom

Programminnesförbrukningen växer successivt med tiden. Om programmet körs i en container eller en App Service-plan med en fast minnesgräns startar det om eller kastar OutOfMemoryException. Övervakning visar hur den hanterade heapen växer utan återvinning av skräpinsamling.

Orsak

Användning AddInMemoryTokenCaches() utan storleksbegränsningar orsakar obundna cachetillväxt. Den här situationen är särskilt problematisk i program som betjänar många användare, eftersom varje användares tokenpost förbrukar minne på obestämd tid.

Som standardinställning tvingar MemoryCache inte en maximal storlek och tar inte bort poster om inte en utgångspolicy har angivits.

Lösning

Alternativ A: Ange en storleksgräns och glidande förfallotid

Konfigurera minnesintern cache med förfalloprinciper:

services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(Configuration)
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddInMemoryTokenCaches();

services.Configure<MsalMemoryTokenCacheOptions>(options =>
{
    options.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(12);
    options.SlidingExpiration = TimeSpan.FromHours(2);
});

Med de här inställningarna upphör poster att gälla efter 12 timmar oavsett åtkomst, och poster som är inaktiva i 2 timmar avlägsnas tidigare.

Alternativ B: Växla till en distribuerad cache

För program med många samtidiga användare skalas inte en minnesintern cache. Växla till en distribuerad cache, till exempel Redis:

services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = Configuration.GetConnectionString("Redis");
});

services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(Configuration)
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDistributedTokenCaches();

En distribuerad cache avlastar minnet från programprocessen, bevarar token över omstarter och stöder distributioner med flera instanser.

Alternativ C: Använd hybridarkitekturen L1/L2

Microsoft. Identity.Web stöder en hybridmetod som kombinerar en snabb intern L1-cache med en beständig distribuerad L2-cache. Konfigurera L1-/L2-hybridcachen:

services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(Configuration)
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDistributedTokenCaches();

services.Configure<MsalDistributedTokenCacheAdapterOptions>(options =>
{
    options.L1CacheOptions = new MsalMemoryTokenCacheOptions
    {
        AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5),
        SlidingExpiration = TimeSpan.FromMinutes(2)
    };
});

Med L1/L2-cachelagring levereras ofta använda token från i minnet (L1) med en svarstid på under en millisekund. L2-cachen ger beständighet och konsistens mellan instanser. L1-cachen använder korta förfallodatum för att begränsa minnestillväxten.

Upprepade uppmaningar om MFA eller godkännande

Symptom

Användare uppmanas upprepade gånger om multifaktorautentisering (MFA) eller medgivande trots att de nyligen har slutfört dessa steg. Programmet kan inte hitta befintliga token i cacheminnet.

Orsak

Det här problemet uppstår när tokencachesökningen inte matchar en cachelagrad post med det aktuella användarkontot. Vanliga orsaker inkluderar:

• Cachenyckeln skiljer sig från den som användes när token lagrades. Den här situationen kan inträffa om HomeAccountId eller tenantkontexten ändras.
• Programmet kör flera instanser bakom en lastbalanserare med minnesintern cachelagring och begäranden dirigeras till en instans som inte har användarens token.
• De begärda anspråken eller omfången har ändrats, så den cachelagrade token uppfyller inte det nya kravet.
• Sessionstillhörighet är inte aktiverat, så användarna dirigerar till olika instanser som saknar sina cachelagrade token.

Diagnostiksteg

Följ de här stegen för att identifiera varför token inte hittas i cacheminnet:

1. Kontrollera cachetypen. Om du använder AddInMemoryTokenCaches() i en distribution med flera instanser är token som cachelagrats på en instans inte tillgängliga på en annan. Växla till en distribuerad cache.
2. Verifiera kontoidentifieraren. Aktivera loggning på felsökningsnivå och sök efter HomeAccountId. Bekräfta att identifieraren är konsekvent mellan begäranden.
3. Granska omfången. Bekräfta att de omfång som begärdes av GetAccessTokenForUserAsync matchar de omfång som ursprungligen samtyckte till. Ett omfångsmatchningsfel gör att MSAL begär en ny token.
4. Granska principer för villkorsstyrd åtkomst. En Microsoft Entra ID princip för villkorsstyrd åtkomst som kräver stegvis autentisering för specifika resurser orsakar ytterligare frågor som inte är relaterade till cachelagring.

Lösning

Steg 1: Växla till distribuerad cachelagring

Om programmet kör flera instanser använder du en distribuerad cache för att dela token mellan instanser:

services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = Configuration.GetConnectionString("Redis");
});

services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(Configuration)
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDistributedTokenCaches();

Steg 2: Verifiera konsekventa omfång

Se till att de omfång som du begär när du hämtar token matchar de omfång som konfigurerats under autentiseringen:

// In authentication setup — initial scopes.
.EnableTokenAcquisitionToCallDownstreamApi(new[] { "User.Read", "Mail.Read" })

// When acquiring a token — use the same scopes.
var token = await tokenAcquisition.GetAccessTokenForUserAsync(
    new[] { "User.Read", "Mail.Read" });

Steg 3: Aktivera sessionstillhörighet (tillfällig lösning)

Om du inte kan växla till ett distribuerat cacheminne direkt aktiverar du sessionstillhörighet (klibbiga sessioner) i lastbalanseraren. Sessionstillhörighet dirigerar en användares begäranden till samma instans. Den här metoden är en tillfällig lösning med skalbarhetsbegränsningar.

Problem med cacheprestanda

Symptom

Tokenhämtningen är långsam och underordnade API-anrop har ökad svarstid. Övervakning visar höga genomsnittliga svarstider för begäranden om tokenförvärv. Svarstiden kommer inte från identitetsprovidern – token hanteras från cacheminnet.

Orsak

Cacheprestandaproblem beror vanligtvis på:

• Hög L2-cachefördröjning. Den distribuerade cachen är hårt belastad, geografiskt avlägsen från programmet eller använder en undersedd tjänstnivå.
• Stora poster i tokencachen. Program som cachelagrar token för många resurser per användare kan skapa stora serialiserade cacheposter som är långsamma att läsa och skriva.
• Ingen L1-cache. Varje tokenförvärv går till den distribuerade cachen över nätverket, även för token som används ofta.

Lösning

Steg 1: Aktivera cacheminnet L1 i minnet

L1-cachen lagrar token som används ofta i processminnet och undviker nätverksresor till L2:

services.Configure<MsalDistributedTokenCacheAdapterOptions>(options =>
{
    options.L1CacheOptions = new MsalMemoryTokenCacheOptions
    {
        AbsoluteExpirationRelativeToNow = TimeSpan.FromMinutes(5),
        SlidingExpiration = TimeSpan.FromMinutes(2)
    };
});

Med den här konfigurationen har token som hanteras från L1 svarstid på under millisekunder. Token som inte finns i L1 återgår till den distribuerade L2-cachen.

Steg 2: Optimera den distribuerade cachenivån

Om L2-cachefördröjningen är hög bör du överväga följande åtgärder:

• Skala upp Redis-instansen. Flytta till en högre nivå (till exempel från Basic till Standard eller Premium i Azure Cache for Redis) för att få mer dataflöde och kortare svarstid.
• Aktivera geo-replikering. Om ditt program hanterar användare i flera regioner, använder du Azure Cache for Redis geo-replikering så att cacheminnet ligger nära varje regions beräkningsresurser.
• Granska nätverkskonfigurationen. Använd Private Link- eller VNet-integrering för att minska nätverkshoppen mellan programmet och cacheminnet.

Steg 3: Minska serialiserad tokenstorlek

Om poster för tokencache är stora kontrollerar du om programmet begär token för fler resurser än nödvändigt. Varje unik resurs- och omfångskombination lägger till cachens inmatningsstorlek. Konsolidera API-anrop där det är möjligt för att minska antalet distinkta åtkomsttoken som cachelagras per användare.

Borttagning av Redis-cache

Symptom

Användare uppmanas tillfälligt att autentisera igen utan mönster baserat på tokens förfallotid. Redis-övervakning visar att evicted_keys ökar och att used_memory närmar sig maxmemory-gränsen.

Orsak

När Redis når sin maxmemory gräns avlägsnas nycklar baserat på den konfigurerade maxmemory-policy. Standardprincipen (volatile-lru) tar bort de senast använda nycklarna som har en förfallotid. Om Redis-instansen används med annan programapplikationsdata konkurrerar token-cacheposter om utrymme och kan avlägsnas i förtid.

Lösning

Steg 1: Kontrollera borttagningsprincipen

Kontrollera den aktuella borttagningsprincipen:

redis-cli CONFIG GET maxmemory-policy

För token-cachar volatile-lru är (som standard) lämpligt eftersom poster för token-cachar har utgångsdatum. Men om andra data utan förfallodatum förbrukar minne avlägsnas tokenposter först.

Steg 2: Använd en dedikerad Redis-instans

Isolera tokencachen från andra programdata med hjälp av en dedikerad Redis-instans:

{
  "ConnectionStrings": {
    "RedisTokenCache": "token-cache-redis.redis.cache.windows.net:6380,password=...,ssl=True,abortConnect=False",
    "RedisAppData": "app-data-redis.redis.cache.windows.net:6380,password=...,ssl=True,abortConnect=False"
  }
}

// Register the token cache Redis instance specifically for distributed caching.
services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = Configuration.GetConnectionString("RedisTokenCache");
});

Steg 3: Öka redis-minnesgränsen

Om en dedikerad instans inte är möjlig ökar du inställningen maxmemory . I Azure Cache for Redis skalar du upp till en högre nivå eller ökar cachestorleken.

Steg 4: Ange lämpliga förfallodatum för cachepost

Ange rimliga förfallodatum så att inaktuella poster tas bort innan minnet tar slut:

services.Configure<MsalDistributedTokenCacheAdapterOptions>(options =>
{
    options.AbsoluteExpirationRelativeToNow = TimeSpan.FromHours(12);
    options.SlidingExpiration = TimeSpan.FromHours(2);
});

SQL-distribuerad cachetabelltillväxt

Symptom

Den SQL-distribuerade cachetabellen växer kontinuerligt och förbrukar diskutrymme. Databasfrågor mot cachetabellen tar lång tid och du kan se varningar om tabellstorlek eller lagringsgränser.

Orsak

Den SQL Server distribuerade cachen (Microsoft.Extensions.Caching.SqlServer) tar inte bort poster som har upphört att gälla automatiskt. Förfallna poster förblir tills de uttryckligen rensas, vilket orsakar obundna tabelltillväxt, försämrad frågeprestanda och lagringsförbrukning.

Lösning

Steg 1: Konfigurera ett återkommande rensningsjobb

Skapa ett SQL Server Agent jobb eller schemalagd aktivitet för att regelbundet ta bort poster som har upphört att gälla:

-- Delete expired entries from the SQL distributed cache table.
-- Schedule this query to run every 30 minutes.
DELETE FROM [dbo].[TokenCache]
WHERE ExpiresAtTime < GETUTCDATE();

Steg 2: Lägg till ett index för effektiv rensning

Om cachetabellen inte redan har ett index för förfallokolumnen lägger du till en för att påskynda borttagningen:

CREATE NONCLUSTERED INDEX IX_TokenCache_ExpiresAtTime
ON [dbo].[TokenCache] (ExpiresAtTime);

Steg 3: Övervaka tabellstorlek

Lägg till övervakning för att spåra radantal och tabellstorlek över tid:

SELECT
    COUNT(*) AS TotalEntries,
    COUNT(CASE WHEN ExpiresAtTime < GETUTCDATE() THEN 1 END) AS ExpiredEntries,
    COUNT(CASE WHEN ExpiresAtTime >= GETUTCDATE() THEN 1 END) AS ActiveEntries
FROM [dbo].[TokenCache];

Steg 4: Överväg att byta till Redis

Om hanteringen av SQL Cache-rensning är betungande växlar du till Redis, som hanterar förfallodatum automatiskt via den inbyggda TTL-mekanismen:

// Replace SQL distributed cache with Redis.
services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = Configuration.GetConnectionString("Redis");
});

Allmänna felsökningstips

Använd de här tipsen när problemet inte matchar ett specifikt scenario i den här artikeln.

Kontrollera att cachen används

Lägg till tillfällig loggning för att bekräfta att token läses från och skrivs till cachen:

services.Configure<MsalDistributedTokenCacheAdapterOptions>(options =>
{
    options.Encrypt = false; // Disable encryption temporarily for debugging only.
    options.OnL2CacheFailure = (ex) =>
    {
        logger.LogError(ex, "L2 cache operation failed.");
        return true;
    };
});

Sök efter flera cacheregistreringar

Om det finns flera anrop till AddInMemoryTokenCaches() eller AddDistributedTokenCaches() i din startkod, avgörs det av den senaste registreringen. Kontrollera att endast en cachetyp är registrerad.

Granska tokens livslängd

Åtkomsttoken har en begränsad livslängd (vanligtvis 60–90 minuter). Om användarna rapporterar återautentisering efter den här perioden, är detta det förväntade beteendet och inte ett cacheproblem. Uppfräschningskoder hämtar nya åtkomstkoder utan användarens medverkan och lagras i cacheminnet. Om uppdateringstoken saknas eller har upphört att gälla måste användaren autentisera igen.

Testa med en ren cache

När du diagnostiserar problem rensar du cachen för att utesluta skadade eller inaktuella poster:

• Minnesintern cache: Starta om programmet.
• Redis: Kör FLUSHDB på cachedatabasen.
• SQL Server: Ta bort alla rader från cachetabellen.

Tokencache tom efter omstart av programmet

Symptom

Användarna måste autentisera igen efter varje omstart eller omdistribution av program. Den distribuerade cachen visas tom eller så sparas inte token.

Orsak

Det här problemet uppstår vanligtvis när du använder en minnesintern cache (AddInMemoryTokenCaches()) eller den icke-beständiga distribuerade minnescachen (AddDistributedMemoryCache()) i produktion. Inget av alternativen bevarar tokens vid programomstarter.

AddDistributedMemoryCache() registrerar en IDistributedCache implementering som lagrar data i minnet. Trots det "distribuerade" namnet bevaras inte data externt och är endast avsett för utveckling och testning.

Lösning

Växla till en beständig distribuerad cache:

// Register a persistent cache (Redis example).
builder.Services.AddStackExchangeRedisCache(options =>
{
    options.Configuration = builder.Configuration.GetConnectionString("Redis");
    options.InstanceName = "MyApp_";
});

// Use distributed token caches instead of in-memory.
builder.Services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
    .AddMicrosoftIdentityWebApp(builder.Configuration)
    .EnableTokenAcquisitionToCallDownstreamApi()
    .AddDistributedTokenCaches();

Relaterat innehåll

• Översikt över tokencache