Tutoriel : Diffuser en direct avec Media Services à l’aide de .NET 7.0

  • Article

Logo de Media Services v3

Avertissement

Azure Media Services sera mis hors service le 30 juin 2024. Pour plus d’informations, consultez le Guide de mise hors service AMS.

Dans Azure Media Services, les événements en direct sont responsables du traitement de contenu de streaming en direct. Un événement en direct fournit un point de terminaison d’entrée (URL d’ingestion) que vous fournissez ensuite à un encodeur live. L’événement en direct reçoit des flux d’entrée de l’encodeur en direct à l’aide des protocoles RTMP/S ou Smooth Streaming et les rend disponibles pour la diffusion en continu via un ou plusieurs points de terminaison de streaming. Les événements en direct fournissent également un point de terminaison d’aperçu (URL d’aperçu) que vous utilisez pour prévisualiser et valider votre flux avant de poursuivre le traitement ou la distribution.

Ce tutoriel montre comment utiliser .NET 7.0 pour créer un événement direct en direct. Les événements en direct pass-through sont utiles lorsque vous disposez d’un encodeur qui est capable d’un encodage aligné sur plusieurs débits et goP en local. Il peut être un moyen de réduire les coûts cloud. Si vous souhaitez réduire la bande passante et envoyer un flux à débit unique vers le cloud pour l’encodage à débit multiple, vous pouvez utiliser un événement de transcodage en direct avec les présélections d’encodage 720P ou 1080P.

Ce didacticiel présente les procédures suivantes :

  • Téléchargez un exemple de projet.
  • Examiner le code qui effectue la diffusion en continu
  • Regardez l’événement avec le Lecteur multimédia Azure sur le site de démonstration du Lecteur multimédia.
  • Configurez Event Grid pour surveiller l’événement en direct.
  • Supprimer des ressources.

Prérequis

Pour ce tutoriel, vous devez disposer des éléments suivants :

Vous avez également besoin de ces éléments pour les logiciels de streaming en direct :

  • Une caméra ou appareil (tel qu’un ordinateur portable) utilisé pour diffuser un événement.
  • Un encodeur logiciel local qui encode votre flux de caméra et l’envoie au service de streaming en direct Media Services via le protocole RTMP/S (Real-Time Messaging Protocol). Pour plus d’informations, consultez Encodeurs live locaux recommandés. Le flux doit être au format RTMP/S ou Smooth Streaming. Cet exemple suppose que vous allez utiliser Open Broadcaster Software (OBS) Studio pour diffuser RTMP/S sur le point de terminaison d’ingestion. Installez OBS Studio.
  • Vous pouvez également essayer le démarrage rapide OBS pour tester tout le processus avec le Portail Azure.

Pour surveiller l’événement en direct à l’aide d’Event Grid et d’Event Hubs, vous pouvez : 1. Suivez les étapes décrites dans Créer et surveiller des événements Media Services avec Event Grid à l’aide de la Portail Azure ou, 1. Suivez les étapes vers la fin de ce didacticiel dans la section Surveillance des événements en direct à l’aide d’Event Grid et d’Event Hubs de cet article.

Conseil

Consultez Streaming en direct avec Media Services v3 avant de commencer.

Télécharger et configurer l’exemple

Clonez le dépôt GitHub qui contient l’exemple .NET de streaming en direct sur votre machine en utilisant la commande suivante :

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

L’exemple de diffusion en direct se trouve dans le dossier Live/LiveEventWithDVR .

Ouvrez appsettings.json dans votre projet téléchargé. Remplacez les valeurs par le nom du compte, l’ID d’abonnement et le nom du groupe de ressources.

Important

Cet exemple utilise un suffixe unique pour chaque ressource. Si vous annulez le débogage ou vous fermez l’application sans l’avoir effectué, vous obtiendrez plusieurs événements en direct sur votre compte. Veillez à arrêter les événements en direct en cours d’exécution. Sinon, vous serez facturé !

Commencer à utiliser les API Media Services avec le SDK .NET

Program.cs crée une référence à la ressource de compte Media Services à l’aide des options suivantes 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);

Créer un événement en temps réel

Cette section montre comment créer un type d’événement direct (LiveEventEncodingType défini sur None). Pour plus d’informations sur les types disponibles, consultez Types d’événements en direct. Si vous souhaitez réduire votre bande passante d’ingestion globale, ou si vous n’avez pas de transcodeur à débit multiple local, vous pouvez utiliser un événement de transcodage en direct pour l’encodage cloud à débit adaptatif 720p ou 1080p.

