Didacticiel : Télécharger, encoder et diffuser des vidéos avec Media Services v3Tutorial: Upload, encode, and stream videos with Media Services v3

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 this tutorial uses .NET SDK examples, the general steps are the same for REST API, CLI, or other supported SDKs.

Azure Media Services vous permet d’encoder vos fichiers multimédias dans des formats lus sur un large choix de navigateurs et d’appareils.Azure Media Services lets you encode your media files into formats that play on a wide variety of browsers and devices. Par exemple, vous pouvez streamer votre contenu au format HLS ou MPEG DASH d’Apple.For example, you might want to stream your content in Apple's HLS or MPEG DASH formats. Avant la diffusion en continu, vous devez encoder votre fichier multimédia numérique haute qualité.Before streaming, you should encode your high-quality digital media file. Pour obtenir de l’aide sur l’encodage, consultez Concept d’encodage.For help with encoding, see Encoding concept. Ce didacticiel charge un fichier vidéo local et encode le fichier chargé.This tutorial uploads a local video file and encodes the uploaded file. Vous pouvez également encoder du contenu que vous mettez à disposition via une URL HTTPS.You can also encode content that you make accessible via an HTTPS URL. Pour plus d’informations, consultez Créer une entrée de travail à partir d’une URL HTTP(s).For more information, see Create a job input from an HTTP(s) URL.

Lire une vidéo avec le lecteur multimédia Azure

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

  • Télécharger l’exemple d’application décrit dans la rubrique.Download the sample app described in the topic.
  • Examiner le code qui charge, encode et diffuse en continuExamine the code that uploads, encodes, and streams.
  • Exécutez l'application.Run the app.
  • Tester l’URL de diffusion en continu.Test the streaming URL.
  • Supprimer des ressources.Clean up resources.

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

Télécharger et configurer l'exempleDownload and set up the sample

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

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

L’exemple se trouve dans le dossier UploadEncodeAndStreamFiles.The sample is located in the UploadEncodeAndStreamFiles 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 credentials that you got from accessing APIs.

Examiner le code qui charge, encode et diffuse en continuExamine the code that uploads, encodes, and streams

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

L’exemple effectue les actions suivantes :The sample performs the following actions:

  1. Crée une transformation (vérifie d’abord si la transformation spécifiée existe).Creates a new Transform (first, checks if the specified Transform exists).
  2. Crée un actif multimédia de sortie qui est utilisé comme sortie du travail d’encodage.Creates an output Asset that's used as the encoding Job's output.
  3. Crée un actif multimédia d’entrée et charge le fichier vidéo local spécifié dans celui-ci.Create an input Asset and uploads the specified local video file into it. La ressource d’entrée est utilisée en tant qu’entrée du travail.The asset is used as the job's input.
  4. Soumet le travail d’encodage à l’aide de l’entrée et de la sortie qui ont été créées.Submits the encoding job using the input and output that was created.
  5. Vérifier l’état du travail.Checks the job's status.
  6. Crée un localisateur de streaming.Creates a Streaming Locator.
  7. Crée des URL de diffusion en continu.Builds streaming URLs.

Commencer à utiliser les API Media Services avec le 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 permettant au client de se connecter à Azure à l’aide d’Azure AD.To create the object, you must 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 une ressource d’entrée et charger un fichier local dans celle-ciCreate an input asset and upload a local file into it

La fonction CreateInputAsset crée une nouvelle ressource d’entrée et charge le fichier vidéo local spécifié dans celle-ci.The CreateInputAsset function creates a new input Asset and uploads the specified local video file into it. Cet élément multimédia est utilisé comme entrée de votre travail d’encodage.This Asset is used as the input to your encoding job. Dans Media Services v3, l’entrée d’un travail peut être un élément multimédia ou du contenu que vous mettez à la disposition de votre compte Media Services par le biais d’URL HTTPS.In Media Services v3, the input to a Job can either be an Asset or content that you make available to your Media Services account via HTTPS URLs. Pour savoir comment encoder à partir d’une URL HTTPS, consultez cet article.To learn how to encode from an HTTPS URL, see this article.

Dans Media Services v3, vous utilisez des API Stockage Azure pour charger des fichiers.In Media Services v3, you use Azure Storage APIs to upload files. L’extrait de code .NET suivant vous explique comment faire.The following .NET snippet shows how.

