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

Aplica-se a: Locatários da força de trabalho Locatários externos (saiba mais)

Neste artigo, você atualiza seu código para permitir que seu aplicativo Web adquira um token de acesso. Você usa a MSAL (biblioteca de autenticação da Microsoft) para o nó para simplificar a adição de autenticação e autorização ao seu aplicativo Web do nó. Este artigo é a terceira parte de uma série de guias de quatro partes.

Pré-requisitos

• Conclua as etapas na primeira parte desta série de guias, Preparar o locatário externo para chamar uma API em um aplicativo Web Node.js.
• Conclua as etapas na segunda parte desta série de guias, Preparar aplicativo para chamar uma API em um aplicativo Web do Node.js.

Atualizar objeto de configuração da MSAL

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

Em seu arquivo authConfig.js, substitua Enter_the_Web_Api_Application_Id_Here pela ID do aplicativo (cliente) do aplicativo de API Web que você registrou no locatário do cliente.

As variáveis todolistReadScope e todolistReadWriteScope contêm as URLs de escopo completo da API Web definidas no locatário externo. Certifique-se de exportar o objeto protectedResources.

Adquirir o token de acesso

No editor de código, abra o arquivo auth/AuthProvider.js e 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);
  

• Se você adquirir um token silenciosamente com êxito, armazene-o em uma sessão. Você recupera o token da sessão ao chamar uma API.

  req.session.accessToken = tokenResponse.accessToken;
  

• Se você não conseguir adquirir o token silenciosamente (como com a exceção InteractionRequiredAuthError), solicite um token de acesso de novo.

Observação

Depois que o aplicativo cliente receber um token de acesso, ele deverá 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, ele deve incluir o token de acesso como está no cabeçalho de Autorização de suas solicitações para a 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óxima etapa

Chamar uma API