Compartilhar via

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

  • Artigo

Importante

A CDN do Azure Standard (clássica) será desativada em 30 de setembro de 2027. Para evitar qualquer interrupção de serviço, é importante migrar seus perfis da CDN do Azure Standard (clássica) para a camada Azure Front Door Standard ou Premium até 30 de setembro de 2027. Para obter mais informações, confira CDN do Azure Standard (clássica).

O CDN do Azure da Edgio será desativado em 4 de novembro de 2025. Você deve migrar sua carga de trabalho para o Azure Front Door antes desta data para evitar interrupção do serviço.. Para obter mais informações, veja Perguntas frequentes sobre a aposentadoria do CDN do Azure da Edgeo.

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

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

Dica

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

Pré-requisitos

Antes de gravar o código de gerenciamento da CDN, é necessário fazer algumas preparações para habilitar o código a interagir com o Azure Resource Manager. Para fazer essas preparações, é necessário:

  • Crie um grupo de recursos para conter o perfil CDN criada neste tutorial
  • Configurar o Microsoft Entra ID para fornecer autenticação para o aplicativo
  • Aplicar permissões ao grupo de recursos, de modo que somente usuários autorizados do locatário do Microsoft Entra possam interagir com o perfil de CDN

Criando o grupo de recursos

  1. Entre no Portal do Azure.

  2. Clique em Criar um recurso.

  3. Procure o Grupo de recursos e no painel de Grupos de Recursos, clique em Criar.

    Criando um novo grupo de recursos

  4. Nomeie o grupo de recursos CdnConsoleTutorial. Selecione sua assinatura e escolha uma localização perto de você. Se desejar, você poderá clicar na caixa de seleção Fixar no painel para fixar o grupo de recursos no painel que está no portal. Ao fixar, facilita a localização posteriormente. Após fazer suas seleções, clique em Criar.

    Captura de tela da caixa de diálogo Grupo de recursos.

  5. Após a criação do grupo de recursos, se você não o fixou ao painel, encontre-o clicando em Procurar e em Grupos de Recursos. Para abri-lo, clique no grupo de recursos. Anote sua ID da assinatura. Ela será necessária mais tarde.

    Captura de tela da seção do Tutorial do console C D N.

Criação de aplicativo do Microsoft Entra e aplicação de permissões

Há duas abordagens para autenticação de aplicativo com Microsoft Entra ID: usuários individuais ou uma entidade de serviço. Uma entidade de serviço é semelhante a uma conta de serviço do Windows. Em vez de conceder permissões particulares de um usuário para interagir com os perfis CDN, as permissões são concedidas à entidade de serviço. As entidades de serviço, geralmente são utilizadas para processos automatizados não interativos. Embora este tutorial esteja gravando um aplicativo de console interativo, nos concentraremos 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 do Microsoft Entra. Para criá-lo, vamos seguir este tutorial.

Importante

Siga todas as etapas do tutorial vinculado. É importante que você conclua-o exatamente conforme descrito. Anote a ID do locatário, o nome de domínio do locatário (normalmente um domínio .onmicrosoft.com, a menos que você tenha especificado um domínio personalizado), a ID do cliente e a chave de autenticação do cliente, pois essas informações serão necessárias mais tarde. Proteja a ID do cliente e a chave de autenticação de cliente, pois essas credenciais podem ser utilizadas 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 Colaborador do Perfil CDN. Depois de atribuir a função Colaborador do Perfil CDN ao aplicativo em seu grupo de recursos, volte para este tutorial.

Após ter criado a entidade de serviço e atribuído a função Colaborador de Perfil de CDN, a folha Usuários do grupo de recursos deverá ser semelhante à seguinte imagem.

Folha de usuários

Autenticação de usuário interativo

Se, em vez de uma entidade de serviço você preferir a autenticação de usuário individual interativa, o processo será semelhante ao de uma entidade de serviço. De fato, é necessário seguir o mesmo procedimento, mas fazer algumas pequenas alterações.

Importante

