Didacticiel : Diffuser en direct avec Media ServicesTutorial: Stream live with Media Services

Notes

Bien que ce didacticiel utilise des exemples .NET SDK, les étapes générales sont les mêmes pour l’API REST, l’interface de ligne de commande et d’autres kits de développement logiciel (SDK) pris en charge.Even though the tutorial uses .NET SDK examples, the general steps are the same for REST API, CLI, or other supported SDKs.

Dans Azure Media Services, les événements en direct sont responsables du traitement de contenu de streaming en direct.In Azure Media Services, Live Events are responsible for processing live streaming content. Un événement en direct fournit un point de terminaison d’entrée (URL de réception) que vous fournissez ensuite à un encodeur live.A Live Event provides an input endpoint (ingest URL) that you then provide to a live encoder. Il reçoit des flux d’entrée en temps réel d’un encodeur live et le rend disponible pour le streaming par le biais d’un ou de plusieurs points de terminaison de streaming.The Live Event receives live input streams from the live encoder and makes it available for streaming through one or more Streaming Endpoints. 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.Live Events also provide a preview endpoint (preview URL) that you use to preview and validate your stream before further processing and delivery. Ce didacticiel explique comment utiliser .NET Core pour créer un type de canal direct d’un événement en temps réel.This tutorial shows how to use .NET Core to create a pass-through type of a live event.

Ce didacticiel explique les procédures suivantes :The tutorial shows you how to:

Si vous n’avez pas d’abonnement Azure, créez un compte gratuit avant de commencer.If you don't have an Azure subscription, create a free account before you begin.

PrérequisPrerequisites

Les éléments suivants sont requis pour suivre le didacticiel :The following items are required to complete the tutorial:

  • Installez Visual Studio Code ou Visual Studio.Install Visual Studio Code or Visual Studio.
  • Créer un compte Media Services.Create a Media Services account.
    Veillez à mémoriser les valeurs utilisées pour le nom du groupe de ressources et le nom du compte Media Services.Make sure to remember the values you use for the resource group name and Media Services account name.
  • Suivez les étapes décrites dans Accéder à l’API Azure Media Services avec Azure CLI et enregistrez les informations d’identification.Follow the steps in Access Azure Media Services API with the Azure CLI and save the credentials. Vous en aurez besoin pour accéder à l’API.You'll need to use them to access the API.
  • Une caméra ou appareil (tel qu’un ordinateur portable) utilisé pour diffuser un événement.A camera or a device (like a laptop) that's used to broadcast an event.
  • Un encodeur vidéo dynamique local qui convertit les signaux de la caméra en flux de données qui sont envoyés vers le service de vidéo en flux continu Media Services.An on-premises live encoder that converts signals from the camera to streams that are sent to the Media Services live streaming service. La diffusion doit se faire au format RTMP ou Smooth Streaming.The stream has to be in RTMP or Smooth Streaming format.

Conseil

Veillez à consulter Diffusion en continu avec Media Services v3 avant de commencer.Make sure to review Live streaming with Media Services v3 before proceeding.

Télécharger et configurer l’exempleDownload and configure the sample

Clonez un référentiel GitHub qui contient l’exemple .NET de diffusion en continu sur votre machine à l’aide de la commande suivante :Clone a GitHub repository that contains the streaming .NET sample to your machine using the following command:

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

L’exemple de diffusion en continu est situé dans le dossier Live.The live streaming sample is located in the Live folder.

Ouvrez appsettings.json dans votre projet téléchargé.Open appsettings.json in your downloaded project. Remplacez les valeurs par les informations d’identification que vous avez obtenues en accédant aux API.Replace the values with the credentials you got from accessing APIs.

Important

Cet exemple utilise un suffixe unique pour chaque ressource.This sample uses a unique suffix for each resource. 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.If you cancel the debugging or terminate the app without running it through, you'll end up with multiple Live Events in your account.
Veillez à arrêter les événements en direct en cours d’exécution.Make sure to stop the running Live Events. Sinon, vous serez facturé !Otherwise, you'll be billed!

Examiner le code qui effectue la diffusion en continuExamine the code that performs live streaming

Cette section examine les fonctions définies dans le fichier Program.cs du projet MediaV3LiveApp.This section examines functions defined in the Program.cs file of the MediaV3LiveApp project.

L’exemple crée un suffixe unique pour chaque ressource afin d’éviter tout conflit de noms si vous exécutez l’exemple plusieurs fois sans le supprimer.The sample creates a unique suffix for each resource so that you don't have name collisions if you run the sample multiple times without cleaning up.

Important

