Tutoriel : Chiffrer la vidéo avec AES-128 et utiliser le service de distribution de clésTutorial: Encrypt video with AES-128 and use the key delivery service

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

Vous pouvez utiliser Media Services pour transmettre du contenu HTTP Live Streaming (HLS), MPEG-DASH et Smooth Streaming chiffré avec AES à l’aide de clés de chiffrement 128 bits.You can use Media Services to deliver HTTP Live Streaming (HLS), MPEG-DASH, and Smooth Streaming encrypted with the AES by using 128-bit encryption keys. Media Services assure également le service de distribution des clés qui fournit des clés de chiffrement aux utilisateurs autorisés.Media Services also provides the key delivery service that delivers encryption keys to authorized users. Si vous souhaitez que Media Services chiffre dynamiquement votre vidéo, associez une clé de chiffrement au localisateur de streaming et configurez la stratégie de clé de contenu.If you want for Media Services to dynamically encrypt your video, you associate the encryption key with a Streaming Locator and also configure the content key policy. Lorsqu’un lecteur demande un flux de données, Media Services utilise la clé spécifiée pour chiffrer dynamiquement votre contenu avec AES-128.When a stream is requested by a player, Media Services uses the specified key to dynamically encrypt your content with AES-128. Pour déchiffrer le flux de données, le lecteur demande la clé au service de remise de clé.To decrypt the stream, the player requests the key from the key delivery service. Pour déterminer si l’utilisateur est autorisé à obtenir la clé, le service évalue la stratégie de clé de contenu que vous avez spécifiée pour la clé.To determine whether the user is authorized to get the key, the service evaluates the content key policy that you specified for the key.

Vous pouvez chiffrer chaque ressource avec plusieurs types de chiffrement (AES-128, PlayReady, Widevine, FairPlay).You can encrypt each asset with multiple encryption types (AES-128, PlayReady, Widevine, FairPlay). Consultez les protocoles de diffusion en continu et les types de chiffrement pour identifier la meilleure combinaison.See Streaming protocols and encryption types, to see what makes sense to combine. Consultez aussi Protéger avec DRM.Also, see How to protect with DRM.

La sortie de l’exemple de cet article inclut une URL menant au lecteur multimédia Azure, l'URL du manifeste et le jeton AES nécessaires pour lire le contenu.The output from the sample this article includes a URL to the Azure Media Player, manifest URL, and the AES token needed to play back the content. L’exemple définit l’expiration du jeton JSON Web Token (JWT) sur 1 heure.The sample sets the expiration of the JSON Web Token (JWT) token to 1 hour. Vous pouvez ouvrir un navigateur et coller l’URL obtenue pour lancer la page de démonstration du lecteur multimédia Azure avec l’URL et le jeton déjà renseignés pour vous au format suivant : https://ampdemo.azureedge.net/?url= {dash Manifest URL} &aes=true&aestoken=Bearer%3D{ JWT Token here}.You can open a browser and paste the resulting URL to launch the Azure Media Player demo page with the URL and token filled out for you already in the following format: https://ampdemo.azureedge.net/?url= {dash Manifest URL} &aes=true&aestoken=Bearer%3D{ JWT Token here}.

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

  • Téléchargez l'exemple EncryptWithAES décrit dans l’article.Download the EncryptWithAES sample described in the article.
  • Commencez à utiliser les API Media Services avec le SDK .NET.Start using Media Services APIs with .NET SDK.
  • Créez une ressource de sortie.Create an output asset.
  • Créer un encodage de transformation.Create an encoding Transform.
  • Soumettez un travail.Submit a Job.
  • Attendez la fin du travail.Wait for the Job to complete.
  • Créer une stratégie de clé de contenuCreate a Content Key Policy
  • Configurez la stratégie pour utiliser la restriction par jeton JWT.Configure the policy to use JWT token restriction.
  • Créez un localisateur de streaming.Create a Streaming Locator.
  • Configurez le localisateur de streaming pour chiffrer la vidéo avec AES (ClearKey).Configure the Streaming Locator to encrypt the video with AES (ClearKey).
  • Obtenez un test de jeton.Get a test token.
  • Créez une URL de diffusion en continu.Build a 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

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

