pulumi-gcp 7.24.0a1716510380__py3-none-any.whl → 7.25.0__py3-none-any.whl

pulumi_gcp/compute/forwarding_rule.py

@@ -1699,313 +1699,6 @@ class ForwardingRule(pulumi.CustomResource):
 
         ## Example Usage
 
-        ### Internal Http Lb With Mig Backend
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        # Internal HTTP load balancer with a managed instance group backend
-        # VPC network
-        ilb_network = gcp.compute.Network("ilb_network",
-            name="l7-ilb-network",
-            auto_create_subnetworks=False)
-        # proxy-only subnet
-        proxy_subnet = gcp.compute.Subnetwork("proxy_subnet",
-            name="l7-ilb-proxy-subnet",
-            ip_cidr_range="10.0.0.0/24",
-            region="europe-west1",
-            purpose="REGIONAL_MANAGED_PROXY",
-            role="ACTIVE",
-            network=ilb_network.id)
-        # backend subnet
-        ilb_subnet = gcp.compute.Subnetwork("ilb_subnet",
-            name="l7-ilb-subnet",
-            ip_cidr_range="10.0.1.0/24",
-            region="europe-west1",
-            network=ilb_network.id)
-        # health check
-        default_region_health_check = gcp.compute.RegionHealthCheck("default",
-            name="l7-ilb-hc",
-            region="europe-west1",
-            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
-                port_specification="USE_SERVING_PORT",
-            ))
-        # instance template
-        instance_template = gcp.compute.InstanceTemplate("instance_template",
-            network_interfaces=[gcp.compute.InstanceTemplateNetworkInterfaceArgs(
-                access_configs=[gcp.compute.InstanceTemplateNetworkInterfaceAccessConfigArgs()],
-                network=ilb_network.id,
-                subnetwork=ilb_subnet.id,
-            )],
-            name="l7-ilb-mig-template",
-            machine_type="e2-small",
-            tags=["http-server"],
-            disks=[gcp.compute.InstanceTemplateDiskArgs(
-                source_image="debian-cloud/debian-10",
-                auto_delete=True,
-                boot=True,
-            )],
-            metadata={
-                "startup-script": \"\"\"#! /bin/bash
-        set -euo pipefail
-
-        export DEBIAN_FRONTEND=noninteractive
-        apt-get update
-        apt-get install -y nginx-light jq
-
-        NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
-        IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
-        METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')
-
-        cat <<EOF > /var/www/html/index.html
-        <pre>
-        Name: $NAME
-        IP: $IP
-        Metadata: $METADATA
-        </pre>
-        EOF
-        \"\"\",
-            })
-        # MIG
-        mig = gcp.compute.RegionInstanceGroupManager("mig",
-            name="l7-ilb-mig1",
-            region="europe-west1",
-            versions=[gcp.compute.RegionInstanceGroupManagerVersionArgs(
-                instance_template=instance_template.id,
-                name="primary",
-            )],
-            base_instance_name="vm",
-            target_size=2)
-        # backend service
-        default_region_backend_service = gcp.compute.RegionBackendService("default",
-            name="l7-ilb-backend-subnet",
-            region="europe-west1",
-            protocol="HTTP",
-            load_balancing_scheme="INTERNAL_MANAGED",
-            timeout_sec=10,
-            health_checks=default_region_health_check.id,
-            backends=[gcp.compute.RegionBackendServiceBackendArgs(
-                group=mig.instance_group,
-                balancing_mode="UTILIZATION",
-                capacity_scaler=1,
-            )])
-        # URL map
-        default_region_url_map = gcp.compute.RegionUrlMap("default",
-            name="l7-ilb-regional-url-map",
-            region="europe-west1",
-            default_service=default_region_backend_service.id)
-        # HTTP target proxy
-        default = gcp.compute.RegionTargetHttpProxy("default",
-            name="l7-ilb-target-http-proxy",
-            region="europe-west1",
-            url_map=default_region_url_map.id)
-        # forwarding rule
-        google_compute_forwarding_rule = gcp.compute.ForwardingRule("google_compute_forwarding_rule",
-            name="l7-ilb-forwarding-rule",
-            region="europe-west1",
-            ip_protocol="TCP",
-            load_balancing_scheme="INTERNAL_MANAGED",
-            port_range="80",
-            target=default.id,
-            network=ilb_network.id,
-            subnetwork=ilb_subnet.id,
-            network_tier="PREMIUM")
-        # allow all access from IAP and health check ranges
-        fw_iap = gcp.compute.Firewall("fw-iap",
-            name="l7-ilb-fw-allow-iap-hc",
-            direction="INGRESS",
-            network=ilb_network.id,
-            source_ranges=[
-                "130.211.0.0/22",
-                "35.191.0.0/16",
-                "35.235.240.0/20",
-            ],
-            allows=[gcp.compute.FirewallAllowArgs(
-                protocol="tcp",
-            )])
-        # allow http from proxy subnet to backends
-        fw_ilb_to_backends = gcp.compute.Firewall("fw-ilb-to-backends",
-            name="l7-ilb-fw-allow-ilb-to-backends",
-            direction="INGRESS",
-            network=ilb_network.id,
-            source_ranges=["10.0.0.0/24"],
-            target_tags=["http-server"],
-            allows=[gcp.compute.FirewallAllowArgs(
-                protocol="tcp",
-                ports=[
-                    "80",
-                    "443",
-                    "8080",
-                ],
-            )])
-        # test instance
-        vm_test = gcp.compute.Instance("vm-test",
-            name="l7-ilb-test-vm",
-            zone="europe-west1-b",
-            machine_type="e2-small",
-            network_interfaces=[gcp.compute.InstanceNetworkInterfaceArgs(
-                network=ilb_network.id,
-                subnetwork=ilb_subnet.id,
-            )],
-            boot_disk=gcp.compute.InstanceBootDiskArgs(
-                initialize_params=gcp.compute.InstanceBootDiskInitializeParamsArgs(
-                    image="debian-cloud/debian-10",
-                ),
-            ))
-        ```
-        ### Internal Tcp Udp Lb With Mig Backend
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        # Internal TCP/UDP load balancer with a managed instance group backend
-        # VPC
-        ilb_network = gcp.compute.Network("ilb_network",
-            name="l4-ilb-network",
-            auto_create_subnetworks=False)
-        # backed subnet
-        ilb_subnet = gcp.compute.Subnetwork("ilb_subnet",
-            name="l4-ilb-subnet",
-            ip_cidr_range="10.0.1.0/24",
-            region="europe-west1",
-            network=ilb_network.id)
-        # health check
-        default_region_health_check = gcp.compute.RegionHealthCheck("default",
-            name="l4-ilb-hc",
-            region="europe-west1",
-            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
-                port=80,
-            ))
-        # instance template
-        instance_template = gcp.compute.InstanceTemplate("instance_template",
-            network_interfaces=[gcp.compute.InstanceTemplateNetworkInterfaceArgs(
-                access_configs=[gcp.compute.InstanceTemplateNetworkInterfaceAccessConfigArgs()],
-                network=ilb_network.id,
-                subnetwork=ilb_subnet.id,
-            )],
-            name="l4-ilb-mig-template",
-            machine_type="e2-small",
-            tags=[
-                "allow-ssh",
-                "allow-health-check",
-            ],
-            disks=[gcp.compute.InstanceTemplateDiskArgs(
-                source_image="debian-cloud/debian-10",
-                auto_delete=True,
-                boot=True,
-            )],
-            metadata={
-                "startup-script": \"\"\"#! /bin/bash
-        set -euo pipefail
-
-        export DEBIAN_FRONTEND=noninteractive
-        apt-get update
-        apt-get install -y nginx-light jq
-
-        NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
-        IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
-        METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')
-
-        cat <<EOF > /var/www/html/index.html
-        <pre>
-        Name: $NAME
-        IP: $IP
-        Metadata: $METADATA
-        </pre>
-        EOF
-        \"\"\",
-            })
-        # MIG
-        mig = gcp.compute.RegionInstanceGroupManager("mig",
-            name="l4-ilb-mig1",
-            region="europe-west1",
-            versions=[gcp.compute.RegionInstanceGroupManagerVersionArgs(
-                instance_template=instance_template.id,
-                name="primary",
-            )],
-            base_instance_name="vm",
-            target_size=2)
-        # backend service
-        default = gcp.compute.RegionBackendService("default",
-            name="l4-ilb-backend-subnet",
-            region="europe-west1",
-            protocol="TCP",
-            load_balancing_scheme="INTERNAL",
-            health_checks=default_region_health_check.id,
-            backends=[gcp.compute.RegionBackendServiceBackendArgs(
-                group=mig.instance_group,
-                balancing_mode="CONNECTION",
-            )])
-        # forwarding rule
-        google_compute_forwarding_rule = gcp.compute.ForwardingRule("google_compute_forwarding_rule",
-            name="l4-ilb-forwarding-rule",
-            backend_service=default.id,
-            region="europe-west1",
-            ip_protocol="TCP",
-            load_balancing_scheme="INTERNAL",
-            all_ports=True,
-            allow_global_access=True,
-            network=ilb_network.id,
-            subnetwork=ilb_subnet.id)
-        # allow all access from health check ranges
-        fw_hc = gcp.compute.Firewall("fw_hc",
-            name="l4-ilb-fw-allow-hc",
-            direction="INGRESS",
-            network=ilb_network.id,
-            source_ranges=[
-                "130.211.0.0/22",
-                "35.191.0.0/16",
-                "35.235.240.0/20",
-            ],
-            allows=[gcp.compute.FirewallAllowArgs(
-                protocol="tcp",
-            )],
-            target_tags=["allow-health-check"])
-        # allow communication within the subnet 
-        fw_ilb_to_backends = gcp.compute.Firewall("fw_ilb_to_backends",
-            name="l4-ilb-fw-allow-ilb-to-backends",
-            direction="INGRESS",
-            network=ilb_network.id,
-            source_ranges=["10.0.1.0/24"],
-            allows=[
-                gcp.compute.FirewallAllowArgs(
-                    protocol="tcp",
-                ),
-                gcp.compute.FirewallAllowArgs(
-                    protocol="udp",
-                ),
-                gcp.compute.FirewallAllowArgs(
-                    protocol="icmp",
-                ),
-            ])
-        # allow SSH
-        fw_ilb_ssh = gcp.compute.Firewall("fw_ilb_ssh",
-            name="l4-ilb-fw-ssh",
-            direction="INGRESS",
-            network=ilb_network.id,
-            allows=[gcp.compute.FirewallAllowArgs(
-                protocol="tcp",
-                ports=["22"],
-            )],
-            target_tags=["allow-ssh"],
-            source_ranges=["0.0.0.0/0"])
-        # test instance
-        vm_test = gcp.compute.Instance("vm_test",
-            name="l4-ilb-test-vm",
-            zone="europe-west1-b",
-            machine_type="e2-small",
-            network_interfaces=[gcp.compute.InstanceNetworkInterfaceArgs(
-                network=ilb_network.id,
-                subnetwork=ilb_subnet.id,
-            )],
-            boot_disk=gcp.compute.InstanceBootDiskArgs(
-                initialize_params=gcp.compute.InstanceBootDiskInitializeParamsArgs(
-                    image="debian-cloud/debian-10",
-                ),
-            ))
-        ```
         ### Forwarding Rule Externallb
 
         ```python
@@ -2182,43 +1875,6 @@ class ForwardingRule(pulumi.CustomResource):
             )],
             base_instance_name="internal-glb",
             target_size=1)
-        default_region_health_check = gcp.compute.RegionHealthCheck("default",
-            region="us-central1",
-            name="website-hc",
-            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
-                port_specification="USE_SERVING_PORT",
-            ))
-        default_region_backend_service = gcp.compute.RegionBackendService("default",
-            load_balancing_scheme="INTERNAL_MANAGED",
-            backends=[gcp.compute.RegionBackendServiceBackendArgs(
-                group=rigm.instance_group,
-                balancing_mode="UTILIZATION",
-                capacity_scaler=1,
-            )],
-            region="us-central1",
-            name="website-backend",
-            protocol="HTTP",
-            timeout_sec=10,
-            health_checks=default_region_health_check.id)
-        default_region_url_map = gcp.compute.RegionUrlMap("default",
-            region="us-central1",
-            name="website-map",
-            default_service=default_region_backend_service.id)
-        default_region_target_http_proxy = gcp.compute.RegionTargetHttpProxy("default",
-            region="us-central1",
-            name="website-proxy",
-            url_map=default_region_url_map.id)
-        # Forwarding rule for Internal Load Balancing
-        default = gcp.compute.ForwardingRule("default",
-            name="website-forwarding-rule",
-            region="us-central1",
-            ip_protocol="TCP",
-            load_balancing_scheme="INTERNAL_MANAGED",
-            port_range="80",
-            target=default_region_target_http_proxy.id,
-            network=default_network.id,
-            subnetwork=default_subnetwork.id,
-            network_tier="PREMIUM")
         fw1 = gcp.compute.Firewall("fw1",
             name="website-fw-1",
             network=default_network.id,
@@ -2244,7 +1900,8 @@ class ForwardingRule(pulumi.CustomResource):
                 ports=["22"],
             )],
             target_tags=["allow-ssh"],
-            direction="INGRESS")
+            direction="INGRESS",
+            opts=pulumi.ResourceOptions(depends_on=[fw1]))
         fw3 = gcp.compute.Firewall("fw3",
             name="website-fw-3",
             network=default_network.id,
@@ -2256,7 +1913,8 @@ class ForwardingRule(pulumi.CustomResource):
                 protocol="tcp",
             )],
             target_tags=["load-balanced-backend"],
-            direction="INGRESS")
+            direction="INGRESS",
+            opts=pulumi.ResourceOptions(depends_on=[fw2]))
         fw4 = gcp.compute.Firewall("fw4",
             name="website-fw-4",
             network=default_network.id,
@@ -2276,7 +1934,35 @@ class ForwardingRule(pulumi.CustomResource):
                     ports=["8000"],
                 ),
             ],
-            direction="INGRESS")
+            direction="INGRESS",
+            opts=pulumi.ResourceOptions(depends_on=[fw3]))
+        default_region_health_check = gcp.compute.RegionHealthCheck("default",
+            region="us-central1",
+            name="website-hc",
+            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
+                port_specification="USE_SERVING_PORT",
+            ),
+            opts=pulumi.ResourceOptions(depends_on=[fw4]))
+        default_region_backend_service = gcp.compute.RegionBackendService("default",
+            load_balancing_scheme="INTERNAL_MANAGED",
+            backends=[gcp.compute.RegionBackendServiceBackendArgs(
+                group=rigm.instance_group,
+                balancing_mode="UTILIZATION",
+                capacity_scaler=1,
+            )],
+            region="us-central1",
+            name="website-backend",
+            protocol="HTTP",
+            timeout_sec=10,
+            health_checks=default_region_health_check.id)
+        default_region_url_map = gcp.compute.RegionUrlMap("default",
+            region="us-central1",
+            name="website-map",
+            default_service=default_region_backend_service.id)
+        default_region_target_http_proxy = gcp.compute.RegionTargetHttpProxy("default",
+            region="us-central1",
+            name="website-proxy",
+            url_map=default_region_url_map.id)
         proxy = gcp.compute.Subnetwork("proxy",
             name="website-net-proxy",
             ip_cidr_range="10.129.0.0/26",
@@ -2284,6 +1970,18 @@ class ForwardingRule(pulumi.CustomResource):
             network=default_network.id,
             purpose="REGIONAL_MANAGED_PROXY",
             role="ACTIVE")
+        # Forwarding rule for Internal Load Balancing
+        default = gcp.compute.ForwardingRule("default",
+            name="website-forwarding-rule",
+            region="us-central1",
+            ip_protocol="TCP",
+            load_balancing_scheme="INTERNAL_MANAGED",
+            port_range="80",
+            target=default_region_target_http_proxy.id,
+            network=default_network.id,
+            subnetwork=default_subnetwork.id,
+            network_tier="PREMIUM",
+            opts=pulumi.ResourceOptions(depends_on=[proxy]))
         ```
         ### Forwarding Rule Regional Http Xlb
 