La fonction suivante effectue les actions ci-après :The following function performs these actions:

  • Crée un élément multimédia.Creates an Asset.
  • Obtient une URL SAP accessible en écriture vers le conteneur de stockage de l’élément multimédia.Gets a writable SAS URL to the asset’s container in storage.
  • Charge le fichier dans le conteneur de stockage à l’aide de l’URL SAP.Uploads the file into the container in storage using the SAS URL.
private static async Task<Asset> CreateInputAssetAsync(
    IAzureMediaServicesClient client,
    string resourceGroupName,
    string accountName,
    string assetName,
    string fileToUpload)
{
    // In this example, we are assuming that the asset name is unique.
    //
    // If you already have an asset with the desired name, use the Assets.Get method
    // to get the existing asset. In Media Services v3, the Get method on entities returns null 
    // if the entity doesn't exist (a case-insensitive check on the name).

    // Call Media Services API to create an Asset.
    // This method creates a container in storage for the Asset.
    // The files (blobs) associated with the asset will be stored in this container.
    Asset asset = await client.Assets.CreateOrUpdateAsync(resourceGroupName, accountName, assetName, new Asset());

    // Use Media Services API to get back a response that contains
    // SAS URL for the Asset container into which to upload blobs.
    // That is where you would specify read-write permissions 
    // and the exparation time for the SAS URL.
    var response = await client.Assets.ListContainerSasAsync(
        resourceGroupName,
        accountName,
        assetName,
        permissions: AssetContainerPermission.ReadWrite,
        expiryTime: DateTime.UtcNow.AddHours(4).ToUniversalTime());

    var sasUri = new Uri(response.AssetContainerSasUrls.First());

    // Use Storage API to get a reference to the Asset container
    // that was created by calling Asset's CreateOrUpdate method.  
    CloudBlobContainer container = new CloudBlobContainer(sasUri);
    var blob = container.GetBlockBlobReference(Path.GetFileName(fileToUpload));

    // Use Strorage API to upload the file into the container in storage.
    await blob.UploadFromFileAsync(fileToUpload);

    return asset;
}

Créer une ressource de sortie pour stocker le résultat d’un travailCreate an output asset to store the result of a job

La ressource de sortie stocke le résultat de votre travail d’encodage.The output Asset stores the result of your encoding job. Le projet définit la fonction DownloadResults qui télécharge les résultats à partir de cette ressource de sortie dans le dossier « output », afin de voir ce que vous avez obtenu.The project defines the DownloadResults function that downloads the results from this output asset into the "output" folder, so you can see what you got.

private static async Task<Asset> CreateOutputAssetAsync(IAzureMediaServicesClient client, string resourceGroupName, string accountName, string assetName)
{
    // Check if an Asset already exists
    Asset outputAsset = await client.Assets.GetAsync(resourceGroupName, accountName, assetName);
    Asset asset = new Asset();
    string outputAssetName = assetName;

    if (outputAsset != null)
    {
        // Name collision! In order to get the sample to work, let's just go ahead and create a unique asset name
        // Note that the returned Asset can have a different name than the one specified as an input parameter.
        // You may want to update this part to throw an Exception instead, and handle name collisions differently.
        string uniqueness = $"-{Guid.NewGuid().ToString("N")}";
        outputAssetName += uniqueness;
        
        Console.WriteLine("Warning – found an existing Asset with name = " + assetName);
        Console.WriteLine("Creating an Asset with this name instead: " + outputAssetName);                
    }

    return await client.Assets.CreateOrUpdateAsync(resourceGroupName, accountName, outputAssetName, asset);
}

Créer une transformation et un travail qui encode le fichier chargéCreate a Transform and a Job that encodes the uploaded file

Lors de l’encodage ou du traitement de contenu dans Media Services, il est courant de configurer les paramètres de codage en tant que formule.When encoding or processing content in Media Services, it's a common pattern to set up the encoding settings as a recipe. Vous envoyez ensuite un travail pour appliquer cette formule à une vidéo.You would then submit a Job to apply that recipe to a video. En envoyant de nouveaux travaux pour chaque nouvelle vidéo, vous appliquez cette formule à toutes les vidéos de votre bibliothèque.By submitting new jobs for each new video, you're applying that recipe to all the videos in your library. Dans Media Services, une formule est appelée transformation.A recipe in Media Services is called a Transform. Pour plus d’informations, consultez Transformations et travaux.For more information, see Transforms and Jobs. L’exemple décrit dans ce didacticiel définit une formule qui encode la vidéo, afin de la diffuser en continu sur divers appareils iOS et Android.The sample described in this tutorial defines a recipe that encodes the video in order to stream it to a variety of iOS and Android devices.

