This feature enables support for the L4 ILB Flex Ports feature currently available in alpha.

google/resource_compute_forwarding_rule.go

@@ -140,6 +140,11 @@ func resourceComputeForwardingRule() *schema.Resource {
 				ForceNew:     true,
 				ValidateFunc: validateGCPName,
 			},
+			"all_ports": {
+				Type:     schema.TypeBool,
+				Optional: true,
+				ForceNew: true,
+			},
 			"region": {
 				Type:             schema.TypeString,
 				Computed:         true,
@@ -267,14 +272,20 @@ func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{
 	} else if v, ok := d.GetOkExists("service_label"); !isEmptyValue(reflect.ValueOf(serviceLabelProp)) && (ok || !reflect.DeepEqual(v, serviceLabelProp)) {
 		obj["serviceLabel"] = serviceLabelProp
 	}
+	allPortsProp, err := expandComputeForwardingRuleAllPorts(d.Get("all_ports"), d, config)
+	if err != nil {
+		return err
+	} else if v, ok := d.GetOkExists("all_ports"); !isEmptyValue(reflect.ValueOf(allPortsProp)) && (ok || !reflect.DeepEqual(v, allPortsProp)) {
+		obj["allPorts"] = allPortsProp
+	}
 	regionProp, err := expandComputeForwardingRuleRegion(d.Get("region"), d, config)
 	if err != nil {
 		return err
 	} else if v, ok := d.GetOkExists("region"); !isEmptyValue(reflect.ValueOf(regionProp)) && (ok || !reflect.DeepEqual(v, regionProp)) {
 		obj["region"] = regionProp
 	}
 
-	url, err := replaceVars(d, config, "https://www.googleapis.com/compute/beta/projects/{{project}}/regions/{{region}}/forwardingRules")
+	url, err := replaceVars(d, config, "https://www.googleapis.com/compute/alpha/projects/{{project}}/regions/{{region}}/forwardingRules")
 	if err != nil {
 		return err
 	}
@@ -328,7 +339,7 @@ func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{
 		labelFingerprintProp := d.Get("label_fingerprint")
 		obj["labelFingerprint"] = labelFingerprintProp
 
-		url, err = replaceVars(d, config, "https://www.googleapis.com/compute/beta/projects/{{project}}/regions/{{region}}/forwardingRules/{{name}}/setLabels")
+		url, err = replaceVars(d, config, "https://www.googleapis.com/compute/alpha/projects/{{project}}/regions/{{region}}/forwardingRules/{{name}}/setLabels")
 		if err != nil {
 			return err
 		}
@@ -358,7 +369,7 @@ func resourceComputeForwardingRuleCreate(d *schema.ResourceData, meta interface{
 func resourceComputeForwardingRuleRead(d *schema.ResourceData, meta interface{}) error {
 	config := meta.(*Config)
 
-	url, err := replaceVars(d, config, "https://www.googleapis.com/compute/beta/projects/{{project}}/regions/{{region}}/forwardingRules/{{name}}")
+	url, err := replaceVars(d, config, "https://www.googleapis.com/compute/alpha/projects/{{project}}/regions/{{region}}/forwardingRules/{{name}}")
 	if err != nil {
 		return err
 	}
@@ -422,6 +433,9 @@ func resourceComputeForwardingRuleRead(d *schema.ResourceData, meta interface{})
 	if err := d.Set("service_name", flattenComputeForwardingRuleServiceName(res["serviceName"])); err != nil {
 		return fmt.Errorf("Error reading ForwardingRule: %s", err)
 	}
+	if err := d.Set("all_ports", flattenComputeForwardingRuleAllPorts(res["allPorts"])); err != nil {
+		return fmt.Errorf("Error reading ForwardingRule: %s", err)
+	}
 	if err := d.Set("region", flattenComputeForwardingRuleRegion(res["region"])); err != nil {
 		return fmt.Errorf("Error reading ForwardingRule: %s", err)
 	}
@@ -453,7 +467,7 @@ func resourceComputeForwardingRuleUpdate(d *schema.ResourceData, meta interface{
 			obj["target"] = targetProp
 		}
 
-		url, err := replaceVars(d, config, "https://www.googleapis.com/compute/beta/projects/{{project}}/regions/{{region}}/forwardingRules/{{name}}/setTarget")
+		url, err := replaceVars(d, config, "https://www.googleapis.com/compute/alpha/projects/{{project}}/regions/{{region}}/forwardingRules/{{name}}/setTarget")
 		if err != nil {
 			return err
 		}
@@ -493,7 +507,7 @@ func resourceComputeForwardingRuleUpdate(d *schema.ResourceData, meta interface{
 		labelFingerprintProp := d.Get("label_fingerprint")
 		obj["labelFingerprint"] = labelFingerprintProp
 
-		url, err := replaceVars(d, config, "https://www.googleapis.com/compute/beta/projects/{{project}}/regions/{{region}}/forwardingRules/{{name}}/setLabels")
+		url, err := replaceVars(d, config, "https://www.googleapis.com/compute/alpha/projects/{{project}}/regions/{{region}}/forwardingRules/{{name}}/setLabels")
 		if err != nil {
 			return err
 		}
@@ -532,7 +546,7 @@ func resourceComputeForwardingRuleUpdate(d *schema.ResourceData, meta interface{
 func resourceComputeForwardingRuleDelete(d *schema.ResourceData, meta interface{}) error {
 	config := meta.(*Config)
 
-	url, err := replaceVars(d, config, "https://www.googleapis.com/compute/beta/projects/{{project}}/regions/{{region}}/forwardingRules/{{name}}")
+	url, err := replaceVars(d, config, "https://www.googleapis.com/compute/alpha/projects/{{project}}/regions/{{region}}/forwardingRules/{{name}}")
 	if err != nil {
 		return err
 	}
@@ -667,6 +681,10 @@ func flattenComputeForwardingRuleServiceName(v interface{}) interface{} {
 	return v
 }
 
+func flattenComputeForwardingRuleAllPorts(v interface{}) interface{} {
+	return v
+}
+
 func flattenComputeForwardingRuleRegion(v interface{}) interface{} {
 	if v == nil {
 		return v
@@ -799,6 +817,10 @@ func expandComputeForwardingRuleServiceLabel(v interface{}, d *schema.ResourceDa
 	return v, nil
 }
 
+func expandComputeForwardingRuleAllPorts(v interface{}, d *schema.ResourceData, config *Config) (interface{}, error) {
+	return v, nil
+}
+
 func expandComputeForwardingRuleRegion(v interface{}, d *schema.ResourceData, config *Config) (interface{}, error) {
 	f, err := parseGlobalFieldValue("regions", v.(string), "project", d, config, true)
 	if err != nil {

google/resource_compute_forwarding_rule_test.go

@@ -142,6 +142,30 @@ func TestAccComputeForwardingRule_networkTier(t *testing.T) {
 	})
 }
 
+func TestAccComputeForwardingRule_allPorts(t *testing.T) {
+	t.Parallel()
+
+	serviceName := fmt.Sprintf("tf-%s", acctest.RandString(10))
+	checkName := fmt.Sprintf("tf-%s", acctest.RandString(10))
+	networkName := fmt.Sprintf("tf-%s", acctest.RandString(10))
+	ruleName := fmt.Sprintf("tf-%s", acctest.RandString(10))
+	resource.Test(t, resource.TestCase{
+		PreCheck:     func() { testAccPreCheck(t) },
+		Providers:    testAccProviders,
+		CheckDestroy: testAccCheckComputeForwardingRuleDestroy,
+		Steps: []resource.TestStep{
+			resource.TestStep{
+				Config: testAccComputeForwardingRule_allPorts(serviceName, checkName, networkName, ruleName),
+			},
+			resource.TestStep{
+				ResourceName:      "google_compute_forwarding_rule.foobar",
+				ImportState:       true,
+				ImportStateVerify: true,
+			},
+		},
+	})
+}
+
 func testAccCheckComputeForwardingRuleDestroy(s *terraform.State) error {
 	config := testAccProvider.Meta().(*Config)
 
@@ -299,3 +323,38 @@ resource "google_compute_forwarding_rule" "foobar" {
 }
 `, poolName, ruleName)
 }
+
+func testAccComputeForwardingRule_allPorts(serviceName, checkName, networkName, ruleName string) string {
+	return fmt.Sprintf(`
+resource "google_compute_region_backend_service" "foobar-bs" {
+  name                  = "%s"
+  description           = "Resource created for Terraform acceptance testing"
+  health_checks         = ["${google_compute_health_check.zero.self_link}"]
+  region                = "us-central1"
+}
+resource "google_compute_health_check" "zero" {
+  name               = "%s"
+  description        = "Resource created for Terraform acceptance testing"
+  check_interval_sec = 1
+  timeout_sec        = 1
+
+  tcp_health_check {
+    port = "80"
+  }
+}
+resource "google_compute_network" "foobar" {
+  name = "%s"
+  auto_create_subnetworks = true
+}
+
+resource "google_compute_forwarding_rule" "foobar" {
+  description           = "Resource created for Terraform acceptance testing"
+  name                  = "%s"
+  load_balancing_scheme = "INTERNAL"
+  backend_service       = "${google_compute_region_backend_service.foobar-bs.self_link}"
+  all_ports              = true
+  network               = "${google_compute_network.foobar.name}"
+  subnetwork            = "%s"
+}
+`, serviceName, checkName, networkName, ruleName, networkName)
+}

website/docs/r/compute_forwarding_rule.html.markdown

@@ -198,6 +198,13 @@ The following arguments are supported:
   character, which cannot be a dash.
   This field is only used for internal load balancing.
 
+* `all_ports` -
+  (Optional)
+  When the load balancing scheme is INTERNAL, this can be used to indicate
+  that all ports should be supported on the ForwardingRule. 
+  This cannot be used with the ports[] or portRange fields.
+  This cannot be used when the load balancing scheme is EXTERNAL.
+
 * `region` -
   (Optional)
   A reference to the region where the regional forwarding rule resides.