Começa com a Biblioteca Azure CDN para .NET

Pode utilizar a Biblioteca Azure CDN para .NET 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 de consola .NET que demonstra várias das operações disponíveis. Este tutorial não se destina a descrever todos os aspetos da Biblioteca Azure CDN para .NET em detalhe.

Precisa do Visual Studio 2015 para completar este tutorial. Visual Studio Community 2015 está livremente disponível para download.

Dica

O projeto concluído deste tutorial está disponível para download na MSDN.

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 pacotes Nuget

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.

A partir do Visual Studio 2015, clique em File, New, Project... para abrir o novo diálogo do projeto. Expandir Visual C#, em seguida, selecione Windows in the pane à esquerda. Clique na Aplicação da Consola no painel central. Nomeie o seu projeto e, em seguida, clique em OK.

Novo Projeto

O nosso projeto vai usar algumas bibliotecas Azure contidas em pacotes Nuget. Vamos adicioná-los ao projeto.

  1. Clique no menu Ferramentas, Gestor de Pacotes Nuget e, em seguida, Consola de Gestor de Pacotes.

    Gerir pacotes Nuget

  2. Na Consola Gestor de Pacotes, execute o seguinte comando para instalar a Biblioteca de Autenticação de Diretório Ativo (ADAL):

    Install-Package Microsoft.IdentityModel.Clients.ActiveDirectory

  3. Execute o seguinte para instalar a Biblioteca de Gestão Azure CDN:

    Install-Package Microsoft.Azure.Management.Cdn

Diretivas, constantes, método principal e métodos de ajuda

Vamos escrever a estrutura básica do nosso programa.

  1. De volta ao separador program.cs, substitua as using diretivas no topo com as seguintes:

    using System;
    using System.Collections.Generic;
    using Microsoft.Azure.Management.Cdn;
    using Microsoft.Azure.Management.Cdn.Models;
    using Microsoft.Azure.Management.Resources;
    using Microsoft.Azure.Management.Resources.Models;
    using Microsoft.IdentityModel.Clients.ActiveDirectory;
    using Microsoft.Rest;
    
  2. Precisamos definir algumas constantes que os nossos métodos usarão. Na Program classe, mas antes do Main método, 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
    private const string clientID = "<YOUR CLIENT ID>";
    private const string clientSecret = "<YOUR CLIENT AUTHENTICATION KEY>"; //Only for service principals
    private const string authority = "https://login.microsoftonline.com/<YOUR TENANT ID>/<YOUR TENANT DOMAIN NAME>";
    
    //Application constants
    private const string subscriptionId = "<YOUR SUBSCRIPTION ID>";
    private const string profileName = "CdnConsoleApp";
    private const string endpointName = "<A UNIQUE NAME FOR YOUR CDN ENDPOINT>";
    private const string resourceGroupName = "CdnConsoleTutorial";
    private const string resourceLocation = "<YOUR PREFERRED AZURE LOCATION, SUCH AS Central US>";
    
  3. Também ao nível da classe, defina estas duas variáveis. Vamos usá-los mais tarde para determinar se o nosso perfil e o nosso ponto final já existem.

    static bool profileAlreadyExists = false;
    static bool endpointAlreadyExists = false;
    
  4. Substitua o Main método da seguinte forma:

    static void Main(string[] args)
    {
        //Get a token
        AuthenticationResult authResult = GetAccessToken();
    
        // Create CDN client
        CdnManagementClient cdn = new CdnManagementClient(new TokenCredentials(authResult.AccessToken))
            { SubscriptionId = subscriptionId };
    
        ListProfilesAndEndpoints(cdn);
    
        // Create CDN Profile
        CreateCdnProfile(cdn);
    
        // Create CDN Endpoint
        CreateCdnEndpoint(cdn);
    
        Console.WriteLine();
    
        // Purge CDN Endpoint
        PromptPurgeCdnEndpoint(cdn);
    
        // Delete CDN Endpoint
        PromptDeleteCdnEndpoint(cdn);
    
        // Delete CDN Profile
        PromptDeleteCdnProfile(cdn);
    
        Console.WriteLine("Press Enter to end program.");
        Console.ReadLine();
    }
    
  5. Alguns dos nossos outros métodos vão incitar o utilizador com perguntas "Sim/Não". Adicione o seguinte método para facilitar um pouco:

    private static bool PromptUser(string Question)
    {
        Console.Write(Question + " (Y/N): ");
        var response = Console.ReadKey();
        Console.WriteLine();
        if (response.Key == ConsoleKey.Y)
        {
            return true;
        }
        else if (response.Key == ConsoleKey.N)
        {
            return false;
        }
        else
        {
            // They pressed something other than Y or N.  Let's ask them again.
            return PromptUser(Question);
        }
    }
    

