Streaming Policies - List

Dienst:

Media Services

API-Version:

2022-08-01

Auflisten von Streamingrichtlinien
Listen der Streamingrichtlinien im Konto

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

Mit optionalen Parametern:

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-Parameter

Name	In	Erforderlich	Typ	Beschreibung
accountName	path	True	string	Der Name des Media Services-Kontos.
resourceGroupName	path	True	string	Der Name der Ressourcengruppe innerhalb des Azure-Abonnements.
subscriptionId	path	True	string	Der eindeutige Bezeichner für ein Microsoft Azure-Abonnement.
api-version	query	True	string	Die Version der API, die mit der Clientanforderung verwendet werden soll.
$filter	query		string	Schränkt den Satz der zurückgegebenen Elemente ein.
$orderby	query		string	Gibt den Schlüssel an, nach dem die Ergebnisauflistung sortiert werden soll.
$top	query		integer int32	Gibt eine nicht negative ganze Zahl n an, die die Anzahl der aus einer Auflistung zurückgegebenen Elemente begrenzt. Der Dienst gibt die Anzahl der verfügbaren Elemente bis zu zurück, aber nicht größer als der angegebene Wert n.

Antworten

Name	Typ	Beschreibung
200 OK	StreamingPolicyCollection	OK
Other Status Codes	ErrorResponse	Detaillierte Fehlerinformationen.

Beispiele

Lists Streaming Policies

Beispielanforderung

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

Beispiel für eine Antwort

Statuscode:

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

Definitionen

Name	Beschreibung
CbcsDrmConfiguration	Klasse zum Angeben von DRM-Konfigurationen des CommonEncryptionCbcs-Schemas in der Streamingrichtlinie
CencDrmConfiguration	Klasse zum Angeben von DRM-Konfigurationen des CommonEncryptionCenc-Schemas in der Streamingrichtlinie
ClearKeyEncryptionConfiguration	Klasse zum Angeben der ClearKey-Konfiguration allgemeiner Verschlüsselungsschemas in der Streamingrichtlinie
CommonEncryptionCbcs	Klasse für commonEncryptionCbcs-Verschlüsselungsschema
CommonEncryptionCenc	Klasse für das Verschlüsselungsschema für Umschläge
createdByType	Der Identitätstyp, der die Ressource erstellt hat.
DefaultKey	Klasse zum Angeben der Eigenschaften des Standardinhaltsschlüssels für jedes Verschlüsselungsschema
EnabledProtocols	Klasse zum Angeben der aktivierten Protokolle
EnvelopeEncryption	Klasse für EnvelopeEncryption-Verschlüsselungsschema
ErrorAdditionalInfo	Zusätzliche Informationen zum Ressourcenverwaltungsfehler.
ErrorDetail	Die Fehlerdetails.
ErrorResponse	Fehlerantwort
NoEncryption	Klasse für NoEncryption-Schema
StreamingPolicy	Eine Streamingrichtlinienressource
StreamingPolicyCollection	Eine Auflistung von StreamingPolicy-Elementen.
StreamingPolicyContentKey	Klasse zum Angeben von Eigenschaften des Inhaltsschlüssels
StreamingPolicyContentKeys	Klasse zum Angeben der Eigenschaften aller Inhaltsschlüssel in der Streamingrichtlinie
StreamingPolicyFairPlayConfiguration	Klasse zum Angeben von FairPlay-Konfigurationen in der Streamingrichtlinie
StreamingPolicyPlayReadyConfiguration	Klasse zum Angeben von Konfigurationen von PlayReady in der Streamingrichtlinie
StreamingPolicyWidevineConfiguration	Klasse zum Angeben von Konfigurationen von Widevine in der Streamingrichtlinie
systemData	Metadaten, die sich auf die Erstellung und letzte Änderung der Ressource beziehen.
TrackPropertyCompareOperation	Zustandsvorgang der Eigenschaft nachverfolgen
TrackPropertyCondition	Klasse zum Angeben einer Trackeigenschaftsbedingung
TrackPropertyType	Eigenschaftentyp nachverfolgen
TrackSelection	Klasse zum Auswählen eines Titels

CbcsDrmConfiguration

Klasse zum Angeben von DRM-Konfigurationen des CommonEncryptionCbcs-Schemas in der Streamingrichtlinie

