Webes API-kat hívó webalkalmazás: Kódkonfiguráció

A következőkre vonatkozik: Zöld kör fehér pipa szimbólummal, amely azt jelzi, hogy a következő tartalom a munkaerő-bérlőkre vonatkozik. Munkaerő-bérlők (további információ)

Ez a cikk bemutatja, hogyan konfigurálhatja az alkalmazáskódot, és hogyan módosíthatja a webalkalmazást, hogy az ne csak bejelentkezteti a felhasználókat, hanem webes API-kat is hívjon. A létrehozott alkalmazás az OAuth 2.0 engedélyezési kódfolyamatával jelentkezteti be a felhasználót. Ennek a folyamatnak két lépése van:

Engedélyezési kód kérése. Ez a rész lehetőséget biztosít a felhasználó privát interakciójára a Microsoft identitásplatformmal. A párbeszéd során a felhasználó bejelentkezik, és hozzájárul a webes API-k használatához. Ha a privát párbeszéd sikeresen véget ér, a webalkalmazás kap egy engedélyezési kódot az átirányítási URI-n.
Hozzáférési jogkivonat kérése az API-hoz az engedélyezési kód beváltásával.

Előfeltételek

Egy Azure-fiók, aktív előfizetéssel. Hozzon létre egy fiókot ingyenesen. Ennek a fióknak rendelkeznie kell az alkalmazások kezeléséhez szükséges engedélyekkel. Az alkalmazás regisztrálásához használja az alábbi szerepkörök egyikét:
- Alkalmazásadminisztrátor
- Alkalmazásfejlesztő
Regisztráljon egy új alkalmazást a Microsoft Entra felügyeleti központban, amely csak ebben a szervezeti címtárban lévő fiókokhoz van konfigurálva. További részletekért tekintse meg az alkalmazás regisztrálását . Jegyezze fel a következő értékeket az alkalmazás áttekintési oldaláról későbbi használatra:
- Alkalmazás (ügyfél) azonosítója
- Címtár (ügyfél) azonosítója

Webalkalmazásokat támogató Microsoft-kódtárak

A következő Microsoft-kódtárak támogatják a webalkalmazásokat:

Nyelv/ keretrendszer	Projekt folyamatban GitHub	Csomag	Megszerzés elkezdődött	Felhasználók bejelentkezése	Webes API-k elérése	Általánosan elérhető (GA) vagy 1. nyilvános előzetes verzió
.NET	MSAL.NET	Microsoft.Identity.Client	—			GA
.NET	Microsoft.IdentityModel	Microsoft.IdentityModel	—	²	²	GA
ASP.NET Core	Microsoft.Identity.Web	Microsoft.Identity.Web	Gyors útmutató			GA
Java	MSAL4J	msal4j	Gyors útmutató			GA
Tavasz	spring-cloud-azure-starter-active-directory	spring-cloud-azure-starter-active-directory	Oktatóanyag			GA
Node.js	MSAL csomópont	msal-node	Gyors útmutató			GA
Python	MSAL Python	msal	—			GA
Python	azonosság	azonosság	Gyors útmutató			--

⁽¹⁾Az online szolgáltatásokra vonatkozó univerzális licencfeltételek a nyilvános előzetes verzióban lévő kódtárakra vonatkoznak.

⁽²⁾ A Microsoft.IdentityModel-kódtár csak a jogkivonatokat érvényesíti – nem tud azonosítókat vagy hozzáférési jogkivonatokat kérni.

Válassza ki a kívánt platform fülét:

Titkos ügyfélkódok vagy ügyféltanúsítványok

Mivel a webalkalmazás most egy alsóbb rétegbeli webes API-t hív meg, adjon meg egy titkos ügyfélkulcsot vagy ügyféltanúsítványt a appsettings.json fájlban. Hozzáadhat egy szakaszt is, amely a következőket adja meg:

Az alsóbb rétegbeli webes API URL-címe
Az API meghívásához szükséges hatókörök

