Introdução à Biblioteca CDN do Azure para .NET

  • Artigo

Você pode usar a Biblioteca CDN do Azure para .NET para automatizar a criação e o gerenciamento de perfis e pontos de extremidade da CDN. Este tutorial descreve a criação de um aplicativo de console .NET simples que demonstra várias das operações disponíveis. Este tutorial não se destina a descrever todos os aspetos da Biblioteca CDN do Azure para .NET em detalhes.

Você precisa do Visual Studio 2015 para concluir este tutorial. O Visual Studio Community 2015 está disponível gratuitamente para download.

Gorjeta

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

Pré-requisitos

Antes de escrever o código de gerenciamento da CDN, você deve fazer alguma preparação para permitir que o código interaja com o Gerenciador de Recursos do Azure. Para fazer essa preparação, você precisa:

  • Criar um grupo de recursos para conter o perfil CDN criado neste tutorial
  • Configurar o Microsoft Entra ID para fornecer autenticação para o aplicativo
  • Aplique permissões ao grupo de recursos para que apenas usuários autorizados do locatário do Microsoft Entra possam interagir com o perfil CDN

Criar o grupo de recursos

  1. Inicie sessão no Portal do Azure.

  2. Clique em Criar um recurso.

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

    Criando um novo grupo de recursos

  4. Nomeie seu grupo de recursos como CdnConsoleTutorial. Selecione a sua subscrição e escolha uma localização perto de si. Se desejar, clique na caixa de seleção Fixar no painel para fixar o grupo de recursos no painel no portal. A fixação facilita a localização posterior. Depois de fazer suas seleções, clique em Criar.

    Captura de ecrã da caixa de diálogo Grupo de recursos.

  5. Depois que o grupo de recursos for criado, se você não o fixou no seu painel, poderá encontrá-lo clicando em Procurar e, em seguida, em Grupos de Recursos. Para abri-lo, clique no grupo de recursos. Anote o seu ID de Subscrição. Precisamos dela mais tarde.

    Captura de ecrã da secção C D N Console Tutorial.

Criando o aplicativo Microsoft Entra e aplicando permissões

Há duas abordagens para a autenticação de aplicativos com o Microsoft Entra ID: usuários individuais ou uma entidade de serviço. Uma entidade de serviço é semelhante a uma conta de serviço no Windows. Em vez de conceder a um usuário específico permissões para interagir com os perfis CDN, as permissões são concedidas à entidade de serviço. As entidades de serviço são normalmente usadas para processos automatizados e não interativos. Embora este tutorial esteja escrevendo um aplicativo de console interativo, vamos nos concentrar na abordagem da entidade de serviço.

A criação de uma entidade de serviço consiste em várias etapas, incluindo a criação de um aplicativo Microsoft Entra. Para criá-lo, vamos seguir este tutorial.

Importante

Certifique-se de seguir todas as etapas no tutorial vinculado. É importante que o complete exatamente como descrito. Certifique-se de anotar seu ID de locatário, nome de domínio do locatário (geralmente um domínio .onmicrosoft.com , a menos que você tenha especificado um domínio personalizado), ID do cliente e chave de autenticação do cliente, pois precisamos dessas informações mais tarde. Tenha cuidado para proteger sua ID de cliente e chave de autenticação de cliente, pois essas credenciais podem ser usadas por qualquer pessoa para executar operações como a entidade de serviço.

Quando chegar à etapa chamada Configurar aplicativo multilocatário, selecione Não.

Quando chegar à etapa Atribuir o aplicativo a uma função, use o grupo de recursos criado anteriormente, CdnConsoleTutorial, mas, em vez da função Leitor, atribua a função de Colaborador de Perfil CDN. Depois de atribuir ao aplicativo a função de Colaborador de Perfil CDN em seu grupo de recursos, retorne a este tutorial.

Depois de criar a entidade de serviço e atribuir a função de Colaborador do Perfil CDN, a folha Usuários do seu grupo de recursos deverá ser semelhante à imagem a seguir.

Lâmina de usuários

Autenticação interativa do usuário

Se, em vez de uma entidade de serviço, você preferir ter autenticação de usuário individual interativa, o processo será semelhante ao de uma entidade de serviço. Na verdade, você precisa seguir o mesmo procedimento, mas fazer algumas pequenas alterações.

Importante

Siga estas próximas etapas somente se você estiver optando por usar a autenticação de usuário individual em vez de uma entidade de serviço.

  1. Ao criar seu aplicativo, em vez de Aplicativo Web, escolha Aplicativo nativo.

    Aplicação nativa

  2. Na página seguinte, será solicitado um URI de redirecionamento. O URI não será validado, mas lembre-se do que você inseriu. Você precisa dele mais tarde.

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

  4. Em vez de atribuir uma entidade de serviço à função de Colaborador do Perfil CDN, vamos atribuir usuários ou grupos individuais. Neste exemplo, você pode ver que eu atribuí Usuário de Demonstração de CDN à função de Colaborador de Perfil de CDN .

    Acesso de utilizador individual

Crie seu projeto e adicione pacotes NuGet