Name	Typ	Beschreibung
fairPlay	StreamingPolicyFairPlayConfiguration	FairPlay-Konfigurationen
playReady	StreamingPolicyPlayReadyConfiguration	PlayReady-Konfigurationen
widevine	StreamingPolicyWidevineConfiguration	Widevine-Konfigurationen

CencDrmConfiguration

Klasse zum Angeben von DRM-Konfigurationen des CommonEncryptionCenc-Schemas in der Streamingrichtlinie

Name	Typ	Beschreibung
playReady	StreamingPolicyPlayReadyConfiguration	PlayReady-Konfigurationen
widevine	StreamingPolicyWidevineConfiguration	Widevine-Konfigurationen

ClearKeyEncryptionConfiguration

Klasse zum Angeben der ClearKey-Konfiguration allgemeiner Verschlüsselungsschemas in der Streamingrichtlinie

Name	Typ	Beschreibung
customKeysAcquisitionUrlTemplate	string	Vorlage für die URL des benutzerdefinierten Diensts, der Inhaltsschlüssel für Endbenutzer-Spieler bereitstellt. Diese ist nicht erforderlich, wenn Sie Azure Media Services für das Ausstellen von Lizenzen verwenden. Die Vorlage unterstützt ersetzbare Token, die der Dienst zur Laufzeit mit dem Wert für die Anforderung aktualisiert. Der derzeit unterstützte Tokenwert ist {AlternativeMediaId}, der durch den Wert streamingLocatorId.AlternativeMediaId ersetzt wird.

CommonEncryptionCbcs

Klasse für commonEncryptionCbcs-Verschlüsselungsschema

Name	Typ	Beschreibung
clearKeyEncryptionConfiguration	ClearKeyEncryptionConfiguration	Optionale Konfiguration, die ClearKey im CommonEncryptionCbcs-Verschlüsselungsschema unterstützt.
clearTracks	TrackSelection[]	Stellt dar, welche Spuren nicht verschlüsselt werden sollen
contentKeys	StreamingPolicyContentKeys	Darstellen des Standardinhaltsschlüssels für jedes Verschlüsselungsschema und separate Inhaltsschlüssel für bestimmte Titel
drm	CbcsDrmConfiguration	Konfiguration von DRMs für das aktuelle Verschlüsselungsschema
enabledProtocols	EnabledProtocols	Darstellen unterstützter Protokolle

CommonEncryptionCenc

Klasse für das Verschlüsselungsschema für Umschläge

Name	Typ	Beschreibung
clearKeyEncryptionConfiguration	ClearKeyEncryptionConfiguration	Optionale Konfiguration, die ClearKey im CommonEncryptionCenc-Verschlüsselungsschema unterstützt.
clearTracks	TrackSelection[]	Stellt dar, welche Spuren nicht verschlüsselt werden sollen
contentKeys	StreamingPolicyContentKeys	Darstellen des Standardinhaltsschlüssels für jedes Verschlüsselungsschema und separate Inhaltsschlüssel für bestimmte Titel
drm	CencDrmConfiguration	Konfiguration von DRMs für das CommonEncryptionCenc-Verschlüsselungsschema
enabledProtocols	EnabledProtocols	Darstellen unterstützter Protokolle

createdByType

Der Identitätstyp, der die Ressource erstellt hat.

Name	Typ	Beschreibung
Application	string
Key	string
ManagedIdentity	string
User	string

DefaultKey

Klasse zum Angeben der Eigenschaften des Standardinhaltsschlüssels für jedes Verschlüsselungsschema

Name	Typ	Beschreibung
label	string	Bezeichnung kann verwendet werden, um den Inhaltsschlüssel beim Erstellen eines Streaminglocators anzugeben.
policyName	string	Vom Standardschlüssel verwendete Richtlinie

EnabledProtocols

Klasse zum Angeben der aktivierten Protokolle

Name	Typ	Beschreibung
dash	boolean	Aktivieren des DASH-Protokolls
download	boolean	Aktivieren des Downloadprotokolls oder nicht
hls	boolean	HlS-Protokoll aktivieren oder nicht
smoothStreaming	boolean	Aktivieren des SmoothStreaming-Protokolls oder nicht

EnvelopeEncryption

Klasse für EnvelopeEncryption-Verschlüsselungsschema

