Introduzione allo sviluppo della rete CDN di Azure

È possibile usare Azure CDN SDK per Node.js per automatizzare la creazione e la gestione dei profili e degli endpoint di rete CDN. Questa esercitazione illustra nel dettaglio la creazione di una semplice applicazione console Node.js che dimostra varie operazioni tra quelle disponibili. Lo scopo di questa esercitazione non è fornire una descrizione dettagliata di tutti gli aspetti di Azure CDN SDK per Node.js.

Per completare questa esercitazione, è necessario che Node.js 4.x.x o versione successiva sia già installato e configurato. Per creare l'applicazione Node.js è possibile usare qualsiasi editor di testo. Per scrivere questa esercitazione è stato usato Visual Studio Code.

Suggerimento

Il progetto completato di questa esercitazione è disponibile per il download in MSDN.

Prerequisiti

Prima di poter scrivere il codice di gestione della rete CDN, è necessario eseguire alcune operazioni preliminari per consentire al codice di interagire con Azure Resource Manager. A tale scopo è necessario:

  • Creare un gruppo di risorse per includere il profilo di rete CDN che verrà creato in questa esercitazione.
  • Configurare Azure Active Directory per fornire l'autenticazione per l'applicazione.
  • Applicare le autorizzazioni al gruppo di risorse in modo che solo gli utenti autorizzati dal tenant di Azure AD possano interagire con il profilo di rete CDN

Creazione del gruppo di risorse

  1. Accedere al portale di Azure.
  2. Fare clic sul pulsante Nuovo in alto a sinistra e poi su Gestione e Gruppo di risorse.

    Creazione di un nuovo gruppo di risorse

  3. Assegnare al gruppo di risorse il nome CdnConsoleTutorial. Selezionare la sottoscrizione e scegliere un percorso locale. Se si desidera, è possibile selezionare la casella di controllo Aggiungi al dashboard per aggiungere il gruppo di risorse al dashboard del portale. In questo modo sarà più semplice trovarlo in un secondo momento. Dopo avere eseguito le selezioni, fare clic su Crea.

    Assegnazione di un nome al gruppo di risorse

  4. Se dopo la creazione il gruppo di risorse non viene aggiunto al dashboard, è possibile trovarlo facendo clic su Esplora e quindi su Gruppi di risorse. Fare clic sul gruppo di risorse per aprirlo. Annotare l' ID sottoscrizione. Sarà necessario più avanti.

    Assegnazione di un nome al gruppo di risorse

Creazione dell'applicazione Azure AD e applicazione delle autorizzazioni

Per l'autenticazione delle app con Azure Active Directory sono possibili due approcci: singoli utenti o un'entità servizio. Un'entità servizio è simile a un account di servizio di Windows. Anziché concedere a un determinato utente le autorizzazioni per interagire con i profili di rete CDN, si concedono le autorizzazioni per l'entità servizio. Le entità servizio in genere vengono usate per i processi automatizzati e non interattivi. Sebbene in questa esercitazione si scriva un'applicazione console interattiva, ci si concentrerà sull'approccio dell'entità servizio.

La creazione di un'entità servizio è costituita da diversi passaggi, compresa la creazione di un'applicazione Azure Active Directory. A tale scopo si eseguirà questa esercitazione.

Importante

Assicurarsi di completare tutti i passaggi dell' esercitazione collegata. È estremamente importante eseguirla esattamente come descritto. Assicurarsi di annotare l'ID tenant, il nome di dominio tenant (in genere un dominio .onmicrosoft.com, se non è stato specificato un dominio personalizzato), l'ID client e la chiave di autenticazione client, che serviranno più avanti. Proteggere con attenzione l'ID client e la chiave di autenticazione client, in quanto queste credenziali possono essere usate da chiunque per eseguire operazioni come entità servizio.

Quando si arriva al passaggio denominato Configurare l'applicazione multi-tenant, selezionare No.

