Compartilhar via

Tutorial: Transmitir ao vivo com os Serviços de Mídia usando o .NET 7.0

  • Artigo

Logotipo dos Serviços de Mídia v3

Aviso

Os Serviços de Mídia do Azure serão desativados em 30 de junho de 2024. Para obter mais informações, consulte o Guia de Desativação do AMS.

Nos Serviços de Mídia do Azure, os eventos ao vivo são responsáveis pelo processamento do conteúdo de transmissão ao vivo. Um evento ao vivo fornece um ponto de extremidade de entrada (URL de ingestão) que você fornece a um codificador dinâmico. O evento ao vivo recebe fluxos de entrada do codificador ao vivo usando os protocolos RTMP/S ou Smooth Streaming e os disponibiliza para transmissão por meio de um ou mais pontos de extremidade de streaming. Os eventos ao vivo também fornecem um ponto de extremidade de pré-visualização (URL de pré-visualização) usado para visualizar e validar o fluxo antes do processamento e da entrega posteriores.

Este tutorial mostra como usar o .NET 7.0 para criar um evento ao vivo de passagem . Os eventos ao vivo de passagem são úteis quando você tem um codificador capaz de codificação alinhada a vários bits, alinhada ao GOP no local. Pode ser uma maneira de reduzir os custos de nuvem. Se você quiser reduzir a largura de banda e enviar um fluxo de taxa de bits única para a nuvem para codificação de várias taxas de bits, poderá usar um evento ao vivo de transcodificação com as predefinições de codificação 720P ou 1080P.

Neste tutorial, você irá:

  • Baixe um projeto de exemplo.
  • Examinar o código que executa a transmissão ao vivo.
  • Assistir ao evento com o Player de Mídia do Azure no site de demonstração do Player de Mídia.
  • Configure a Grade de Eventos para monitorar o evento ao vivo.
  • Limpe os recursos.

Pré-requisitos

Você precisa dos seguintes itens para concluir o tutorial:

Você também precisa desses itens para software de transmissão ao vivo:

  • Uma câmera ou um dispositivo (como um laptop) usado para transmitir um evento.
  • Um codificador de software local que codifica seu fluxo de câmera e o envia para o serviço de transmissão ao vivo dos Serviços de Mídia por meio do RTMP/S (Protocolo de Mensagens Real-Time). Para saber mais, confira Codificadores dinâmicos locais recomendados. O fluxo deve estar no formato RTMP/S ou Smooth Streaming. Este exemplo pressupõe que você usará o Open Broadcaster Software (OBS) Studio para transmitir RTMP/S para o ponto de extremidade de ingestão. Instale o OBS Studio.
  • Como alternativa, você pode experimentar o Início Rápido do OBS para testar todo o processo com o portal do Azure primeiro.

Para monitorar o evento ao vivo usando a Grade de Eventos e os Hubs de Eventos, você pode: 1. Siga as etapas em Criar e monitorar eventos dos Serviços de Mídia com a Grade de Eventos usando o portal do Azure ou, 1. Siga as etapas próximas ao final deste tutorial na seção Monitorando eventos ao vivo usando a Grade de Eventos e os Hubs de Eventos deste artigo.

Dica

Examine Transmissão ao vivo com os Serviços de Mídia v3 antes de continuar.

Baixar e configurar o exemplo

Clone o repositório GitHub que contém o exemplo de transmissão ao vivo do Node.js em computador usando o seguinte comando:

git clone https://github.com/Azure-Samples/media-services-v3-dotnet.git

O exemplo de transmissão ao vivo está na pasta Live/LiveEventWithDVR .

Abra appsettings.json em seu projeto baixado. Substitua os valores pelo nome da conta, pela ID da assinatura e pelo nome do grupo de recursos.

Importante

Esta amostra usa um sufixo exclusivo para cada recurso. Se você cancelar a depuração ou encerrar o aplicativo sem executá-lo, terá vários eventos ao vivo na sua conta. Interrompa a execução de eventos ao vivo. Caso contrário, haverá cobrança.

Comece a usar as APIs dos Serviços de Mídia com o SDK do .NET

Program.cs cria uma referência ao recurso de conta dos Serviços de Mídia usando as opções de appsettings.json:

var mediaServicesResourceId = MediaServicesAccountResource.CreateResourceIdentifier(
    subscriptionId: options.AZURE_SUBSCRIPTION_ID.ToString(),
    resourceGroupName: options.AZURE_RESOURCE_GROUP,
    accountName: options.AZURE_MEDIA_SERVICES_ACCOUNT_NAME);