Siga as próximas etapas, se escolher 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.

    Aplicativo nativo

  2. Na próxima página, será solicitado um URI de Redirecionamento. O URI não será validado, mas lembre-se do que você digitou. Isso será necessário mais tarde.

  3. Não é necessário criar uma chave de autenticação do cliente.

  4. Em vez de atribuir uma entidade de serviço para a função Colaborador do Perfil CDN , vamos atribuir usuários individuais ou grupos. Neste exemplo, é possível ver que você atribuiu o Usuário de Demonstração CDN para a função Colaborador do Perfil CDN .

    Acesso de usuário individual

Crie seu projeto e adicione pacotes do NuGet

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

Importante

O pacote NuGet Microsoft.IdentityModel.Clients.ActiveDirectory e a ADAL (Biblioteca de Autenticação do Azure AD) foram preteridos. Não foi adicionado nenhum novo recurso desde 30 de junho de 2020. Recomendamos com ênfase que você faça upgrade. Para obter mais informações, confira 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. Nomeie o projeto e selecione OK.

Novo projeto

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

  1. Selecione no menu Ferramentas, Gerenciador de pacotes do 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 ADAL (Biblioteca de Autenticação do Active Directory) :

    Install-Package Microsoft.Identity.Client

  3. Execute o seguinte para instalar a biblioteca de gerenciamento do Azure CDN:

    Install-Package Microsoft.Azure.Management.Cdn

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

Vejamos a estrutura básica do nosso programa gravado.

  1. De volta à guia Program.cs, substitua as diretivas using na parte superior com o 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 são usadas nos nossos métodos. Na classe Program, mas antes do método Main, adicione os seguintes blocos de código. Substitua os espaços reservados, inclusive os <sinais maior e menor que> , 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 no nível de classe, defina essas duas variáveis. Essas variáveis são usadas posteriormente para determinar se o perfil e o ponto de extremidade já existem.

    static bool profileAlreadyExists = false;
static bool endpointAlreadyExists = false;

  4. Substitua o método Main da seguinte maneira:

    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 solicitarão que o usuário responda perguntas do tipo "Sim/Não". Adicione o seguinte método para tornar esse processo 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á gravada, devemos criar métodos chamados pelo método Main .

Autenticação

Para que possamos usar a biblioteca de gerenciamento do Azure CDN, é necessário autenticar nossa entidade de serviço e obter um token de autenticação. Esse método usa a Biblioteca de Autenticação do Active 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;
}

Ao usar a autenticação de usuário individual, o método GetAccessToken parecerá ligeiramente diferente.

Importante

Use este exemplo de código somente se optar pela 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> com o URI de redirecionamento que você inseriu quando registrou o aplicativo no Microsoft Entra ID.

Relacione os perfis CDN e os pontos de extremidade

Agora estamos prontos para executar as operações de CDN. A primeira tarefa do nosso método é relacionar todos os perfis e pontos de extremidade no grupo de recursos e, se ele encontrar uma correspondência para os nomes de perfis e de pontos de extremidade especificados nas constantes, ele fará uma observação a respeito posteriormente. Portanto, não tentaremos 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 for 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);
    }
}

Observação

O exemplo acima atribui ao ponto de extremidade uma origem denominada Contoso, com um nome de host www.contoso.com. Você deve alterá-la para apontar para o nome de host de sua própria origem.

Limpar um ponto de extremidade

Supondo que o ponto de extremidade tenha sido criado, uma tarefa comum que talvez desejemos executar em nosso programa está limpando o conteúdo no 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();
    }
}

Observação

No exemplo anterior, a cadeia de caracteres /* indica que eu quero limpar tudo na raiz do caminho do ponto de extremidade. Isso é equivalente a marcar Limpar Tudo na caixa de diálogo "limpeza" do portal do Azure. No método CreateCdnProfile, criei nosso perfil como um perfil do Azure CDN do Edgio usando o código Sku = new Sku(SkuName.StandardVerizon); assim, ele será bem-sucedido.

Excluir perfis CDN e pontos de extremidade

Os últimos métodos excluem nosso ponto de extremidade 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 a seu grupo de recursos no portal do Azure e ver que o perfil foi criado.

Êxito!

Em seguida, podemos confirmar as solicitações para executar o restante do programa.

Programa em conclusão

Próximas etapas

Para localizar mais documentação sobre a biblioteca de gerenciamento da CDN do Azure para .NET, confira a referência no MSDN.

Gerencie seus recursos CDN com o PowerShell.