Agora que a estrutura básica do nosso programa está escrita, devemos criar os métodos chamados pelo Main método.

Autenticação

Antes de podermos utilizar a Biblioteca de Gestão Azure CDN, precisamos de autenticar o nosso principal de serviço e obter um sinal de autenticação. Este método usa a ADAL para recuperar o símbolo.

private static AuthenticationResult GetAccessToken()
{
    AuthenticationContext authContext = new AuthenticationContext(authority);
    ClientCredential credential = new ClientCredential(clientID, clientSecret);
    AuthenticationResult authResult =
        authContext.AcquireTokenAsync("https://management.core.windows.net/", credential).Result;

    return authResult;
}

Se estiver a utilizar a autenticação individual do utilizador, o GetAccessToken método será ligeiramente diferente.

Importante

Utilize apenas esta amostra de código se estiver a optar por ter a autenticação individual do utilizador em vez de um principal de serviço.

private static AuthenticationResult GetAccessToken()
{
    AuthenticationContext authContext = new AuthenticationContext(authority);
    AuthenticationResult authResult = authContext.AcquireTokenAsync("https://management.core.windows.net/",
        clientID, new Uri("http://<redirect URI>"), new PlatformParameters(PromptBehavior.RefreshSession)).Result;

    return authResult;
}

Não se esqueça de substituir <redirect URI> pelo URI de redirecionamento que inseriu quando registou a aplicação no Azure AD.

Listar perfis e pontos finais da CDN

Agora estamos prontos para fazer operações de CDN. A primeira coisa que o nosso método faz é listar todos os perfis e pontos finais do nosso grupo de recursos, e se encontrar uma correspondência para os nomes de perfil e ponto final especificados nas nossas constantes, faz uma nota disso para mais tarde para não tentarmos criar duplicados.

private static void ListProfilesAndEndpoints(CdnManagementClient cdn)
{
    // List all the CDN profiles in this resource group
    var profileList = cdn.Profiles.ListByResourceGroup(resourceGroupName);
    foreach (Profile p in profileList)
    {
        Console.WriteLine("CDN profile {0}", p.Name);
        if (p.Name.Equals(profileName, StringComparison.OrdinalIgnoreCase))
        {
            // Hey, that's the name of the CDN profile we want to create!
            profileAlreadyExists = true;
        }

        //List all the CDN endpoints on this CDN profile
        Console.WriteLine("Endpoints:");
        var endpointList = cdn.Endpoints.ListByProfile(p.Name, resourceGroupName);
        foreach (Endpoint e in endpointList)
        {
            Console.WriteLine("-{0} ({1})", e.Name, e.HostName);
            if (e.Name.Equals(endpointName, StringComparison.OrdinalIgnoreCase))
            {
                // The unique endpoint name already exists.
                endpointAlreadyExists = true;
            }
        }
        Console.WriteLine();
    }
}

Criar perfis e pontos finais de CDN

A seguir, vamos criar um perfil.

