pulumi-gcp 8.28.0a1745598508__py3-none-any.whl → 8.29.0__py3-none-any.whl

pulumi_gcp/compute/address.py

@@ -750,6 +750,9 @@ class _AddressState:
 
 
 class Address(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/address:Address"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/attached_disk.py

@@ -376,6 +376,9 @@ class _AttachedDiskState:
 
 
 class AttachedDisk(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/attachedDisk:AttachedDisk"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/autoscaler.py

@@ -286,6 +286,9 @@ class _AutoscalerState:
 
 
 class Autoscaler(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/autoscaler:Autoscaler"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/backend_bucket.py

@@ -407,6 +407,9 @@ class _BackendBucketState:
 
 
 class BackendBucket(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/backendBucket:BackendBucket"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/backend_bucket_iam_binding.py

@@ -254,6 +254,9 @@ class _BackendBucketIamBindingState:
 
 
 class BackendBucketIamBinding(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/backendBucketIamBinding:BackendBucketIamBinding"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/backend_bucket_iam_member.py

@@ -254,6 +254,9 @@ class _BackendBucketIamMemberState:
 
 
 class BackendBucketIamMember(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/backendBucketIamMember:BackendBucketIamMember"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/backend_bucket_iam_policy.py

@@ -153,6 +153,9 @@ class _BackendBucketIamPolicyState:
 
 
 class BackendBucketIamPolicy(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/backendBucketIamPolicy:BackendBucketIamPolicy"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/backend_bucket_signed_url_key.py

@@ -184,6 +184,9 @@ class _BackendBucketSignedUrlKeyState:
 
 
 class BackendBucketSignedUrlKey(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/backendBucketSignedUrlKey:BackendBucketSignedUrlKey"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/backend_service.py

@@ -42,6 +42,7 @@ class BackendServiceArgs:
                  locality_lb_policies: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceLocalityLbPolicyArgs']]]] = None,
                  locality_lb_policy: Optional[pulumi.Input[builtins.str]] = None,
                  log_config: Optional[pulumi.Input['BackendServiceLogConfigArgs']] = None,
+                 max_stream_duration: Optional[pulumi.Input['BackendServiceMaxStreamDurationArgs']] = None,
                  name: Optional[pulumi.Input[builtins.str]] = None,
                  outlier_detection: Optional[pulumi.Input['BackendServiceOutlierDetectionArgs']] = None,
                  port_name: Optional[pulumi.Input[builtins.str]] = None,
@@ -169,6 +170,13 @@ class BackendServiceArgs:
         :param pulumi.Input['BackendServiceLogConfigArgs'] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
+        :param pulumi.Input['BackendServiceMaxStreamDurationArgs'] max_stream_duration: Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+               beginning of the stream until the response has been completely processed, including all retries. A stream that
+               does not complete in this duration is closed.
+               If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+               This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+               This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] name: Name of the resource. Provided by the client when the resource is
                created. The name must be 1-63 characters long, and comply with
                RFC1035. Specifically, the name must be 1-63 characters long and match
@@ -254,6 +262,8 @@ class BackendServiceArgs:
             pulumi.set(__self__, "locality_lb_policy", locality_lb_policy)
         if log_config is not None:
             pulumi.set(__self__, "log_config", log_config)
+        if max_stream_duration is not None:
+            pulumi.set(__self__, "max_stream_duration", max_stream_duration)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if outlier_detection is not None:
@@ -612,6 +622,24 @@ class BackendServiceArgs:
     def log_config(self, value: Optional[pulumi.Input['BackendServiceLogConfigArgs']]):
         pulumi.set(self, "log_config", value)
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> Optional[pulumi.Input['BackendServiceMaxStreamDurationArgs']]:
+        """
+        Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+        beginning of the stream until the response has been completely processed, including all retries. A stream that
+        does not complete in this duration is closed.
+        If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+        This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+        This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "max_stream_duration")
+
+    @max_stream_duration.setter
+    def max_stream_duration(self, value: Optional[pulumi.Input['BackendServiceMaxStreamDurationArgs']]):
+        pulumi.set(self, "max_stream_duration", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -815,6 +843,7 @@ class _BackendServiceState:
                  locality_lb_policies: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceLocalityLbPolicyArgs']]]] = None,
                  locality_lb_policy: Optional[pulumi.Input[builtins.str]] = None,
                  log_config: Optional[pulumi.Input['BackendServiceLogConfigArgs']] = None,
+                 max_stream_duration: Optional[pulumi.Input['BackendServiceMaxStreamDurationArgs']] = None,
                  name: Optional[pulumi.Input[builtins.str]] = None,
                  outlier_detection: Optional[pulumi.Input['BackendServiceOutlierDetectionArgs']] = None,
                  port_name: Optional[pulumi.Input[builtins.str]] = None,
@@ -947,6 +976,13 @@ class _BackendServiceState:
         :param pulumi.Input['BackendServiceLogConfigArgs'] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
+        :param pulumi.Input['BackendServiceMaxStreamDurationArgs'] max_stream_duration: Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+               beginning of the stream until the response has been completely processed, including all retries. A stream that
+               does not complete in this duration is closed.
+               If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+               This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+               This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] name: Name of the resource. Provided by the client when the resource is
                created. The name must be 1-63 characters long, and comply with
                RFC1035. Specifically, the name must be 1-63 characters long and match
@@ -1039,6 +1075,8 @@ class _BackendServiceState:
             pulumi.set(__self__, "locality_lb_policy", locality_lb_policy)
         if log_config is not None:
             pulumi.set(__self__, "log_config", log_config)
+        if max_stream_duration is not None:
+            pulumi.set(__self__, "max_stream_duration", max_stream_duration)
         if name is not None:
             pulumi.set(__self__, "name", name)
         if outlier_detection is not None:
@@ -1436,6 +1474,24 @@ class _BackendServiceState:
     def log_config(self, value: Optional[pulumi.Input['BackendServiceLogConfigArgs']]):
         pulumi.set(self, "log_config", value)
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> Optional[pulumi.Input['BackendServiceMaxStreamDurationArgs']]:
+        """
+        Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+        beginning of the stream until the response has been completely processed, including all retries. A stream that
+        does not complete in this duration is closed.
+        If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+        This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+        This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "max_stream_duration")
+
+    @max_stream_duration.setter
+    def max_stream_duration(self, value: Optional[pulumi.Input['BackendServiceMaxStreamDurationArgs']]):
+        pulumi.set(self, "max_stream_duration", value)
+
     @property
     @pulumi.getter
     def name(self) -> Optional[pulumi.Input[builtins.str]]:
@@ -1626,6 +1682,9 @@ class _BackendServiceState:
 
 
 class BackendService(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/backendService:BackendService"
+
     @overload
     def __init__(__self__,
                  resource_name: str,
@@ -1650,6 +1709,7 @@ class BackendService(pulumi.CustomResource):
                  locality_lb_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['BackendServiceLocalityLbPolicyArgs', 'BackendServiceLocalityLbPolicyArgsDict']]]]] = None,
                  locality_lb_policy: Optional[pulumi.Input[builtins.str]] = None,
                  log_config: Optional[pulumi.Input[Union['BackendServiceLogConfigArgs', 'BackendServiceLogConfigArgsDict']]] = None,
+                 max_stream_duration: Optional[pulumi.Input[Union['BackendServiceMaxStreamDurationArgs', 'BackendServiceMaxStreamDurationArgsDict']]] = None,
                  name: Optional[pulumi.Input[builtins.str]] = None,
                  outlier_detection: Optional[pulumi.Input[Union['BackendServiceOutlierDetectionArgs', 'BackendServiceOutlierDetectionArgsDict']]] = None,
                  port_name: Optional[pulumi.Input[builtins.str]] = None,
@@ -1671,6 +1731,9 @@ class BackendService(pulumi.CustomResource):
 
         Currently self-managed internal load balancing is only available in beta.
 
+        > **Note:** Recreating a `compute.BackendService` that references other dependent resources like `compute.URLMap` will give a `resourceInUseByAnotherResource` error, when modifying the number of other dependent resources.
+        Use `lifecycle.create_before_destroy` on the dependent resources to avoid this type of error as shown in the Dynamic Backends example.
+
         To get more information about BackendService, see:
 
         * [API documentation](https://cloud.google.com/compute/docs/reference/v1/backendServices)
@@ -2045,7 +2108,6 @@ class BackendService(pulumi.CustomResource):
                 "authentication_config": default_backend_authentication_config.id.apply(lambda id: f"//networksecurity.googleapis.com/{id}"),
             })
         ```
-
         ## Import
 
         BackendService can be imported using any of these accepted formats:
@@ -2185,6 +2247,13 @@ class BackendService(pulumi.CustomResource):
         :param pulumi.Input[Union['BackendServiceLogConfigArgs', 'BackendServiceLogConfigArgsDict']] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
+        :param pulumi.Input[Union['BackendServiceMaxStreamDurationArgs', 'BackendServiceMaxStreamDurationArgsDict']] max_stream_duration: Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+               beginning of the stream until the response has been completely processed, including all retries. A stream that
+               does not complete in this duration is closed.
+               If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+               This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+               This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] name: Name of the resource. Provided by the client when the resource is
                created. The name must be 1-63 characters long, and comply with
                RFC1035. Specifically, the name must be 1-63 characters long and match
@@ -2244,6 +2313,9 @@ class BackendService(pulumi.CustomResource):
 
         Currently self-managed internal load balancing is only available in beta.
 
+        > **Note:** Recreating a `compute.BackendService` that references other dependent resources like `compute.URLMap` will give a `resourceInUseByAnotherResource` error, when modifying the number of other dependent resources.
+        Use `lifecycle.create_before_destroy` on the dependent resources to avoid this type of error as shown in the Dynamic Backends example.
+
         To get more information about BackendService, see:
 
         * [API documentation](https://cloud.google.com/compute/docs/reference/v1/backendServices)
@@ -2618,7 +2690,6 @@ class BackendService(pulumi.CustomResource):
                 "authentication_config": default_backend_authentication_config.id.apply(lambda id: f"//networksecurity.googleapis.com/{id}"),
             })
         ```
-
         ## Import
 
         BackendService can be imported using any of these accepted formats:
@@ -2678,6 +2749,7 @@ class BackendService(pulumi.CustomResource):
                  locality_lb_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['BackendServiceLocalityLbPolicyArgs', 'BackendServiceLocalityLbPolicyArgsDict']]]]] = None,
                  locality_lb_policy: Optional[pulumi.Input[builtins.str]] = None,
                  log_config: Optional[pulumi.Input[Union['BackendServiceLogConfigArgs', 'BackendServiceLogConfigArgsDict']]] = None,
