pulumi-azure-native-kotlin/com.pulumi.azurenative.videoindexer.kotlin/Account

Account

class Account : KotlinCustomResource

An Azure Video Analyzer for Media account. API Version: 2021-10-18-preview.

Example Usage

Put example #1

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var account = new AzureNative.VideoIndexer.Account("account", new()
    {
        AccountName = "contosto-videoanalyzer",
        Identity = new AzureNative.VideoIndexer.Inputs.ManagedServiceIdentityArgs
        {
            Type = "UserAssigned",
            UserAssignedIdentities =
            {
                { "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", null },
            },
        },
        Location = "NorthEurope",
        MediaServices = new AzureNative.VideoIndexer.Inputs.MediaServicesForPutRequestArgs
        {
            ResourceId = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms",
            UserAssignedIdentity = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi",
        },
        ResourceGroupName = "contosto-videoanalyzer-rg",
    });
});
Content copied to clipboard
package main
import (
	videoindexer "github.com/pulumi/pulumi-azure-native-sdk/videoindexer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := videoindexer.NewAccount(ctx, "account", &videoindexer.AccountArgs{
			AccountName: pulumi.String("contosto-videoanalyzer"),
			Identity: &videoindexer.ManagedServiceIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				UserAssignedIdentities: pulumi.AnyMap{
					"/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi": nil,
				},
			},
			Location: pulumi.String("NorthEurope"),
			MediaServices: &videoindexer.MediaServicesForPutRequestArgs{
				ResourceId:           pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
				UserAssignedIdentity: pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi"),
			},
			ResourceGroupName: pulumi.String("contosto-videoanalyzer-rg"),
		})
		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.azurenative.videoindexer.Account;
import com.pulumi.azurenative.videoindexer.AccountArgs;
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 account = new Account("account", AccountArgs.builder()
            .accountName("contosto-videoanalyzer")
            .identity(Map.ofEntries(
                Map.entry("type", "UserAssigned"),
                Map.entry("userAssignedIdentities", Map.of("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", ))
            ))
            .location("NorthEurope")
            .mediaServices(Map.ofEntries(
                Map.entry("resourceId", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
                Map.entry("userAssignedIdentity", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi")
            ))
            .resourceGroupName("contosto-videoanalyzer-rg")
            .build());
    }
}
Content copied to clipboard

Put example #10

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var account = new AzureNative.VideoIndexer.Account("account", new()
    {
        AccountName = "contosto-videoanalyzer",
        Identity = new AzureNative.VideoIndexer.Inputs.ManagedServiceIdentityArgs
        {
            Type = "UserAssigned",
            UserAssignedIdentities = null,
        },
        Location = "NorthEurope",
        MediaServices = new AzureNative.VideoIndexer.Inputs.MediaServicesForPutRequestArgs
        {
            ResourceId = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms",
            UserAssignedIdentity = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi",
        },
        ResourceGroupName = "contosto-videoanalyzer-rg",
    });
});
Content copied to clipboard
package main
import (
	videoindexer "github.com/pulumi/pulumi-azure-native-sdk/videoindexer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := videoindexer.NewAccount(ctx, "account", &videoindexer.AccountArgs{
			AccountName: pulumi.String("contosto-videoanalyzer"),
			Identity: &videoindexer.ManagedServiceIdentityArgs{
				Type:                   pulumi.String("UserAssigned"),
				UserAssignedIdentities: nil,
			},
			Location: pulumi.String("NorthEurope"),
			MediaServices: &videoindexer.MediaServicesForPutRequestArgs{
				ResourceId:           pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
				UserAssignedIdentity: pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi"),
			},
			ResourceGroupName: pulumi.String("contosto-videoanalyzer-rg"),
		})
		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.azurenative.videoindexer.Account;
import com.pulumi.azurenative.videoindexer.AccountArgs;
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 account = new Account("account", AccountArgs.builder()
            .accountName("contosto-videoanalyzer")
            .identity(Map.ofEntries(
                Map.entry("type", "UserAssigned"),
                Map.entry("userAssignedIdentities", )
            ))
            .location("NorthEurope")
            .mediaServices(Map.ofEntries(
                Map.entry("resourceId", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
                Map.entry("userAssignedIdentity", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi")
            ))
            .resourceGroupName("contosto-videoanalyzer-rg")
            .build());
    }
}
Content copied to clipboard

