Introduzione allo sviluppo della rete CDN di AzureGet started with Azure CDN development

È possibile usare Azure CDN SDK per Node.js per automatizzare la creazione e la gestione dei profili e degli endpoint di rete CDN.You can use the Azure CDN SDK for Node.js to automate creation and management of CDN profiles and endpoints. Questa esercitazione illustra nel dettaglio la creazione di una semplice applicazione console Node.js che dimostra varie operazioni tra quelle disponibili.This tutorial walks through the creation of a simple Node.js console application that demonstrates several of the available operations. Lo scopo di questa esercitazione non è fornire una descrizione dettagliata di tutti gli aspetti di Azure CDN SDK per Node.js.This tutorial is not intended to describe all aspects of the Azure CDN SDK for Node.js in detail.

Per completare questa esercitazione, è necessario che Node.js 4.x.x o versione successiva sia già installato e configurato.To complete this tutorial, you should already have Node.js 4.x.x or higher installed and configured. Per creare l'applicazione Node.js è possibile usare qualsiasi editor di testo.You can use any text editor you want to create your Node.js application. Per scrivere questa esercitazione è stato usato Visual Studio Code.To write this tutorial, I used Visual Studio Code.

Suggerimento

Il progetto completato di questa esercitazione è disponibile per il download in MSDN.The completed project from this tutorial is available for download on MSDN.

PrerequisitiPrerequisites

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.Before we can write CDN management code, we need to do some preparation to enable our code to interact with the Azure Resource Manager. A tale scopo è necessario:To do this, you'll need to:

  • Creare un gruppo di risorse per includere il profilo di rete CDN che verrà creato in questa esercitazione.Create a resource group to contain the CDN profile we create in this tutorial
  • Configurare Azure Active Directory per fornire l'autenticazione per l'applicazione.Configure Azure Active Directory to provide authentication for our application
  • 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 CDNApply permissions to the resource group so that only authorized users from our Azure AD tenant can interact with our CDN profile

Creazione del gruppo di risorseCreating the resource group

  1. Accedere al portale di Azure.Log into the Azure Portal.
  2. Fare clic sul pulsante Nuovo in alto a sinistra e poi su Gestione e Gruppo di risorse.Click the New button in the upper left, and then Management, and Resource Group.

    Creazione di un nuovo gruppo di risorse

  3. Assegnare al gruppo di risorse il nome CdnConsoleTutorial.Call your resource group CdnConsoleTutorial. Selezionare la sottoscrizione e scegliere un percorso locale.Select your subscription and choose a location near you. Se si desidera, è possibile selezionare la casella di controllo Aggiungi al dashboard per aggiungere il gruppo di risorse al dashboard del portale.If you wish, you may click the Pin to dashboard checkbox to pin the resource group to the dashboard in the portal. In questo modo sarà più semplice trovarlo in un secondo momento.This will make it easier to find later. Dopo avere eseguito le selezioni, fare clic su Crea.After you've made your selections, click Create.

    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.After the resource group is created, if you didn't pin it to your dashboard, you can find it by clicking Browse, then Resource Groups. Fare clic sul gruppo di risorse per aprirlo.Click the resource group to open it. Annotare l' ID sottoscrizione.Make a note of your Subscription ID. Sarà necessario più avanti.We'll need it later.

    Assegnazione di un nome al gruppo di risorse

Creazione dell'applicazione Azure AD e applicazione delle autorizzazioniCreating the Azure AD application and applying permissions

Per l'autenticazione delle app con Azure Active Directory sono possibili due approcci: singoli utenti o un'entità servizio.There are two approaches to app authentication with Azure Active Directory: Individual users or a service principal. Un'entità servizio è simile a un account di servizio di Windows.A service principal is similar to a service account in 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.Instead of granting a particular user permissions to interact with the CDN profiles, we instead grant the permissions to the service principal. Le entità servizio in genere vengono usate per i processi automatizzati e non interattivi.Service principals are generally used for automated, non-interactive processes. Sebbene in questa esercitazione si scriva un'applicazione console interattiva, ci si concentrerà sull'approccio dell'entità servizio.Even though this tutorial is writing an interactive console app, we'll focus on the service principal approach.

La creazione di un'entità servizio è costituita da diversi passaggi, compresa la creazione di un'applicazione Azure Active Directory.Creating a service principal consists of several steps, including creating an Azure Active Directory application. A tale scopo si eseguirà questa esercitazione.To do this, we're going to follow this tutorial.

Importante

