azure.machinelearning.InferenceCluster

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

const current = azure.core.getClientConfig({});
const example = new azure.core.ResourceGroup("example", {
    name: "example-rg",
    location: "west europe",
    tags: {
        stage: "example",
    },
});
const exampleInsights = new azure.appinsights.Insights("example", {
    name: "example-ai",
    location: example.location,
    resourceGroupName: example.name,
    applicationType: "web",
});
const exampleKeyVault = new azure.keyvault.KeyVault("example", {
    name: "example-kv",
    location: example.location,
    resourceGroupName: example.name,
    tenantId: current.then(current => current.tenantId),
    skuName: "standard",
    purgeProtectionEnabled: true,
});
const exampleAccount = new azure.storage.Account("example", {
    name: "examplesa",
    location: example.location,
    resourceGroupName: example.name,
    accountTier: "Standard",
    accountReplicationType: "LRS",
});
const exampleWorkspace = new azure.machinelearning.Workspace("example", {
    name: "example-mlw",
    location: example.location,
    resourceGroupName: example.name,
    applicationInsightsId: exampleInsights.id,
    keyVaultId: exampleKeyVault.id,
    storageAccountId: exampleAccount.id,
    identity: {
        type: "SystemAssigned",
    },
});
const exampleVirtualNetwork = new azure.network.VirtualNetwork("example", {
    name: "example-vnet",
    addressSpaces: ["10.1.0.0/16"],
    location: example.location,
    resourceGroupName: example.name,
});
const exampleSubnet = new azure.network.Subnet("example", {
    name: "example-subnet",
    resourceGroupName: example.name,
    virtualNetworkName: exampleVirtualNetwork.name,
    addressPrefixes: ["10.1.0.0/24"],
});
const exampleKubernetesCluster = new azure.containerservice.KubernetesCluster("example", {
    name: "example-aks",
    location: example.location,
    resourceGroupName: example.name,
    dnsPrefixPrivateCluster: "prefix",
    defaultNodePool: {
        name: "default",
        nodeCount: 3,
        vmSize: "Standard_D3_v2",
        vnetSubnetId: exampleSubnet.id,
    },
    identity: {
        type: "SystemAssigned",
    },
});
const exampleInferenceCluster = new azure.machinelearning.InferenceCluster("example", {
    name: "example",
    location: example.location,
    clusterPurpose: "FastProd",
    kubernetesClusterId: exampleKubernetesCluster.id,
    description: "This is an example cluster used with Terraform",
    machineLearningWorkspaceId: exampleWorkspace.id,
    tags: {
        stage: "example",
    },
});

import pulumi
import pulumi_azure as azure

current = azure.core.get_client_config()
example = azure.core.ResourceGroup("example",
    name="example-rg",
    location="west europe",
    tags={
        "stage": "example",
    })
example_insights = azure.appinsights.Insights("example",
    name="example-ai",
    location=example.location,
    resource_group_name=example.name,
    application_type="web")
example_key_vault = azure.keyvault.KeyVault("example",
    name="example-kv",
    location=example.location,
    resource_group_name=example.name,
    tenant_id=current.tenant_id,
    sku_name="standard",
    purge_protection_enabled=True)
example_account = azure.storage.Account("example",
    name="examplesa",
    location=example.location,
    resource_group_name=example.name,
    account_tier="Standard",
    account_replication_type="LRS")
example_workspace = azure.machinelearning.Workspace("example",
    name="example-mlw",
    location=example.location,
    resource_group_name=example.name,
    application_insights_id=example_insights.id,
    key_vault_id=example_key_vault.id,
    storage_account_id=example_account.id,
    identity={
        "type": "SystemAssigned",
    })
example_virtual_network = azure.network.VirtualNetwork("example",
    name="example-vnet",
    address_spaces=["10.1.0.0/16"],
    location=example.location,
    resource_group_name=example.name)
example_subnet = azure.network.Subnet("example",
    name="example-subnet",
    resource_group_name=example.name,
    virtual_network_name=example_virtual_network.name,
    address_prefixes=["10.1.0.0/24"])