TransformerTransform

Lorsque vous créez une instance de transformation, vous devez spécifier ce qu’elle doit produire comme sortie.When creating a new Transform instance, you need to specify what you want it to produce as an output. Le paramètre requis est un objet TransformOutput, comme indiqué dans le code ci-dessous.The required parameter is a TransformOutput object, as shown in the code below. Chaque objet TransformOutput contient un préréglage.Each TransformOutput contains a Preset. Le préréglage décrit les instructions détaillées concernant les opérations de traitement vidéo et/ou audio qui doivent être utilisées pour générer l’objet TransformOutput souhaité.Preset describes the step-by-step instructions of video and/or audio processing operations that are to be used to generate the desired TransformOutput. L’exemple décrit dans cet article utilise un préréglage appelé AdaptiveStreaming.The sample described in this article uses a built-in Preset called AdaptiveStreaming. Le préréglage encode la vidéo d’entrée dans une échelle des vitesses de transmission générée automatiquement (paires vitesse de transmission-résolution) basée sur la vitesse de transmission et la résolution de la sortie, et crée des fichiers MP4 ISO avec des fichiers audio AAC et des fichiers vidéo H.264 qui correspondent à chaque paire vitesse de transmission-résolution.The Preset encodes the input video into an auto-generated bitrate ladder (bitrate-resolution pairs) based on the input resolution and bitrate, and produces ISO MP4 files with H.264 video and AAC audio corresponding to each bitrate-resolution pair. Pour plus d’informations sur ce préréglage, consultez Encode with an auto-generated bitrate ladder (Encoder avec une échelle des vitesses de transmission générée automatiquement).For information about this Preset, see auto-generating bitrate ladder.

Vous pouvez utiliser un préréglage EncoderNamedPreset intégré ou des préréglages personnalisés.You can use a built-in EncoderNamedPreset or use custom presets. Pour plus d’informations, consultez How to customize encoder presets (Procédure : personnaliser les présélections de l’encodeur).For more information, see How to customize encoder presets.

Lorsque vous créez une transformation, vous devez tout d’abord vérifier s’il en existe déjà une à l’aide de la méthode Get, comme indiqué dans le code qui suit.When creating a Transform, you should first check if one already exists using the Get method, as shown in the code that follows. Dans Media Services v3, les méthodes Get appliquées sur les entités renvoient null si l’entité n’existe pas (une vérification du nom respectant la casse).In Media Services v3, Get methods on entities return null if the entity doesn’t exist (a case-insensitive check on the name).

private static async Task<Transform> GetOrCreateTransformAsync(
    IAzureMediaServicesClient client,
    string resourceGroupName,
    string accountName,
    string transformName)
{
    // Does a Transform already exist with the desired name? Assume that an existing Transform with the desired name
    // also uses the same recipe or Preset for processing content.
    Transform transform = await client.Transforms.GetAsync(resourceGroupName, accountName, transformName);

    if (transform == null)
    {
        // You need to specify what you want it to produce as an output
        TransformOutput[] output = new TransformOutput[]
        {
            new TransformOutput
            {
                // The preset for the Transform is set to one of Media Services built-in sample presets.
                // You can  customize the encoding settings by changing this to use "StandardEncoderPreset" class.
                Preset = new BuiltInStandardEncoderPreset()
                {
                    // This sample uses the built-in encoding preset for Adaptive Bitrate Streaming.
                    PresetName = EncoderNamedPreset.AdaptiveStreaming
                }
            }
        };

        // Create the Transform with the output defined above
        transform = await client.Transforms.CreateOrUpdateAsync(resourceGroupName, accountName, transformName, output);
    }

    return transform;
}

TravailJob

Comme indiqué ci-dessus, l’objet Transformation est la formule et un travail est la requête réelle envoyée à Media Services pour appliquer cette transformation à un contenu vidéo ou audio d’entrée donné.As mentioned above, the Transform object is the recipe and a Job is the actual request to Media Services to apply that Transform to a given input video or audio content. Le travail spécifie des informations telles que l’emplacement de la vidéo d’entrée et celui de la sortie.The Job specifies information like the location of the input video, and the location for the output.

