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

Gäller för:Personalklientorganisationer Externa klienter (läs 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 klientorganisation för att anropa ett API i en Node.js webbapp.
• Slutför stegen i den andra delen av den här guideserien, Förbered appen för att anropa ett API i en Node.js webbapp.

Uppdatera MSAL-konfigurationsobjekt

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

    //..   
    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 Enter_the_Web_Api_Application_Id_Here du 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 autentisering/AuthProvider.js fil i kodredigeraren och uppdatera getToken sedan metoden i AuthProvider klassen:

    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 tyst lagrar du 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 tyst (till exempel med InteractionRequiredAuthError undantag) begär du en åtkomsttoken på nytt.

Kommentar

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 som den är i auktoriseringshuvudet 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.

Gå vidare

Anropa ett API