Introducción al desarrollo de Azure CDNGet started with Azure CDN development

Puede usar el SDK de Azure CDN para Node.js para automatizar la creación y la administración de puntos de conexión y perfiles de red CDN.You can use the Azure CDN SDK for Node.js to automate creation and management of CDN profiles and endpoints. Este tutorial explica paso a paso la creación de una aplicación de consola Node.js sencilla que muestra algunas de las operaciones disponibles.This tutorial walks through the creation of a simple Node.js console application that demonstrates several of the available operations. No se pretende describir todos los aspectos del SDK de Azure CDN para Node.js en detalle.This tutorial is not intended to describe all aspects of the Azure CDN SDK for Node.js in detail.

Para completar este tutorial, debe tener ya instalado y configurado Node.js 4.x.x o superior.To complete this tutorial, you should already have Node.js 4.x.x or higher installed and configured. Puede usar cualquier editor de texto que desee para crear la aplicación de Node.js.You can use any text editor you want to create your Node.js application. Para escribir este tutorial, se ha usado Visual Studio Code.To write this tutorial, I used Visual Studio Code.

Sugerencia

El proyecto completado en este tutorial está disponible para descargarse en MSDN.The completed project from this tutorial is available for download on MSDN.

Requisitos previosPrerequisites

Antes de escribir el código de administración de la red CDN, tiene que realizar algunos preparativos para habilitar el código para que interactúe con Azure Resource Manager.Before writing CDN management code, you must do some preparation to enable the code to interact with the Azure Resource Manager. Para hacer esta preparación, deberá:To do this preparation, you need to:

  • Crear un grupo de recursos que contenga el perfil de CDN creado en este tutorial.Create a resource group to contain the CDN profile created in this tutorial
  • Configurar Azure Active Directory para que proporcione autenticación para la aplicación.Configure Azure Active Directory to provide authentication for the application
  • Aplicar permisos al grupo de recursos para que solo los usuarios autorizados del inquilino de Azure AD puedan interactuar con el perfil de CDN.Apply permissions to the resource group so that only authorized users from your Azure AD tenant can interact with the CDN profile

Creación del grupo de recursosCreating the resource group

  1. Inicie sesión en Azure Portal.Sign in to the Azure Portal.

  2. Haga clic en Crear un recurso.Click Create a resource.

  3. Busque Grupo de recursos y, en el panel Grupo de recursos, haga clic en Crear.Search for Resource group and in the Resource group pane, click Create.

    Crear un grupo de recursos

  4. Llame al grupo de recursos CdnConsoleTutorial.Name your resource group CdnConsoleTutorial. Seleccione la suscripción y elija una ubicación cercana.Select your subscription and choose a location near you. Si lo desea, puede hacer clic en la casilla Anclar al panel para anclar el grupo de recursos al panel en el portal.If you wish, you can click the Pin to dashboard checkbox to pin the resource group to the dashboard in the portal. El anclaje hará que sea más fácil encontrarlo luego.Pinning makes it easier to find later. Cuando termine las selecciones, haga clic en Crear.After you've made your selections, click Create.

    Asignar un nombre al grupo de recursos

  5. Una vez creado el grupo de recursos, si no lo ancló al panel, para buscarlo, haga clic en Examinar y en Grupos de recursos.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. Para abrirlo, haga clic en el grupo de recursos.To open it, click the resource group. Tome nota del valor en Id. de suscripción.Make a note of your Subscription ID. Lo necesitará más adelante.We need it later.

    Asignar un nombre al grupo de recursos

Creación de la aplicación de Azure AD y aplicación de los permisosCreating the Azure AD application and applying permissions

Existen dos enfoques para la autenticación de la aplicación con Azure Active Directory: usuarios individuales o una entidad de servicio.There are two approaches to app authentication with Azure Active Directory: Individual users or a service principal. Una entidad de servicio se parece a una cuenta de servicio en Windows.A service principal is similar to a service account in Windows. En lugar de conceder permisos a usuarios concretos para que interactúen con los perfiles de CDN, los permisos se conceden a la entidad de servicio.Instead of granting a particular user permissions to interact with the CDN profiles, permissions are instead granted to the service principal. Las entidades de servicio se suelen utilizar para procesos automatizados no interactivos.Service principals are typically used for automated, non-interactive processes. Aunque en este tutorial escribimos una aplicación de consola interactiva, nos centraremos en el enfoque de entidad de servicio.Even though this tutorial is writing an interactive console app, we'll focus on the service principal approach.

Para crear una entidad de servicio, se siguen varios pasos, incluida la creación de una aplicación de Azure Active Directory.Creating a service principal consists of several steps, including creating an Azure Active Directory application. Para crearlo, complete este tutorial.To create it, we're going to follow this tutorial.

Importante