Cet exemple utilise un suffixe unique pour chaque ressource.This sample uses a unique suffix for each resource. 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.If you cancel the debugging or terminate the app without running it through, you'll end up with multiple Live Events in your account.
Veillez à arrêter les événements en direct en cours d’exécution.Make sure to stop the running Live Events. Sinon, vous serez facturé !Otherwise, you'll be billed!

Commencer à utiliser les API Media Services avec le Kit de développement logiciel (SDK) .NETStart using Media Services APIs with .NET SDK

Pour commencer à utiliser les API Media Services avec .NET, vous devez créer un objet AzureMediaServicesClient.To start using Media Services APIs with .NET, you need to create an AzureMediaServicesClient object. Pour créer l’objet, vous devez fournir les informations d’identification nécessaires pour que le client puisse se connecter à Azure à l’aide d’Azure AD.To create the object, you need to supply credentials needed for the client to connect to Azure using Azure AD. Dans le code que vous avez cloné au début de l’article, la fonction GetCredentialsAsync crée l’objet ServiceClientCredentials basé sur les informations d’identification fournies dans le fichier de configuration local.In the code you cloned at the beginning of the article, the GetCredentialsAsync function creates the ServiceClientCredentials object based on the credentials supplied in local configuration file.

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

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

Créer un événement en temps réelCreate a live event

Cette section montre comment créer un type de transmission directe d’événement en direct (LiveEventEncodingType défini sur Aucun).This section shows how to create a pass-through type of Live Event (LiveEventEncodingType set to None). Pour plus d’informations sur les types d’événements en direct disponibles, consultez Types d’événements en direct.For more information about the available types of Live Events, see Live Event types.