+                 max_stream_duration: Optional[pulumi.Input[Union['BackendServiceMaxStreamDurationArgs', 'BackendServiceMaxStreamDurationArgsDict']]] = None,
                  name: Optional[pulumi.Input[builtins.str]] = None,
                  outlier_detection: Optional[pulumi.Input[Union['BackendServiceOutlierDetectionArgs', 'BackendServiceOutlierDetectionArgsDict']]] = None,
                  port_name: Optional[pulumi.Input[builtins.str]] = None,
@@ -2719,6 +2791,7 @@ class BackendService(pulumi.CustomResource):
             __props__.__dict__["locality_lb_policies"] = locality_lb_policies
             __props__.__dict__["locality_lb_policy"] = locality_lb_policy
             __props__.__dict__["log_config"] = log_config
+            __props__.__dict__["max_stream_duration"] = max_stream_duration
             __props__.__dict__["name"] = name
             __props__.__dict__["outlier_detection"] = outlier_detection
             __props__.__dict__["port_name"] = port_name
@@ -2768,6 +2841,7 @@ class BackendService(pulumi.CustomResource):
             locality_lb_policies: Optional[pulumi.Input[Sequence[pulumi.Input[Union['BackendServiceLocalityLbPolicyArgs', 'BackendServiceLocalityLbPolicyArgsDict']]]]] = None,
             locality_lb_policy: Optional[pulumi.Input[builtins.str]] = None,
             log_config: Optional[pulumi.Input[Union['BackendServiceLogConfigArgs', 'BackendServiceLogConfigArgsDict']]] = None,