Asegúrese de seguir los pasos descritos en el tutorial vinculado.Be sure to follow all the steps in the linked tutorial. Es importante que lo complete exactamente como se describe.It is important that you complete it exactly as described. No se olvide de tomar nota del identificador de inquilino, el nombre de dominio del inquilino (por lo general, un dominio .onmicrosoft.com, a menos que haya especificado uno personalizado), el identificador de cliente y la clave de autenticación de cliente, ya que se necesitará esta información más adelante.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 need this information later. Tenga cuidado de proteger el identificador de cliente y la clave de autenticación de cliente, ya que cualquiera puede usar estas credenciales para ejecutar operaciones como entidad de servicio.Be 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.

Cuando llegue al paso denominado Configuración de aplicación multiinquilino, seleccione No.When you get to the step named Configure multi-tenant application, select No.

Cuando llegue al paso Asignación de aplicación a un rol, use el grupo de recursos que creó antes (CdnConsoleTutorial), pero en lugar del rol Lector, asigne el rol Colaborador de perfil de CDN.When you get to the step Assign the application to a role, use the resource group created earlier, CdnConsoleTutorial, but instead of the Reader role, assign the CDN Profile Contributor role. Después de asignar la aplicación al rol CDN Profile Contributor (Colaborador de perfil de CDN) en el grupo de recursos, vuelva a este tutorial.After you assign the application the CDN Profile Contributor role on your resource group, return to this tutorial.

Una vez creada la entidad de servicio y asignado el rol CDN Profile Contributor (Colaborador de perfil de CDN), la hoja Usuarios del grupo de recursos debería parecerse a la imagen siguiente.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 the following image.

Hoja Usuarios

Autenticación interactiva de usuariosInteractive user authentication

Si, en lugar de una entidad de servicio, prefiere la autenticación interactiva de usuario individual, el proceso se parece al usado con una entidad de servicio.If, instead of a service principal, you'd rather have interactive individual user authentication, the process is similar to that for a service principal. De hecho, debe seguir el mismo procedimiento, con algunos cambios menores.In fact, you need to follow the same procedure, but make a few minor changes.

Importante

Siga estos pasos únicamente si opta por usar la autenticación de usuario individual en lugar de una entidad de servicio.Only follow these next steps if you are choosing to use individual user authentication instead of a service principal.

  1. Al crear la aplicación, en lugar de Aplicación web, elija Aplicación nativa.When creating your application, instead of Web Application, choose Native application.

    Aplicación nativa

  2. En la página siguiente, se le pedirá un URI de redirección.On the next page, you are prompted for a redirect URI. No se validará el URI, pero debe recordarlo.The URI won't be validated, but remember what you entered. Lo necesitará más adelante.You need it later.

  3. No hay necesidad de crear una clave de autenticación de cliente.There is no need to create a client authentication key.

  4. En lugar de asignar una entidad de servicio al rol CDN Profile Contributor (Colaborador de perfil de CDN), vamos a asignar usuarios individuales o grupos.Instead of assigning a service principal to the CDN Profile Contributor role, we're going to assign individual users or groups. En este ejemplo, puede ver que hemos asignado CDN Demo User (Usuario de demostración de CDN) al rol CDN Profile Contributor (Colaborador de perfil de CDN).In this example, you can see that I've assigned CDN Demo User to the CDN Profile Contributor role.

    Acceso de usuario individual

Creación del proyecto e incorporación de dependencias NPMCreate your project and add NPM dependencies

Ahora que hemos creado un grupo de recursos para los perfiles de CDN y concedido permiso a la aplicación de Azure AD para administrar perfiles y puntos de conexión de CDN dentro de ese grupo, podemos comenzar a crear la aplicación.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.

Cree una carpeta para almacenar la aplicación.Create a folder to store your application. Desde una consola con las herramientas de Node.js en su ruta de acceso actual, establezca su ubicación actual en esta nueva carpeta e inicialice el proyecto ejecutando: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

A continuación, se le ofrecerán una serie de preguntas para inicializar el proyecto.You will then be presented a series of questions to initialize your project. Para punto de entrada, este tutorial usa app.js.For entry point, this tutorial uses app.js. Puede ver las demás opciones en el ejemplo siguiente.You can see my other choices in the following example.

Salida de NPM init

El proyecto se inicializa ahora con un archivo packages.json .Our project is now initialized with a packages.json file. Va a usar algunas bibliotecas de Azure contenidas en paquetes NPM.Our project is going to use some Azure libraries contained in NPM packages. Vamos a usar el tiempo de ejecución de cliente de Azure para Node.js (ms-rest-azure) y la biblioteca de cliente de Azure CDN para 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). Vamos a agregar estos elementos al proyecto como dependencias.Let's add those to the project as dependencies.

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

Una vez que los paquetes se han instalado, el archivo package.json debe ser similar a este ejemplo (los números de versión pueden variar):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"
  }
}

Por último, con el editor de texto, cree un archivo de texto en blanco y guárdelo en la raíz de la carpeta del proyecto como 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. Ya está todo preparado para empezar a escribir código.We're now ready to begin writing code.

"Requieres", constantes, autenticación y estructuraRequires, constants, authentication, and structure