A következő példában a szakasz ezeket a GraphBeta beállításokat adja meg.

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

Feljegyzés

Javasolhat ügyfél-hitelesítő adatok gyűjteményét, beleértve egy hitelesítő adatok nélküli megoldást, például a számítási feladatok identitásának összevonását az Azure Kuberneteshez. A Microsoft.Identity.Web korábbi verziói egyetlen "ClientSecret" tulajdonságban fejezték ki az ügyfélkulcsot az "Ügyfél hitelesítő adatai" helyett. Ez továbbra is támogatott a visszamenőleges kompatibilitás érdekében, de nem használhatja a "ClientSecret" tulajdonságot és az "Ügyfél hitelesítő adatai" gyűjteményt.

Ügyfélkód helyett ügyféltanúsítványt is megadhat. Az alábbi kódrészlet az Azure Key Vaultban tárolt tanúsítvány használatát mutatja be.

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

Figyelmeztetés

Ha elfelejti tömbbé változtatni a Scopes-t, amikor megpróbálja használni a IDownstreamApi-t, a hatókörök null értékűek lesznek, és a IDownstreamApi névtelen (nem hitelesített) hívást kísérel meg a downstream API-hoz, ami egy 401/unauthenticated-t eredményez.

A Microsoft.Identity.Web számos módszert kínál a tanúsítványok leírására konfiguráció vagy kód alapján egyaránt. További információ: Microsoft.Identity.Web – Tanúsítványok használata a GitHubon.

A Startup.cs fájl módosítása

A webalkalmazásnak jogkivonatot kell beszereznie az alsóbb rétegbeli API-hoz. A .EnableTokenAcquisitionToCallDownstreamApi() sor .AddMicrosoftIdentityWebApp(Configuration) utáni hozzáadásával adhatja meg. Ez a sor elérhetővé teszi a vezérlőben és az IAuthorizationHeaderProvider oldalműveletekben használható szolgáltatást. Azonban, ahogy az alábbi két lehetőség is látható, egyszerűbben is elvégezhető. Önnek ténylegesen választania kell egy token gyorsítótár implementálást, például .AddInMemoryTokenCaches(), a Startup.cs-ban:

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

Az EnableTokenAcquisitionToCallDownstreamApi hatókörök átadása nem kötelező, és lehetővé teszi a webalkalmazás számára, hogy a bejelentkezéskor kérje a hatóköröket és a felhasználó hozzájárulását hozzájuk. Ha nem adja meg a hatóköröket, a Microsoft.Identity.Web növekményes hozzájárulást tesz lehetővé.

A Microsoft.Identity.Web két mechanizmust kínál a webes API webalkalmazásból való meghívására anélkül, hogy jogkivonatot kellene beszereznie. A választott lehetőség attól függ, hogy meghívja-e a Microsoft Graphot vagy egy másik API-t.

1. lehetőség: A Microsoft Graph meghívása

Ha meg szeretné hívni a Microsoft Graphot, a Microsoft.Identity.Web lehetővé teszi a GraphServiceClient (Microsoft Graph SDK által közzétett) közvetlen használatát az API-műveletekben. A Microsoft Graph felfedéséhez:

Adja hozzá a Microsoft.Identity.Web.GraphServiceClient NuGet-csomagot a projekthez.

Adja hozzá .AddMicrosoftGraph() a .EnableTokenAcquisitionToCallDownstreamApi() után a Startup.cs fájlban. .AddMicrosoftGraph() több felülírási lehetőséggel rendelkezik. A konfigurációs szakaszt paraméterként használó felülbírálás használatával a kód a következő lesz:

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

2. lehetőség: A Microsoft Graphtól eltérő alsóbb rétegbeli webes API meghívása

Ha a Microsoft Graphtól eltérő API-t szeretne meghívni, a Microsoft.Identity.Web lehetővé teszi a felület használatát az IDownstreamApi API-műveletekben. A felület használatához:

Adja hozzá a Microsoft.Identity.Web.DownstreamApi NuGet-csomagot a projekthez.

