pulumi-azure-kotlin/com.pulumi.azure.media.kotlin/StreamingLocator

StreamingLocator

class StreamingLocator : KotlinCustomResource

Manages a Media Streaming Locator.

Example Usage

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";
const example = new azure.core.ResourceGroup("example", {
    name: "media-resources",
    location: "West Europe",
});
const exampleAccount = new azure.storage.Account("example", {
    name: "examplestoracc",
    resourceGroupName: example.name,
    location: example.location,
    accountTier: "Standard",
    accountReplicationType: "GRS",
});
const exampleServiceAccount = new azure.media.ServiceAccount("example", {
    name: "examplemediaacc",
    location: example.location,
    resourceGroupName: example.name,
    storageAccounts: [{
        id: exampleAccount.id,
        isPrimary: true,
    }],
});
const exampleAccountFilter = new azure.media.AccountFilter("example", {
    name: "Filter1",
    resourceGroupName: example.name,
    mediaServicesAccountName: exampleServiceAccount.name,
});
const exampleAsset = new azure.media.Asset("example", {
    name: "Asset1",
    resourceGroupName: example.name,
    mediaServicesAccountName: exampleServiceAccount.name,
    description: "Asset description",
});
const exampleStreamingLocator = new azure.media.StreamingLocator("example", {
    name: "example",
    resourceGroupName: example.name,
    mediaServicesAccountName: exampleServiceAccount.name,
    assetName: exampleAsset.name,
    streamingPolicyName: "Predefined_ClearStreamingOnly",
    filterNames: [exampleAccountFilter.name],
});
Content copied to clipboard
import pulumi
import pulumi_azure as azure
example = azure.core.ResourceGroup("example",
    name="media-resources",
    location="West Europe")
example_account = azure.storage.Account("example",
    name="examplestoracc",
    resource_group_name=example.name,
    location=example.location,
    account_tier="Standard",
    account_replication_type="GRS")
example_service_account = azure.media.ServiceAccount("example",
    name="examplemediaacc",
    location=example.location,
    resource_group_name=example.name,
    storage_accounts=[{
        "id": example_account.id,
        "is_primary": True,
    }])
example_account_filter = azure.media.AccountFilter("example",
    name="Filter1",
    resource_group_name=example.name,
    media_services_account_name=example_service_account.name)
example_asset = azure.media.Asset("example",
    name="Asset1",
    resource_group_name=example.name,
    media_services_account_name=example_service_account.name,
    description="Asset description")
example_streaming_locator = azure.media.StreamingLocator("example",
    name="example",
    resource_group_name=example.name,
    media_services_account_name=example_service_account.name,
    asset_name=example_asset.name,
    streaming_policy_name="Predefined_ClearStreamingOnly",
    filter_names=[example_account_filter.name])
