pulumi-azure-native-kotlin/com.pulumi.azurenative.machinelearningservices.kotlin/ComputeArgs

ComputeArgs

data class ComputeArgs(val computeName: Output<String>? = null, val identity: Output<ManagedServiceIdentityArgs>? = null, val location: Output<String>? = null, val properties: Output<Any>? = null, val resourceGroupName: Output<String>? = null, val sku: Output<SkuArgs>? = null, val tags: Output<Map<String, String>>? = null, val workspaceName: Output<String>? = null) : ConvertibleToJava<ComputeArgs>

Machine Learning compute object wrapped into ARM resource envelope. Azure REST API version: 2023-04-01. Other available API versions: 2022-01-01-preview, 2023-04-01-preview, 2023-06-01-preview, 2023-08-01-preview, 2023-10-01, 2024-01-01-preview, 2024-04-01, 2024-04-01-preview.

Example Usage

Attach a Kubernetes Compute

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var compute = new AzureNative.MachineLearningServices.Compute("compute", new()
    {
        ComputeName = "compute123",
        Location = "eastus",
        Properties = new AzureNative.MachineLearningServices.Inputs.KubernetesArgs
        {
            ComputeType = "Kubernetes",
            Description = "some compute",
            Properties = new AzureNative.MachineLearningServices.Inputs.KubernetesPropertiesArgs
            {
                DefaultInstanceType = "defaultInstanceType",
                InstanceTypes =
                {
                    { "defaultInstanceType", new AzureNative.MachineLearningServices.Inputs.InstanceTypeSchemaArgs
                    {
                        Resources = new AzureNative.MachineLearningServices.Inputs.InstanceTypeSchemaResourcesArgs
                        {
                            Limits =
                            {
                                { "cpu", "1" },
                                { "memory", "4Gi" },
                                { "nvidia.com/gpu", null },
                            },
                            Requests =
                            {
                                { "cpu", "1" },
                                { "memory", "4Gi" },
                                { "nvidia.com/gpu", null },
                            },
                        },
                    } },
                },
                Namespace = "default",
            },
            ResourceId = "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourcegroups/testrg123/providers/Microsoft.ContainerService/managedClusters/compute123-56826-c9b00420020b2",
        },
        ResourceGroupName = "testrg123",
        WorkspaceName = "workspaces123",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/machinelearningservices/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
pulumi.Run(func(ctx *pulumi.Context) error {
_, err := machinelearningservices.NewCompute(ctx, "compute", &machinelearningservices.ComputeArgs{
ComputeName: pulumi.String("compute123"),
Location: pulumi.String("eastus"),
Properties: machinelearningservices.Kubernetes{
ComputeType: "Kubernetes",
Description: "some compute",
Properties: machinelearningservices.KubernetesProperties{
DefaultInstanceType: "defaultInstanceType",
InstanceTypes: interface{}{
DefaultInstanceType: machinelearningservices.InstanceTypeSchema{
Resources: machinelearningservices.InstanceTypeSchemaResources{
Limits: interface{}{
Cpu: "1",
Memory: "4Gi",
Nvidia.com/gpu: nil,
},
Requests: interface{}{
Cpu: "1",
Memory: "4Gi",
Nvidia.com/gpu: nil,
},
},
},
},
Namespace: "default",
},
ResourceId: "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourcegroups/testrg123/providers/Microsoft.ContainerService/managedClusters/compute123-56826-c9b00420020b2",
},
ResourceGroupName: pulumi.String("testrg123"),
WorkspaceName: pulumi.String("workspaces123"),
})
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.machinelearningservices.Compute;
import com.pulumi.azurenative.machinelearningservices.ComputeArgs;
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 compute = new Compute("compute", ComputeArgs.builder()
            .computeName("compute123")
            .location("eastus")
            .properties(KubernetesArgs.builder()
                .computeType("Kubernetes")
                .description("some compute")
                .properties(KubernetesPropertiesArgs.builder()
                    .defaultInstanceType("defaultInstanceType")
                    .instanceTypes(Map.of("defaultInstanceType", Map.of("resources", Map.ofEntries(
                        Map.entry("limits", Map.ofEntries(
                            Map.entry("cpu", "1"),
                            Map.entry("memory", "4Gi"),
                            Map.entry("nvidia.com/gpu", null)
                        )),
                        Map.entry("requests", Map.ofEntries(
                            Map.entry("cpu", "1"),
                            Map.entry("memory", "4Gi"),
                            Map.entry("nvidia.com/gpu", null)
                        ))
                    ))))
                    .namespace("default")
                    .build())
                .resourceId("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourcegroups/testrg123/providers/Microsoft.ContainerService/managedClusters/compute123-56826-c9b00420020b2")
                .build())
            .resourceGroupName("testrg123")
            .workspaceName("workspaces123")
            .build());
    }
}
Content copied to clipboard

Create a AML Compute

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var compute = new AzureNative.MachineLearningServices.Compute("compute", new()
    {
        ComputeName = "compute123",
        Location = "eastus",
        Properties = new AzureNative.MachineLearningServices.Inputs.AmlComputeArgs
        {
            ComputeType = "AmlCompute",
            Properties = new AzureNative.MachineLearningServices.Inputs.AmlComputePropertiesArgs
            {
                EnableNodePublicIp = true,
                IsolatedNetwork = false,
                OsType = AzureNative.MachineLearningServices.OsType.Windows,
                RemoteLoginPortPublicAccess = AzureNative.MachineLearningServices.RemoteLoginPortPublicAccess.NotSpecified,
                ScaleSettings = new AzureNative.MachineLearningServices.Inputs.ScaleSettingsArgs
                {
                    MaxNodeCount = 1,
                    MinNodeCount = 0,
                    NodeIdleTimeBeforeScaleDown = "PT5M",
                },
                VirtualMachineImage = new AzureNative.MachineLearningServices.Inputs.VirtualMachineImageArgs
                {
                    Id = "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myImageGallery/images/myImageDefinition/versions/0.0.1",
                },
                VmPriority = AzureNative.MachineLearningServices.VmPriority.Dedicated,
                VmSize = "STANDARD_NC6",
            },
        },
        ResourceGroupName = "testrg123",
        WorkspaceName = "workspaces123",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/machinelearningservices/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := machinelearningservices.NewCompute(ctx, "compute", &machinelearningservices.ComputeArgs{
			ComputeName: pulumi.String("compute123"),
			Location:    pulumi.String("eastus"),
			Properties: machinelearningservices.AmlCompute{
				ComputeType: "AmlCompute",
				Properties: machinelearningservices.AmlComputeProperties{
					EnableNodePublicIp:          true,
					IsolatedNetwork:             false,
					OsType:                      machinelearningservices.OsTypeWindows,
					RemoteLoginPortPublicAccess: machinelearningservices.RemoteLoginPortPublicAccessNotSpecified,
					ScaleSettings: machinelearningservices.ScaleSettings{
						MaxNodeCount:                1,
						MinNodeCount:                0,
						NodeIdleTimeBeforeScaleDown: "PT5M",
					},
					VirtualMachineImage: machinelearningservices.VirtualMachineImage{
						Id: "/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myImageGallery/images/myImageDefinition/versions/0.0.1",
					},
					VmPriority: machinelearningservices.VmPriorityDedicated,
					VmSize:     "STANDARD_NC6",
				},
			},
			ResourceGroupName: pulumi.String("testrg123"),
			WorkspaceName:     pulumi.String("workspaces123"),
		})
		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.machinelearningservices.Compute;
import com.pulumi.azurenative.machinelearningservices.ComputeArgs;
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 compute = new Compute("compute", ComputeArgs.builder()
            .computeName("compute123")
            .location("eastus")
            .properties(AmlComputeArgs.builder()
                .computeType("AmlCompute")
                .properties(AmlComputePropertiesArgs.builder()
                    .enableNodePublicIp(true)
                    .isolatedNetwork(false)
                    .osType("Windows")
                    .remoteLoginPortPublicAccess("NotSpecified")
                    .scaleSettings(ScaleSettingsArgs.builder()
                        .maxNodeCount(1)
                        .minNodeCount(0)
                        .nodeIdleTimeBeforeScaleDown("PT5M")
                        .build())
                    .virtualMachineImage(VirtualMachineImageArgs.builder()
                        .id("/subscriptions/00000000-0000-0000-0000-000000000000/resourceGroups/myResourceGroup/providers/Microsoft.Compute/galleries/myImageGallery/images/myImageDefinition/versions/0.0.1")
                        .build())
                    .vmPriority("Dedicated")
                    .vmSize("STANDARD_NC6")
                    .build())
                .build())
            .resourceGroupName("testrg123")
            .workspaceName("workspaces123")
            .build());
    }
}
Content copied to clipboard

Create a DataFactory Compute

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var compute = new AzureNative.MachineLearningServices.Compute("compute", new()
    {
        ComputeName = "compute123",
        Location = "eastus",
        Properties = new AzureNative.MachineLearningServices.Inputs.DataFactoryArgs
        {
            ComputeType = "DataFactory",
        },
        ResourceGroupName = "testrg123",
        WorkspaceName = "workspaces123",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/machinelearningservices/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := machinelearningservices.NewCompute(ctx, "compute", &machinelearningservices.ComputeArgs{
			ComputeName: pulumi.String("compute123"),
			Location:    pulumi.String("eastus"),
			Properties: machinelearningservices.DataFactory{
				ComputeType: "DataFactory",
			},
			ResourceGroupName: pulumi.String("testrg123"),
			WorkspaceName:     pulumi.String("workspaces123"),
		})
		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.machinelearningservices.Compute;
import com.pulumi.azurenative.machinelearningservices.ComputeArgs;
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 compute = new Compute("compute", ComputeArgs.builder()
            .computeName("compute123")
            .location("eastus")
            .properties(DataFactoryArgs.builder()
                .computeType("DataFactory")
                .build())
            .resourceGroupName("testrg123")
            .workspaceName("workspaces123")
            .build());
    }
}
Content copied to clipboard

Create an AKS Compute

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var compute = new AzureNative.MachineLearningServices.Compute("compute", new()
    {
        ComputeName = "compute123",
        Location = "eastus",
        Properties = new AzureNative.MachineLearningServices.Inputs.AKSArgs
        {
            ComputeType = "AKS",
        },
        ResourceGroupName = "testrg123",
        WorkspaceName = "workspaces123",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/machinelearningservices/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := machinelearningservices.NewCompute(ctx, "compute", &machinelearningservices.ComputeArgs{
			ComputeName: pulumi.String("compute123"),
			Location:    pulumi.String("eastus"),
			Properties: machinelearningservices.AKS{
				ComputeType: "AKS",
			},
			ResourceGroupName: pulumi.String("testrg123"),
			WorkspaceName:     pulumi.String("workspaces123"),
		})
		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.machinelearningservices.Compute;
import com.pulumi.azurenative.machinelearningservices.ComputeArgs;
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 compute = new Compute("compute", ComputeArgs.builder()
            .computeName("compute123")
            .location("eastus")
            .properties(AKSArgs.builder()
                .computeType("AKS")
                .build())
            .resourceGroupName("testrg123")
            .workspaceName("workspaces123")
            .build());
    }
}
Content copied to clipboard

Create an ComputeInstance Compute

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var compute = new AzureNative.MachineLearningServices.Compute("compute", new()
    {
        ComputeName = "compute123",
        Location = "eastus",
        Properties = new AzureNative.MachineLearningServices.Inputs.ComputeInstanceArgs
        {
            ComputeType = "ComputeInstance",
            Properties = new AzureNative.MachineLearningServices.Inputs.ComputeInstancePropertiesArgs
            {
                ApplicationSharingPolicy = AzureNative.MachineLearningServices.ApplicationSharingPolicy.Personal,
                ComputeInstanceAuthorizationType = AzureNative.MachineLearningServices.ComputeInstanceAuthorizationType.Personal,
                CustomServices = new[]
                {
                    new AzureNative.MachineLearningServices.Inputs.CustomServiceArgs
                    {
                        Docker = new AzureNative.MachineLearningServices.Inputs.DockerArgs
                        {
                            Privileged = true,
                        },
                        Endpoints = new[]
                        {
                            new AzureNative.MachineLearningServices.Inputs.EndpointArgs
                            {
                                Name = "connect",
                                Protocol = AzureNative.MachineLearningServices.Protocol.Http,
                                Published = 8787,
                                Target = 8787,
                            },
                        },
                        EnvironmentVariables =
                        {
                            { "test_variable", new AzureNative.MachineLearningServices.Inputs.EnvironmentVariableArgs
                            {
                                Type = AzureNative.MachineLearningServices.EnvironmentVariableType.Local,
                                Value = "test_value",
                            } },
                        },
                        Image = new AzureNative.MachineLearningServices.Inputs.ImageArgs
                        {
                            Reference = "ghcr.io/azure/rocker-rstudio-ml-verse:latest",
                            Type = AzureNative.MachineLearningServices.ImageType.Docker,
                        },
                        Name = "rstudio",
                        Volumes = new[]
                        {
                            new AzureNative.MachineLearningServices.Inputs.VolumeDefinitionArgs
                            {
                                ReadOnly = false,
                                Source = "/home/azureuser/cloudfiles",
                                Target = "/home/azureuser/cloudfiles",
                                Type = AzureNative.MachineLearningServices.VolumeDefinitionType.Bind,
                            },
                        },
                    },
                },
                PersonalComputeInstanceSettings = new AzureNative.MachineLearningServices.Inputs.PersonalComputeInstanceSettingsArgs
                {
                    AssignedUser = new AzureNative.MachineLearningServices.Inputs.AssignedUserArgs
                    {
                        ObjectId = "00000000-0000-0000-0000-000000000000",
                        TenantId = "00000000-0000-0000-0000-000000000000",
                    },
                },
                SshSettings = new AzureNative.MachineLearningServices.Inputs.ComputeInstanceSshSettingsArgs
                {
                    SshPublicAccess = AzureNative.MachineLearningServices.SshPublicAccess.Disabled,
                },
                Subnet = new AzureNative.MachineLearningServices.Inputs.ResourceIdArgs
                {
                    Id = "test-subnet-resource-id",
                },
                VmSize = "STANDARD_NC6",
            },
        },
        ResourceGroupName = "testrg123",
        WorkspaceName = "workspaces123",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/machinelearningservices/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := machinelearningservices.NewCompute(ctx, "compute", &machinelearningservices.ComputeArgs{
			ComputeName: pulumi.String("compute123"),
			Location:    pulumi.String("eastus"),
			Properties: machinelearningservices.ComputeInstance{
				ComputeType: "ComputeInstance",
				Properties: machinelearningservices.ComputeInstanceProperties{
					ApplicationSharingPolicy:         machinelearningservices.ApplicationSharingPolicyPersonal,
					ComputeInstanceAuthorizationType: machinelearningservices.ComputeInstanceAuthorizationTypePersonal,
					CustomServices: []machinelearningservices.CustomService{
						{
							Docker: {
								Privileged: true,
							},
							Endpoints: []machinelearningservices.Endpoint{
								{
									Name:      "connect",
									Protocol:  machinelearningservices.ProtocolHttp,
									Published: 8787,
									Target:    8787,
								},
							},
							EnvironmentVariables: {
								Test_variable: {
									Type:  machinelearningservices.EnvironmentVariableTypeLocal,
									Value: "test_value",
								},
							},
							Image: {
								Reference: "ghcr.io/azure/rocker-rstudio-ml-verse:latest",
								Type:      machinelearningservices.ImageTypeDocker,
							},
							Name: "rstudio",
							Volumes: []machinelearningservices.VolumeDefinition{
								{
									ReadOnly: false,
									Source:   "/home/azureuser/cloudfiles",
									Target:   "/home/azureuser/cloudfiles",
									Type:     machinelearningservices.VolumeDefinitionTypeBind,
								},
							},
						},
					},
					PersonalComputeInstanceSettings: machinelearningservices.PersonalComputeInstanceSettings{
						AssignedUser: machinelearningservices.AssignedUser{
							ObjectId: "00000000-0000-0000-0000-000000000000",
							TenantId: "00000000-0000-0000-0000-000000000000",
						},
					},
					SshSettings: machinelearningservices.ComputeInstanceSshSettings{
						SshPublicAccess: machinelearningservices.SshPublicAccessDisabled,
					},
					Subnet: machinelearningservices.ResourceId{
						Id: "test-subnet-resource-id",
					},
					VmSize: "STANDARD_NC6",
				},
			},
			ResourceGroupName: pulumi.String("testrg123"),
			WorkspaceName:     pulumi.String("workspaces123"),
		})
		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.machinelearningservices.Compute;
import com.pulumi.azurenative.machinelearningservices.ComputeArgs;
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 compute = new Compute("compute", ComputeArgs.builder()
            .computeName("compute123")
            .location("eastus")
            .properties(ComputeInstanceArgs.builder()
                .computeType("ComputeInstance")
                .properties(ComputeInstancePropertiesArgs.builder()
                    .applicationSharingPolicy("Personal")
                    .computeInstanceAuthorizationType("personal")
                    .customServices(CustomServiceArgs.builder()
                        .docker(DockerArgs.builder()
                            .privileged(true)
                            .build())
                        .endpoints(EndpointArgs.builder()
                            .name("connect")
                            .protocol("http")
                            .published(8787)
                            .target(8787)
                            .build())
                        .environmentVariables(Map.of("test_variable", Map.ofEntries(
                            Map.entry("type", "local"),
                            Map.entry("value", "test_value")
                        )))
                        .image(ImageArgs.builder()
                            .reference("ghcr.io/azure/rocker-rstudio-ml-verse:latest")
                            .type("docker")
                            .build())
                        .name("rstudio")
                        .volumes(VolumeDefinitionArgs.builder()
                            .readOnly(false)
                            .source("/home/azureuser/cloudfiles")
                            .target("/home/azureuser/cloudfiles")
                            .type("bind")
                            .build())
                        .build())
                    .personalComputeInstanceSettings(PersonalComputeInstanceSettingsArgs.builder()
                        .assignedUser(AssignedUserArgs.builder()
                            .objectId("00000000-0000-0000-0000-000000000000")
                            .tenantId("00000000-0000-0000-0000-000000000000")
                            .build())
                        .build())
                    .sshSettings(ComputeInstanceSshSettingsArgs.builder()
                        .sshPublicAccess("Disabled")
                        .build())
                    .subnet(ResourceIdArgs.builder()
                        .id("test-subnet-resource-id")
                        .build())
                    .vmSize("STANDARD_NC6")
                    .build())
                .build())
            .resourceGroupName("testrg123")
            .workspaceName("workspaces123")
            .build());
    }
}
Content copied to clipboard

Create an ComputeInstance Compute with Schedules

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var compute = new AzureNative.MachineLearningServices.Compute("compute", new()
    {
        ComputeName = "compute123",
        Location = "eastus",
        Properties = new AzureNative.MachineLearningServices.Inputs.ComputeInstanceArgs
        {
            ComputeType = "ComputeInstance",
            Properties = new AzureNative.MachineLearningServices.Inputs.ComputeInstancePropertiesArgs
            {
                ApplicationSharingPolicy = AzureNative.MachineLearningServices.ApplicationSharingPolicy.Personal,
                ComputeInstanceAuthorizationType = AzureNative.MachineLearningServices.ComputeInstanceAuthorizationType.Personal,
                PersonalComputeInstanceSettings = new AzureNative.MachineLearningServices.Inputs.PersonalComputeInstanceSettingsArgs
                {
                    AssignedUser = new AzureNative.MachineLearningServices.Inputs.AssignedUserArgs
                    {
                        ObjectId = "00000000-0000-0000-0000-000000000000",
                        TenantId = "00000000-0000-0000-0000-000000000000",
                    },
                },
                Schedules = new AzureNative.MachineLearningServices.Inputs.ComputeSchedulesArgs
                {
                    ComputeStartStop = new[]
                    {
                        new AzureNative.MachineLearningServices.Inputs.ComputeStartStopScheduleArgs
                        {
                            Action = AzureNative.MachineLearningServices.ComputePowerAction.Stop,
                            Cron = new AzureNative.MachineLearningServices.Inputs.CronArgs
                            {
                                Expression = "0 18 * * *",
                                StartTime = "2021-04-23T01:30:00",
                                TimeZone = "Pacific Standard Time",
                            },
                            Status = AzureNative.MachineLearningServices.ScheduleStatus.Enabled,
                            TriggerType = AzureNative.MachineLearningServices.TriggerType.Cron,
                        },
                    },
                },
                SshSettings = new AzureNative.MachineLearningServices.Inputs.ComputeInstanceSshSettingsArgs
                {
                    SshPublicAccess = AzureNative.MachineLearningServices.SshPublicAccess.Disabled,
                },
                VmSize = "STANDARD_NC6",
            },
        },
        ResourceGroupName = "testrg123",
        WorkspaceName = "workspaces123",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/machinelearningservices/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := machinelearningservices.NewCompute(ctx, "compute", &machinelearningservices.ComputeArgs{
			ComputeName: pulumi.String("compute123"),
			Location:    pulumi.String("eastus"),
			Properties: machinelearningservices.ComputeInstance{
				ComputeType: "ComputeInstance",
				Properties: machinelearningservices.ComputeInstanceProperties{
					ApplicationSharingPolicy:         machinelearningservices.ApplicationSharingPolicyPersonal,
					ComputeInstanceAuthorizationType: machinelearningservices.ComputeInstanceAuthorizationTypePersonal,
					PersonalComputeInstanceSettings: machinelearningservices.PersonalComputeInstanceSettings{
						AssignedUser: machinelearningservices.AssignedUser{
							ObjectId: "00000000-0000-0000-0000-000000000000",
							TenantId: "00000000-0000-0000-0000-000000000000",
						},
					},
					Schedules: machinelearningservices.ComputeSchedules{
						ComputeStartStop: []machinelearningservices.ComputeStartStopSchedule{
							{
								Action: machinelearningservices.ComputePowerActionStop,
								Cron: {
									Expression: "0 18 * * *",
									StartTime:  "2021-04-23T01:30:00",
									TimeZone:   "Pacific Standard Time",
								},
								Status:      machinelearningservices.ScheduleStatusEnabled,
								TriggerType: machinelearningservices.TriggerTypeCron,
							},
						},
					},
					SshSettings: machinelearningservices.ComputeInstanceSshSettings{
						SshPublicAccess: machinelearningservices.SshPublicAccessDisabled,
					},
					VmSize: "STANDARD_NC6",
				},
			},
			ResourceGroupName: pulumi.String("testrg123"),
			WorkspaceName:     pulumi.String("workspaces123"),
		})
		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.machinelearningservices.Compute;
import com.pulumi.azurenative.machinelearningservices.ComputeArgs;
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 compute = new Compute("compute", ComputeArgs.builder()
            .computeName("compute123")
            .location("eastus")
            .properties(ComputeInstanceArgs.builder()
                .computeType("ComputeInstance")
                .properties(ComputeInstancePropertiesArgs.builder()
                    .applicationSharingPolicy("Personal")
                    .computeInstanceAuthorizationType("personal")
                    .personalComputeInstanceSettings(PersonalComputeInstanceSettingsArgs.builder()
                        .assignedUser(AssignedUserArgs.builder()
                            .objectId("00000000-0000-0000-0000-000000000000")
                            .tenantId("00000000-0000-0000-0000-000000000000")
                            .build())
                        .build())
                    .schedules(ComputeSchedulesArgs.builder()
                        .computeStartStop(ComputeStartStopScheduleArgs.builder()
                            .action("Stop")
                            .cron(CronArgs.builder()
                                .expression("0 18 * * *")
                                .startTime("2021-04-23T01:30:00")
                                .timeZone("Pacific Standard Time")
                                .build())
                            .status("Enabled")
                            .triggerType("Cron")
                            .build())
                        .build())
                    .sshSettings(ComputeInstanceSshSettingsArgs.builder()
                        .sshPublicAccess("Disabled")
                        .build())
                    .vmSize("STANDARD_NC6")
                    .build())
                .build())
            .resourceGroupName("testrg123")
            .workspaceName("workspaces123")
            .build());
    }
}
Content copied to clipboard

Create an ComputeInstance Compute with minimal inputs

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var compute = new AzureNative.MachineLearningServices.Compute("compute", new()
    {
        ComputeName = "compute123",
        Location = "eastus",
        Properties = new AzureNative.MachineLearningServices.Inputs.ComputeInstanceArgs
        {
            ComputeType = "ComputeInstance",
            Properties = new AzureNative.MachineLearningServices.Inputs.ComputeInstancePropertiesArgs
            {
                VmSize = "STANDARD_NC6",
            },
        },
        ResourceGroupName = "testrg123",
        WorkspaceName = "workspaces123",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/machinelearningservices/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := machinelearningservices.NewCompute(ctx, "compute", &machinelearningservices.ComputeArgs{
			ComputeName: pulumi.String("compute123"),
			Location:    pulumi.String("eastus"),
			Properties: machinelearningservices.ComputeInstance{
				ComputeType: "ComputeInstance",
				Properties: machinelearningservices.ComputeInstanceProperties{
					VmSize: "STANDARD_NC6",
				},
			},
			ResourceGroupName: pulumi.String("testrg123"),
			WorkspaceName:     pulumi.String("workspaces123"),
		})
		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.machinelearningservices.Compute;
import com.pulumi.azurenative.machinelearningservices.ComputeArgs;
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 compute = new Compute("compute", ComputeArgs.builder()
            .computeName("compute123")
            .location("eastus")
            .properties(ComputeInstanceArgs.builder()
                .computeType("ComputeInstance")
                .properties(ComputeInstancePropertiesArgs.builder()
                    .vmSize("STANDARD_NC6")
                    .build())
                .build())
            .resourceGroupName("testrg123")
            .workspaceName("workspaces123")
            .build());
    }
}
Content copied to clipboard

Update a AML Compute

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var compute = new AzureNative.MachineLearningServices.Compute("compute", new()
    {
        ComputeName = "compute123",
        Location = "eastus",
        Properties = new AzureNative.MachineLearningServices.Inputs.AmlComputeArgs
        {
            ComputeType = "AmlCompute",
            Description = "some compute",
            Properties = new AzureNative.MachineLearningServices.Inputs.AmlComputePropertiesArgs
            {
                ScaleSettings = new AzureNative.MachineLearningServices.Inputs.ScaleSettingsArgs
                {
                    MaxNodeCount = 4,
                    MinNodeCount = 4,
                    NodeIdleTimeBeforeScaleDown = "PT5M",
                },
            },
        },
        ResourceGroupName = "testrg123",
        WorkspaceName = "workspaces123",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/machinelearningservices/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := machinelearningservices.NewCompute(ctx, "compute", &machinelearningservices.ComputeArgs{
			ComputeName: pulumi.String("compute123"),
			Location:    pulumi.String("eastus"),
			Properties: machinelearningservices.AmlCompute{
				ComputeType: "AmlCompute",
				Description: "some compute",
				Properties: machinelearningservices.AmlComputeProperties{
					ScaleSettings: machinelearningservices.ScaleSettings{
						MaxNodeCount:                4,
						MinNodeCount:                4,
						NodeIdleTimeBeforeScaleDown: "PT5M",
					},
				},
			},
			ResourceGroupName: pulumi.String("testrg123"),
			WorkspaceName:     pulumi.String("workspaces123"),
		})
		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.machinelearningservices.Compute;
import com.pulumi.azurenative.machinelearningservices.ComputeArgs;
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 compute = new Compute("compute", ComputeArgs.builder()
            .computeName("compute123")
            .location("eastus")
            .properties(AmlComputeArgs.builder()
                .computeType("AmlCompute")
                .description("some compute")
                .properties(AmlComputePropertiesArgs.builder()
                    .scaleSettings(ScaleSettingsArgs.builder()
                        .maxNodeCount(4)
                        .minNodeCount(4)
                        .nodeIdleTimeBeforeScaleDown("PT5M")
                        .build())
                    .build())
                .build())
            .resourceGroupName("testrg123")
            .workspaceName("workspaces123")
            .build());
    }
}
Content copied to clipboard

Update an AKS Compute

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using AzureNative = Pulumi.AzureNative;
return await Deployment.RunAsync(() =>
{
    var compute = new AzureNative.MachineLearningServices.Compute("compute", new()
    {
        ComputeName = "compute123",
        Location = "eastus",
        Properties = new AzureNative.MachineLearningServices.Inputs.AKSArgs
        {
            ComputeType = "AKS",
            Description = "some compute",
            Properties = new AzureNative.MachineLearningServices.Inputs.AKSSchemaPropertiesArgs
            {
                AgentCount = 4,
            },
            ResourceId = "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourcegroups/testrg123/providers/Microsoft.ContainerService/managedClusters/compute123-56826-c9b00420020b2",
        },
        ResourceGroupName = "testrg123",
        WorkspaceName = "workspaces123",
    });
});
Content copied to clipboard
package main
import (
	"github.com/pulumi/pulumi-azure-native-sdk/machinelearningservices/v2"
	"github.com/pulumi/pulumi/sdk/v3/go/pulumi"
)
func main() {
	pulumi.Run(func(ctx *pulumi.Context) error {
		_, err := machinelearningservices.NewCompute(ctx, "compute", &machinelearningservices.ComputeArgs{
			ComputeName: pulumi.String("compute123"),
			Location:    pulumi.String("eastus"),
			Properties: machinelearningservices.AKS{
				ComputeType: "AKS",
				Description: "some compute",
				Properties: machinelearningservices.AKSSchemaProperties{
					AgentCount: 4,
				},
				ResourceId: "/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourcegroups/testrg123/providers/Microsoft.ContainerService/managedClusters/compute123-56826-c9b00420020b2",
			},
			ResourceGroupName: pulumi.String("testrg123"),
			WorkspaceName:     pulumi.String("workspaces123"),
		})
		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.machinelearningservices.Compute;
import com.pulumi.azurenative.machinelearningservices.ComputeArgs;
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 compute = new Compute("compute", ComputeArgs.builder()
            .computeName("compute123")
            .location("eastus")
            .properties(AKSArgs.builder()
                .computeType("AKS")
                .description("some compute")
                .properties(AKSSchemaPropertiesArgs.builder()
                    .agentCount(4)
                    .build())
                .resourceId("/subscriptions/34adfa4f-cedf-4dc0-ba29-b6d1a69ab345/resourcegroups/testrg123/providers/Microsoft.ContainerService/managedClusters/compute123-56826-c9b00420020b2")
                .build())
            .resourceGroupName("testrg123")
            .workspaceName("workspaces123")
            .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:machinelearningservices:Compute compute123 /subscriptions/{subscriptionId}/resourceGroups/{resourceGroupName}/providers/Microsoft.MachineLearningServices/workspaces/{workspaceName}/computes/{computeName}
Content copied to clipboard

Constructors

Link copied to clipboard
constructor(computeName: Output<String>? = null, identity: Output<ManagedServiceIdentityArgs>? = null, location: Output<String>? = null, properties: Output<Any>? = null, resourceGroupName: Output<String>? = null, sku: Output<SkuArgs>? = null, tags: Output<Map<String, String>>? = null, workspaceName: Output<String>? = null)

Properties

Link copied to clipboard
val computeName: Output<String>? = null

Name of the Azure Machine Learning compute.

Link copied to clipboard
val identity: Output<ManagedServiceIdentityArgs>? = null

The identity of the resource.

Link copied to clipboard
val location: Output<String>? = null

Specifies the location of the resource.

Link copied to clipboard
val properties: Output<Any>? = null

Compute properties

Link copied to clipboard
val resourceGroupName: Output<String>? = null

The name of the resource group. The name is case insensitive.

Link copied to clipboard
val sku: Output<SkuArgs>? = null

The sku of the workspace.

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

Contains resource tags defined as key/value pairs.

Link copied to clipboard
val workspaceName: Output<String>? = null

Name of Azure Machine Learning workspace.

Functions

Link copied to clipboard
open override fun toJava(): ComputeArgs