example_kubernetes_cluster = azure.containerservice.KubernetesCluster("example",
    name="example-aks",
    location=example.location,
    resource_group_name=example.name,
    dns_prefix_private_cluster="prefix",
    default_node_pool={
        "name": "default",
        "node_count": 3,
        "vm_size": "Standard_D3_v2",
        "vnet_subnet_id": example_subnet.id,
    },
    identity={
        "type": "SystemAssigned",
    })
example_inference_cluster = azure.machinelearning.InferenceCluster("example",
    name="example",
    location=example.location,
    cluster_purpose="FastProd",
    kubernetes_cluster_id=example_kubernetes_cluster.id,
    description="This is an example cluster used with Terraform",
    machine_learning_workspace_id=example_workspace.id,
    tags={
        "stage": "example",
    })

package main

import (
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/appinsights"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/containerservice"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/core"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/keyvault"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/machinelearning"
	"github.com/pulumi/pulumi-azure/sdk/v6/go/azure/network"
	"github.com/pulumi/pulumi-azure/sdk/v6/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, map[string]interface{}{}, nil)
		if err != nil {
			return err
		}
		example, err := core.NewResourceGroup(ctx, "example", &core.ResourceGroupArgs{
			Name:     pulumi.String("example-rg"),
			Location: pulumi.String("west europe"),
			Tags: pulumi.StringMap{
				"stage": pulumi.String("example"),
			},
		})
		if err != nil {
			return err
		}
		exampleInsights, err := appinsights.NewInsights(ctx, "example", &appinsights.InsightsArgs{
			Name:              pulumi.String("example-ai"),
			Location:          example.Location,
			ResourceGroupName: example.Name,
			ApplicationType:   pulumi.String("web"),
		})
		if err != nil {
			return err
		}
		exampleKeyVault, err := keyvault.NewKeyVault(ctx, "example", &keyvault.KeyVaultArgs{
			Name:                   pulumi.String("example-kv"),
			Location:               example.Location,
			ResourceGroupName:      example.Name,
			TenantId:               pulumi.String(current.TenantId),
			SkuName:                pulumi.String("standard"),
			PurgeProtectionEnabled: pulumi.Bool(true),
		})
		if err != nil {
			return err
		}
		exampleAccount, err := storage.NewAccount(ctx, "example", &storage.AccountArgs{
			Name:                   pulumi.String("examplesa"),
			Location:               example.Location,
			ResourceGroupName:      example.Name,
			AccountTier:            pulumi.String("Standard"),
			AccountReplicationType: pulumi.String("LRS"),
		})
		if err != nil {
			return err
		}
		exampleWorkspace, err := machinelearning.NewWorkspace(ctx, "example", &machinelearning.WorkspaceArgs{
			Name:                  pulumi.String("example-mlw"),
			Location:              example.Location,
			ResourceGroupName:     example.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, "example", &network.VirtualNetworkArgs{
			Name: pulumi.String("example-vnet"),
			AddressSpaces: pulumi.StringArray{
				pulumi.String("10.1.0.0/16"),
			},
			Location:          example.Location,
			ResourceGroupName: example.Name,
		})
		if err != nil {
			return err
		}
		exampleSubnet, err := network.NewSubnet(ctx, "example", &network.SubnetArgs{
			Name:               pulumi.String("example-subnet"),
			ResourceGroupName:  example.Name,
			VirtualNetworkName: exampleVirtualNetwork.Name,
			AddressPrefixes: pulumi.StringArray{
				pulumi.String("10.1.0.0/24"),
			},
		})
		if err != nil {
			return err
		}
		exampleKubernetesCluster, err := containerservice.NewKubernetesCluster(ctx, "example", &containerservice.KubernetesClusterArgs{
			Name:                    pulumi.String("example-aks"),
			Location:                example.Location,
			ResourceGroupName:       example.Name,
			DnsPrefixPrivateCluster: pulumi.String("prefix"),
			DefaultNodePool: &containerservice.KubernetesClusterDefaultNodePoolArgs{
				Name:         pulumi.String("default"),
				NodeCount:    pulumi.Int(3),
				VmSize:       pulumi.String("Standard_D3_v2"),
				VnetSubnetId: exampleSubnet.ID(),
			},
			Identity: &containerservice.KubernetesClusterIdentityArgs{
				Type: pulumi.String("SystemAssigned"),
			},
		})
		if err != nil {
			return err
		}
		_, err = machinelearning.NewInferenceCluster(ctx, "example", &machinelearning.InferenceClusterArgs{
			Name:                       pulumi.String("example"),
			Location:                   example.Location,
			ClusterPurpose:             pulumi.String("FastProd"),
			KubernetesClusterId:        exampleKubernetesCluster.ID(),
			Description:                pulumi.String("This is an example cluster used with Terraform"),
			MachineLearningWorkspaceId: exampleWorkspace.ID(),
			Tags: pulumi.StringMap{
				"stage": pulumi.String("example"),
			},
		})
		if err != nil {
			return err
		}
		return nil
	})
}

