Webová aplikace, která volá webová rozhraní API: Konfigurace kódu

Článek
08/01/2024

V předchozím článku jste zaregistrovali aplikaci v Microsoft Entra. V tomto článku se dozvíte, jak nakonfigurovat kód aplikace a upravit webovou aplikaci tak, aby nejen přihlašuje uživatele, ale také volá webová rozhraní API. Aplikace, kterou vytvoříte, používá tok autorizačního kódu OAuth 2.0 k přihlášení uživatele. Tento tok má dva kroky:

Požádejte o autorizační kód. Tato část deleguje soukromý dialog s uživatelem na platformu Microsoft Identity Platform. Během tohoto dialogu se uživatel přihlásí a souhlasí s používáním webových rozhraní API. Po úspěšném ukončení soukromého dialogu obdrží webová aplikace autorizační kód na identifikátoru URI přesměrování.
Požádejte o přístupový token pro rozhraní API uplatněním autorizačního kódu.

Požadavky

Webová aplikace, která volá webová rozhraní API: Registrace aplikace

Knihovny Microsoftu podporující webové aplikace

Následující knihovny Microsoftu podporují webové aplikace:

Jazyk / architektura	Project on GitHub	Balíček	Dostání z těchto možností	Přihlášení uživatelů	Přístup k webovým rozhraním API	Obecná dostupnost (GA) nebo Public Preview¹
.NET	MSAL.NET	Microsoft.Identity.Client	—			GA
.NET	Microsoft.IdentityModel	Microsoft.IdentityModel	—	²	²	GA
ASP.NET Core	Microsoft.Identity.Web	Microsoft.Identity.Web	Rychlý start			GA
Java	MSAL4J	msal4j	Rychlý start			GA
Spring	spring-cloud-azure-starter-active-directory	spring-cloud-azure-starter-active-directory	Kurz			GA
Node.js	Uzel MSAL	msal-node	Rychlý start			GA
Python	MSAL Python	msal				GA
Python	identita	identita	Rychlý start			--

⁽¹⁾ Univerzální licenční podmínky pro online služby se vztahují na knihovny ve verzi Public Preview.

⁽²⁾ Knihovna Microsoft.IdentityModel ověřuje pouze tokeny – nemůže požádat o ID ani přístupové tokeny.

Vyberte kartu pro platformu, kterou vás zajímá:

Tajné klíče klienta nebo klientské certifikáty

Vzhledem k tomu, že vaše webová aplikace teď volá podřízené webové rozhraní API, zadejte tajný klíč klienta nebo klientský certifikát do souboru appsettings.json . Můžete také přidat oddíl, který určuje:

Adresa URL podřízeného webového rozhraní API
Obory vyžadované pro volání rozhraní API

V následujícím příkladu GraphBeta část určuje tato nastavení.

{
  "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"]
    }
}

Poznámka:

Můžete navrhnout kolekci přihlašovacích údajů klienta, včetně řešení bez přihlašovacích údajů, jako je federace identit úloh pro Azure Kubernetes. Předchozí verze Microsoft.Identity.Web vyjádřily tajný klíč klienta v jedné vlastnosti ClientSecret místo ClientCredentials. Tato funkce je stále podporovaná pro zpětnou kompatibilitu, ale nemůžete použít vlastnost ClientSecret i kolekci ClientCredentials.

Místo tajného klíče klienta můžete zadat klientský certifikát. Následující fragment kódu ukazuje použití certifikátu uloženého ve službě 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"]
  }
}

Upozorňující

Pokud zapomenete změnit Scopes pole, při pokusu o použití IDownstreamApi oborů se zobrazí hodnota null a IDownstreamApi pokusíte se anonymní (neověřené) volání do podřízeného rozhraní API, což bude mít za 401/unauthenticatednásledek .

Microsoft.Identity.Web nabízí několik způsobů, jak popsat certifikáty podle konfigurace nebo kódu. Podrobnosti najdete v tématu Microsoft.Identity.Web – Použití certifikátů na GitHubu.

Úprava souboru Startup.cs