var credential = new DefaultAzureCredential(includeInteractiveCredentials: true);
var armClient = new ArmClient(credential);
var mediaServicesAccount = armClient.GetMediaServicesAccountResource(mediaServicesResourceId);

Criar um evento ao vivo

Esta seção mostra como criar um tipo de passagem de evento ao vivo (LiveEventEncodingType definido como Nenhum). Para obter mais informações sobre os tipos disponíveis, confira Tipos de evento ao vivo. Se você quiser reduzir a largura de banda de ingestão geral ou não tiver um transcodificador de várias taxas de bits local, poderá usar um evento de transcodificação ao vivo para codificação de nuvem de taxa de bits adaptável de 720p ou 1080p.

Você pode especificar os seguintes itens ao criar o evento ao vivo:

  • O protocolo de ingestão para o evento ao vivo. Atualmente, há suporte para os protocolos RTMPS e Smooth Streaming. Você não pode alterar a opção de protocolo enquanto o evento ao vivo está em execução. Se precisar de protocolos diferentes, crie um evento ao vivo separado para cada protocolo de streaming.

  • Restrições de IP sobre a ingestão e a versão prévia. Você pode definir os endereços IP que têm permissão para receber um vídeo para este evento ao vivo. Os endereços IP permitidos podem ser especificados como uma destas opções:

    • Um único endereço IP (por exemplo, 10.0.0.1 ou 2001:db8::1)

    • Um intervalo de IP que usa um endereço IP e uma máscara de sub-rede CIDR (roteamento de Inter-Domain sem classe) (por exemplo, 10.0.0.1/22 ou 2001:db8::/48)

    • Um intervalo de IP que usa um endereço IP e uma máscara de sub-rede decimal pontilhada (por exemplo, 10.0.0.1 255.255.252.0)

      Se nenhum endereço IP for especificado e não houver definição de regra, nenhum endereço IP será permitido. Para permitir qualquer endereço IP, crie uma regra e defina 0.0.0.0/0 e ::/0. Os endereços IP precisam estar em um dos seguintes formatos: endereços IPv4 ou IPv6 com quatro números ou um intervalo de endereços CIDR. Para obter mais informações, consulte Restringir o acesso à licença DRM e à entrega de chaves do AES usando listas de permissões de IP.

  • Inicie automaticamente em um evento ao criá-lo. Quando o início automático for definido como true, o evento ao vivo será iniciado após a criação. Isso significa que a cobrança começa assim que o evento ao vivo começa a ser executado. É necessário chamar explicitamente Stop no recurso do evento ao vivo para impedir cobranças adicionais. Para obter mais informações, consulte Estados do evento ao vivo e cobrança.

    Há modos de espera disponíveis para iniciar o evento ao vivo em um estado "alocado" de menor custo que acelera a mudança para um estado de execução. É útil para situações como pools quentes que precisam distribuir canais rapidamente para os streamers.

  • Um nome de host estático e um GUID exclusivo. Para que uma URL de ingestão seja preditiva e mais fácil de manter em um codificador dinâmico baseado em hardware, defina a useStaticHostname propriedade como true. Para obter informações detalhadas, confira URLs de ingestão de evento ao vivo.

    var liveEvent = await mediaServicesAccount.GetMediaLiveEvents().CreateOrUpdateAsync(
    WaitUntil.Completed,
    liveEventName,
    new MediaLiveEventData(mediaServicesAccount.Get().Value.Data.Location)
    {
        Description = "Sample Live Event from the .NET SDK sample",
        UseStaticHostname = true,
        // 1) Set up the input settings for the Live event...
        Input = new LiveEventInput(streamingProtocol: LiveEventInputProtocol.Rtmp)
        {
            StreamingProtocol = LiveEventInputProtocol.Rtmp,
            AccessToken = "acf7b6ef-8a37-425f-b8fc-51c2d6a5a86a", // used to make the ingest URL unique
            KeyFrameIntervalDuration = TimeSpan.FromSeconds(2),
            IPAllowedIPs =
            {
                new IPRange
                {
                    Name = "AllowAllIpV4Addresses",
                    Address = IPAddress.Parse("0.0.0.0"),
                    SubnetPrefixLength = 0
                },
                new IPRange
                {
                    Name = "AllowAllIpV6Addresses",
                    Address = IPAddress.Parse("0::"),
                    SubnetPrefixLength = 0
                }
            }
        },
        // 2) Set the live event to use pass-through or cloud encoding modes...
        Encoding = new LiveEventEncoding()
        {
            EncodingType = LiveEventEncodingType.PassthroughBasic
        },
        // 3) Set up the Preview endpoint for monitoring
        Preview = new LiveEventPreview
        {
            IPAllowedIPs =
            {
                new IPRange()
                {
                    Name = "AllowAllIpV4Addresses",
                    Address = IPAddress.Parse("0.0.0.0"),
                    SubnetPrefixLength = 0
                },
                new IPRange()
                {
                    Name = "AllowAllIpV6Addresses",
                    Address = IPAddress.Parse("0::"),
                    SubnetPrefixLength = 0
                }
            }
        },
        // 4) Set up more advanced options on the live event. Low Latency is the most common one. Set
        //    this to Default or Low Latency. When using Low Latency mode, you must configure the Azure
        //    Media Player to use the quick start heuristic profile or you won't notice the change. In
        //    the AMP player client side JS options, set -  heuristicProfile: "Low Latency Heuristic
        //    Profile". To use low latency optimally, you should tune your encoder settings down to 1
        //    second GOP size instead of 2 seconds.
        StreamOptions =
        {
            StreamOptionsFlag.LowLatency
        },
        // 5) Optionally enable live transcriptions if desired. This is only supported on
        //    PassthroughStandard, and the transcoding live event types. It is not supported on Basic
        //    pass-through type.
        // WARNING: This is extra cost, so please check pricing before enabling.
        //Transcriptions =
        //{
        //    new LiveEventTranscription
        //    {
        //        // The value should be in BCP-47 format (e.g: 'en-US'). See https://go.microsoft.com/fwlink/?linkid=2133742
        //        Language = "en-us",
        //        TrackName = "English" // set the name you want to appear in the output manifest
        //    }
        //}
    },
    autoStart: false);

