Introdução à programação do CDN do Azure

Pode utilizar o SDK Azure CDN para o JavaScript para automatizar a criação e gestão de perfis e pontos finais da CDN. Este tutorial percorre a criação de uma aplicação simples Node.js consola que demonstra várias das operações disponíveis. Este tutorial não se destina a descrever todos os aspetos do Azure CDN SDK para JavaScript em detalhe.

Para completar este tutorial, já deve ter Node.js 6.x.x ou superior instalado e configurado. Pode utilizar qualquer editor de texto que pretenda criar a sua aplicação Node.js. Para escrever este tutorial, usei o Código do Estúdio Visual.

Pré-requisitos

Antes de escrever o código de gestão cdn, deve fazer alguma preparação para permitir que o código interaja com o Gestor de Recursos Azure. Para fazer esta preparação, você precisa:

  • Crie um grupo de recursos para conter o perfil CDN criado neste tutorial
  • Configure Azure Ative Directy para fornecer autenticação para a aplicação
  • Aplique permissões ao grupo de recursos para que apenas os utilizadores autorizados do seu inquilino AZURE AD possam interagir com o perfil cdN

Criar o grupo de recursos

  1. Inscreva-se no Portal Azure.

  2. Clique em Criar um recurso.

  3. Procure por grupo de recursos e no painel de grupo de recursos, clique em Criar.

    Criação de um novo grupo de recursos

  4. Nomeie o seu grupo de recursos CdnConsoleTutorial. Selecione a sua subscrição e escolha um local perto de si. Se desejar, pode clicar no Pin para a caixa de verificação do painel de instrumentos para fixar o grupo de recursos no painel de instrumentos do portal. Pinning torna mais fácil de encontrar mais tarde. Depois de ter feito as suas seleções, clique em Criar.

    Screenshot da caixa de diálogo do grupo de recursos.

  5. Após a criação do grupo de recursos, se não o fixar no painel de instrumentos, poderá encontrá-lo clicando em Procurar, em seguida, Grupos de Recursos. Para abri-la, clique no grupo de recursos. Tome nota do seu ID de assinatura. Precisamos mais tarde.

    Screenshot da secção tutorial da consola C D N.

Criar a aplicação AZure AD e aplicar permissões

Existem duas abordagens para a autenticação de aplicações com o Azure Ative Directory: Utilizadores individuais ou um diretor de serviço. Um diretor de serviço é semelhante a uma conta de serviço no Windows. Em vez de conceder a um determinado utilizador permissões para interagir com os perfis da CDN, as permissões são concedidas ao principal do serviço. Os princípios de serviço são normalmente utilizados para processos automatizados e não interativos. Mesmo que este tutorial esteja a escrever uma aplicação de consola interativa, vamos focar-nos na abordagem principal do serviço.

A criação de um principal serviço consiste em várias etapas, incluindo a criação de uma aplicação Azure Ative Directory. Para criá-lo, vamos seguir este tutorial.

Importante

Certifique-se de seguir todos os passos no tutorial ligado. É importante que o complete exatamente como descrito. Certifique-se de que nota o seu ID do inquilino, nome de domínio do inquilino (geralmente um domínio .onmicrosoft.com a menos que tenha especificado um domínio personalizado), ID do cliente, e chave de autenticação do cliente, pois precisamos desta informação mais tarde. Tenha cuidado para guardar a identificação do seu cliente e a chave de autenticação do cliente, uma vez que estas credenciais podem ser utilizadas por qualquer pessoa para executar operações como diretor de serviço.

Quando chegar ao degrau denominado Configure multi-inusitário, selecione .

Quando chegar ao passo Atribua a aplicação a uma função,utilize o grupo de recursos criado anteriormente, CdnConsoleTutorial, mas em vez da função Reader, atribua o papel de Contribuidor de Perfil CDN. Depois de atribuir a aplicação, a função de Contribuinte de Perfil CDN no seu grupo de recursos, volte a este tutorial.

Uma vez criado o seu principal de serviço e atribuído a função de Contribuinte de Perfil CDN, a lâmina dos Utilizadores para o seu grupo de recursos deve ser semelhante à seguinte imagem.

Lâmina de utilizadores

Autenticação interativa do utilizador

Se, em vez de um principal de serviço, preferir a autenticação individual do utilizador interativo, o processo é semelhante ao de um diretor de serviço. Na verdade, tens de seguir o mesmo procedimento, mas fazer algumas pequenas alterações.

Importante

Siga apenas estes próximos passos se optar por utilizar a autenticação individual do utilizador em vez de um principal de serviço.

  1. Ao criar a sua aplicação, em vez de Aplicação Web, escolha a aplicação Native.

    Aplicação nativa

  2. Na página seguinte, é solicitado um URI de redirecionamento. O URI não será validado, mas lembre-se do que entrou. Precisa mais tarde.

  3. Não há necessidade de criar uma chave de autenticação do cliente.

  4. Em vez de atribuir um principal de serviço à função de Contribuinte de Perfil CDN, vamos atribuir utilizadores ou grupos individuais. Neste exemplo, pode ver que atribuí o Utilizador cdn de demonstração para o papel de Contribuinte de Perfil CDN.

    Acesso individual do utilizador

Crie o seu projeto e adicione dependências de NPM

