Streaming Policies - List

服務:

Media Services

API 版本:

2022-08-01

列出串流原則
清單 帳戶中的串流原則

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

含選擇性參數:

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 參數

名稱	位於	必要	類型	Description
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 的可用項目數目。

回應

名稱	類型	Description
200 OK	StreamingPolicyCollection	確定
Other Status Codes	ErrorResponse	詳細的錯誤資訊。

範例

Lists Streaming Policies

範例要求

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

範例回覆

狀態碼:

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"
}

定義

名稱	Description
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	追蹤屬性類型
TrackSelection	要選取追蹤的類別

CbcsDrmConfiguration

類別，指定串流原則中 CommonEncryptionCbcs 配置的DRM組態

名稱	類型	Description
fairPlay	StreamingPolicyFairPlayConfiguration	FairPlay 設定
playReady	StreamingPolicyPlayReadyConfiguration	PlayReady 設定
widevine	StreamingPolicyWidevineConfiguration	Widevine 組態

CencDrmConfiguration

類別，指定串流原則中 CommonEncryptionCenc 配置的DRM組態

名稱	類型	Description
playReady	StreamingPolicyPlayReadyConfiguration	PlayReady 設定
widevine	StreamingPolicyWidevineConfiguration	Widevine 組態

ClearKeyEncryptionConfiguration

類別，指定串流原則中通用加密配置的 ClearKey 組態

名稱	類型	Description
customKeysAcquisitionUrlTemplate	string	自訂服務的 URL 範本，將內容金鑰傳遞給使用者播放機。 使用 Azure 媒體服務發出授權時不需要。 此範本支援可更換的權杖，服務將在執行階段將權杖更新為要求的特定值。 目前支援的令牌值為 {AlternativeMediaId}，其會取代為 StreamingLocatorId.AlternativeMediaId 的值。

CommonEncryptionCbcs

CommonEncryptionCbcs 加密配置的類別

名稱	類型	Description
clearKeyEncryptionConfiguration	ClearKeyEncryptionConfiguration	在 CommonEncryptionCbcs 加密配置中支援 ClearKey 的選擇性設定。
clearTracks	TrackSelection[]	表示不應該加密哪些追蹤
contentKeys	StreamingPolicyContentKeys	代表每個加密配置的預設內容密鑰，以及特定追蹤的不同內容金鑰
drm	CbcsDrmConfiguration	目前加密配置的DRM設定
enabledProtocols	EnabledProtocols	表示支援的通訊協定

CommonEncryptionCenc

信封加密配置的類別

名稱	類型	Description
clearKeyEncryptionConfiguration	ClearKeyEncryptionConfiguration	在 CommonEncryptionCenc 加密配置中支援 ClearKey 的選擇性設定。
clearTracks	TrackSelection[]	表示不應該加密哪些追蹤
contentKeys	StreamingPolicyContentKeys	代表每個加密配置的預設內容密鑰，以及特定追蹤的不同內容金鑰
drm	CencDrmConfiguration	CommonEncryptionCenc 加密配置的DRM設定
enabledProtocols	EnabledProtocols	表示支援的通訊協定

createdByType

建立資源的身分識別類型。

名稱	類型	Description
Application	string
Key	string
ManagedIdentity	string
User	string

DefaultKey

類別，指定每個加密配置的預設內容密鑰屬性

名稱	類型	Description
label	string	建立串流定位器時，可以使用標籤來指定內容密鑰
policyName	string	預設金鑰所使用的原則

EnabledProtocols

類別，指定要啟用哪些通訊協定

名稱	類型	Description
dash	boolean	啟用 DASH 通訊協定或未啟用
download	boolean	啟用下載通訊協定
hls	boolean	啟用 HLS 通訊協定或不啟用
smoothStreaming	boolean	啟用 SmoothStreaming 通訊協定或未啟用

EnvelopeEncryption

EnvelopeEncryption 加密配置的類別

名稱	類型	Description
clearTracks	TrackSelection[]	表示不應該加密哪些追蹤
contentKeys	StreamingPolicyContentKeys	代表每個加密配置的預設內容密鑰，以及特定追蹤的不同內容金鑰
customKeyAcquisitionUrlTemplate	string	自訂服務 URL 的範本，將金鑰傳遞給使用者播放機。 使用 Azure 媒體服務發出金鑰時不需要。 此範本支援可更換的權杖，服務將在執行階段將權杖更新為要求的特定值。 目前支援的令牌值為 {AlternativeMediaId}，其會取代為 StreamingLocatorId.AlternativeMediaId 和 {ContentKeyId}的值，其會取代為所要求密鑰的標識符值。
enabledProtocols	EnabledProtocols	表示支援的通訊協定

ErrorAdditionalInfo

資源管理錯誤其他資訊。

名稱	類型	Description
info	object	其他資訊。
type	string	其他信息類型。

ErrorDetail

錯誤詳細數據。

