Kurz: Volání webového rozhraní API z aplikace démona Node.js

Tento kurz ukazuje, jak připravit klientskou aplikaci démona Node.js a pak ji nakonfigurovat tak, aby získala přístupový token pro volání webového rozhraní API. Aplikace, kterou sestavíte, používá knihovnu Microsoft Authentication Library (MSAL) pro Node ke zjednodušení přidávání autorizace do aplikace démona uzlu.

Tok udělení přihlašovacích údajů klienta OAuth 2.0 umožňuje webové službě (důvěrnému klientovi) použít vlastní přihlašovací údaje místo zosobnění uživatele k ověření před voláním jiné webové služby. Tok udělení přihlašovacích údajů klienta se běžně používá pro interakce mezi servery, které musí běžet na pozadí bez okamžité interakce s uživatelem.

V tomto kurzu provedete následující:

• Vytvořte Node.js aplikaci a pak nainstalujte závislosti.
• Povolte aplikaci Node.js, aby získala přístupový token pro volání webového rozhraní API.

Požadavky

• Node.js.
• Visual Studio Code nebo jiný editor kódu.
• Podrobnosti registrace aplikace démona Node.js a webového rozhraní API, které jste vytvořili v kurzu přípravy tenanta.
• Chráněné webové rozhraní API, které je spuštěné a připravené přijímat požadavky. Pokud jste ho ještě nevytvořili, projděte si kurz vytvoření chráněného webového rozhraní API. Ujistěte se, že toto webové rozhraní API používá podrobnosti o registraci aplikace, které jste vytvořili v kurzu přípravy tenanta. Ujistěte se, že webové rozhraní API zveřejňuje následující koncové body prostřednictvím protokolu https:
  • GET /api/todolist dostat všechny todos.
  • POST /api/todolist a přidejte úkol.

Vytvoření projektu démona Node.js

Vytvořte složku pro hostování aplikace démona Node.js, například ciam-call-api-node-daemon:

1. V terminálu změňte adresář na složku aplikace démon Node, například cd ciam-call-api-node-daemon, a pak spusťte npm init -ypříkaz . Tímto příkazem vytvoříte pro svůj projekt Node.js výchozí soubor package.json. Tento příkaz vytvoří výchozí package.json soubor pro projekt Node.js.

2. Vytvořte další složky a soubory, abyste dosáhli následující struktury projektu:

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

Instalace závislostí aplikací

V terminálu nainstalujte axiosbalíčky a @azure/msal-nodeyargs spuštěním následujícího příkazu:

npm install axios yargs @azure/msal-node   

Vytvoření objektu konfigurace MSAL

V editoru kódu otevřete souborauthConfig.js a přidejte následující kód:

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,
};

Objekt msalConfig obsahuje sadu možností konfigurace, které slouží k přizpůsobení chování toku autorizace.

V souboru authConfig.js nahraďte:

• Enter_the_Application_Id_Here s ID aplikace (klienta) aplikace démon klienta, kterou jste zaregistrovali dříve.

• Enter_the_Tenant_Subdomain_Here a nahraďte ji subdoménou Adresáře (tenanta). Pokud je contoso.onmicrosoft.comnapříklad primární doménou vašeho tenanta , použijte contoso. Pokud nemáte název tenanta, přečtěte si, jak si přečíst podrobnosti o tenantovi.

• Enter_the_Client_Secret_Here s hodnotou tajného klíče aplikace démon klienta, kterou jste zkopírovali dříve.

• Enter_the_Web_Api_Application_Id_Here s ID aplikace (klienta) webové aplikace API, kterou jste zkopírovali dříve.

Všimněte si, že scopes vlastnost v protectedResources proměnné je identifikátor prostředku (IDENTIFIKÁTOR URI ID aplikace) webového rozhraní API , které jste zaregistrovali dříve. Identifikátor URI úplného oboru vypadá podobně jako api://Enter_the_Web_Api_Application_Id_Here/.default.

Získání přístupového tokenu

V editoru kódu otevřete souborauth.js a přidejte následující kód:

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,
};

V kódu:

• tokenRequest Připravte objekt aapiConfig. Obsahuje tokenRequest obor, pro který požadujete přístupový token. Obor vypadá přibližně takto api://Enter_the_Web_Api_Application_Id_Here/.default: . Objekt apiConfig obsahuje koncový bod webového rozhraní API. Přečtěte si další informace o toku přihlašovacích údajů klienta OAuth 2.0.

• Instanci důvěrného klienta vytvoříte předáním objektu msalConfig do konstruktoru třídy ConfidentialClientApplication .

  const cca = new msal.ConfidentialClientApplication(msalConfig);
  

• Pak pomocí funkce acquireTokenByClientCredential získáte přístupový token. Tuto logiku implementujete ve getToken funkci:

  cca.acquireTokenByClientCredential(tokenRequest);
  

Po získání přístupového tokenu můžete pokračovat voláním rozhraní API.

Volání rozhraní API

V editoru kódu otevřete souborfetch.js a přidejte následující kód:

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
};

V tomto kódu provedete volání webového rozhraní API předáním přístupového tokenu jako nosný token v hlavičce požadavku Authorization :

 Authorization: `Bearer ${accessToken}`

Použijete přístupový token, který jste získali dříve v části Získání přístupového tokenu.

Jakmile webové rozhraní API přijme požadavek, vyhodnotí ho a pak určí, že se jedná o žádost aplikace. Pokud je přístupový token platný, webové rozhraní API vrátí požadovaná data. V opačném případě rozhraní API vrátí 401 Unauthorized chybu HTTP.

Dokončení aplikace démona

V editoru kódu otevřete souborindex.js a přidejte následující kód:

#!/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();

Tento kód je vstupním bodem vaší aplikace. K interaktivnímu načtení přístupového tokenu a následnému volání rozhraní API použijete knihovnu pro analýzu argumentů jargs js pro Node.js aplikace. Použijete getToken funkce a, callApi které jste definovali dříve:

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

Spuštění a testování aplikace a rozhraní API démona

V tuto chvíli jste připraveni otestovat aplikaci démona klienta a webové rozhraní API:

1. Pomocí kroků, které jste se naučili v kurzu Zabezpečení ASP.NET webového rozhraní API , spusťte webové rozhraní API. Vaše webové rozhraní API je teď připravené obsluhovat požadavky klientů. Pokud webové rozhraní API nespustíte na portu 44351 , jak je uvedeno v souboruauthConfig.js , nezapomeňte aktualizovat souborauthConfig.js tak, aby používal správné číslo portu webového rozhraní API.

2. V terminálu se ujistěte, že jste ve složce projektu, která obsahuje aplikaci démona Node.js, jako ciam-call-api-node-daemonje , a spusťte následující příkaz:

   node . --op getToDos
   

Pokud se vaše aplikace démona a webové rozhraní API úspěšně spustí, měli byste v okně konzoly najít data vrácené proměnnou koncového bodu todos webového rozhraní API, podobně jako v následujícím poli JSON:

{
    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'
}

Další kroky

Zjistěte, jak používat klientský certifikát místo tajného klíče pro ověřování v Node.js důvěrné aplikaci.