scaleway
diff --git a/‎docs/resources/lb.md
+4 b/‎docs/resources/lb.md
+4
diff --git a/‎docs/resources/lb_private_network.md
+69 b/‎docs/resources/lb_private_network.md
+69
diff --git a/‎scaleway/data_source_lb.go
+16 b/‎scaleway/data_source_lb.go
+16
diff --git a/‎scaleway/helpers_lb.go
+24 b/‎scaleway/helpers_lb.go
+24
diff --git a/‎scaleway/provider.go
+2 b/‎scaleway/provider.go
+2
diff --git a/‎scaleway/provider_test.go
+1-1 b/‎scaleway/provider_test.go
+1-1
diff --git a/‎scaleway/resource_lb.go
+45-10 b/‎scaleway/resource_lb.go
+45-10
diff --git a/‎scaleway/resource_lb_acl_test.go
+8 b/‎scaleway/resource_lb_acl_test.go
+8
diff --git a/‎scaleway/resource_lb_backend.go
+12 b/‎scaleway/resource_lb_backend.go
+12
diff --git a/‎scaleway/resource_lb_certificate.go
+5-4 b/‎scaleway/resource_lb_certificate.go
+5-4
diff --git a/‎scaleway/resource_lb_frontend.go
+14-2 b/‎scaleway/resource_lb_frontend.go
+14-2
diff --git a/‎scaleway/resource_lb_ip.go
+1-1 b/‎scaleway/resource_lb_ip.go
+1-1
@@ -21,6 +21,7 @@ resource "scaleway_lb" "base" {
   ip_id  = scaleway_lb_ip.ip.id
   zone = "fr-par-1"
   type   = "LB-S"
+  release_ip = true
 }
 ```
 
@@ -40,6 +41,8 @@ The following arguments are supported:
 
 - `tags` - (Optional) The tags associated with the load-balancers.
 
+- `release_ip` - (Defaults to false) The release_ip allow release the ip address associated with the load-balancers.
+
 - `zone` - (Defaults to [provider](../index.md#zone) `zone`) The [zone](../guides/regions_and_zones.md#zones) in which the IP should be reserved.
 
 - `project_id` - (Defaults to [provider](../index.md#project_id) `project_id`) The ID of the project the load-balancer is associated with.
@@ -77,6 +80,7 @@ resource "scaleway_lb" "base" {
   ip_id  = scaleway_lb_ip.ip.id
   zone = "fr-par-1"
   type   = "LB-S"
+  release_ip = true
 }
 ```
 
 