+            max_stream_duration: Optional[pulumi.Input[Union['BackendServiceMaxStreamDurationArgs', 'BackendServiceMaxStreamDurationArgsDict']]] = None,
             name: Optional[pulumi.Input[builtins.str]] = None,
             outlier_detection: Optional[pulumi.Input[Union['BackendServiceOutlierDetectionArgs', 'BackendServiceOutlierDetectionArgsDict']]] = None,
             port_name: Optional[pulumi.Input[builtins.str]] = None,
@@ -2905,6 +2979,13 @@ class BackendService(pulumi.CustomResource):
         :param pulumi.Input[Union['BackendServiceLogConfigArgs', 'BackendServiceLogConfigArgsDict']] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
+        :param pulumi.Input[Union['BackendServiceMaxStreamDurationArgs', 'BackendServiceMaxStreamDurationArgsDict']] max_stream_duration: Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+               beginning of the stream until the response has been completely processed, including all retries. A stream that
+               does not complete in this duration is closed.
+               If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+               This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+               This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+               Structure is documented below.
         :param pulumi.Input[builtins.str] name: Name of the resource. Provided by the client when the resource is
                created. The name must be 1-63 characters long, and comply with
                RFC1035. Specifically, the name must be 1-63 characters long and match
@@ -2978,6 +3059,7 @@ class BackendService(pulumi.CustomResource):
         __props__.__dict__["locality_lb_policies"] = locality_lb_policies
         __props__.__dict__["locality_lb_policy"] = locality_lb_policy
         __props__.__dict__["log_config"] = log_config