Vaše webová aplikace potřebuje získat token pro podřízené rozhraní API. Zadáte ho .EnableTokenAcquisitionToCallDownstreamApi() přidáním řádku za .AddMicrosoftIdentityWebApp(Configuration). Tento řádek zveřejňuje IAuthorizationHeaderProvider službu, kterou můžete použít v kontroleru a akcích stránky. Jak ale vidíte v následujících dvou možnostech, můžete to udělat jednodušeji. Musíte také zvolit implementaci mezipaměti tokenů, například .AddInMemoryTokenCaches()v 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();
   // ...
  }
  // ...
}

Obory předané EnableTokenAcquisitionToCallDownstreamApi jsou volitelné a umožňují webové aplikaci požadovat obory a souhlas uživatele s těmito obory při přihlášení. Pokud nezadáte obory, Microsoft.Identity.Web povolí přírůstkové vyjádření souhlasu.

Microsoft.Identity.Web nabízí dva mechanismy pro volání webového rozhraní API z webové aplikace, aniž byste museli získat token. Možnost, kterou zvolíte, závisí na tom, jestli chcete volat Microsoft Graph nebo jiné rozhraní API.

Možnost 1: Volání Microsoft Graphu

Pokud chcete volat Microsoft Graph, Microsoft.Identity.Web umožňuje přímo používat GraphServiceClient (vystavené sadou Microsoft Graph SDK) v akcích rozhraní API. Zveřejnění Microsoft Graphu:

Přidejte do projektu balíček NuGet Microsoft.Identity.Web.GraphServiceClient .

Přidejte .AddMicrosoftGraph() za .EnableTokenAcquisitionToCallDownstreamApi() soubor Startup.cs . .AddMicrosoftGraph() má několik přepsání. Pomocí přepsání, které jako parametr přebírá oddíl konfigurace, se kód stane:

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();
   // ...
  }
  // ...
}

Možnost 2: Volání podřízeného webového rozhraní API jiného než Microsoft Graphu

Pokud chcete volat jiné rozhraní než Microsoft Graph, Microsoft.Identity.Web umožňuje používat IDownstreamApi rozhraní v akcích rozhraní API. Chcete-li použít toto rozhraní:

Přidejte do projektu balíček NuGet Microsoft.Identity.Web.DownstreamApi .

Přidejte .AddDownstreamApi() za .EnableTokenAcquisitionToCallDownstreamApi() soubor Startup.cs . .AddDownstreamApi() má dva argumenty a zobrazuje se v následujícím fragmentu kódu:

Název služby (API), která se používá v akcích kontroleru k odkazování na odpovídající konfiguraci
oddíl konfigurace představující parametry používané k volání podřízeného webového rozhraní API.

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();
   // ...
  }
  // ...
}

Shrnutí

Stejně jako u webových rozhraní API můžete zvolit různé implementace mezipaměti tokenů. Podrobnosti najdete v tématu Microsoft.Identity.Web – Serializace mezipaměti tokenů na GitHubu.

Následující obrázek ukazuje různé možnosti Microsoft.Identity.Web a jejich vliv na soubor Startup.cs :

Blokový diagram znázorňující možnosti konfigurace služby ve spouštěcí sadě C S pro volání webového rozhraní API a zadání implementace mezipaměti tokenů

Poznámka:

Abyste plně porozuměli příkladům kódu, seznamte se se základy ASP.NET Core a zejména injektážem závislostí a možnostmi.

Tajné klíče klienta nebo klientské certifikáty

Adresa URL podřízeného webového rozhraní API
Obory vyžadované pro volání rozhraní API

V následujícím příkladu GraphBeta část určuje tato nastavení.

{
  "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"]
    }
}

Poznámka:

Místo tajného klíče klienta můžete zadat klientský certifikát. Následující fragment kódu ukazuje použití certifikátu uloženého ve službě 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"]
  }
}

Upozorňující

Startup.Auth.cs

Vaše webová aplikace potřebuje získat token pro podřízené rozhraní API, Microsoft.Identity.Web poskytuje dva mechanismy pro volání webového rozhraní API z webové aplikace. Možnost, kterou zvolíte, závisí na tom, jestli chcete volat Microsoft Graph nebo jiné rozhraní API.

Možnost 1: Volání Microsoft Graphu

Přidejte do projektu balíček NuGet Microsoft.Identity.Web.GraphServiceClient .
Přidejte .AddMicrosoftGraph() do kolekce služeb v souboru Startup.Auth.cs . .AddMicrosoftGraph() má několik přepsání. Pomocí přepsání, které jako parametr přebírá oddíl konfigurace, se kód stane:

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