Put example #2

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var account = new AzureNative.VideoIndexer.Account("account", new()
    {
        AccountName = "contosto-videoanalyzer",
        Identity = new AzureNative.VideoIndexer.Inputs.ManagedServiceIdentityArgs
        {
            Type = "UserAssigned",
            UserAssignedIdentities =
            {
                { "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", null },
            },
        },
        Location = "NorthEurope",
        MediaServices = new AzureNative.VideoIndexer.Inputs.MediaServicesForPutRequestArgs
        {
            ResourceId = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms",
            UserAssignedIdentity = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi",
        },
        ResourceGroupName = "contosto-videoanalyzer-rg",
    });
});
Content copied to clipboard
package main
import (
	videoindexer "github.com/pulumi/pulumi-azure-native-sdk/videoindexer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := videoindexer.NewAccount(ctx, "account", &videoindexer.AccountArgs{
			AccountName: pulumi.String("contosto-videoanalyzer"),
			Identity: &videoindexer.ManagedServiceIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				UserAssignedIdentities: pulumi.AnyMap{
					"/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi": nil,
				},
			},
			Location: pulumi.String("NorthEurope"),
			MediaServices: &videoindexer.MediaServicesForPutRequestArgs{
				ResourceId:           pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
				UserAssignedIdentity: pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi"),
			},
			ResourceGroupName: pulumi.String("contosto-videoanalyzer-rg"),
		})
		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.azurenative.videoindexer.Account;
import com.pulumi.azurenative.videoindexer.AccountArgs;
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 account = new Account("account", AccountArgs.builder()
            .accountName("contosto-videoanalyzer")
            .identity(Map.ofEntries(
                Map.entry("type", "UserAssigned"),
                Map.entry("userAssignedIdentities", Map.of("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", ))
            ))
            .location("NorthEurope")
            .mediaServices(Map.ofEntries(
                Map.entry("resourceId", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
                Map.entry("userAssignedIdentity", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi")
            ))
            .resourceGroupName("contosto-videoanalyzer-rg")
            .build());
    }
}
Content copied to clipboard

Put example #3

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var account = new AzureNative.VideoIndexer.Account("account", new()
    {
        AccountName = "contosto-videoanalyzer",
        Identity = new AzureNative.VideoIndexer.Inputs.ManagedServiceIdentityArgs
        {
            Type = "UserAssigned",
            UserAssignedIdentities =
            {
                { "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", null },
            },
        },
        Location = "NorthEurope",
        MediaServices = new AzureNative.VideoIndexer.Inputs.MediaServicesForPutRequestArgs
        {
            ResourceId = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms",
            UserAssignedIdentity = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi",
        },
        ResourceGroupName = "contosto-videoanalyzer-rg",
    });
});
Content copied to clipboard
package main
import (
	videoindexer "github.com/pulumi/pulumi-azure-native-sdk/videoindexer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := videoindexer.NewAccount(ctx, "account", &videoindexer.AccountArgs{
			AccountName: pulumi.String("contosto-videoanalyzer"),
			Identity: &videoindexer.ManagedServiceIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				UserAssignedIdentities: pulumi.AnyMap{
					"/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi": nil,
				},
			},
			Location: pulumi.String("NorthEurope"),
			MediaServices: &videoindexer.MediaServicesForPutRequestArgs{
				ResourceId:           pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
				UserAssignedIdentity: pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi"),
			},
			ResourceGroupName: pulumi.String("contosto-videoanalyzer-rg"),
		})
		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.azurenative.videoindexer.Account;
import com.pulumi.azurenative.videoindexer.AccountArgs;
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 account = new Account("account", AccountArgs.builder()
            .accountName("contosto-videoanalyzer")
            .identity(Map.ofEntries(
                Map.entry("type", "UserAssigned"),
                Map.entry("userAssignedIdentities", Map.of("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", ))
            ))
            .location("NorthEurope")
            .mediaServices(Map.ofEntries(
                Map.entry("resourceId", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
                Map.entry("userAssignedIdentity", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi")
            ))
            .resourceGroupName("contosto-videoanalyzer-rg")
            .build());
    }
}
Content copied to clipboard

