pulumi-gcp 7.24.0a1716588893__py3-none-any.whl → 7.25.0a1717097889__py3-none-any.whl

pulumi_gcp/compute/instance_group.py

@@ -392,56 +392,6 @@ class InstanceGroup(pulumi.CustomResource):
             zone="us-central1-a")
         ```
 
-        ### Example Usage - Recreating an instance group in use
-        Recreating an instance group that's in use by another resource will give a
-        `resourceInUseByAnotherResource` error. Use `lifecycle.create_before_destroy`
-        as shown in this example to avoid this type of error.
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        debian_image = gcp.compute.get_image(family="debian-11",
-            project="debian-cloud")
-        staging_vm = gcp.compute.Instance("staging_vm",
-            name="staging-vm",
-            machine_type="e2-medium",
-            zone="us-central1-c",
-            boot_disk=gcp.compute.InstanceBootDiskArgs(
-                initialize_params=gcp.compute.InstanceBootDiskInitializeParamsArgs(
-                    image=debian_image.self_link,
-                ),
-            ),
-            network_interfaces=[gcp.compute.InstanceNetworkInterfaceArgs(
-                network="default",
-            )])
-        staging_group = gcp.compute.InstanceGroup("staging_group",
-            name="staging-instance-group",
-            zone="us-central1-c",
-            instances=[staging_vm.id],
-            named_ports=[
-                gcp.compute.InstanceGroupNamedPortArgs(
-                    name="http",
-                    port=8080,
-                ),
-                gcp.compute.InstanceGroupNamedPortArgs(
-                    name="https",
-                    port=8443,
-                ),
-            ])
-        staging_health = gcp.compute.HttpsHealthCheck("staging_health",
-            name="staging-health",
-            request_path="/health_check")
-        staging_service = gcp.compute.BackendService("staging_service",
-            name="staging-service",
-            port_name="https",
-            protocol="HTTPS",
-            backends=[gcp.compute.BackendServiceBackendArgs(
-                group=staging_group.id,
-            )],
-            health_checks=staging_health.id)
-        ```
-
         ## Import
 
         Instance groups can be imported using the `zone` and `name` with an optional `project`, e.g.
@@ -540,56 +490,6 @@ class InstanceGroup(pulumi.CustomResource):
             zone="us-central1-a")
         ```
 
-        ### Example Usage - Recreating an instance group in use
-        Recreating an instance group that's in use by another resource will give a
-        `resourceInUseByAnotherResource` error. Use `lifecycle.create_before_destroy`
-        as shown in this example to avoid this type of error.
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        debian_image = gcp.compute.get_image(family="debian-11",
-            project="debian-cloud")
-        staging_vm = gcp.compute.Instance("staging_vm",
-            name="staging-vm",
-            machine_type="e2-medium",
-            zone="us-central1-c",
-            boot_disk=gcp.compute.InstanceBootDiskArgs(
-                initialize_params=gcp.compute.InstanceBootDiskInitializeParamsArgs(
-                    image=debian_image.self_link,
-                ),
-            ),
-            network_interfaces=[gcp.compute.InstanceNetworkInterfaceArgs(
-                network="default",
-            )])
-        staging_group = gcp.compute.InstanceGroup("staging_group",
-            name="staging-instance-group",
-            zone="us-central1-c",
-            instances=[staging_vm.id],
-            named_ports=[
-                gcp.compute.InstanceGroupNamedPortArgs(
-                    name="http",
-                    port=8080,
-                ),
-                gcp.compute.InstanceGroupNamedPortArgs(
-                    name="https",
-                    port=8443,
-                ),
-            ])
-        staging_health = gcp.compute.HttpsHealthCheck("staging_health",
-            name="staging-health",
-            request_path="/health_check")
-        staging_service = gcp.compute.BackendService("staging_service",
-            name="staging-service",
-            port_name="https",
-            protocol="HTTPS",
-            backends=[gcp.compute.BackendServiceBackendArgs(
-                group=staging_group.id,
-            )],
-            health_checks=staging_health.id)
-        ```
-
         ## Import
 
         Instance groups can be imported using the `zone` and `name` with an optional `project`, e.g.