Content copied to clipboard
using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;
return await Deployment.RunAsync(() =>
{
    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "media-resources",
        Location = "West Europe",
    });
    var exampleAccount = new Azure.Storage.Account("example", new()
    {
        Name = "examplestoracc",
        ResourceGroupName = example.Name,
        Location = example.Location,
        AccountTier = "Standard",
        AccountReplicationType = "GRS",
    });
    var exampleServiceAccount = new Azure.Media.ServiceAccount("example", new()
    {
        Name = "examplemediaacc",
        Location = example.Location,
        ResourceGroupName = example.Name,
        StorageAccounts = new[]
        {
            new Azure.Media.Inputs.ServiceAccountStorageAccountArgs
            {
                Id = exampleAccount.Id,
                IsPrimary = true,
            },
        },
    });
    var exampleAccountFilter = new Azure.Media.AccountFilter("example", new()
    {
        Name = "Filter1",
        ResourceGroupName = example.Name,
        MediaServicesAccountName = exampleServiceAccount.Name,
    });
    var exampleAsset = new Azure.Media.Asset("example", new()
    {
        Name = "Asset1",
        ResourceGroupName = example.Name,
        MediaServicesAccountName = exampleServiceAccount.Name,
        Description = "Asset description",
    });
    var exampleStreamingLocator = new Azure.Media.StreamingLocator("example", new()
    {
        Name = "example",
        ResourceGroupName = example.Name,
        MediaServicesAccountName = exampleServiceAccount.Name,
        AssetName = exampleAsset.Name,
        StreamingPolicyName = "Predefined_ClearStreamingOnly",
        FilterNames = new[]
        {
            exampleAccountFilter.Name,
        },
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/media"
	"github.com/pulumi/pulumi-azure/sdk/v5/go/azure/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("media-resources"),
			Location: pulumi.String("West Europe"),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "example", &storage.AccountArgs{
			Name:                   pulumi.String("examplestoracc"),
			ResourceGroupName:      example.Name,
			Location:               example.Location,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("GRS"),
		})
		if err != nil {
			return err
		}
		exampleServiceAccount, err := media.NewServiceAccount(ctx, "example", &media.ServiceAccountArgs{
			Name:              pulumi.String("examplemediaacc"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
			StorageAccounts: media.ServiceAccountStorageAccountArray{
				&media.ServiceAccountStorageAccountArgs{
					Id:        exampleAccount.ID(),
					IsPrimary: pulumi.Bool(true),
				},
			},
		})
		if err != nil {
			return err
		}
		exampleAccountFilter, err := media.NewAccountFilter(ctx, "example", &media.AccountFilterArgs{
			Name:                     pulumi.String("Filter1"),
			ResourceGroupName:        example.Name,
			MediaServicesAccountName: exampleServiceAccount.Name,
		})
		if err != nil {
			return err
		}
		exampleAsset, err := media.NewAsset(ctx, "example", &media.AssetArgs{
			Name:                     pulumi.String("Asset1"),
			ResourceGroupName:        example.Name,
			MediaServicesAccountName: exampleServiceAccount.Name,
			Description:              pulumi.String("Asset description"),
		})
		if err != nil {
			return err
		}
		_, err = media.NewStreamingLocator(ctx, "example", &media.StreamingLocatorArgs{
			Name:                     pulumi.String("example"),
			ResourceGroupName:        example.Name,
			MediaServicesAccountName: exampleServiceAccount.Name,
			AssetName:                exampleAsset.Name,
			StreamingPolicyName:      pulumi.String("Predefined_ClearStreamingOnly"),
			FilterNames: pulumi.StringArray{
				exampleAccountFilter.Name,
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}
Content copied to clipboard
package generated_program;
import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.storage.Account;
import com.pulumi.azure.storage.AccountArgs;
import com.pulumi.azure.media.ServiceAccount;
import com.pulumi.azure.media.ServiceAccountArgs;
import com.pulumi.azure.media.inputs.ServiceAccountStorageAccountArgs;
import com.pulumi.azure.media.AccountFilter;
import com.pulumi.azure.media.AccountFilterArgs;
import com.pulumi.azure.media.Asset;
import com.pulumi.azure.media.AssetArgs;
import com.pulumi.azure.media.StreamingLocator;
import com.pulumi.azure.media.StreamingLocatorArgs;
import java.util.List;
import java.util.ArrayList;
import java.util.Map;
import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;
public class App {
    public static void main(String[] args) {
        Pulumi.run(App::stack);
    }
    public static void stack(Context ctx) {
        var example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("media-resources")
            .location("West Europe")
            .build());
        var exampleAccount = new Account("exampleAccount", AccountArgs.builder()
            .name("examplestoracc")
            .resourceGroupName(example.name())
            .location(example.location())
            .accountTier("Standard")
            .accountReplicationType("GRS")
            .build());
        var exampleServiceAccount = new ServiceAccount("exampleServiceAccount", ServiceAccountArgs.builder()
            .name("examplemediaacc")
            .location(example.location())
            .resourceGroupName(example.name())
            .storageAccounts(ServiceAccountStorageAccountArgs.builder()
                .id(exampleAccount.id())
                .isPrimary(true)
                .build())
            .build());
        var exampleAccountFilter = new AccountFilter("exampleAccountFilter", AccountFilterArgs.builder()
            .name("Filter1")
            .resourceGroupName(example.name())
            .mediaServicesAccountName(exampleServiceAccount.name())
            .build());
        var exampleAsset = new Asset("exampleAsset", AssetArgs.builder()
            .name("Asset1")
            .resourceGroupName(example.name())
            .mediaServicesAccountName(exampleServiceAccount.name())
            .description("Asset description")
            .build());
        var exampleStreamingLocator = new StreamingLocator("exampleStreamingLocator", StreamingLocatorArgs.builder()
            .name("example")
            .resourceGroupName(example.name())
            .mediaServicesAccountName(exampleServiceAccount.name())
            .assetName(exampleAsset.name())
            .streamingPolicyName("Predefined_ClearStreamingOnly")
            .filterNames(exampleAccountFilter.name())
            .build());
    }
}
Content copied to clipboard
resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: media-resources
      location: West Europe
  exampleAccount:
    type: azure:storage:Account
    name: example
    properties:
      name: examplestoracc
      resourceGroupName: ${example.name}
      location: ${example.location}
      accountTier: Standard
      accountReplicationType: GRS
  exampleServiceAccount:
    type: azure:media:ServiceAccount
    name: example
    properties:
      name: examplemediaacc
      location: ${example.location}
      resourceGroupName: ${example.name}
      storageAccounts:
        - id: ${exampleAccount.id}
          isPrimary: true
  exampleAccountFilter:
    type: azure:media:AccountFilter
    name: example
    properties:
      name: Filter1
      resourceGroupName: ${example.name}
      mediaServicesAccountName: ${exampleServiceAccount.name}
  exampleAsset:
    type: azure:media:Asset
    name: example
    properties:
      name: Asset1
      resourceGroupName: ${example.name}
      mediaServicesAccountName: ${exampleServiceAccount.name}
      description: Asset description
  exampleStreamingLocator:
    type: azure:media:StreamingLocator
    name: example
    properties:
      name: example
      resourceGroupName: ${example.name}
      mediaServicesAccountName: ${exampleServiceAccount.name}
      assetName: ${exampleAsset.name}
      streamingPolicyName: Predefined_ClearStreamingOnly
      filterNames:
        - ${exampleAccountFilter.name}
Content copied to clipboard

Import

Streaming Locators can be imported using the resource id, e.g.

$ pulumi import azure:media/streamingLocator:StreamingLocator example /subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/group1/providers/Microsoft.Media/mediaServices/account1/streamingLocators/locator1
Content copied to clipboard

Properties

Link copied to clipboard
val alternativeMediaId: Output<String>?

Alternative Media ID of this Streaming Locator. Changing this forces a new Streaming Locator to be created.

Link copied to clipboard
val assetName: Output<String>

Asset Name. Changing this forces a new Streaming Locator to be created.

Link copied to clipboard
val contentKeys: Output<List<StreamingLocatorContentKey>>?

One or more content_key blocks as defined below. Changing this forces a new Streaming Locator to be created.

Link copied to clipboard
val defaultContentKeyPolicyName: Output<String>?

Name of the default Content Key Policy used by this Streaming Locator.Changing this forces a new Streaming Locator to be created.

Link copied to clipboard
val endTime: Output<String>

The end time of the Streaming Locator. Changing this forces a new Streaming Locator to be created.

Link copied to clipboard
val filterNames: Output<List<String>>?

A list of names of asset or account filters which apply to this Streaming Locator. Changing this forces a new Streaming Locator to be created.

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val mediaServicesAccountName: Output<String>

The Media Services account name. Changing this forces a new Streaming Locator to be created.

Link copied to clipboard
val name: Output<String>

The name which should be used for this Streaming Locator. Changing this forces a new Streaming Locator to be created.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val resourceGroupName: Output<String>

The name of the Resource Group where the Streaming Locator should exist. Changing this forces a new Streaming Locator to be created.

Link copied to clipboard
val startTime: Output<String>?

The start time of the Streaming Locator. Changing this forces a new Streaming Locator to be created.

Link copied to clipboard
val streamingLocatorId: Output<String>

The ID of the Streaming Locator. Changing this forces a new Streaming Locator to be created.

Link copied to clipboard
val streamingPolicyName: Output<String>

Name of the Streaming Policy used by this Streaming Locator. Either specify the name of Streaming Policy you created or use one of the predefined Streaming Policies. The predefined Streaming Policies available are: Predefined_DownloadOnly, Predefined_ClearStreamingOnly, Predefined_DownloadAndClearStreaming, Predefined_ClearKey, Predefined_MultiDrmCencStreaming and Predefined_MultiDrmStreaming. Changing this forces a new Streaming Locator to be created.

Link copied to clipboard
val urn: Output<String>