Obter URLs de ingestão

Depois que o Evento ao Vivo é criado, você pode obter URLs de ingestão que você fornecerá ao codificador dinâmico. O codificador usa essas URLs para gerar entrada de um fluxo ao vivo.

// Get the RTMP ingest URL. The endpoints is a collection of RTMP primary and secondary,
// and RTMPS primary and secondary URLs.
Console.WriteLine($"The RTMP ingest URL to enter into OBS Studio is:");
Console.WriteLine(liveEvent.Data.Input.Endpoints.First(x => x.Uri.Scheme == "rtmps").Uri);
Console.WriteLine("Make sure to enter a Stream Key into the OBS Studio settings. It can be");
Console.WriteLine("any value or you can repeat the accessToken used in the ingest URL path.");
Console.WriteLine();

Obter a URL de versão prévia

Use previewEndpoint para visualizar e verificar se a entrada do codificador está sendo recebida.

Importante

Verifique se o vídeo está fluindo para a URL de pré-visualização antes de continuar.

// Use the previewEndpoint to preview and verify that the input from the encoder is actually
// being received The preview endpoint URL also support the addition of various format strings
// for HLS (format=m3u8-cmaf) and DASH (format=mpd-time-cmaf) for example. The default manifest
// is Smooth.
string previewEndpoint = liveEvent.Data.Preview.Endpoints.First().Uri.ToString();
Console.WriteLine($"The preview URL is:");
Console.WriteLine(previewEndpoint);
Console.WriteLine();
Console.WriteLine($"Open the live preview in your browser and use the Azure Media Player to monitor the preview playback:");
Console.WriteLine($"https://ampdemo.azureedge.net/?url={HttpUtility.UrlEncode(previewEndpoint)}&heuristicprofile=lowlatency");
Console.WriteLine();
Console.WriteLine("Start the live stream now, sending the input to the ingest URL and verify");
Console.WriteLine("that it is arriving with the preview URL.");
Console.WriteLine("IMPORTANT: Make sure that the video is flowing to the Preview URL before continuing!");
Console.WriteLine("Press enter to continue...");
Console.ReadLine();

Criar e gerenciar eventos ao vivo e saídas ao vivo

Depois que a transmissão ao vivo do codificador local for transmitida para o evento ao vivo, você poderá iniciar o evento ao vivo criando um ativo, uma saída ao vivo e um localizador de streaming. O fluxo é arquivado e está disponível para visualizadores por meio do ponto de extremidade de streaming.