using System.Collections.Generic;
using System.Linq;
using Pulumi;
using Azure = Pulumi.Azure;

return await Deployment.RunAsync(() => 
{
    var current = Azure.Core.GetClientConfig.Invoke();

    var example = new Azure.Core.ResourceGroup("example", new()
    {
        Name = "example-rg",
        Location = "west europe",
        Tags = 
        {
            { "stage", "example" },
        },
    });

    var exampleInsights = new Azure.AppInsights.Insights("example", new()
    {
        Name = "example-ai",
        Location = example.Location,
        ResourceGroupName = example.Name,
        ApplicationType = "web",
    });

    var exampleKeyVault = new Azure.KeyVault.KeyVault("example", new()
    {
        Name = "example-kv",
        Location = example.Location,
        ResourceGroupName = example.Name,
        TenantId = current.Apply(getClientConfigResult => getClientConfigResult.TenantId),
        SkuName = "standard",
        PurgeProtectionEnabled = true,
    });

    var exampleAccount = new Azure.Storage.Account("example", new()
    {
        Name = "examplesa",
        Location = example.Location,
        ResourceGroupName = example.Name,
        AccountTier = "Standard",
        AccountReplicationType = "LRS",
    });

    var exampleWorkspace = new Azure.MachineLearning.Workspace("example", new()
    {
        Name = "example-mlw",
        Location = example.Location,
        ResourceGroupName = example.Name,
        ApplicationInsightsId = exampleInsights.Id,
        KeyVaultId = exampleKeyVault.Id,
        StorageAccountId = exampleAccount.Id,
        Identity = new Azure.MachineLearning.Inputs.WorkspaceIdentityArgs
        {
            Type = "SystemAssigned",
        },
    });

    var exampleVirtualNetwork = new Azure.Network.VirtualNetwork("example", new()
    {
        Name = "example-vnet",
        AddressSpaces = new[]
        {
            "10.1.0.0/16",
        },
        Location = example.Location,
        ResourceGroupName = example.Name,
    });

    var exampleSubnet = new Azure.Network.Subnet("example", new()
    {
        Name = "example-subnet",
        ResourceGroupName = example.Name,
        VirtualNetworkName = exampleVirtualNetwork.Name,
        AddressPrefixes = new[]
        {
            "10.1.0.0/24",
        },
    });

    var exampleKubernetesCluster = new Azure.ContainerService.KubernetesCluster("example", new()
    {
        Name = "example-aks",
        Location = example.Location,
        ResourceGroupName = example.Name,
        DnsPrefixPrivateCluster = "prefix",
        DefaultNodePool = new Azure.ContainerService.Inputs.KubernetesClusterDefaultNodePoolArgs
        {
            Name = "default",
            NodeCount = 3,
            VmSize = "Standard_D3_v2",
            VnetSubnetId = exampleSubnet.Id,
        },
        Identity = new Azure.ContainerService.Inputs.KubernetesClusterIdentityArgs
        {
            Type = "SystemAssigned",
        },
    });

    var exampleInferenceCluster = new Azure.MachineLearning.InferenceCluster("example", new()
    {
        Name = "example",
        Location = example.Location,
        ClusterPurpose = "FastProd",
        KubernetesClusterId = exampleKubernetesCluster.Id,
        Description = "This is an example cluster used with Terraform",
        MachineLearningWorkspaceId = exampleWorkspace.Id,
        Tags = 
        {
            { "stage", "example" },
        },
    });

});