Agora que criamos um grupo de recursos para nossos perfis de CDN e demos permissão ao nosso aplicativo Microsoft Entra para gerenciar perfis de CDN e pontos de extremidade dentro desse grupo, podemos começar a criar nosso aplicativo.

Importante

O pacote NuGet Microsoft.IdentityModel.Clients.ActiveDirectory e a Biblioteca de Autenticação do Azure AD (ADAL) foram preteridos. Nenhum novo recurso foi adicionado desde 30 de junho de 2020. Recomendamos vivamente que atualize. Para obter mais informações, consulte o guia de migração.

No Visual Studio 2015, selecione Arquivo, Novo, Projeto... para abrir a caixa de diálogo do novo projeto. Expanda Visual C# e, em seguida, selecione Windows no painel à esquerda. Selecione Aplicativo de console no painel central. Atribua um nome ao seu projeto e, em seguida, selecione OK.

Novo Projeto

Nosso projeto usará algumas bibliotecas do Azure contidas em pacotes NuGet. Vamos adicionar essas bibliotecas ao projeto.

  1. Selecione o menu Ferramentas , Gerenciador de Pacotes Nuget e, em seguida , Console do Gerenciador de Pacotes.

    Gerenciar pacotes Nuget

  2. No Console do Gerenciador de Pacotes, execute o seguinte comando para instalar a Biblioteca de Autenticação do Ative Directory (ADAL):

    Install-Package Microsoft.Identity.Client

  3. Execute o seguinte para instalar a Biblioteca de Gerenciamento de CDN do Azure:

    Install-Package Microsoft.Azure.Management.Cdn

Diretivas, constantes, método principal e métodos auxiliares

Vamos escrever a estrutura básica do nosso programa.

  1. De volta à guia Program.cs, substitua as using diretivas na parte superior pelo seguinte comando:

    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.Identity.Client;
using Microsoft.Rest;

  2. Precisamos definir algumas constantes que nossos métodos usam. Program Na classe, mas antes do Main método, adicione os seguintes blocos de código. Certifique-se de substituir os espaços reservados, incluindo os <colchetes> angulares, por seus próprios valores, conforme 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 turma, defina estas duas variáveis. Usamos essas variáveis posteriormente para determinar se nosso perfil e endpoint 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 avisar o usuário com perguntas "Sim/Não". Adicione o seguinte método para tornar isso um pouco mais fácil:

    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 usar a Biblioteca de Gerenciamento de CDN do Azure, precisamos autenticar nossa entidade de serviço e obter um token de autenticação. Esse método usa a Biblioteca de Autenticação do Ative Directory para recuperar o token.

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 você estiver usando a autenticação de usuário individual, o GetAccessToken método será ligeiramente diferente.

Importante

Use este exemplo de código somente se você estiver optando por ter autenticação de usuário individual em vez de uma entidade 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;
}

Certifique-se de substituir <redirect URI> pelo URI de redirecionamento que você inseriu quando registrou o aplicativo no Microsoft Entra ID.

Listar perfis CDN e pontos de extremidade

Agora estamos prontos para executar operações CDN. A primeira coisa que nosso método faz é listar todos os perfis e pontos de extremidade em nosso grupo de recursos e, se encontrar uma correspondência para os nomes de perfil e ponto final especificados em nossas constantes, anote para mais tarde para que não tentemos criar duplicatas.

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 CDN e pontos de extremidade

Em seguida, criamos 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);
    }
}

Depois que o perfil é criado, criamos um ponto de extremidade.

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 de extremidade uma origem chamada Contoso com um nome www.contoso.comde host. Você deve alterar isso para apontar para o nome de host da sua própria origem.

Limpar um ponto de extremidade

Supondo que o ponto de extremidade tenha sido criado, uma tarefa comum que podemos querer executar em nosso programa é limpar o conteúdo em nosso ponto de extremidade.

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 anterior, a cadeia de caracteres /* indica que quero limpar tudo na raiz do caminho do ponto de extremidade. Isso equivale a verificar Limpar Tudo na caixa de diálogo "Limpar" do portal do Azure. CreateCdnProfile No método, criei nosso perfil como uma CDN do Azure a partir do perfil Edgio usando o códigoSku = new Sku(SkuName.StandardVerizon), então isso será bem-sucedido.

Excluir perfis CDN e pontos de extremidade

Os últimos métodos excluem nosso endpoint 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();
    }
}

Executando o programa

Agora podemos compilar e executar o programa clicando no botão Iniciar no Visual Studio.

Programa em execução

Quando o programa atingir o prompt acima, você poderá retornar ao seu grupo de recursos no portal do Azure e ver se o perfil foi criado.

Êxito!

Podemos então confirmar os prompts para executar o resto do programa.

Conclusão do programa

Passos Seguintes

Para ver o projeto concluído a partir deste passo a passo, baixe o exemplo.

Para encontrar mais documentação na Biblioteca de Gerenciamento de CDN do Azure para .NET, consulte a referência no MSDN.

Gerencie seus recursos de CDN com o PowerShell.