A próxima seção examinará a criação do ativo e da saída ao vivo.

Criar um ativo

Criar um Ativo para a saída ao vivo usar.

// Create an Asset for the Live Output to use. Think of this as the "tape" that will be recorded
// to. The asset entity points to a folder/container in your Azure Storage account
Console.Write($"Creating the output Asset '{assetName}'...".PadRight(60));
var asset = (await mediaServicesAccount.GetMediaAssets().CreateOrUpdateAsync(
    WaitUntil.Completed,
    assetName,
    new MediaAssetData
    {
        Description = "My video description"
    })).Value;
Console.WriteLine("Done");

Criar uma saída ao vivo

As saídas ao vivo começam quando são criadas e param quando são excluídas. Ao excluir a saída ao vivo, você não está excluindo o ativo de saída ou o conteúdo no ativo. O ativo com a gravação está disponível para streaming sob demanda, desde que exista e haja um localizador de streaming associado a ele.

// Create the Live Output - think of this as the "tape recorder for the live event". Live
// outputs are optional, but are required if you want to archive the event to storage, use the
// asset for on-demand playback later, or if you want to enable cloud DVR time-shifting. We will
// use the asset created above for the "tape" to record to.
Console.Write($"Creating Live Output...".PadRight(60));
var liveOutput = (await liveEvent.GetMediaLiveOutputs().CreateOrUpdateAsync(
    WaitUntil.Completed,
    liveOutputName,
    new MediaLiveOutputData
    {
        AssetName = asset.Data.Name,
        // The HLS and DASH manifest file name. This is recommended to
        // set if you want a deterministic manifest path up front.
        // archive window can be set from 3 minutes to 25 hours.
        // Content that falls outside of ArchiveWindowLength is
        // continuously discarded from storage and is non-recoverable.
        // For a full event archive, set to the maximum, 25 hours.
        ManifestName = manifestName,
        ArchiveWindowLength = TimeSpan.FromHours(1)
    })).Value;
Console.WriteLine("Done");

Criar um localizador de streaming

Observação

Quando sua conta dos Serviços de Mídia é criada, um ponto de extremidade de streaming padrão é adicionado à sua conta em estado parado. Para iniciar o streaming do conteúdo e aproveitar o empacotamento dinâmico e a criptografia dinâmica, o ponto de extremidade de streaming do qual você deseja transmitir o conteúdo deve estar no estado de execução.

Você publica um ativo criando um localizador de streaming. O evento ao vivo (até o comprimento da janela DVR) é acessível até a expiração ou exclusão do localizador de streaming, o que ocorrer primeiro. É assim que você disponibiliza o vídeo para que seu público-alvo veja ao vivo e sob demanda. A mesma URL pode ser usada para watch o evento ao vivo, a janela DVR ou o ativo sob demanda quando o evento ao vivo for concluído e a saída ao vivo for excluída.

var streamingLocator = (await mediaServicesAccount.GetStreamingLocators().CreateOrUpdateAsync(
    WaitUntil.Completed,
    streamingLocatorName,
    new StreamingLocatorData
    {
        AssetName = asset.Data.Name,
        StreamingPolicyName = "Predefined_ClearStreamingOnly",
        Filters =
        {
            filter.Data.Name
        }
    })).Value;

Assistir ao evento

Execute o código. Use as URLs de streaming de saída para watch seu evento ao vivo. Copie a URL do localizador de streaming. Você pode usar um player de mídia de sua escolha. Você pode usar o site de demonstração do Media Player para testar seu fluxo. Insira a URL no campo URL e selecione Atualizar player.

Monitorando eventos ao vivo usando a Grade de Eventos e Hubs de Eventos

O projeto de exemplo pode usar a Grade de Eventos e os Hubs de Eventos para monitorar o evento ao vivo. Você pode configurar e usar a Grade de Eventos usando o seguinte