private static void CreateCdnProfile(CdnManagementClient cdn)
{
    if (profileAlreadyExists)
    {
        Console.WriteLine("Profile {0} already exists.", profileName);
    }
    else
    {
        Console.WriteLine("Creating profile {0}.", profileName);
        ProfileCreateParameters profileParms =
            new ProfileCreateParameters() { Location = resourceLocation, Sku = new Sku(SkuName.StandardVerizon) };
        cdn.Profiles.Create(profileName, profileParms, resourceGroupName);
    }
}

Assim que o perfil for criado, criaremos um ponto final.

private static void CreateCdnEndpoint(CdnManagementClient cdn)
{
    if (endpointAlreadyExists)
    {
        Console.WriteLine("Profile {0} already exists.", profileName);
    }
    else
    {
        Console.WriteLine("Creating endpoint {0} on profile {1}.", endpointName, profileName);
        EndpointCreateParameters endpointParms =
            new EndpointCreateParameters()
            {
                Origins = new List<DeepCreatedOrigin>() { new DeepCreatedOrigin("Contoso", "www.contoso.com") },
                IsHttpAllowed = true,
                IsHttpsAllowed = true,
                Location = resourceLocation
            };
        cdn.Endpoints.Create(endpointName, endpointParms, profileName, resourceGroupName);
    }
}

Nota

O exemplo acima atribui ao ponto final uma origem chamada Contoso com um nome de www.contoso.com anfitrião. Devias mudar isto para apontar para o nome de anfitrião da tua própria origem.

Purgue um ponto final

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

private static void PromptPurgeCdnEndpoint(CdnManagementClient cdn)
{
    if (PromptUser(String.Format("Purge CDN endpoint {0}?", endpointName)))
    {
        Console.WriteLine("Purging endpoint. Please wait...");
        cdn.Endpoints.PurgeContent(resourceGroupName, profileName, endpointName, new List<string>() { "/*" });
        Console.WriteLine("Done.");
        Console.WriteLine();
    }
}

Nota

No exemplo acima, a corda /* denota que quero purgar tudo na raiz do caminho do ponto final. Isto equivale a verificar o diálogo de purga all in the Azure portal "purgar". No CreateCdnProfile método, criei o nosso perfil como UM CDN Azure a partir do perfil de Verizon usando o código , para que isto seja bem Sku = new Sku(SkuName.StandardVerizon) sucedido. No entanto, a Azure CDN dos perfis da Akamai não suporta o Purpur All, por isso, se eu estivesse a usar um perfil da Akamai para este tutorial, teria de incluir caminhos específicos para a purga.

Eliminar perfis e pontos finais da CDN

Os últimos métodos eliminarão o nosso ponto final e perfil.

private static void PromptDeleteCdnEndpoint(CdnManagementClient cdn)
{
    if(PromptUser(String.Format("Delete CDN endpoint {0} on profile {1}?", endpointName, profileName)))
    {
        Console.WriteLine("Deleting endpoint. Please wait...");
        cdn.Endpoints.DeleteIfExists(endpointName, profileName, resourceGroupName);
        Console.WriteLine("Done.");
        Console.WriteLine();
    }
}

private static void PromptDeleteCdnProfile(CdnManagementClient cdn)
{
    if(PromptUser(String.Format("Delete CDN profile {0}?", profileName)))
    {
        Console.WriteLine("Deleting profile. Please wait...");
        cdn.Profiles.DeleteIfExists(profileName, resourceGroupName);
        Console.WriteLine("Done.");
        Console.WriteLine();
    }
}

Executar o programa

Agora podemos compilar e executar o programa clicando no botão Iniciar no Estúdio Visual.

Programa em execução

Quando o programa chegar ao pedido acima, deverá ser capaz de voltar ao seu grupo de recursos no portal Azure e ver se o perfil foi criado.

Êxito!

Podemos então confirmar as instruções para executar o resto do programa.

Conclusão do programa

Passos Seguintes

Para ver o projeto concluído a partir deste walkthrough, descarregue a amostra.

Para encontrar documentação adicional na Biblioteca de Gestão Azure CDN para .NET, consulte a referência na MSDN.

Gerencie os seus recursos CDN com o PowerShell.