Share via

Zelfstudie: Een web-API aanroepen vanuit uw Node.js daemon-toepassing

  • Artikel

Deze zelfstudie is het laatste deel van een reeks die laat zien hoe u uw Node.js daemon-client-app voorbereidt met behulp van de OAuth 2.0-clientreferentiestroom (Open Authorization) 2.0 en deze vervolgens configureert om een toegangstoken te verkrijgen voor het aanroepen van een web-API. In deel 1 van deze reeks hebt u een web-API en daemon-app geregistreerd in het Microsoft Entra-beheercentrum en machtigingen verleend. In deze laatste stap ziet u hoe u een Node.js-toepassing bouwt met behulp van de Microsoft Authentication Library (MSAL) voor Node om het toevoegen van autorisatie aan uw app te vereenvoudigen.

In deze zelfstudie;

  • Maak een Node.js-app in Visual Studio Code en installeer vervolgens afhankelijkheden.
  • Schakel de Node.js-app in om een toegangstoken te verkrijgen voor het aanroepen van een web-API.

Vereisten

  • Zelfstudie: Uw externe tenant voorbereiden om een Node.js daemon-toepassing te autoriseren.
  • Een beveiligde web-API die wordt uitgevoerd en gereed is om aanvragen te accepteren. Als u er nog geen hebt gemaakt, raadpleegt u de zelfstudie over het maken van een beveiligde web-API. Zorg ervoor dat deze web-API de app-registratiegegevens gebruikt die u hebt gemaakt in de zelfstudie tenant voorbereiden. Zorg ervoor dat uw web-API de volgende eindpunten beschikbaar maakt via HTTPS:
    • GET /api/todolist om alle todos te krijgen.
    • POST /api/todolist om een todo toe te voegen.
  • Node.js.
  • Hoewel elke IDE (Integrated Development Environment) die React-toepassingen ondersteunt, kan worden gebruikt, maakt deze zelfstudie gebruik van Visual Studio Code.
  • Registratiegegevens voor de Node.js daemon-app en web-API die u hebt gemaakt in de zelfstudie tenant voorbereiden.

Het Node.js-daemonproject maken

Maak een map om uw Node.js daemon-toepassing te hosten, zoals ciam-call-api-node-daemon:

  1. Wijzig in de terminal de map van de Node-daemon-app, zoals cd ciam-call-api-node-daemonen voer npm init -ydeze uit. Met deze opdracht maakt u een package.json-standaardbestand voor uw Node.js-project. Met deze opdracht maakt u een standaardbestand package.json voor uw Node.js project.

  2. Maak extra mappen en bestanden om de volgende projectstructuur te bereiken:

        ciam-call-api-node-daemon/
    ├── auth.js
    └── authConfig.js
    └── fetch.js
    └── index.js 
    └── package.json

App-afhankelijkheden installeren

Installeer axiosyargs en @azure/msal-node pakketten in uw terminal door de volgende opdracht uit te voeren:

npm install axios yargs @azure/msal-node

MSAL-configuratieobject maken

Open authConfig.js bestand in de code-editor en voeg de volgende code toe:

require('dotenv').config();

/**
 * Configuration object to be passed to MSAL instance on creation.
 * For a full list of MSAL Node configuration parameters, visit:
 * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-node/docs/configuration.md
 */    
const msalConfig = {
    auth: {
        clientId: process.env.CLIENT_ID || 'Enter_the_Application_Id_Here', // 'Application (client) ID' of app registration in Azure portal - this value is a GUID
        authority: process.env.AUTHORITY || 'https://Enter_the_Tenant_Subdomain_Here.ciamlogin.com/', // Replace "Enter_the_Tenant_Subdomain_Here" with your tenant subdomain
        clientSecret: process.env.CLIENT_SECRET || 'Enter_the_Client_Secret_Here', // Client secret generated from the app 
    },
    system: {
        loggerOptions: {
            loggerCallback(loglevel, message, containsPii) {
                console.log(message);
            },
            piiLoggingEnabled: false,
            logLevel: 'Info',
        },
    },
};    
const protectedResources = {
    apiToDoList: {
        endpoint: process.env.API_ENDPOINT || 'https://localhost:44351/api/todolist',
        scopes: [process.env.SCOPES || 'api://Enter_the_Web_Api_Application_Id_Here'],
    },
};