Name	Typ	Beschreibung
clearTracks	TrackSelection[]	Stellt dar, welche Spuren nicht verschlüsselt werden sollen
contentKeys	StreamingPolicyContentKeys	Darstellen des Standardinhaltsschlüssels für jedes Verschlüsselungsschema und separate Inhaltsschlüssel für bestimmte Titel
customKeyAcquisitionUrlTemplate	string	Vorlage für die URL des benutzerdefinierten Diensts, der Schlüssel für Endbenutzer-Spieler bereitstellt. Diese ist nicht erforderlich, wenn Sie Azure Media Services für das Ausstellen von Schlüsseln verwenden. Die Vorlage unterstützt ersetzbare Token, die der Dienst zur Laufzeit mit dem Wert für die Anforderung aktualisiert. Die derzeit unterstützten Werte für Token sind {AlternativeMediaId} (wird durch den Wert von StreamingLocatorId.AlternativeMediaId ersetzt) und {ContentKeyId} (wird durch den Wert des Bezeichners des angeforderten Schlüssels ersetzt).
enabledProtocols	EnabledProtocols	Darstellen unterstützter Protokolle

ErrorAdditionalInfo

Zusätzliche Informationen zum Ressourcenverwaltungsfehler.

Name	Typ	Beschreibung
info	object	Zusätzliche Informationen.
type	string	Typ der zusätzlichen Informationen.

ErrorDetail

Die Fehlerdetails.

Name	Typ	Beschreibung
additionalInfo	ErrorAdditionalInfo[]	Die zusätzlichen Fehlerinformationen.
code	string	Der Fehlercode.
details	ErrorDetail[]	Die Fehlerdetails.
message	string	Die Fehlermeldung.
target	string	Das Fehlerziel.

ErrorResponse

Fehlerantwort

Name	Typ	Beschreibung
error	ErrorDetail	Das Fehlerobjekt.

NoEncryption

Klasse für NoEncryption-Schema

Name	Typ	Beschreibung
enabledProtocols	EnabledProtocols	Darstellen unterstützter Protokolle

StreamingPolicy

Eine Streamingrichtlinienressource

Name	Typ	Beschreibung
id	string	Vollqualifizierte Ressourcen-ID für die Ressource. Beispiel: /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/{resourceProviderNamespace}/{resourceType}/{resourceName}
name	string	Der Name der Ressource
properties.commonEncryptionCbcs	CommonEncryptionCbcs	Konfiguration von CommonEncryptionCbcs
properties.commonEncryptionCenc	CommonEncryptionCenc	Konfiguration von CommonEncryptionCenc
properties.created	string	Zeitpunkt der Erstellung der Streamingrichtlinie
properties.defaultContentKeyPolicyName	string	Standardmäßiger ContentKey, der von der aktuellen Streamingrichtlinie verwendet wird.
properties.envelopeEncryption	EnvelopeEncryption	Konfiguration von EnvelopeEncryption
properties.noEncryption	NoEncryption	Konfiguration von NoEncryption
systemData	systemData	Die Systemmetadaten, die sich auf diese Ressource beziehen.
type	string	Der Typ der Ressource. Z.B. "Microsoft.Compute/virtualMachines" oder "Microsoft.Storage/storageAccounts"

StreamingPolicyCollection

Eine Auflistung von StreamingPolicy-Elementen.

Name	Typ	Beschreibung
@odata.nextLink	string	Ein Link zur nächsten Seite der Auflistung (wenn die Auflistung zu viele Ergebnisse enthält, um in einer Antwort zurückgegeben zu werden).
value	StreamingPolicy[]	Eine Auflistung von StreamingPolicy-Elementen.

StreamingPolicyContentKey

Klasse zum Angeben von Eigenschaften des Inhaltsschlüssels

Name	Typ	Beschreibung
label	string	Bezeichnung kann verwendet werden, um den Inhaltsschlüssel beim Erstellen eines Streaminglocators anzugeben.
policyName	string	Vom Inhaltsschlüssel verwendete Richtlinie
tracks	TrackSelection[]	Nachverfolgen, die diesen Inhaltsschlüssel verwenden

StreamingPolicyContentKeys

Klasse zum Angeben der Eigenschaften aller Inhaltsschlüssel in der Streamingrichtlinie

Name	Typ	Beschreibung
defaultKey	DefaultKey	Standardinhaltsschlüssel für ein Verschlüsselungsschema
keyToTrackMappings	StreamingPolicyContentKey[]	Für die Darstellung von Spuren ist ein separater Inhaltsschlüssel erforderlich.

StreamingPolicyFairPlayConfiguration

Klasse zum Angeben von FairPlay-Konfigurationen in der Streamingrichtlinie

