你当前正在访问 Microsoft Azure Global Edition 技术文档网站。 如果需要访问由世纪互联运营的 Microsoft Azure 中国技术文档网站，请访问 https://docs.azure.cn。

Streaming Policies - List

Service:

Media Services

API Version:

2022-08-01

列出流式处理策略
Lists帐户中的流式处理策略

GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaServices/{accountName}/streamingPolicies?api-version=2022-08-01

With optional parameters:

GET https://management.azure.com/subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.Media/mediaServices/{accountName}/streamingPolicies?api-version=2022-08-01&$filter={$filter}&$top={$top}&$orderby={$orderby}

URI 参数

名称	在	必需	类型	说明
accountName	path	True	string	媒体服务帐户名称。
resourceGroupName	path	True	string	Azure 订阅中的资源组的名称。
subscriptionId	path	True	string	Microsoft Azure 订阅的唯一标识符。
api-version	query	True	string	要与客户端请求一起使用的 API 版本。
$filter	query		string	限制返回的项集。
$orderby	query		string	指定结果集合的排序依据的键。
$top	query		integer int32	指定一个非负整数 n，用于限制从集合返回的项数。 服务返回的可用项数最多不超过指定值 n。。

响应

名称	类型	说明
200 OK	StreamingPolicyCollection	确定
Other Status Codes	ErrorResponse	详细的错误信息。

示例

Lists Streaming Policies

Sample Request

HTTP

GET https://management.azure.com/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/contosorg/providers/Microsoft.Media/mediaServices/contosomedia/streamingPolicies?api-version=2022-08-01

Java

/** Samples for StreamingPolicies List. */
public final class Main {
    /*
     * x-ms-original-file: specification/mediaservices/resource-manager/Microsoft.Media/Metadata/stable/2022-08-01/examples/streaming-policies-list.json
     */
    /**
     * Sample code: Lists Streaming Policies.
     *
     * @param manager Entry point to MediaServicesManager.
     */
    public static void listsStreamingPolicies(com.azure.resourcemanager.mediaservices.MediaServicesManager manager) {
        manager
            .streamingPolicies()
            .list("contosorg", "contosomedia", null, null, null, com.azure.core.util.Context.NONE);
    }
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Python

from azure.identity import DefaultAzureCredential
from azure.mgmt.media import AzureMediaServices

"""
# PREREQUISITES
    pip install azure-identity
    pip install azure-mgmt-media
# USAGE
    python streamingpolicieslist.py

    Before run the sample, please set the values of the client ID, tenant ID and client secret
    of the AAD application as environment variables: AZURE_CLIENT_ID, AZURE_TENANT_ID,
    AZURE_CLIENT_SECRET. For more info about how to get the value, please see:
    https://docs.microsoft.com/azure/active-directory/develop/howto-create-service-principal-portal
"""


def main():
    client = AzureMediaServices(
        credential=DefaultAzureCredential(),
        subscription_id="00000000-0000-0000-0000-000000000000",
    )