Télécharger le codeDownload code

Clonez un dépôt GitHub qui contient l’exemple .NET complet abordé dans cet article sur votre machine avec la commande suivante :Clone a GitHub repository that contains the full .NET sample discussed in this article to your machine using the following command:

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

L’exemple de chiffrement avec AES-128 se trouve dans le dossier EncryptWithAES.The "Encrypt with AES-128" sample is located in the EncryptWithAES folder.

Notes

L’exemple crée des ressources uniques chaque fois que vous exécutez l’application.The sample creates unique resources every time you run the app. En règle générale, vous réutilisez les ressources existantes telles que les transformations et les stratégies (si une ressource existante a des configurations requises).Typically, you'll reuse existing resources like transforms and policies (if existing resource have required configurations).

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, créez un objet AzureMediaServicesClient.To start using Media Services APIs with .NET, 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 the 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 de sortieCreate an output asset

La ressource de sortie stocke le résultat de votre travail d’encodage.The output Asset stores the result of your encoding job.

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

Obtenir ou créer un encodage de transformationGet or create an encoding Transform

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, puis 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 autogenerated bitrate ladder (bitrate-resolution pairs) based on the input resolution and bitrate, and then produces ISO MP4 files with H.264 video and AAC audio corresponding to each bitrate-resolution pair.

Avant de créer une transformation, vérifiez tout d’abord s’il en existe déjà une à l’aide de la méthode Get, comme indiqué dans le code suivant.Before creating a new Transform, 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;
}

Envoi du travailSubmit Job

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 ce tutoriel, nous créons l’entrée du travail à partir d’un fichier qui est ingéré directement depuis une URL HTTPS source.In this tutorial, we create the job's input based on a file that's ingested directly from an HTTPs source URL.

private static async Task<Job> SubmitJobAsync(IAzureMediaServicesClient client,
    string resourceGroup,
    string accountName,
    string transformName,
    string outputAssetName,
    string jobName)
{
    // This example shows how to encode from any HTTPs source URL - a new feature of the v3 API.  
    // Change the URL to any accessible HTTPs URL or SAS URL from Azure.
    JobInputHttp jobInput =
        new JobInputHttp(files: new[] { "https://nimbuscdn-nimbuspm.streaming.mediaservices.windows.net/2b533311-b215-4409-80af-529c3e853622/Ignite-short.mp4" });

    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(
        resourceGroup,
        accountName,
        transformName,
        jobName,
        new Job
        {
            Input = jobInput,
            Outputs = jobOutputs,
        });

    return job;
}

Attendre la fin du travailWait for the Job to complete

Ce travail prend un certain temps.The job takes some time to complete. Vous voulez être averti de la fin du travail.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. Pour plus d’informations, consultez Router des événements vers un point de terminaison web personnalisé.For more information, 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 come across 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 = 20 * 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;
}

Créer une stratégie de clé de contenuCreate a Content Key Policy

Une clé de contenu fournit un accès sécurisé à vos éléments multimédias.A content key provides secure access to your Assets. Vous devez créer une stratégie de clé de contenu qui configure le mode de remise de la clé de contenu pour les clients finaux.You need to create a Content Key Policy that configures how the content key is delivered to end clients. La clé de contenu est associée au localisateur de streaming.The content key is associated with the Streaming Locator. Media Services assure également le service de distribution des clés qui fournit des clés de chiffrement aux utilisateurs autorisés.Media Services also provides the key delivery service that delivers encryption keys to authorized users.

Lorsqu’un lecteur demande un flux de données, Media Services utilise la clé spécifiée pour chiffrer dynamiquement votre contenu (dans ce cas, à l’aide du chiffrement AES). Pour déchiffrer le flux de données, le lecteur demande la clé au service de remise de clé.When a stream is requested by a player, Media Services uses the specified key to dynamically encrypt your content (in this case, by using AES encryption.) To decrypt the stream, the player requests the key from the key delivery service. Pour déterminer si l’utilisateur est autorisé à obtenir la clé, le service évalue la stratégie de clé de contenu que vous avez spécifiée pour la clé.To determine whether the user is authorized to get the key, the service evaluates the content key policy that you specified for the key.

