Esercitazione: Eseguire lo streaming live con Servizi multimediali usando .NET 7.0

  • Articolo

Logo di Servizi multimediali v3

Avviso

Servizi multimediali di Azure verrà ritirato il 30 giugno 2024. Per altre informazioni, vedere la Guida al ritiro di AMS.

In Servizi multimediali di Azure gli eventi live sono responsabili dell'elaborazione di contenuti in streaming live. Un evento live fornisce un endpoint di input (URL di inserimento) che viene quindi fornito a un codificatore live. L'evento live riceve flussi di input dal codificatore live usando i protocolli RTMP/S o Smooth Streaming e li rende disponibili per lo streaming tramite uno o più endpoint di streaming. Gli eventi live forniscono anche un endpoint di anteprima (URL di anteprima) usato per visualizzare in anteprima e convalidare il flusso prima di un'ulteriore elaborazione e recapito.

Questa esercitazione illustra come usare .NET 7.0 per creare un evento live pass-through . Gli eventi live pass-through sono utili quando si dispone di un codificatore in grado di codificare a bitrate multipli, gop allineato in locale. Può essere un modo per ridurre i costi del cloud. Se si vuole ridurre la larghezza di banda e inviare un flusso a velocità in bit singola al cloud per la codifica a bitrate multipli, è possibile usare un evento live di transcodifica con i set di impostazioni di codifica 720P o 1080P.

In questa esercitazione si apprenderà come:

  • Scaricare un progetto di esempio.
  • Esaminare il codice che esegue lo streaming live.
  • Guardare l'evento con Azure Media Player nel sito demo di Media Player.
  • Configurare Griglia di eventi per monitorare l'evento live.
  • Pulire le risorse.

Prerequisiti

Per completare l'esercitazione sono necessari gli elementi seguenti:

Sono necessari anche questi elementi per il software di streaming live:

  • Una fotocamera o un dispositivo (ad esempio un portatile) usato per trasmettere un evento.
  • Codificatore software locale che codifica il flusso della fotocamera e lo invia al servizio di streaming live di Servizi multimediali tramite il protocollo RTMP/S (Messaging Protocol) di Real-Time. Per altre informazioni, vedere Codificatori live locali consigliati. Il flusso deve essere in formato RTMP/S o Smooth Streaming. Questo esempio presuppone che si userà Open Broadcaster Software (OBS) Studio per trasmettere RTMP/S all'endpoint di inserimento. Installare OBS Studio.
  • In alternativa, è possibile provare la guida introduttiva di OBS per testare prima l'intero processo con il portale di Azure.

Per monitorare l'evento live usando Griglia di eventi e Hub eventi, è possibile: 1. Seguire la procedura descritta in Creare e monitorare gli eventi di Servizi multimediali con Griglia di eventi usando il portale di Azure o, 1. Seguire la procedura alla fine di questa esercitazione nella sezione Monitoraggio degli eventi live tramite Griglia di eventi e Hub eventi di questo articolo.

Suggerimento

Prima di procedere, vedere Streaming live con Servizi multimediali v3 .

Scaricare e configurare l'esempio

Clonare il repository GitHub che contiene l'esempio .NET in streaming live nel computer usando il comando seguente:

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

L'esempio di streaming live si trova nella cartella Live/LiveEventWithDVR .

Aprire appsettings.json nel progetto scaricato. Sostituire i valori con il nome dell'account, l'ID sottoscrizione e il nome del gruppo di risorse.

Importante

Questo esempio usa un suffisso univoco per ogni risorsa. Se si annulla il debug o si termina l'app senza eseguirla, si otterranno più eventi live nell'account. Assicurarsi di arrestare gli eventi live in esecuzione. In caso contrario, verrà fatturato!

Iniziare a usare le API di Servizi multimediali con .NET SDK

Program.cs crea un riferimento alla risorsa dell'account di Servizi multimediali usando le opzioni di 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);

Creare un evento live

Questa sezione illustra come creare un tipo pass-through di evento live (LiveEventEncodingType impostato su None). Per informazioni sui tipi disponibili, vedere Tipi di eventi live. Se si vuole ridurre la larghezza di banda complessiva di inserimento o non si dispone di un transcoder a bitrate multipli locale, è possibile usare un evento di transcodifica live per la codifica cloud a velocità in bit adattiva a 720p o 1080p.