Adja hozzá .AddDownstreamApi() a .EnableTokenAcquisitionToCallDownstreamApi() után a Startup.cs fájlban. .AddDownstreamApi() két argumentuma van, és az alábbi kódrészletben jelenik meg:

A vezérlőműveletek során a megfelelő konfigurációra hivatkozó szolgáltatás (API) neve
egy konfigurációs szakasz, amely az alsóbb rétegbeli webes API meghívásához használt paramétereket jelöli.

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

Összegzés

A webes API-khoz hasonlóan különböző tokengyorsítótár-implementációkat is választhat. További információ: Microsoft.Identity.Web – Token cache szerializálása a GitHubon.

Az alábbi képen a Microsoft.Identity.Web különböző lehetőségei láthatók, és azok hatása a Startup.cs fájlra:

Blokkdiagram, amely bemutatja a szolgáltatáskonfigurációs lehetőségeket a startup.cs fájlban a webes API meghívásához és a tokengyorsítótár implementációjának meghatározásához

Feljegyzés

Az itt található kód példák teljes megértéséhez ismernie kell ASP.NET alapvető alapismereteket, és különösen a függőséginjektálást és a lehetőségeket.

Titkos ügyfélkódok vagy ügyféltanúsítványok

Az alsóbb rétegbeli webes API URL-címe
Az API meghívásához szükséges hatókörök

A következő példában a szakasz ezeket a GraphBeta beállításokat adja meg.

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

Feljegyzés

Ügyfélkód helyett ügyféltanúsítványt is megadhat. Az alábbi kódrészlet az Azure Key Vaultban tárolt tanúsítvány használatát mutatja be.

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

Figyelmeztetés

Startup.Auth.cs

A webalkalmazásnak jogkivonatot kell beszereznie az alsóbb rétegbeli API-hoz, a Microsoft.Identity.Web két mechanizmust biztosít a webes API webalkalmazásból való meghívására. A választott lehetőség attól függ, hogy meghívja-e a Microsoft Graphot vagy egy másik API-t.

1. lehetőség: A Microsoft Graph meghívása

Adja hozzá a Microsoft.Identity.Web.GraphServiceClient NuGet-csomagot a projekthez.
Adja hozzá .AddMicrosoftGraph() a szolgáltatásgyűjteményhez a Startup.Auth.cs fájlban. .AddMicrosoftGraph() több felülírási lehetőséggel rendelkezik. A konfigurációs szakaszt paraméterként használó felülbírálás használatával a kód a következő lesz:

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

2. lehetőség: A Microsoft Graphtól eltérő alsóbb rétegbeli webes API meghívása

Ha a Microsoft Graphtól eltérő API-t szeretne meghívni, a Microsoft.Identity.Web lehetővé teszi a felület használatát az IDownstreamApi API-műveletekben. A felület használatához:

Adja hozzá a Microsoft.Identity.Web.DownstreamApi NuGet-csomagot a projekthez.
Adja hozzá .AddDownstreamApi() a .EnableTokenAcquisitionToCallDownstreamApi() után a Startup.cs fájlban. .AddDownstreamApi() két argumentuma van:
- Egy szolgáltatás (API) neve: ezt a nevet használja a vezérlőműveletekben a megfelelő konfigurációra való hivatkozáshoz
- egy konfigurációs szakasz, amely az alsóbb rétegbeli webes API meghívásához használt paramétereket jelöli.

A kód a következő:

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

Összegzés

Különböző tokengyorsítótár-implementációk közül választhat. További információ: Microsoft.Identity.Web – Token cache szerializálása a GitHubon.

Az alábbi képen a Microsoft.Identity.Web különböző lehetőségei láthatók, és azok hatása a Startup.cs fájlra:

Blokkdiagram, amely bemutatja a szolgáltatáskonfigurációs lehetőségeket a startup.cs fájlban a webes API meghívásához és a tokengyorsítótár implementációjának meghatározásához

Feljegyzés