private static async Task<ContentKeyPolicy> GetOrCreateContentKeyPolicyAsync(
    IAzureMediaServicesClient client,
    string resourceGroupName,
    string accountName,
    string contentKeyPolicyName)
{
    ContentKeyPolicy policy = await client.ContentKeyPolicies.GetAsync(resourceGroupName, accountName, contentKeyPolicyName);

    if (policy == null)
    {

        ContentKeyPolicySymmetricTokenKey primaryKey = new ContentKeyPolicySymmetricTokenKey(TokenSigningKey);
        List<ContentKeyPolicyRestrictionTokenKey> alternateKeys = null;
        List<ContentKeyPolicyTokenClaim> requiredClaims = new List<ContentKeyPolicyTokenClaim>()
        {
            ContentKeyPolicyTokenClaim.ContentKeyIdentifierClaim
        };

        List<ContentKeyPolicyOption> options = new List<ContentKeyPolicyOption>()
        {
            new ContentKeyPolicyOption(
                new ContentKeyPolicyClearKeyConfiguration(),
                new ContentKeyPolicyTokenRestriction(Issuer, Audience, primaryKey,
                    ContentKeyPolicyRestrictionTokenType.Jwt, alternateKeys, requiredClaims))
        };

        // Since we are randomly generating the signing key each time, make sure to create or update the policy each time.
        // Normally you would use a long lived key so you would just check for the policies existence with Get instead of
        // ensuring to create or update it each time.
        policy = await client.ContentKeyPolicies.CreateOrUpdateAsync(resourceGroupName, accountName, contentKeyPolicyName, options);

    }

    return policy;
}

Créer un localisateur de streamingCreate a Streaming Locator

Une fois l’encodage terminé, et la stratégie de clé de contenu configurée, 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, and the content key policy is set, the next step is to make the video in the output Asset available to clients for playback. Vous rendez la vidéo disponible en deux étapes :You make the video available in two steps:

  1. Créez un localisateur de streaming.Create a Streaming Locator.
  2. Générez les URL de streaming que les clients peuvent utiliser.Build the streaming URLs that clients can use.

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

Lors de la création d’un élément Streaming Locator, vous devrez spécifier le nom StreamingPolicyName souhaité.When creating a Streaming Locator, you'll need to specify the desired StreamingPolicyName. Dans ce tutoriel, nous utilisons un des éléments PredefinedStreamingPolicies, ce qui indique à Azure Media Services comment publier le contenu en vue de la diffusion en continu.In this tutorial, we're using one of the PredefinedStreamingPolicies, which tells Azure Media Services how to publish the content for streaming. Dans cet exemple, le chiffrement AES Envelope est appliqué (ce chiffrement est également appelé chiffrement ClearKey, car la clé est envoyée au client de la lecture via HTTPS et pas une licence DRM).In this example, the AES Envelope encryption is applied (this encryption is also known as ClearKey encryption because the key is delivered to the playback client via HTTPS and not a DRM license).

Important

Lorsque vous utilisez une stratégie StreamingPolicy 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 StreamingPolicy, you should design a limited set of such policies for your Media Service account, and re-use them for your Streaming Locators 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 StreamingPolicy.Your Media Service account has a quota for the number of StreamingPolicy entries. Vous ne devez pas créer de stratégie de streaming pour chaque localisateur de streaming.You shouldn't be creating a new StreamingPolicy for each Streaming Locator.

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

    return locator;
}

Obtenir un test de jetonGet a test token

Dans ce didacticiel, nous spécifions que la stratégie de clé de contenu a une restriction au niveau du jeton.In this tutorial, we specify for the content key policy to have a token restriction. La stratégie de restriction à jeton doit être accompagnée d’un jeton émis par un service d’émission de jeton de sécurité (STS).The token-restricted policy must be accompanied by a token issued by a security token service (STS). Media Services prend en charge les jetons aux formats JWT, et c’est ce qui est configuré dans cet exemple.Media Services supports tokens in the JWT format and that's what we configure in the sample.