Vous souhaiterez peut-être spécifier les éléments suivants lors de la création de l’événement en direct :

  • Protocole d’ingestion pour l’événement en direct. Actuellement, les protocoles RTMPS et Smooth Streaming sont pris en charge. Vous ne pouvez pas modifier l’option de protocole pendant l’exécution de l’événement en direct. Si vous avez besoin d’autres protocoles, créez des événements en direct distincts pour chaque protocole de streaming.

  • Restrictions IP sur l’ingestion et l’aperçu. Vous pouvez définir les adresses IP autorisées à recevoir du contenu vidéo sur cet événement en direct. Les adresses IP autorisées peuvent être spécifiées sous l’une des formes suivantes :

    • Une adresse IP unique (par exemple, 10.0.0.1 ou 2001 :db8 ::1)

    • Plage d’adresses IP qui utilise une adresse IP et un masque de sous-réseau ciDR (Classless Inter-Domain Routing) (par exemple, 10.0.0.1/22 ou 2001 :db8 ::/48)

    • Plage d’adresses IP qui utilise une adresse IP et un masque de sous-réseau décimal en pointillés (par exemple, 10.0.0.1 255.255.252.0)

      Si aucune adresse IP n’est spécifiée et qu’il n’existe pas de définition de règle, alors aucune adresse IP ne sera autorisée. Pour autoriser une adresse IP, créez une règle et définissez 0.0.0.0/0 et ::/0. Les adresses IP doivent être dans l’un des formats suivants : adresses IPv4 ou IPv6 avec quatre nombres ou une plage d’adresses CIDR. Pour plus d’informations, consultez Restreindre l’accès à la licence DRM et à la remise de clés AES à l’aide de listes d’adresses IP autorisées.

  • Démarrage automatique d’un événement quand vous le créez. Lorsque le démarrage automatique est défini sur true, l’événement en direct démarre après sa création. La facturation commence donc dès le démarrage de l’événement en direct. Vous devez appeler explicitement la commande Stop sur la ressource de l’événement en direct pour arrêter toute facturation supplémentaire. Pour plus d’informations, consultez États et facturation des événements en direct.

    Des modes veille permettent de démarrer l’événement en direct dans un état « alloué » à moindre coût qui accélère le passage à l’état En cours d’exécution. Il est utile pour les situations telles que les pools chauds qui doivent transmettre rapidement des canaux aux streamers.

  • Un nom d’hôte statique et un GUID unique. Pour qu’une URL d’ingestion soit prédictive et plus facile à gérer dans un encodeur live basé sur le matériel, définissez la useStaticHostname propriété sur true. Pour plus d’informations, consultez URL d’ingestion des événements en direct.

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

Obtenir les URL de réception

Après la création de l’événement en direct, vous pouvez obtenir des URL d’ingestion que vous fournirez à l’encodeur live. L’encodeur utilise ces URL pour entrer un flux dynamique.

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

Obtenir l’URL d’aperçu

Utilisez previewEndpoint pour obtenir un aperçu et vérifier que l’entrée de l’encodeur est bien reçue.

Important

Avant de poursuivre, veillez à ce que la vidéo transite par l’URL d’aperçu.

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

Créer et gérer des événements en direct et des sorties en direct

Une fois que le flux en direct de l’encodeur local est diffusé en continu vers l’événement en direct, vous pouvez commencer l’événement en direct en créant une ressource, une sortie en direct et un localisateur de diffusion en continu. Le flux est archivé et est disponible pour les téléspectateurs via le point de terminaison de streaming.

La section suivante vous guidera tout au long de la création de l’actif multimédia et de la sortie en direct.

Créer une ressource

Créez un actif multimédia pour la sortie en direct à utiliser.

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

Créer une sortie en direct

Les sorties en direct démarrent quand elles sont créées et s’arrêtent quand elles sont supprimées. Lorsque vous supprimez la sortie en direct, vous ne supprimez pas la ressource de sortie ou le contenu de la ressource. La ressource avec l’enregistrement est disponible pour la diffusion en continu à la demande tant qu’elle existe et qu’un localisateur de diffusion en continu lui est associé.

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

Créer un localisateur de diffusion en continu

Notes

Une fois votre compte Media Services créé, un point de terminaison de streaming par défaut est ajouté à votre compte dans l’état Arrêté. Pour démarrer le streaming de votre contenu et tirer parti de l’empaquetage dynamique et du chiffrement dynamique, le point de terminaison de streaming à partir duquel vous souhaitez diffuser du contenu doit se trouver à l’état En cours d’exécution.

Vous publiez une ressource en créant un localisateur de streaming. L’événement en direct (jusqu’à la longueur de la fenêtre DVR) est visible jusqu’à l’expiration ou la suppression du localisateur de streaming, selon la première éventualité. C’est ainsi que vous mettez la vidéo à la disposition de votre public de visionnement en direct et à la demande. La même URL peut être utilisée pour watch l’événement en direct, la fenêtre DVR ou la ressource à la demande lorsque l’événement en direct est terminé et que la sortie en direct est supprimée.

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