Name	Typ	Beschreibung
allowPersistentLicense	boolean	Alle Lizenzen, die dauerhaft sein sollen oder nicht
customLicenseAcquisitionUrlTemplate	string	Vorlage für die URL des benutzerdefinierten Diensts, der Lizenzen für Endbenutzerplayer bereitstellt. Diese ist nicht erforderlich, wenn Sie Azure Media Services für das Ausstellen von Lizenzen verwenden. Die Vorlage unterstützt ersetzbare Token, die der Dienst zur Laufzeit mit dem Wert für die Anforderung aktualisiert. Die derzeit unterstützten Werte für Token sind {AlternativeMediaId} (wird durch den Wert von StreamingLocatorId.AlternativeMediaId ersetzt) und {ContentKeyId} (wird durch den Wert des Bezeichners des angeforderten Schlüssels ersetzt).

StreamingPolicyPlayReadyConfiguration

Klasse zum Angeben von Konfigurationen von PlayReady in der Streamingrichtlinie

Name	Typ	Beschreibung
customLicenseAcquisitionUrlTemplate	string	Vorlage für die URL des benutzerdefinierten Diensts, der Lizenzen für Endbenutzer-Spieler bereitstellt. Diese ist nicht erforderlich, wenn Sie Azure Media Services für das Ausstellen von Lizenzen verwenden. Die Vorlage unterstützt ersetzbare Token, die der Dienst zur Laufzeit mit dem Wert für die Anforderung aktualisiert. Die derzeit unterstützten Werte für Token sind {AlternativeMediaId} (wird durch den Wert von StreamingLocatorId.AlternativeMediaId ersetzt) und {ContentKeyId} (wird durch den Wert des Bezeichners des angeforderten Schlüssels ersetzt).
playReadyCustomAttributes	string	Benutzerdefinierte Attribute für PlayReady

StreamingPolicyWidevineConfiguration

Klasse zum Angeben von Konfigurationen von Widevine in der Streamingrichtlinie

Name	Typ	Beschreibung
customLicenseAcquisitionUrlTemplate	string	Vorlage für die URL des benutzerdefinierten Diensts, der Lizenzen für Endbenutzer-Spieler bereitstellt. Diese ist nicht erforderlich, wenn Sie Azure Media Services für das Ausstellen von Lizenzen verwenden. Die Vorlage unterstützt ersetzbare Token, die der Dienst zur Laufzeit mit dem Wert für die Anforderung aktualisiert. Die derzeit unterstützten Werte für Token sind {AlternativeMediaId} (wird durch den Wert von StreamingLocatorId.AlternativeMediaId ersetzt) und {ContentKeyId} (wird durch den Wert des Bezeichners des angeforderten Schlüssels ersetzt).

systemData

Metadaten, die sich auf die Erstellung und letzte Änderung der Ressource beziehen.

Name	Typ	Beschreibung
createdAt	string	Der Zeitstempel der Ressourcenerstellung (UTC).
createdBy	string	Die Identität, die die Ressource erstellt hat.
createdByType	createdByType	Der Identitätstyp, der die Ressource erstellt hat.
lastModifiedAt	string	Der Zeitstempel der letzten Änderung der Ressource (UTC)
lastModifiedBy	string	Die Identität, die die Ressource zuletzt geändert hat.
lastModifiedByType	createdByType	Der Identitätstyp, der die Ressource zuletzt geändert hat.

TrackPropertyCompareOperation

Zustandsvorgang der Eigenschaft nachverfolgen

Name	Typ	Beschreibung
Equal	string	Gleicher Vorgang
Unknown	string	Vergleichsvorgang für unbekannte Spureigenschaften

TrackPropertyCondition

Klasse zum Angeben einer Trackeigenschaftsbedingung

Name	Typ	Beschreibung
operation	TrackPropertyCompareOperation	Nachverfolgen des Bedingungsvorgangs der Eigenschaft
property	TrackPropertyType	Track-Eigenschaftstyp
value	string	Nachverfolgen des Eigenschaftswerts

TrackPropertyType

Eigenschaftentyp nachverfolgen

Name	Typ	Beschreibung
FourCC	string	Track FourCC
Unknown	string	Unbekannte Spureigenschaft

TrackSelection

Klasse zum Auswählen eines Titels

Name	Typ	Beschreibung
trackSelections	TrackPropertyCondition[]	TrackSelections ist eine Liste der Track-Eigenschaftenbedingungen, die Die Spur(n) angeben kann.