Quando si crea l'evento live, è possibile specificare gli elementi seguenti:

  • Protocollo di inserimento per l'evento live. Attualmente sono supportati i protocolli RTMPS e Smooth Streaming. Non è possibile modificare l'opzione del protocollo durante l'esecuzione dell'evento live. Se sono necessari protocolli diversi, creare un evento live separato per ogni protocollo di streaming.

  • Restrizioni IP per l'inserimento e l'anteprima. È possibile definire gli indirizzi IP autorizzati a inserire un video in questo evento live. Gli indirizzi IP consentiti possono essere specificati come una di queste opzioni:

    • Un singolo indirizzo IP (ad esempio, 10.0.0.1 o 2001:db8::1)

    • Intervallo IP che usa un indirizzo IP e una subnet mask CIDR (Classless Inter-Domain Routing), ad esempio 10.0.0.1/22 o 2001:db8::/48)

    • Intervallo IP che usa un indirizzo IP e una subnet mask decimale punteggiata (ad esempio, 10.0.0.1 255.255.252.0)

      Se non viene specificato alcun indirizzo IP e non è presente una definizione della regola, non sarà consentito alcun indirizzo IP. Per consentire qualsiasi indirizzo IP, creare una regola e impostare 0.0.0.0/0 e ::/0. Gli indirizzi IP devono essere in uno dei formati seguenti: indirizzi IPv4 o IPv6 con quattro numeri o un intervallo di indirizzi CIDR. Per altre informazioni, vedere Limitare l'accesso alla licenza DRM e al recapito delle chiavi AES usando gli elenchi di indirizzi IP consentiti.

  • Avvio automatico in un evento durante la creazione. Quando l'avvio automatico è impostato su true, l'evento live verrà avviato dopo la creazione. Ciò significa che la fatturazione viene avviata non appena l'evento live inizia l'esecuzione. È necessario chiamare Stop in modo esplicito la risorsa evento live per interrompere la fatturazione. Per altre informazioni, vedere Stati e fatturazione degli eventi live.

    Le modalità di standby sono disponibili per avviare l'evento live in uno stato "allocato" a costo inferiore che rende più veloce passare a uno stato di esecuzione. È utile per situazioni come i pool di accesso frequente che devono distribuire rapidamente i canali agli streamer.

  • Un nome host statico e un GUID univoco. Affinché un URL di inserimento sia predittivo e più semplice da gestire in un codificatore live basato su hardware, impostare la useStaticHostname proprietà su true. Per informazioni dettagliate, vedere URL di inserimento di eventi live.

    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);

Ottenere gli URL di inserimento

Dopo aver creato l'evento live, è possibile ottenere gli URL di inserimento che verranno forniti al codificatore live. Questi URL vengono usati dal codificatore per inserire un flusso live.

// 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();

Ottenere l'URL di anteprima

Usare previewEndpoint per visualizzare in anteprima e verificare che l'input del codificatore venga ricevuto.

Importante

Assicurarsi che il video venga propagato all'URL di anteprima prima di continuare.

// 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();

Creare e gestire eventi live e output live

Dopo che il flusso live dal codificatore locale viene trasmesso all'evento live, è possibile iniziare l'evento live creando un asset, un output live e un localizzatore di streaming. Il flusso viene archiviato ed è disponibile per gli utenti tramite l'endpoint di streaming.

La sezione successiva illustra la creazione dell'asset e l'output live.

Creare un asset

Creare un asset per l'output live da usare.

// 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");

Creare un output live

Gli output live iniziano quando vengono creati e arrestati quando vengono eliminati. Quando si elimina l'output live, non si elimina l'asset di output o il contenuto nell'asset. L'asset con la registrazione è disponibile per lo streaming on demand, purché esista e vi sia un localizzatore di streaming associato.

// 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");

Creare un localizzatore di streaming

Nota

Quando viene creato l'account di Servizi multimediali, all'account viene aggiunto un endpoint di streaming predefinito nello stato arrestato. Per avviare lo streaming del contenuto e sfruttare la creazione dinamica dei pacchetti e la crittografia dinamica, l'endpoint di streaming da cui si vuole trasmettere il contenuto deve trovarsi nello stato di esecuzione.

Per pubblicare un asset, creare un localizzatore di streaming. L'evento live (fino alla lunghezza della finestra DVR) è visualizzabile fino alla scadenza o all'eliminazione del localizzatore di streaming, a qualunque punto venga visualizzato per primo. È come rendere il video disponibile per il pubblico di visualizzazione per vedere live e on demand. Lo stesso URL può essere usato per watch l'evento live, la finestra DVR o l'asset su richiesta al termine dell'evento live e l'output live viene eliminato.

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

Guardare l'evento