Put example #4

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var account = new AzureNative.VideoIndexer.Account("account", new()
    {
        AccountName = "contosto-videoanalyzer",
        Identity = new AzureNative.VideoIndexer.Inputs.ManagedServiceIdentityArgs
        {
            Type = "UserAssigned",
            UserAssignedIdentities =
            {
                { "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", null },
            },
        },
        Location = "NorthEurope",
        MediaServices = new AzureNative.VideoIndexer.Inputs.MediaServicesForPutRequestArgs
        {
            ResourceId = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms",
            UserAssignedIdentity = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi",
        },
        ResourceGroupName = "contosto-videoanalyzer-rg",
    });
});
Content copied to clipboard
package main
import (
	videoindexer "github.com/pulumi/pulumi-azure-native-sdk/videoindexer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := videoindexer.NewAccount(ctx, "account", &videoindexer.AccountArgs{
			AccountName: pulumi.String("contosto-videoanalyzer"),
			Identity: &videoindexer.ManagedServiceIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				UserAssignedIdentities: pulumi.AnyMap{
					"/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi": nil,
				},
			},
			Location: pulumi.String("NorthEurope"),
			MediaServices: &videoindexer.MediaServicesForPutRequestArgs{
				ResourceId:           pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
				UserAssignedIdentity: pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi"),
			},
			ResourceGroupName: pulumi.String("contosto-videoanalyzer-rg"),
		})
		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.azurenative.videoindexer.Account;
import com.pulumi.azurenative.videoindexer.AccountArgs;
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 account = new Account("account", AccountArgs.builder()
            .accountName("contosto-videoanalyzer")
            .identity(Map.ofEntries(
                Map.entry("type", "UserAssigned"),
                Map.entry("userAssignedIdentities", Map.of("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", ))
            ))
            .location("NorthEurope")
            .mediaServices(Map.ofEntries(
                Map.entry("resourceId", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
                Map.entry("userAssignedIdentity", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi")
            ))
            .resourceGroupName("contosto-videoanalyzer-rg")
            .build());
    }
}
Content copied to clipboard

Put example #5

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var account = new AzureNative.VideoIndexer.Account("account", new()
    {
        AccountName = "contosto-videoanalyzer",
        Identity = new AzureNative.VideoIndexer.Inputs.ManagedServiceIdentityArgs
        {
            Type = "UserAssigned",
            UserAssignedIdentities =
            {
                { "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", null },
            },
        },
        Location = "NorthEurope",
        MediaServices = new AzureNative.VideoIndexer.Inputs.MediaServicesForPutRequestArgs
        {
            ResourceId = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms",
            UserAssignedIdentity = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi",
        },
        ResourceGroupName = "contosto-videoanalyzer-rg",
    });
});
Content copied to clipboard
package main
import (
	videoindexer "github.com/pulumi/pulumi-azure-native-sdk/videoindexer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := videoindexer.NewAccount(ctx, "account", &videoindexer.AccountArgs{
			AccountName: pulumi.String("contosto-videoanalyzer"),
			Identity: &videoindexer.ManagedServiceIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				UserAssignedIdentities: pulumi.AnyMap{
					"/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi": nil,
				},
			},
			Location: pulumi.String("NorthEurope"),
			MediaServices: &videoindexer.MediaServicesForPutRequestArgs{
				ResourceId:           pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
				UserAssignedIdentity: pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi"),
			},
			ResourceGroupName: pulumi.String("contosto-videoanalyzer-rg"),
		})
		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.azurenative.videoindexer.Account;
import com.pulumi.azurenative.videoindexer.AccountArgs;
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 account = new Account("account", AccountArgs.builder()
            .accountName("contosto-videoanalyzer")
            .identity(Map.ofEntries(
                Map.entry("type", "UserAssigned"),
                Map.entry("userAssignedIdentities", Map.of("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", ))
            ))
            .location("NorthEurope")
            .mediaServices(Map.ofEntries(
                Map.entry("resourceId", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
                Map.entry("userAssignedIdentity", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi")
            ))
            .resourceGroupName("contosto-videoanalyzer-rg")
            .build());
    }
}
Content copied to clipboard

Put example #6

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var account = new AzureNative.VideoIndexer.Account("account", new()
    {
        AccountName = "contosto-videoanalyzer",
        Identity = new AzureNative.VideoIndexer.Inputs.ManagedServiceIdentityArgs
        {
            Type = "UserAssigned",
            UserAssignedIdentities =
            {
                { "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", null },
            },
        },
        Location = "NorthEurope",
        MediaServices = new AzureNative.VideoIndexer.Inputs.MediaServicesForPutRequestArgs
        {
            ResourceId = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms",
            UserAssignedIdentity = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi",
        },
        ResourceGroupName = "contosto-videoanalyzer-rg",
    });
});
Content copied to clipboard
package main
import (
	videoindexer "github.com/pulumi/pulumi-azure-native-sdk/videoindexer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := videoindexer.NewAccount(ctx, "account", &videoindexer.AccountArgs{
			AccountName: pulumi.String("contosto-videoanalyzer"),
			Identity: &videoindexer.ManagedServiceIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				UserAssignedIdentities: pulumi.AnyMap{
					"/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi": nil,
				},
			},
			Location: pulumi.String("NorthEurope"),
			MediaServices: &videoindexer.MediaServicesForPutRequestArgs{
				ResourceId:           pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
				UserAssignedIdentity: pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi"),
			},
			ResourceGroupName: pulumi.String("contosto-videoanalyzer-rg"),
		})
		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.azurenative.videoindexer.Account;
