azure.machinelearning.ComputeCluster

using Pulumi;
using Azure = Pulumi.Azure;

class MyStack : Stack
{
    public MyStack()
    {
        var current = Output.Create(Azure.Core.GetClientConfig.InvokeAsync());
        var exampleResourceGroup = new Azure.Core.ResourceGroup("exampleResourceGroup", new Azure.Core.ResourceGroupArgs
        {
            Location = "west europe",
            Tags = 
            {
                { "stage", "example" },
            },
        });
        var exampleInsights = new Azure.AppInsights.Insights("exampleInsights", new Azure.AppInsights.InsightsArgs
        {
            Location = exampleResourceGroup.Location,
            ResourceGroupName = exampleResourceGroup.Name,
            ApplicationType = "web",
        });
        var exampleKeyVault = new Azure.KeyVault.KeyVault("exampleKeyVault", new Azure.KeyVault.KeyVaultArgs
        {
            Location = exampleResourceGroup.Location,
            ResourceGroupName = exampleResourceGroup.Name,
            TenantId = current.Apply(current => current.TenantId),
            SkuName = "standard",
            PurgeProtectionEnabled = true,
        });
        var exampleAccount = new Azure.Storage.Account("exampleAccount", new Azure.Storage.AccountArgs
        {
            Location = exampleResourceGroup.Location,
            ResourceGroupName = exampleResourceGroup.Name,
            AccountTier = "Standard",
            AccountReplicationType = "LRS",
        });
        var exampleWorkspace = new Azure.MachineLearning.Workspace("exampleWorkspace", new Azure.MachineLearning.WorkspaceArgs
        {
            Location = exampleResourceGroup.Location,
            ResourceGroupName = exampleResourceGroup.Name,
            ApplicationInsightsId = exampleInsights.Id,
            KeyVaultId = exampleKeyVault.Id,
            StorageAccountId = exampleAccount.Id,
            Identity = new Azure.MachineLearning.Inputs.WorkspaceIdentityArgs
            {
                Type = "SystemAssigned",
            },
        });
        var exampleVirtualNetwork = new Azure.Network.VirtualNetwork("exampleVirtualNetwork", new Azure.Network.VirtualNetworkArgs
        {
            AddressSpaces = 
            {
                "10.1.0.0/16",
            },
            Location = exampleResourceGroup.Location,
            ResourceGroupName = exampleResourceGroup.Name,
        });
        var exampleSubnet = new Azure.Network.Subnet("exampleSubnet", new Azure.Network.SubnetArgs
        {
            ResourceGroupName = exampleResourceGroup.Name,
            VirtualNetworkName = exampleVirtualNetwork.Name,
            AddressPrefixes = 
            {
                "10.1.0.0/24",
            },
        });
        var test = new Azure.MachineLearning.ComputeCluster("test", new Azure.MachineLearning.ComputeClusterArgs
        {
            Location = "West Europe",
            VmPriority = "LowPriority",
            VmSize = "Standard_DS2_v2",
            MachineLearningWorkspaceId = exampleWorkspace.Id,
            SubnetResourceId = exampleSubnet.Id,
            ScaleSettings = new Azure.MachineLearning.Inputs.ComputeClusterScaleSettingsArgs
            {
                MinNodeCount = 0,
                MaxNodeCount = 1,
                ScaleDownNodesAfterIdleDuration = "PT30S",
            },
            Identity = new Azure.MachineLearning.Inputs.ComputeClusterIdentityArgs
            {
                Type = "SystemAssigned",
            },
        });
    }

}

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/appinsights"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/keyvault"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/machinelearning"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/network"
	"github.com/pulumi/pulumi-azure/sdk/v4/go/azure/storage"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)