+        __props__.__dict__["max_stream_duration"] = max_stream_duration
         __props__.__dict__["name"] = name
         __props__.__dict__["outlier_detection"] = outlier_detection
         __props__.__dict__["port_name"] = port_name
@@ -3271,6 +3353,20 @@ class BackendService(pulumi.CustomResource):
         """
         return pulumi.get(self, "log_config")
 
+    @property
+    @pulumi.getter(name="maxStreamDuration")
+    def max_stream_duration(self) -> pulumi.Output[Optional['outputs.BackendServiceMaxStreamDuration']]:
+        """
+        Specifies the default maximum duration (timeout) for streams to this service. Duration is computed from the
+        beginning of the stream until the response has been completely processed, including all retries. A stream that
+        does not complete in this duration is closed.
+        If not specified, there will be no timeout limit, i.e. the maximum duration is infinite.
+        This value can be overridden in the PathMatcher configuration of the UrlMap that references this backend service.
+        This field is only allowed when the loadBalancingScheme of the backend service is INTERNAL_SELF_MANAGED.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "max_stream_duration")
+
     @property
     @pulumi.getter
     def name(self) -> pulumi.Output[builtins.str]:

pulumi_gcp/compute/backend_service_iam_binding.py

@@ -266,6 +266,9 @@ class _BackendServiceIamBindingState:
 
 
 class BackendServiceIamBinding(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/backendServiceIamBinding:BackendServiceIamBinding"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/backend_service_iam_member.py

@@ -266,6 +266,9 @@ class _BackendServiceIamMemberState:
 
 
 class BackendServiceIamMember(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/backendServiceIamMember:BackendServiceIamMember"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/backend_service_iam_policy.py

@@ -153,6 +153,9 @@ class _BackendServiceIamPolicyState:
 
 
 class BackendServiceIamPolicy(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/backendServiceIamPolicy:BackendServiceIamPolicy"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/backend_service_signed_url_key.py

@@ -184,6 +184,9 @@ class _BackendServiceSignedUrlKeyState:
 
 
 class BackendServiceSignedUrlKey(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/backendServiceSignedUrlKey:BackendServiceSignedUrlKey"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/ca_external_account_key.py

@@ -182,6 +182,9 @@ class _CaExternalAccountKeyState:
 
 
 class CaExternalAccountKey(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/caExternalAccountKey:CaExternalAccountKey"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/disk.py

@@ -1676,6 +1676,9 @@ class _DiskState:
 
 
 class Disk(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/disk:Disk"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/disk_async_replication.py

@@ -106,6 +106,9 @@ class _DiskAsyncReplicationState:
 
 
 class DiskAsyncReplication(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/diskAsyncReplication:DiskAsyncReplication"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/disk_iam_binding.py

@@ -294,6 +294,9 @@ class _DiskIamBindingState:
 
 
 class DiskIamBinding(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/diskIamBinding:DiskIamBinding"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/disk_iam_member.py

@@ -294,6 +294,9 @@ class _DiskIamMemberState:
 
 
 class DiskIamMember(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/diskIamMember:DiskIamMember"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/disk_iam_policy.py

@@ -193,6 +193,9 @@ class _DiskIamPolicyState:
 
 
 class DiskIamPolicy(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/diskIamPolicy:DiskIamPolicy"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/disk_resource_policy_attachment.py

@@ -181,6 +181,9 @@ class _DiskResourcePolicyAttachmentState:
 
 
 class DiskResourcePolicyAttachment(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/diskResourcePolicyAttachment:DiskResourcePolicyAttachment"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/external_vpn_gateway.py

@@ -352,6 +352,9 @@ class _ExternalVpnGatewayState:
 
 
 class ExternalVpnGateway(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/externalVpnGateway:ExternalVpnGateway"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/firewall.py

@@ -891,6 +891,9 @@ class _FirewallState:
 
 
 class Firewall(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/firewall:Firewall"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/firewall_policy.py

@@ -260,6 +260,9 @@ class _FirewallPolicyState:
 
 
 class FirewallPolicy(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/firewallPolicy:FirewallPolicy"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/firewall_policy_association.py

@@ -172,6 +172,9 @@ class _FirewallPolicyAssociationState:
 
 
 class FirewallPolicyAssociation(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/firewallPolicyAssociation:FirewallPolicyAssociation"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/firewall_policy_rule.py

@@ -507,6 +507,9 @@ class _FirewallPolicyRuleState:
 
 
 class FirewallPolicyRule(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/firewallPolicyRule:FirewallPolicyRule"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/firewall_policy_with_rules.py

@@ -287,6 +287,9 @@ class _FirewallPolicyWithRulesState:
 
 
 class FirewallPolicyWithRules(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/firewallPolicyWithRules:FirewallPolicyWithRules"
+
     @overload
     def __init__(__self__,
                  resource_name: str,
@@ -338,7 +341,7 @@ class FirewallPolicyWithRules(pulumi.CustomResource):
                     "enable_logging": True,
                     "action": "allow",
                     "direction": "EGRESS",
-                    "target_resources": [f"https://www.googleapis.com/compute/beta/projects/{project.name}/global/networks/default"],
+                    "target_resources": [f"https://www.googleapis.com/compute/beta/projects/{project.project_id}/global/networks/default"],
                     "match": {
                         "dest_ip_ranges": ["11.100.0.1/32"],
                         "dest_fqdns": [
@@ -519,7 +522,7 @@ class FirewallPolicyWithRules(pulumi.CustomResource):
                     "enable_logging": True,
                     "action": "allow",
                     "direction": "EGRESS",
-                    "target_resources": [f"https://www.googleapis.com/compute/beta/projects/{project.name}/global/networks/default"],
+                    "target_resources": [f"https://www.googleapis.com/compute/beta/projects/{project.project_id}/global/networks/default"],
                     "match": {
                         "dest_ip_ranges": ["11.100.0.1/32"],
                         "dest_fqdns": [

pulumi_gcp/compute/forwarding_rule.py

@@ -1738,6 +1738,9 @@ class _ForwardingRuleState:
 
 
 class ForwardingRule(pulumi.CustomResource):
+
+    pulumi_type = "gcp:compute/forwardingRule:ForwardingRule"
+
     @overload
     def __init__(__self__,
                  resource_name: str,

pulumi_gcp/compute/get_backend_service.py

@@ -28,7 +28,7 @@ class GetBackendServiceResult:
     """
     A collection of values returned by getBackendService.
     """
-    def __init__(__self__, affinity_cookie_ttl_sec=None, backends=None, cdn_policies=None, circuit_breakers=None, compression_mode=None, connection_draining_timeout_sec=None, consistent_hash=None, creation_timestamp=None, custom_metrics=None, custom_request_headers=None, custom_response_headers=None, description=None, edge_security_policy=None, enable_cdn=None, fingerprint=None, generated_id=None, health_checks=None, iaps=None, id=None, ip_address_selection_policy=None, load_balancing_scheme=None, locality_lb_policies=None, locality_lb_policy=None, log_configs=None, name=None, outlier_detections=None, port_name=None, project=None, protocol=None, security_policy=None, security_settings=None, self_link=None, service_lb_policy=None, session_affinity=None, strong_session_affinity_cookies=None, timeout_sec=None, tls_settings=None):
+    def __init__(__self__, affinity_cookie_ttl_sec=None, backends=None, cdn_policies=None, circuit_breakers=None, compression_mode=None, connection_draining_timeout_sec=None, consistent_hash=None, creation_timestamp=None, custom_metrics=None, custom_request_headers=None, custom_response_headers=None, description=None, edge_security_policy=None, enable_cdn=None, fingerprint=None, generated_id=None, health_checks=None, iaps=None, id=None, ip_address_selection_policy=None, load_balancing_scheme=None, locality_lb_policies=None, locality_lb_policy=None, log_configs=None, max_stream_durations=None, name=None, outlier_detections=None, port_name=None, project=None, protocol=None, security_policy=None, security_settings=None, self_link=None, service_lb_policy=None, session_affinity=None, strong_session_affinity_cookies=None, timeout_sec=None, tls_settings=None):
         if affinity_cookie_ttl_sec and not isinstance(affinity_cookie_ttl_sec, int):
             raise TypeError("Expected argument 'affinity_cookie_ttl_sec' to be a int")
         pulumi.set(__self__, "affinity_cookie_ttl_sec", affinity_cookie_ttl_sec)
@@ -101,6 +101,9 @@ class GetBackendServiceResult:
         if log_configs and not isinstance(log_configs, list):
             raise TypeError("Expected argument 'log_configs' to be a list")
         pulumi.set(__self__, "log_configs", log_configs)
+        if max_stream_durations and not isinstance(max_stream_durations, list):
+            raise TypeError("Expected argument 'max_stream_durations' to be a list")
+        pulumi.set(__self__, "max_stream_durations", max_stream_durations)
         if name and not isinstance(name, str):
             raise TypeError("Expected argument 'name' to be a str")
         pulumi.set(__self__, "name", name)
@@ -285,6 +288,11 @@ class GetBackendServiceResult:
     def log_configs(self) -> Sequence['outputs.GetBackendServiceLogConfigResult']:
         return pulumi.get(self, "log_configs")
 
+    @property
+    @pulumi.getter(name="maxStreamDurations")
+    def max_stream_durations(self) -> Sequence['outputs.GetBackendServiceMaxStreamDurationResult']:
+        return pulumi.get(self, "max_stream_durations")
+
     @property
     @pulumi.getter
     def name(self) -> builtins.str:
@@ -396,6 +404,7 @@ class AwaitableGetBackendServiceResult(GetBackendServiceResult):
             locality_lb_policies=self.locality_lb_policies,
             locality_lb_policy=self.locality_lb_policy,
             log_configs=self.log_configs,
+            max_stream_durations=self.max_stream_durations,
             name=self.name,
             outlier_detections=self.outlier_detections,
             port_name=self.port_name,
@@ -468,6 +477,7 @@ def get_backend_service(name: Optional[builtins.str] = None,
         locality_lb_policies=pulumi.get(__ret__, 'locality_lb_policies'),
         locality_lb_policy=pulumi.get(__ret__, 'locality_lb_policy'),
         log_configs=pulumi.get(__ret__, 'log_configs'),
+        max_stream_durations=pulumi.get(__ret__, 'max_stream_durations'),
         name=pulumi.get(__ret__, 'name'),
         outlier_detections=pulumi.get(__ret__, 'outlier_detections'),
         port_name=pulumi.get(__ret__, 'port_name'),
@@ -537,6 +547,7 @@ def get_backend_service_output(name: Optional[pulumi.Input[builtins.str]] = None
         locality_lb_policies=pulumi.get(__response__, 'locality_lb_policies'),
         locality_lb_policy=pulumi.get(__response__, 'locality_lb_policy'),
         log_configs=pulumi.get(__response__, 'log_configs'),
+        max_stream_durations=pulumi.get(__response__, 'max_stream_durations'),
         name=pulumi.get(__response__, 'name'),
         outlier_detections=pulumi.get(__response__, 'outlier_detections'),
         port_name=pulumi.get(__response__, 'port_name'),