package generated_program;

import com.pulumi.Context;
import com.pulumi.Pulumi;
import com.pulumi.core.Output;
import com.pulumi.azure.core.CoreFunctions;
import com.pulumi.azure.core.ResourceGroup;
import com.pulumi.azure.core.ResourceGroupArgs;
import com.pulumi.azure.appinsights.Insights;
import com.pulumi.azure.appinsights.InsightsArgs;
import com.pulumi.azure.keyvault.KeyVault;
import com.pulumi.azure.keyvault.KeyVaultArgs;
import com.pulumi.azure.storage.Account;
import com.pulumi.azure.storage.AccountArgs;
import com.pulumi.azure.machinelearning.Workspace;
import com.pulumi.azure.machinelearning.WorkspaceArgs;
import com.pulumi.azure.machinelearning.inputs.WorkspaceIdentityArgs;
import com.pulumi.azure.network.VirtualNetwork;
import com.pulumi.azure.network.VirtualNetworkArgs;
import com.pulumi.azure.network.Subnet;
import com.pulumi.azure.network.SubnetArgs;
import com.pulumi.azure.containerservice.KubernetesCluster;
import com.pulumi.azure.containerservice.KubernetesClusterArgs;
import com.pulumi.azure.containerservice.inputs.KubernetesClusterDefaultNodePoolArgs;
import com.pulumi.azure.containerservice.inputs.KubernetesClusterIdentityArgs;
import com.pulumi.azure.machinelearning.InferenceCluster;
import com.pulumi.azure.machinelearning.InferenceClusterArgs;
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) {
        final var current = CoreFunctions.getClientConfig();

        var example = new ResourceGroup("example", ResourceGroupArgs.builder()
            .name("example-rg")
            .location("west europe")
            .tags(Map.of("stage", "example"))
            .build());

        var exampleInsights = new Insights("exampleInsights", InsightsArgs.builder()
            .name("example-ai")
            .location(example.location())
            .resourceGroupName(example.name())
            .applicationType("web")
            .build());

        var exampleKeyVault = new KeyVault("exampleKeyVault", KeyVaultArgs.builder()
            .name("example-kv")
            .location(example.location())
            .resourceGroupName(example.name())
            .tenantId(current.applyValue(getClientConfigResult -> getClientConfigResult.tenantId()))
            .skuName("standard")
            .purgeProtectionEnabled(true)
            .build());

        var exampleAccount = new Account("exampleAccount", AccountArgs.builder()
            .name("examplesa")
            .location(example.location())
            .resourceGroupName(example.name())
            .accountTier("Standard")
            .accountReplicationType("LRS")
            .build());

        var exampleWorkspace = new Workspace("exampleWorkspace", WorkspaceArgs.builder()
            .name("example-mlw")
            .location(example.location())
            .resourceGroupName(example.name())
            .applicationInsightsId(exampleInsights.id())
            .keyVaultId(exampleKeyVault.id())
            .storageAccountId(exampleAccount.id())
            .identity(WorkspaceIdentityArgs.builder()
                .type("SystemAssigned")
                .build())
            .build());

        var exampleVirtualNetwork = new VirtualNetwork("exampleVirtualNetwork", VirtualNetworkArgs.builder()
            .name("example-vnet")
            .addressSpaces("10.1.0.0/16")
            .location(example.location())
            .resourceGroupName(example.name())
            .build());

        var exampleSubnet = new Subnet("exampleSubnet", SubnetArgs.builder()
            .name("example-subnet")
            .resourceGroupName(example.name())
            .virtualNetworkName(exampleVirtualNetwork.name())
            .addressPrefixes("10.1.0.0/24")
            .build());

        var exampleKubernetesCluster = new KubernetesCluster("exampleKubernetesCluster", KubernetesClusterArgs.builder()
            .name("example-aks")
            .location(example.location())
            .resourceGroupName(example.name())
            .dnsPrefixPrivateCluster("prefix")
            .defaultNodePool(KubernetesClusterDefaultNodePoolArgs.builder()
                .name("default")
                .nodeCount(3)
                .vmSize("Standard_D3_v2")
                .vnetSubnetId(exampleSubnet.id())
                .build())
            .identity(KubernetesClusterIdentityArgs.builder()
                .type("SystemAssigned")
                .build())
            .build());

        var exampleInferenceCluster = new InferenceCluster("exampleInferenceCluster", InferenceClusterArgs.builder()
            .name("example")
            .location(example.location())
            .clusterPurpose("FastProd")
            .kubernetesClusterId(exampleKubernetesCluster.id())
            .description("This is an example cluster used with Terraform")
            .machineLearningWorkspaceId(exampleWorkspace.id())
            .tags(Map.of("stage", "example"))
            .build());

    }
}