pulumi_gcp/compute/packet_mirroring.py

@@ -412,7 +412,8 @@ class PacketMirroring(pulumi.CustomResource):
             all_ports=True,
             network=default.id,
             subnetwork=default_subnetwork.id,
-            network_tier="PREMIUM")
+            network_tier="PREMIUM",
+            opts=pulumi.ResourceOptions(depends_on=[default_subnetwork]))
         foobar = gcp.compute.PacketMirroring("foobar",
             name="my-mirroring",
             description="bar",
@@ -546,7 +547,8 @@ class PacketMirroring(pulumi.CustomResource):
             all_ports=True,
             network=default.id,
             subnetwork=default_subnetwork.id,
-            network_tier="PREMIUM")
+            network_tier="PREMIUM",
+            opts=pulumi.ResourceOptions(depends_on=[default_subnetwork]))
         foobar = gcp.compute.PacketMirroring("foobar",
             name="my-mirroring",
             description="bar",

pulumi_gcp/compute/region_security_policy_rule.py

@@ -648,7 +648,8 @@ class RegionSecurityPolicyRule(pulumi.CustomResource):
                 offset=8,
                 size=2,
                 mask="0x8F00",
-            )])
+            )],
+            opts=pulumi.ResourceOptions(depends_on=[edge_sec_service]))
         policy_rule_network_match = gcp.compute.RegionSecurityPolicyRule("policy_rule_network_match",
             region="us-west2",
             security_policy=policynetworkmatch.name,
@@ -897,7 +898,8 @@ class RegionSecurityPolicyRule(pulumi.CustomResource):
                 offset=8,
                 size=2,
                 mask="0x8F00",
-            )])
+            )],
+            opts=pulumi.ResourceOptions(depends_on=[edge_sec_service]))
         policy_rule_network_match = gcp.compute.RegionSecurityPolicyRule("policy_rule_network_match",
             region="us-west2",
             security_policy=policynetworkmatch.name,

pulumi_gcp/compute/region_ssl_certificate.py

@@ -411,100 +411,6 @@ class RegionSslCertificate(pulumi.CustomResource):
 
         ## Example Usage
 
-        ### Region Ssl Certificate Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-        import pulumi_std as std
-
-        default = gcp.compute.RegionSslCertificate("default",
-            region="us-central1",
-            name_prefix="my-certificate-",
-            description="a description",
-            private_key=std.file(input="path/to/private.key").result,
-            certificate=std.file(input="path/to/certificate.crt").result)
-        ```
-        ### Region Ssl Certificate Random Provider
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-        import pulumi_random as random
-        import pulumi_std as std
-
-        certificate = random.RandomId("certificate",
-            byte_length=4,
-            prefix="my-certificate-",
-            keepers={
-                "private_key": std.filebase64sha256(input="path/to/private.key").result,
-                "certificate": std.filebase64sha256(input="path/to/certificate.crt").result,
-            })
-        # You may also want to control name generation explicitly:
-        default = gcp.compute.RegionSslCertificate("default",
-            region="us-central1",
-            name=certificate.hex,
-            private_key=std.file(input="path/to/private.key").result,
-            certificate=std.file(input="path/to/certificate.crt").result)
-        ```
-        ### Region Ssl Certificate Target Https Proxies
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-        import pulumi_std as std
-
-        # Using with Region Target HTTPS Proxies
-        #
-        # SSL certificates cannot be updated after creation. In order to apply
-        # the specified configuration, the provider will destroy the existing
-        # resource and create a replacement. To effectively use an SSL
-        # certificate resource with a Target HTTPS Proxy resource, it's
-        # recommended to specify create_before_destroy in a lifecycle block.
-        # Either omit the Instance Template name attribute, specify a partial
-        # name with name_prefix, or use random_id resource. Example:
-        default = gcp.compute.RegionSslCertificate("default",
-            region="us-central1",
-            name_prefix="my-certificate-",
-            private_key=std.file(input="path/to/private.key").result,
-            certificate=std.file(input="path/to/certificate.crt").result)
-        default_region_health_check = gcp.compute.RegionHealthCheck("default",
-            region="us-central1",
-            name="http-health-check",
-            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
-                port=80,
-            ))
-        default_region_backend_service = gcp.compute.RegionBackendService("default",
-            region="us-central1",
-            name="backend-service",
-            protocol="HTTP",
-            load_balancing_scheme="INTERNAL_MANAGED",
-            timeout_sec=10,
-            health_checks=default_region_health_check.id)
-        default_region_url_map = gcp.compute.RegionUrlMap("default",
-            region="us-central1",
-            name="url-map",
-            description="a description",
-            default_service=default_region_backend_service.id,
-            host_rules=[gcp.compute.RegionUrlMapHostRuleArgs(
-                hosts=["mysite.com"],
-                path_matcher="allpaths",
-            )],
-            path_matchers=[gcp.compute.RegionUrlMapPathMatcherArgs(
-                name="allpaths",
-                default_service=default_region_backend_service.id,
-                path_rules=[gcp.compute.RegionUrlMapPathMatcherPathRuleArgs(
-                    paths=["/*"],
-                    service=default_region_backend_service.id,
-                )],
-            )])
-        default_region_target_https_proxy = gcp.compute.RegionTargetHttpsProxy("default",
-            region="us-central1",
-            name="test-proxy",
-            url_map=default_region_url_map.id,
-            ssl_certificates=[default.id])
-        ```
-
         ## Import
 
         RegionSslCertificate can be imported using any of these accepted formats:
@@ -582,100 +488,6 @@ class RegionSslCertificate(pulumi.CustomResource):
 
         ## Example Usage
 
-        ### Region Ssl Certificate Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-        import pulumi_std as std
-
-        default = gcp.compute.RegionSslCertificate("default",
-            region="us-central1",
-            name_prefix="my-certificate-",
-            description="a description",
-            private_key=std.file(input="path/to/private.key").result,
-            certificate=std.file(input="path/to/certificate.crt").result)
-        ```
-        ### Region Ssl Certificate Random Provider
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-        import pulumi_random as random
-        import pulumi_std as std
-
-        certificate = random.RandomId("certificate",
-            byte_length=4,
-            prefix="my-certificate-",
-            keepers={
-                "private_key": std.filebase64sha256(input="path/to/private.key").result,
-                "certificate": std.filebase64sha256(input="path/to/certificate.crt").result,
-            })
-        # You may also want to control name generation explicitly:
-        default = gcp.compute.RegionSslCertificate("default",
-            region="us-central1",
-            name=certificate.hex,
-            private_key=std.file(input="path/to/private.key").result,
-            certificate=std.file(input="path/to/certificate.crt").result)
-        ```
-        ### Region Ssl Certificate Target Https Proxies
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-        import pulumi_std as std
-
-        # Using with Region Target HTTPS Proxies
-        #
-        # SSL certificates cannot be updated after creation. In order to apply
-        # the specified configuration, the provider will destroy the existing
-        # resource and create a replacement. To effectively use an SSL
-        # certificate resource with a Target HTTPS Proxy resource, it's
-        # recommended to specify create_before_destroy in a lifecycle block.
-        # Either omit the Instance Template name attribute, specify a partial
-        # name with name_prefix, or use random_id resource. Example:
-        default = gcp.compute.RegionSslCertificate("default",
-            region="us-central1",
-            name_prefix="my-certificate-",
-            private_key=std.file(input="path/to/private.key").result,
-            certificate=std.file(input="path/to/certificate.crt").result)
-        default_region_health_check = gcp.compute.RegionHealthCheck("default",
-            region="us-central1",
-            name="http-health-check",
-            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
-                port=80,
-            ))
-        default_region_backend_service = gcp.compute.RegionBackendService("default",
-            region="us-central1",
-            name="backend-service",
-            protocol="HTTP",
-            load_balancing_scheme="INTERNAL_MANAGED",
-            timeout_sec=10,
-            health_checks=default_region_health_check.id)
-        default_region_url_map = gcp.compute.RegionUrlMap("default",
-            region="us-central1",
-            name="url-map",
-            description="a description",
-            default_service=default_region_backend_service.id,
-            host_rules=[gcp.compute.RegionUrlMapHostRuleArgs(
-                hosts=["mysite.com"],
-                path_matcher="allpaths",
-            )],
-            path_matchers=[gcp.compute.RegionUrlMapPathMatcherArgs(
-                name="allpaths",
-                default_service=default_region_backend_service.id,
-                path_rules=[gcp.compute.RegionUrlMapPathMatcherPathRuleArgs(
-                    paths=["/*"],
-                    service=default_region_backend_service.id,
-                )],
-            )])
-        default_region_target_https_proxy = gcp.compute.RegionTargetHttpsProxy("default",
-            region="us-central1",
-            name="test-proxy",
-            url_map=default_region_url_map.id,
-            ssl_certificates=[default.id])
-        ```
-
         ## Import
 
         RegionSslCertificate can be imported using any of these accepted formats:

pulumi_gcp/compute/route.py

@@ -804,7 +804,11 @@ class Route(pulumi.CustomResource):
             tags=[
                 "tag1",
                 "tag2",
-            ])
+            ],
+            opts=pulumi.ResourceOptions(depends_on=[
+                    peering1,
+                    peering2,
+                ]))
         ```
 
         ## Import
@@ -1039,7 +1043,11 @@ class Route(pulumi.CustomResource):
             tags=[
                 "tag1",
                 "tag2",
-            ])
+            ],
+            opts=pulumi.ResourceOptions(depends_on=[
+                    peering1,
+                    peering2,
+                ]))
         ```
 
         ## Import

pulumi_gcp/compute/ssl_certificate.py

@@ -374,89 +374,6 @@ class SSLCertificate(pulumi.CustomResource):
 
         ## Example Usage
 
-        ### Ssl Certificate Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-        import pulumi_std as std
-
-        default = gcp.compute.SSLCertificate("default",
-            name_prefix="my-certificate-",
-            description="a description",
-            private_key=std.file(input="path/to/private.key").result,
-            certificate=std.file(input="path/to/certificate.crt").result)
-        ```
-        ### Ssl Certificate Random Provider
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-        import pulumi_random as random
-        import pulumi_std as std
-
-        certificate = random.RandomId("certificate",
-            byte_length=4,
-            prefix="my-certificate-",
-            keepers={
-                "private_key": std.filebase64sha256(input="path/to/private.key").result,
-                "certificate": std.filebase64sha256(input="path/to/certificate.crt").result,
-            })
-        # You may also want to control name generation explicitly:
-        default = gcp.compute.SSLCertificate("default",
-            name=certificate.hex,
-            private_key=std.file(input="path/to/private.key").result,
-            certificate=std.file(input="path/to/certificate.crt").result)
-        ```
-        ### Ssl Certificate Target Https Proxies
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-        import pulumi_std as std
-
-        # Using with Target HTTPS Proxies
-        #
-        # SSL certificates cannot be updated after creation. In order to apply
-        # the specified configuration, the provider will destroy the existing
-        # resource and create a replacement. Example:
-        default = gcp.compute.SSLCertificate("default",
-            name_prefix="my-certificate-",
-            private_key=std.file(input="path/to/private.key").result,
-            certificate=std.file(input="path/to/certificate.crt").result)
-        default_http_health_check = gcp.compute.HttpHealthCheck("default",
-            name="http-health-check",
-            request_path="/",
-            check_interval_sec=1,
-            timeout_sec=1)
-        default_backend_service = gcp.compute.BackendService("default",
-            name="backend-service",
-            port_name="http",
-            protocol="HTTP",
-            timeout_sec=10,
-            health_checks=default_http_health_check.id)
-        default_url_map = gcp.compute.URLMap("default",
-            name="url-map",
-            description="a description",
-            default_service=default_backend_service.id,
-            host_rules=[gcp.compute.URLMapHostRuleArgs(
-                hosts=["mysite.com"],
-                path_matcher="allpaths",
-            )],
-            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
-                name="allpaths",
-                default_service=default_backend_service.id,
-                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
-                    paths=["/*"],
-                    service=default_backend_service.id,
-                )],
-            )])
-        default_target_https_proxy = gcp.compute.TargetHttpsProxy("default",
-            name="test-proxy",
-            url_map=default_url_map.id,
-            ssl_certificates=[default.id])
-        ```
-
         ## Import
 
         SslCertificate can be imported using any of these accepted formats:
@@ -526,89 +443,6 @@ class SSLCertificate(pulumi.CustomResource):
 
         ## Example Usage
 
-        ### Ssl Certificate Basic
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-        import pulumi_std as std
-
-        default = gcp.compute.SSLCertificate("default",
-            name_prefix="my-certificate-",
-            description="a description",
-            private_key=std.file(input="path/to/private.key").result,
-            certificate=std.file(input="path/to/certificate.crt").result)
-        ```
-        ### Ssl Certificate Random Provider
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-        import pulumi_random as random
-        import pulumi_std as std
-
-        certificate = random.RandomId("certificate",
-            byte_length=4,
-            prefix="my-certificate-",
-            keepers={
-                "private_key": std.filebase64sha256(input="path/to/private.key").result,
-                "certificate": std.filebase64sha256(input="path/to/certificate.crt").result,
-            })
-        # You may also want to control name generation explicitly:
-        default = gcp.compute.SSLCertificate("default",
-            name=certificate.hex,
-            private_key=std.file(input="path/to/private.key").result,
-            certificate=std.file(input="path/to/certificate.crt").result)
-        ```
-        ### Ssl Certificate Target Https Proxies
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-        import pulumi_std as std
-
-        # Using with Target HTTPS Proxies
-        #
-        # SSL certificates cannot be updated after creation. In order to apply
-        # the specified configuration, the provider will destroy the existing
-        # resource and create a replacement. Example:
-        default = gcp.compute.SSLCertificate("default",
-            name_prefix="my-certificate-",
-            private_key=std.file(input="path/to/private.key").result,
-            certificate=std.file(input="path/to/certificate.crt").result)
-        default_http_health_check = gcp.compute.HttpHealthCheck("default",
-            name="http-health-check",
-            request_path="/",
-            check_interval_sec=1,
-            timeout_sec=1)
-        default_backend_service = gcp.compute.BackendService("default",
-            name="backend-service",
-            port_name="http",
-            protocol="HTTP",
-            timeout_sec=10,
-            health_checks=default_http_health_check.id)
-        default_url_map = gcp.compute.URLMap("default",
-            name="url-map",
-            description="a description",
-            default_service=default_backend_service.id,
-            host_rules=[gcp.compute.URLMapHostRuleArgs(
-                hosts=["mysite.com"],
-                path_matcher="allpaths",
-            )],
-            path_matchers=[gcp.compute.URLMapPathMatcherArgs(
-                name="allpaths",
-                default_service=default_backend_service.id,
-                path_rules=[gcp.compute.URLMapPathMatcherPathRuleArgs(
-                    paths=["/*"],
-                    service=default_backend_service.id,
-                )],
-            )])
-        default_target_https_proxy = gcp.compute.TargetHttpsProxy("default",
-            name="test-proxy",
-            url_map=default_url_map.id,
-            ssl_certificates=[default.id])
-        ```
-
         ## Import
 
         SslCertificate can be imported using any of these accepted formats:

pulumi_gcp/compute/target_instance.py

@@ -516,7 +516,8 @@ class TargetInstance(pulumi.CustomResource):
             name="region-secpolicy",
             region="southamerica-west1",
             description="basic security policy for target instance",
-            type="CLOUD_ARMOR_NETWORK")
+            type="CLOUD_ARMOR_NETWORK",
+            opts=pulumi.ResourceOptions(depends_on=[edge_sec_service]))
         default_target_instance = gcp.compute.TargetInstance("default",
             name="target-instance",
             zone="southamerica-west1-a",
@@ -705,7 +706,8 @@ class TargetInstance(pulumi.CustomResource):
             name="region-secpolicy",
             region="southamerica-west1",
             description="basic security policy for target instance",
-            type="CLOUD_ARMOR_NETWORK")
+            type="CLOUD_ARMOR_NETWORK",
+            opts=pulumi.ResourceOptions(depends_on=[edge_sec_service]))
         default_target_instance = gcp.compute.TargetInstance("default",
             name="target-instance",
             zone="southamerica-west1-a",

pulumi_gcp/compute/vpn_gateway.py

@@ -330,7 +330,12 @@ class VPNGateway(pulumi.CustomResource):
             name="tunnel1",
             peer_ip="15.0.0.120",
             shared_secret="a secret message",
-            target_vpn_gateway=target_gateway.id)
+            target_vpn_gateway=target_gateway.id,
+            opts=pulumi.ResourceOptions(depends_on=[
+                    fr_esp,
+                    fr_udp500,
+                    fr_udp4500,
+                ]))
         route1 = gcp.compute.Route("route1",
             name="route1",
             network=network1.name,
@@ -438,7 +443,12 @@ class VPNGateway(pulumi.CustomResource):
             name="tunnel1",
             peer_ip="15.0.0.120",
             shared_secret="a secret message",
-            target_vpn_gateway=target_gateway.id)
+            target_vpn_gateway=target_gateway.id,
+            opts=pulumi.ResourceOptions(depends_on=[
+                    fr_esp,
+                    fr_udp500,
+                    fr_udp4500,
+                ]))
         route1 = gcp.compute.Route("route1",
             name="route1",
             network=network1.name,

pulumi_gcp/compute/vpn_tunnel.py

@@ -859,14 +859,6 @@ class VPNTunnel(pulumi.CustomResource):
         target_gateway = gcp.compute.VPNGateway("target_gateway",
             name="vpn-1",
             network=network1.id)
-        tunnel1 = gcp.compute.VPNTunnel("tunnel1",
-            name="tunnel-1",
-            peer_ip="15.0.0.120",
-            shared_secret="a secret message",
-            target_vpn_gateway=target_gateway.id,
-            labels={
-                "foo": "bar",
-            })
         vpn_static_ip = gcp.compute.Address("vpn_static_ip", name="vpn-static-ip")
         fr_esp = gcp.compute.ForwardingRule("fr_esp",
             name="fr-esp",
@@ -885,6 +877,19 @@ class VPNTunnel(pulumi.CustomResource):
             port_range="4500",
             ip_address=vpn_static_ip.address,
             target=target_gateway.id)
+        tunnel1 = gcp.compute.VPNTunnel("tunnel1",
+            name="tunnel-1",
+            peer_ip="15.0.0.120",
+            shared_secret="a secret message",
+            target_vpn_gateway=target_gateway.id,
+            labels={
+                "foo": "bar",
+            },
+            opts=pulumi.ResourceOptions(depends_on=[
+                    fr_esp,
+                    fr_udp500,
+                    fr_udp4500,
+                ]))
         route1 = gcp.compute.Route("route1",
             name="route1",
             network=network1.name,
@@ -999,14 +1004,6 @@ class VPNTunnel(pulumi.CustomResource):
         target_gateway = gcp.compute.VPNGateway("target_gateway",
             name="vpn-1",
             network=network1.id)
-        tunnel1 = gcp.compute.VPNTunnel("tunnel1",
-            name="tunnel-1",
-            peer_ip="15.0.0.120",
-            shared_secret="a secret message",
-            target_vpn_gateway=target_gateway.id,
-            labels={
-                "foo": "bar",
-            })
         vpn_static_ip = gcp.compute.Address("vpn_static_ip", name="vpn-static-ip")
         fr_esp = gcp.compute.ForwardingRule("fr_esp",
             name="fr-esp",
@@ -1025,6 +1022,19 @@ class VPNTunnel(pulumi.CustomResource):
             port_range="4500",
             ip_address=vpn_static_ip.address,
             target=target_gateway.id)
+        tunnel1 = gcp.compute.VPNTunnel("tunnel1",
+            name="tunnel-1",
+            peer_ip="15.0.0.120",
+            shared_secret="a secret message",
+            target_vpn_gateway=target_gateway.id,
+            labels={
+                "foo": "bar",
+            },
+            opts=pulumi.ResourceOptions(depends_on=[
+                    fr_esp,
+                    fr_udp500,
+                    fr_udp4500,
+                ]))
         route1 = gcp.compute.Route("route1",
             name="route1",
             network=network1.name,