Add fields to support for configuring Class ALB migration feature. (GoogleCloudPlatform#13926)

Co-authored-by: Riley Karson <[email protected]>

Author: 2 people

mmv1/products/compute/BackendService.yaml

@@ -860,7 +860,6 @@ properties:
       external load balancing. A backend service created for one type of
       load balancing cannot be used with the other. For more information, refer to
       [Choosing a load balancer](https://cloud.google.com/load-balancing/docs/backend-service).
-    immutable: true
     default_value: "EXTERNAL"
     # If you're modifying this value, it probably means Global ILB is now
     # an option. If that's the case, all of the documentation is based on
@@ -870,6 +869,38 @@ properties:
       - 'INTERNAL_SELF_MANAGED'
       - 'INTERNAL_MANAGED'
       - 'EXTERNAL_MANAGED'
+  - name: 'externalManagedMigrationState'
+    type: Enum
+    description: |
+      Specifies the canary migration state. Possible values are PREPARE, TEST_BY_PERCENTAGE, and
+      TEST_ALL_TRAFFIC.
+
+      To begin the migration from EXTERNAL to EXTERNAL_MANAGED, the state must be changed to
+      PREPARE. The state must be changed to TEST_ALL_TRAFFIC before the loadBalancingScheme can be
+      changed to EXTERNAL_MANAGED. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate
+      traffic by percentage using externalManagedMigrationTestingPercentage.
+
+      Rolling back a migration requires the states to be set in reverse order. So changing the
+      scheme from EXTERNAL_MANAGED to EXTERNAL requires the state to be set to TEST_ALL_TRAFFIC at
+      the same time. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate some traffic
+      back to EXTERNAL or PREPARE can be used to migrate all traffic back to EXTERNAL.
+    enum_values:
+      - 'PREPARE'
+      - 'TEST_BY_PERCENTAGE'
+      - 'TEST_ALL_TRAFFIC'
+  - name: 'externalManagedMigrationTestingPercentage'
+    type: Double
+    description: |
+      Determines the fraction of requests that should be processed by the Global external
+      Application Load Balancer.
+
+      The value of this field must be in the range [0, 100].
+
+      Session affinity options will slightly affect this routing behavior, for more details,
+      see: Session Affinity.
+
+      This value can only be set if the loadBalancingScheme in the backend service is set to
+      EXTERNAL (when using the Classic ALB) and the migration state is TEST_BY_PERCENTAGE.
   - name: 'localityLbPolicy'
     type: Enum
     description: |

mmv1/products/compute/GlobalForwardingRule.yaml

@@ -318,6 +318,8 @@ properties:
       - 'EXTERNAL_MANAGED'
       - 'INTERNAL_MANAGED'
       - 'INTERNAL_SELF_MANAGED'
+    update_url: 'projects/{{project}}/global/forwardingRules/{{name}}'
+    update_verb: 'PATCH'
   - name: 'metadataFilters'
     type: Array
     description: |
@@ -500,6 +502,40 @@ properties:
     enum_values:
       - 'PREMIUM'
       - 'STANDARD'
+  - name: 'externalManagedBackendBucketMigrationState'
+    type: Enum
+    description: |
+      Specifies the canary migration state for the backend buckets attached to this forwarding rule.
+      Possible values are PREPARE, TEST_BY_PERCENTAGE, and TEST_ALL_TRAFFIC.
+
+      To begin the migration from EXTERNAL to EXTERNAL_MANAGED, the state must be changed to
+      PREPARE. The state must be changed to TEST_ALL_TRAFFIC before the loadBalancingScheme can be
+      changed to EXTERNAL_MANAGED. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate
+      traffic to backend buckets attached to this forwarding rule by percentage using
+      externalManagedBackendBucketMigrationTestingPercentage.
+
+      Rolling back a migration requires the states to be set in reverse order. So changing the
+      scheme from EXTERNAL_MANAGED to EXTERNAL requires the state to be set to TEST_ALL_TRAFFIC at
+      the same time. Optionally, the TEST_BY_PERCENTAGE state can be used to migrate some traffic
+      back to EXTERNAL or PREPARE can be used to migrate all traffic back to EXTERNAL.
+    enum_values:
+      - 'PREPARE'
+      - 'TEST_BY_PERCENTAGE'
+      - 'TEST_ALL_TRAFFIC'
+    update_url: 'projects/{{project}}/global/forwardingRules/{{name}}'
+    update_verb: 'PATCH'
+  - name: 'externalManagedBackendBucketMigrationTestingPercentage'
+    type: Double
+    description: |
+      Determines the fraction of requests to backend buckets that should be processed by the Global
+      external Application Load Balancer.
+
+      The value of this field must be in the range [0, 100].
+
+      This value can only be set if the loadBalancingScheme in the forwarding rule is set to
+      EXTERNAL (when using the Classic ALB) and the migration state is TEST_BY_PERCENTAGE.
+    update_url: 'projects/{{project}}/global/forwardingRules/{{name}}'
+    update_verb: 'PATCH'
   - name: 'serviceDirectoryRegistrations'
     type: Array
     description: |

mmv1/third_party/terraform/services/compute/resource_compute_backend_service_test.go.tmpl

@@ -3,9 +3,10 @@ package compute_test
 import (
 	"fmt"
 	"testing"
-	"github.com/hashicorp/terraform-provider-google/google/acctest"
 
 	"github.com/hashicorp/terraform-plugin-testing/helper/resource"
+	"github.com/hashicorp/terraform-plugin-testing/plancheck"
+	"github.com/hashicorp/terraform-provider-google/google/acctest"
 )
 
 func TestAccComputeBackendService_basic(t *testing.T) {
@@ -146,57 +147,85 @@ func TestAccComputeBackendService_withBackendAndIAP(t *testing.T) {
 	})
 }
 
-func TestAccComputeBackendService_withBackendAndPreference(t *testing.T) {
+func TestAccComputeBackendService_withBackendAndPreferenceInternalManaged(t *testing.T) {
 	t.Parallel()
 
-	randomSuffix := acctest.RandString(t, 10)
+	im_suffix := fmt.Sprintf("im-%s", acctest.RandString(t, 10))
+
 	acctest.VcrTest(t, resource.TestCase{
 		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
 		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
 		CheckDestroy:             testAccCheckComputeBackendServiceDestroyProducer(t),
 		Steps: []resource.TestStep{
 			{
-				Config: testAccComputeBackendService_withBackendAndPreference(randomSuffix, "INTERNAL_MANAGED", "DEFAULT", 10),
+				Config: testAccComputeBackendService_withBackendAndPreference(im_suffix, "INTERNAL_MANAGED", "DEFAULT", 10),
 			},
 			{
 				ResourceName:      "google_compute_backend_service.lipsum",
 				ImportState:       true,
 				ImportStateVerify: true,
 			},
 			{
-				Config: testAccComputeBackendService_withBackendAndPreference(randomSuffix, "INTERNAL_MANAGED", "PREFERRED", 20),
+				Config: testAccComputeBackendService_withBackendAndPreference(im_suffix, "INTERNAL_MANAGED", "PREFERRED", 20),
 			},
 			{
 				ResourceName:      "google_compute_backend_service.lipsum",
 				ImportState:       true,
 				ImportStateVerify: true,
 			},
+		},
+	})
+}
+
+func TestAccComputeBackendService_withBackendAndPreferenceInternalSelfManaged(t *testing.T) {
+	t.Parallel()
+
+	ism_suffix := fmt.Sprintf("ism-%s", acctest.RandString(t, 10))
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckComputeBackendServiceDestroyProducer(t),
+		Steps: []resource.TestStep{
 			{
-				Config: testAccComputeBackendService_withBackendAndPreference(randomSuffix, "INTERNAL_SELF_MANAGED", "DEFAULT", 10),
+				Config: testAccComputeBackendService_withBackendAndPreference(ism_suffix, "INTERNAL_SELF_MANAGED", "DEFAULT", 10),
 			},
 			{
 				ResourceName:      "google_compute_backend_service.lipsum",
 				ImportState:       true,
 				ImportStateVerify: true,
 			},
 			{
-				Config: testAccComputeBackendService_withBackendAndPreference(randomSuffix, "INTERNAL_SELF_MANAGED", "PREFERRED", 20),
+				Config: testAccComputeBackendService_withBackendAndPreference(ism_suffix, "INTERNAL_SELF_MANAGED", "PREFERRED", 20),
 			},
 			{
 				ResourceName:      "google_compute_backend_service.lipsum",
 				ImportState:       true,
 				ImportStateVerify: true,
 			},
-			{
-				Config: testAccComputeBackendService_withBackendAndPreference(randomSuffix, "EXTERNAL_MANAGED", "DEFAULT", 10),
+		},
+	})
+}
+
+func TestAccComputeBackendService_withBackendAndPreferenceExternalManaged(t *testing.T) {
+	t.Parallel()
+	em_suffix := fmt.Sprintf("em-%s", acctest.RandString(t, 10))
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckComputeBackendServiceDestroyProducer(t),
+		Steps: []resource.TestStep{
+		{
+				Config: testAccComputeBackendService_withBackendAndPreference(em_suffix, "EXTERNAL_MANAGED", "DEFAULT", 10),
 			},
 			{
 				ResourceName:      "google_compute_backend_service.lipsum",
 				ImportState:       true,
 				ImportStateVerify: true,
 			},
 			{
-				Config: testAccComputeBackendService_withBackendAndPreference(randomSuffix, "EXTERNAL_MANAGED", "PREFERRED", 20),
+				Config: testAccComputeBackendService_withBackendAndPreference(em_suffix, "EXTERNAL_MANAGED", "PREFERRED", 20),
 			},
 			{
 				ResourceName:      "google_compute_backend_service.lipsum",
@@ -789,16 +818,31 @@ func TestAccComputeBackendService_withLogConfig(t *testing.T) {
 				ImportState:       true,
 				ImportStateVerify: true,
 			},
+		},
+	})
+}
+
+func TestAccComputeBackendService_withLogConfigMode(t *testing.T) {
+	t.Parallel()
+
+	serviceName := fmt.Sprintf("tf-test-lc-%s", acctest.RandString(t, 10))
+	checkName := fmt.Sprintf("tf-test-lc-%s", acctest.RandString(t, 10))
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		CheckDestroy:             testAccCheckComputeBackendServiceDestroyProducer(t),
+		Steps: []resource.TestStep{
 			{
-				Config: testAccComputeBackendService_withLogConfig3(serviceName, checkName, "INCLUDE_ALL_OPTIONAL", true),
+				Config: testAccComputeBackendService_withLogConfigMode(serviceName, checkName, "INCLUDE_ALL_OPTIONAL", true),
 			},
 			{
 				ResourceName:      "google_compute_backend_service.foobar",
 				ImportState:       true,
 				ImportStateVerify: true,
 			},
 			{
-				Config: testAccComputeBackendService_withLogConfig3(serviceName, checkName, "EXCLUDE_ALL_OPTIONAL", true),
+				Config: testAccComputeBackendService_withLogConfigMode(serviceName, checkName, "EXCLUDE_ALL_OPTIONAL", true),
 			},
 			{
 				ResourceName:      "google_compute_backend_service.foobar",
@@ -2232,7 +2276,7 @@ resource "google_compute_http_health_check" "zero" {
 `, serviceName, enabled, checkName)
 }
 
-func testAccComputeBackendService_withLogConfig3(serviceName, checkName, mode string, enabled bool) string {
+func testAccComputeBackendService_withLogConfigMode(serviceName, checkName, mode string, enabled bool) string {
 	return fmt.Sprintf(`
 resource "google_compute_backend_service" "foobar" {
   name          		= "%s"
@@ -2686,3 +2730,140 @@ resource "google_compute_health_check" "health_check" {
 }
 `, suffix, timeout, loadBalancingScheme, preference, suffix, suffix, suffix)
 }
+
+func TestAccComputeBackendService_updateCanaryMigration(t *testing.T) {
+	t.Parallel()
+
+	serviceName := fmt.Sprintf("tf-test-%s", acctest.RandString(t, 10))
+	checkName := fmt.Sprintf("tf-test-%s", acctest.RandString(t, 10))
+
+	acctest.VcrTest(t, resource.TestCase{
+		PreCheck:                 func() { acctest.AccTestPreCheck(t) },
+		ProtoV5ProviderFactories: acctest.ProtoV5ProviderFactories(t),
+		ExternalProviders: map[string]resource.ExternalProvider{
+			"time": {},
+		},
+		CheckDestroy:             testAccCheckComputeBackendServiceDestroyProducer(t),
+		Steps: []resource.TestStep{
+			{
+				Config: testAccComputeBackendService_basic(serviceName, checkName),
+			},
+			{
+				ResourceName:      "google_compute_backend_service.foobar",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+			{
+				Config: testAccComputeBackendService_withCanaryMigration(
+					serviceName, checkName, "updated-to-prepare", "PREPARE"),
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction("google_compute_backend_service.foobar", plancheck.ResourceActionUpdate),
+					},
+				},
+			},
+			{
+				ResourceName:      "google_compute_backend_service.foobar",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+			{
+				Config: testAccComputeBackendService_withCanaryMigrationPercentage(
+					serviceName, checkName, "updated-to-percentage", 50),
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction("google_compute_backend_service.foobar", plancheck.ResourceActionUpdate),
+					},
+				},
+			},
+			{
+				ResourceName:      "google_compute_backend_service.foobar",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+			{
+				Config: testAccComputeBackendService_withCanaryMigration(
+					serviceName, checkName, "update-to-all", "TEST_ALL_TRAFFIC"),
+				ConfigPlanChecks: resource.ConfigPlanChecks{
+					PreApply: []plancheck.PlanCheck{
+						plancheck.ExpectResourceAction("google_compute_backend_service.foobar", plancheck.ResourceActionUpdate),
+					},
+				},
+			},
+			{
+				ResourceName:      "google_compute_backend_service.foobar",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
+func testAccComputeBackendService_withCanaryMigration(serviceName, checkName, description, migrationState string) string {
+	return fmt.Sprintf(`
+resource "google_compute_backend_service" "foobar" {
+  name             = "%s"
+  description      = "%s"
+  health_checks    = [google_compute_http_health_check.zero.self_link]
+  external_managed_migration_state = "%s"
+}
+
+resource "google_compute_http_health_check" "zero" {
+  name               = "%s"
+  request_path       = "/"
+  check_interval_sec = 1
+  timeout_sec        = 1
+}
+`, serviceName, description, migrationState, checkName)
+}
+
+func testAccComputeBackendService_withCanaryMigrationWithWait(serviceName, checkName, description, migrationState string) string {
+	return fmt.Sprintf(`
+resource "time_sleep" "six_minutes_delay" {
+  create_duration = "370s" # litte more than 6 minutes (360 seconds = 6 minutes)
+}
+
+resource "google_compute_backend_service" "foobar" {
+  name             = "%s"
+  description      = "%s"
+  health_checks    = [google_compute_http_health_check.zero.self_link]
+  external_managed_migration_state = "%s"
+	depends_on = [
+		time_sleep.six_minutes_delay
+	]
+}
+
+resource "google_compute_http_health_check" "zero" {
+  name               = "%s"
+  request_path       = "/"
+  check_interval_sec = 1
+  timeout_sec        = 1
+}
+`, serviceName, description, migrationState, checkName)
+}
+
+func testAccComputeBackendService_withCanaryMigrationPercentage(serviceName, checkName, description string, percentage int64) string {
+	return fmt.Sprintf(`
+resource "time_sleep" "six_minutes_delay" {
+  create_duration = "370s" # litte more than 6 minutes (360 seconds = 6 minutes)
+}
+
+resource "google_compute_backend_service" "foobar" {
+  name             = "%s"
+  description      = "%s"
+  health_checks    = [google_compute_http_health_check.zero.self_link]
+  external_managed_migration_state = "TEST_BY_PERCENTAGE"
+	external_managed_migration_testing_percentage = %d
+	depends_on = [
+		time_sleep.six_minutes_delay
+	]
+}
+
+resource "google_compute_http_health_check" "zero" {
+  name               = "%s"
+  request_path       = "/"
+  check_interval_sec = 1
+  timeout_sec        = 1
+}
+`, serviceName, description, percentage, checkName)
+}