fix(rdb): enable private_network when restoring from snapshot

internal/services/rdb/instance.go

@@ -405,6 +405,15 @@ func ResourceRdbInstanceCreate(ctx context.Context, d *schema.ResourceData, m an
 			}
 		}
 
+		// Configure endpoints after instance creation from snapshot
+		if diags := createPrivateNetworkEndpoints(ctx, rdbAPI, region, res.ID, d); diags.HasError() {
+			return diags
+		}
+
+		if diags := createLoadBalancerEndpoint(ctx, rdbAPI, region, res.ID, d); diags.HasError() {
+			return diags
+		}
+
 		d.SetId(regional.NewIDString(region, res.ID))
 		id = res.ID
 	} else {
@@ -434,43 +443,16 @@ func ResourceRdbInstanceCreate(ctx context.Context, d *schema.ResourceData, m an
 		}
 
 		// Init Endpoints
-		if pn, pnExist := d.GetOk("private_network"); pnExist {
-			ipamConfig, staticConfig := getIPConfigCreate(d, "ip_net")
-
-			var diags diag.Diagnostics
-
-			createReq.InitEndpoints, diags = expandPrivateNetwork(pn, pnExist, ipamConfig, staticConfig)
-			if diags.HasError() {
-				return diags
-			}
-
-			for _, warning := range diags {
-				tflog.Warn(ctx, warning.Detail)
-			}
-		}
-
-		if _, lbExists := d.GetOk("load_balancer"); lbExists {
-			createReq.InitEndpoints = append(createReq.InitEndpoints, expandLoadBalancer())
+		endpoints, diags := collectEndpointSpecs(d)
+		if diags.HasError() {
+			return diags
 		}
-		// Init Endpoints
-		if pn, pnExist := d.GetOk("private_network"); pnExist {
-			ipamConfig, staticConfig := getIPConfigCreate(d, "ip_net")
-
-			var diags diag.Diagnostics
-
-			createReq.InitEndpoints, diags = expandPrivateNetwork(pn, pnExist, ipamConfig, staticConfig)
-			if diags.HasError() {
-				return diags
-			}
 
-			for _, warning := range diags {
-				tflog.Warn(ctx, warning.Detail)
-			}
+		for _, warning := range diags {
+			tflog.Warn(ctx, warning.Detail)
 		}
 
-		if _, lbExists := d.GetOk("load_balancer"); lbExists {
-			createReq.InitEndpoints = append(createReq.InitEndpoints, expandLoadBalancer())
-		}
+		createReq.InitEndpoints = endpoints
 
 		if size, ok := d.GetOk("volume_size_in_gb"); ok {
 			if createReq.VolumeType == rdb.VolumeTypeLssd {
@@ -548,6 +530,77 @@ func ResourceRdbInstanceCreate(ctx context.Context, d *schema.ResourceData, m an
 	return ResourceRdbInstanceRead(ctx, d, m)
 }
 
+// createPrivateNetworkEndpoints creates private network endpoints for an instance
+func createPrivateNetworkEndpoints(ctx context.Context, rdbAPI *rdb.API, region scw.Region, instanceID string, d *schema.ResourceData) diag.Diagnostics {
+	if pn, pnExist := d.GetOk("private_network"); pnExist {
+		ipamConfig, staticConfig := getIPConfigCreate(d, "ip_net")
+
+		privateEndpoints, diags := expandPrivateNetwork(pn, pnExist, ipamConfig, staticConfig)
+		if diags.HasError() {
+			return diags
+		}
+
+		for _, warning := range diags {
+			tflog.Warn(ctx, warning.Detail)
+		}
+
+		for _, e := range privateEndpoints {
+			_, err := rdbAPI.CreateEndpoint(
+				&rdb.CreateEndpointRequest{Region: region, InstanceID: instanceID, EndpointSpec: e},
+				scw.WithContext(ctx))
+			if err != nil {
+				return diag.FromErr(err)
+			}
+		}
+	}
+
+	return nil
+}
+
+// createLoadBalancerEndpoint creates load balancer endpoint for an instance
+func createLoadBalancerEndpoint(ctx context.Context, rdbAPI *rdb.API, region scw.Region, instanceID string, d *schema.ResourceData) diag.Diagnostics {
+	if _, lbExists := d.GetOk("load_balancer"); lbExists {
+		_, err := rdbAPI.CreateEndpoint(&rdb.CreateEndpointRequest{
+			Region:       region,
+			InstanceID:   instanceID,
+			EndpointSpec: expandLoadBalancer(),
+		}, scw.WithContext(ctx))
+		if err != nil {
+			return diag.FromErr(err)
+		}
+	}
+
+	return nil
+}
+
+// collectEndpointSpecs collects all endpoint specifications for instance creation
+func collectEndpointSpecs(d *schema.ResourceData) ([]*rdb.EndpointSpec, diag.Diagnostics) {
+	var endpoints []*rdb.EndpointSpec
+
+	var diags diag.Diagnostics
+
+	// Add private network endpoints
+	if pn, pnExist := d.GetOk("private_network"); pnExist {
+		ipamConfig, staticConfig := getIPConfigCreate(d, "ip_net")
+
+		privateEndpoints, pnDiags := expandPrivateNetwork(pn, pnExist, ipamConfig, staticConfig)
+		if pnDiags.HasError() {
+			return nil, pnDiags
+		}
+
+		diags = append(diags, pnDiags...)
+
+		endpoints = append(endpoints, privateEndpoints...)
+	}
+
+	// Add load balancer endpoint
+	if _, lbExists := d.GetOk("load_balancer"); lbExists {
+		endpoints = append(endpoints, expandLoadBalancer())
+	}
+
+	return endpoints, diags
+}
+
 func ResourceRdbInstanceRead(ctx context.Context, d *schema.ResourceData, m any) diag.Diagnostics {
 	rdbAPI, region, ID, err := NewAPIWithRegionAndID(m, d.Id())
 	if err != nil {

internal/services/rdb/instance_test.go

@@ -1296,6 +1296,88 @@ func TestAccInstance_CompleteWorkflow(t *testing.T) {
 	})
 }
 
+func TestAccInstance_FromSnapshotWithPrivateNetwork(t *testing.T) {
+	tt := acctest.NewTestTools(t)
+	defer tt.Cleanup()
+
+	latestEngineVersion := rdbchecks.GetLatestEngineVersion(tt, postgreSQLEngineName)
+
+	resource.ParallelTest(t, resource.TestCase{
+		PreCheck:          func() { acctest.PreCheck(t) },
+		ProviderFactories: tt.ProviderFactories,
+		CheckDestroy:      IsSnapshotDestroyed(tt),
+		Steps: []resource.TestStep{
+			// Step 1: Create an instance, private network, and a snapshot
+			{
+				Config: fmt.Sprintf(`
+					resource "scaleway_vpc" "vpc" {
+						name = "test-vpc"
+					}
+
+					resource "scaleway_vpc_private_network" "pn" {
+						vpc_id = scaleway_vpc.vpc.id
+						ipv4_subnet {
+							subnet = "192.168.0.0/24"
+						}
+						depends_on = [scaleway_vpc.vpc]
+					}
+
+					resource "scaleway_rdb_instance" "main" {
+						name           = "test-rdb-instance"
+						node_type      = "db-dev-s"
+						engine         = %q
+						is_ha_cluster  = false
+						disable_backup = true
+						user_name      = "my_initial_user"
+						password       = "thiZ_is_v&ry_s3cret"
+						tags           = ["terraform-test", "scaleway_rdb_instance"]
+						volume_type    = "sbs_5k"
+						volume_size_in_gb = 10
+
+						private_network {
+							pn_id       = scaleway_vpc_private_network.pn.id
+							enable_ipam = true
+						}
+
+						depends_on = [scaleway_vpc_private_network.pn]
+					}
+
+					resource "scaleway_rdb_snapshot" "test" {
+						name        = "test-snapshot"
+						instance_id = scaleway_rdb_instance.main.id
+						depends_on  = [scaleway_rdb_instance.main]
+					}
+
+					resource "scaleway_rdb_instance" "from_snapshot" {
+						name           = "test-instance-from-snapshot"
+						node_type      = "db-dev-s"
+						is_ha_cluster  = false
+						disable_backup = true
+						snapshot_id    = scaleway_rdb_snapshot.test.id
+						volume_type    = "sbs_5k"
+						tags           = ["terraform-test", "restored_instance"]
+
+						private_network {
+							pn_id       = scaleway_vpc_private_network.pn.id
+							enable_ipam = true
+						}
+
+						depends_on = [scaleway_rdb_snapshot.test]
+					}
+				`, latestEngineVersion),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr("scaleway_rdb_instance.from_snapshot", "name", "test-instance-from-snapshot"),
+					resource.TestCheckResourceAttr("scaleway_rdb_instance.from_snapshot", "user_name", "my_initial_user"),
+					resource.TestCheckResourceAttr("scaleway_rdb_instance.from_snapshot", "tags.0", "terraform-test"),
+					resource.TestCheckResourceAttr("scaleway_rdb_instance.from_snapshot", "tags.1", "restored_instance"),
+					resource.TestCheckResourceAttrSet("scaleway_rdb_instance.from_snapshot", "private_network.0.pn_id"),
+					resource.TestCheckResourceAttr("scaleway_rdb_instance.from_snapshot", "private_network.0.enable_ipam", "true"),
+				),
+			},
+		},
+	})
+}
+
 func isInstancePresent(tt *acctest.TestTools, n string) resource.TestCheckFunc {
 	return func(s *terraform.State) error {
 		rs, ok := s.RootModule().Resources[n]