Para habilitar o monitoramento:

  1. Use o portal do Azure para criar o Namespace dos Hubs de Eventos e um Hubs de Eventos
    1. Pesquise por "Hubs de Eventos" usando a caixa de texto na parte superior do portal do Azure.
    2. Selecione Hub de Eventos na lista e siga as instruções para criar um Namespace dos Hubs de Eventos.
    3. Navegue até o recurso Namespace dos Hubs de Eventos.
    4. Selecione Hubs de Eventos na seção Entidades do menu do portal.
    5. Crie um Hubs de Eventos no namespace dos Hubs de Eventos.
    6. Navegue até o recurso Hubs de Eventos.
    7. Selecione Controle de acesso e , em seguida, Adicionar atribuição de função.
    8. Selecione o Hubs de Eventos do Azure Data Receiver e conceda o acesso a si mesmo.
    9. Selecione Controle de acesso e , em seguida, Adicionar atribuição de função.
    10. Selecione o Hubs de Eventos do Azure Remetente de Dados e conceda-o à Identidade Gerenciada criada para a conta dos Serviços de Mídia.
  2. Use o portal do Azure para criar uma conta de Armazenamento do Azure.
    1. Depois de criar a conta de armazenamento, navegue até o recurso Conta de Armazenamento.
    2. Selecione Controle de acesso e , em seguida, Adicionar atribuição de função.
    3. Selecione o Colaborador de Dados de Blob de Armazenamento e conceda esse acesso a si mesmo.
  3. Criar uma assinatura de evento
    1. Navegue até a conta dos Serviços de Mídia.
    2. Selecione Eventos no menu do portal.
    3. Selecione + Assinatura de Evento.
    4. Insira um nome de assinatura e um nome de artigo do sistema.
    5. Defina o Tipo de Ponto de Extremidade como Event Hub.
    6. Defina os Hubs de Eventos para os Hubs de Eventos criados anteriormente e defina a Identidade Gerenciada como a identidade que recebeu acesso do Remetente anteriormente aos Hubs de Eventos
  4. Atualize o arquivo appsetttings.json.
    1. Defina EVENT_HUB_NAMESPACE como o nome completo do namespace. Deve ser semelhante a myeventhub.servicebus.windows.net.
    2. Definir EVENT_HUB_NAME.
    3. Definir AZURE_STORAGE_ACCOUNT_NAME.

Execute o exemplo novamente. Com a integração dos Hubs de Eventos habilitada, o exemplo registra eventos quando o codificador se conecta e se desconecta do Evento ao Vivo. Vários outros eventos também são registrados.

Depois de executar o exemplo, exclua os Hubs de Eventos e a conta de armazenamento se eles não forem mais necessários.

Limpar os recursos em sua conta de Serviços de Mídia

Se você tiver terminado a transmissão de eventos e deseja limpar os recursos provisionados anteriormente, use o seguinte procedimento:

  1. Pare o streaming do codificador.
  2. Pare o evento ao vivo. Depois que o evento ao vivo estiver parado, ele não incorrerá em nenhum encargo. Quando você precisar iniciá-la novamente, a mesma URL de ingestão poderá ser usada para que você não precise reconfigurar o codificador.
  3. Interrompa o ponto de extremidade de streaming, a menos que você queira continuar a fornecer o arquivo do evento ao vivo como um fluxo sob demanda. Se o evento ao vivo estiver em um estado parado, ele não incorrerá em nenhum encargo.
if (liveOutput != null)
{
    Console.Write("Deleting the Live Output...".PadRight(60));
    await liveOutput.DeleteAsync(WaitUntil.Completed);
    Console.WriteLine("Done");
}

if (liveEvent?.Data.ResourceState == LiveEventResourceState.Running)
{
    Console.Write("Stopping the Live Event...".PadRight(60));
    await liveEvent.StopAsync(WaitUntil.Completed, new LiveEventActionContent() { RemoveOutputsOnStop = true });
    Console.WriteLine("Done");
}

if (liveEvent != null)
{
    Console.Write("Deleting the Live Event...".PadRight(60));
    await liveEvent.DeleteAsync(WaitUntil.Completed);
    Console.WriteLine("Done");
}

if (streamingLocator != null)
{
    Console.Write("Deleting the Streaming Locator...".PadRight(60));
    await streamingLocator.DeleteAsync(WaitUntil.Completed);
    Console.WriteLine("Done");
}

if (asset != null)
{
    Console.Write("Deleting the Asset...".PadRight(60));
    await asset.DeleteAsync(WaitUntil.Completed);
    Console.WriteLine("Done");
}

Limpar recursos remanescentes

Se você não precisar mais dos Serviços de Mídia e das contas de armazenamento que criou para este tutorial, exclua o grupo de recursos criado anteriormente.

Execute o seguinte comando da CLI:


az group delete --name amsResourceGroup

Obter ajuda e suporte

Você pode entrar em contato com os Serviços de Mídia com perguntas ou seguir nossas atualizações por um dos seguintes métodos: