Share via

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

  • Artikel

In deze zelfstudie ziet u hoe u uw Node.js daemon-client-app voorbereidt en deze vervolgens configureert om een toegangstoken te verkrijgen voor het aanroepen van een web-API. De toepassing die u bouwt, maakt gebruik van Microsoft Authentication Library (MSAL) voor Node om het toevoegen van autorisatie aan uw knooppuntdaemontoepassing te vereenvoudigen.

Met de stroom voor het verlenen van OAuth 2.0-clientreferenties kan een webservice (vertrouwelijke client) eigen referenties gebruiken in plaats van een gebruiker te imiteren, om te verifiëren voordat een andere webservice wordt aangeroepen. De stroom voor het verlenen van clientreferenties wordt vaak gebruikt voor server-naar-serverinteracties die op de achtergrond moeten worden uitgevoerd, zonder onmiddellijke interactie met een gebruiker.

In deze zelfstudie gaat u:

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

Vereisten

  • Node.js.
  • Visual Studio Code of een andere code-editor.
  • Registratiedetails voor de Node.js daemon-app en web-API die u hebt gemaakt in de zelfstudie tenant voorbereiden.
  • Een beveiligde web-API die wordt uitgevoerd en klaar is om aanvragen te accepteren. Als u nog geen web-API hebt gemaakt, raadpleegt u de zelfstudie Een beveiligde web-API maken. Zorg ervoor dat deze web-API gebruikmaakt van de app-registratiegegevens 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 todo's te krijgen.
    • POST /api/todolist om een todo toe te voegen.

Het Node.js-daemonproject maken

Maak een map voor het hosten van uw Node.js daemontoepassing, zoals ciam-call-api-node-daemon:

  1. Wijzig in uw terminal de map in de map van uw Node-daemon-app, zoals cd ciam-call-api-node-daemon, en voer vervolgens uit npm init -y. Met deze opdracht maakt u een package.json-standaardbestand voor uw Node.js-project. Met deze opdracht maakt u een package.json-standaardbestand 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 axiosin uw terminal de pakketten en @azure/msal-nodeyargs 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 vervolgens 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 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 dit door het subdomein Map (tenant). Als het primaire domein van uw tenant bijvoorbeeld is contoso.onmicrosoft.com, gebruikt u contoso. Als u de naam van uw tenant niet hebt, leest u hoe u uw tenantgegevens kunt lezen.

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

  • Enter_the_Web_Api_Application_Id_Here door 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 auth.js-bestand in de code-editor en voeg vervolgens 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 object en voor apiConfig . De tokenRequest bevat het bereik waarvoor u een toegangstoken aanvraagt. Het bereik ziet er ongeveer als volgt api://Enter_the_Web_Api_Application_Id_Here/.defaultuit. Het apiConfig -object bevat het eindpunt voor uw web-API. Meer informatie over de OAuth 2.0-clientreferentiestroom.

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

    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 fetch.js-bestand in de code-editor 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 voert u een aanroep uit naar de web-API door het toegangstoken door te geven als een Bearer-token in de aanvraagheader Authorization :

 Authorization: `Bearer ${accessToken}`

U gebruikt het toegangstoken dat u eerder hebt verkregen in Een toegangstoken verkrijgen.

Zodra de web-API de aanvraag heeft ontvangen, wordt er 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 index.js-bestand in de code-editor 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 js-opdrachtregelbibliotheek voor het parseren van argumenten voor Node.js-apps om interactief een toegangstoken op te halen en vervolgens DE API aan te roepen. U gebruikt de getToken functies en 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 punt bent u klaar om uw client daemon-app en web-API te testen:

  1. Gebruik de stappen die u hebt geleerd in de zelfstudie Een ASP.NET web-API beveiligen om uw web-API te starten. Uw web-API is nu gereed 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 bevat Node.js app, zoals ciam-call-api-node-daemon, en voer vervolgens de volgende opdracht uit:

    node . --op getToDos

Als uw daemon-app en web-API worden uitgevoerd, vindt u de gegevens 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 stappen

Meer informatie over het gebruik van een clientcertificaat in plaats van een geheim voor verificatie in uw Node.js vertrouwelijke app.