Dans cet exemple, la vidéo d’entrée a été chargée à partir de votre ordinateur local.In this example, the input video has been uploaded from your local machine. Pour savoir comment encoder à partir d’une URL HTTPS, consultez cet article.If you want to learn how to encode from an HTTPS URL, see this article.

private static async Task<Job> SubmitJobAsync(IAzureMediaServicesClient client,
    string resourceGroupName,
    string accountName,
    string transformName,
    string jobName,
    string inputAssetName,
    string outputAssetName)
{
    // Use the name of the created input asset to create the job input.
    JobInput jobInput = new JobInputAsset(assetName: inputAssetName);

    JobOutput[] jobOutputs =
    {
        new JobOutputAsset(outputAssetName),
    };

    // In this example, we are assuming that the job name is unique.
    //
    // If you already have a job with the desired name, use the Jobs.Get method
    // to get the existing job. In Media Services v3, the Get method on entities returns null 
    // if the entity doesn't exist (a case-insensitive check on the name).
    Job job = await client.Jobs.CreateAsync(
        resourceGroupName,
        accountName,
        transformName,
        jobName,
        new Job
        {
            Input = jobInput,
            Outputs = jobOutputs,
        });

    return job;
}

Attendre la fin du travailWait for the Job to complete

Le travail prend du temps à se terminer et vous voulez être prévenu lorsque c’est le cas.The job takes some time to complete and when it does you want to be notified. L’exemple de code ci-dessous montre comment interroger le service pour connaître l’état du travail.The code sample below shows how to poll the service for the status of the Job. L’interrogation ne relève pas d'une pratique recommandée pour les applications de production en raison de la latence potentielle.Polling isn't a recommended best practice for production apps because of potential latency. L’interrogation peut être limitée si elle est utilisée de façon excessive sur un compte.Polling can be throttled if overused on an account. À la place, les développeurs doivent utiliser Event Grid.Developers should instead use Event Grid.

Event Grid est conçu pour une haute disponibilité, des performances cohérentes et une mise à l’échelle dynamique.Event Grid is designed for high availability, consistent performance, and dynamic scale. Avec Event Grid, vos applications peuvent écouter les événements de presque tous les services Azure ou de toute source personnalisée, et y réagir.With Event Grid, your apps can listen for and react to events from virtually all Azure services, as well as custom sources. La gestion simple et réactive des événements basée sur HTTP vous aide à générer des solutions efficaces grâce au filtrage et au routage intelligents des événements.Simple, HTTP-based reactive event handling helps you build efficient solutions through intelligent filtering and routing of events. Consultez Acheminer des événements Azure Media Services vers un point de terminaison personnalisé à l’aide de CLI.See Route events to a custom web endpoint.

Le travail passe généralement par les états suivants : Planifié, En attente, Traitement en cours, Terminé (l’état final).The Job usually goes through the following states: Scheduled, Queued, Processing, Finished (the final state). Si le travail a rencontré une erreur, vous obtenez l’état Erreur.If the job has encountered an error, you get the Error state. Si le travail est en cours d’annulation, vous obtenez Annulation en cours et Annulé une fois l’opération terminée.If the job is in the process of being canceled, you get Canceling and Canceled when it's done.

private static async Task<Job> WaitForJobToFinishAsync(IAzureMediaServicesClient client,
    string resourceGroupName,
    string accountName,
    string transformName,
    string jobName)
{
    const int SleepIntervalMs = 60 * 1000;

    Job job = null;

    do
    {
        job = await client.Jobs.GetAsync(resourceGroupName, accountName, transformName, jobName);

        Console.WriteLine($"Job is '{job.State}'.");
        for (int i = 0; i < job.Outputs.Count; i++)
        {
            JobOutput output = job.Outputs[i];
            Console.Write($"\tJobOutput[{i}] is '{output.State}'.");
            if (output.State == JobState.Processing)
            {
                Console.Write($"  Progress: '{output.Progress}'.");
            }

            Console.WriteLine();
        }

        if (job.State != JobState.Finished && job.State != JobState.Error && job.State != JobState.Canceled)
        {
            await Task.Delay(SleepIntervalMs);
        }
    }
    while (job.State != JobState.Finished && job.State != JobState.Error && job.State != JobState.Canceled);

    return job;
}

Codes d’erreur des tâchesJob error codes

Consultez Codes d’erreur.See Error codes.

Obtenir un localisateur de streamingGet a Streaming Locator