@@ -0,0 +1,69 @@
+---
+page_title: "Scaleway: scaleway_lb_private_network"
+description: |-
+Manages Scaleway Load-Balancers private networks
+---
+
+# scaleway_lb_private_network
+
+Creates and manages Scaleway attach/detach private networks to Load-Balancers.
+For more information, see [the documentation](https://developers.scaleway.com/en/products/lb/zoned_api/#post-d4b30).
+
+## Examples
+
+### Basic
+
+```hcl
+resource scaleway_vpc_private_network pn01 {
+  name = "test-lb-pn"
+}
+
+resource scaleway_lb_ip ip01 {}
+
+resource scaleway_lb lb01 {
+  ip_id = scaleway_lb_ip.ip01.id
+  name = "test-lb"
+  type = "lb-s"
+  release_ip = true
+}
+
+resource scaleway_lb_private_network lb01pn01 {
+  lb_id = scaleway_lb.lb01.id
+  private_network_id = scaleway_vpc_private_network.pn01.id
+  static_config = ["172.16.0.100", "172.16.0.101"]
+}
+```
+
+## Arguments Reference
+
+The following arguments are supported:
+
+- `lb_id` - (Required) The ID of the load-balancer to associate.
+
+- `private_network_id` - (Required) The ID of the Private Network to associate.
+
+- `static_config` - (Required) Define two local ip address of your choice for each load balancer instance. See below.
+
+- `dhcp_config` - (Required) Set to true if you want to let DHCP assign IP addresses. See below.
+
+~> **Important:**  Only one of static_config and dhcp_config may be set.
+
+- `zone` - (Defaults to [provider](../index.md#zone) `zone`) The [zone](../guides/regions_and_zones.md#zones) in which the IP should be reserved.
+
+- `project_id` - (Defaults to [provider](../index.md#project_id) `project_id`) The ID of the project the load-balancer is associated with.
+
+## Attributes Reference
+
+In addition to all arguments above, the following attributes are exported:
+
+- `status` -  The Private Network attachment status
+
+## Import
+
+Load-Balancer private network can be imported using the `{zone}/{id}`, e.g.
+
+```bash
+$ terraform import scaleway_lb_private_network.lb01pn01 fr-par/11111111-1111-1111-1111-111111111111
+```
+
+The attachments can either be found in the console
@@ -25,6 +25,12 @@ func dataSourceScalewayLb() *schema.Resource {
 		ValidateFunc:  validationUUIDorUUIDWithLocality(),
 		ConflictsWith: []string{"name"},
 	}
+	dsSchema["release_ip"] = &schema.Schema{
+		Type:        schema.TypeBool,
+		Optional:    true,
+		Default:     false,
+		Description: "Release the IPs related to this load-balancer",
+	}
 
 	return &schema.Resource{
 		ReadContext: dataSourceScalewayLbRead,
@@ -57,6 +63,16 @@ func dataSourceScalewayLbRead(ctx context.Context, d *schema.ResourceData, meta
 		lbID = res.LBs[0].ID
 	}
 
+	var relaseIPValue bool
+	releaseIPAddress, releaseIPExist := d.GetOk("release_ip")
+	if releaseIPExist {
+		relaseIPValue = *expandBoolPtr(releaseIPAddress)
+	}
+
+	err = d.Set("release_ip", relaseIPValue)
+	if err != nil {
+		return diag.FromErr(err)
+	}
 	zonedID := datasourceNewZonedID(lbID, zone)
 	d.SetId(zonedID)
 	err = d.Set("lb_id", zonedID)
 
@@ -293,3 +293,27 @@ func lbUpgradeV1RegionalToZonedID(element string) (string, error) {
 	//  append zone 1 as default: e.g. fr-par-1
 	return fmt.Sprintf("%s-1/%s", locality, id), nil
 }
+
+func expandLbPrivateNetworkStaticConfig(raw interface{}) *lb.PrivateNetworkStaticConfig {
+	if raw == nil || len(raw.([]interface{})) < 1 {
+		return nil
+	}
+	return &lb.PrivateNetworkStaticConfig{
+		IPAddress: expandStrings(raw),
+	}
+}
+
+func flattenLbPrivateNetworkStaticConfig(cfg *lb.PrivateNetworkStaticConfig) []string {
+	if cfg == nil {
+		return nil
+	}
+
+	return cfg.IPAddress
+}
+
+func expandLbPrivateNetworkDHCPConfig(raw interface{}) *lb.PrivateNetworkDHCPConfig {
+	if raw == nil || !raw.(bool) {
+		return nil
+	}
+	return &lb.PrivateNetworkDHCPConfig{}
+}
@@ -84,6 +84,8 @@ func Provider(config *ProviderConfig) plugin.ProviderFunc {
 				"scaleway_lb_backend":                    resourceScalewayLbBackend(),
 				"scaleway_lb_certificate":                resourceScalewayLbCertificate(),
 				"scaleway_lb_frontend":                   resourceScalewayLbFrontend(),
+				"scaleway_lb_private_network":            resourceScalewayLbPrivateNetwork(),
+				"scaleway_lb_route":                      resourceScalewayLbRoute(),
 				"scaleway_registry_namespace":            resourceScalewayRegistryNamespace(),
 				"scaleway_rdb_acl":                       resourceScalewayRdbACL(),
 				"scaleway_rdb_database":                  resourceScalewayRdbDatabase(),
 
@@ -84,7 +84,7 @@ type TestTools struct {
 }
 
 func NewTestTools(t *testing.T) *TestTools {
-	// Create an http client with recording capabilities
+	// Create a http client with recording capabilities
 	httpClient, cleanup, err := getHTTPRecoder(t, *UpdateCassettes)
 	require.NoError(t, err)
 
 
@@ -3,13 +3,18 @@ package scaleway
 import (
 	"context"
 	"strings"
+	"time"
 
 	"github.com/hashicorp/terraform-plugin-sdk/v2/diag"
 	"github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema"
 	"github.com/scaleway/scaleway-sdk-go/api/lb/v1"
 	"github.com/scaleway/scaleway-sdk-go/scw"
 )
 
+const (
+	DefaultWaitLBRetryInterval = 30 * time.Second
+)
+
 func resourceScalewayLb() *schema.Resource {
 	return &schema.Resource{
 		CreateContext: resourceScalewayLbCreate,
@@ -60,6 +65,12 @@ func resourceScalewayLb() *schema.Resource {
 				Computed:    true,
 				Description: "The load-balance public IP address",
 			},
+			"release_ip": {
+				Type:        schema.TypeBool,
+				Optional:    true,
+				Default:     false,
+				Description: "Release the IPs related to this load-balancer",
+			},
 			"region":          regionComputedSchema(),
 			"zone":            zoneSchema(),
 			"organization_id": organizationIDSchema(),
@@ -132,13 +143,20 @@ func resourceScalewayLbRead(ctx context.Context, d *schema.ResourceData, meta in
 		return diag.FromErr(err)
 	}
 
+	var relaseIPValue bool
+	releaseIPAddress, releaseIPPExist := d.GetOk("release_ip")
+	if releaseIPPExist {
+		relaseIPValue = *expandBoolPtr(releaseIPAddress)
+	}
+
+	_ = d.Set("release_ip", relaseIPValue)
 	_ = d.Set("name", res.Name)
 	_ = d.Set("zone", zone.String())
 	_ = d.Set("region", region.String())
 	_ = d.Set("organization_id", res.OrganizationID)
 	_ = d.Set("project_id", res.ProjectID)
 	_ = d.Set("tags", res.Tags)
-	// For now API return lowercase lb type. This should be fix in a near future on the API side
+	// For now API return lowercase lb type. This should be fixed in a near future on the API side
 	_ = d.Set("type", strings.ToUpper(res.Type))
 	_ = d.Set("ip_id", newZonedIDString(zone, res.IP[0].ID))
 	_ = d.Set("ip_address", res.IP[0].IPAddress)
@@ -160,6 +178,17 @@ func resourceScalewayLbUpdate(ctx context.Context, d *schema.ResourceData, meta
 			Tags: expandStrings(d.Get("tags")),
 		}
 
+		_, err = lbAPI.WaitForLb(&lb.ZonedAPIWaitForLBRequest{
+			LBID:          ID,
+			Zone:          zone,
+			Timeout:       scw.TimeDurationPtr(LbWaitForTimeout),
+			RetryInterval: DefaultWaitRetryInterval,
+		}, scw.WithContext(ctx))
+
+		if err != nil && !is404Error(err) {
+			return diag.FromErr(err)
+		}
+
 		_, err = lbAPI.UpdateLB(req, scw.WithContext(ctx))
 		if err != nil {
 			return diag.FromErr(err)
@@ -175,21 +204,27 @@ func resourceScalewayLbDelete(ctx context.Context, d *schema.ResourceData, meta
 		return diag.FromErr(err)
 	}
 
-	err = lbAPI.DeleteLB(&lb.ZonedAPIDeleteLBRequest{
-		Zone:      zone,
-		LBID:      ID,
-		ReleaseIP: false,
+	_, err = lbAPI.WaitForLb(&lb.ZonedAPIWaitForLBRequest{
+		LBID:          ID,
+		Zone:          zone,
+		Timeout:       scw.TimeDurationPtr(LbWaitForTimeout),
+		RetryInterval: DefaultWaitRetryInterval,
 	}, scw.WithContext(ctx))
 
 	if err != nil && !is404Error(err) {
 		return diag.FromErr(err)
 	}
 
-	_, err = lbAPI.WaitForLb(&lb.ZonedAPIWaitForLBRequest{
-		LBID:          ID,
-		Zone:          zone,
-		Timeout:       scw.TimeDurationPtr(LbWaitForTimeout),
-		RetryInterval: DefaultWaitRetryInterval,
+	var releaseAddressValue bool
+	releaseIPAddress, releaseIPPExist := d.GetOk("release_ip")
+	if releaseIPPExist {
+		releaseAddressValue = *expandBoolPtr(releaseIPAddress)
+	}
+
+	err = lbAPI.DeleteLB(&lb.ZonedAPIDeleteLBRequest{
+		Zone:      zone,
+		LBID:      ID,
+		ReleaseIP: releaseAddressValue,
 	}, scw.WithContext(ctx))
 
 	if err != nil && !is404Error(err) {
 
@@ -188,6 +188,14 @@ func TestAccScalewayLbAcl_Basic(t *testing.T) {
 					}),
 				),
 			},
+			{
+				Config: `
+					resource scaleway_lb_ip ip01 {}
+				`,
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttrSet("scaleway_lb_ip.ip01", "id"),
+				),
+			},
 		},
 	})
 }
 
@@ -255,6 +255,18 @@ func resourceScalewayLbBackendCreate(ctx context.Context, d *schema.ResourceData
 		healthCheckPort = d.Get("forward_port").(int)
 	}
 
+	retryInterval := DefaultWaitLBRetryInterval
+	_, err = lbAPI.WaitForLb(&lb.ZonedAPIWaitForLBRequest{
+		Zone:          zone,
+		LBID:          LbID,
+		Timeout:       scw.TimeDurationPtr(defaultInstanceServerWaitTimeout),
+		RetryInterval: &retryInterval,
+	}, scw.WithContext(ctx))
+
+	if err != nil && !is404Error(err) {
+		return diag.FromErr(err)
+	}
+
 	createReq := &lb.ZonedAPICreateBackendRequest{
 		Zone:                     zone,
 		LBID:                     LbID,
 
@@ -124,6 +124,11 @@ func resourceScalewayLbCertificateCreate(ctx context.Context, d *schema.Resource
 		return diag.FromErr(err)
 	}
 
+	lbAPI, _, err := lbAPIWithZone(d, meta)
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
 	createReq := &lb.ZonedAPICreateCertificateRequest{
 		Zone:              zone,
 		LBID:              lbID,
@@ -135,10 +140,6 @@ func resourceScalewayLbCertificateCreate(ctx context.Context, d *schema.Resource
 		return diag.FromErr(errors.New("you need to define either letsencrypt or custom_certificate configuration"))
 	}
 
-	lbAPI, _, err := lbAPIWithZone(d, meta)
-	if err != nil {
-		return diag.FromErr(err)
-	}
 	res, err := lbAPI.CreateCertificate(createReq, scw.WithContext(ctx))
 	if err != nil {
 		return diag.FromErr(err)
 
@@ -158,14 +158,26 @@ func resourceScalewayLbFrontendCreate(ctx context.Context, d *schema.ResourceDat
 		return diag.FromErr(err)
 	}
 
-	zone, LbID, err := parseZonedID(d.Get("lb_id").(string))
+	zone, lbID, err := parseZonedID(d.Get("lb_id").(string))
 	if err != nil {
 		return diag.FromErr(err)
 	}
 
+	retryInterval := DefaultWaitLBRetryInterval
+	_, err = lbAPI.WaitForLb(&lb.ZonedAPIWaitForLBRequest{
+		Zone:          zone,
+		LBID:          lbID,
+		Timeout:       scw.TimeDurationPtr(defaultInstanceServerWaitTimeout),
+		RetryInterval: &retryInterval,
+	}, scw.WithContext(ctx))
+
+	if err != nil && !is404Error(err) {
+		return diag.FromErr(err)
+	}
+
 	res, err := lbAPI.CreateFrontend(&lb.ZonedAPICreateFrontendRequest{
 		Zone:          zone,
-		LBID:          LbID,
+		LBID:          lbID,
 		Name:          expandOrGenerateString(d.Get("name"), "lb-frt"),
 		InboundPort:   int32(d.Get("inbound_port").(int)),
 		BackendID:     expandID(d.Get("backend_id")),
 
@@ -45,7 +45,7 @@ func resourceScalewayLbIP() *schema.Resource {
 			"lb_id": {
 				Type:        schema.TypeString,
 				Computed:    true,
-				Description: "The ID of the loadbalancer attached to this IP, if any",
+				Description: "The ID of the load balancer attached to this IP, if any",
 			},
 		},
 	}
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ type TestTools struct {`
`84`	`84`	`}`
`85`	`85`
`86`	`86`	`func NewTestTools(t testing.T) TestTools {`
`87`		`- // Create an http client with recording capabilities`
	`87`	`+ // Create a http client with recording capabilities`
`88`	`88`	`httpClient, cleanup, err := getHTTPRecoder(t, *UpdateCassettes)`
`89`	`89`	`require.NoError(t, err)`
`90`	`90`
Original file line number	Diff line number	Diff line change
`@@ -45,7 +45,7 @@ func resourceScalewayLbIP() *schema.Resource {`
`45`	`45`	`"lb_id": {`
`46`	`46`	`Type: schema.TypeString,`
`47`	`47`	`Computed: true,`
`48`		`- Description: "The ID of the loadbalancer attached to this IP, if any",`
	`48`	`+ Description: "The ID of the load balancer attached to this IP, if any",`
`49`	`49`	`},`
`50`	`50`	`},`
`51`	`51`	`}`