Quando si arriva al passaggio Assign application to role (Assegnare l'applicazione al ruolo), usare il gruppo di risorse creato in precedenza, CdnConsoleTutorial, ma anziché il ruolo di Lettore, assegnare il ruolo di CDN Profile Contributor. Dopo aver assegnato all'applicazione il ruolo di collaboratore profilo di rete CDN nel gruppo di risorse, tornare a questa esercitazione.

Dopo aver creato l'entità servizio e assegnato il ruolo CDN Profile Contributoril pannello Utenti per il gruppo di risorse dovrebbe avere un aspetto simile a questo.

Pannello Utenti

Autenticazione utente interattiva

Se, invece di un'entità servizio, si preferisce l'autenticazione interattiva del singolo utente, il processo è molto simile a quello per un'entità servizio. Infatti, è necessario seguire la stessa procedura, a parte alcune piccole modifiche.

Importante

Seguire questa procedura solo se si sceglie di utilizzare l'autenticazione interattiva del singolo utente anziché un'entità servizio.

  1. Quando si crea l'applicazione, invece di Applicazione Web scegliere Applicazione nativa.

    Applicazione nativa

  2. Nella pagina successiva verrà richiesto di immettere un URI di reindirizzamento. L'URI non verrà convalidato, ma è necessario ricordare i valori immessi. Sarà necessario più avanti.
  3. Non è necessario creare una chiave di autenticazione client.
  4. Invece di assegnare un'entità servizio al ruolo di collaboratore profilo di rete CDN , verranno assegnati singoli utenti o gruppi. In questo esempio si può notare che è stato assegnato l'utente CDN Demo User al ruolo CDN Profile Contributor.

    Accesso del singolo utente

Creare il progetto e aggiungere le dipendenze NPM

Ora che abbiamo creato un gruppo di risorse per i profili di rete CDN e assegnato all'applicazione Azure AD l'autorizzazione per gestire i profili e gli endpoint della rete CDN all'interno del gruppo, è possibile iniziare a creare l'applicazione.

Creare una cartella in cui archiviare l'applicazione. Da una console con gli strumenti Node.js nel percorso corrente, posizionarsi sulla nuova cartella e inizializzare il progetto eseguendo:

npm init

Verrà quindi visualizzata una serie di domande per inizializzare il progetto. Come punto di ingressoquesta esercitazione usa app.js. È possibile visualizzare le altre scelte nell'esempio seguente.

Output NPM iniziale

A questo punto il progetto viene inizializzato con un file packages.json . Il progetto userà alcune librerie di Azure contenute in pacchetti NPM. Verranno usati il runtime del client di Azure per Node.js (ms-rest-azure) e la libreria client della rete CDN di Azure per Node.js (azure-arm-cd). Aggiungere tali elementi al progetto come dipendenze.

npm install --save ms-rest-azure
npm install --save azure-arm-cdn

Al termine dell'installazione dei pacchetti, il file package.json dovrebbe avere un aspetto simile a questo esempio, anche se i numeri di versione possono variare:

{
  "name": "cdn_node",
  "version": "1.0.0",
  "description": "Azure CDN Node.js tutorial project",
  "main": "app.js",
  "scripts": {
    "test": "echo \"Error: no test specified\" && exit 1"
  },
  "author": "Cam Soper",
  "license": "MIT",
  "dependencies": {
    "azure-arm-cdn": "^0.2.1",
    "ms-rest-azure": "^1.14.4"
  }
}

Infine, usare l'editor di testo per creare un file di testo vuoto e salvarlo nella radice della cartella di progetto denominandolo app.js. Ora è possibile iniziare a scrivere codice.

Istruzioni require, costanti, autenticazione e struttura

Aprire app.js nell'editor e scrivere la struttura di base del programma.

  1. Aggiungere le istruzioni "require" per i pacchetti NPM all'inizio inserendo il codice seguente:

    var msRestAzure = require('ms-rest-azure');
    var cdnManagementClient = require('azure-arm-cdn');
    
  2. È necessario definire alcune costanti che i metodi useranno. Aggiungere il codice seguente. Sostituire i segnaposto, incluse le <parentesi acute>, con i valori necessari.

    //Tenant app constants
    const clientId = "<YOUR CLIENT ID>";
    const clientSecret = "<YOUR CLIENT AUTHENTICATION KEY>"; //Only for service principals
    const tenantId = "<YOUR TENANT ID>";
    
    //Application constants
    const subscriptionId = "<YOUR SUBSCRIPTION ID>";
    const resourceGroupName = "CdnConsoleTutorial";
    const resourceLocation = "<YOUR PREFERRED AZURE LOCATION, SUCH AS Central US>";
    
  3. Successivamente, verrà creata un'istanza del client di gestione della rete CDN a cui verranno assegnate le credenziali.

    var credentials = new msRestAzure.ApplicationTokenCredentials(clientId, tenantId, clientSecret);
    var cdnClient = new cdnManagementClient(credentials, subscriptionId);
    

    Se si usa l'autenticazione del singolo utente, queste due righe di codice avranno un aspetto leggermente diverso.

    Importante

    Usare questo esempio di codice solo se si sceglie l'autenticazione interattiva del singolo utente anziché un'entità servizio. Custodire attentamente le credenziali utente individuali e tenerle segrete.

    var credentials = new msRestAzure.UserTokenCredentials(clientId, 
        tenantId, '<username>', '<password>', '<redirect URI>');
    var cdnClient = new cdnManagementClient(credentials, subscriptionId);
    

    Sostituire le voci tra <parentesi acute> con le informazioni corrette. Sostituire <redirect URI>con l'URI di reindirizzamento immesso al momento della registrazione dell'applicazione in Azure AD.

  4. L'applicazione console Node.js necessita di alcuni parametri della riga di comando. Verificare che venga passato almeno un parametro.

    //Collect command-line parameters
    var parms = process.argv.slice(2);
    
    //Do we have parameters?
    if(parms == null || parms.length == 0)
    {
        console.log("Not enough parameters!");
        console.log("Valid commands are list, delete, create, and purge.");
        process.exit(1);
    }
    
  5. Nella parte principale del programma si passa poi ad altre funzioni, in base ai parametri che sono stati passati.

    switch(parms[0].toLowerCase())
    {
        case "list":
            cdnList();
            break;
    
        case "create":
            cdnCreate();
            break;
    
        case "delete":
            cdnDelete();
            break;
    
        case "purge":
            cdnPurge();
            break;
    
        default:
            console.log("Valid commands are list, delete, create, and purge.");
            process.exit(1);
    }
    
  6. In diversi punti del programma sarà necessario assicurarsi che venga passato il numero appropriato di parametri e visualizzare gli argomenti della Guida in caso di inesattezze. Creare le funzioni necessarie a tale scopo.

    function requireParms(parmCount) {
        if(parms.length < parmCount) {
            usageHelp(parms[0].toLowerCase());
            process.exit(1);
        }
    }
    
    function usageHelp(cmd) {
        console.log("Usage for " + cmd + ":");
        switch(cmd)
        {
            case "list":
                console.log("list profiles");
                console.log("list endpoints <profile name>");
                break;
    
            case "create":
                console.log("create profile <profile name>");
                console.log("create endpoint <profile name> <endpoint name> <origin hostname>");
                break;
    
            case "delete":
                console.log("delete profile <profile name>");
                console.log("delete endpoint <profile name> <endpoint name>");
                break;
    
            case "purge":
                console.log("purge <profile name> <endpoint name> <path>");
                break;
    
            default:
                console.log("Invalid command.");
        }
    }
    
  7. Le funzioni da usare nel client di gestione della rete CDN sono asincrone. È quindi necessario un metodo di richiamata dopo l'esecuzione delle funzioni. Creare un metodo che possa visualizzare l'output del client di gestione dell'eventuale rete CDN e uscire dal programma normalmente.

    function callback(err, result, request, response) {
        if (err) {
            console.log(err);
            process.exit(1);
        } else {
            console.log((result == null) ? "Done!" : result);
            process.exit(0);
        }
    }
    

Ora che la struttura di base del programma è stata scritta, è necessario creare le funzioni che vengono chiamate in base ai parametri.

Elencare i profili e gli endpoint della rete CDN

Scrivere il codice necessario per elencare i profili e gli endpoint esistenti. I commenti al codice forniscono la sintassi prevista che permette di determinare la posizione dei parametri.

// list profiles
// list endpoints <profile name>
function cdnList(){
    requireParms(2);
    switch(parms[1].toLowerCase())
    {
        case "profiles":
            console.log("Listing profiles...");
            cdnClient.profiles.listByResourceGroup(resourceGroupName, callback);
            break;

        case "endpoints":
            requireParms(3);
            console.log("Listing endpoints...");
            cdnClient.endpoints.listByProfile(parms[2], resourceGroupName, callback);
            break;

        default:
            console.log("Invalid parameter.");
            process.exit(1);
    }
}

Creare profili ed endpoint della rete CDN

Scrivere le funzioni per la creazione dei profili e degli endpoint.

function cdnCreate() {
    requireParms(2);
    switch(parms[1].toLowerCase())
    {
        case "profile":
            cdnCreateProfile();
            break;

        case "endpoint":
            cdnCreateEndpoint();
            break;

        default:
            console.log("Invalid parameter.");
            process.exit(1);
    }
}

// create profile <profile name>
function cdnCreateProfile() {
    requireParms(3);
    console.log("Creating profile...");
    var standardCreateParameters = {
        location: resourceLocation,
        sku: {
            name: 'Standard_Verizon'
        }
    };

    cdnClient.profiles.create(parms[2], standardCreateParameters, resourceGroupName, callback);
}

// create endpoint <profile name> <endpoint name> <origin hostname>        
function cdnCreateEndpoint() {
    requireParms(5);
    console.log("Creating endpoint...");
    var endpointProperties = {
        location: resourceLocation,
        origins: [{
            name: parms[4],
            hostName: parms[4]
        }]
    };

    cdnClient.endpoints.create(parms[3], endpointProperties, parms[2], resourceGroupName, callback);
}

Ripulire un endpoint

Supponendo che l'endpoint sia stato creato, è consigliabile eseguire nel programma un'attività comune di eliminazione del contenuto dell'endpoint.

// purge <profile name> <endpoint name> <path>
function cdnPurge() {
    requireParms(4);
    console.log("Purging endpoint...");
    var purgeContentPaths = [ parms[3] ];
    cdnClient.endpoints.purgeContent(parms[2], parms[1], resourceGroupName, purgeContentPaths, callback);
}

Eliminare profili ed endpoint della rete CDN

L'ultima funzione da includere elimina gli endpoint e i profili.

function cdnDelete() {
    requireParms(2);
    switch(parms[1].toLowerCase())
    {
        // delete profile <profile name>
        case "profile":
            requireParms(3);
            console.log("Deleting profile...");
            cdnClient.profiles.deleteIfExists(parms[2], resourceGroupName, callback);
            break;

        // delete endpoint <profile name> <endpoint name>
        case "endpoint":
            requireParms(4);
            console.log("Deleting endpoint...");
            cdnClient.endpoints.deleteIfExists(parms[3], parms[2], resourceGroupName, callback);
            break;

        default:
            console.log("Invalid parameter.");
            process.exit(1);
    }
}

Esecuzione del programma

Ora è possibile eseguire il programma Node.js con un debugger a scelta o alla console.

Suggerimento

Se si usa Visual Studio Code come debugger, è necessario configurare l'ambiente per passare i parametri della riga di comando. Visual Studio Code esegue questa operazione nel file launch.json . Cercare una proprietà denominata args e aggiungere una matrice di valori stringa per i parametri, in modo che abbia un aspetto analogo al seguente: "args": ["list", "profiles"].

Iniziare a elencare i profili.

Elencare i profili

Viene restituita una matrice vuota. Si tratta di un risultato previsto, dato che non c'è alcun profilo nel gruppo di risorse. Creare un profilo.

Creare il profilo

Aggiungere un endpoint.

Creare un endpoint

Infine, eliminare il profilo.

Eliminare il profilo

Passaggi successivi

Per vedere il progetto completato di questa procedura dettagliata, scaricare l'esempio.

Per informazioni su Azure CDN SDK per Node.js, vedere il riferimento.

Per altra documentazione su Azure SDK per Node.js, vedere il riferimento completo.

Gestire le risorse della rete CDN con PowerShell.