Voici quelques éléments que vous voudrez probablement spécifier lors de la création de l’événement en temps réel :Some things that you might want to specify when creating the live event are:

  • Emplacement de Media Services.Media Services location.
  • Protocole de streaming de l’événement en direct (les protocoles RTMP et Smooth Streaming sont actuellement pris en charge).The streaming protocol for the Live Event (currently, the RTMP and Smooth Streaming protocols are supported).
    Vous ne pouvez pas changer l’option de protocole pendant l’exécution de l’événement en direct ou des sorties en direct qui lui sont associées.You can't change the protocol option while the Live Event or its associated Live Outputs are running. Si vous avez besoin d’autres protocoles, créez des événements en direct distincts pour chaque protocole de streaming.If you require different protocols, create separate Live Event for each streaming protocol.
  • Restictions IP sur l’ingestion et la préversion.IP restrictions on the ingest and preview. Vous pouvez définir les adresses IP autorisées à recevoir du contenu vidéo sur cet événement en direct.You can define the IP addresses that are allowed to ingest a video to this Live Event. Les adresses IP autorisées peuvent être définies sous forme d’adresse IP unique (par exemple, « 10.0.0.1 »), de plage d’adresses IP constituée d’une adresse IP et d’un masque de sous-réseau CIDR (par exemple, « 10.0.0.1/22 ») ou de plage d’adresses IP constituée d’une adresse IP et d’un masque de sous-réseau au format décimal séparé par des points (par exemple, « 10.0.0.1(255.255.252.0) »).Allowed IP addresses can be specified as either a single IP address (for example '10.0.0.1'), an IP range using an IP address and a CIDR subnet mask (for example, '10.0.0.1/22'), or an IP range using an IP address and a dotted decimal subnet mask (for example, '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.If no IP addresses are specified and there's no rule definition, then no IP address will be allowed. Pour autoriser toutes les adresses IP, créez une règle et définissez la valeur 0.0.0.0/0.To allow any IP address, create a rule and set 0.0.0.0/0.
    Les adresses IP doivent utiliser un des formats suivants : adresses IPv4 à quatre chiffres ou plage d’adresses CIDR.The IP addresses have to be in one of the following formats: IpV4 address with four numbers or CIDR address range.
  • Lors de la création de l’événement, vous pouvez spécifier qu’il démarre automatiquement.When creating the event, you can specify to autostart it.
    Lorsque le démarrage automatique est défini sur true, l’événement en direct démarre après sa création.When autostart is set to true, the Live Event will be started after creation. La facturation commence donc dès le démarrage de l’événement en direct.That means the billing starts as soon as the Live Event starts running. Vous devez appeler explicitement la commande Stop sur la ressource de l’événement en direct pour arrêter toute facturation supplémentaire.You must explicitly call Stop on the Live Event resource to halt further billing. Pour plus d’informations, consultez États et facturation des événements en direct.For more information, see Live Event states and billing.
  • Pour qu’une URL de réception soit prédictive, réglez le mode « personnel ».For an ingest URL to be predictive, set the "vanity" mode. Pour plus d’informations, consultez URL de réception des événements en direct.For detailed information, see Live Event ingest URLs.
Console.WriteLine($"Creating a live event named {liveEventName}");
Console.WriteLine();

// Note: When creating a LiveEvent, you can specify allowed IP addresses in one of the following formats:                 
//      IpV4 address with 4 numbers
//      CIDR address range

IPRange allAllowIPRange = new IPRange(
    name: "AllowAll",
    address: "0.0.0.0",
    subnetPrefixLength: 0
);

// Create the LiveEvent input IP access control.
LiveEventInputAccessControl liveEventInputAccess = new LiveEventInputAccessControl
{
    Ip = new IPAccessControl(
            allow: new IPRange[]
            {
                allAllowIPRange
            }
        )

};

// Create the LiveEvent Preview IP access control
LiveEventPreview liveEventPreview = new LiveEventPreview
{
    AccessControl = new LiveEventPreviewAccessControl(
        ip: new IPAccessControl(
            allow: new IPRange[]
            {
                allAllowIPRange
            }
        )
    )
};

// To get the same ingest URL for the same LiveEvent name:
// 1. Set vanityUrl to true so you have ingest like: 
//        rtmps://liveevent-hevc12-eventgridmediaservice-usw22.channel.media.azure.net:2935/live/522f9b27dd2d4b26aeb9ef8ab96c5c77           
// 2. Set accessToken to a desired GUID string (with or without hyphen)

LiveEvent liveEvent = new LiveEvent(
    location: mediaService.Location,
    description: "Sample LiveEvent for testing",
    vanityUrl: false,
    encoding: new LiveEventEncoding(
                // When encodingType is None, the service simply passes through the incoming video and audio layer(s) to the output
                // When the encodingType is set to Standard or Premium1080p, a live encoder is used to transcode the incoming stream
                // into multiple bit rates or layers. See https://go.microsoft.com/fwlink/?linkid=2095101 for more information
                encodingType: LiveEventEncodingType.None,
                presetName: null
            ),
    input: new LiveEventInput(LiveEventInputProtocol.RTMP, liveEventInputAccess),
    preview: liveEventPreview,
    streamOptions: new List<StreamOptionsFlag?>()
    {
        // Set this to Default or Low Latency
        // When using Low Latency mode, you must configure the Azure Media Player to use the 
        // quick start hueristic 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.
        StreamOptionsFlag.LowLatency
    }
);

Console.WriteLine($"Creating the LiveEvent, be patient this can take time...");

// When autostart is set to true, the Live Event will be started after creation. 
// That means, the billing starts as soon as the Live Event starts running. 
// You must explicitly call Stop on the Live Event resource to halt further billing.
// The following operation can sometimes take awhile. Be patient.
liveEvent = await client.LiveEvents.CreateAsync(config.ResourceGroup, config.AccountName, liveEventName, liveEvent, autoStart: true);

Obtenir les URL de réceptionGet ingest URLs

Après la création de l’événement en direct, vous pouvez obtenir des URL d’ingestion que vous fournirez à l’encodeur live.Once the Live Event is created, you can get ingest URLs that you'll provide to the live encoder. L’encodeur utilise ces URL pour entrer un flux dynamique.The encoder uses these URLs to input a live stream.

string ingestUrl = liveEvent.Input.Endpoints.First().Url;
Console.WriteLine($"The ingest url to configure the on premise encoder with is:");
Console.WriteLine($"\t{ingestUrl}");
Console.WriteLine();

Obtenir l’URL d’aperçuGet the preview URL

Utilisez le point de terminaison d’aperçu et vérifiez que l’entrée de l’encodeur est bien reçue.Use the previewEndpoint to preview and verify that the input from the encoder is actually being received.

Important

Veillez à ce que la vidéo transite par l’URL d’aperçu avant de poursuivre.Make sure that the video is flowing to the Preview URL before continuing.

string previewEndpoint = liveEvent.Preview.Endpoints.First().Url;
Console.WriteLine($"The preview url is:");
Console.WriteLine($"\t{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($"\thttps://ampdemo.azureedge.net/?url={previewEndpoint}&heuristicprofile=lowlatency");
Console.WriteLine();

Créer et gérer des événements en direct et des sorties en directCreate and manage Live Events and Live Outputs

Une fois que le flux transite dans l’événement en direct, vous pouvez commencer l’événement de streaming en créant un actif multimédia, une sortie en direct et un localisateur de streaming.Once you have the stream flowing into the Live Event, you can begin the streaming event by creating an Asset, Live Output, and Streaming Locator. Le flux est alors archivé et mis à la disposition des observateurs via le point de terminaison de diffusion en continu.This will archive the stream and make it available to viewers through the Streaming Endpoint.

Créer une ressourceCreate an Asset

Créez un actif multimédia pour la sortie en direct à utiliser.Create an Asset for the Live Output to use.

Console.WriteLine($"Creating an asset named {assetName}");
Console.WriteLine();
Asset asset = await client.Assets.CreateOrUpdateAsync(config.ResourceGroup, config.AccountName, assetName, new Asset());

Créer une sortie en directCreate a Live Output

Les sorties en direct démarrent dès leur création et s’arrêtent à leur suppression.Live Outputs start on creation and stop when deleted. Quand vous supprimez la sortie en direct, vous ne supprimez pas l’élément multimédia sous-jacent ni le contenu de celui-ci.When you delete the Live Output, you're not deleting the underlying Asset and content in the asset.

string manifestName = "output";
Console.WriteLine($"Creating a live output named {liveOutputName}");
Console.WriteLine();

LiveOutput liveOutput = new LiveOutput(assetName: asset.Name, manifestName: manifestName, archiveWindowLength: TimeSpan.FromMinutes(10));
liveOutput = await client.LiveOutputs.CreateAsync(config.ResourceGroup, config.AccountName, liveEventName, liveOutputName, liveOutput);

Créer un localisateur de streamingCreate a Streaming Locator

Notes

Après la création de votre compte Media Services, un point de terminaison de streaming par défaut est ajouté à votre compte à l’état Arrêté.When your Media Services account is created, a default streaming endpoint is added to your account in the Stopped state. 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.To start streaming your content and take advantage of dynamic packaging and dynamic encryption, the streaming endpoint from which you want to stream content has to be in the Running state.

Quand vous publiez l’actif Sortie en direct à l’aide d’un localisateur de streaming, l’événement en direct (jusqu’à la longueur de la fenêtre DVR) reste visible jusqu’à l’expiration ou la suppression du localisateur de streaming, en fonction de ce qui se produit en premier.When you publish the Live Output asset using a Streaming Locator, the Live Event (up to the DVR window length) will continue to be viewable until the Streaming Locator's expiry or deletion, whichever comes first.

Console.WriteLine($"Creating a streaming locator named {streamingLocatorName}");
Console.WriteLine();

StreamingLocator locator = new StreamingLocator(assetName: asset.Name, streamingPolicyName: PredefinedStreamingPolicy.ClearStreamingOnly);
locator = await client.StreamingLocators.CreateAsync(config.ResourceGroup, config.AccountName, streamingLocatorName, locator);

// Get the default Streaming Endpoint on the account
StreamingEndpoint streamingEndpoint = await client.StreamingEndpoints.GetAsync(config.ResourceGroup, config.AccountName, streamingEndpointName);

// If it's not running, Start it. 
if (streamingEndpoint.ResourceState != StreamingEndpointResourceState.Running)
{
    Console.WriteLine("Streaming Endpoint was Stopped, restarting now..");
    await client.StreamingEndpoints.StartAsync (config.ResourceGroup, config.AccountName, streamingEndpointName);
}

// Get the url to stream the output
ListPathsResponse paths = await client.StreamingLocators.ListPathsAsync(resourceGroupName, accountName, locatorName);

foreach (StreamingPath path in paths.StreamingPaths)
{
    UriBuilder uriBuilder = new UriBuilder();
    uriBuilder.Scheme = "https";
    uriBuilder.Host = streamingEndpoint.HostName;

    uriBuilder.Path = path.Paths[0];
    // Get the URL from the uriBuilder: uriBuilder.ToString()
}

Suppression des ressources de votre compte Media ServicesCleaning up resources in your Media Services account

Si vous avez terminé de diffuser en continu les événements et que vous voulez nettoyer les ressources configurées précédemment, suivez la procédure ci-dessous.If you're done streaming events and want to clean up the resources provisioned earlier, follow the following procedure:

  • Arrêtez d’envoyer le flux à partir de l’encodeur.Stop pushing the stream from the encoder.
  • Arrêtez l’événement en direct.Stop the Live Event. Une fois l’événement en direct arrêté, aucun frais n’est encouru.Once the Live Event is stopped, it won't incur any charges. Lorsque vous devez le redémarrer, il possède la même URL de réception. Vous n’avez donc pas besoin de reconfigurer votre encodeur.When you need to start it again, it will have the same ingest URL so you won't need to reconfigure your encoder.
  • Vous pouvez arrêter votre point de terminaison de diffusion en continu, sauf si vous souhaitez continuer à fournir l’archive de votre événement en direct en tant que flux à la demande.You can stop your Streaming Endpoint, unless you want to continue to provide the archive of your live event as an on-demand stream. Si l’événement en direct est à l’état Arrêté, aucun frais n’est encouru.If the Live Event is in a stopped state, it won't incur any charges.
private static async Task CleanupLiveEventAndOutputAsync(IAzureMediaServicesClient client, string resourceGroup, string accountName, string liveEventName)
{
    try
    {
        LiveEvent liveEvent = await client.LiveEvents.GetAsync(resourceGroup, accountName, liveEventName);

        if (liveEvent != null)
        {
            if (liveEvent.ResourceState == LiveEventResourceState.Running)
            {
                // If the LiveEvent is running, stop it and have it remove any LiveOutputs
                await client.LiveEvents.StopAsync(resourceGroup, accountName, liveEventName, removeOutputsOnStop: true);
            }

            // Delete the LiveEvent
            await client.LiveEvents.DeleteAsync(resourceGroup, accountName, liveEventName);
        }
    }
    catch (ApiErrorException e)
    {
        Console.WriteLine("CleanupLiveEventAndOutputAsync -- Hit ApiErrorException");
        Console.WriteLine($"\tCode: {e.Body.Error.Code}");
        Console.WriteLine($"\tCode: {e.Body.Error.Message}");
        Console.WriteLine();
    }
}
private static async Task CleanupLocatorandAssetAsync(IAzureMediaServicesClient client, string resourceGroup, string accountName, string streamingLocatorName, string assetName)
{
    try
    {
        // Delete the Streaming Locator
        await client.StreamingLocators.DeleteAsync(resourceGroup, accountName, streamingLocatorName);

        // Delete the Archive Asset
        await client.Assets.DeleteAsync(resourceGroup, accountName, assetName);
    }
    catch (ApiErrorException e)
    {
        Console.WriteLine("CleanupLocatorandAssetAsync -- Hit ApiErrorException");
        Console.WriteLine($"\tCode: {e.Body.Error.Code}");
        Console.WriteLine($"\tCode: {e.Body.Error.Message}");
        Console.WriteLine();
    }
}

Regarder l’événementWatch the event

Pour regarder l’événement, copiez l’URL de streaming obtenue à l’exécution du code décrit dans Créer un localisateur de streaming.To watch the event, copy the streaming URL that you got when you ran code described in Create a Streaming Locator. Vous pouvez utiliser le lecteur multimédia de votre choix.You can use a media player of your choice. Lecteur multimédia Azure vous permet de tester votre flux à l’adresse https://ampdemo.azureedge.net.Azure Media Player is available to test your stream at https://ampdemo.azureedge.net.

Une fois arrêté, l’événement en direct est automatiquement converti en contenu à la demande.Live Event automatically converts events to on-demand content when stopped. Même après l’arrêt et la suppression de l’événement, les utilisateurs pourront lire votre contenu archivé en tant que vidéo à la demande tant que vous n’aurez pas supprimé l’élément multimédia.Even after you stop and delete the event, users can stream your archived content as a video on demand for as long as you don't delete the asset. Vous ne pouvez pas supprimer d’élément multimédia s’il est utilisé par un événement. Vous devez d’abord supprimer l’événement.An asset can't be deleted if it's used by an event; the event must be deleted first.

Supprimer des ressourcesClean up resources

Si vous n’avez plus besoin des ressources de votre groupe de ressources, notamment les comptes de stockage et Media Services que vous avez créés pour ce didacticiel, supprimez le groupe de ressources créé précédemment.If you no longer need any of the resources in your resource group, including the Media Services and storage accounts you created for this tutorial, delete the resource group you created earlier.

Exécutez la commande CLI suivante :Execute the following CLI command:

az group delete --name amsResourceGroup

Important

Laisser l’événement en direct s’exécuter entraîne des frais.Leaving the Live Event running incurs billing costs. Sachez que si le projet/programme plante ou est fermé pour une quelconque raison, l’événement peut continuer de s’exécuter et ainsi entraîner des frais.Be aware, if the project/program crashes or is closed out for any reason, it could leave the Live Event running in a billing state.

Poser des questions, envoyer des commentaires, obtenir des mises à jourAsk questions, give feedback, get updates

Découvrez l’article Communauté Azure Media Services pour découvrir les différentes façons dont vous pouvez poser des questions, faire des commentaires et obtenir des mises à jour sur Media Services.Check out the Azure Media Services community article to see different ways you can ask questions, give feedback, and get updates about Media Services.

Étapes suivantesNext steps

Diffuser des fichiersStream files