azurerm_machine_learning_workspace - Add support for serverless_compute

internal/services/machinelearning/machine_learning_workspace_resource.go

@@ -22,6 +22,7 @@ import (
 	"github.com/hashicorp/terraform-provider-azurerm/internal/clients"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/features"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/services/machinelearning/validate"
+	networkValidate "github.com/hashicorp/terraform-provider-azurerm/internal/services/network/validate"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/pluginsdk"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/suppress"
 	"github.com/hashicorp/terraform-provider-azurerm/internal/tf/validation"
@@ -230,6 +231,26 @@ func resourceMachineLearningWorkspace() *pluginsdk.Resource {
 				Default:  false,
 			},
 
+			"serverless_compute": {
+				Type:     pluginsdk.TypeList,
+				Optional: true,
+				MaxItems: 1,
+				Elem: &pluginsdk.Resource{
+					Schema: map[string]*pluginsdk.Schema{
+						"subnet_id": {
+							Type:         pluginsdk.TypeString,
+							Optional:     true,
+							ValidateFunc: networkValidate.SubnetID,
+						},
+						"public_ip_enabled": {
+							Type:     pluginsdk.TypeBool,
+							Optional: true,
+							Default:  true,
+						},
+					},
+				},
+			},
+
 			"discovery_url": {
 				Type:     pluginsdk.TypeString,
 				Computed: true,
@@ -315,6 +336,22 @@ func resourceMachineLearningWorkspaceCreateOrUpdate(d *pluginsdk.ResourceData, m
 		},
 	}
 
+	serverlessCompute := expandMachineLearningWorkspaceServerlessCompute(d.Get("serverless_compute").([]interface{}))
+	if serverlessCompute != nil {
+		if !networkAccessBehindVnetEnabled && !*serverlessCompute.ServerlessComputeNoPublicIP {
+			return fmt.Errorf(" Not supported to set `public_ip_enabled` to `false` without `subnet_id` when `public_network_access_enabled` is `false`")
+		}
+
+		if serverlessCompute.ServerlessComputeCustomSubnet == nil {
+			oldVal, newVal := d.GetChange("serverless_compute.0.public_ip_enabled")
+			if oldVal.(bool) && !newVal.(bool) {
+				return fmt.Errorf(" Not supported to update `public_ip_enabled` from `true` to `false` when `subnet_id` is null or empty")
+			}
+		}
+	}
+
+	workspace.Properties.ServerlessComputeSettings = serverlessCompute
+
 	if networkAccessBehindVnetEnabled {
 		workspace.Properties.PublicNetworkAccess = pointer.To(workspaces.PublicNetworkAccessEnabled)
 	}
@@ -414,6 +451,7 @@ func resourceMachineLearningWorkspaceRead(d *pluginsdk.ResourceData, meta interf
 		d.Set("v1_legacy_mode_enabled", props.V1LegacyMode)
 		d.Set("workspace_id", props.WorkspaceId)
 		d.Set("managed_network", flattenMachineLearningWorkspaceManagedNetwork(props.ManagedNetwork))
+		d.Set("serverless_compute", flattenMachineLearningWorkspaceServerlessCompute(props.ServerlessComputeSettings))
 
 		kvId, err := commonids.ParseKeyVaultIDInsensitively(*props.KeyVault)
 		if err != nil {
@@ -670,3 +708,39 @@ func flattenMachineLearningWorkspaceManagedNetwork(i *workspaces.ManagedNetworkS
 
 	return &[]interface{}{out}
 }
+
+func expandMachineLearningWorkspaceServerlessCompute(i []interface{}) *workspaces.ServerlessComputeSettings {
+	if len(i) == 0 || i[0] == nil {
+		return nil
+	}
+
+	v := i[0].(map[string]interface{})
+
+	serverlessCompute := workspaces.ServerlessComputeSettings{
+		ServerlessComputeNoPublicIP: pointer.To(!v["public_ip_enabled"].(bool)),
+	}
+
+	if subnetId, ok := v["subnet_id"].(string); ok && subnetId != "" {
+		serverlessCompute.ServerlessComputeCustomSubnet = pointer.To(subnetId)
+	}
+
+	return &serverlessCompute
+}
+
+func flattenMachineLearningWorkspaceServerlessCompute(i *workspaces.ServerlessComputeSettings) *[]interface{} {
+	if i == nil {
+		return &[]interface{}{}
+	}
+
+	out := map[string]interface{}{}
+
+	if i.ServerlessComputeCustomSubnet != nil {
+		out["subnet_id"] = *i.ServerlessComputeCustomSubnet
+	}
+
+	if i.ServerlessComputeNoPublicIP != nil {
+		out["public_ip_enabled"] = !*i.ServerlessComputeNoPublicIP
+	}
+
+	return &[]interface{}{out}
+}

internal/services/machinelearning/machine_learning_workspace_resource_test.go

@@ -353,6 +353,24 @@ func TestAccMachineLearningWorkspace_purgeSoftDelete(t *testing.T) {
 	})
 }
 
+func TestAccMachineLearningWorkspace_serverlessCompute(t *testing.T) {
+	data := acceptance.BuildTestData(t, "azurerm_machine_learning_workspace", "test")
+	r := WorkspaceResource{}
+
+	data.ResourceTest(t, r, []acceptance.TestStep{
+		{
+			Config: r.serverlessCompute(data),
+			Check: acceptance.ComposeTestCheckFunc(
+				check.That(data.ResourceName).ExistsInAzure(r),
+				check.That(data.ResourceName).Key("serverless_compute.#").HasValue("1"),
+				check.That(data.ResourceName).Key("serverless_compute.0.subnet_id").Exists(),
+				check.That(data.ResourceName).Key("serverless_compute.0.public_ip_enabled").HasValue("false"),
+			),
+		},
+		data.ImportStep(),
+	})
+}
+
 func (r WorkspaceResource) Exists(ctx context.Context, client *clients.Client, state *pluginsdk.InstanceState) (*bool, error) {
 	workspacesClient := client.MachineLearning.Workspaces
 	id, err := workspaces.ParseWorkspaceID(state.ID)
@@ -1166,3 +1184,40 @@ resource "azurerm_machine_learning_workspace" "test" {
 }
 `, template, data.RandomInteger)
 }
+
+func (r WorkspaceResource) serverlessCompute(data acceptance.TestData) string {
+	template := r.template(data)
+	return fmt.Sprintf(`
+%s
+
+resource "azurerm_virtual_network" "test" {
+  name                = "acctestvirtnet%[2]d"
+  address_space       = ["10.0.0.0/16"]
+  location            = azurerm_resource_group.test.location
+  resource_group_name = azurerm_resource_group.test.name
+}
+resource "azurerm_subnet" "test" {
+  name                 = "internal"
+  resource_group_name  = azurerm_resource_group.test.name
+  virtual_network_name = azurerm_virtual_network.test.name
+  address_prefixes     = ["10.0.2.0/24"]
+}
+
+resource "azurerm_machine_learning_workspace" "test" {
+  name                    = "acctest-MLW-%[2]d"
+  location                = azurerm_resource_group.test.location
+  resource_group_name     = azurerm_resource_group.test.name
+  application_insights_id = azurerm_application_insights.test.id
+  key_vault_id            = azurerm_key_vault.test.id
+  storage_account_id      = azurerm_storage_account.test.id
+
+  serverless_compute {
+    subnet_id = azurerm_subnet.test.id
+  }
+
+  identity {
+    type = "SystemAssigned"
+  }
+}
+`, template, data.RandomInteger)
+}

website/docs/r/machine_learning_workspace.html.markdown

@@ -390,6 +390,8 @@ The following arguments are supported:
 
 * `sku_name` - (Optional) SKU/edition of the Machine Learning Workspace, possible values are `Free`, `Basic`, `Standard` and `Premium`. Defaults to `Basic`.
 
+* `serverless_compute` - (Optional) A `serverless_compute` block as defined below.
+
 * `tags` - (Optional) A mapping of tags to assign to the resource.
 
 ---
@@ -422,6 +424,18 @@ An `managed_network` block supports the following:
 
 ---
 
+An `serverless_compute` block supports the following:
+
+* `custom_subnet_id` - (Optional) The ID of an existing virtual network subnet in which serverless compute nodes should be deployed.
+
+* `no_public_ip_enabled` - (Optional) Is serverless compute nodes deployed in custom vNet would have no public IP addresses enabled for a workspace with private endpoint? Defaults to `false`.
+
+~> **Note:** Not supported to set `public_ip_enabled` to `false` without `subnet_id` when `public_network_access_enabled` is `false`.
+
+~> **Note:** Not supported to update `public_ip_enabled` from `true` to `false` when `subnet_id` is null or empty
+
+---
+
 An `feature_store` block supports the following:
 
 * `computer_spark_runtime_version` - (Optional) The version of Spark runtime.