Une fois l’encodage terminé, l’étape suivante consiste à mettre à la disposition des clients la vidéo dans la ressource de sortie pour qu’ils puissent la lire.After the encoding is complete, the next step is to make the video in the output Asset available to clients for playback. Pour ce faire, vous suivez deux étapes : commencez par créer un localisateur de streaming, puis générez les URL de streaming que les clients peuvent utiliser.You can make it available in two steps: first, create a Streaming Locator, and second, build the streaming URLs that clients can use.

Le processus de création d’un localisateur de streaming est appelée « publication ».The process of creating a Streaming Locator is called publishing. Par défaut, le localisateur de streaming est valide immédiatement après avoir effectué les appels d’API et dure jusqu’à ce qu’il soit supprimé, sauf si vous configurez les heures de début et de fin facultatives.By default, the Streaming Locator is valid immediately after you make the API calls, and lasts until it's deleted, unless you configure the optional start and end times.

Lors de la création d’un élément StreamingLocator, vous devez spécifier le nom StreamingPolicyName souhaité.When creating a StreamingLocator, you'll need to specify the desired StreamingPolicyName. Dans cet exemple, vous allez diffuser en continu du contenu en clair (ou non chiffré), la stratégie de diffusion en continu en clair prédéfinie (PredefinedStreamingPolicy.ClearStreamingOnly) est donc utilisée.In this example, you'll be streaming in-the-clear (or non-encrypted content) so the predefined clear streaming policy (PredefinedStreamingPolicy.ClearStreamingOnly) is used.

Important

Quand vous utilisez une stratégie de streaming personnalisée, vous devez concevoir un ensemble limité de ces stratégies pour votre compte Media Services et les réutiliser pour vos éléments StreamingLocators chaque fois que les mêmes protocoles et options de chiffrement sont nécessaires.When using a custom Streaming Policy, you should design a limited set of such policies for your Media Service account, and re-use them for your StreamingLocators whenever the same encryption options and protocols are needed. Votre compte Media Services a un quota en matière de nombre d’entrées de stratégie de streaming.Your Media Service account has a quota for the number of Streaming Policy entries. Vous ne devez pas créer de stratégie de streaming pour chaque localisateur de streaming.You shouldn't be creating a new Streaming Policy for each Streaming Locator.

Le code suivant suppose que vous appelez la fonction avec un locatorName unique.The following code assumes that you're calling the function with a unique locatorName.

private static async Task<StreamingLocator> CreateStreamingLocatorAsync(
    IAzureMediaServicesClient client,
    string resourceGroup,
    string accountName,
    string assetName,
    string locatorName)
{
    StreamingLocator locator = await client.StreamingLocators.CreateAsync(
        resourceGroup,
        accountName,
        locatorName,
        new StreamingLocator
        {
            AssetName = assetName,
            StreamingPolicyName = PredefinedStreamingPolicy.ClearStreamingOnly
        });

    return locator;
}

Tandis que l’exemple de cette rubrique traite de streaming, vous pouvez utiliser le même appel pour créer un localisateur de streaming pour la diffusion de contenu vidéo par le biais d’un téléchargement progressif.While the sample in this topic discusses streaming, you can use the same call to create a Streaming Locator for delivering video via progressive download.

Obtenir des URL de diffusion en continuGet streaming URLs

Maintenant que le localisateur de streaming a été créé, vous pouvez obtenir les URL de streaming, comme indiqué dans GetStreamingURLs.Now that the Streaming Locator has been created, you can get the streaming URLs, as shown in GetStreamingURLs. Pour générer une URL, vous devez concaténer le nom d’hôte du point de terminaison de streaming et le chemin du localisateur de streaming.To build a URL, you need to concatenate the Streaming Endpoint host name and the Streaming Locator path. Dans cet exemple, le point de terminaison de streaming par défaut est utilisé.In this sample, the default Streaming Endpoint is used. Quand vous créez pour la première fois un compte Media Services, ce point de terminaison de streaming par défaut est dans l’état Arrêté. Vous devez donc appeler Start.When you first create a Media Service account, this default Streaming Endpoint will be in a stopped state, so you need to call Start.

Notes

Dans cette méthode, vous avez besoin de la valeur locatorName qui a été utilisé lors de la création du localisateur de streaming pour l’actif multimédia de sortie.In this method, you need the locatorName that was used when creating the Streaming Locator for the output Asset.

