Adquira 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 Microsoft Authentication Library (MSAL) for Node para simplificar a adição de autenticação e autorização ao seu aplicativo Web de nó. 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 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 Node.js.

Atualizar objeto de configuração MSAL

No editor de códigos, abra authConfig.js arquivo e atualize o código adicionando o protectedResources objeto:

    //..   
    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 pela ID do aplicativo (cliente) do aplicativo de API da Web que você registrou no locatário do cliente.

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

Adquirir token de acesso

No editor de códigos, abra o arquivo auth/AuthProvider.js e atualize o getToken método na AuthProvider classe:

    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, armazene-o em uma sessão. Você recupera o token da sessão quando chama uma API.

  req.session.accessToken = tokenResponse.accessToken;
  

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

Nota

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, ele deve incluir o token de acesso como está no cabeçalho Authorization 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óximo passo

Chamar uma API