Con apps.js abierto en el editor, vamos a escribir la estructura básica del programa.With app.js open in our editor, let's get the basic structure of our program written.

  1. En la parte superior agregue los "requiere" para los paquetes NPM con lo siguiente: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. Necesitamos definir algunas constantes que los métodos van a usar.We need to define some constants our methods will use. Agregue lo siguiente.Add the following. Asegúrese de reemplazar los marcadores de posición (incluidos los <corchetes angulares> ) con sus propios valores según sea necesario.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. A continuación, crearemos una instancia del cliente de administración de la red CDN y le asignaremos nuestras credenciales.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);
    

    Si utiliza la autenticación de usuario individual, estas dos líneas tendrán un aspecto algo distinto.If you are using individual user authentication, these two lines will look slightly different.

    Importante

    Use este ejemplo de código únicamente si opta por la autenticación de usuario individual en lugar de una entidad de servicio.Only use this code sample if you are choosing to have individual user authentication instead of a service principal. Asegúrese de guardar las credenciales de usuario individual y de mantenerlas en secreto.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);
    

    No olvide reemplazar los elementos en <corchetes angulares> por la información correcta.Be sure to replace the items in <angle brackets> with the correct information. Para <redirect URI>, use el URI de redirección que especificó al registrar la aplicación en Azure AD.For <redirect URI>, use the redirect URI you entered when you registered the application in Azure AD.

  4. Nuestra aplicación de consola Node.js necesita algunos parámetros de línea de comandos.Our Node.js console application is going to take some command-line parameters. Vamos a dar por válido que por lo menos un parámetro se pasó.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. Con esto llegamos a la parte principal del programa, donde vamos a derivar a otras funciones basadas en los parámetros que se pasaron.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. En varios lugares del programa, es necesario asegurarse de que se ha pasado la cantidad correcta de parámetros, si parece que esto no es así, hay que mostrar ayudas.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. Vamos a crear funciones para hacerlo.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. Por último, las funciones que vamos a usar en el cliente de administración de la red CDN son asincrónicas, por lo que necesitan un método al que llamar cuando hayan terminado.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. Vamos a hacer uno que pueda mostrar el resultado desde el cliente de administración de la red CDN (si lo hubiera) y salir del programa sin contratiempos.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);
        }
    }
    

Ahora que ya hemos escrito la estructura básica del programa, deberíamos crear las funciones a las que se llama en base a los parámetros.Now that the basic structure of our program is written, we should create the functions called based on our parameters.

Lista de perfiles y puntos de conexión de CDNList CDN profiles and endpoints

Comencemos con código para enumera los perfiles y puntos de conexión existentes.Let's start with code to list our existing profiles and endpoints. Los comentarios de código proporcionan la sintaxis esperada para saber dónde va cada parámetro.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);
    }
}

Creación de perfiles y puntos de conexión de CDNCreate CDN profiles and endpoints

A continuación, escribiremos las funciones para crear perfiles y puntos de conexión.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);
}

Purga de un punto de conexiónPurge an endpoint

Suponiendo que se haya creado el punto de conexión, una tarea habitual que podríamos llevar a cabo en el programa es purgar el contenido del punto de conexión.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);
}

Eliminación de perfiles y puntos de conexión de CDNDelete CDN profiles and endpoints

La última función que incluiremos elimina puntos de conexión y perfiles.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);
    }
}

Ejecución del programaRunning the program

Ahora ya podemos ejecutar nuestro programa de Node.js usando nuestro depurador preferido o en la consola.We can now execute our Node.js program using our favorite debugger or at the console.

Sugerencia

Si usa código de Visual Studio como depurador, tiene que configurar su entorno para pasar los parámetros de línea de comandos.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 hace esto en el archivo launch.json.Visual Studio Code does this in the launch.json file. Busque una propiedad denominada args y agregue una matriz de valores de cadena para los parámetros, de forma que se parezca a esto: "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"].

Vamos a empezar con una lista de nuestros perfiles.Let's start by listing our profiles.

Listado de perfiles

Recuperamos una matriz vacía.We got back an empty array. Esto es normal ya que no tenemos ningún perfil en nuestro grupo de recursos.Since we don't have any profiles in our resource group, that's expected. Vamos a crear un perfil.Let's create a profile now.

Creación de perfil

Ahora, vamos a agregar un punto de conexión.Now, let's add an endpoint.

Crear punto de conexión

Por último, vamos a eliminar el perfil.Finally, let's delete our profile.

Eliminación de perfil

Pasos siguientesNext Steps

Para ver el proyecto de este tutorial terminado, descargue el ejemplo.To see the completed project from this walkthrough, download the sample.

Para ver la referencia del SDK de Azure CDN para Node.js, consulte el documento de referencia.To see the reference for the Azure CDN SDK for Node.js, view the reference.

Para encontrar más documentación sobre Azure SDK para Node.js, consulte el material de referencia completo.To find additional documentation on the Azure SDK for Node.js, view the full reference.

Administración de los recursos de red CDN con PowerShell.Manage your CDN resources with PowerShell.