    response = client.streaming_policies.list(
        resource_group_name="contoso",
        account_name="contosomedia",
    )
    for item in response:
        print(item)


# x-ms-original-file: specification/mediaservices/resource-manager/Microsoft.Media/Metadata/stable/2022-08-01/examples/streaming-policies-list.json
if __name__ == "__main__":
    main()

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Go

package armmediaservices_test

import (
	"context"
	"log"

	"github.com/Azure/azure-sdk-for-go/sdk/azidentity"
	"github.com/Azure/azure-sdk-for-go/sdk/resourcemanager/mediaservices/armmediaservices/v3"
)

// Generated from example definition: https://github.com/Azure/azure-rest-api-specs/blob/e7bf3adfa2d5e5cdbb804eec35279501794f461c/specification/mediaservices/resource-manager/Microsoft.Media/Metadata/stable/2022-08-01/examples/streaming-policies-list.json
func ExampleStreamingPoliciesClient_NewListPager() {
	cred, err := azidentity.NewDefaultAzureCredential(nil)
	if err != nil {
		log.Fatalf("failed to obtain a credential: %v", err)
	}
	ctx := context.Background()
	clientFactory, err := armmediaservices.NewClientFactory("<subscription-id>", cred, nil)
	if err != nil {
		log.Fatalf("failed to create client: %v", err)
	}
	pager := clientFactory.NewStreamingPoliciesClient().NewListPager("contoso", "contosomedia", &armmediaservices.StreamingPoliciesClientListOptions{Filter: nil,
		Top:     nil,
		Orderby: nil,
	})
	for pager.More() {
		page, err := pager.NextPage(ctx)
		if err != nil {
			log.Fatalf("failed to advance page: %v", err)
		}
		for _, v := range page.Value {
			// You could use page here. We use blank identifier for just demo purposes.
			_ = v
		}
		// If the HTTP response code is 200 as defined in example definition, your page structure would look as follows. Please pay attention that all the values in the output are fake values for just demo purposes.
		// page.StreamingPolicyCollection = armmediaservices.StreamingPolicyCollection{
		// 	Value: []*armmediaservices.StreamingPolicy{
		// 		{
		// 			Name: to.Ptr("clearStreamingPolicy"),
		// 			Type: to.Ptr("Microsoft.Media/mediaservices/streamingPolicies"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/contoso/providers/Microsoft.Media/mediaservices/contosomedia/streamingPolicies/clearStreamingPolicy"),
		// 			Properties: &armmediaservices.StreamingPolicyProperties{
		// 				Created: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-08-08T18:29:30.676Z"); return t}()),
		// 				NoEncryption: &armmediaservices.NoEncryption{
		// 					EnabledProtocols: &armmediaservices.EnabledProtocols{
		// 						Dash: to.Ptr(true),
		// 						Download: to.Ptr(true),
		// 						Hls: to.Ptr(true),
		// 						SmoothStreaming: to.Ptr(true),
		// 					},
		// 				},
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("secureStreamingPolicy"),
		// 			Type: to.Ptr("Microsoft.Media/mediaservices/streamingPolicies"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/contoso/providers/Microsoft.Media/mediaservices/contosomedia/streamingPolicies/secureStreamingPolicy"),
		// 			Properties: &armmediaservices.StreamingPolicyProperties{
		// 				CommonEncryptionCbcs: &armmediaservices.CommonEncryptionCbcs{
		// 					ClearTracks: []*armmediaservices.TrackSelection{
		// 					},
		// 					ContentKeys: &armmediaservices.StreamingPolicyContentKeys{
		// 						DefaultKey: &armmediaservices.DefaultKey{
		// 							Label: to.Ptr("cbcsDefaultKey"),
		// 						},
		// 						KeyToTrackMappings: []*armmediaservices.StreamingPolicyContentKey{
		// 						},
		// 					},
		// 					Drm: &armmediaservices.CbcsDrmConfiguration{
		// 						FairPlay: &armmediaservices.StreamingPolicyFairPlayConfiguration{
		// 							AllowPersistentLicense: to.Ptr(true),
		// 							CustomLicenseAcquisitionURLTemplate: to.Ptr("https://contoso.com/{AssetAlternativeId}/fairplay/{ContentKeyId}"),
		// 						},
		// 					},
		// 					EnabledProtocols: &armmediaservices.EnabledProtocols{
		// 						Dash: to.Ptr(false),
		// 						Download: to.Ptr(false),
		// 						Hls: to.Ptr(true),
		// 						SmoothStreaming: to.Ptr(false),
		// 					},
		// 				},
		// 				CommonEncryptionCenc: &armmediaservices.CommonEncryptionCenc{
		// 					ClearTracks: []*armmediaservices.TrackSelection{
		// 						{
		// 							TrackSelections: []*armmediaservices.TrackPropertyCondition{
		// 								{
		// 									Operation: to.Ptr(armmediaservices.TrackPropertyCompareOperationUnknown),
		// 									Property: to.Ptr(armmediaservices.TrackPropertyTypeFourCC),
		// 									Value: to.Ptr("hev1"),
		// 							}},
		// 					}},
		// 					ContentKeys: &armmediaservices.StreamingPolicyContentKeys{
		// 						DefaultKey: &armmediaservices.DefaultKey{
		// 							Label: to.Ptr("cencDefaultKey"),
		// 						},
		// 						KeyToTrackMappings: []*armmediaservices.StreamingPolicyContentKey{
		// 						},
		// 					},
		// 					Drm: &armmediaservices.CencDrmConfiguration{
		// 						PlayReady: &armmediaservices.StreamingPolicyPlayReadyConfiguration{
		// 							CustomLicenseAcquisitionURLTemplate: to.Ptr("https://contoso.com/{AssetAlternativeId}/playready/{ContentKeyId}"),
		// 							PlayReadyCustomAttributes: to.Ptr("PlayReady CustomAttributes"),
		// 						},
		// 						Widevine: &armmediaservices.StreamingPolicyWidevineConfiguration{
		// 							CustomLicenseAcquisitionURLTemplate: to.Ptr("https://contoso.com/{AssetAlternativeId}/widevine/{ContentKeyId"),
		// 						},
		// 					},
		// 					EnabledProtocols: &armmediaservices.EnabledProtocols{
		// 						Dash: to.Ptr(true),
		// 						Download: to.Ptr(false),
		// 						Hls: to.Ptr(false),
		// 						SmoothStreaming: to.Ptr(true),
		// 					},
		// 				},
		// 				Created: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-08-08T18:29:30.678Z"); return t}()),
		// 				DefaultContentKeyPolicyName: to.Ptr("PolicyWithMultipleOptions"),
		// 				EnvelopeEncryption: &armmediaservices.EnvelopeEncryption{
		// 					ClearTracks: []*armmediaservices.TrackSelection{
		// 					},
		// 					ContentKeys: &armmediaservices.StreamingPolicyContentKeys{
		// 						DefaultKey: &armmediaservices.DefaultKey{
		// 							Label: to.Ptr("aesDefaultKey"),
		// 						},
		// 						KeyToTrackMappings: []*armmediaservices.StreamingPolicyContentKey{
		// 						},
		// 					},
		// 					CustomKeyAcquisitionURLTemplate: to.Ptr("https://contoso.com/{AssetAlternativeId}/envelope/{ContentKeyId}"),
		// 					EnabledProtocols: &armmediaservices.EnabledProtocols{
		// 						Dash: to.Ptr(true),
		// 						Download: to.Ptr(false),
		// 						Hls: to.Ptr(true),
		// 						SmoothStreaming: to.Ptr(true),
		// 					},
		// 				},
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("secureStreamingPolicyWithCommonEncryptionCbcsOnly"),
		// 			Type: to.Ptr("Microsoft.Media/mediaservices/streamingPolicies"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/contoso/providers/Microsoft.Media/mediaservices/contosomedia/streamingPolicies/secureStreamingPolicyWithCommonEncryptionCbcsOnly"),
		// 			Properties: &armmediaservices.StreamingPolicyProperties{
		// 				CommonEncryptionCbcs: &armmediaservices.CommonEncryptionCbcs{
		// 					ClearTracks: []*armmediaservices.TrackSelection{
		// 					},
		// 					ContentKeys: &armmediaservices.StreamingPolicyContentKeys{
		// 						DefaultKey: &armmediaservices.DefaultKey{
		// 							Label: to.Ptr("cbcsDefaultKey"),
		// 						},
		// 						KeyToTrackMappings: []*armmediaservices.StreamingPolicyContentKey{
		// 						},
		// 					},
		// 					Drm: &armmediaservices.CbcsDrmConfiguration{
		// 						FairPlay: &armmediaservices.StreamingPolicyFairPlayConfiguration{
		// 							AllowPersistentLicense: to.Ptr(true),
		// 							CustomLicenseAcquisitionURLTemplate: to.Ptr("https://contoso.com/{AssetAlternativeId}/fairplay/{ContentKeyId}"),
		// 						},
		// 					},
		// 					EnabledProtocols: &armmediaservices.EnabledProtocols{
		// 						Dash: to.Ptr(false),
		// 						Download: to.Ptr(false),
		// 						Hls: to.Ptr(true),
		// 						SmoothStreaming: to.Ptr(false),
		// 					},
		// 				},
		// 				Created: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-08-08T18:29:30.678Z"); return t}()),
		// 				DefaultContentKeyPolicyName: to.Ptr("PolicyWithMultipleOptions"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("secureStreamingPolicyWithCommonEncryptionCencOnly"),
		// 			Type: to.Ptr("Microsoft.Media/mediaservices/streamingPolicies"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/contoso/providers/Microsoft.Media/mediaservices/contosomedia/streamingPolicies/secureStreamingPolicyWithCommonEncryptionCencOnly"),
		// 			Properties: &armmediaservices.StreamingPolicyProperties{
		// 				CommonEncryptionCenc: &armmediaservices.CommonEncryptionCenc{
		// 					ClearTracks: []*armmediaservices.TrackSelection{
		// 						{
		// 							TrackSelections: []*armmediaservices.TrackPropertyCondition{
		// 								{
		// 									Operation: to.Ptr(armmediaservices.TrackPropertyCompareOperationUnknown),
		// 									Property: to.Ptr(armmediaservices.TrackPropertyTypeFourCC),
		// 									Value: to.Ptr("hev1"),
		// 							}},
		// 					}},
		// 					ContentKeys: &armmediaservices.StreamingPolicyContentKeys{
		// 						DefaultKey: &armmediaservices.DefaultKey{
		// 							Label: to.Ptr("cencDefaultKey"),
		// 						},
		// 						KeyToTrackMappings: []*armmediaservices.StreamingPolicyContentKey{
		// 						},
		// 					},
		// 					Drm: &armmediaservices.CencDrmConfiguration{
		// 						PlayReady: &armmediaservices.StreamingPolicyPlayReadyConfiguration{
		// 							CustomLicenseAcquisitionURLTemplate: to.Ptr("https://contoso.com/{AssetAlternativeId}/playready/{ContentKeyId}"),
		// 							PlayReadyCustomAttributes: to.Ptr("PlayReady CustomAttributes"),
		// 						},
		// 						Widevine: &armmediaservices.StreamingPolicyWidevineConfiguration{
		// 							CustomLicenseAcquisitionURLTemplate: to.Ptr("https://contoso.com/{AssetAlternativeId}/widevine/{ContentKeyId"),
		// 						},
		// 					},
		// 					EnabledProtocols: &armmediaservices.EnabledProtocols{
		// 						Dash: to.Ptr(true),
		// 						Download: to.Ptr(false),
		// 						Hls: to.Ptr(false),
		// 						SmoothStreaming: to.Ptr(true),
		// 					},
		// 				},
		// 				Created: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-08-08T18:29:30.678Z"); return t}()),
		// 				DefaultContentKeyPolicyName: to.Ptr("PolicyWithMultipleOptions"),
		// 			},
		// 		},
		// 		{
		// 			Name: to.Ptr("secureStreamingPolicyWithEnvelopeEncryptionOnly"),
		// 			Type: to.Ptr("Microsoft.Media/mediaservices/streamingPolicies"),
		// 			ID: to.Ptr("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/contoso/providers/Microsoft.Media/mediaservices/contosomedia/streamingPolicies/secureStreamingPolicyWithEnvelopeEncryptionOnly"),
		// 			Properties: &armmediaservices.StreamingPolicyProperties{
		// 				Created: to.Ptr(func() time.Time { t, _ := time.Parse(time.RFC3339Nano, "2018-08-08T18:29:30.678Z"); return t}()),
		// 				DefaultContentKeyPolicyName: to.Ptr("PolicyWithClearKeyOptionAndTokenRestriction"),
		// 				EnvelopeEncryption: &armmediaservices.EnvelopeEncryption{
		// 					ClearTracks: []*armmediaservices.TrackSelection{
		// 					},
		// 					ContentKeys: &armmediaservices.StreamingPolicyContentKeys{
		// 						DefaultKey: &armmediaservices.DefaultKey{
		// 							Label: to.Ptr("aesDefaultKey"),
		// 						},
		// 						KeyToTrackMappings: []*armmediaservices.StreamingPolicyContentKey{
		// 						},
		// 					},
		// 					CustomKeyAcquisitionURLTemplate: to.Ptr("https://contoso.com/{AssetAlternativeId}/envelope/{ContentKeyId}"),
		// 					EnabledProtocols: &armmediaservices.EnabledProtocols{
		// 						Dash: to.Ptr(true),
		// 						Download: to.Ptr(false),
		// 						Hls: to.Ptr(true),
		// 						SmoothStreaming: to.Ptr(true),
		// 					},
		// 				},
		// 			},
		// 	}},
		// }
	}
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

JavaScript

const { AzureMediaServices } = require("@azure/arm-mediaservices");
const { DefaultAzureCredential } = require("@azure/identity");

/**
 * This sample demonstrates how to Lists the Streaming Policies in the account
 *
 * @summary Lists the Streaming Policies in the account
 * x-ms-original-file: specification/mediaservices/resource-manager/Microsoft.Media/Metadata/stable/2022-08-01/examples/streaming-policies-list.json
 */
async function listsStreamingPolicies() {
  const subscriptionId =
    process.env["MEDIASERVICES_SUBSCRIPTION_ID"] || "00000000-0000-0000-0000-000000000000";
  const resourceGroupName = process.env["MEDIASERVICES_RESOURCE_GROUP"] || "contoso";
  const accountName = "contosomedia";
  const credential = new DefaultAzureCredential();
  const client = new AzureMediaServices(credential, subscriptionId);
  const resArray = new Array();
  for await (let item of client.streamingPolicies.list(resourceGroupName, accountName)) {
    resArray.push(item);
  }
  console.log(resArray);
}

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

dotnet

using System;
using System.Threading.Tasks;
using Azure;
using Azure.Core;
using Azure.Identity;
using Azure.ResourceManager;
using Azure.ResourceManager.Media;
using Azure.ResourceManager.Media.Models;

// Generated from example definition: specification/mediaservices/resource-manager/Microsoft.Media/Metadata/stable/2022-08-01/examples/streaming-policies-list.json
// this example is just showing the usage of "StreamingPolicies_List" operation, for the dependent resources, they will have to be created separately.

// get your azure access token, for more details of how Azure SDK get your access token, please refer to https://learn.microsoft.com/en-us/dotnet/azure/sdk/authentication?tabs=command-line
TokenCredential cred = new DefaultAzureCredential();
// authenticate your client
ArmClient client = new ArmClient(cred);

// this example assumes you already have this MediaServicesAccountResource created on azure
// for more information of creating MediaServicesAccountResource, please refer to the document of MediaServicesAccountResource
string subscriptionId = "00000000-0000-0000-0000-000000000000";
string resourceGroupName = "contoso";
string accountName = "contosomedia";
ResourceIdentifier mediaServicesAccountResourceId = MediaServicesAccountResource.CreateResourceIdentifier(subscriptionId, resourceGroupName, accountName);
MediaServicesAccountResource mediaServicesAccount = client.GetMediaServicesAccountResource(mediaServicesAccountResourceId);

// get the collection of this StreamingPolicyResource
StreamingPolicyCollection collection = mediaServicesAccount.GetStreamingPolicies();

// invoke the operation and iterate over the result
await foreach (StreamingPolicyResource item in collection.GetAllAsync())
{
    // the variable item is a resource, you could call other operations on this instance as well
    // but just for demo, we get its data from this resource instance
    StreamingPolicyData resourceData = item.Data;
    // for demo we just print out the id
    Console.WriteLine($"Succeeded on id: {resourceData.Id}");
}

Console.WriteLine($"Succeeded");

To use the Azure SDK library in your project, see this documentation. To provide feedback on this code sample, open a GitHub issue

Sample Response

Status code:

200

{
  "value": [
    {
      "name": "clearStreamingPolicy",
      "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/contosorg/providers/Microsoft.Media/mediaservices/contosomedia/streamingPolicies/clearStreamingPolicy",
      "type": "Microsoft.Media/mediaservices/streamingPolicies",
      "properties": {
        "created": "2018-08-08T18:29:30.676067Z",
        "noEncryption": {
          "enabledProtocols": {
            "download": true,
            "dash": true,
            "hls": true,
            "smoothStreaming": true
          }
        }
      }
    },
    {
      "name": "secureStreamingPolicy",
      "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/contosorg/providers/Microsoft.Media/mediaservices/contosomedia/streamingPolicies/secureStreamingPolicy",
      "type": "Microsoft.Media/mediaservices/streamingPolicies",
      "properties": {
        "created": "2018-08-08T18:29:30.6781134Z",
        "defaultContentKeyPolicyName": "PolicyWithMultipleOptions",
        "envelopeEncryption": {
          "enabledProtocols": {
            "download": false,
            "dash": true,
            "hls": true,
            "smoothStreaming": true
          },
          "clearTracks": [],
          "contentKeys": {
            "defaultKey": {
              "label": "aesDefaultKey"
            },
            "keyToTrackMappings": []
          },
          "customKeyAcquisitionUrlTemplate": "https://contoso.com/{AssetAlternativeId}/envelope/{ContentKeyId}"
        },
        "commonEncryptionCenc": {
          "enabledProtocols": {
            "download": false,
            "dash": true,
            "hls": false,
            "smoothStreaming": true
          },
          "clearTracks": [
            {
              "trackSelections": [
                {
                  "property": "FourCC",
                  "operation": "Unknown",
                  "value": "hev1"
                }
              ]
            }
          ],
          "contentKeys": {
            "defaultKey": {
              "label": "cencDefaultKey"
            },
            "keyToTrackMappings": []
          },
          "drm": {
            "playReady": {
              "customLicenseAcquisitionUrlTemplate": "https://contoso.com/{AssetAlternativeId}/playready/{ContentKeyId}",
              "playReadyCustomAttributes": "PlayReady CustomAttributes"
            },
            "widevine": {
              "customLicenseAcquisitionUrlTemplate": "https://contoso.com/{AssetAlternativeId}/widevine/{ContentKeyId"
            }
          }
        },
        "commonEncryptionCbcs": {
          "enabledProtocols": {
            "download": false,
            "dash": false,
            "hls": true,
            "smoothStreaming": false
          },
          "clearTracks": [],
          "contentKeys": {
            "defaultKey": {
              "label": "cbcsDefaultKey"
            },
            "keyToTrackMappings": []
          },
          "drm": {
            "fairPlay": {
              "customLicenseAcquisitionUrlTemplate": "https://contoso.com/{AssetAlternativeId}/fairplay/{ContentKeyId}",
              "allowPersistentLicense": true
            }
          }
        }
      }
    },
    {
      "name": "secureStreamingPolicyWithCommonEncryptionCbcsOnly",
      "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/contosorg/providers/Microsoft.Media/mediaservices/contosomedia/streamingPolicies/secureStreamingPolicyWithCommonEncryptionCbcsOnly",
      "type": "Microsoft.Media/mediaservices/streamingPolicies",
      "properties": {
        "created": "2018-08-08T18:29:30.6781134Z",
        "defaultContentKeyPolicyName": "PolicyWithMultipleOptions",
        "commonEncryptionCbcs": {
          "enabledProtocols": {
            "download": false,
            "dash": false,
            "hls": true,
            "smoothStreaming": false
          },
          "clearTracks": [],
          "contentKeys": {
            "defaultKey": {
              "label": "cbcsDefaultKey"
            },
            "keyToTrackMappings": []
          },
          "drm": {
            "fairPlay": {
              "customLicenseAcquisitionUrlTemplate": "https://contoso.com/{AssetAlternativeId}/fairplay/{ContentKeyId}",
              "allowPersistentLicense": true
            }
          }
        }
      }
    },
    {
      "name": "secureStreamingPolicyWithCommonEncryptionCencOnly",
      "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/contosorg/providers/Microsoft.Media/mediaservices/contosomedia/streamingPolicies/secureStreamingPolicyWithCommonEncryptionCencOnly",
      "type": "Microsoft.Media/mediaservices/streamingPolicies",
      "properties": {
        "created": "2018-08-08T18:29:30.6781134Z",
        "defaultContentKeyPolicyName": "PolicyWithMultipleOptions",
        "commonEncryptionCenc": {
          "enabledProtocols": {
            "download": false,
            "dash": true,
            "hls": false,
            "smoothStreaming": true
          },
          "clearTracks": [
            {
              "trackSelections": [
                {
                  "property": "FourCC",
                  "operation": "Unknown",
                  "value": "hev1"
                }
              ]
            }
          ],
          "contentKeys": {
            "defaultKey": {
              "label": "cencDefaultKey"
            },
            "keyToTrackMappings": []
          },
          "drm": {
            "playReady": {
              "customLicenseAcquisitionUrlTemplate": "https://contoso.com/{AssetAlternativeId}/playready/{ContentKeyId}",
              "playReadyCustomAttributes": "PlayReady CustomAttributes"
            },
            "widevine": {
              "customLicenseAcquisitionUrlTemplate": "https://contoso.com/{AssetAlternativeId}/widevine/{ContentKeyId"
            }
          }
        }
      }
    },
    {
      "name": "secureStreamingPolicyWithEnvelopeEncryptionOnly",
      "id": "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/contosorg/providers/Microsoft.Media/mediaservices/contosomedia/streamingPolicies/secureStreamingPolicyWithEnvelopeEncryptionOnly",
      "type": "Microsoft.Media/mediaservices/streamingPolicies",
      "properties": {
        "created": "2018-08-08T18:29:30.6781134Z",
        "defaultContentKeyPolicyName": "PolicyWithClearKeyOptionAndTokenRestriction",
        "envelopeEncryption": {
          "enabledProtocols": {
            "download": false,
            "dash": true,
            "hls": true,
            "smoothStreaming": true
          },
          "clearTracks": [],
          "contentKeys": {
            "defaultKey": {
              "label": "aesDefaultKey"
            },
            "keyToTrackMappings": []
          },
          "customKeyAcquisitionUrlTemplate": "https://contoso.com/{AssetAlternativeId}/envelope/{ContentKeyId}"
        }
      }
    }
  ],
  "@odata.nextLink": "http://server/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/contosorg/providers/Microsoft.Media/mediaServices/contosomedia/streamingPolicies?api-version=2022-08-01&$skiptoken=secureStreamingPolicyWithEnvelopeEncryptionOnly"
}

定义

名称	说明
CbcsDrmConfiguration	用于在流式处理策略中指定 CommonEncryptionCbcs 方案的 DRM 配置的类
CencDrmConfiguration	用于在流式处理策略中指定 CommonEncryptionCenc 方案的 DRM 配置的类
ClearKeyEncryptionConfiguration	用于指定流式处理策略中常见加密方案的 ClearKey 配置的类
CommonEncryptionCbcs	CommonEncryptionCbcs 加密方案的类
CommonEncryptionCenc	信封加密方案的类
createdByType	创建资源的标识类型。
DefaultKey	用于指定每个加密方案的默认内容密钥属性的类
EnabledProtocols	用于指定启用的协议的类
EnvelopeEncryption	EnvelopeEncryption 加密方案的类
ErrorAdditionalInfo	资源管理错误附加信息。
ErrorDetail	错误详细信息。
ErrorResponse	错误响应
NoEncryption	NoEncryption 方案的类
StreamingPolicy	流式处理策略资源
StreamingPolicyCollection	StreamingPolicy 项的集合。
StreamingPolicyContentKey	用于指定内容键属性的类
StreamingPolicyContentKeys	用于指定流式处理策略中所有内容键的属性的类
StreamingPolicyFairPlayConfiguration	用于在流式处理策略中指定 FairPlay 配置的类
StreamingPolicyPlayReadyConfiguration	用于在流式处理策略中指定 PlayReady 配置的类
StreamingPolicyWidevineConfiguration	用于在流式处理策略中指定 Widevine 配置的类
systemData	与资源的创建和上次修改相关的元数据。
TrackPropertyCompareOperation	跟踪属性条件操作
TrackPropertyCondition	用于指定一个跟踪属性条件的类
TrackPropertyType	Track 属性类型
TrackSelection	用于选择轨道的类

CbcsDrmConfiguration

用于在流式处理策略中指定 CommonEncryptionCbcs 方案的 DRM 配置的类

名称	类型	说明
fairPlay	StreamingPolicyFairPlayConfiguration	FairPlay 配置
playReady	StreamingPolicyPlayReadyConfiguration	PlayReady 配置
widevine	StreamingPolicyWidevineConfiguration	Widevine 配置

CencDrmConfiguration

用于在流式处理策略中指定 CommonEncryptionCenc 方案的 DRM 配置的类

名称	类型	说明
playReady	StreamingPolicyPlayReadyConfiguration	PlayReady 配置
widevine	StreamingPolicyWidevineConfiguration	Widevine 配置

ClearKeyEncryptionConfiguration

用于指定流式处理策略中常见加密方案的 ClearKey 配置的类

名称	类型	说明
customKeysAcquisitionUrlTemplate	string	用于向最终用户玩家传送内容密钥的自定义服务的 URL 的模板。 使用 Azure 媒体服务颁发许可证时不需要。 该模板支持可替换的令牌，在运行时，服务将使用特定于请求的值更新这些令牌。 当前支持的令牌值为 {AlternativeMediaId}，替换为 StreamingLocatorId.AlternativeMediaId 的值。

CommonEncryptionCbcs

CommonEncryptionCbcs 加密方案的类

名称	类型	说明
clearKeyEncryptionConfiguration	ClearKeyEncryptionConfiguration	可选配置，支持 CommonEncryptionCbcs 加密方案中的 ClearKey。
clearTracks	TrackSelection[]	表示不应加密的轨迹
contentKeys	StreamingPolicyContentKeys	表示每个加密方案的默认内容密钥，以及特定轨道的单独内容密钥
drm	CbcsDrmConfiguration	为当前加密方案配置 DRM
enabledProtocols	EnabledProtocols	表示支持的协议

CommonEncryptionCenc

信封加密方案的类

名称	类型	说明
clearKeyEncryptionConfiguration	ClearKeyEncryptionConfiguration	可选配置，支持 CommonEncryptionCenc 加密方案中的 ClearKey。
clearTracks	TrackSelection[]	表示不应加密的轨迹
contentKeys	StreamingPolicyContentKeys	表示每个加密方案的默认内容密钥，以及特定轨道的单独内容密钥
drm	CencDrmConfiguration	为 CommonEncryptionCenc 加密方案配置 DRM
enabledProtocols	EnabledProtocols	表示支持的协议

createdByType

创建资源的标识类型。

名称	类型	说明
Application	string
Key	string
ManagedIdentity	string
User	string

DefaultKey

用于指定每个加密方案的默认内容密钥属性的类

名称	类型	说明
label	string	标签可用于在创建流式处理定位符时指定内容键
policyName	string	默认密钥使用的策略

EnabledProtocols

用于指定启用的协议的类

名称	类型	说明
dash	boolean	是否启用 DASH 协议
download	boolean	是否启用下载协议
hls	boolean	是否启用 HLS 协议
smoothStreaming	boolean	是否启用平滑流式处理协议

EnvelopeEncryption

EnvelopeEncryption 加密方案的类

名称	类型	说明
clearTracks	TrackSelection[]	表示不应加密的轨迹
contentKeys	StreamingPolicyContentKeys	表示每个加密方案的默认内容密钥，以及特定轨道的单独内容密钥
customKeyAcquisitionUrlTemplate	string	用于向最终用户玩家传递密钥的自定义服务的 URL 的模板。 使用 Azure 媒体服务颁发密钥时不是必需的。 该模板支持可替换的令牌，在运行时，服务将使用特定于请求的值更新这些令牌。 当前支持的令牌值是 {AlternativeMediaId}，替换为 StreamingLocatorId.AlternativeMediaId 的值和 {ContentKeyId}，后者被替换为所请求密钥的标识符值。
enabledProtocols	EnabledProtocols	表示支持的协议

ErrorAdditionalInfo

资源管理错误附加信息。

名称	类型	说明
info	object	其他信息。
type	string	其他信息类型。

ErrorDetail

错误详细信息。

名称	类型	说明
additionalInfo	ErrorAdditionalInfo[]	错误附加信息。
code	string	错误代码。
details	ErrorDetail[]	错误详细信息。
message	string	错误消息。
target	string	错误目标。

ErrorResponse

错误响应

名称	类型	说明
error	ErrorDetail	错误对象。

NoEncryption

NoEncryption 方案的类

名称	类型	说明
enabledProtocols	EnabledProtocols	表示支持的协议

StreamingPolicy

流式处理策略资源

名称	类型	说明
id	string	资源的完全限定的资源 ID。 例如 - /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
name	string	资源的名称
properties.commonEncryptionCbcs	CommonEncryptionCbcs	CommonEncryptionCbcs 的配置
properties.commonEncryptionCenc	CommonEncryptionCenc	CommonEncryptionCenc 的配置
properties.created	string	流式处理策略的创建时间
properties.defaultContentKeyPolicyName	string	当前流式处理策略使用的默认 ContentKey
properties.envelopeEncryption	EnvelopeEncryption	EnvelopeEncryption 的配置
properties.noEncryption	NoEncryption	NoEncryption 的配置
systemData	systemData	与此资源相关的系统元数据。
type	string	资源类型。 例如“Microsoft.Compute/virtualMachines”或“Microsoft.Storage/storageAccounts”

StreamingPolicyCollection

StreamingPolicy 项的集合。

名称	类型	说明
@odata.nextLink	string	指向集合下一页的链接 (集合包含的结果太多，无法返回一个响应) 。
value	StreamingPolicy[]	StreamingPolicy 项的集合。

StreamingPolicyContentKey

用于指定内容键属性的类

名称	类型	说明
label	string	标签可用于在创建流式处理定位符时指定内容键
policyName	string	内容密钥使用的策略
tracks	TrackSelection[]	跟踪使用此内容密钥的

StreamingPolicyContentKeys

用于指定流式处理策略中所有内容键的属性的类

名称	类型	说明
defaultKey	DefaultKey	加密方案的默认内容密钥
keyToTrackMappings	StreamingPolicyContentKey[]	表示曲目需要单独的内容密钥

StreamingPolicyFairPlayConfiguration

用于在流式处理策略中指定 FairPlay 配置的类

名称	类型	说明
allowPersistentLicense	boolean	要永久或不具有所有许可证
customLicenseAcquisitionUrlTemplate	string	向最终用户玩家传送许可证的自定义服务的 URL 的模板。 使用 Azure 媒体服务颁发许可证时不需要。 该模板支持可替换的令牌，在运行时，服务将使用特定于请求的值更新这些令牌。 当前支持的令牌值是 {AlternativeMediaId}，替换为 StreamingLocatorId.AlternativeMediaId 的值和 {ContentKeyId}，后者被替换为所请求密钥的标识符值。

StreamingPolicyPlayReadyConfiguration

用于在流式处理策略中指定 PlayReady 配置的类

名称	类型	说明
customLicenseAcquisitionUrlTemplate	string	向最终用户玩家传送许可证的自定义服务的 URL 的模板。 使用 Azure 媒体服务颁发许可证时不需要。 该模板支持可替换的令牌，在运行时，服务将使用特定于请求的值更新这些令牌。 当前支持的令牌值是 {AlternativeMediaId}，替换为 StreamingLocatorId.AlternativeMediaId 的值和 {ContentKeyId}，后者被替换为所请求密钥的标识符值。
playReadyCustomAttributes	string	PlayReady 的自定义属性

StreamingPolicyWidevineConfiguration

用于在流式处理策略中指定 Widevine 配置的类

名称	类型	说明
customLicenseAcquisitionUrlTemplate	string	向最终用户玩家传送许可证的自定义服务的 URL 的模板。 使用 Azure 媒体服务颁发许可证时不需要。 该模板支持可替换的令牌，在运行时，服务将使用特定于请求的值更新这些令牌。 当前支持的令牌值是 {AlternativeMediaId}，替换为 StreamingLocatorId.AlternativeMediaId 的值和 {ContentKeyId}，后者被替换为所请求密钥的标识符值。

systemData

与资源的创建和上次修改相关的元数据。

名称	类型	说明
createdAt	string	资源的创建时间戳 (UTC) 。
createdBy	string	创建资源的标识。
createdByType	createdByType	创建资源的标识类型。
lastModifiedAt	string	资源上次修改的时间戳 (UTC)
lastModifiedBy	string	上次修改资源的标识。
lastModifiedByType	createdByType	上次修改资源的标识类型。

TrackPropertyCompareOperation

跟踪属性条件操作

名称	类型	说明
Equal	string	相等运算
Unknown	string	未知跟踪属性比较操作

TrackPropertyCondition

用于指定一个跟踪属性条件的类

名称	类型	说明
operation	TrackPropertyCompareOperation	跟踪属性条件操作
property	TrackPropertyType	Track 属性类型
value	string	跟踪属性值

TrackPropertyType

Track 属性类型

名称	类型	说明
FourCC	string	Track FourCC
Unknown	string	未知轨道属性

TrackSelection

用于选择轨道的类

名称	类型	说明
trackSelections	TrackPropertyCondition[]	TrackSelections 是一个跟踪属性条件列表，可以指定跟踪 ()