Hämta en åtkomsttoken i din Node.js webbapp

Gäller för: arbetskraftshyresgäster externa hyresgäster (lära dig mer)

I den här artikeln uppdaterar du koden så att webbappen kan hämta en åtkomsttoken. Du använder Microsoft Authentication Library (MSAL) för Node för att förenkla tillägg av autentisering och auktorisering i nodwebbprogrammet. Den här artikeln är den tredje delen i en guideserie i fyra delar.

Förutsättningar

• Slutför stegen i den första delen av den här guideserien Förbered extern hyresgäst för att anropa ett API i en Node.js webbapplikation.
• Slutför stegen i den andra delen av den här guideserien Förbered appen för att anropa ett API i ett Node.js webbprogram.

Uppdatera MSAL-konfigurationsobjekt

Öppna authConfig.js fil i kodredigeraren och uppdatera sedan koden genom att lägga till protectedResources-objektet:

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

I din authConfig.js-fil ersätter du Enter_the_Web_Api_Application_Id_Here med program-ID:t (klient) för webb-API-appen som du registrerade i kundens klientorganisation.

Variablerna todolistReadScope och todolistReadWriteScope innehåller webb-API:ets fullständiga omfångs-URL:er som du angav i din externa klientorganisation. Kontrollera att du exporterar protectedResources-objektet.

Hämta åtkomsttoken

Öppna filen autentisering/AuthProvider.js i kodredigeraren och uppdatera sedan metoden getToken i klassen 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);
                }
            };
        }
    //...
    }

• Först försöker funktionen hämta en åtkomsttoken tyst (utan att fråga användaren om autentiseringsuppgifter):

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

• Om du hämtar en token utan användarens medgivande, lagra den i en session. Du hämtar token från sessionen när du anropar ett API.

  req.session.accessToken = tokenResponse.accessToken;
  

• Om du inte kan hämta token i tysthet (till exempel med undantag InteractionRequiredAuthError), begär du en åtkomsttoken på nytt.

Not

När klientprogrammet har fått en åtkomsttoken bör det behandlas som en ogenomskinlig sträng. Åtkomsttoken är avsedd för API:et, inte för klientprogrammet. Därför bör klientprogrammet inte försöka läsa eller bearbeta åtkomsttoken. I stället bör den inkludera åtkomsttoken as-is i Authorization-huvudet för dess begäranden till API:et. API:et ansvarar för att tolka åtkomsttoken och använda den för att autentisera och auktorisera klientprogrammets begäranden.

Nästa steg

Anropa en API