L’élément ContentKeyIdentifierClaim est utilisé dans la Stratégie de clé de contenu, ce qui signifie que le jeton présenté au service de remise de clé doit contenir l’identificateur de la clé de contenu.The ContentKeyIdentifierClaim is used in the Content Key Policy, which means that the token presented to the Key Delivery service must have the identifier of the content key in it. Dans l’exemple, nous ne spécifions pas de clé de contenu lors de la création du localisateur de streaming. Le système en crée une de manière aléatoire pour nous.In the sample, we didn't specify a content key when creating the Streaming Locator, the system created a random one for us. Pour générer le jeton de test, nous devons obtenir l’élément ContentKeyId à placer dans la revendication ContentKeyIdentifierClaim.To generate the test token, we must get the ContentKeyId to put in the ContentKeyIdentifierClaim claim.

private static string GetTokenAsync(string issuer, string audience, string keyIdentifier, byte[] tokenVerificationKey)
{
    var tokenSigningKey = new SymmetricSecurityKey(tokenVerificationKey);

    SigningCredentials cred = new SigningCredentials(
        tokenSigningKey,
        // Use the  HmacSha256 and not the HmacSha256Signature option, or the token will not work!
        SecurityAlgorithms.HmacSha256,
        SecurityAlgorithms.Sha256Digest);

    Claim[] claims = new Claim[]
    {
        new Claim(ContentKeyPolicyTokenClaim.ContentKeyIdentifierClaim.ClaimType, keyIdentifier)
    };

    JwtSecurityToken token = new JwtSecurityToken(
        issuer: issuer,
        audience: audience,
        claims: claims,
        notBefore: DateTime.Now.AddMinutes(-5),
        expires: DateTime.Now.AddMinutes(60),
        signingCredentials: cred);

    JwtSecurityTokenHandler handler = new JwtSecurityTokenHandler();

    return handler.WriteToken(token);
}

Générer une URL de diffusion en continu DASHBuild a DASH streaming URL

Maintenant que le localisateur de streaming a été créé, vous pouvez obtenir les URL de diffusion en continu.Now that the Streaming Locator has been created, you can get the streaming URLs. Pour générer une URL, vous devez concaténer le nom d’hôte StreamingEndpoint et le chemin d’accès du localisateur de streaming.To build a URL, you need to concatenate the StreamingEndpoint 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.

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

    string dashPath = "";

    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;

        // Look for just the DASH path and generate a URL for the Azure Media Player to playback the content with the AES token to decrypt.
        // Note that the JWT token is set to expire in 1 hour. 
        if (path.StreamingProtocol == StreamingPolicyStreamingProtocol.Dash)
        {
            uriBuilder.Path = path.Paths[0];

            dashPath = uriBuilder.ToString();

        }
    }

    return dashPath;
}

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, les localisateurs de streaming, etc.).Generally, you should clean up everything except objects that you're planning to reuse (typically, you'll reuse Transforms, Streaming Locators, and so on). Si vous voulez que votre compte soit propre après les expériences, supprimez les ressources dont vous n’avez plus besoin.If you want for 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,
    string contentKeyPolicyName,
    List<string> assetNames,
    string jobName)
{
    await client.Jobs.DeleteAsync(resourceGroupName, accountName, transformName, jobName);

    foreach (var assetName in assetNames)
    {
        await client.Assets.DeleteAsync(resourceGroupName, accountName, assetName);
    }

    client.ContentKeyPolicies.Delete(resourceGroupName, accountName, contentKeyPolicyName);
}

Nettoyer les 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

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.

Remarques supplémentairesAdditional notes

  • Widevine est un service fourni par Google Inc. soumis aux conditions de service et à la politique de confidentialité de Google, Inc.Widevine is a service provided by Google Inc. and subject to the terms of service and Privacy Policy of Google, Inc.

Étapes suivantesNext steps