import com.pulumi.azurenative.videoindexer.AccountArgs;
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 account = new Account("account", AccountArgs.builder()
            .accountName("contosto-videoanalyzer")
            .identity(Map.ofEntries(
                Map.entry("type", "UserAssigned"),
                Map.entry("userAssignedIdentities", Map.of("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", ))
            ))
            .location("NorthEurope")
            .mediaServices(Map.ofEntries(
                Map.entry("resourceId", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
                Map.entry("userAssignedIdentity", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi")
            ))
            .resourceGroupName("contosto-videoanalyzer-rg")
            .build());
    }
}
Content copied to clipboard

Put example #7

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var account = new AzureNative.VideoIndexer.Account("account", new()
    {
        AccountName = "contosto-videoanalyzer",
        Identity = new AzureNative.VideoIndexer.Inputs.ManagedServiceIdentityArgs
        {
            Type = "UserAssigned",
            UserAssignedIdentities =
            {
                { "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", null },
            },
        },
        Location = "NorthEurope",
        MediaServices = new AzureNative.VideoIndexer.Inputs.MediaServicesForPutRequestArgs
        {
            ResourceId = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms",
            UserAssignedIdentity = "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi",
        },
        ResourceGroupName = "contosto-videoanalyzer-rg",
    });
});
Content copied to clipboard
package main
import (
	videoindexer "github.com/pulumi/pulumi-azure-native-sdk/videoindexer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := videoindexer.NewAccount(ctx, "account", &videoindexer.AccountArgs{
			AccountName: pulumi.String("contosto-videoanalyzer"),
			Identity: &videoindexer.ManagedServiceIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				UserAssignedIdentities: pulumi.AnyMap{
					"/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi": nil,
				},
			},
			Location: pulumi.String("NorthEurope"),
			MediaServices: &videoindexer.MediaServicesForPutRequestArgs{
				ResourceId:           pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
				UserAssignedIdentity: pulumi.String("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi"),
			},
			ResourceGroupName: pulumi.String("contosto-videoanalyzer-rg"),
		})
		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.azurenative.videoindexer.Account;
import com.pulumi.azurenative.videoindexer.AccountArgs;
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 account = new Account("account", AccountArgs.builder()
            .accountName("contosto-videoanalyzer")
            .identity(Map.ofEntries(
                Map.entry("type", "UserAssigned"),
                Map.entry("userAssignedIdentities", Map.of("/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi", ))
            ))
            .location("NorthEurope")
            .mediaServices(Map.ofEntries(
                Map.entry("resourceId", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.Media/mediaservices/contoso-videoanalyzer-ms"),
                Map.entry("userAssignedIdentity", "/subscriptions/xxx/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/contoso-videoanalyzer-mi")
            ))
            .resourceGroupName("contosto-videoanalyzer-rg")
            .build());
    }
}
Content copied to clipboard

Put example #8

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var account = new AzureNative.VideoIndexer.Account("account", new()
    {
        AccountName = "contosto-videoanalyzer",
        Identity = new AzureNative.VideoIndexer.Inputs.ManagedServiceIdentityArgs
        {
            Type = "UserAssigned",
            UserAssignedIdentities =
            {
                { "subscriptions/24237b72-8546-4da5-b204-8c3cb76dd930/resourceGroups/uratzmon-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/talshoham", null },
            },
        },
        Location = "NorthEurope",
        MediaServices = new AzureNative.VideoIndexer.Inputs.MediaServicesForPutRequestArgs
        {
            ResourceId = "/subscriptions/24237b72-8546-4da5-b204-8c3cb76dd930/resourceGroups/uratzmon-rg/providers/Microsoft.Media/mediaservices/talshoham",
        },
        ResourceGroupName = "contosto-videoanalyzer-rg",
    });
});
Content copied to clipboard
package main
import (
	videoindexer "github.com/pulumi/pulumi-azure-native-sdk/videoindexer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := videoindexer.NewAccount(ctx, "account", &videoindexer.AccountArgs{
			AccountName: pulumi.String("contosto-videoanalyzer"),
			Identity: &videoindexer.ManagedServiceIdentityArgs{
				Type: pulumi.String("UserAssigned"),
				UserAssignedIdentities: pulumi.AnyMap{
					"subscriptions/24237b72-8546-4da5-b204-8c3cb76dd930/resourceGroups/uratzmon-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/talshoham": nil,
				},
			},
			Location: pulumi.String("NorthEurope"),
			MediaServices: &videoindexer.MediaServicesForPutRequestArgs{
				ResourceId: pulumi.String("/subscriptions/24237b72-8546-4da5-b204-8c3cb76dd930/resourceGroups/uratzmon-rg/providers/Microsoft.Media/mediaservices/talshoham"),
			},
			ResourceGroupName: pulumi.String("contosto-videoanalyzer-rg"),
		})
		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.azurenative.videoindexer.Account;
