Het NuGet-pakket Microsoft.Identity.Web.TokenCache biedt serialisatie van tokencaches in de Microsoft.Identity.Web-bibliotheek.
Als u de MSAL-bibliotheek rechtstreeks in een ASP.NET Core-app gebruikt, kunt u overwegen Microsoft.Identity.Web te gebruiken, wat een eenvoudigere API op een hoger niveau biedt. Zie anders Niet-ASP.NET Core web-apps en web-API's, waarin direct MSAL-gebruik wordt behandeld.
| Extensiemethode |
Description |
| AddInMemoryTokenCaches |
Hiermee maakt u een tijdelijke cache in het geheugen voor tokenopslag en ophalen. Tokencaches in het geheugen zijn sneller dan andere cachetypen, maar hun tokens blijven niet behouden tussen het opnieuw opstarten van de toepassing en u kunt de cachegrootte niet bepalen. Caches in het geheugen zijn geschikt voor toepassingen waarvoor geen tokens hoeven te worden bewaard tussen het opnieuw opstarten van apps. Gebruik een tokencache in het geheugen in apps die deelnemen aan verificatiescenario's van computer-naar-computer, zoals services, daemons en andere die AcquireTokenForClient gebruiken (de clientreferenties verlenen). Tokencaches in het geheugen zijn ook geschikt voor voorbeeldtoepassingen en tijdens het ontwikkelen van lokale apps. Microsoft.Identity.Web-versies 1.19.0+ delen een tokencache in het geheugen in alle toepassingsexemplaren. |
| AddSessionTokenCaches |
De tokencache is gebonden aan de gebruikerssessie. Deze optie is niet ideaal als het id-token veel claims bevat, omdat de cookie te groot wordt. |
AddDistributedTokenCaches |
De tokencache is een adapter voor de ASP.NET Core IDistributedCache implementatie. Hiermee kunt u kiezen tussen een gedistribueerde geheugencache, een Redis-cache, een gedistribueerde NCache of een SQL Server-cache. Zie IDistributedCachegedistribueerde geheugencache voor meer informatie over de implementaties. |
Tokencache in het geheugen
Hier volgt een voorbeeld van code die gebruikmaakt van de cache in het geheugen in de methode ConfigureServices van de klasse Startup in een ASP.NET Core-toepassing:
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 is geschikt in productie als u alleen-app-tokens aanvraagt. Als u gebruikerstokens gebruikt, kunt u overwegen een gedistribueerde tokencache te gebruiken.
Configuratiecode voor tokencache is vergelijkbaar tussen ASP.NET Core web-apps en web-API's.
Gedistribueerde tokencaches
Hier volgen voorbeelden van mogelijke gedistribueerde caches:
// 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;
});
Zie voor meer informatie:
Het gebruik van gedistribueerde cache wordt weergegeven in de zelfstudie ASP.NET Core web-app in de fase 2-2 tokencache.
Als u MSAL.NET gebruikt in uw web-app of web-API, kunt u profiteren van serializers voor tokencache in Microsoft.Identity.Web.TokenCache
Verwijzen naar het NuGet-pakket
Voeg het NuGet-pakket Microsoft.Identity.Web.TokenCache toe aan uw project in plaats van MSAL.NET.
De tokencache configureren
De volgende code laat zien hoe u een goed gepartitioneerde tokencache in het geheugen toevoegt aan uw app.
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)
// Alternatively to the certificate, you can use .WithClientSecret(clientSecret)
.WithCertificate(cert)
.WithLegacyCacheCompatibility(false)
.WithAuthority(authority)
.Build();
// Add a static in-memory token cache. Other options available: see below
app.AddInMemoryTokenCache(); // Microsoft.Identity.Web.TokenCache 1.17+
// Make the call to get a token for client_credentials flow (app-to-app scenario)
return await app.AcquireTokenForClient(scopes).ExecuteAsync();
// OR Make the call to get a token for OBO (web API scenario)
return await app.AcquireTokenOnBehalfOf(scopes, userAssertion).ExecuteAsync();
// OR Make the call to get a token via auth code (web app scenario)
return await app.AcquireTokenByAuthorizationCode(scopes, authCode);
// OR, when the user has previously logged in, get a token silently
string homeAccountId = User.GetHomeAccountId(); // uid and utid claims
var account = await app.GetAccountAsync(homeAccountId);
try
{
return await app.AcquireTokenSilent(scopes, account).ExecuteAsync();;
}
catch (MsalUiRequiredException)
{
// cannot get a token silently, so redirect the user to be challenged
}
}
Beschikbare technologieën voor in de cache opslaan
In plaats van app.AddInMemoryTokenCache();kunt u verschillende serialisatietechnologieën gebruiken voor in de cache opslaan. U kunt bijvoorbeeld geen serialisatie, in het geheugen en gedistribueerde tokencache-opslag van .NET gebruiken.
Serialisatie van aangepaste tokencache
U kunt opgeven dat u geen serialisatie van tokencaches wilt hebben en in plaats daarvan afhankelijk bent van de MSAL.NET interne cache. Gebruik .WithCacheOptions(CacheOptions.EnableSharedCacheOptions) bij het bouwen van de toepassing en voeg geen serialisatiefunctie toe.
r.
// 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) maakt de interne MSAL-tokencache gedeeld tussen exemplaren van de MSAL-clienttoepassing. Het delen van een tokencache is sneller dan serialisatie van tokencaches, maar de interne tokencache in het geheugen heeft geen verwijderingsbeleid. Bestaande tokens worden ter plaatse vernieuwd, maar het ophalen van tokens voor verschillende gebruikers, tenants en resources zorgt ervoor dat de cache dienovereenkomstig groeit.
Als u deze aanpak gebruikt en een groot aantal gebruikers of tenants hebt, moet u de geheugenvoetafdruk controleren. Als de geheugenvoetafdruk een probleem wordt, kunt u overwegen serialisatie van de tokencache in te schakelen, waardoor de interne cachegrootte kan worden verkleind. Op dit moment kunt u gedeelde cache en cacheserialisatie niet samen gebruiken.
Tokencache in het geheugen
Serialisatie van tokencache in het geheugen is geweldig bij voorbeelden. Het werkt ook goed in productietoepassingen als u alleen app-tokens aanvraagt (AcquireTokenForClient), mits u het niet erg vindt als de tokencache verloren gaat wanneer de web-app opnieuw wordt opgestart. We raden het niet aan in productie te gebruiken als u gebruikerstokens (AcquireTokenByAuthorizationCode, AcquireTokenSilent, AcquireTokenOnBehalfOf) aanvraagt.
// Add an in-memory token cache
app.AddInMemoryTokenCache();
U kunt ook opties opgeven om de grootte van de tokencache in het geheugen te beperken:
// Add an in-memory token cache with options
app.AddInMemoryTokenCache(services =>
{
// Configure the memory cache options
services.Configure<MemoryCacheOptions>(options =>
{
options.SizeLimit = 500 * 1024 * 1024; // in bytes (500 MB)
});
}
);
Gedistribueerde caches
Als u app.AddDistributedTokenCache gebruikt, is de tokencache een adapter bij de .NETIDistributedCache-implementatie. U kunt dus kiezen tussen een SQL Server-cache, een Redis-cache, een Azure Cosmos DB-cache of een andere cache die de IDistributedCache-interface implementeert.
Alleen voor testdoeleinden kunt u services.AddDistributedMemoryCache() gebruiken, een implementatie in het geheugen van IDistributedCache.
Hier volgt de code voor een 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);
});
});
Hier volgt de code voor een 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;
};
});
});
Dit is de code voor een 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;
});
});
Zie voor meer informatie over gedistribueerde caches:
Een verouderde tokencache uitschakelen
MSAL bevat specifieke interne code om interacties met verouderde ADAL-cache (Microsoft Authentication Library) mogelijk te maken. Wanneer MSAL en ADAL niet naast elkaar worden gebruikt, wordt de verouderde cache niet gebruikt en is de gerelateerde verouderde code niet nodig. MSAL 4.25.0 voegt de mogelijkheid toe om verouderde ADAL-cachecode uit te schakelen en de prestaties van het cachegebruik te verbeteren. Zie GitHub pull-aanvraag 2309 voor een prestatievergelijking voor en na het uitschakelen van de verouderde cache.
Roep .WithLegacyCacheCompatibility(false) binnen een toepassingsbouwer aan zoals de volgende code.
var app = ConfidentialClientApplicationBuilder
.Create(clientId)
.WithClientSecret(clientSecret)
.WithLegacyCacheCompatibility(false)
.Build();
Voorbeelden
In bureaubladtoepassingen raden we u aan de platformoverschrijdende tokencache te gebruiken. MSAL.NET biedt de platformoverschrijdende tokencache in een afzonderlijke bibliotheek met de naam Microsoft.Identity.Client.Extensions.Msal.
Verwijzen naar het NuGet-pakket
Voeg het pakket Microsoft.Identity.Client.Extensions.Msal NuGet toe aan uw project.
De tokencache configureren
Zie Tokencache voor meerdere platformen voor meer informatie. Hier volgt een voorbeeld van het gebruik van de platformoverschrijdende 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);
Terugvalmodus voor tekst zonder opmaak
Met de platformoverschrijdende tokencache kunt u niet-versleutelde tokens opslaan in tekst zonder opmaak. Deze functie is alleen bedoeld voor gebruik in ontwikkelomgevingen voor foutopsporing.
U kunt de terugvalmodus voor tekst zonder opmaak gebruiken met het codepatroon.
storageProperties =
new StorageCreationPropertiesBuilder(
Config.CacheFileName + ".plaintext",
Config.CacheDir)
.WithUnprotectedFile()
.Build();
var cacheHelper = await MsalCacheHelper.CreateAsync(storageProperties).ConfigureAwait(false);
MSAL.NET biedt standaard een tokencache in het geheugen. Serialisatie wordt standaard geboden voor platforms waar beveiligde opslag beschikbaar is voor een gebruiker als onderdeel van het platform: Universeel Windows-platform (UWP), Xamarin.iOS en Xamarin.Android.
Als u uw eigen serialisatiefunctie voor tokencache wilt schrijven, biedt MSAL.NET aangepaste serialisatie van de tokencache in de .NET Framework- en .NET Core-subplatformen. Gebeurtenissen worden geactiveerd wanneer de cache wordt geopend. Apps kunnen kiezen of de cache moet worden geserialiseerd of gedeserialiseerd.
Voor vertrouwelijke clienttoepassingen die gebruikers verwerken (web-apps die gebruikers aanmelden en web-API's aanroepen, en web-API's die downstream-web-API's aanroepen), kunnen er veel gebruikers zijn. De gebruikers worden parallel verwerkt. Voor de veiligheid en prestaties wordt aanbevolen één cache per gebruiker te serialiseren. Gebeurtenissen inzake serialisatie berekenen een cachesleutel op basis van de identiteit van de verwerkte gebruiker en serialiseren of deserialiseren van een tokencache voor die gebruiker.
Houd er rekening mee dat aangepaste serialisatie niet beschikbaar is op mobiele platforms (UWP, Xamarin.iOS en Xamarin.Android). MSAL definieert al een veilig en presterend serialisatiemechanisme voor deze platforms. .NET Desktop- en .NET Core-toepassingen hebben echter verschillende architecturen. En MSAL kan geen serialisatiemechanisme voor algemeen gebruik implementeren.
Websites kunnen bijvoorbeeld kiezen om tokens op te slaan in een Redis-cache, of desktop-apps slaan tokens op in een versleuteld bestand. Serialisatie is dus niet gebruiksklaar beschikbaar. Als u een permanente toepassing voor tokencaches in .NET Desktop of .NET Core wilt hebben, past u de serialisatie aan.
De volgende klassen en interfaces worden gebruikt in serialisatie van tokencaches:
ITokenCache definieert gebeurtenissen voor het abonneren op serialisatieaanvragen voor tokencache en methoden voor het serialiseren of deserialiseren van de cache in verschillende indelingen (MSAL 2.x en MSAL 3.x).TokenCacheCallback is een callback die wordt doorgegeven aan de gebeurtenissen, zodat u de serialisatie kunt afhandelen. Ze worden aangeroepen met argumenten van het type TokenCacheNotificationArgs.TokenCacheNotificationArgs geeft alleen de waarde ClientId van de toepassing en een verwijzing naar de gebruiker waarvoor het token beschikbaar is.
Belangrijk
MSAL.NET maakt tokencaches voor u. Het biedt u de IToken cache wanneer u de en UserTokenCache eigenschappen van AppTokenCache een toepassing aanroept. U hoort de interface niet zelf te implementeren.
Wanneer u een aangepaste serialisatie van de tokencache implementeert, moet u reageren op BeforeAccess gebeurtenissen AfterAccess (of de bijhorende Async variëteiten). De BeforeAccess gemachtigde is verantwoordelijk voor het deserialiseren van de cache, terwijl de AfterAccess gemachtigde verantwoordelijk is voor het serialiseren van de cache. Delen van deze gebeurtenissen slaan blobs op of laden blobs, die via het gebeurtenisargument worden doorgegeven aan de gewenste opslag.
De strategieën verschillen, afhankelijk van of u een token-cache-serialisatie schrijft voor een openbare clienttoepassing (desktop) of een vertrouwelijke clienttoepassing (web-app, web-API, daemon-app).
Aangepaste tokencache voor een web-app of web-API (vertrouwelijke clienttoepassing)
Als u uw eigen serialisatiefunctie voor tokencache wilt schrijven voor vertrouwelijke clienttoepassingen, raden we aan deze over te nemen van Microsoft.Identity.Web.MsalAbstractTokenCacheProvider en de WriteCacheBytesAsync en ReadCacheBytesAsync methoden te overschrijven.
Voorbeelden van serialisatiefuncties voor tokencaches zijn beschikbaar in Microsoft.Identity.Web/TokenCacheProviders.
Aangepaste tokencache voor een desktop- of mobiele app (openbare clienttoepassing)
MSAL.NET v2.x en latere versies bieden verschillende opties voor het serialiseren van de tokencache van een openbare client. U kunt de cache alleen serialiseren naar de MSAL.NET-indeling. (De geïntegreerde indelingscache is gebruikelijk voor MSAL en de platforms.) U kunt ook ondersteuning bieden voor de serialisatie van de verouderde tokencache van ADAL v3.
Het aanpassen van de serialisatie van de tokencache om de status van eenmalige aanmelding te delen tussen ADAL.NET 3.x, ADAL.NET 5.x en MSAL.NET wordt uitgelegd in een deel van het volgende voorbeeld: active-directory-dotnet-v1-to-v2.
Notitie
De voorbeeld indeling MSAL.NET 1.1.4-tokencache wordt niet meer ondersteund in MSAL 2.x. Als u toepassingen hebt die gebruikmaken van MSAL.NET 1.x, moeten uw gebruikers zich opnieuw aanmelden. De migratie van ADAL 4.x (en 3.x) wordt ondersteund.
Eenvoudige serialisatie van tokencache (alleen MSAL)
De volgende code is een voorbeeld van systeemeigen implementatie van aangepaste serialisatie van een tokencache voor desktoptoepassingen. Hier is de gebruikerstokencache een bestand in dezelfde map als de toepassing.
Nadat u de toepassing hebt gebouwd, schakelt u de serialisatie in door de TokenCacheHelper.EnableSerialization() methode aan te roepen en de eigenschap van UserTokenCache de toepassing door te geven.
app = PublicClientApplicationBuilder.Create(ClientId)
.Build();
TokenCacheHelper.EnableSerialization(app.UserTokenCache);
De TokenCacheHelper helperklasse wordt gedefinieerd als:
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)
);
}
}
}
}
Een serialisatiefunctie voor tokencache van productkwaliteit op basis van bestanden voor openbare clienttoepassingen (voor bureaubladtoepassingen die worden uitgevoerd op Windows, Mac en Linux) is beschikbaar in de open bronbibliotheek Microsoft.Identity.Client.Extensions.Msal. U kunt deze opnemen in uw toepassingen vanuit het volgende NuGet-pakket: Microsoft.Identity.Client.Extensions.Msal.
Serialisatie van dubbele tokencache (GEÏNTEGREERDE MSAL-cache)
Als u serialisatie van tokencaches wilt implementeren met de uniforme cacheindeling (gebruikelijk voor MSAL.NET 2.x en andere MSALs van dezelfde generatie of ouder, op hetzelfde platform), bekijkt u het volgende voorbeeld: https://github.com/Azure-Samples/active-directory-dotnet-v1-to-v2/tree/master/TokenCacheMigration/ADAL2MSAL.
MSAL maakt belangrijke metrische gegevens beschikbaar als onderdeel van het object AuthenticationResult.AuthenticationResultMetadata. U kunt deze metrische gegevens registreren om de status van uw toepassing te beoordelen.
In de volgende voorbeelden ziet u serialisatie van tokencaches.