@@ -2327,47 +2025,6 @@ class ForwardingRule(pulumi.CustomResource):
             )],
             base_instance_name="internal-glb",
             target_size=1)
-        default_region_health_check = gcp.compute.RegionHealthCheck("default",
-            region="us-central1",
-            name="website-hc",
-            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
-                port_specification="USE_SERVING_PORT",
-            ))
-        default_region_backend_service = gcp.compute.RegionBackendService("default",
-            load_balancing_scheme="EXTERNAL_MANAGED",
-            backends=[gcp.compute.RegionBackendServiceBackendArgs(
-                group=rigm.instance_group,
-                balancing_mode="UTILIZATION",
-                capacity_scaler=1,
-            )],
-            region="us-central1",
-            name="website-backend",
-            protocol="HTTP",
-            timeout_sec=10,
-            health_checks=default_region_health_check.id)
-        default_region_url_map = gcp.compute.RegionUrlMap("default",
-            region="us-central1",
-            name="website-map",
-            default_service=default_region_backend_service.id)
-        default_region_target_http_proxy = gcp.compute.RegionTargetHttpProxy("default",
-            region="us-central1",
-            name="website-proxy",
-            url_map=default_region_url_map.id)
-        default_address = gcp.compute.Address("default",
-            name="website-ip-1",
-            region="us-central1",
-            network_tier="STANDARD")
-        # Forwarding rule for Regional External Load Balancing
-        default = gcp.compute.ForwardingRule("default",
-            name="website-forwarding-rule",
-            region="us-central1",
-            ip_protocol="TCP",
-            load_balancing_scheme="EXTERNAL_MANAGED",
-            port_range="80",
-            target=default_region_target_http_proxy.id,
-            network=default_network.id,
-            ip_address=default_address.id,
-            network_tier="STANDARD")
         fw1 = gcp.compute.Firewall("fw1",
             name="website-fw-1",
             network=default_network.id,
@@ -2393,7 +2050,8 @@ class ForwardingRule(pulumi.CustomResource):
                 ports=["22"],
             )],
             target_tags=["allow-ssh"],
-            direction="INGRESS")
+            direction="INGRESS",
+            opts=pulumi.ResourceOptions(depends_on=[fw1]))
         fw3 = gcp.compute.Firewall("fw3",
             name="website-fw-3",
             network=default_network.id,
@@ -2405,7 +2063,8 @@ class ForwardingRule(pulumi.CustomResource):
                 protocol="tcp",
             )],
             target_tags=["load-balanced-backend"],
-            direction="INGRESS")
+            direction="INGRESS",
+            opts=pulumi.ResourceOptions(depends_on=[fw2]))
         fw4 = gcp.compute.Firewall("fw4",
             name="website-fw-4",
             network=default_network.id,
@@ -2425,7 +2084,39 @@ class ForwardingRule(pulumi.CustomResource):
                     ports=["8000"],
                 ),
             ],
-            direction="INGRESS")
+            direction="INGRESS",
+            opts=pulumi.ResourceOptions(depends_on=[fw3]))
+        default_region_health_check = gcp.compute.RegionHealthCheck("default",
+            region="us-central1",
+            name="website-hc",
+            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
+                port_specification="USE_SERVING_PORT",
+            ),
+            opts=pulumi.ResourceOptions(depends_on=[fw4]))
+        default_region_backend_service = gcp.compute.RegionBackendService("default",
+            load_balancing_scheme="EXTERNAL_MANAGED",
+            backends=[gcp.compute.RegionBackendServiceBackendArgs(
+                group=rigm.instance_group,
+                balancing_mode="UTILIZATION",
+                capacity_scaler=1,
+            )],
+            region="us-central1",
+            name="website-backend",
+            protocol="HTTP",
+            timeout_sec=10,
+            health_checks=default_region_health_check.id)
+        default_region_url_map = gcp.compute.RegionUrlMap("default",
+            region="us-central1",
+            name="website-map",
+            default_service=default_region_backend_service.id)
+        default_region_target_http_proxy = gcp.compute.RegionTargetHttpProxy("default",
+            region="us-central1",
+            name="website-proxy",
+            url_map=default_region_url_map.id)
+        default_address = gcp.compute.Address("default",
+            name="website-ip-1",
+            region="us-central1",
+            network_tier="STANDARD")
         proxy = gcp.compute.Subnetwork("proxy",
             name="website-net-proxy",
             ip_cidr_range="10.129.0.0/26",
@@ -2433,6 +2124,18 @@ class ForwardingRule(pulumi.CustomResource):
             network=default_network.id,
             purpose="REGIONAL_MANAGED_PROXY",
             role="ACTIVE")
+        # Forwarding rule for Regional External Load Balancing
+        default = gcp.compute.ForwardingRule("default",
+            name="website-forwarding-rule",
+            region="us-central1",
+            ip_protocol="TCP",
+            load_balancing_scheme="EXTERNAL_MANAGED",
+            port_range="80",
+            target=default_region_target_http_proxy.id,
+            network=default_network.id,
+            ip_address=default_address.address,
+            network_tier="STANDARD",
+            opts=pulumi.ResourceOptions(depends_on=[proxy]))
         ```
         ### Forwarding Rule Vpc Psc
 
@@ -2589,22 +2292,23 @@ class ForwardingRule(pulumi.CustomResource):
             name="service-backend",
             region="us-central1",
             load_balancing_scheme="EXTERNAL")
+        external_forwarding_rule = gcp.compute.ForwardingRule("external",
+            name="external-forwarding-rule",
+            region="us-central1",
+            ip_address=basic.address,
+            backend_service=external.self_link,
+            load_balancing_scheme="EXTERNAL")
         steering = gcp.compute.ForwardingRule("steering",
             name="steering-rule",
             region="us-central1",
-            ip_address=basic.self_link,
+            ip_address=basic.address,
             backend_service=external.self_link,
             load_balancing_scheme="EXTERNAL",
             source_ip_ranges=[
                 "34.121.88.0/24",
                 "35.187.239.137",
-            ])
-        external_forwarding_rule = gcp.compute.ForwardingRule("external",
-            name="external-forwarding-rule",
-            region="us-central1",
-            ip_address=basic.self_link,
-            backend_service=external.self_link,
-            load_balancing_scheme="EXTERNAL")
+            ],
+            opts=pulumi.ResourceOptions(depends_on=[external_forwarding_rule]))
         ```
         ### Forwarding Rule Internallb Ipv6
 
@@ -2866,340 +2570,33 @@ class ForwardingRule(pulumi.CustomResource):
                regional forwarding rules, this target must be in the same region as the
                forwarding rule. For global forwarding rules, this target must be a global
                load balancing resource.
-               The forwarded traffic must be of a type appropriate to the target object.
-               *  For load balancers, see the "Target" column in [Port specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications).
-               *  For Private Service Connect forwarding rules that forward traffic to Google APIs, provide the name of a supported Google API bundle:
-               *  `vpc-sc` - [ APIs that support VPC Service Controls](https://cloud.google.com/vpc-service-controls/docs/supported-products).
-               *  `all-apis` - [All supported Google APIs](https://cloud.google.com/vpc/docs/private-service-connect#supported-apis).
-               
-               For Private Service Connect forwarding rules that forward traffic to managed services, the target must be a service attachment.
-        """
-        ...
-    @overload
-    def __init__(__self__,
-                 resource_name: str,
-                 args: Optional[ForwardingRuleArgs] = None,
-                 opts: Optional[pulumi.ResourceOptions] = None):
-        """
-        A ForwardingRule resource. A ForwardingRule resource specifies which pool
-        of target virtual machines to forward a packet to if it matches the given
-        [IPAddress, IPProtocol, portRange] tuple.
-
-        To get more information about ForwardingRule, see:
-
-        * [API documentation](https://cloud.google.com/compute/docs/reference/v1/forwardingRules)
-        * How-to Guides
-            * [Official Documentation](https://cloud.google.com/compute/docs/load-balancing/network/forwarding-rules)
-
-        ## Example Usage
-
-        ### Internal Http Lb With Mig Backend
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        # Internal HTTP load balancer with a managed instance group backend
-        # VPC network
-        ilb_network = gcp.compute.Network("ilb_network",
-            name="l7-ilb-network",
-            auto_create_subnetworks=False)
-        # proxy-only subnet
-        proxy_subnet = gcp.compute.Subnetwork("proxy_subnet",
-            name="l7-ilb-proxy-subnet",
-            ip_cidr_range="10.0.0.0/24",
-            region="europe-west1",
-            purpose="REGIONAL_MANAGED_PROXY",
-            role="ACTIVE",
-            network=ilb_network.id)
-        # backend subnet
-        ilb_subnet = gcp.compute.Subnetwork("ilb_subnet",
-            name="l7-ilb-subnet",
-            ip_cidr_range="10.0.1.0/24",
-            region="europe-west1",
-            network=ilb_network.id)
-        # health check
-        default_region_health_check = gcp.compute.RegionHealthCheck("default",
-            name="l7-ilb-hc",
-            region="europe-west1",
-            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
-                port_specification="USE_SERVING_PORT",
-            ))
-        # instance template
-        instance_template = gcp.compute.InstanceTemplate("instance_template",
-            network_interfaces=[gcp.compute.InstanceTemplateNetworkInterfaceArgs(
-                access_configs=[gcp.compute.InstanceTemplateNetworkInterfaceAccessConfigArgs()],
-                network=ilb_network.id,
-                subnetwork=ilb_subnet.id,
-            )],
-            name="l7-ilb-mig-template",
-            machine_type="e2-small",
-            tags=["http-server"],
-            disks=[gcp.compute.InstanceTemplateDiskArgs(
-                source_image="debian-cloud/debian-10",
-                auto_delete=True,
-                boot=True,
-            )],
-            metadata={
-                "startup-script": \"\"\"#! /bin/bash
-        set -euo pipefail
-
-        export DEBIAN_FRONTEND=noninteractive
-        apt-get update
-        apt-get install -y nginx-light jq
-
-        NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
-        IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
-        METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')
-
-        cat <<EOF > /var/www/html/index.html
-        <pre>
-        Name: $NAME
-        IP: $IP
-        Metadata: $METADATA
-        </pre>
-        EOF
-        \"\"\",
-            })
-        # MIG
-        mig = gcp.compute.RegionInstanceGroupManager("mig",
-            name="l7-ilb-mig1",
-            region="europe-west1",
-            versions=[gcp.compute.RegionInstanceGroupManagerVersionArgs(
-                instance_template=instance_template.id,
-                name="primary",
-            )],
-            base_instance_name="vm",
-            target_size=2)
-        # backend service
-        default_region_backend_service = gcp.compute.RegionBackendService("default",
-            name="l7-ilb-backend-subnet",
-            region="europe-west1",
-            protocol="HTTP",
-            load_balancing_scheme="INTERNAL_MANAGED",
-            timeout_sec=10,
-            health_checks=default_region_health_check.id,
-            backends=[gcp.compute.RegionBackendServiceBackendArgs(
-                group=mig.instance_group,
-                balancing_mode="UTILIZATION",
-                capacity_scaler=1,
-            )])
-        # URL map
-        default_region_url_map = gcp.compute.RegionUrlMap("default",
-            name="l7-ilb-regional-url-map",
-            region="europe-west1",
-            default_service=default_region_backend_service.id)
-        # HTTP target proxy
-        default = gcp.compute.RegionTargetHttpProxy("default",
-            name="l7-ilb-target-http-proxy",
-            region="europe-west1",
-            url_map=default_region_url_map.id)
-        # forwarding rule
-        google_compute_forwarding_rule = gcp.compute.ForwardingRule("google_compute_forwarding_rule",
-            name="l7-ilb-forwarding-rule",
-            region="europe-west1",
-            ip_protocol="TCP",
-            load_balancing_scheme="INTERNAL_MANAGED",
-            port_range="80",
-            target=default.id,
-            network=ilb_network.id,
-            subnetwork=ilb_subnet.id,
-            network_tier="PREMIUM")
-        # allow all access from IAP and health check ranges
-        fw_iap = gcp.compute.Firewall("fw-iap",
-            name="l7-ilb-fw-allow-iap-hc",
-            direction="INGRESS",
-            network=ilb_network.id,
-            source_ranges=[
-                "130.211.0.0/22",
-                "35.191.0.0/16",
-                "35.235.240.0/20",
-            ],
-            allows=[gcp.compute.FirewallAllowArgs(
-                protocol="tcp",
-            )])
-        # allow http from proxy subnet to backends
-        fw_ilb_to_backends = gcp.compute.Firewall("fw-ilb-to-backends",
-            name="l7-ilb-fw-allow-ilb-to-backends",
-            direction="INGRESS",
-            network=ilb_network.id,
-            source_ranges=["10.0.0.0/24"],
-            target_tags=["http-server"],
-            allows=[gcp.compute.FirewallAllowArgs(
-                protocol="tcp",
-                ports=[
-                    "80",
-                    "443",
-                    "8080",
-                ],
-            )])
-        # test instance
-        vm_test = gcp.compute.Instance("vm-test",
-            name="l7-ilb-test-vm",
-            zone="europe-west1-b",
-            machine_type="e2-small",
-            network_interfaces=[gcp.compute.InstanceNetworkInterfaceArgs(
-                network=ilb_network.id,
-                subnetwork=ilb_subnet.id,
-            )],
-            boot_disk=gcp.compute.InstanceBootDiskArgs(
-                initialize_params=gcp.compute.InstanceBootDiskInitializeParamsArgs(
-                    image="debian-cloud/debian-10",
-                ),
-            ))
-        ```
-        ### Internal Tcp Udp Lb With Mig Backend
+               The forwarded traffic must be of a type appropriate to the target object.
+               *  For load balancers, see the "Target" column in [Port specifications](https://cloud.google.com/load-balancing/docs/forwarding-rule-concepts#ip_address_specifications).
+               *  For Private Service Connect forwarding rules that forward traffic to Google APIs, provide the name of a supported Google API bundle:
+               *  `vpc-sc` - [ APIs that support VPC Service Controls](https://cloud.google.com/vpc-service-controls/docs/supported-products).
+               *  `all-apis` - [All supported Google APIs](https://cloud.google.com/vpc/docs/private-service-connect#supported-apis).
+               
+               For Private Service Connect forwarding rules that forward traffic to managed services, the target must be a service attachment.
+        """
+        ...
+    @overload
+    def __init__(__self__,
+                 resource_name: str,
+                 args: Optional[ForwardingRuleArgs] = None,
+                 opts: Optional[pulumi.ResourceOptions] = None):
+        """
+        A ForwardingRule resource. A ForwardingRule resource specifies which pool
+        of target virtual machines to forward a packet to if it matches the given
+        [IPAddress, IPProtocol, portRange] tuple.
 
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
+        To get more information about ForwardingRule, see:
+
+        * [API documentation](https://cloud.google.com/compute/docs/reference/v1/forwardingRules)
+        * How-to Guides
+            * [Official Documentation](https://cloud.google.com/compute/docs/load-balancing/network/forwarding-rules)
+
+        ## Example Usage
 
-        # Internal TCP/UDP load balancer with a managed instance group backend
-        # VPC
-        ilb_network = gcp.compute.Network("ilb_network",
-            name="l4-ilb-network",
-            auto_create_subnetworks=False)
-        # backed subnet
-        ilb_subnet = gcp.compute.Subnetwork("ilb_subnet",
-            name="l4-ilb-subnet",
-            ip_cidr_range="10.0.1.0/24",
-            region="europe-west1",
-            network=ilb_network.id)
-        # health check
-        default_region_health_check = gcp.compute.RegionHealthCheck("default",
-            name="l4-ilb-hc",
-            region="europe-west1",
-            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
-                port=80,
-            ))
-        # instance template
-        instance_template = gcp.compute.InstanceTemplate("instance_template",
-            network_interfaces=[gcp.compute.InstanceTemplateNetworkInterfaceArgs(
-                access_configs=[gcp.compute.InstanceTemplateNetworkInterfaceAccessConfigArgs()],
-                network=ilb_network.id,
-                subnetwork=ilb_subnet.id,
-            )],
-            name="l4-ilb-mig-template",
-            machine_type="e2-small",
-            tags=[
-                "allow-ssh",
-                "allow-health-check",
-            ],
-            disks=[gcp.compute.InstanceTemplateDiskArgs(
-                source_image="debian-cloud/debian-10",
-                auto_delete=True,
-                boot=True,
-            )],
-            metadata={
-                "startup-script": \"\"\"#! /bin/bash
-        set -euo pipefail
-
-        export DEBIAN_FRONTEND=noninteractive
-        apt-get update
-        apt-get install -y nginx-light jq
-
-        NAME=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/hostname")
-        IP=$(curl -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/network-interfaces/0/ip")
-        METADATA=$(curl -f -H "Metadata-Flavor: Google" "http://metadata.google.internal/computeMetadata/v1/instance/attributes/?recursive=True" | jq 'del(.["startup-script"])')
-
-        cat <<EOF > /var/www/html/index.html
-        <pre>
-        Name: $NAME
-        IP: $IP
-        Metadata: $METADATA
-        </pre>
-        EOF
-        \"\"\",
-            })
-        # MIG
-        mig = gcp.compute.RegionInstanceGroupManager("mig",
-            name="l4-ilb-mig1",
-            region="europe-west1",
-            versions=[gcp.compute.RegionInstanceGroupManagerVersionArgs(
-                instance_template=instance_template.id,
-                name="primary",
-            )],
-            base_instance_name="vm",
-            target_size=2)
-        # backend service
-        default = gcp.compute.RegionBackendService("default",
-            name="l4-ilb-backend-subnet",
-            region="europe-west1",
-            protocol="TCP",
-            load_balancing_scheme="INTERNAL",
-            health_checks=default_region_health_check.id,
-            backends=[gcp.compute.RegionBackendServiceBackendArgs(
-                group=mig.instance_group,
-                balancing_mode="CONNECTION",
-            )])
-        # forwarding rule
-        google_compute_forwarding_rule = gcp.compute.ForwardingRule("google_compute_forwarding_rule",
-            name="l4-ilb-forwarding-rule",
-            backend_service=default.id,
-            region="europe-west1",
-            ip_protocol="TCP",
-            load_balancing_scheme="INTERNAL",
-            all_ports=True,
-            allow_global_access=True,
-            network=ilb_network.id,
-            subnetwork=ilb_subnet.id)
-        # allow all access from health check ranges
-        fw_hc = gcp.compute.Firewall("fw_hc",
-            name="l4-ilb-fw-allow-hc",
-            direction="INGRESS",
-            network=ilb_network.id,
-            source_ranges=[
-                "130.211.0.0/22",
-                "35.191.0.0/16",
-                "35.235.240.0/20",
-            ],
-            allows=[gcp.compute.FirewallAllowArgs(
-                protocol="tcp",
-            )],
-            target_tags=["allow-health-check"])
-        # allow communication within the subnet 
-        fw_ilb_to_backends = gcp.compute.Firewall("fw_ilb_to_backends",
-            name="l4-ilb-fw-allow-ilb-to-backends",
-            direction="INGRESS",
-            network=ilb_network.id,
-            source_ranges=["10.0.1.0/24"],
-            allows=[
-                gcp.compute.FirewallAllowArgs(
-                    protocol="tcp",
-                ),
-                gcp.compute.FirewallAllowArgs(
-                    protocol="udp",
-                ),
-                gcp.compute.FirewallAllowArgs(
-                    protocol="icmp",
-                ),
-            ])
-        # allow SSH
-        fw_ilb_ssh = gcp.compute.Firewall("fw_ilb_ssh",
-            name="l4-ilb-fw-ssh",
-            direction="INGRESS",
-            network=ilb_network.id,
-            allows=[gcp.compute.FirewallAllowArgs(
-                protocol="tcp",
-                ports=["22"],
-            )],
-            target_tags=["allow-ssh"],
-            source_ranges=["0.0.0.0/0"])
-        # test instance
-        vm_test = gcp.compute.Instance("vm_test",
-            name="l4-ilb-test-vm",
-            zone="europe-west1-b",
-            machine_type="e2-small",
-            network_interfaces=[gcp.compute.InstanceNetworkInterfaceArgs(
-                network=ilb_network.id,
-                subnetwork=ilb_subnet.id,
-            )],
-            boot_disk=gcp.compute.InstanceBootDiskArgs(
-                initialize_params=gcp.compute.InstanceBootDiskInitializeParamsArgs(
-                    image="debian-cloud/debian-10",
-                ),
-            ))
-        ```
         ### Forwarding Rule Externallb
 
         ```python
@@ -3376,43 +2773,6 @@ class ForwardingRule(pulumi.CustomResource):
             )],
             base_instance_name="internal-glb",
             target_size=1)
-        default_region_health_check = gcp.compute.RegionHealthCheck("default",
-            region="us-central1",
-            name="website-hc",
-            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
-                port_specification="USE_SERVING_PORT",
-            ))
-        default_region_backend_service = gcp.compute.RegionBackendService("default",
-            load_balancing_scheme="INTERNAL_MANAGED",
-            backends=[gcp.compute.RegionBackendServiceBackendArgs(
-                group=rigm.instance_group,
-                balancing_mode="UTILIZATION",
-                capacity_scaler=1,
-            )],
-            region="us-central1",
-            name="website-backend",
-            protocol="HTTP",
-            timeout_sec=10,
-            health_checks=default_region_health_check.id)
-        default_region_url_map = gcp.compute.RegionUrlMap("default",
-            region="us-central1",
-            name="website-map",
-            default_service=default_region_backend_service.id)
-        default_region_target_http_proxy = gcp.compute.RegionTargetHttpProxy("default",
-            region="us-central1",
-            name="website-proxy",
-            url_map=default_region_url_map.id)
-        # Forwarding rule for Internal Load Balancing
-        default = gcp.compute.ForwardingRule("default",
-            name="website-forwarding-rule",
-            region="us-central1",
-            ip_protocol="TCP",
-            load_balancing_scheme="INTERNAL_MANAGED",
-            port_range="80",
-            target=default_region_target_http_proxy.id,
-            network=default_network.id,
-            subnetwork=default_subnetwork.id,
-            network_tier="PREMIUM")
         fw1 = gcp.compute.Firewall("fw1",
             name="website-fw-1",
             network=default_network.id,
@@ -3438,7 +2798,8 @@ class ForwardingRule(pulumi.CustomResource):
                 ports=["22"],
             )],
             target_tags=["allow-ssh"],
-            direction="INGRESS")
+            direction="INGRESS",
+            opts=pulumi.ResourceOptions(depends_on=[fw1]))
         fw3 = gcp.compute.Firewall("fw3",
             name="website-fw-3",
             network=default_network.id,
@@ -3450,7 +2811,8 @@ class ForwardingRule(pulumi.CustomResource):
                 protocol="tcp",
             )],
             target_tags=["load-balanced-backend"],
-            direction="INGRESS")
+            direction="INGRESS",
+            opts=pulumi.ResourceOptions(depends_on=[fw2]))
         fw4 = gcp.compute.Firewall("fw4",
             name="website-fw-4",
             network=default_network.id,
@@ -3470,7 +2832,35 @@ class ForwardingRule(pulumi.CustomResource):
                     ports=["8000"],
                 ),
             ],
-            direction="INGRESS")
+            direction="INGRESS",
+            opts=pulumi.ResourceOptions(depends_on=[fw3]))
+        default_region_health_check = gcp.compute.RegionHealthCheck("default",
+            region="us-central1",
+            name="website-hc",
+            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
+                port_specification="USE_SERVING_PORT",
+            ),
+            opts=pulumi.ResourceOptions(depends_on=[fw4]))
+        default_region_backend_service = gcp.compute.RegionBackendService("default",
+            load_balancing_scheme="INTERNAL_MANAGED",
+            backends=[gcp.compute.RegionBackendServiceBackendArgs(
+                group=rigm.instance_group,
+                balancing_mode="UTILIZATION",
+                capacity_scaler=1,
+            )],
+            region="us-central1",
+            name="website-backend",
+            protocol="HTTP",
+            timeout_sec=10,
+            health_checks=default_region_health_check.id)
+        default_region_url_map = gcp.compute.RegionUrlMap("default",
+            region="us-central1",
+            name="website-map",
+            default_service=default_region_backend_service.id)
+        default_region_target_http_proxy = gcp.compute.RegionTargetHttpProxy("default",
+            region="us-central1",
+            name="website-proxy",
+            url_map=default_region_url_map.id)
         proxy = gcp.compute.Subnetwork("proxy",
             name="website-net-proxy",
             ip_cidr_range="10.129.0.0/26",
@@ -3478,6 +2868,18 @@ class ForwardingRule(pulumi.CustomResource):
             network=default_network.id,
             purpose="REGIONAL_MANAGED_PROXY",
             role="ACTIVE")
+        # Forwarding rule for Internal Load Balancing
+        default = gcp.compute.ForwardingRule("default",
+            name="website-forwarding-rule",
+            region="us-central1",
+            ip_protocol="TCP",
+            load_balancing_scheme="INTERNAL_MANAGED",
+            port_range="80",
+            target=default_region_target_http_proxy.id,
+            network=default_network.id,
+            subnetwork=default_subnetwork.id,
+            network_tier="PREMIUM",
+            opts=pulumi.ResourceOptions(depends_on=[proxy]))
         ```
         ### Forwarding Rule Regional Http Xlb
 
@@ -3521,47 +2923,6 @@ class ForwardingRule(pulumi.CustomResource):
             )],
             base_instance_name="internal-glb",
             target_size=1)
-        default_region_health_check = gcp.compute.RegionHealthCheck("default",
-            region="us-central1",
-            name="website-hc",
-            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
-                port_specification="USE_SERVING_PORT",
-            ))
-        default_region_backend_service = gcp.compute.RegionBackendService("default",
-            load_balancing_scheme="EXTERNAL_MANAGED",
-            backends=[gcp.compute.RegionBackendServiceBackendArgs(
-                group=rigm.instance_group,
-                balancing_mode="UTILIZATION",
-                capacity_scaler=1,
-            )],
-            region="us-central1",
-            name="website-backend",
-            protocol="HTTP",
-            timeout_sec=10,
-            health_checks=default_region_health_check.id)
-        default_region_url_map = gcp.compute.RegionUrlMap("default",
-            region="us-central1",
-            name="website-map",
-            default_service=default_region_backend_service.id)
-        default_region_target_http_proxy = gcp.compute.RegionTargetHttpProxy("default",
-            region="us-central1",
-            name="website-proxy",
-            url_map=default_region_url_map.id)
-        default_address = gcp.compute.Address("default",
-            name="website-ip-1",
-            region="us-central1",
-            network_tier="STANDARD")
-        # Forwarding rule for Regional External Load Balancing
-        default = gcp.compute.ForwardingRule("default",
-            name="website-forwarding-rule",
-            region="us-central1",
-            ip_protocol="TCP",
-            load_balancing_scheme="EXTERNAL_MANAGED",
-            port_range="80",
-            target=default_region_target_http_proxy.id,
-            network=default_network.id,
-            ip_address=default_address.id,
-            network_tier="STANDARD")
         fw1 = gcp.compute.Firewall("fw1",
             name="website-fw-1",
             network=default_network.id,
@@ -3587,7 +2948,8 @@ class ForwardingRule(pulumi.CustomResource):
                 ports=["22"],
             )],
             target_tags=["allow-ssh"],
-            direction="INGRESS")
+            direction="INGRESS",
+            opts=pulumi.ResourceOptions(depends_on=[fw1]))
         fw3 = gcp.compute.Firewall("fw3",
             name="website-fw-3",
             network=default_network.id,
@@ -3599,7 +2961,8 @@ class ForwardingRule(pulumi.CustomResource):
                 protocol="tcp",
             )],
             target_tags=["load-balanced-backend"],
-            direction="INGRESS")
+            direction="INGRESS",
+            opts=pulumi.ResourceOptions(depends_on=[fw2]))
         fw4 = gcp.compute.Firewall("fw4",
             name="website-fw-4",
             network=default_network.id,
@@ -3619,7 +2982,39 @@ class ForwardingRule(pulumi.CustomResource):
                     ports=["8000"],
                 ),
             ],
-            direction="INGRESS")
+            direction="INGRESS",
+            opts=pulumi.ResourceOptions(depends_on=[fw3]))
+        default_region_health_check = gcp.compute.RegionHealthCheck("default",
+            region="us-central1",
+            name="website-hc",
+            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
+                port_specification="USE_SERVING_PORT",
+            ),
+            opts=pulumi.ResourceOptions(depends_on=[fw4]))
+        default_region_backend_service = gcp.compute.RegionBackendService("default",
+            load_balancing_scheme="EXTERNAL_MANAGED",
+            backends=[gcp.compute.RegionBackendServiceBackendArgs(
+                group=rigm.instance_group,
+                balancing_mode="UTILIZATION",
+                capacity_scaler=1,
+            )],
+            region="us-central1",
+            name="website-backend",
+            protocol="HTTP",
+            timeout_sec=10,
+            health_checks=default_region_health_check.id)
+        default_region_url_map = gcp.compute.RegionUrlMap("default",
+            region="us-central1",
+            name="website-map",
+            default_service=default_region_backend_service.id)
+        default_region_target_http_proxy = gcp.compute.RegionTargetHttpProxy("default",
+            region="us-central1",
+            name="website-proxy",
+            url_map=default_region_url_map.id)
+        default_address = gcp.compute.Address("default",
+            name="website-ip-1",
+            region="us-central1",
+            network_tier="STANDARD")
         proxy = gcp.compute.Subnetwork("proxy",
             name="website-net-proxy",
             ip_cidr_range="10.129.0.0/26",
@@ -3627,6 +3022,18 @@ class ForwardingRule(pulumi.CustomResource):
             network=default_network.id,
             purpose="REGIONAL_MANAGED_PROXY",
             role="ACTIVE")
