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

Tento kurz je poslední částí série, která ukazuje, jak připravit klientskou aplikaci démona Node.js pomocí toku udělení přihlašovacích údajů klienta OAuth 2.0 (Open Authorization) 2.0 a pak ho nakonfigurovat tak, aby získal přístupový token pro volání webového rozhraní API. v části 1 této série jste zaregistrovali webové rozhraní API a aplikaci démona v Centru pro správu Microsoft Entra a udělili oprávnění. Tento poslední krok ukazuje, jak vytvořit Node.js aplikaci pomocí knihovny Microsoft Authentication Library (MSAL) pro Node , aby se zjednodušilo přidávání autorizace do vaší aplikace.

V tomto kurzu;

• Vytvořte Node.js aplikaci v editoru Visual Studio Code a pak nainstalujte závislosti.
• Povolte aplikaci Node.js získání přístupového tokenu pro volání webového rozhraní API.

Požadavky

• Kurz: Příprava externího tenanta na autorizaci aplikace démona Node.js
• Chráněné webové rozhraní API, které je spuštěné a připravené přijímat požadavky. Pokud jste ho nevytvořili, podívejte se na 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 todosy.
  • POST /api/todolist a přidejte todo.
• Node.js.
• I když je možné použít jakékoli integrované vývojové prostředí (IDE), které podporuje aplikace React, tento kurz používá Visual Studio Code.
• Podrobnosti registrace pro aplikaci Node.js démon a webové rozhraní API, které jste vytvořili v kurzu přípravy tenanta.

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ář do složky aplikace démon Node, například cd ciam-call-api-node-daemon, a pak spusťte npm init -y. 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 váš 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 axiosyargs a @azure/msal-node balíčky 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 soubor authConfig.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é používáte 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 například primární doména vašeho tenanta contoso.onmicrosoft.com, 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 kódu 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 si 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. Úplný identifikátor URI 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 soubor auth.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:

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

• Vytvoříte důvěrnou instanci klienta předáním msalConfig objektu do konstruktoru třídy ConfidentialClientApplication .

  const cca = new msal.ConfidentialClientApplication(msalConfig);
  

• Pak použijete funkci acquireTokenByClientCredential k získání přístupového tokenu. Tuto logiku getToken implementujete do funkce:

  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 soubor fetch.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 obdrží požadavek, vyhodnotí ho a pak určí, že se jedná o požadavek 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 soubor index.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 aplikace. Knihovnu pro analýzu argumentů příkazového řádku JavaScriptu použijete pro Node.js aplikací k interaktivnímu načtení přístupového tokenu a následnému volání rozhraní API. Použijete dříve getToken callApi definované funkce:

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

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

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

1. Pomocí kroků, které jste se naučili v kurzu k zabezpečení ASP.NET webového rozhraní API, spusťte webové rozhraní API. Vaše webové rozhraní API je teď připravené k obsluhě požadavků klientů. Pokud webové rozhraní API nespusíte na portu 44351 , jak je uvedeno v souboru authConfig.js , nezapomeňte aktualizovat soubor authConfig.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 proces démon, Node.js aplikaci, například ciam-call-api-node-daemon, 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ší krok

Pro ověřování v Node.js důvěrné aplikaci používejte klientský certifikát místo tajného klíče.