feat: AKS OS disk ephemeral

castai/resource_node_configuration.go

@@ -39,6 +39,7 @@ const (
 	FieldNodeConfigurationGKE                     = "gke"
 	FieldNodeConfigurationEKSTargetGroup          = "target_group"
 	FieldNodeConfigurationAKSImageFamily          = "aks_image_family"
+	FieldNodeConfigurationAKSEphemeralOSDisk      = "ephemeral_os_disk"
 	FieldNodeConfigurationEKSImageFamily          = "eks_image_family"
 	FieldNodeConfigurationLoadbalancers           = "loadbalancers"
 	FieldNodeConfigurationAKSLoadbalancerIPPools  = "ip_based_backend_pools"
@@ -52,8 +53,12 @@ const (
 )
 
 const (
-	aksImageFamilyUbuntu     = "ubuntu"
-	aksImageFamilyAzureLinux = "azure-linux"
+	aksImageFamilyUbuntu                  = "ubuntu"
+	aksImageFamilyAzureLinux              = "azure-linux"
+	aksEphemeralDiskPlacementCacheDisk    = "cacheDisk"
+	aksEphemeralDiskPlacementResourceDisk = "resourceDisk"
+	aksDiskCacheReadOnly                  = "ReadOnly"
+	aksDiskCacheReadWrite                 = "ReadWrite"
 )
 
 func resourceNodeConfiguration() *schema.Resource {
@@ -332,6 +337,34 @@ func resourceNodeConfiguration() *schema.Resource {
 								return strings.EqualFold(oldValue, newValue)
 							},
 						},
+						FieldNodeConfigurationAKSEphemeralOSDisk: {
+							Type:        schema.TypeList,
+							Optional:    true,
+							Description: "Ephemeral OS disk configuration for CAST provisioned nodes",
+							MaxItems:    1,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"placement": {
+										Type:             schema.TypeString,
+										Required:         true,
+										Description:      "Placement of the ephemeral OS disk. One of: cacheDisk, resourceDisk",
+										ValidateDiagFunc: validation.ToDiagFunc(validation.StringInSlice([]string{aksEphemeralDiskPlacementCacheDisk, aksEphemeralDiskPlacementResourceDisk}, true)),
+										DiffSuppressFunc: func(k, oldValue, newValue string, d *schema.ResourceData) bool {
+											return strings.EqualFold(oldValue, newValue)
+										},
+									},
+									"cache": {
+										Type:             schema.TypeString,
+										Optional:         true,
+										Description:      "Cache type for the ephemeral OS disk. One of: ReadOnly, ReadWrite",
+										ValidateDiagFunc: validation.ToDiagFunc(validation.StringInSlice([]string{aksDiskCacheReadOnly, aksDiskCacheReadWrite}, true)),
+										DiffSuppressFunc: func(k, oldValue, newValue string, d *schema.ResourceData) bool {
+											return strings.EqualFold(oldValue, newValue)
+										},
+									},
+								},
+							},
+						},
 						FieldNodeConfigurationLoadbalancers: {
 							Type:        schema.TypeList,
 							Optional:    true,
@@ -983,6 +1016,10 @@ func toAKSSConfig(obj map[string]interface{}) *sdk.NodeconfigV1AKSConfig {
 		out.OsDiskType = toAKSOSDiskType(v)
 	}
 
+	if v, ok := obj[FieldNodeConfigurationAKSEphemeralOSDisk].([]any); ok && len(v) > 0 {
+		out.OsDiskEphemeral = toAKSEphemeralOSDisk(v[0])
+	}
+
 	if v, ok := obj[FieldNodeConfigurationAKSImageFamily].(string); ok {
 		out.ImageFamily = toAKSImageFamily(v)
 	}
@@ -994,6 +1031,34 @@ func toAKSSConfig(obj map[string]interface{}) *sdk.NodeconfigV1AKSConfig {
 	return out
 }
 
+func toAKSEphemeralOSDisk(obj any) *sdk.NodeconfigV1AKSConfigOsDiskEphemeral {
+	if obj == nil {
+		return nil
+	}
+
+	osDisk := &sdk.NodeconfigV1AKSConfigOsDiskEphemeral{}
+
+	if v, ok := obj.(map[string]any)["placement"].(string); ok && v != "" {
+		switch v {
+		case aksEphemeralDiskPlacementResourceDisk:
+			osDisk.Placement = lo.ToPtr(sdk.PLACEMENTRESOURCEDISK)
+		case aksEphemeralDiskPlacementCacheDisk:
+			osDisk.Placement = lo.ToPtr(sdk.PLACEMENTCACHEDISK)
+		}
+	}
+
+	if v, ok := obj.(map[string]any)["cache"].(string); ok && v != "" {
+		switch v {
+		case aksDiskCacheReadWrite:
+			osDisk.CacheType = lo.ToPtr(sdk.NodeconfigV1AKSConfigOsDiskEphemeralCacheTypeREADWRITE)
+		case aksDiskCacheReadOnly:
+			osDisk.CacheType = lo.ToPtr(sdk.NodeconfigV1AKSConfigOsDiskEphemeralCacheTypeREADONLY)
+		}
+	}
+
+	return osDisk
+}
+
 func toAksLoadBalancers(obj []interface{}) *[]sdk.NodeconfigV1AKSConfigLoadBalancers {
 	if obj == nil {
 		return nil
@@ -1110,6 +1175,37 @@ func flattenAKSConfig(config *sdk.NodeconfigV1AKSConfig) []map[string]interface{
 		m[FieldNodeConfigurationLoadbalancers] = fromAksLoadBalancers(*v)
 	}
 
+	if v := config.OsDiskEphemeral; v != nil {
+		m[FieldNodeConfigurationAKSEphemeralOSDisk] = fromAKSEphemeralOSDisk(v)
+	}
+
+	return []map[string]interface{}{m}
+}
+
+func fromAKSEphemeralOSDisk(sdkEph *sdk.NodeconfigV1AKSConfigOsDiskEphemeral) []map[string]interface{} {
+	if sdkEph == nil {
+		return nil
+	}
+
+	m := map[string]interface{}{}
+	if sdkEph.Placement != nil {
+		switch *sdkEph.Placement {
+		case sdk.PLACEMENTRESOURCEDISK:
+			m["placement"] = aksEphemeralDiskPlacementResourceDisk
+		case sdk.PLACEMENTCACHEDISK:
+			m["placement"] = aksEphemeralDiskPlacementCacheDisk
+		}
+	}
+
+	if sdkEph.CacheType != nil {
+		switch *sdkEph.CacheType {
+		case sdk.NodeconfigV1AKSConfigOsDiskEphemeralCacheTypeREADWRITE:
+			m["cache"] = aksDiskCacheReadWrite
+		case sdk.NodeconfigV1AKSConfigOsDiskEphemeralCacheTypeREADONLY:
+			m["cache"] = aksDiskCacheReadOnly
+		}
+	}
+
 	return []map[string]interface{}{m}
 }
 

castai/resource_node_configuration_aks_test.go

@@ -43,6 +43,8 @@ func TestAccResourceNodeConfiguration_aks(t *testing.T) {
 					resource.TestCheckResourceAttr(resourceName, "min_disk_size", "121"),
 					resource.TestCheckResourceAttr(resourceName, "aks.0.max_pods_per_node", "32"),
 					resource.TestCheckResourceAttr(resourceName, "aks.0.aks_image_family", "azure-linux"),
+					resource.TestCheckResourceAttr(resourceName, "aks.0.ephemeral_os_disk.0.placement", "cacheDisk"),
+					resource.TestCheckResourceAttr(resourceName, "aks.0.ephemeral_os_disk.0.cache", "ReadOnly"),
 					resource.TestCheckResourceAttr(resourceName, "aks.0.loadbalancers.0.name", "test-lb"),
 					resource.TestCheckResourceAttr(resourceName, "aks.0.loadbalancers.0.ip_based_backend_pools.0.name", "test"),
 					resource.TestCheckResourceAttr(resourceName, "eks.#", "0"),
@@ -102,6 +104,10 @@ resource "castai_node_configuration" "test" {
   aks {
 	max_pods_per_node = 32
     aks_image_family = "azure-linux"
+	ephemeral_os_disk {
+    	placement = "cacheDisk"
+    	cache = "ReadOnly"
+	}
 	loadbalancers {
 		name = "test-lb"
 		ip_based_backend_pools {

castai/resource_sso_connection_test.go

@@ -136,6 +136,7 @@ func TestSSOConnection_CreateADDConnector(t *testing.T) {
     "clientSecret": "test_secret"
   },
   "emailDomain": "test_email",
+  "defaultRoleId": null,
   "name": "test_sso"
 }
 `)
@@ -213,6 +214,7 @@ func TestSSOConnection_CreateADDConnector(t *testing.T) {
     "clientSecret": "test_secret"
   },
   "emailDomain": "test_email",
+  "defaultRoleId": null,
   "additionalEmailDomains": ["test_domain1.com", "test_domain2.com"],
   "name": "test_sso"
 }
@@ -294,6 +296,7 @@ func TestSSOConnection_CreateOktaConnector(t *testing.T) {
     "clientSecret": "test_secret"
   },
   "emailDomain": "test_email",
+  "defaultRoleId": null,
   "name": "test_sso"
 }`)
 
@@ -391,6 +394,7 @@ func TestSSOConnection_UpdateADDConnector(t *testing.T) {
     "clientId": "updated_client_id",
     "clientSecret": "updated_client_secret"
   },
+  "defaultRoleId": null,
   "name": "updated_name"
 }`)
 
@@ -452,7 +456,6 @@ func TestSSOConnection_UpdateADDConnector(t *testing.T) {
 		}
 		connectionID := "b6bfc074-a267-400f-b8f1-db0850c369b1"
 
-
 		raw := make(map[string]interface{})
 		raw[FieldSSOConnectionName] = "updated_name"
 
@@ -480,6 +483,7 @@ func TestSSOConnection_UpdateADDConnector(t *testing.T) {
     "clientSecret": "updated_client_secret"
   },
   "name": "updated_name",
+  "defaultRoleId": null,
 	"additionalEmailDomains": ["updated_domain_one", "updated_domain_two"]
 }`)
 
@@ -570,6 +574,7 @@ func TestSSOConnection_UpdateOktaConnector(t *testing.T) {
     "clientId": "updated_client_id",
     "clientSecret": "updated_client_secret"
   },
+  "defaultRoleId": null,
   "name": "updated_name"
 }`)