private static async Task<IList<string>> GetStreamingUrlsAsync(
    IAzureMediaServicesClient client,
    string resourceGroupName,
    string accountName,
    String locatorName)
{
    const string DefaultStreamingEndpointName = "default";

    IList<string> streamingUrls = new List<string>();

    StreamingEndpoint streamingEndpoint = await client.StreamingEndpoints.GetAsync(resourceGroupName, accountName, DefaultStreamingEndpointName);

    if (streamingEndpoint != null)
    {
        if (streamingEndpoint.ResourceState != StreamingEndpointResourceState.Running)
        {
            await client.StreamingEndpoints.StartAsync(resourceGroupName, accountName, DefaultStreamingEndpointName);
        }
    }

    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];
        streamingUrls.Add(uriBuilder.ToString());
    }

    return streamingUrls;
}

Supprimer les ressources de votre compte Media ServicesClean up resources in your Media Services account

En règle générale, vous devez supprimer tous les éléments à l’exception des objets que vous envisagez de réutiliser (habituellement, vous réutilisez les transformations et conservez les éléments StreamingLocators, etc.).Generally, you should clean up everything except objects that you're planning to reuse (typically, you'll reuse Transforms, and you'll persist StreamingLocators, etc.). Si vous souhaitez que votre compte soit propre au terme de vos expériences, vous devez supprimer les ressources que vous n’envisagez pas de réutiliser.If you want your account to be clean after experimenting, delete the resources that you don't plan to reuse. Par exemple, le code suivant supprime les travaux :For example, the following code deletes Jobs:

private static async Task CleanUpAsync(
    IAzureMediaServicesClient client,
    string resourceGroupName,
    string accountName,
    string transformName)
{

    var jobs = await client.Jobs.ListAsync(resourceGroupName, accountName, transformName);
    foreach (var job in jobs)
    {
        await client.Jobs.DeleteAsync(resourceGroupName, accountName, transformName, job.Name);
    }

    var assets = await client.Assets.ListAsync(resourceGroupName, accountName);
    foreach (var asset in assets)
    {
        await client.Assets.DeleteAsync(resourceGroupName, accountName, asset.Name);
    }
}

Exécution de l'exemple d'applicationRun the sample app

  1. Appuyez sur Ctrl+F5 pour exécuter l’application EncodeAndStreamFiles.Press Ctrl+F5 to run the EncodeAndStreamFiles app.
  2. Copiez l’une des URL de diffusion en continu à partir de la console.Copy one of the streaming URLs from the console.

Cet exemple affiche les URL qui peuvent être utilisées pour lire la vidéo à l’aide de différents protocoles :This example displays URLs that can be used to play back the video using different protocols:

Exemple de sortie présentant des URL pour la diffusion en continu de vidéo Media Services

Tester l’URL de diffusion en continuTest the streaming URL

Pour tester la diffusion en continu, cet article utilise le lecteur multimédia Azure.To test the stream, this article uses Azure Media Player.

Notes

Si un lecteur est hébergé sur un site https, veillez à mettre à jour l’URL vers « https ».If a player is hosted on an https site, make sure to update the URL to "https".

  1. Ouvrez un navigateur web et accédez à https://aka.ms/azuremediaplayer/.Open a web browser and navigate to https://aka.ms/azuremediaplayer/.
  2. Dans le champ URL : , collez l’une des valeurs d’URL de diffusion en continu que vous avez obtenues lors de l’exécution de l’application.In the URL: box, paste one of the streaming URL values you got when you ran the app.
  3. Sélectionnez Update Player (Mettre à jour le lecteur) .Select Update Player.

Le lecteur multimédia Azure peut être utilisé pour effectuer des tests, mais ne doit pas être utilisé dans un environnement de production.Azure Media Player can be used for testing but shouldn't be used in a production environment.

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

MultithreadingMultithreading

Les kits de développement logiciel (SDK) Azure Media Services v3 ne sont pas thread-safe.The Azure Media Services v3 SDKs aren't thread-safe. Lorsque vous développez une application multithread, vous devez générer et utiliser un nouvel objet AzureMediaServicesClient par thread.When developing a multi-threaded app, you should generate and use a new AzureMediaServicesClient object per thread.

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

Maintenant que vous savez comment charger, encoder et diffuser en continu votre vidéo, consultez l’article suivant :Now that you know how to upload, encode, and stream your video, see the following article: