Získání přístupového tokenu ve webové aplikaci Node.js

platí pro: uživatelé pracovních sil externí uživatelé. (další informace)

V tomto článku aktualizujete kód, aby vaše webová aplikace mohla získat přístupový token. Pro Node používáte Microsoft Authentication Library (MSAL) ke zjednodušení přidávání ověřování a autorizace do webové aplikace uzlu. Tento článek je třetí částí čtyřdílné série průvodců.

Požadavky

• Dokončete kroky v první části této série průvodců Příprava externího tenanta na volání rozhraní API ve webové aplikaci Node.js.
• Dokončete kroky ve druhé části této série návodů Příprava aplikace na volání rozhraní API ve webové aplikaci Node.js.

Aktualizace objektu konfigurace MSAL

V editoru kódu otevřete soubor authConfig.js a aktualizujte kód přidáním objektu protectedResources:

    //..   
    const toDoListReadScope = process.env.TODOLIST_READ || 'api://Enter_the_Web_Api_Application_Id_Here/ToDoList.Read';
    const toDoListReadWriteScope = process.env.TODOLIST_READWRITE || 'api://Enter_the_Web_Api_Application_Id_Here/ToDoList.ReadWrite';
    
    const protectedResources = {
        toDoListAPI: {
            endpoint: 'https://localhost:44351/api/todolist',
            scopes: {
                read: [toDoListReadScope],
                write: [toDoListReadWriteScope],
            },
        },
    };    
    module.exports = {
        //..
        protectedResources,
        //..
    };

V souboru authConfig.js nahraďte Enter_the_Web_Api_Application_Id_Here ID aplikace (klienta) webové aplikace API, kterou jste zaregistrovali v tenantovi zákazníka.

Proměnné todolistReadScope a todolistReadWriteScope obsahují adresy URL úplného oboru webového rozhraní API, které jste nastavili ve svém externím tenantovi. Ujistěte se, že exportujete objekt protectedResources.

Získání přístupového tokenu

V editoru kódu otevřete soubor ověřování/AuthProvider.js a pak aktualizujte metodu getToken ve třídě AuthProvider:

    const axios = require('axios');
    class AuthProvider {
    //...
        getToken(scopes) {
            return  async function (req, res, next) {
                const msalInstance = authProvider.getMsalInstance(authProvider.config.msalConfig);
                try {
                    msalInstance.getTokenCache().deserialize(req.session.tokenCache);
    
                    const silentRequest = {
                        account: req.session.account,
                        scopes: scopes,
                    };
    
                    const tokenResponse = await msalInstance.acquireTokenSilent(silentRequest);
    
                    req.session.tokenCache = msalInstance.getTokenCache().serialize();
                    req.session.accessToken = tokenResponse.accessToken;
                    next();
                } catch (error) {
                    if (error instanceof msal.InteractionRequiredAuthError) {
                        req.session.csrfToken = authProvider.cryptoProvider.createNewGuid();
    
                        const state = authProvider.cryptoProvider.base64Encode(
                            JSON.stringify({
                                redirectTo: 'http://localhost:3000/todos',
                                csrfToken: req.session.csrfToken,
                            })
                        );
                        
                        const authCodeUrlRequestParams = {
                            state: state,
                            scopes: scopes,
                        };
    
                        const authCodeRequestParams = {
                            state: state,
                            scopes: scopes,
                        };
    
                        authProvider.redirectToAuthCodeUrl(
                            req,
                            res,
                            next,
                            authCodeUrlRequestParams,
                            authCodeRequestParams,
                            msalInstance
                        );
                    }
    
                    next(error);
                }
            };
        }
    //...
    }

• Nejprve se funkce pokusí bezobslužně získat přístupový token (bez výzvy uživatele k zadání přihlašovacích údajů):

  const silentRequest = {
      account: req.session.account,
      scopes: scopes,
  };
  
  const tokenResponse = await msalInstance.acquireTokenSilent(silentRequest);
  

• Pokud token úspěšně získáte tiše, uložte ho do relace. Token načtete z relace při volání rozhraní API.

  req.session.accessToken = tokenResponse.accessToken;
  

• Pokud se vám nepodaří získat token bez zásahu uživatele (například s výjimkou InteractionRequiredAuthError), požádejte o přístupový token znovu.

Poznámka

Jakmile klientská aplikace obdrží přístupový token, měl by s ním zacházet jako s neprůzým řetězcem. Přístupový token je určený pro rozhraní API, ne pro klientskou aplikaci. Klientská aplikace by se proto neměla pokoušet číst ani zpracovávat přístupový token. Místo toho by měl obsahovat přístupový token as-is do hlavičky Authorization svých požadavků na rozhraní API. Rozhraní API zodpovídá za interpretaci přístupového tokenu a jeho použití k ověření a autorizaci požadavků klientské aplikace.

Další krok

Zavolejte API