Assicurarsi di completare tutti i passaggi dell' esercitazione collegata.Be sure to follow all the steps in the linked tutorial. È estremamente importante eseguirla esattamente come descritto.It is extremely important that you complete it exactly as described. 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.Make sure to note your tenant ID, tenant domain name (commonly a .onmicrosoft.com domain unless you've specified a custom domain), client ID, and client authentication key, as we will need these later. 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.Be very careful to guard your client ID and client authentication key, as these credentials can be used by anyone to execute operations as the service principal.

Quando si arriva al passaggio denominato Configurare l'applicazione multi-tenant, selezionare No.When you get to the step named Configure multi-tenant application, select 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.When you get to the step Assign application to role, use the resource group we created earlier, CdnConsoleTutorial, but instead of the Reader role, assign the CDN Profile Contributor role. Dopo aver assegnato all'applicazione il ruolo di collaboratore profilo di rete CDN nel gruppo di risorse, tornare a questa esercitazione.After you assign the application the CDN Profile Contributor role on your resource group, return to this tutorial.

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.Once you've created your service principal and assigned the CDN Profile Contributor role, the Users blade for your resource group should look similar to this.

Pannello Utenti

Autenticazione utente interattivaInteractive user authentication

Se, invece di un'entità servizio, si preferisce l'autenticazione interattiva del singolo utente, il processo è molto simile a quello per un'entità servizio.If, instead of a service principal, you'd rather have interactive individual user authentication, the process is very similar to that for a service principal. Infatti, è necessario seguire la stessa procedura, a parte alcune piccole modifiche.In fact, you will need to follow the same procedure, but make a few minor changes.

Importante

Seguire questa procedura solo se si sceglie di utilizzare l'autenticazione interattiva del singolo utente anziché un'entità servizio.Only follow these next steps if you are choosing to use individual user authentication instead of a service principal.

  1. Quando si crea l'applicazione, invece di Applicazione Web scegliere Applicazione nativa.When creating your application, instead of Web Application, choose Native application.

    Applicazione nativa

  2. Nella pagina successiva verrà richiesto di immettere un URI di reindirizzamento.On the next page, you will be prompted for a redirect URI. L'URI non verrà convalidato, ma è necessario ricordare i valori immessi.The URI won't be validated, but remember what you entered. Sarà necessario più avanti.You'll need it later.
  3. Non è necessario creare una chiave di autenticazione client.There is no need to create a client authentication key.
  4. Invece di assegnare un'entità servizio al ruolo di collaboratore profilo di rete CDN , verranno assegnati singoli utenti o gruppi.Instead of assigning a service principal to the CDN Profile Contributor role, we're going to assign individual users or groups. In questo esempio si può notare che è stato assegnato l'utente CDN Demo User al ruolo CDN Profile Contributor.In this example, you can see that I've assigned CDN Demo User to the CDN Profile Contributor role.

    Accesso del singolo utente

Creare il progetto e aggiungere le dipendenze NPMCreate your project and add NPM dependencies

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.Now that we've created a resource group for our CDN profiles and given our Azure AD application permission to manage CDN profiles and endpoints within that group, we can start creating our application.

Creare una cartella in cui archiviare l'applicazione.Create a folder to store your application. Da una console con gli strumenti Node.js nel percorso corrente, posizionarsi sulla nuova cartella e inizializzare il progetto eseguendo:From a console with the Node.js tools in your current path, set your current location to this new folder and initialize your project by executing:

npm init

Verrà quindi visualizzata una serie di domande per inizializzare il progetto.You will then be presented a series of questions to initialize your project. Come punto di ingressoquesta esercitazione usa app.js.For entry point, this tutorial uses app.js. È possibile visualizzare le altre scelte nell'esempio seguente.You can see my other choices in the following example.

Output NPM iniziale

A questo punto il progetto viene inizializzato con un file packages.json .Our project is now initialized with a packages.json file. Il progetto userà alcune librerie di Azure contenute in pacchetti NPM.Our project is going to use some Azure libraries contained in NPM packages. 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).We'll use the Azure Client Runtime for Node.js (ms-rest-azure) and the Azure CDN Client Library for Node.js (azure-arm-cd). Aggiungere tali elementi al progetto come dipendenze.Let's add those to the project as dependencies.

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:After the packages are done installing, the package.json file should look similar to this example (version numbers may differ):