func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		current, err := core.GetClientConfig(ctx, nil, nil)
		if err != nil {
			return err
		}
		exampleResourceGroup, err := core.NewResourceGroup(ctx, "exampleResourceGroup", &core.ResourceGroupArgs{
			Location: pulumi.String("west europe"),
			Tags: pulumi.StringMap{
				"stage": pulumi.String("example"),
			},
		})
		if err != nil {
			return err
		}
		exampleInsights, err := appinsights.NewInsights(ctx, "exampleInsights", &appinsights.InsightsArgs{
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
			ApplicationType:   pulumi.String("web"),
		})
		if err != nil {
			return err
		}
		exampleKeyVault, err := keyvault.NewKeyVault(ctx, "exampleKeyVault", &keyvault.KeyVaultArgs{
			Location:               exampleResourceGroup.Location,
			ResourceGroupName:      exampleResourceGroup.Name,
			TenantId:               pulumi.String(current.TenantId),
			SkuName:                pulumi.String("standard"),
			PurgeProtectionEnabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "exampleAccount", &storage.AccountArgs{
			Location:               exampleResourceGroup.Location,
			ResourceGroupName:      exampleResourceGroup.Name,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
		})
		if err != nil {
			return err
		}
		exampleWorkspace, err := machinelearning.NewWorkspace(ctx, "exampleWorkspace", &machinelearning.WorkspaceArgs{
			Location:              exampleResourceGroup.Location,
			ResourceGroupName:     exampleResourceGroup.Name,
			ApplicationInsightsId: exampleInsights.ID(),
			KeyVaultId:            exampleKeyVault.ID(),
			StorageAccountId:      exampleAccount.ID(),
			Identity: &machinelearning.WorkspaceIdentityArgs{
				Type: pulumi.String("SystemAssigned"),
			},
		})
		if err != nil {
			return err
		}
		exampleVirtualNetwork, err := network.NewVirtualNetwork(ctx, "exampleVirtualNetwork", &network.VirtualNetworkArgs{
			AddressSpaces: pulumi.StringArray{
				pulumi.String("10.1.0.0/16"),
			},
			Location:          exampleResourceGroup.Location,
			ResourceGroupName: exampleResourceGroup.Name,
		})
		if err != nil {
			return err
		}
		exampleSubnet, err := network.NewSubnet(ctx, "exampleSubnet", &network.SubnetArgs{
			ResourceGroupName:  exampleResourceGroup.Name,
			VirtualNetworkName: exampleVirtualNetwork.Name,
			AddressPrefixes: pulumi.StringArray{
				pulumi.String("10.1.0.0/24"),
			},
		})
		if err != nil {
			return err
		}
		_, err = machinelearning.NewComputeCluster(ctx, "test", &machinelearning.ComputeClusterArgs{
			Location:                   pulumi.String("West Europe"),
			VmPriority:                 pulumi.String("LowPriority"),
			VmSize:                     pulumi.String("Standard_DS2_v2"),
			MachineLearningWorkspaceId: exampleWorkspace.ID(),
			SubnetResourceId:           exampleSubnet.ID(),
			ScaleSettings: &machinelearning.ComputeClusterScaleSettingsArgs{
				MinNodeCount:                    pulumi.Int(0),
				MaxNodeCount:                    pulumi.Int(1),
				ScaleDownNodesAfterIdleDuration: pulumi.String("PT30S"),
			},
			Identity: &machinelearning.ComputeClusterIdentityArgs{
				Type: pulumi.String("SystemAssigned"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

import * as pulumi from "@pulumi/pulumi";
import * as azure from "@pulumi/azure";

const current = azure.core.getClientConfig({});
const exampleResourceGroup = new azure.core.ResourceGroup("exampleResourceGroup", {
    location: "west europe",
    tags: {
        stage: "example",
    },
});
const exampleInsights = new azure.appinsights.Insights("exampleInsights", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    applicationType: "web",
});
const exampleKeyVault = new azure.keyvault.KeyVault("exampleKeyVault", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    tenantId: current.then(current => current.tenantId),
    skuName: "standard",
    purgeProtectionEnabled: true,
});
const exampleAccount = new azure.storage.Account("exampleAccount", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    accountTier: "Standard",
    accountReplicationType: "LRS",
});
const exampleWorkspace = new azure.machinelearning.Workspace("exampleWorkspace", {
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
    applicationInsightsId: exampleInsights.id,
    keyVaultId: exampleKeyVault.id,
    storageAccountId: exampleAccount.id,
    identity: {
        type: "SystemAssigned",
    },
});
const exampleVirtualNetwork = new azure.network.VirtualNetwork("exampleVirtualNetwork", {
    addressSpaces: ["10.1.0.0/16"],
    location: exampleResourceGroup.location,
    resourceGroupName: exampleResourceGroup.name,
});
const exampleSubnet = new azure.network.Subnet("exampleSubnet", {
    resourceGroupName: exampleResourceGroup.name,
    virtualNetworkName: exampleVirtualNetwork.name,
    addressPrefixes: ["10.1.0.0/24"],
});
const test = new azure.machinelearning.ComputeCluster("test", {
    location: "West Europe",
    vmPriority: "LowPriority",
    vmSize: "Standard_DS2_v2",
    machineLearningWorkspaceId: exampleWorkspace.id,
    subnetResourceId: exampleSubnet.id,
    scaleSettings: {
        minNodeCount: 0,
        maxNodeCount: 1,
        scaleDownNodesAfterIdleDuration: "PT30S",
    },
    identity: {
        type: "SystemAssigned",
    },
});

import pulumi
import pulumi_azure as azure

current = azure.core.get_client_config()
example_resource_group = azure.core.ResourceGroup("exampleResourceGroup",
    location="west europe",
    tags={
        "stage": "example",
    })
example_insights = azure.appinsights.Insights("exampleInsights",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    application_type="web")
example_key_vault = azure.keyvault.KeyVault("exampleKeyVault",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    tenant_id=current.tenant_id,
    sku_name="standard",
    purge_protection_enabled=True)
example_account = azure.storage.Account("exampleAccount",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    account_tier="Standard",
    account_replication_type="LRS")
example_workspace = azure.machinelearning.Workspace("exampleWorkspace",
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name,
    application_insights_id=example_insights.id,
    key_vault_id=example_key_vault.id,
    storage_account_id=example_account.id,
    identity=azure.machinelearning.WorkspaceIdentityArgs(
        type="SystemAssigned",
    ))
example_virtual_network = azure.network.VirtualNetwork("exampleVirtualNetwork",
    address_spaces=["10.1.0.0/16"],
    location=example_resource_group.location,
    resource_group_name=example_resource_group.name)
example_subnet = azure.network.Subnet("exampleSubnet",
    resource_group_name=example_resource_group.name,
    virtual_network_name=example_virtual_network.name,
    address_prefixes=["10.1.0.0/24"])
test = azure.machinelearning.ComputeCluster("test",
    location="West Europe",
    vm_priority="LowPriority",
    vm_size="Standard_DS2_v2",
    machine_learning_workspace_id=example_workspace.id,
    subnet_resource_id=example_subnet.id,
    scale_settings=azure.machinelearning.ComputeClusterScaleSettingsArgs(
        min_node_count=0,
        max_node_count=1,
        scale_down_nodes_after_idle_duration="PT30S",
    ),
    identity=azure.machinelearning.ComputeClusterIdentityArgs(
        type="SystemAssigned",
    ))