名稱	類型	Description
additionalInfo	ErrorAdditionalInfo[]	錯誤其他資訊。
code	string	錯誤碼。
details	ErrorDetail[]	錯誤詳細資料。
message	string	錯誤訊息。
target	string	錯誤目標。

ErrorResponse

錯誤回應

名稱	類型	Description
error	ErrorDetail	error 物件。

NoEncryption

NoEncryption 配置的類別

名稱	類型	Description
enabledProtocols	EnabledProtocols	表示支援的通訊協定

StreamingPolicy

串流原則資源

名稱	類型	Description
id	string	資源的完整資源識別碼。 Ex - /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	Nocompression 的設定
systemData	systemData	與此資源相關的系統元數據。
type	string	資源類型。 例如“Microsoft.Compute/virtualMachines” 或 “Microsoft.Storage/storageAccounts”

StreamingPolicyCollection

StreamingPolicy 專案的集合。

名稱	類型	Description
@odata.nextLink	string	當集合包含太多結果，無法傳回一個回應) 時，集合 (下一頁的連結。
value	StreamingPolicy[]	StreamingPolicy 專案的集合。

StreamingPolicyContentKey

指定內容索引鍵屬性的類別

名稱	類型	Description
label	string	建立串流定位器時，可以使用標籤來指定內容密鑰
policyName	string	內容金鑰使用的原則
tracks	TrackSelection[]	追蹤使用此內容金鑰的索引鍵

StreamingPolicyContentKeys

類別，指定串流原則中所有內容索引鍵的屬性

名稱	類型	Description
defaultKey	DefaultKey	加密配置的預設內容金鑰
keyToTrackMappings	StreamingPolicyContentKey[]	代表曲目需要個別的內容密鑰

StreamingPolicyFairPlayConfiguration

在串流原則中指定 FairPlay 設定的類別

名稱	類型	Description
allowPersistentLicense	boolean	所有要永續性的授權
customLicenseAcquisitionUrlTemplate	string	自訂服務的 URL 範本，會將授權傳遞給終端使用者播放程式。 使用 Azure 媒體服務來發行授權時不需要。 此範本支援可更換的權杖，服務將在執行階段將權杖更新為要求的特定值。 目前支援的令牌值為 {AlternativeMediaId}，此值會取代為 StreamingLocatorId.AlternativeMediaId 和 {ContentKeyId}的值，此值會取代為所要求密鑰的標識符值。

StreamingPolicyPlayReadyConfiguration

類別，指定串流原則中 PlayReady 的組態

名稱	類型	Description
customLicenseAcquisitionUrlTemplate	string	自訂服務 URL 的範本，將授權傳遞給使用者播放機。 使用 Azure 媒體服務發出授權時不需要。 此範本支援可更換的權杖，服務將在執行階段將權杖更新為要求的特定值。 目前支援的令牌值為 {AlternativeMediaId}，其會取代為 StreamingLocatorId.AlternativeMediaId 和 {ContentKeyId}的值，其會取代為所要求密鑰的標識符值。
playReadyCustomAttributes	string	PlayReady 的自定義屬性

StreamingPolicyWidevineConfiguration

類別，指定串流原則中的Widevine組態

名稱	類型	Description
customLicenseAcquisitionUrlTemplate	string	自訂服務 URL 的範本，將授權傳遞給使用者播放機。 使用 Azure 媒體服務發出授權時不需要。 此範本支援可更換的權杖，服務將在執行階段將權杖更新為要求的特定值。 目前支援的令牌值為 {AlternativeMediaId}，此值會取代為 StreamingLocatorId.AlternativeMediaId 和 {ContentKeyId}的值，此值會取代為所要求密鑰的標識符值。

systemData

與建立和上次修改資源相關的元數據。

名稱	類型	Description
createdAt	string	資源建立的時間戳 (UTC) 。
createdBy	string	建立資源的身分識別。
createdByType	createdByType	建立資源的身分識別類型。
lastModifiedAt	string	上次修改的資源時間戳 (UTC)
lastModifiedBy	string	上次修改資源的身分識別。
lastModifiedByType	createdByType	上次修改資源的身分識別類型。

TrackPropertyCompareOperation

追蹤屬性條件作業

名稱	類型	Description
Equal	string	相等運算
Unknown	string	未知的追蹤屬性比較作業

TrackPropertyCondition

指定一個追蹤屬性條件的類別

名稱	類型	Description
operation	TrackPropertyCompareOperation	追蹤屬性條件作業
property	TrackPropertyType	追蹤屬性類型
value	string	追蹤屬性值

TrackPropertyType

追蹤屬性類型

名稱	類型	Description
FourCC	string	追蹤FourCC
Unknown	string	未知的追蹤屬性

TrackSelection

要選取追蹤的類別

名稱	類型	Description
trackSelections	TrackPropertyCondition[]	TrackSelections 是追蹤屬性條件清單，可指定追蹤 (s)