module.exports = {
    msalConfig,
    protectedResources,
};

Het msalConfig object bevat een set configuratieopties die u gebruikt om het gedrag van uw autorisatiestroom aan te passen.

Vervang het volgende in het authConfig.js-bestand :

  • Enter_the_Application_Id_Here met de toepassings-id (client) van de client-daemon-app die u eerder hebt geregistreerd.

  • Enter_the_Tenant_Subdomain_Here en vervang het door het subdomein Directory (tenant). Als uw primaire tenantdomein bijvoorbeeld is contoso.onmicrosoft.com, gebruikt u contoso. Als u uw tenantnaam niet hebt, leest u de details van uw tenant.

  • Enter_the_Client_Secret_Here met de geheime waarde van de client daemon-app die u eerder hebt gekopieerd.

  • Enter_the_Web_Api_Application_Id_Here met de toepassings-id (client) van de web-API-app die u eerder hebt gekopieerd.

U ziet dat de scopes eigenschap in de protectedResources variabele de resource-id (toepassings-id-URI) is van de web-API die u eerder hebt geregistreerd. De volledige bereik-URI ziet er ongeveer als volgt uit api://Enter_the_Web_Api_Application_Id_Here/.default.

Een toegangstoken verkrijgen

Open in de code-editor auth.js bestand en voeg de volgende code toe:

const msal = require('@azure/msal-node');
const { msalConfig, protectedResources } = require('./authConfig');
/**
 * With client credentials flows permissions need to be granted in the portal by a tenant administrator.
 * The scope is always in the format '<resource-appId-uri>/.default'. For more, visit:
 * https://docs.microsoft.com/azure/active-directory/develop/v2-oauth2-client-creds-grant-flow
 */
const tokenRequest = {
    scopes: [`${protectedResources.apiToDoList.scopes}/.default`],
};

const apiConfig = {
    uri: protectedResources.apiToDoList.endpoint,
};

/**
 * Initialize a confidential client application. For more info, visit:
 * https://github.com/AzureAD/microsoft-authentication-library-for-js/blob/dev/lib/msal-node/docs/initialize-confidential-client-application.md
 */
const cca = new msal.ConfidentialClientApplication(msalConfig);
/**
 * Acquires token with client credentials.
 * @param {object} tokenRequest
 */
async function getToken(tokenRequest) {
    return await cca.acquireTokenByClientCredential(tokenRequest);
}

module.exports = {
    apiConfig: apiConfig,
    tokenRequest: tokenRequest,
    getToken: getToken,
};

In de code:

  • Bereid het tokenRequest en apiConfig object voor. Het tokenRequest bevat het bereik waarvoor u een toegangstoken aanvraagt. Het bereik ziet er ongeveer als volgt uit api://Enter_the_Web_Api_Application_Id_Here/.default. Het apiConfig object bevat het eindpunt voor uw web-API. Meer informatie over de OAuth 2.0-clientreferentiestroom.

  • U maakt een vertrouwelijk clientexemplaren door het msalConfig object door te geven aan de constructor confidentialClientApplication van de klasse.

    const cca = new msal.ConfidentialClientApplication(msalConfig);

  • Vervolgens gebruikt u de functie acquireTokenByClientCredential om een toegangstoken te verkrijgen. U implementeert deze logica in de getToken functie:

    cca.acquireTokenByClientCredential(tokenRequest);

Zodra u een toegangstoken hebt verkregen, kunt u doorgaan met het aanroepen van een API.

Een API aanroepen

Open in de code-editor fetch.js bestand en voeg vervolgens de volgende code toe:

const axios = require('axios');