Az itt található kód példák teljes megértéséhez ismernie kell ASP.NET alapvető alapismereteket, és különösen a függőséginjektálást és a lehetőségeket.

A cikkben és a következő példában szereplő kódmintákat a ASP.NET webalkalmazás-mintából nyerjük ki. A teljes megvalósítási részletekért tekintse meg ezt a mintát.

A Node.js kódminta implementálása

A cikkben és az alábbi példában szereplő kódmintákat a microsoft graphot meghívó Node.js &Express.js webalkalmazásból nyerjük ki, amely egy MSAL-csomópontot használó webalkalmazás-minta.

A minta jelenleg lehetővé teszi az MSAL Node számára az engedélyezési kód URL-címének létrehozását, és kezeli a Microsoft identitásplatform autentikációs végpontjára történő navigációt. Ez az alábbiakban látható:

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

Az engedélyezési kódot beváltó kód

A Microsoft.Identity.Web leegyszerűsíti a kódot a megfelelő OpenID Connect-beállítások beállításával, a kapott eseményre való feliratkozással és a kód beváltásával. Az engedélyezési kód beváltásához nincs szükség további kódra. Ennek működésével kapcsolatos részletekért tekintse meg a Microsoft.Identity.Web forráskódját .

Az AuthProvider osztály handleRedirect metódusa feldolgozza a Microsoft Entra-azonosítótól kapott engedélyezési kódot. Ez az alábbiakban látható:

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

Miután az alkalmazás megkapta az engedélyezési kódot, a AuthFilter.java#L51-L56:

Delegál az AuthHelper.processAuthenticationCodeRedirect metódusra az AuthHelper.java#L67-L97 fájlban.
Hívások 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
  }
}

A getAuthResultByAuthCode metódus AuthHelper.java#L176-ban van definiálva. Létrehoz egy MSAL-t ConfidentialClientApplication, majd meghívja az engedélyezési kódból létrehozott hívásokat acquireToken()AuthorizationCodeParameters .

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

Tekintse meg az oktatóanyagot: Felhasználók bejelentkezése Python Flask-webalkalmazásba a Microsoft identitásplatform használatával

A Microsoft bejelentkezési képernyője elküldi az engedélyezési kódot az /getAToken alkalmazásregisztrációban megadott URL-címre. Az auth_response útvonal kezeli ezt az URL-címet, meghívja auth.complete_login az engedélyezési kód feldolgozására, majd hibát ad vissza, vagy átirányítja a kezdőlapra.

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

A kód teljes kontextusát lásd a app.py .

Az ügyfélkód helyett a bizalmas ügyfélalkalmazás ügyféltanúsítvány vagy ügyfélérvényesítés használatával is igazolni tudja személyazonosságát. A kliens állítások használata egy haladó forgatókönyv, amit a Client assertions részben részletezünk.

Token-gyorsítótár

Fontos

A token-cache implementáció webalkalmazások vagy webes API-k esetében eltér az asztali alkalmazások implementációjától, amely gyakran fájlalapú. Biztonsági és teljesítménybeli okokból fontos, hogy a webalkalmazások és webes API-k esetében felhasználói fiókonként egy token gyorsítótár legyen. Minden fiókhoz serializálnia kell a token gyorsítótárát.

Az ASP.NET alapvető oktatóanyag függőséginjektálást használ annak eldöntéséhez, hogy a tokengyorsítótár implementációja az alkalmazás Startup.cs fájljában van-e. A Microsoft.Identity.Web tartalmaz előre összeállított token-cache szerializálókat, amint a tokengyorsítótár-szerializálás leírja. Érdekes lehetőség az ASP.NET Core elosztott memóriagyorsítótárak kiválasztása:

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

A gyorsítótár-szolgáltató tokenekkel kapcsolatos részletekért lásd még a Microsoft.Identity.Web tokengyorsítótár-szerializálásról szóló cikkét, valamint az ASP.NET Core webalkalmazás oktatóanyagok | A webalkalmazások oktatóanyagának tokengyorsítótár szakaszát.