Regarder l’événement

Exécutez le code. Utilisez les URL de streaming de sortie pour watch votre événement en direct. Copiez l’URL du localisateur de streaming. Vous pouvez utiliser le lecteur multimédia de votre choix. Vous pouvez utiliser le site de démonstration du Lecteur multimédia pour tester votre flux. Entrez l’URL dans le champ URL, puis sélectionnez Mettre à jour le lecteur.

Surveillance des événements en direct à l’aide d’Event Grid et d’Event Hubs

L’exemple de projet peut utiliser Event Grid et Event Hubs pour surveiller l’événement en direct. Vous pouvez configurer et utiliser Event Grid à l’aide des éléments suivants :

Pour activer la surveillance :

  1. Utiliser le Portail Azure pour créer un espace de noms Event Hubs et un hubs d’événements
    1. Recherchez « Event Hubs » à l’aide de la zone de texte située en haut du Portail Azure.
    2. Sélectionnez Event Hub dans la liste, puis suivez les instructions pour créer un espace de noms Event Hubs.
    3. Accédez à la ressource Espace de noms Event Hubs.
    4. Sélectionnez Event Hubs dans la section Entités du menu du portail.
    5. Créez un Event Hubs dans l’espace de noms Event Hubs.
    6. Accédez à la ressource Event Hubs.
    7. Sélectionnez Contrôle d’accès , Ajouter, puis Ajouter une attribution de rôle.
    8. Sélectionnez le récepteur de données Azure Event Hubs, puis accordez-vous l’accès à vous-même.
    9. Sélectionnez Contrôle d’accès , Ajouter, puis Ajouter une attribution de rôle.
    10. Sélectionnez l’expéditeur de données Azure Event Hubs, puis accordez-le à l’identité managée créée pour le compte Media Services.
  2. Utilisez le Portail Azure pour créer un compte de stockage Azure.
    1. Après avoir créé le compte de stockage, accédez à la ressource Compte de stockage.
    2. Sélectionnez Contrôle d’accès , Ajouter, puis Ajouter une attribution de rôle.
    3. Sélectionnez le Contributeur aux données Blob de stockage , puis accordez-vous cet accès.
  3. Créer un abonnement aux événements
    1. Accédez au compte Media Services.
    2. Sélectionnez Événements dans le menu du portail.
    3. Sélectionnez + Abonnement aux événements.
    4. Entrez un nom d’abonnement et un nom d’article système.
    5. Définissez le type de point de terminaison sur Event Hub.
    6. Définissez Event Hubs sur event Hubs créés précédemment et définissez l’identité managée sur l’identité qui a précédemment reçu l’accès de l’expéditeur aux hubs d’événements.
  4. Mettre à jour le fichier appsetttings.json.
    1. Définissez EVENT_HUB_NAMESPACE sur le nom complet de l’espace de noms. Il doit être similaire à myeventhub.servicebus.windows.net.
    2. Définissez EVENT_HUB_NAME.
    3. Définissez AZURE_STORAGE_ACCOUNT_NAME.

Réexécutez l’exemple. Une fois l’intégration d’Event Hubs activée, l’exemple journalise les événements lorsque l’encodeur se connecte et se déconnecte de l’événement en direct. Divers autres événements sont également consignés.

Après avoir exécuté l’exemple, supprimez le compte Event Hubs et le compte de stockage s’ils ne sont plus nécessaires.

Supprimer les ressources de votre compte Media Services

Si vous avez terminé de diffuser en streaming les événements et que vous voulez nettoyer les ressources provisionnées précédemment, utilisez la procédure ci-dessous :

  1. Arrêtez la diffusion en continu à partir de l’encodeur.
  2. Arrêtez l’événement en temps réel. Une fois l’événement en direct arrêté, aucun frais n’est encouru. Lorsque vous devez le redémarrer, la même URL d’ingestion peut être utilisée afin que vous n’ayez pas besoin de reconfigurer votre encodeur.
  3. Arrêtez le point de terminaison de streaming, sauf si vous souhaitez continuer à fournir l’archive de votre événement en direct en tant que flux à la demande. Si l’événement en direct est à l’état Arrêté, aucun frais n’est encouru.
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");
}

Nettoyer les ressources restantes

Si vous n’avez plus besoin des comptes Media Services et de stockage que vous avez créés pour ce didacticiel, supprimez le groupe de ressources que vous avez créé précédemment.

Exécutez la commande d’interface de ligne de commande ci-dessous :


az group delete --name amsResourceGroup

Obtenir de l’aide et du support

Vous pouvez contacter Media Services pour toute question ou suivre nos mises à jour selon l’une des méthodes suivantes :