Conecte-se à API de Serviços de Mídia v3 - .NET

logotipo dos Serviços de Mídia v3


Você está procurando a documentação dos Serviços de Mídia v2?

Este artigo mostra como se conectar ao SDK do .NET dos Serviços de Mídia do Azure v3 usando o método de login da entidade de serviço.

Pré-requisitos

Importante

Examine Convenções de nomenclatura.

Criar um aplicativo de console

  1. Inicie o Visual Studio.
  2. No menu Arquivo, clique em Novo > Projeto.
  3. Crie um aplicativo de console do .NET Core.

O aplicativo de exemplo neste tópico, tem como meta netcoreapp2.0. O código usa 'async Main', que está disponível a partir do C# 7.1. Para obter mais informações, confira este blog.

Adicionar os pacotes/assemblies NuGet necessários

  1. No Visual Studio, selecione Ferramentas > Gerenciador de Pacotes do NuGet > Console do Gerenciador de Nuget.
  2. Na janela do Console do Gerenciador de Pacotes, use o comando Install-Package para adicionar os seguintes pacotes NuGet. Por exemplo, Install-Package Microsoft.Azure.Management.Media.
Pacote Descrição
Microsoft.Azure.Management.Media SDK dos Serviços de Mídia do Azure.
Para verificar se você está usando o pacote mais recente dos Serviços de Mídia do Azure, verifique Microsoft.Azure.Management.Media.

Outros assemblies necessários

  • Azure.Storage.Blobs
  • Microsoft.Extensions.Configuration
  • Microsoft.Extensions.Configuration.EnvironmentVariables
  • Microsoft.Extensions.Configuration.Json
  • Microsoft.Rest.ClientRuntime.Azure.Authentication

Criar e configurar o arquivo de configurações do aplicativo

Criar o appsettings.json

  1. Vá para Geral > Arquivo de texto.
  2. Nomeie-o "appsettings.json".
  3. Defina a propriedade "Copiar para o diretório de saída" do arquivo .json como "Copiar se for mais recente" (para que o aplicativo possa acessá-lo quando publicado).

Definir os valores em appsettings.json

Execute o comando az ams account sp create conforme descrito em APIs de acesso. O comando retorna o json que você deve copiar para "appsettings.json".

Adicionar arquivo de configuração

Para sua conveniência, adicione um arquivo de configuração que seja responsável por ler valores de "appsettings.json".

  1. Adicione uma nova classe .cs ao seu projeto. Nomeie-o como ConfigWrapper.
  2. Cole o código a seguir neste arquivo (este exemplo pressupõe que você tem o namespace ConsoleApp1).
using System;

using Microsoft.Extensions.Configuration;

namespace ConsoleApp1
{
    public class ConfigWrapper
    {
        private readonly IConfiguration _config;

        public ConfigWrapper(IConfiguration config)
        {
            _config = config;
        }

        public string SubscriptionId
        {
            get { return _config["SubscriptionId"]; }
        }

        public string ResourceGroup
        {
            get { return _config["ResourceGroup"]; }
        }

        public string AccountName
        {
            get { return _config["AccountName"]; }
        }

        public string AadTenantId
        {
            get { return _config["AadTenantId"]; }
        }

        public string AadClientId
        {
            get { return _config["AadClientId"]; }
        }

        public string AadSecret
        {
            get { return _config["AadSecret"]; }
        }

        public Uri ArmAadAudience
        {
            get { return new Uri(_config["ArmAadAudience"]); }
        }

        public Uri AadEndpoint
        {
            get { return new Uri(_config["AadEndpoint"]); }
        }

        public Uri ArmEndpoint
        {
            get { return new Uri(_config["ArmEndpoint"]); }
        }

        public string Location
        {
            get { return _config["Location"]; }
        }
    }
}

Conectar-se ao cliente .NET

Para começar a usar a APIs de Serviços de Mídia do Azure com o .NET, é necessário criar um objeto AzureMediaServicesClient. Para criar o objeto, você precisa fornecer as credenciais necessárias para o cliente se conectar ao Azure usando o Microsoft Azure Active Directory. No código abaixo, a função GetCredentialsAsync cria o objeto ServiceClientCredentials com base nas credenciais fornecidas no arquivo de configuração local.

  1. Abra o Program.cs.
  2. Cole o seguinte código:
using System;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using System.Threading.Tasks;

using Microsoft.Azure.Management.Media;
using Microsoft.Azure.Management.Media.Models;
using Microsoft.Extensions.Configuration;
using Microsoft.IdentityModel.Clients.ActiveDirectory;
using Microsoft.Rest;
using Microsoft.Rest.Azure.Authentication;

namespace ConsoleApp1
{
    class Program
    {
        public static async Task Main(string[] args)
        {
            
            ConfigWrapper config = new ConfigWrapper(new ConfigurationBuilder()
                .SetBasePath(Directory.GetCurrentDirectory())
                .AddJsonFile("appsettings.json", optional: true, reloadOnChange: true)
                .AddEnvironmentVariables()
                .Build());

            try
            {
                IAzureMediaServicesClient client = await CreateMediaServicesClientAsync(config);
                Console.WriteLine("connected");
            }
            catch (Exception exception)
            {
                if (exception.Source.Contains("ActiveDirectory"))
                {
                    Console.Error.WriteLine("TIP: Make sure that you have filled out the appsettings.json file before running this sample.");
                }

                Console.Error.WriteLine($"{exception.Message}");

                ApiErrorException apiException = exception.GetBaseException() as ApiErrorException;
                if (apiException != null)
                {
                    Console.Error.WriteLine(
                        $"ERROR: API call failed with error code '{apiException.Body.Error.Code}' and message '{apiException.Body.Error.Message}'.");
                }
            }

            Console.WriteLine("Press Enter to continue.");
            Console.ReadLine();
        }
 
        private static async Task<ServiceClientCredentials> GetCredentialsAsync(ConfigWrapper config)
        {
            // Use ApplicationTokenProvider.LoginSilentWithCertificateAsync or UserTokenProvider.LoginSilentAsync to get a token using service principal with certificate
            //// ClientAssertionCertificate
            //// ApplicationTokenProvider.LoginSilentWithCertificateAsync

            // Use ApplicationTokenProvider.LoginSilentAsync to get a token using a service principal with symmetric key
            ClientCredential clientCredential = new ClientCredential(config.AadClientId, config.AadSecret);
            return await ApplicationTokenProvider.LoginSilentAsync(config.AadTenantId, clientCredential, ActiveDirectoryServiceSettings.Azure);
        }

        private static async Task<IAzureMediaServicesClient> CreateMediaServicesClientAsync(ConfigWrapper config)
        {
            var credentials = await GetCredentialsAsync(config);

            return new AzureMediaServicesClient(config.ArmEndpoint, credentials)
            {
                SubscriptionId = config.SubscriptionId,
            };
        }

    }
}

Próximas etapas

Confira também