GCS Backend Buckets Support For Cross-region Internal Application Load Balancer (#14178) (#23499)

[upstream:f3baeb30b46158c3c8387ee626dcad36d4ef6f94]

Signed-off-by: Modular Magician <[email protected]>

Author: modular-magician

.changelog/14178.txt

@@ -0,0 +1,3 @@
+```release-note:enhancement
+compute: added `load_balancing_scheme` field to `google_compute_backend_bucket` resource
+```

google/services/compute/resource_compute_backend_bucket.go

@@ -244,6 +244,13 @@ client when the resource is created.`,
 				Optional:    true,
 				Description: `If true, enable Cloud CDN for this BackendBucket.`,
 			},
+			"load_balancing_scheme": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ValidateFunc: verify.ValidateEnum([]string{"INTERNAL_MANAGED", ""}),
+				Description: `The value can only be INTERNAL_MANAGED for cross-region internal layer 7 load balancer.
+If loadBalancingScheme is not specified, the backend bucket can be used by classic global external load balancers, or global application external load balancers, or both. Possible values: ["INTERNAL_MANAGED"]`,
+			},
 			"creation_timestamp": {
 				Type:        schema.TypeString,
 				Computed:    true,
@@ -320,6 +327,12 @@ func resourceComputeBackendBucketCreate(d *schema.ResourceData, meta interface{}
 	} else if v, ok := d.GetOkExists("name"); !tpgresource.IsEmptyValue(reflect.ValueOf(nameProp)) && (ok || !reflect.DeepEqual(v, nameProp)) {
 		obj["name"] = nameProp
 	}
+	loadBalancingSchemeProp, err := expandComputeBackendBucketLoadBalancingScheme(d.Get("load_balancing_scheme"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("load_balancing_scheme"); ok || !reflect.DeepEqual(v, loadBalancingSchemeProp) {
+		obj["loadBalancingScheme"] = loadBalancingSchemeProp
+	}
 
 	obj, err = resourceComputeBackendBucketEncoder(d, meta, obj)
 	if err != nil {
@@ -471,6 +484,9 @@ func resourceComputeBackendBucketRead(d *schema.ResourceData, meta interface{})
 	if err := d.Set("name", flattenComputeBackendBucketName(res["name"], d, config)); err != nil {
 		return fmt.Errorf("Error reading BackendBucket: %s", err)
 	}
+	if err := d.Set("load_balancing_scheme", flattenComputeBackendBucketLoadBalancingScheme(res["loadBalancingScheme"], d, config)); err != nil {
+		return fmt.Errorf("Error reading BackendBucket: %s", err)
+	}
 	if err := d.Set("self_link", tpgresource.ConvertSelfLinkToV1(res["selfLink"].(string))); err != nil {
 		return fmt.Errorf("Error reading BackendBucket: %s", err)
 	}
@@ -542,6 +558,12 @@ func resourceComputeBackendBucketUpdate(d *schema.ResourceData, meta interface{}
 	} else if v, ok := d.GetOkExists("name"); !tpgresource.IsEmptyValue(reflect.ValueOf(v)) && (ok || !reflect.DeepEqual(v, nameProp)) {
 		obj["name"] = nameProp
 	}
+	loadBalancingSchemeProp, err := expandComputeBackendBucketLoadBalancingScheme(d.Get("load_balancing_scheme"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("load_balancing_scheme"); ok || !reflect.DeepEqual(v, loadBalancingSchemeProp) {
+		obj["loadBalancingScheme"] = loadBalancingSchemeProp
+	}
 
 	obj, err = resourceComputeBackendBucketEncoder(d, meta, obj)
 	if err != nil {
@@ -944,6 +966,10 @@ func flattenComputeBackendBucketName(v interface{}, d *schema.ResourceData, conf
 	return v
 }
 
+func flattenComputeBackendBucketLoadBalancingScheme(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} {
+	return v
+}
+
 func expandComputeBackendBucketBucketName(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
 	return v, nil
 }
@@ -1190,6 +1216,10 @@ func expandComputeBackendBucketName(v interface{}, d tpgresource.TerraformResour
 	return v, nil
 }
 
+func expandComputeBackendBucketLoadBalancingScheme(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) {
+	return v, nil
+}
+
 func resourceComputeBackendBucketEncoder(d *schema.ResourceData, meta interface{}, obj map[string]interface{}) (map[string]interface{}, error) {
 	// This custom encoder helps prevent sending 0 for clientTtl, defaultTtl and
 	// maxTtl in API calls to update these values  when unset in the provider

google/services/compute/resource_compute_backend_bucket_generated_meta.yaml

@@ -25,4 +25,5 @@ fields:
   - field: 'description'
   - field: 'edge_security_policy'
   - field: 'enable_cdn'
+  - field: 'load_balancing_scheme'
   - field: 'name'

google/services/compute/resource_compute_backend_bucket_generated_test.go

@@ -26,6 +26,7 @@ import (
 	"github.com/hashicorp/terraform-plugin-testing/terraform"
 
 	"github.com/hashicorp/terraform-provider-google/google/acctest"
+	"github.com/hashicorp/terraform-provider-google/google/envvar"
 	"github.com/hashicorp/terraform-provider-google/google/tpgresource"
 	transport_tpg "github.com/hashicorp/terraform-provider-google/google/transport"
 )
@@ -476,6 +477,69 @@ resource "google_storage_bucket" "image_bucket" {
 `, context)
 }
 
