Klienthemligheter eller klientcertifikat
Eftersom webbappen nu anropar ett underordnat webb-API anger du en klienthemlighet eller ett klientcertifikat i appsettings.json-filen. Du kan också lägga till ett avsnitt som anger:
- URL:en för det underordnade webb-API:et
- De omfång som krävs för att anropa API:et
I följande exempel anger avsnittet GraphBeta
dessa inställningar.
{
"AzureAd": {
"Instance": "https://login.microsoftonline.com/",
"ClientId": "[Enter_the_Application_Id_Here]",
"TenantId": "common",
// To call an API
"ClientCredentials": [
{
"SourceType": "ClientSecret",
"ClientSecret":"[Enter_the_Client_Secret_Here]"
}
]
},
"GraphBeta": {
"BaseUrl": "https://graph.microsoft.com/beta",
"Scopes": ["user.read"]
}
}
Kommentar
Du kan föreslå en samling klientautentiseringsuppgifter, inklusive en lösning utan autentiseringsuppgifter som arbetsbelastningsidentitetsfederation för Azure Kubernetes.
Tidigare versioner av Microsoft.Identity.Web uttryckte klienthemligheten i en enda egenskap "ClientSecret" i stället för "ClientCredentials". Detta stöds fortfarande för bakåtkompatibilitet, men du kan inte använda både egenskapen "ClientSecret" och samlingen "ClientCredentials".
I stället för en klienthemlighet kan du ange ett klientcertifikat. Följande kodfragment visar hur du använder ett certifikat som lagras i Azure Key Vault.
{
"AzureAd": {
"Instance": "https://login.microsoftonline.com/",
"ClientId": "[Enter_the_Application_Id_Here]",
"TenantId": "common",
// To call an API
"ClientCredentials": [
{
"SourceType": "KeyVault",
"KeyVaultUrl": "https://msidentitywebsamples.vault.azure.net",
"KeyVaultCertificateName": "MicrosoftIdentitySamplesCert"
}
]
},
"GraphBeta": {
"BaseUrl": "https://graph.microsoft.com/beta",
"Scopes": ["user.read"]
}
}
Varning
Om du glömmer att ändra Scopes
till en matris visas null när du försöker använda omfången IDownstreamApi
och IDownstreamApi
ett anonymt (oautentiserat) anrop till det underordnade API:et, vilket resulterar i ett 401/unauthenticated
.
Microsoft.Identity.Web innehåller flera sätt att beskriva certifikat, både efter konfiguration eller kod. Mer information finns i Microsoft.Identity.Web – Använda certifikat på GitHub.
Ändra filen Startup.cs
Webbappen måste hämta en token för det underordnade API:et. Du anger det genom att lägga till .EnableTokenAcquisitionToCallDownstreamApi()
raden efter .AddMicrosoftIdentityWebApp(Configuration)
. Den här raden exponerar den IAuthorizationHeaderProvider
tjänst som du kan använda i kontrollanten och sidåtgärder. Men som du ser i följande två alternativ kan det göras mer enkelt. Du måste också välja en implementering av tokencache, till exempel .AddInMemoryTokenCaches()
i Startup.cs:
using Microsoft.Identity.Web;
public class Startup
{
// ...
public void ConfigureServices(IServiceCollection services)
{
// ...
services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
.AddMicrosoftIdentityWebApp(Configuration, "AzureAd")
.EnableTokenAcquisitionToCallDownstreamApi(new string[]{"user.read" })
.AddInMemoryTokenCaches();
// ...
}
// ...
}
De omfång som skickas till EnableTokenAcquisitionToCallDownstreamApi
är valfria och gör det möjligt för webbappen att begära omfången och användarens medgivande till dessa omfång när de loggar in. Om du inte anger omfången aktiverar Microsoft.Identity.Web en inkrementell medgivandeupplevelse.
Microsoft.Identity.Web erbjuder två mekanismer för att anropa ett webb-API från en webbapp utan att du behöver hämta en token. Vilket alternativ du väljer beror på om du vill anropa Microsoft Graph eller något annat API.
Alternativ 1: Anropa Microsoft Graph
Om du vill anropa Microsoft Graph gör Microsoft.Identity.Web att du kan använda GraphServiceClient
(exponeras av Microsoft Graph SDK) direkt i dina API-åtgärder. Så här exponerar du Microsoft Graph:
Lägg till NuGet-paketet Microsoft.Identity.Web.GraphServiceClient i projektet.
Lägg till .AddMicrosoftGraph()
efter .EnableTokenAcquisitionToCallDownstreamApi()
i filen Startup.cs . .AddMicrosoftGraph()
har flera åsidosättningar. Med hjälp av åsidosättningen som tar ett konfigurationsavsnitt som en parameter blir koden:
using Microsoft.Identity.Web;
public class Startup
{
// ...
public void ConfigureServices(IServiceCollection services)
{
// ...
services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
.AddMicrosoftIdentityWebApp(Configuration, "AzureAd")
.EnableTokenAcquisitionToCallDownstreamApi(new string[]{"user.read" })
.AddMicrosoftGraph(Configuration.GetSection("GraphBeta"))
.AddInMemoryTokenCaches();
// ...
}
// ...
}
Alternativ 2: Anropa ett annat underordnat webb-API än Microsoft Graph
Om du vill anropa ett annat API än Microsoft Graph gör Microsoft.Identity.Web att du kan använda IDownstreamApi
gränssnittet i dina API-åtgärder. Så här använder du det här gränssnittet:
Lägg till NuGet-paketet Microsoft.Identity.Web.DownstreamApi i projektet.
Lägg till .AddDownstreamApi()
efter .EnableTokenAcquisitionToCallDownstreamApi()
i filen Startup.cs . .AddDownstreamApi()
har två argument och visas i följande kodfragment:
- Namnet på en tjänst (API), som används i dina kontrollantåtgärder för att referera till motsvarande konfiguration
- ett konfigurationsavsnitt som representerar de parametrar som används för att anropa det underordnade webb-API:et.
using Microsoft.Identity.Web;
public class Startup
{
// ...
public void ConfigureServices(IServiceCollection services)
{
// ...
services.AddAuthentication(OpenIdConnectDefaults.AuthenticationScheme)
.AddMicrosoftIdentityWebApp(Configuration, "AzureAd")
.EnableTokenAcquisitionToCallDownstreamApi(new string[]{"user.read" })
.AddDownstreamApi("MyApi", Configuration.GetSection("GraphBeta"))
.AddInMemoryTokenCaches();
// ...
}
// ...
}
Sammanfattning
Precis som med webb-API:er kan du välja olika implementeringar av tokencache. Mer information finns i Microsoft.Identity.Web – Cache-serialisering för token på GitHub.
Följande bild visar de olika möjligheterna för Microsoft.Identity.Web och deras effekt på filen Startup.cs :
Klienthemligheter eller klientcertifikat
Eftersom webbappen nu anropar ett underordnat webb-API anger du en klienthemlighet eller ett klientcertifikat i appsettings.json-filen. Du kan också lägga till ett avsnitt som anger:
- URL:en för det underordnade webb-API:et
- De omfång som krävs för att anropa API:et
I följande exempel anger avsnittet GraphBeta
dessa inställningar.
{
"AzureAd": {
"Instance": "https://login.microsoftonline.com/",
"ClientId": "[Enter_the_Application_Id_Here]",
"TenantId": "common",
// To call an API
"ClientCredentials": [
{
"SourceType": "ClientSecret",
"ClientSecret":"[Enter_the_Client_Secret_Here]"
}
]
},
"GraphBeta": {
"BaseUrl": "https://graph.microsoft.com/beta",
"Scopes": ["user.read"]
}
}
Kommentar
Du kan föreslå en samling klientautentiseringsuppgifter, inklusive en lösning utan autentiseringsuppgifter som arbetsbelastningsidentitetsfederation för Azure Kubernetes.
Tidigare versioner av Microsoft.Identity.Web uttryckte klienthemligheten i en enda egenskap "ClientSecret" i stället för "ClientCredentials". Detta stöds fortfarande för bakåtkompatibilitet, men du kan inte använda både egenskapen "ClientSecret" och samlingen "ClientCredentials".
I stället för en klienthemlighet kan du ange ett klientcertifikat. Följande kodfragment visar hur du använder ett certifikat som lagras i Azure Key Vault.
{
"AzureAd": {
"Instance": "https://login.microsoftonline.com/",
"ClientId": "[Enter_the_Application_Id_Here]",
"TenantId": "common",
// To call an API
"ClientCredentials": [
{
"SourceType": "KeyVault",
"KeyVaultUrl": "https://msidentitywebsamples.vault.azure.net",
"KeyVaultCertificateName": "MicrosoftIdentitySamplesCert"
}
]
},
"GraphBeta": {
"BaseUrl": "https://graph.microsoft.com/beta",
"Scopes": ["user.read"]
}
}
Varning
Om du glömmer att ändra Scopes
till en matris visas null när du försöker använda omfången IDownstreamApi
och IDownstreamApi
ett anonymt (oautentiserat) anrop till det underordnade API:et, vilket resulterar i ett 401/unauthenticated
.
Microsoft.Identity.Web innehåller flera sätt att beskriva certifikat, både efter konfiguration eller kod. Mer information finns i Microsoft.Identity.Web – Använda certifikat på GitHub.
Startup.Auth.cs
Webbappen måste hämta en token för det underordnade API:et. Microsoft.Identity.Web tillhandahåller två mekanismer för att anropa ett webb-API från en webbapp. Vilket alternativ du väljer beror på om du vill anropa Microsoft Graph eller något annat API.
Alternativ 1: Anropa Microsoft Graph
Om du vill anropa Microsoft Graph gör Microsoft.Identity.Web att du kan använda GraphServiceClient
(exponeras av Microsoft Graph SDK) direkt i dina API-åtgärder. Så här exponerar du Microsoft Graph:
- Lägg till NuGet-paketet Microsoft.Identity.Web.GraphServiceClient i projektet.
- Lägg till
.AddMicrosoftGraph()
i tjänstsamlingen i Startup.Auth.cs-filen. .AddMicrosoftGraph()
har flera åsidosättningar. Med hjälp av åsidosättningen som tar ett konfigurationsavsnitt som en parameter blir koden:
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Identity.Client;
using Microsoft.Identity.Web;
using Microsoft.Identity.Web.OWIN;
using Microsoft.Identity.Web.TokenCacheProviders.InMemory;
using Microsoft.IdentityModel.Validators;
using Microsoft.Owin.Security;
using Microsoft.Owin.Security.Cookies;
using Owin;
namespace WebApp
{
public partial class Startup
{
public void ConfigureAuth(IAppBuilder app)
{
app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);
app.UseCookieAuthentication(new CookieAuthenticationOptions());
// Get an TokenAcquirerFactory specialized for OWIN
OwinTokenAcquirerFactory owinTokenAcquirerFactory = TokenAcquirerFactory.GetDefaultInstance<OwinTokenAcquirerFactory>();
// Configure the web app.
app.AddMicrosoftIdentityWebApp(owinTokenAcquirerFactory,
updateOptions: options => {});
// Add the services you need.
owinTokenAcquirerFactory.Services
.Configure<ConfidentialClientApplicationOptions>(options =>
{ options.RedirectUri = "https://localhost:44326/"; })
.AddMicrosoftGraph()
.AddInMemoryTokenCaches();
owinTokenAcquirerFactory.Build();
}
}
}
Alternativ 2: Anropa ett annat underordnat webb-API än Microsoft Graph
Om du vill anropa ett annat API än Microsoft Graph gör Microsoft.Identity.Web att du kan använda IDownstreamApi
gränssnittet i dina API-åtgärder. Så här använder du det här gränssnittet:
- Lägg till NuGet-paketet Microsoft.Identity.Web.DownstreamApi i projektet.
- Lägg till
.AddDownstreamApi()
efter .EnableTokenAcquisitionToCallDownstreamApi()
i filen Startup.cs . .AddDownstreamApi()
har två argument:
- Namnet på en tjänst (API): du använder det här namnet i dina kontrollantåtgärder för att referera till motsvarande konfiguration
- ett konfigurationsavsnitt som representerar de parametrar som används för att anropa det underordnade webb-API:et.
Här är koden:
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Identity.Client;
using Microsoft.Identity.Web;
using Microsoft.Identity.Web.OWIN;
using Microsoft.Identity.Web.TokenCacheProviders.InMemory;
using Microsoft.IdentityModel.Validators;
using Microsoft.Owin.Security;
using Microsoft.Owin.Security.Cookies;
using Owin;
namespace WebApp
{
public partial class Startup
{
public void ConfigureAuth(IAppBuilder app)
{
app.SetDefaultSignInAsAuthenticationType(CookieAuthenticationDefaults.AuthenticationType);
app.UseCookieAuthentication(new CookieAuthenticationOptions());
// Get a TokenAcquirerFactory specialized for OWIN.
OwinTokenAcquirerFactory owinTokenAcquirerFactory = TokenAcquirerFactory.GetDefaultInstance<OwinTokenAcquirerFactory>();
// Configure the web app.
app.AddMicrosoftIdentityWebApp(owinTokenAcquirerFactory,
updateOptions: options => {});
// Add the services you need.
owinTokenAcquirerFactory.Services
.Configure<ConfidentialClientApplicationOptions>(options =>
{ options.RedirectUri = "https://localhost:44326/"; })
.AddDownstreamApi("Graph", owinTokenAcquirerFactory.Configuration.GetSection("GraphBeta"))
.AddInMemoryTokenCaches();
owinTokenAcquirerFactory.Build();
}
}
}
Sammanfattning
Du kan välja olika implementeringar av tokencache. Mer information finns i Microsoft.Identity.Web – Cache-serialisering för token på GitHub.
Följande bild visar de olika möjligheterna för Microsoft.Identity.Web och deras effekt på filen Startup.cs :
Kodexempel i den här artikeln och följande extraheras från ASP.NET webbappexempel. Du kanske vill se exemplet för fullständig implementeringsinformation.
Implementera Java-kodexemplet
Kodexempel i den här artikeln och följande extraheras från Java-webbprogrammet som anropar Microsoft Graph, ett webbappexempel som använder MSAL för Java.
Med exemplet kan MSAL för Java skapa auktoriseringskod-URL:en och hantera navigeringen till auktoriseringsslutpunkten för Microsofts identitetsplattform. Det är också möjligt att använda Sprint-säkerhet för att logga in användaren. Du kanske vill se exemplet för fullständig implementeringsinformation.
Implementera kodexemplet Node.js
Kodexempel i den här artikeln och följande extraheras från Node.js & Express.js webbprogram som anropar Microsoft Graph, ett webbappexempel som använder MSAL Node.
Med exemplet kan MSAL Node för närvarande skapa auktoriseringskod-URL:en och hantera navigeringen till auktoriseringsslutpunkten för Microsofts identitetsplattform. Detta visas nedan:
/**
* Prepares the auth code request parameters and initiates the first leg of auth code flow
* @param req: Express request object
* @param res: Express response object
* @param next: Express next function
* @param authCodeUrlRequestParams: parameters for requesting an auth code url
* @param authCodeRequestParams: parameters for requesting tokens using auth code
*/
redirectToAuthCodeUrl(authCodeUrlRequestParams, authCodeRequestParams, msalInstance) {
return async (req, res, next) => {
// Generate PKCE Codes before starting the authorization flow
const { verifier, challenge } = await this.cryptoProvider.generatePkceCodes();
// Set generated PKCE codes and method as session vars
req.session.pkceCodes = {
challengeMethod: 'S256',
verifier: verifier,
challenge: challenge,
};
/**
* By manipulating the request objects below before each request, we can obtain
* auth artifacts with desired claims. For more information, visit:
* https://azuread.github.io/microsoft-authentication-library-for-js/ref/modules/_azure_msal_node.html#authorizationurlrequest
* https://azuread.github.io/microsoft-authentication-library-for-js/ref/modules/_azure_msal_node.html#authorizationcoderequest
**/
req.session.authCodeUrlRequest = {
...authCodeUrlRequestParams,
responseMode: msal.ResponseMode.FORM_POST, // recommended for confidential clients
codeChallenge: req.session.pkceCodes.challenge,
codeChallengeMethod: req.session.pkceCodes.challengeMethod,
};
req.session.authCodeRequest = {
...authCodeRequestParams,
code: '',
};
try {
const authCodeUrlResponse = await msalInstance.getAuthCodeUrl(req.session.authCodeUrlRequest);
res.redirect(authCodeUrlResponse);
} catch (error) {
next(error);
}
};
}
Implementera Python-kodexemplet
Kodfragment i den här artikeln och följande extraheras från Python-webbprogrammet som anropar Microsoft Graph-exemplet med hjälp av identitetspaketet (en omslutning runt MSAL Python).
Exemplet använder identitetspaketet för att skapa auktoriseringskodens URL och hanterar navigeringen till auktoriseringsslutpunkten för Microsofts identitetsplattform. Du kanske vill se exemplet för fullständig implementeringsinformation.
Metoden handleRedirect i klassen AuthProvider bearbetar auktoriseringskoden som tas emot från Microsoft Entra-ID. Detta visas nedan:
handleRedirect(options = {}) {
return async (req, res, next) => {
if (!req.body || !req.body.state) {
return next(new Error('Error: response not found'));
}
const authCodeRequest = {
...req.session.authCodeRequest,
code: req.body.code,
codeVerifier: req.session.pkceCodes.verifier,
};
try {
const msalInstance = this.getMsalInstance(this.msalConfig);
if (req.session.tokenCache) {
msalInstance.getTokenCache().deserialize(req.session.tokenCache);
}
const tokenResponse = await msalInstance.acquireTokenByCode(authCodeRequest, req.body);
req.session.tokenCache = msalInstance.getTokenCache().serialize();
req.session.idToken = tokenResponse.idToken;
req.session.account = tokenResponse.account;
req.session.isAuthenticated = true;
const state = JSON.parse(this.cryptoProvider.base64Decode(req.body.state));
res.redirect(state.successRedirect);
} catch (error) {
next(error);
}
}
}
Se Webbapp som loggar in användare: Kodkonfiguration för att förstå hur Java-exemplet hämtar auktoriseringskoden. När appen har fått koden AuthFilter.java#L51-L56:
- Delegerar till
AuthHelper.processAuthenticationCodeRedirect
metoden i AuthHelper.java#L67-L97.
- Anropar
getAuthResultByAuthCode
.
class AuthHelper {
// Code omitted
void processAuthenticationCodeRedirect(HttpServletRequest httpRequest, String currentUri, String fullUrl)
throws Throwable {
// Code omitted
AuthenticationResponse authResponse = AuthenticationResponseParser.parse(new URI(fullUrl), params);
// Code omitted
IAuthenticationResult result = getAuthResultByAuthCode(
httpRequest,
oidcResponse.getAuthorizationCode(),
currentUri);
// Code omitted
}
}
Metoden getAuthResultByAuthCode
definieras i AuthHelper.java#L176. Den skapar en MSAL ConfidentialClientApplication
och anropar acquireToken()
sedan med AuthorizationCodeParameters
skapad från auktoriseringskoden.
private IAuthenticationResult getAuthResultByAuthCode(
HttpServletRequest httpServletRequest,
AuthorizationCode authorizationCode,
String currentUri) throws Throwable {
IAuthenticationResult result;
ConfidentialClientApplication app;
try {
app = createClientApplication();
String authCode = authorizationCode.getValue();
AuthorizationCodeParameters parameters = AuthorizationCodeParameters.builder(
authCode,
new URI(currentUri)).
build();
Future<IAuthenticationResult> future = app.acquireToken(parameters);
result = future.get();
} catch (ExecutionException e) {
throw e.getCause();
}
if (result == null) {
throw new ServiceUnavailableException("authentication result was null");
}
SessionManagementHelper.storeTokenCacheInSession(httpServletRequest, app.tokenCache().serialize());
return result;
}
private ConfidentialClientApplication createClientApplication() throws MalformedURLException {
return ConfidentialClientApplication.builder(clientId, ClientCredentialFactory.create(clientSecret)).
authority(authority).
build();
}
Se Webbapp som loggar in användare: Kodkonfiguration för att förstå hur Python-exemplet hämtar auktoriseringskoden.
Microsoft-inloggningsskärmen skickar auktoriseringskoden till den /getAToken
URL som angavs i appregistreringen. Vägen auth_response
hanterar webbadressen, anropar auth.complete_login
för att bearbeta auktoriseringskoden och returnerar sedan antingen ett fel eller omdirigerar till startsidan.
@app.route(app_config.REDIRECT_PATH)
def auth_response():
result = auth.complete_log_in(request.args)
if "error" in result:
return render_template("auth_error.html", result=result)
return redirect(url_for("index"))
Se app.py för den fullständiga kontexten för koden.
I stället för en klienthemlighet kan det konfidentiella klientprogrammet också bevisa sin identitet med hjälp av ett klientcertifikat eller ett klientintyg.
Användningen av klientkontroller är ett avancerat scenario som beskrivs i Klientkontroller.
I självstudien ASP.NET core används beroendeinmatning för att du ska kunna bestämma implementeringen av tokencache i Startup.cs-filen för ditt program. Microsoft.Identity.Web levereras med fördefinierade token-cache-serialiserare som beskrivs i Token cache serialisering. En intressant möjlighet är att välja ASP.NET Core-distribuerade minnescacheminnen:
// Use a distributed token cache by adding:
services.AddMicrosoftIdentityWebAppAuthentication(Configuration, "AzureAd")
.EnableTokenAcquisitionToCallDownstreamApi(
initialScopes: new string[] { "user.read" })
.AddDistributedTokenCaches();
// Then, choose your implementation.
// For instance, the distributed in-memory cache (not cleared when you stop the app):
services.AddDistributedMemoryCache();
// Or a Redis cache:
services.AddStackExchangeRedisCache(options =>
{
options.Configuration = "localhost";
options.InstanceName = "SampleInstance";
});
// Or even a SQL Server token cache:
services.AddDistributedSqlServerCache(options =>
{
options.ConnectionString = _config["DistCache_ConnectionString"];
options.SchemaName = "dbo";
options.TableName = "TestCache";
});
Mer information om token-cacheprovidrar finns även i artikeln microsoft.Identity.web's token cache serialization article, and the ASP.NET Core web app tutorials | Tokencachelagringsfasen i självstudiekursen för webbappar.
I självstudien ASP.NET används beroendeinmatning för att bestämma implementeringen av tokencache i Startup.Auth.cs-filen för ditt program. Microsoft.Identity.Web levereras med fördefinierade token-cache-serialiserare som beskrivs i Token cache serialisering. En intressant möjlighet är att välja ASP.NET Core-distribuerade minnescacheminnen:
var services = owinTokenAcquirerFactory.Services;
// Use a distributed token cache by adding:
services.AddDistributedTokenCaches();
// Then, choose your implementation.
// For instance, the distributed in-memory cache (not cleared when you stop the app):
services.AddDistributedMemoryCache();
// Or a Redis cache:
services.AddStackExchangeRedisCache(options =>
{
options.Configuration = "localhost";
options.InstanceName = "SampleInstance";
});
// Or even a SQL Server token cache:
services.AddDistributedSqlServerCache(options =>
{
options.ConnectionString = _config["DistCache_ConnectionString"];
options.SchemaName = "dbo";
options.TableName = "TestCache";
});
Mer information om token-cacheprovidrar finns även i artikeln Microsoft.Identity.Web Token cache serialisering och självstudierna ASP.NET Core-webbapp | Tokencachelagringsfasen i webbappens självstudie.
Mer information finns i Token cache serialisering för MSAL.NET.
MSAL Java tillhandahåller metoder för att serialisera och deserialisera tokencachen. Java-exemplet hanterar serialiseringen från sessionen, enligt metoden i getAuthResultBySilentFlow
AuthHelper.java#L99-L122:
IAuthenticationResult getAuthResultBySilentFlow(HttpServletRequest httpRequest, HttpServletResponse httpResponse)
throws Throwable {
IAuthenticationResult result = SessionManagementHelper.getAuthSessionObject(httpRequest);
IConfidentialClientApplication app = createClientApplication();
Object tokenCache = httpRequest.getSession().getAttribute("token_cache");
if (tokenCache != null) {
app.tokenCache().deserialize(tokenCache.toString());
}
SilentParameters parameters = SilentParameters.builder(
Collections.singleton("User.Read"),
result.account()).build();
CompletableFuture<IAuthenticationResult> future = app.acquireTokenSilently(parameters);
IAuthenticationResult updatedResult = future.get();
// Update session with latest token cache.
SessionManagementHelper.storeTokenCacheInSession(httpRequest, app.tokenCache().serialize());
return updatedResult;
}
Information om SessionManagementHelper
klassen finns i MSAL-exemplet för Java.
I det Node.js exemplet används programsessionen för att lagra tokencachen. Med hjälp av MSAL Node-cachemetoder läss tokencachen i sessionen innan en tokenbegäran görs och uppdateras sedan när tokenbegäran har slutförts. Detta visas nedan:
acquireToken(options = {}) {
return async (req, res, next) => {
try {
const msalInstance = this.getMsalInstance(this.msalConfig);
/**
* If a token cache exists in the session, deserialize it and set it as the
* cache for the new MSAL CCA instance. For more, see:
* https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-node/docs/caching.md
*/
if (req.session.tokenCache) {
msalInstance.getTokenCache().deserialize(req.session.tokenCache);
}
const tokenResponse = await msalInstance.acquireTokenSilent({
account: req.session.account,
scopes: options.scopes || [],
});
/**
* On successful token acquisition, write the updated token
* cache back to the session. For more, see:
* https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-node/docs/caching.md
*/
req.session.tokenCache = msalInstance.getTokenCache().serialize();
req.session.accessToken = tokenResponse.accessToken;
req.session.idToken = tokenResponse.idToken;
req.session.account = tokenResponse.account;
res.redirect(options.successRedirect);
} catch (error) {
if (error instanceof msal.InteractionRequiredAuthError) {
return this.login({
scopes: options.scopes || [],
redirectUri: options.redirectUri,
successRedirect: options.successRedirect || '/',
})(req, res, next);
}
next(error);
}
};
}
I Python-exemplet tar identitetspaketet hand om tokencachen med hjälp av det globala session
objektet för lagring.
Flask har inbyggt stöd för sessioner som lagras i en cookie, men på grund av identitetscookiesens längd använder exemplet Flask-sessionspaketet i stället. Allt initieras i app.py:
import identity
import identity.web
import requests
from flask import Flask, redirect, render_template, request, session, url_for
from flask_session import Session
import app_config
app = Flask(__name__)
app.config.from_object(app_config)
Session(app)
auth = identity.web.Auth(
session=session,
authority=app.config["AUTHORITY"],
client_id=app.config["CLIENT_ID"],
client_credential=app.config["CLIENT_SECRET"],
)
På grund av inställningen SESSION_TYPE="filesystem"
i app_config.py
lagrar Flask-session-paketet sessioner med hjälp av det lokala filsystemet.
För produktion bör du använda en inställning som finns kvar i flera instanser och distribuerar din app, till exempel "sqlachemy" eller "redis".
Nu när användaren loggar in lagras en token i tokencachen. Nu ska vi se hur den sedan används i andra delar av webbappen.