Agora que criámos um grupo de recursos para os nossos perfis CDN e demos a nossa permissão à nossa aplicação AZure AD para gerir perfis e pontos finais da CDN dentro desse grupo, podemos começar a criar a nossa aplicação.

Crie uma pasta para armazenar a sua aplicação. A partir de uma consola com as ferramentas Node.js no seu caminho atual, desacorda a sua localização atual para esta nova pasta e inicialize o seu projeto executando:

npm init

Em seguida, ser-lhe-á apresentada uma série de perguntas para rubricar o seu projeto. Para o ponto de entrada, este tutorial utiliza app.js. Podem ver as minhas outras escolhas no exemplo seguinte.

Saída init NPM

O nosso projeto está agora rubricado com uma packages.jsarquivada. O nosso projeto vai usar algumas bibliotecas Azure contidas em pacotes NPM. Utilizaremos a biblioteca para autenticação do Azure Ative Directory em Node.js ( @azure/ms-rest-nodeauth ) e a Biblioteca de Clientes Azure CDN para JavaScript ( @azure/arm-cdn ). Vamos adicioná-los ao projeto como dependências.

npm install --save @azure/ms-rest-nodeauth
npm install --save @azure/arm-cdn

Depois de as embalagens serem feitas para instalar, o package.jsno ficheiro deve parecer semelhante a este exemplo (os números das versões podem diferir):

{
  "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": "^5.2.0",
    "@azure/ms-rest-nodeauth": "^3.0.0"
  }
}

Finalmente, utilizando o seu editor de texto, crie um ficheiro de texto em branco e guarde-o na raiz da nossa pasta de projeto à medida queapp.js. Estamos prontos para começar a escrever código.

Requer, constantes, autenticação e estrutura

Com app.js aberto no nosso editor, vamos escrever a estrutura básica do nosso programa.

  1. Adicione os "requer" para os nossos pacotes NPM no topo com o seguinte:

    var msRestAzure = require('@azure/ms-rest-nodeauth');
    const { CdnManagementClient } = require('@azure/arm-cdn');
    
  2. Precisamos definir algumas constantes que os nossos métodos usarão. Adicione o seguinte. Certifique-se de que substitui os espaços reservados, incluindo os < suportes angulares, > com os seus próprios valores, se necessário.

    //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. Em seguida, vamos instantaneaizar o cliente de gestão da CDN e dar-lhe as nossas credenciais.

    var credentials = new msRestAzure.ApplicationTokenCredentials(clientId, tenantId, clientSecret);
    var cdnClient = new CdnManagementClient(credentials, subscriptionId);
    
  4. A nossa aplicação de consola Node.js vai levar alguns parâmetros de linha de comando. Vamos validar que pelo menos um parâmetro foi passado.

    //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. Isso leva-nos à parte principal do nosso programa, onde nos ramificamos para outras funções com base nos parâmetros que foram passados.

    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. Em vários lugares do nosso programa, precisamos de ter certeza de que o número certo de parâmetros foram passados e mostrar alguma ajuda se eles não parecerem corretos. Vamos criar funções para fazer isso.

    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. Finalmente, as funções que vamos usar no cliente de gestão da CDN são assíncronos, por isso precisam de um método para ligar de volta quando terminarem. Vamos fazer um que possa exibir a saída do cliente de gestão CDN (se houver) e sair do programa graciosamente.

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

Agora que a estrutura básica do nosso programa está escrita, devemos criar as funções chamadas com base nos nossos parâmetros.

Listar perfis e pontos finais da CDN

Vamos começar com o código para listar os nossos perfis e pontos finais existentes. Os meus comentários de código fornecem a sintaxe esperada para sabermos para onde vai cada parâmetro.

// 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(resourceGroupName, parms[2], callback);
            break;

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

Criar perfis e pontos finais de CDN

Em seguida, escreveremos as funções para criar perfis e pontos finais.

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( resourceGroupName, parms[2], standardCreateParameters, 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(resourceGroupName, parms[2], parms[3], endpointProperties, callback);
}

Purgue um ponto final

Assumindo que o ponto final foi criado, uma tarefa comum que podemos querer realizar no nosso programa é purgar conteúdo no nosso ponto final.

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

Eliminar perfis e pontos finais da CDN

A última função que iremos incluir elimina pontos finais e perfis.

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

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

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

Executar o programa

Agora podemos executar o nosso programa de Node.js usando o nosso depuração favorito ou na consola.

Dica

Se estiver a usar o Código do Estúdio Visual como seu depurado, terá de configurar o seu ambiente para passar nos parâmetros da linha de comando. O Código do Estúdio Visual faz isto no launch.jsem ficheiro. Procure uma propriedade chamada Args e adicione uma variedade de valores de corda para os seus parâmetros, de modo que se pareça com este: "args": ["list", "profiles"] .

Vamos começar por listar os nossos perfis.

Perfis de lista

Temos de volta uma matriz vazia. Como não temos perfis no nosso grupo de recursos, isso é esperado. Vamos criar um perfil agora.

Criar perfil

Agora, vamos adicionar um ponto final.

Criar ponto final

Finalmente, vamos apagar o nosso perfil.

Eliminar perfil

Passos Seguintes

Para ver a referência para o Azure CDN SDK para JavaScript, consulte a referência.

Para encontrar documentação adicional sobre o Azure SDK para JavaScript, consulte a referência completa.

Gerencie os seus recursos CDN com o PowerShell.