+        # Forwarding rule for Regional External Load Balancing
+        default = gcp.compute.ForwardingRule("default",
+            name="website-forwarding-rule",
+            region="us-central1",
+            ip_protocol="TCP",
+            load_balancing_scheme="EXTERNAL_MANAGED",
+            port_range="80",
+            target=default_region_target_http_proxy.id,
+            network=default_network.id,
+            ip_address=default_address.address,
+            network_tier="STANDARD",
+            opts=pulumi.ResourceOptions(depends_on=[proxy]))
         ```
         ### Forwarding Rule Vpc Psc
 
@@ -3783,22 +3190,23 @@ class ForwardingRule(pulumi.CustomResource):
             name="service-backend",
             region="us-central1",
             load_balancing_scheme="EXTERNAL")
+        external_forwarding_rule = gcp.compute.ForwardingRule("external",
+            name="external-forwarding-rule",
+            region="us-central1",
+            ip_address=basic.address,
+            backend_service=external.self_link,
+            load_balancing_scheme="EXTERNAL")
         steering = gcp.compute.ForwardingRule("steering",
             name="steering-rule",
             region="us-central1",
-            ip_address=basic.self_link,
+            ip_address=basic.address,
             backend_service=external.self_link,
             load_balancing_scheme="EXTERNAL",
             source_ip_ranges=[
                 "34.121.88.0/24",
                 "35.187.239.137",
-            ])
-        external_forwarding_rule = gcp.compute.ForwardingRule("external",
-            name="external-forwarding-rule",
-            region="us-central1",
-            ip_address=basic.self_link,
-            backend_service=external.self_link,
-            load_balancing_scheme="EXTERNAL")
+            ],
+            opts=pulumi.ResourceOptions(depends_on=[external_forwarding_rule]))
         ```
         ### Forwarding Rule Internallb Ipv6