Az ASP.NET oktatóanyag a függőséginjektálást használja, hogy lehetővé tegye a fejlesztő számára a jogkivonat-gyorsítótár implementációjának kiválasztását az alkalmazás Startup.Auth.cs fájljában. A Microsoft.Identity.Web előre összeállított token-cache szerializálókat tartalmaz, amelyek a Token cache serialization részben vannak leírva. Érdekes lehetőség az ASP.NET Core elosztott memóriagyorsítótárak kiválasztása:

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

A tokengyorsítótár-szolgáltatókkal kapcsolatos részletekért lásd még a Microsoft.Identity.WebTokengyorsítótár-szerializálási cikket, valamint a webalkalmazás oktatóanyagának ASP.NET Core tokengyorsítótár fázisát.

További részletekért lásd a tokengyorsítótár szerializálását az MSAL.NET-hez.

Az MSAL Java metódusokat kínál a gyorsítótárban lévő jogkivonatok szerializálására és deszerializálására. A Java példa kezeli a munkamenet szerializálását, ahogy az getAuthResultBySilentFlow metódusban az AuthHelper.java#L99-L122 fájlban látható.

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

Az osztály részleteit a SessionManagementHelperJava MSAL-mintájában adhatja meg.

A Node.js mintában az alkalmazás munkamenete az értéktároló gyorsítótár tárolására szolgál. Az MSAL Node gyorsítótár-metódusok használatával a token gyorsítótár a munkamenetben beolvasásra kerül a token kérés előtt, majd a token kérés sikeres teljesítése után frissül. Ez az alábbiakban látható:

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

A Python-mintában az identitáscsomag kezeli a jogkivonat-gyorsítótárat, és a tároláshoz a globális session objektumot használja.

A Flask beépített támogatást nyújt a cookie-ban tárolt munkamenetekhez, de az identitás cookie-k hossza miatt a minta a Flask-session csomagot használja. Minden az app.py fájlban van inicializálva.

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"],
)

A Flask-session csomag a SESSION_TYPE="filesystem"app_config.pybeállítás miatt a helyi fájlrendszerrel tárolja a munkameneteket.

Éles környezetben olyan beállítást kell használnia, amely több példányban is megmarad, és üzembe helyezi az alkalmazást, például "sqlachemy" vagy "redis".

Következő lépés

Amikor a felhasználó bejelentkezik, egy token kerül tárolásra a gyorsítótárban. Nézzük meg, hogyan használják a webalkalmazás más részeiben.

Fiókok eltávolítása a globális kijelentkezés gyorsítótárából.

Visszajelzés

Hasznosnak találta ezt az oldalt?

Last updated on 2025-09-11

Megosztás a következőn keresztül:

Titkos ügyfélkódok vagy ügyféltanúsítványok

A Startup.cs fájl módosítása

1. lehetőség: A Microsoft Graph meghívása

2. lehetőség: A Microsoft Graphtól eltérő alsóbb rétegbeli webes API meghívása

Összegzés

Titkos ügyfélkódok vagy ügyféltanúsítványok

Startup.Auth.cs

1. lehetőség: A Microsoft Graph meghívása

2. lehetőség: A Microsoft Graphtól eltérő alsóbb rétegbeli webes API meghívása

Összegzés

A Java-kódminta implementálása

A Node.js kódminta implementálása

A Python-kódminta implementálása

Megosztás a következőn keresztül:

Webes API-kat hívó webalkalmazás: Kódkonfiguráció

Előfeltételek

Webalkalmazásokat támogató Microsoft-kódtárak

Titkos ügyfélkódok vagy ügyféltanúsítványok

A Startup.cs fájl módosítása

1. lehetőség: A Microsoft Graph meghívása

2. lehetőség: A Microsoft Graphtól eltérő alsóbb rétegbeli webes API meghívása

Összegzés

Az engedélyezési kódot beváltó kód

Token-gyorsítótár

Következő lépés

Visszajelzés

További források