import com.pulumi.azurenative.videoindexer.AccountArgs;
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 account = new Account("account", AccountArgs.builder()
            .accountName("contosto-videoanalyzer")
            .identity(Map.ofEntries(
                Map.entry("type", "UserAssigned"),
                Map.entry("userAssignedIdentities", Map.of("subscriptions/24237b72-8546-4da5-b204-8c3cb76dd930/resourceGroups/uratzmon-rg/providers/Microsoft.ManagedIdentity/userAssignedIdentities/talshoham", ))
            ))
            .location("NorthEurope")
            .mediaServices(Map.of("resourceId", "/subscriptions/24237b72-8546-4da5-b204-8c3cb76dd930/resourceGroups/uratzmon-rg/providers/Microsoft.Media/mediaservices/talshoham"))
            .resourceGroupName("contosto-videoanalyzer-rg")
            .build());
    }
}
Content copied to clipboard

Put example #9

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var account = new AzureNative.VideoIndexer.Account("account", new()
    {
        AccountName = "contosto-videoanalyzer",
        ResourceGroupName = "contosto-videoanalyzer-rg",
    });
});
Content copied to clipboard
package main
import (
	videoindexer "github.com/pulumi/pulumi-azure-native-sdk/videoindexer"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := videoindexer.NewAccount(ctx, "account", &videoindexer.AccountArgs{
			AccountName:       pulumi.String("contosto-videoanalyzer"),
			ResourceGroupName: pulumi.String("contosto-videoanalyzer-rg"),
		})
		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.azurenative.videoindexer.Account;
import com.pulumi.azurenative.videoindexer.AccountArgs;
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 account = new Account("account", AccountArgs.builder()
            .accountName("contosto-videoanalyzer")
            .resourceGroupName("contosto-videoanalyzer-rg")
            .build());
    }
}
Content copied to clipboard

Import

An existing resource can be imported using its type token, name, and identifier, e.g.

$ pulumi import azure-native:videoindexer:Account contosto-videoanalyzer /subscriptions/586d4f48-8f08-4a4e-96b7-e1892d6dba9e/resourceGroups/contoso-videoanalyzer-rg/providers/Microsoft.VideoIndexer/accounts/contosto-videoanalyzer
Content copied to clipboard

Properties

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

The account's data-plane ID. This can be set only when connecting an existing classic account

Link copied to clipboard
val accountName: Output<String>

The account's name

Link copied to clipboard
val id: Output<String>
Link copied to clipboard
val identity: Output<ManagedServiceIdentityResponse>?

Managed service identity (system assigned and/or user assigned identities)

Link copied to clipboard
val location: Output<String>

The geo-location where the resource lives

Link copied to clipboard
val mediaServices: Output<MediaServicesForPutRequestResponse>?

The media services details

Link copied to clipboard
val name: Output<String>

The name of the resource

Link copied to clipboard
val provisioningState: Output<String>

Gets the status of the account at the time the operation was called.

Link copied to clipboard
val pulumiChildResources: Set<KotlinResource>
Link copied to clipboard
Link copied to clipboard
Link copied to clipboard
val systemData: Output<SystemDataResponse>

The system meta data relating to this resource.

Link copied to clipboard
val tags: Output<Map<String, String>>?

Resource tags.

Link copied to clipboard
val tenantId: Output<String>

The account's tenant id

Link copied to clipboard
val type: Output<String>

The type of the resource. E.g. "Microsoft.Compute/virtualMachines" or "Microsoft.Storage/storageAccounts"

Link copied to clipboard
val urn: Output<String>