Možnost 2: Volání podřízeného webového rozhraní API jiného než Microsoft Graphu

Pokud chcete volat jiné rozhraní než Microsoft Graph, Microsoft.Identity.Web umožňuje používat IDownstreamApi rozhraní v akcích rozhraní API. Chcete-li použít toto rozhraní:

Přidejte do projektu balíček NuGet Microsoft.Identity.Web.DownstreamApi .
Přidejte .AddDownstreamApi() za .EnableTokenAcquisitionToCallDownstreamApi() soubor Startup.cs . .AddDownstreamApi() má dva argumenty:
- Název služby (API): Tento název použijete v akcích kontroleru k odkazování na odpovídající konfiguraci.
- oddíl konfigurace představující parametry používané k volání podřízeného webového rozhraní API.

Tady je kód:

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

Shrnutí

Můžete zvolit různé implementace mezipaměti tokenů. Podrobnosti najdete v tématu Microsoft.Identity.Web – Serializace mezipaměti tokenů na GitHubu.

Následující obrázek ukazuje různé možnosti Microsoft.Identity.Web a jejich vliv na soubor Startup.cs :

Blokový diagram znázorňující možnosti konfigurace služby ve spouštěcí sadě C S pro volání webového rozhraní API a zadání implementace mezipaměti tokenů

Poznámka:

Abyste plně porozuměli příkladům kódu, seznamte se se základy ASP.NET Core a zejména injektážem závislostí a možnostmi.

Příklady kódu v tomto článku a následující příklady se extrahují z ukázky webové aplikace ASP.NET. Na tuto ukázku můžete chtít odkazovat pro úplné podrobnosti implementace.

Implementace ukázky kódu Node.js

Příklady kódu v tomto článku a následující příklady se extrahují z webové aplikace Node.js a Express.js, která volá Microsoft Graph, ukázku webové aplikace, která používá uzel MSAL.

Ukázka v současné době umožňuje uzlu MSAL vytvořit adresu URL autorizačního kódu a zpracuje navigaci do koncového bodu autorizace pro platformu Microsoft Identity Platform. Toto je znázorněno níže:

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

Kód, který uplatní autorizační kód

Microsoft.Identity.Web zjednodušuje váš kód nastavením správného nastavení OpenID Connect, přihlášením k odběru přijaté události a uplatněním kódu. K uplatnění autorizačního kódu se nevyžaduje žádný další kód. Podrobnosti o tom, jak to funguje, najdete ve zdrojovém kódu Microsoft.Identity.Web.

Metoda handleRedirect ve třídě AuthProvider zpracovává autorizační kód přijatý z ID Microsoft Entra. Toto je znázorněno níže:

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

Podívejte se na webovou aplikaci, která přihlašuje uživatele: Konfigurace kódu, abyste pochopili, jak ukázka Javy získá autorizační kód. Jakmile aplikace obdrží kód, AuthFilter.java#L51-L56:

Deleguje metodu AuthHelper.processAuthenticationCodeRedirect v AuthHelper.java#L67-L97.
Zavolá metodu 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
  }
}

Metoda je definována getAuthResultByAuthCode v AuthHelper.java#L176. Vytvoří knihovnu MSAL ConfidentialClientApplicationa potom zavolá acquireToken() AuthorizationCodeParameters vytvořenou z autorizačního kódu.

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

Podívejte se na webovou aplikaci, která přihlašuje uživatele: Konfigurace kódu, abyste pochopili, jak ukázka Pythonu získá autorizační kód.

Přihlašovací obrazovka Microsoftu odešle autorizační kód na /getAToken adresu URL zadanou v registraci aplikace. Trasa auth_response tuto adresu URL zpracuje, zavolá auth.complete_login autorizační kód a pak buď vrátí chybu, nebo přesměruje na domovskou stránku.

@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"))

Úplný kontext tohoto kódu najdete v app.py .

Místo tajného klíče klienta může důvěrná klientská aplikace také prokázat svou identitu pomocí klientského certifikátu nebo klientského kontrolního výrazu. Použití klientských kontrolních výrazů je pokročilý scénář podrobně popsaný v klientských kontrolních výrazech.

Mezipaměť tokenů