{
  "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.Finally, using your text editor, create a blank text file and save it in the root of our project folder as app.js. Ora è possibile iniziare a scrivere codice.We're now ready to begin writing code.

Istruzioni require, costanti, autenticazione e strutturaRequires, constants, authentication, and structure

Aprire app.js nell'editor e scrivere la struttura di base del programma.With app.js open in our editor, let's get the basic structure of our program written.

  1. Aggiungere le istruzioni "require" per i pacchetti NPM all'inizio inserendo il codice seguente:Add the "requires" for our NPM packages at the top with the following:

    var msRestAzure = require('ms-rest-azure');
    var cdnManagementClient = require('azure-arm-cdn');
    
  2. È necessario definire alcune costanti che i metodi useranno.We need to define some constants our methods will use. Aggiungere il codice seguente.Add the following. Sostituire i segnaposto, incluse le <parentesi acute>, con i valori necessari.Be sure to replace the placeholders, including the <angle brackets>, with your own values as needed.

    //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.Next, we'll instantiate the CDN management client and give it our credentials.

    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.If you are using individual user authentication, these two lines will look slightly different.

    Importante

    Usare questo esempio di codice solo se si sceglie l'autenticazione interattiva del singolo utente anziché un'entità servizio.Only use this code sample if you are choosing to have individual user authentication instead of a service principal. Custodire attentamente le credenziali utente individuali e tenerle segrete.Be careful to guard your individual user credentials and keep them secret.

    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.Be sure to replace the items in <angle brackets> with the correct information. Sostituire <redirect URI>con l'URI di reindirizzamento immesso al momento della registrazione dell'applicazione in Azure AD.For <redirect URI>, use the redirect URI you entered when you registered the application in Azure AD.

  4. L'applicazione console Node.js necessita di alcuni parametri della riga di comando.Our Node.js console application is going to take some command-line parameters. Verificare che venga passato almeno un parametro.Let's validate that at least one parameter was passed.

    //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.That brings us to the main part of our program, where we branch off to other functions based on what parameters were passed.

    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.At several places in our program, we'll need to make sure the right number of parameters were passed in and display some help if they don't look correct. Creare le funzioni necessarie a tale scopo.Let's create functions to do that.

    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.Finally, the functions we'll be using on the CDN management client are asynchronous, so they need a method to call back when they're done. Creare un metodo che possa visualizzare l'output del client di gestione dell'eventuale rete CDN e uscire dal programma normalmente.Let's make one that can display the output from the CDN management client (if any) and exit the program gracefully.

    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.Now that the basic structure of our program is written, we should create the functions called based on our parameters.

Elencare i profili e gli endpoint della rete CDNList CDN profiles and endpoints

Scrivere il codice necessario per elencare i profili e gli endpoint esistenti.Let's start with code to list our existing profiles and endpoints. I commenti al codice forniscono la sintassi prevista che permette di determinare la posizione dei parametri.My code comments provide the expected syntax so we know where each parameter goes.

// 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 CDNCreate CDN profiles and endpoints

Scrivere le funzioni per la creazione dei profili e degli endpoint.Next, we'll write the functions to create profiles and endpoints.

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 endpointPurge an endpoint

Supponendo che l'endpoint sia stato creato, è consigliabile eseguire nel programma un'attività comune di eliminazione del contenuto dell'endpoint.Assuming the endpoint has been created, one common task that we might want to perform in our program is purging content in our 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 CDNDelete CDN profiles and endpoints

L'ultima funzione da includere elimina gli endpoint e i profili.The last function we will include deletes endpoints and profiles.

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 programmaRunning the program

Ora è possibile eseguire il programma Node.js con un debugger a scelta o alla console.We can now execute our Node.js program using our favorite debugger or at the console.

Suggerimento

Se si usa Visual Studio Code come debugger, è necessario configurare l'ambiente per passare i parametri della riga di comando.If you're using Visual Studio Code as your debugger, you'll need to set up your environment to pass in the command-line parameters. Visual Studio Code esegue questa operazione nel file launch.json .Visual Studio Code does this in the lanuch.json file. 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"].Look for a property named args and add an array of string values for your parameters, so that it looks similar to this: "args": ["list", "profiles"].

Iniziare a elencare i profili.Let's start by listing our profiles.

Elencare i profili

Viene restituita una matrice vuota.We got back an empty array. Si tratta di un risultato previsto, dato che non c'è alcun profilo nel gruppo di risorse.Since we don't have any profiles in our resource group, that's expected. Creare un profilo.Let's create a profile now.

Creare il profilo

Aggiungere un endpoint.Now, let's add an endpoint.

Creare un endpoint

Infine, eliminare il profilo.Finally, let's delete our profile.

Eliminare il profilo

Passaggi successiviNext Steps

Per vedere il progetto completato di questa procedura dettagliata, scaricare l'esempio.To see the completed project from this walkthrough, download the sample.

Per informazioni su Azure CDN SDK per Node.js, vedere il riferimento.To see the reference for the Azure CDN SDK for Node.js, view the reference.

Per altra documentazione su Azure SDK per Node.js, vedere il riferimento completo.To find additional documentation on the Azure SDK for Node.js, view the full reference.

Gestire le risorse della rete CDN con PowerShell.Manage your CDN resources with PowerShell.