Acquisire un token di accesso nell'app Web Node.js

Applicabile a: Tenant esterni della forza lavoro (altre informazioni)

In questo articolo si aggiorna il proprio codice per consentire all'app Web di acquisire un token di accesso. Si usa Microsoft Authentication Library (MSAL) per Node per semplificare l'aggiunta di autenticazione e autorizzazione all'applicazione Web node. Questo articolo è la terza parte di una serie di guide di quattro parti.

Prerequisiti

• Completare i passaggi della prima parte di questa serie di guide, Preparare il tenant esterno per chiamare un'API in un'applicazione Web Node.js.
• Completare i passaggi della seconda parte di questa serie di guide, Preparare l’app per chiamare un'API in un'applicazione Web Node.js.

Aggiornare l'oggetto di configurazione MSAL

Nell'editor di codice, aprire il file authConfig.js, quindi aggiornare il codice aggiungendo l'oggetto 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,
        //..
    };

Nel file authConfig.js, sostituire Enter_the_Web_Api_Application_Id_Here con l'ID applicazione (client) dell'app per le API Web registrata nel tenant del cliente.

Le variabili todolistReadScope e todolistReadWriteScope contengono gli URL di ambito completo dell'API Web impostati nel tenant esterno. Assicurarsi di esportare l'oggetto protectedResources.

Acquisire il token di accesso

Nell'editor di codice, aprire il file auth/AuthProvider.js, quindi aggiornare il metodo getToken nella classe 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);
                }
            };
        }
    //...
    }

• Prima di tutto, la funzione tenta di acquisire automaticamente un token di accesso (senza richiedere le credenziali all’utente):

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

• Se si acquisisce silenziosamente un token, archiviarlo in una sessione. Il token viene recuperato dalla sessione quando si chiama un'API.

  req.session.accessToken = tokenResponse.accessToken;
  

• Se non si riesce ad acquisire silenziosamente il token (ad esempio, con eccezione InteractionRequiredAuthError), richiedere un token di accesso non aggiornato.

Nota

Quando l'applicazione client riceve un token di accesso, deve considerarlo come stringa opaca. Il token di accesso è destinato all'API, non all'applicazione client. Pertanto, l'applicazione client non deve tentare di leggere o elaborare il token di accesso. Deve invece includere il token di accesso così come è nell'intestazione Autorizzazione delle proprie richieste all'API. L'API è responsabile dell'interpretazione del token di accesso e del suo uso per autenticare e autorizzare le richieste dell'applicazione client.

Passaggio successivo

Chiamare un'API