Důležité

Implementace mezipaměti tokenů pro webové aplikace nebo webová rozhraní API se liší od implementace desktopových aplikací, což je často založené na souborech. Z důvodů zabezpečení a výkonu je důležité zajistit, aby pro webové aplikace a webová rozhraní API byla jedna mezipaměť tokenů na uživatelský účet. Pro každý účet je nutné serializovat mezipaměť tokenů.

Kurz ASP.NET jádra používá injektáž závislostí, abyste mohli rozhodnout o implementaci mezipaměti tokenů v souboru Startup.cs pro vaši aplikaci. Microsoft.Identity.Web obsahuje předem sestavené serializátory token-cache popsané v serializaci mezipaměti tokenů. Zajímavá možnost je zvolit ASP.NET mezipaměti distribuované paměti Core:

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

Podrobnosti o poskytovatelích mezipaměti tokenů najdete v článku o serializaci mezipaměti tokenů microsoft.Identity.Web a kurzech k webové aplikaci ASP.NET Core | Fáze ukládání tokenů do mezipaměti kurzu webových aplikací

Kurz ASP.NET používá injektáž závislostí, abyste mohli rozhodnout o implementaci mezipaměti tokenů v souboru Startup.Auth.cs pro vaši aplikaci. Microsoft.Identity.Web obsahuje předem sestavené serializátory token-cache popsané v serializaci mezipaměti tokenů. Zajímavá možnost je zvolit ASP.NET mezipaměti distribuované paměti Core:

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

Podrobnosti o poskytovatelích mezipaměti tokenů najdete také v článku o serializaci mezipaměti tokenů Microsoft.Identity.Web Token a kurzech k webové aplikaci ASP.NET Core | Fáze ukládání tokenů do mezipaměti kurzu webové aplikace

Podrobnosti naleznete v tématu Serializace mezipaměti tokenů pro MSAL.NET.

MSAL Java poskytuje metody serializace a deserializace mezipaměti tokenů. Ukázka Javy zpracovává serializaci z relace, jak je znázorněno v getAuthResultBySilentFlow metodě v 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;
}

Podrobnosti SessionManagementHelper třídy jsou uvedeny v ukázce MSAL pro Javu.

V ukázce Node.js se relace aplikace používá k ukládání mezipaměti tokenů. Pomocí metod mezipaměti uzlu MSAL se mezipaměť tokenů v relaci před provedením požadavku na token přečte a po úspěšném dokončení požadavku na token se aktualizuje. Toto je znázorněno níže:

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

V ukázce Pythonu se balíček identity postará o mezipaměť tokenů pomocí globálního session objektu pro úložiště.

Flask má integrovanou podporu relací uložených v souboru cookie, ale vzhledem k délce souborů cookie identity používá ukázka místo toho balíček relace Flask. Vše se inicializuje v 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"],
)

SESSION_TYPE="filesystem" Kvůli nastavení v app_config.pybalíčku relace Flask ukládá relace pomocí místního systému souborů.

V produkčním prostředí byste měli použít nastavení , které se zachová napříč několika instancemi a nasadí vaši aplikaci, například sqlachemy nebo redis.

Další krok

Když se uživatel přihlásí, v tomto okamžiku se token uloží do mezipaměti tokenů. Pojďme se podívat, jak se pak používá v jiných částech webové aplikace.

Odeberte účty z mezipaměti při globálním odhlášení.

Sdílet prostřednictvím

Webová aplikace, která volá webová rozhraní API: Konfigurace kódu

Požadavky

Knihovny Microsoftu podporující webové aplikace

Tajné klíče klienta nebo klientské certifikáty

Úprava souboru Startup.cs

Možnost 1: Volání Microsoft Graphu

Možnost 2: Volání podřízeného webového rozhraní API jiného než Microsoft Graphu

Shrnutí

Tajné klíče klienta nebo klientské certifikáty

Startup.Auth.cs

Možnost 1: Volání Microsoft Graphu

Možnost 2: Volání podřízeného webového rozhraní API jiného než Microsoft Graphu

Shrnutí

Implementace ukázky kódu Java

Implementace ukázky kódu Node.js

Implementace ukázky kódu Pythonu

Kód, který uplatní autorizační kód

Mezipaměť tokenů

Další krok

Váš názor

Další materiály