Eseguire il codice. Usare gli URL di streaming di output per watch l'evento live. Copiare l'URL del localizzatore di streaming. È possibile usare il lettore multimediale desiderato. È possibile usare il sito demo di Media Player per testare il flusso. Immettere l'URL nel campo URL e selezionare Aggiorna lettore.

Monitoraggio degli eventi live tramite Griglia di eventi e Hub eventi

Il progetto di esempio può usare Griglia di eventi e Hub eventi per monitorare l'evento live. È possibile configurare e usare Griglia di eventi usando quanto segue

Per abilitare il monitoraggio:

  1. Usare il portale di Azure per creare uno spazio dei nomi di Hub eventi e un hub eventi
    1. Cercare "Hub eventi" usando la casella di testo nella parte superiore del portale di Azure.
    2. Selezionare Hub eventi dall'elenco e quindi seguire le istruzioni per creare uno spazio dei nomi di Hub eventi.
    3. Passare alla risorsa Spazio dei nomi di Hub eventi.
    4. Selezionare Hub eventi nella sezione Entità del menu del portale.
    5. Creare un hub eventi nello spazio dei nomi di Hub eventi.
    6. Passare alla risorsa hub eventi.
    7. Selezionare Controllo di accesso , quindi Aggiungi, quindi Aggiungi assegnazione di ruolo.
    8. Selezionare il ricevitore di dati Hub eventi di Azure e quindi concedere l'accesso a se stessi.
    9. Selezionare Controllo di accesso , quindi Aggiungi, quindi Aggiungi assegnazione di ruolo.
    10. Selezionare il Hub eventi di Azure Mittente dati e quindi concederlo all'identità gestita creata per l'account di Servizi multimediali.
  2. Usare il portale di Azure per creare un account di archiviazione di Azure.
    1. Dopo aver creato l'account di archiviazione, passare alla risorsa account di archiviazione.
    2. Selezionare Controllo di accesso , quindi Aggiungi, quindi Aggiungi assegnazione di ruolo.
    3. Selezionare collaboratore ai dati del BLOB di archiviazione e quindi concedere l'accesso a se stessi.
  3. Creare una sottoscrizione di eventi
    1. Passare all'account di Servizi multimediali.
    2. Selezionare Eventi dal menu del portale.
    3. Selezionare + Sottoscrizione di eventi.
    4. Immettere un nome di sottoscrizione e un nome di articolo di sistema.
    5. Impostare Tipo di endpoint su Event Hub.
    6. Impostare Hub eventi su Hub eventi creato in precedenza e impostare l'identità gestita sull'identità precedentemente concessa al mittente per l'accesso a Hub eventi
  4. Aggiornare il file appsetttings.json.
    1. Impostare EVENT_HUB_NAMESPACE sul nome completo dello spazio dei nomi. Dovrebbe essere simile a myeventhub.servicebus.windows.net.
    2. Impostare EVENT_HUB_NAME.
    3. Impostare AZURE_STORAGE_ACCOUNT_NAME.

Eseguire di nuovo l'esempio. Con l'integrazione di Hub eventi abilitata, gli eventi di esempio registrano gli eventi quando il codificatore si connette e si disconnette dall'evento live. Vengono registrati anche vari altri eventi.

Dopo aver eseguito l'esempio, eliminare Hub eventi e l'account di archiviazione se non sono più necessari.

Pulire le risorse nell'account di Servizi multimediali

Se gli eventi di streaming sono stati completati e si vuole pulire le risorse di cui è stato effettuato il provisioning in precedenza, usare la procedura seguente:

  1. Arrestare lo streaming dal codificatore.
  2. Arrestare l'evento live. Dopo l'arresto dell'evento live, non verranno addebitati addebiti. Quando è necessario avviarlo di nuovo, è possibile usare lo stesso URL di inserimento in modo da non dover riconfigurare il codificatore.
  3. Arrestare l'endpoint di streaming, a meno che non si voglia continuare a fornire l'archivio dell'evento live come flusso on demand. Se l'evento live è in stato arrestato, non verrà addebitato alcun addebito.
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");
}

Pulire le risorse rimanenti

Se non sono più necessari gli account di archiviazione e Servizi multimediali creati per questa esercitazione, eliminare il gruppo di risorse creato in precedenza.

Eseguire il comando dell'interfaccia della riga di comando seguente:


az group delete --name amsResourceGroup

Guida e supporto tecnico

È possibile contattare Servizi multimediali con domande o seguire gli aggiornamenti tramite uno dei metodi seguenti: