En webbapp som anropar webb-API:er: Kodkonfiguration

Artikel
01/10/2024

Som visas i webbappen som loggar in användare använder webbappen OAuth 2.0-auktoriseringskodflödet för att logga in användaren. Det här flödet har två steg:

Begär en auktoriseringskod. Den här delen delegerar en privat dialog med användaren till Microsofts identitetsplattform. Under den dialogen loggar användaren in och godkänner användningen av webb-API:er. När den privata dialogen avslutas får webbappen en auktoriseringskod på sin omdirigerings-URI.
Begär en åtkomsttoken för API:et genom att lösa in auktoriseringskoden.

Webbappen som loggar in användarscenarier omfattade endast det första steget. Här lär du dig hur du ändrar din webbapp så att den inte bara loggar in användare utan även nu anropar webb-API:er.

Microsoft-bibliotek som stöder webbappar

Följande Microsoft-bibliotek stöder webbappar:

Språk/ramverk	Projekt på GitHub	Paket	Få komma igång	Logga in användare	Åtkomst till webb-API:er	Allmänt tillgänglig (GA) eller Offentlig förhandsversion¹
.NET	MSAL.NET	Microsoft.Identity.Client	—			Allmän tillgänglighet
.NET	Microsoft.IdentityModel	Microsoft.IdentityModel	—	²	²	Allmän tillgänglighet
ASP.NET Core	ASP.NET Core	Microsoft.AspNetCore.Authentication	Snabbstart			Allmän tillgänglighet
ASP.NET Core	Microsoft.Identity.Web	Microsoft.Identity.Web	Snabbstart			Allmän tillgänglighet
Java	MSAL4J	msal4j	Snabbstart			Allmän tillgänglighet
Spring	spring-cloud-azure-starter-active-directory	spring-cloud-azure-starter-active-directory	Självstudie			Allmän tillgänglighet
Node.js	MSAL-nod	msal-node	Snabbstart			Allmän tillgänglighet
Python	MSAL Python	msal				Allmän tillgänglighet
Python	Identitet	Identitet	Snabbstart			--

⁽¹⁾Universella licensvillkor för onlinetjänster gäller för bibliotek i offentlig förhandsversion.

⁽²⁾Microsoft.IdentityModel-biblioteket validerar endast token – det kan inte begära ID eller åtkomsttoken.

Välj fliken för den plattform som du är intresserad av:

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.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 :

Blockdiagram som visar tjänstkonfigurationsalternativ i startpunkt C S för att anropa ett webb-API och ange en implementering av tokencache

Kommentar

Om du vill förstå kodexemplen fullt ut här bör du känna till grunderna för ASP.NET Core, särskilt beroendeinmatning och alternativ.

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

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

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

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

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 :

Blockdiagram som visar tjänstkonfigurationsalternativ i startpunkt C S för att anropa ett webb-API och ange en implementering av tokencache

Kommentar

Om du vill förstå kodexemplen fullt ut här bör du känna till grunderna för ASP.NET Core, särskilt beroendeinmatning och alternativ.

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.

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);
        }
    };
}

Kod som löser in auktoriseringskoden

Microsoft.Identity.Web förenklar koden genom att ange rätt OpenID-Anslut inställningar, prenumerera på den mottagna koden och lösa in koden. Ingen extra kod krävs för att lösa in auktoriseringskoden. Mer information om hur detta fungerar finns i Microsoft.Identity.Web-källkoden .

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 ConfidentialClientApplicationoch 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.

Tokencache

Viktigt!

Implementeringen av tokencache för webbappar eller webb-API:er skiljer sig från implementeringen för skrivbordsprogram, som ofta är filbaserad. Av säkerhets- och prestandaskäl är det viktigt att se till att det för webbappar och webb-API:er finns en tokencache per användarkonto. Du måste serialisera tokencachen för varje konto.

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.WebToken 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 getAuthResultBySilentFlowAuthHelper.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.pylagrar 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".

Nästa steg

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.

Gå vidare till nästa artikel i det här scenariot: Ta bort konton från cachen vid global utloggning.

Dela via

En webbapp som anropar webb-API:er: Kodkonfiguration

Microsoft-bibliotek som stöder webbappar

Klienthemligheter eller klientcertifikat

Startup.cs

Alternativ 1: Anropa Microsoft Graph

Alternativ 2: Anropa ett annat underordnat webb-API än Microsoft Graph

Sammanfattning

Klienthemligheter eller klientcertifikat

Startup.Auth.cs

Alternativ 1: Anropa Microsoft Graph

Alternativ 2: Anropa ett annat underordnat webb-API än Microsoft Graph

Sammanfattning

Kod som löser in auktoriseringskoden

Tokencache

Nästa steg

Feedback

Feedback

Ytterligare resurser