resources:
  example:
    type: azure:core:ResourceGroup
    properties:
      name: example-rg
      location: west europe
      tags:
        stage: example
  exampleInsights:
    type: azure:appinsights:Insights
    name: example
    properties:
      name: example-ai
      location: ${example.location}
      resourceGroupName: ${example.name}
      applicationType: web
  exampleKeyVault:
    type: azure:keyvault:KeyVault
    name: example
    properties:
      name: example-kv
      location: ${example.location}
      resourceGroupName: ${example.name}
      tenantId: ${current.tenantId}
      skuName: standard
      purgeProtectionEnabled: true
  exampleAccount:
    type: azure:storage:Account
    name: example
    properties:
      name: examplesa
      location: ${example.location}
      resourceGroupName: ${example.name}
      accountTier: Standard
      accountReplicationType: LRS
  exampleWorkspace:
    type: azure:machinelearning:Workspace
    name: example
    properties:
      name: example-mlw
      location: ${example.location}
      resourceGroupName: ${example.name}
      applicationInsightsId: ${exampleInsights.id}
      keyVaultId: ${exampleKeyVault.id}
      storageAccountId: ${exampleAccount.id}
      identity:
        type: SystemAssigned
  exampleVirtualNetwork:
    type: azure:network:VirtualNetwork
    name: example
    properties:
      name: example-vnet
      addressSpaces:
        - 10.1.0.0/16
      location: ${example.location}
      resourceGroupName: ${example.name}
  exampleSubnet:
    type: azure:network:Subnet
    name: example
    properties:
      name: example-subnet
      resourceGroupName: ${example.name}
      virtualNetworkName: ${exampleVirtualNetwork.name}
      addressPrefixes:
        - 10.1.0.0/24
  exampleKubernetesCluster:
    type: azure:containerservice:KubernetesCluster
    name: example
    properties:
      name: example-aks
      location: ${example.location}
      resourceGroupName: ${example.name}
      dnsPrefixPrivateCluster: prefix
      defaultNodePool:
        name: default
        nodeCount: 3
        vmSize: Standard_D3_v2
        vnetSubnetId: ${exampleSubnet.id}
      identity:
        type: SystemAssigned
  exampleInferenceCluster:
    type: azure:machinelearning:InferenceCluster
    name: example
    properties:
      name: example
      location: ${example.location}
      clusterPurpose: FastProd
      kubernetesClusterId: ${exampleKubernetesCluster.id}
      description: This is an example cluster used with Terraform
      machineLearningWorkspaceId: ${exampleWorkspace.id}
      tags:
        stage: example
variables:
  current:
    fn::invoke:
      Function: azure:core:getClientConfig
      Arguments: {}

