Adquira um token de acesso em seu aplicativo Web Node.js

Aplica-se a: Inquilinos do Workforce Inquilinos externos (saber mais)

Neste artigo, você atualiza seu código para permitir que seu aplicativo Web adquira um token de acesso. Você usa a Microsoft Authentication Library (MSAL) para Node para simplificar a adição de autenticação e autorização à sua aplicação web Node.js. Este artigo é a terceira parte de uma série de guias em quatro partes.

Pré-requisitos

• Conclua as etapas na primeira parte desta série de guias, Preparar inquilino externo para chamar uma API em um aplicativo web Node.js.
• Conclua as etapas na segunda parte desta série de guias, Preparar aplicação para chamar uma API numa aplicação web Node.js.

Atualizar objeto de configuração MSAL

No editor de códigos, abra authConfig.js arquivo e, em seguida, atualize o código adicionando o objeto 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,
        //..
    };

No arquivo authConfig.js, substitua Enter_the_Web_Api_Application_Id_Here pelo ID da aplicação (cliente) da aplicação de API da web que registou no tenant do cliente.

As variáveis todolistReadScope e todolistReadWriteScope mantêm as URLs completas de escopo da API Web que você definiu na sua instância externa. Certifique-se de exportar o objeto protectedResources.

Adquirir token de acesso

No seu editor de código, abra o ficheiro auth/AuthProvider.js e, em seguida, atualize o método getToken na 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);
                }
            };
        }
    //...
    }

• Primeiro, a função tenta adquirir um token de acesso silenciosamente (sem solicitar credenciais ao usuário):

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

• Caso consiga adquirir um token de forma silenciosa, armazene-o numa sessão. Você recupera o token da sessão quando chama uma API.

  req.session.accessToken = tokenResponse.accessToken;
  

• Se não for possível obter o token de forma silenciosa, como, por exemplo, no caso da exceção InteractionRequiredAuthError, solicite novamente um token de acesso.

Observação

Depois que seu aplicativo cliente recebe um token de acesso, ele deve tratá-lo como uma cadeia de caracteres opaca. O token de acesso destina-se à API, não ao aplicativo cliente. Portanto, o aplicativo cliente não deve tentar ler ou processar o token de acesso. Em vez disso, deve incluir o token de acesso as-is no cabeçalho de Autorização das suas solicitações à API. A API é responsável por interpretar o token de acesso e usá-lo para autenticar e autorizar as solicitações do aplicativo cliente.

Próximo passo

Chamar uma API