/**
 * Calls the endpoint with authorization bearer token.
 * @param {string} endpoint
 * @param {string} accessToken 
 */
async function callApi(endpoint, accessToken) {

    const options = {
        headers: {
            Authorization: `Bearer ${accessToken}`
        }
    };

    console.log('request made to web API at: ' + new Date().toString());

    try {
        const response = await axios.get(endpoint, options);
        return response.data;
    } catch (error) {
        console.log(error)
        return error;
    }
};

module.exports = {
    callApi: callApi
};

In deze code maakt u een aanroep naar de web-API door het toegangstoken door te geven als bearer-token in de aanvraagheader Authorization :

 Authorization: `Bearer ${accessToken}`

U gebruikt het toegangstoken dat u eerder in Acquire an access token hebt verkregen.

Zodra de web-API de aanvraag ontvangt, wordt deze geëvalueerd en wordt vervolgens bepaald dat het een toepassingsaanvraag is. Als het toegangstoken geldig is, retourneert de web-API aangevraagde gegevens. Anders retourneert de API een 401 Unauthorized HTTP-fout.

Uw daemon-app voltooien

Open in de code-editor index.js bestand en voeg vervolgens de volgende code toe:

#!/usr/bin/env node

// read in env settings

require('dotenv').config();

const yargs = require('yargs');
const fetch = require('./fetch');
const auth = require('./auth');

const options = yargs
    .usage('Usage: --op <operation_name>')
    .option('op', { alias: 'operation', describe: 'operation name', type: 'string', demandOption: true })
    .argv;

async function main() {
    console.log(`You have selected: ${options.op}`);

    switch (yargs.argv['op']) {
        case 'getToDos':
            try {
                const authResponse = await auth.getToken(auth.tokenRequest);
                const todos = await fetch.callApi(auth.apiConfig.uri, authResponse.accessToken);                
            } catch (error) {
                console.log(error);
            }

            break;
        default:
            console.log('Select an operation first');
            break;
    }
};

main();

Deze code is het toegangspunt voor uw app. U gebruikt de yargs JavaScript-opdrachtregelargumentenbibliotheek voor het parseren van Node.js-apps om interactief een toegangstoken op te halen en vervolgens API aan te roepen. U gebruikt de getToken functies die callApi u eerder hebt gedefinieerd:

const authResponse = await auth.getToken(auth.tokenRequest);
const todos = await fetch.callApi(auth.apiConfig.uri, authResponse.accessToken);

Daemon-app en API uitvoeren en testen

Op dit moment bent u klaar om uw client-daemon-app en web-API te testen:

  1. Gebruik de stappen die u hebt geleerd in een zelfstudie over het beveiligen van een ASP.NET web-API om uw web-API te starten. Uw web-API is nu klaar om clientaanvragen te verwerken. Als u de web-API niet uitvoert op de poort 44351 die is opgegeven in het authConfig.js-bestand , moet u het authConfig.js-bestand bijwerken om het juiste poortnummer van de web-API te gebruiken.

  2. Controleer in de terminal of u zich in de projectmap bevindt die uw daemon Node.js-app bevat, bijvoorbeeld ciam-call-api-node-daemon, en voer vervolgens de volgende opdracht uit:

    node . --op getToDos

Als uw daemon-app en web-API zijn uitgevoerd, moet u de gegevens vinden die worden geretourneerd door de eindpuntvariabele todos van de web-API, vergelijkbaar met de volgende JSON-matrix, in het consolevenster:

{
    id: 1,
    owner: '3e8....-db63-43a2-a767-5d7db...',
    description: 'Pick up grocery'
},
{
    id: 2,
    owner: 'c3cc....-c4ec-4531-a197-cb919ed.....',
    description: 'Finish invoice report'
},
{
    id: 3,
    owner: 'a35e....-3b8a-4632-8c4f-ffb840d.....',
    description: 'Water plants'
}

Volgende stap

Gebruik clientcertificaat in plaats van een geheim voor verificatie in uw Node.js vertrouwelijke app.