+func TestAccComputeBackendBucket_backendBucketGlobalIlbExample(t *testing.T) {
+	t.Parallel()
+
+	context := map[string]interface{}{
+		"billing_account": envvar.GetTestBillingAccountFromEnv(t),
+		"org_id":          envvar.GetTestOrgFromEnv(t),
+		"random_suffix":   acctest.RandString(t, 10),
+	}
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckComputeBackendBucketDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccComputeBackendBucket_backendBucketGlobalIlbExample(context),
+			},
+			{
+				ResourceName:      "google_compute_backend_bucket.global-ilb-backend",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
+func testAccComputeBackendBucket_backendBucketGlobalIlbExample(context map[string]interface{}) string {
+	return acctest.Nprintf(`
+resource "google_project" "unarmored" {
+  project_id      = "tf-test%{random_suffix}"
+  name            = "tf-test%{random_suffix}"
+  org_id          = "%{org_id}"
+  billing_account = "%{billing_account}"
+  deletion_policy = "DELETE"
+}
+
+resource "google_project_service" "project" {
+  project = google_project.unarmored.number
+  service = "compute.googleapis.com"
+  disable_on_destroy = true
+}
+
+resource "google_compute_backend_bucket" "global-ilb-backend" {
+  name                  = "tf-test-global-ilb-backend-bucket%{random_suffix}"
+  project               = google_project.unarmored.number
+  bucket_name           = google_storage_bucket.global-ilb-backend.name
+  load_balancing_scheme = "INTERNAL_MANAGED"
+
+  depends_on = [google_project_service.project]
+}
+
+resource "google_storage_bucket" "global-ilb-backend" {
+  name                        = "tf-test-global-ilb-bucket%{random_suffix}"
+  project                     = google_project.unarmored.number
+  location                    = "US-CENTRAL1"
+  force_destroy               = true
+  uniform_bucket_level_access = true
+
+  depends_on = [google_project_service.project]
+}
+`, context)
+}
+
 func testAccCheckComputeBackendBucketDestroyProducer(t *testing.T) func(s *terraform.State) error {
 	return func(s *terraform.State) error {
 		for name, rs := range s.RootModule().Resources {

website/docs/r/compute_backend_bucket.html.markdown

@@ -186,6 +186,12 @@ The following arguments are supported:
   (Optional)
   If true, enable Cloud CDN for this BackendBucket.
 
+* `load_balancing_scheme` -
+  (Optional)
+  The value can only be INTERNAL_MANAGED for cross-region internal layer 7 load balancer.
+  If loadBalancingScheme is not specified, the backend bucket can be used by classic global external load balancers, or global application external load balancers, or both.
+  Possible values are: `INTERNAL_MANAGED`.
+
 * `project` - (Optional) The ID of the project in which the resource belongs.
     If it is not provided, the provider project is used.