var inferenceClusterResource = new Azure.MachineLearning.InferenceCluster("inferenceClusterResource", new()
{
    KubernetesClusterId = "string",
    MachineLearningWorkspaceId = "string",
    ClusterPurpose = "string",
    Description = "string",
    Identity = new Azure.MachineLearning.Inputs.InferenceClusterIdentityArgs
    {
        Type = "string",
        IdentityIds = new[]
        {
            "string",
        },
        PrincipalId = "string",
        TenantId = "string",
    },
    Location = "string",
    Name = "string",
    Ssl = new Azure.MachineLearning.Inputs.InferenceClusterSslArgs
    {
        Cert = "string",
        Cname = "string",
        Key = "string",
        LeafDomainLabel = "string",
        OverwriteExistingDomain = false,
    },
    Tags = 
    {
        { "string", "string" },
    },
});

example, err := machinelearning.NewInferenceCluster(ctx, "inferenceClusterResource", &machinelearning.InferenceClusterArgs{
	KubernetesClusterId:        pulumi.String("string"),
	MachineLearningWorkspaceId: pulumi.String("string"),
	ClusterPurpose:             pulumi.String("string"),
	Description:                pulumi.String("string"),
	Identity: &machinelearning.InferenceClusterIdentityArgs{
		Type: pulumi.String("string"),
		IdentityIds: pulumi.StringArray{
			pulumi.String("string"),
		},
		PrincipalId: pulumi.String("string"),
		TenantId:    pulumi.String("string"),
	},
	Location: pulumi.String("string"),
	Name:     pulumi.String("string"),
	Ssl: &machinelearning.InferenceClusterSslArgs{
		Cert:                    pulumi.String("string"),
		Cname:                   pulumi.String("string"),
		Key:                     pulumi.String("string"),
		LeafDomainLabel:         pulumi.String("string"),
		OverwriteExistingDomain: pulumi.Bool(false),
	},
	Tags: pulumi.StringMap{
		"string": pulumi.String("string"),
	},
})

var inferenceClusterResource = new InferenceCluster("inferenceClusterResource", InferenceClusterArgs.builder()
    .kubernetesClusterId("string")
    .machineLearningWorkspaceId("string")
    .clusterPurpose("string")
    .description("string")
    .identity(InferenceClusterIdentityArgs.builder()
        .type("string")
        .identityIds("string")
        .principalId("string")
        .tenantId("string")
        .build())
    .location("string")
    .name("string")
    .ssl(InferenceClusterSslArgs.builder()
        .cert("string")
        .cname("string")
        .key("string")
        .leafDomainLabel("string")
        .overwriteExistingDomain(false)
        .build())
    .tags(Map.of("string", "string"))
    .build());

inference_cluster_resource = azure.machinelearning.InferenceCluster("inferenceClusterResource",
    kubernetes_cluster_id="string",
    machine_learning_workspace_id="string",
    cluster_purpose="string",
    description="string",
    identity={
        "type": "string",
        "identity_ids": ["string"],
        "principal_id": "string",
        "tenant_id": "string",
    },
    location="string",
    name="string",
    ssl={
        "cert": "string",
        "cname": "string",
        "key": "string",
        "leaf_domain_label": "string",
        "overwrite_existing_domain": False,
    },
    tags={
        "string": "string",
    })

const inferenceClusterResource = new azure.machinelearning.InferenceCluster("inferenceClusterResource", {
    kubernetesClusterId: "string",
    machineLearningWorkspaceId: "string",
    clusterPurpose: "string",
    description: "string",
    identity: {
        type: "string",
        identityIds: ["string"],
        principalId: "string",
        tenantId: "string",
    },
    location: "string",
    name: "string",
    ssl: {
        cert: "string",
        cname: "string",
        key: "string",
        leafDomainLabel: "string",
        overwriteExistingDomain: false,
    },
    tags: {
        string: "string",
    },
});

type: azure:machinelearning:InferenceCluster
properties:
    clusterPurpose: string
    description: string
    identity:
        identityIds:
            - string
        principalId: string
        tenantId: string
        type: string
    kubernetesClusterId: string
    location: string
    machineLearningWorkspaceId: string
    name: string
    ssl:
        cert: string
        cname: string
        key: string
        leafDomainLabel: string
        overwriteExistingDomain: false
    tags:
        string: string