pulumi-gcp 7.30.0__py3-none-any.whl → 7.30.0a1719470057__py3-none-any.whl

pulumi_gcp/compute/region_backend_service.py

@@ -4,14 +4,9 @@
 
 import copy
 import warnings
-import sys
 import pulumi
 import pulumi.runtime
 from typing import Any, Mapping, Optional, Sequence, Union, overload
-if sys.version_info >= (3, 11):
-    from typing import NotRequired, TypedDict, TypeAlias
-else:
-    from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 from . import outputs
 from ._inputs import *
@@ -125,6 +120,7 @@ class RegionBackendServiceArgs:
                instance either reported a valid weight or had
                UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
                equal-weight.
+               
                This field is applicable to either:
                * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
                and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -132,6 +128,7 @@ class RegionBackendServiceArgs:
                * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
                Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
                Network Load Balancing. The default is MAGLEV.
+               
                If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
                or RING_HASH, session affinity settings will not take effect.
                Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced
@@ -455,6 +452,7 @@ class RegionBackendServiceArgs:
         instance either reported a valid weight or had
         UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
         equal-weight.
+
         This field is applicable to either:
         * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
         and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -462,6 +460,7 @@ class RegionBackendServiceArgs:
         * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
         Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
         Network Load Balancing. The default is MAGLEV.
+
         If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
         or RING_HASH, session affinity settings will not take effect.
         Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced
@@ -761,6 +760,7 @@ class _RegionBackendServiceState:
                instance either reported a valid weight or had
                UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
                equal-weight.
+               
                This field is applicable to either:
                * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
                and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -768,6 +768,7 @@ class _RegionBackendServiceState:
                * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
                Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
                Network Load Balancing. The default is MAGLEV.
+               
                If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
                or RING_HASH, session affinity settings will not take effect.
                Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced
@@ -1137,6 +1138,7 @@ class _RegionBackendServiceState:
         instance either reported a valid weight or had
         UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
         equal-weight.
+
         This field is applicable to either:
         * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
         and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -1144,6 +1146,7 @@ class _RegionBackendServiceState:
         * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
         Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
         Network Load Balancing. The default is MAGLEV.
+
         If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
         or RING_HASH, session affinity settings will not take effect.
         Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced
@@ -1346,30 +1349,30 @@ class RegionBackendService(pulumi.CustomResource):
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
                  affinity_cookie_ttl_sec: Optional[pulumi.Input[int]] = None,
-                 backends: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RegionBackendServiceBackendArgs', 'RegionBackendServiceBackendArgsDict']]]]] = None,
-                 cdn_policy: Optional[pulumi.Input[Union['RegionBackendServiceCdnPolicyArgs', 'RegionBackendServiceCdnPolicyArgsDict']]] = None,
-                 circuit_breakers: Optional[pulumi.Input[Union['RegionBackendServiceCircuitBreakersArgs', 'RegionBackendServiceCircuitBreakersArgsDict']]] = None,
+                 backends: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['RegionBackendServiceBackendArgs']]]]] = None,
+                 cdn_policy: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceCdnPolicyArgs']]] = None,
+                 circuit_breakers: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceCircuitBreakersArgs']]] = None,
                  connection_draining_timeout_sec: Optional[pulumi.Input[int]] = None,
-                 connection_tracking_policy: Optional[pulumi.Input[Union['RegionBackendServiceConnectionTrackingPolicyArgs', 'RegionBackendServiceConnectionTrackingPolicyArgsDict']]] = None,
-                 consistent_hash: Optional[pulumi.Input[Union['RegionBackendServiceConsistentHashArgs', 'RegionBackendServiceConsistentHashArgsDict']]] = None,
+                 connection_tracking_policy: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceConnectionTrackingPolicyArgs']]] = None,
+                 consistent_hash: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceConsistentHashArgs']]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  enable_cdn: Optional[pulumi.Input[bool]] = None,
-                 failover_policy: Optional[pulumi.Input[Union['RegionBackendServiceFailoverPolicyArgs', 'RegionBackendServiceFailoverPolicyArgsDict']]] = None,
+                 failover_policy: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceFailoverPolicyArgs']]] = None,
                  health_checks: Optional[pulumi.Input[str]] = None,
-                 iap: Optional[pulumi.Input[Union['RegionBackendServiceIapArgs', 'RegionBackendServiceIapArgsDict']]] = None,
+                 iap: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceIapArgs']]] = None,
                  load_balancing_scheme: Optional[pulumi.Input[str]] = None,
                  locality_lb_policy: Optional[pulumi.Input[str]] = None,
-                 log_config: Optional[pulumi.Input[Union['RegionBackendServiceLogConfigArgs', 'RegionBackendServiceLogConfigArgsDict']]] = None,
+                 log_config: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceLogConfigArgs']]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  network: Optional[pulumi.Input[str]] = None,
-                 outlier_detection: Optional[pulumi.Input[Union['RegionBackendServiceOutlierDetectionArgs', 'RegionBackendServiceOutlierDetectionArgsDict']]] = None,
+                 outlier_detection: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceOutlierDetectionArgs']]] = None,
                  port_name: Optional[pulumi.Input[str]] = None,
                  project: Optional[pulumi.Input[str]] = None,
                  protocol: Optional[pulumi.Input[str]] = None,
                  region: Optional[pulumi.Input[str]] = None,
                  security_policy: Optional[pulumi.Input[str]] = None,
                  session_affinity: Optional[pulumi.Input[str]] = None,
-                 subsetting: Optional[pulumi.Input[Union['RegionBackendServiceSubsettingArgs', 'RegionBackendServiceSubsettingArgsDict']]] = None,
+                 subsetting: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceSubsettingArgs']]] = None,
                  timeout_sec: Optional[pulumi.Input[int]] = None,
                  __props__=None):
         """
@@ -1394,9 +1397,9 @@ class RegionBackendService(pulumi.CustomResource):
             name="rbs-health-check",
             check_interval_sec=1,
             timeout_sec=1,
-            tcp_health_check={
-                "port": 80,
-            })
+            tcp_health_check=gcp.compute.HealthCheckTcpHealthCheckArgs(
+                port=80,
+            ))
         default = gcp.compute.RegionBackendService("default",
             name="region-service",
             region="us-central1",
@@ -1415,10 +1418,10 @@ class RegionBackendService(pulumi.CustomResource):
             region="us-central1",
             protocol="HTTP",
             load_balancing_scheme="EXTERNAL",
-            iap={
-                "oauth2ClientId": "abc",
-                "oauth2ClientSecret": "xyz",
-            })
+            iap=gcp.compute.RegionBackendServiceIapArgs(
+                oauth2_client_id="abc",
+                oauth2_client_secret="xyz",
+            ))
         ```
         ### Region Backend Service Cache
 
@@ -1429,22 +1432,22 @@ class RegionBackendService(pulumi.CustomResource):
         default_region_health_check = gcp.compute.RegionHealthCheck("default",
             name="rbs-health-check",
             region="us-central1",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         default = gcp.compute.RegionBackendService("default",
             name="region-service",
             region="us-central1",
             health_checks=default_region_health_check.id,
             enable_cdn=True,
-            cdn_policy={
-                "cacheMode": "CACHE_ALL_STATIC",
-                "defaultTtl": 3600,
-                "clientTtl": 7200,
-                "maxTtl": 10800,
-                "negativeCaching": True,
-                "signedUrlCacheMaxAgeSec": 7200,
-            },
+            cdn_policy=gcp.compute.RegionBackendServiceCdnPolicyArgs(
+                cache_mode="CACHE_ALL_STATIC",
+                default_ttl=3600,
+                client_ttl=7200,
+                max_ttl=10800,
+                negative_caching=True,
+                signed_url_cache_max_age_sec=7200,
+            ),
             load_balancing_scheme="EXTERNAL",
             protocol="HTTP")
         ```
@@ -1456,9 +1459,9 @@ class RegionBackendService(pulumi.CustomResource):
 
         health_check = gcp.compute.HealthCheck("health_check",
             name="rbs-health-check",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.HealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         default = gcp.compute.RegionBackendService("default",
             region="us-central1",
             name="region-service",
@@ -1476,9 +1479,9 @@ class RegionBackendService(pulumi.CustomResource):
         health_check = gcp.compute.RegionHealthCheck("health_check",
             name="rbs-health-check",
             region="us-central1",
-            tcp_health_check={
-                "port": 80,
-            })
+            tcp_health_check=gcp.compute.RegionHealthCheckTcpHealthCheckArgs(
+                port=80,
+            ))
         default = gcp.compute.RegionBackendService("default",
             region="us-central1",
             name="region-service",
@@ -1495,9 +1498,9 @@ class RegionBackendService(pulumi.CustomResource):
         health_check = gcp.compute.RegionHealthCheck("health_check",
             name="rbs-health-check",
             region="us-central1",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         default = gcp.compute.RegionBackendService("default",
             region="us-central1",
             name="region-service",
@@ -1514,9 +1517,9 @@ class RegionBackendService(pulumi.CustomResource):
 
         health_check = gcp.compute.HealthCheck("health_check",
             name="rbs-health-check",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.HealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         default = gcp.compute.RegionBackendService("default",
             region="us-central1",
             name="region-service",
@@ -1525,21 +1528,21 @@ class RegionBackendService(pulumi.CustomResource):
             locality_lb_policy="RING_HASH",
             session_affinity="HTTP_COOKIE",
             protocol="HTTP",
-            circuit_breakers={
-                "maxConnections": 10,
-            },
-            consistent_hash={
-                "httpCookie": {
-                    "ttl": {
-                        "seconds": 11,
-                        "nanos": 1111,
-                    },
-                    "name": "mycookie",
-                },
-            },
-            outlier_detection={
-                "consecutiveErrors": 2,
-            })
+            circuit_breakers=gcp.compute.RegionBackendServiceCircuitBreakersArgs(
+                max_connections=10,
+            ),
+            consistent_hash=gcp.compute.RegionBackendServiceConsistentHashArgs(
+                http_cookie=gcp.compute.RegionBackendServiceConsistentHashHttpCookieArgs(
+                    ttl=gcp.compute.RegionBackendServiceConsistentHashHttpCookieTtlArgs(
+                        seconds=11,
+                        nanos=1111,
+                    ),
+                    name="mycookie",
+                ),
+            ),
+            outlier_detection=gcp.compute.RegionBackendServiceOutlierDetectionArgs(
+                consecutive_errors=2,
+            ))
         ```
         ### Region Backend Service Balancing Mode
 
@@ -1561,15 +1564,15 @@ class RegionBackendService(pulumi.CustomResource):
         instance_template = gcp.compute.InstanceTemplate("instance_template",
             name="template-region-service",
             machine_type="e2-medium",
-            network_interfaces=[{
-                "network": default_network.id,
-                "subnetwork": default_subnetwork.id,
-            }],
-            disks=[{
-                "sourceImage": debian_image.self_link,
-                "autoDelete": True,
-                "boot": True,
-            }],
+            network_interfaces=[gcp.compute.InstanceTemplateNetworkInterfaceArgs(
+                network=default_network.id,
+                subnetwork=default_subnetwork.id,
+            )],
+            disks=[gcp.compute.InstanceTemplateDiskArgs(
+                source_image=debian_image.self_link,
+                auto_delete=True,
+                boot=True,
+            )],
             tags=[
                 "allow-ssh",
                 "load-balanced-backend",
@@ -1577,25 +1580,25 @@ class RegionBackendService(pulumi.CustomResource):
         rigm = gcp.compute.RegionInstanceGroupManager("rigm",
             region="us-central1",
             name="rbs-rigm",
-            versions=[{
-                "instanceTemplate": instance_template.id,
-                "name": "primary",
-            }],
+            versions=[gcp.compute.RegionInstanceGroupManagerVersionArgs(
+                instance_template=instance_template.id,
+                name="primary",
+            )],
             base_instance_name="internal-glb",
             target_size=1)
         default_region_health_check = gcp.compute.RegionHealthCheck("default",
             region="us-central1",
             name="rbs-health-check",
-            http_health_check={
-                "portSpecification": "USE_SERVING_PORT",
-            })
+            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
+                port_specification="USE_SERVING_PORT",
+            ))
         default = gcp.compute.RegionBackendService("default",
             load_balancing_scheme="INTERNAL_MANAGED",
-            backends=[{
-                "group": rigm.instance_group,
-                "balancingMode": "UTILIZATION",
-                "capacityScaler": 1,
-            }],
+            backends=[gcp.compute.RegionBackendServiceBackendArgs(
+                group=rigm.instance_group,
+                balancing_mode="UTILIZATION",
+                capacity_scaler=1,
+            )],
             region="us-central1",
             name="region-service",
             protocol="HTTP",
@@ -1611,9 +1614,9 @@ class RegionBackendService(pulumi.CustomResource):
         health_check = gcp.compute.RegionHealthCheck("health_check",
             name="rbs-health-check",
             region="us-central1",
-            tcp_health_check={
-                "port": 22,
-            })
+            tcp_health_check=gcp.compute.RegionHealthCheckTcpHealthCheckArgs(
+                port=22,
+            ))
         default = gcp.compute.RegionBackendService("default",
             name="region-service",
             region="us-central1",
@@ -1622,12 +1625,12 @@ class RegionBackendService(pulumi.CustomResource):
             session_affinity="CLIENT_IP",
             protocol="TCP",
             load_balancing_scheme="EXTERNAL",
-            connection_tracking_policy={
-                "trackingMode": "PER_SESSION",
-                "connectionPersistenceOnUnhealthyBackends": "NEVER_PERSIST",
-                "idleTimeoutSec": 60,
-                "enableStrongAffinity": True,
-            })
+            connection_tracking_policy=gcp.compute.RegionBackendServiceConnectionTrackingPolicyArgs(
+                tracking_mode="PER_SESSION",
+                connection_persistence_on_unhealthy_backends="NEVER_PERSIST",
+                idle_timeout_sec=60,
+                enable_strong_affinity=True,
+            ))
         ```
 
         ## Import
@@ -1667,22 +1670,22 @@ class RegionBackendService(pulumi.CustomResource):
                only until the end of the browser session (or equivalent). The
                maximum allowed value for TTL is one day.
                When the load balancing scheme is INTERNAL, this field is not used.
-        :param pulumi.Input[Sequence[pulumi.Input[Union['RegionBackendServiceBackendArgs', 'RegionBackendServiceBackendArgsDict']]]] backends: The set of backends that serve this RegionBackendService.
+        :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['RegionBackendServiceBackendArgs']]]] backends: The set of backends that serve this RegionBackendService.
                Structure is documented below.
-        :param pulumi.Input[Union['RegionBackendServiceCdnPolicyArgs', 'RegionBackendServiceCdnPolicyArgsDict']] cdn_policy: Cloud CDN configuration for this BackendService.
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceCdnPolicyArgs']] cdn_policy: Cloud CDN configuration for this BackendService.
                Structure is documented below.
-        :param pulumi.Input[Union['RegionBackendServiceCircuitBreakersArgs', 'RegionBackendServiceCircuitBreakersArgsDict']] circuit_breakers: Settings controlling the volume of connections to a backend service. This field
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceCircuitBreakersArgs']] circuit_breakers: Settings controlling the volume of connections to a backend service. This field
                is applicable only when the `load_balancing_scheme` is set to INTERNAL_MANAGED
                and the `protocol` is set to HTTP, HTTPS, or HTTP2.
                Structure is documented below.
         :param pulumi.Input[int] connection_draining_timeout_sec: Time for which instance will be drained (not accept new
                connections, but still work to finish started).
                From version 6.0.0 ConnectionDrainingTimeoutSec default value will be 300 to match default GCP value.
-        :param pulumi.Input[Union['RegionBackendServiceConnectionTrackingPolicyArgs', 'RegionBackendServiceConnectionTrackingPolicyArgsDict']] connection_tracking_policy: Connection Tracking configuration for this BackendService.
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceConnectionTrackingPolicyArgs']] connection_tracking_policy: Connection Tracking configuration for this BackendService.
                This is available only for Layer 4 Internal Load Balancing and
                Network Load Balancing.
                Structure is documented below.
-        :param pulumi.Input[Union['RegionBackendServiceConsistentHashArgs', 'RegionBackendServiceConsistentHashArgsDict']] consistent_hash: Consistent Hash-based load balancing can be used to provide soft session
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceConsistentHashArgs']] consistent_hash: Consistent Hash-based load balancing can be used to provide soft session
                affinity based on HTTP headers, cookies or other properties. This load balancing
                policy is applicable only for HTTP connections. The affinity to a particular
                destination host will be lost when one or more hosts are added/removed from the
@@ -1691,14 +1694,14 @@ class RegionBackendService(pulumi.CustomResource):
                This field only applies when all of the following are true -
         :param pulumi.Input[str] description: An optional description of this resource.
         :param pulumi.Input[bool] enable_cdn: If true, enable Cloud CDN for this RegionBackendService.
-        :param pulumi.Input[Union['RegionBackendServiceFailoverPolicyArgs', 'RegionBackendServiceFailoverPolicyArgsDict']] failover_policy: Policy for failovers.
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceFailoverPolicyArgs']] failover_policy: Policy for failovers.
                Structure is documented below.
         :param pulumi.Input[str] health_checks: The set of URLs to HealthCheck resources for health checking
                this RegionBackendService. Currently at most one health
                check can be specified.
                A health check must be specified unless the backend service uses an internet
                or serverless NEG as a backend.
-        :param pulumi.Input[Union['RegionBackendServiceIapArgs', 'RegionBackendServiceIapArgsDict']] iap: Settings for enabling Cloud Identity Aware Proxy
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceIapArgs']] iap: Settings for enabling Cloud Identity Aware Proxy
                Structure is documented below.
         :param pulumi.Input[str] load_balancing_scheme: Indicates what kind of load balancing this regional backend service
                will be used for. A backend service created for one type of load
@@ -1738,6 +1741,7 @@ class RegionBackendService(pulumi.CustomResource):
                instance either reported a valid weight or had
                UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
                equal-weight.
+               
                This field is applicable to either:
                * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
                and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -1745,13 +1749,14 @@ class RegionBackendService(pulumi.CustomResource):
                * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
                Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
                Network Load Balancing. The default is MAGLEV.
+               
                If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
                or RING_HASH, session affinity settings will not take effect.
                Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced
                by a URL map that is bound to target gRPC proxy that has validate_for_proxyless
                field set to true.
                Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`.
-        :param pulumi.Input[Union['RegionBackendServiceLogConfigArgs', 'RegionBackendServiceLogConfigArgsDict']] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceLogConfigArgs']] 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[str] name: Name of the resource. Provided by the client when the resource is
@@ -1785,7 +1790,7 @@ class RegionBackendService(pulumi.CustomResource):
         :param pulumi.Input[str] session_affinity: Type of session affinity to use. The default is NONE. Session affinity is
                not applicable if the protocol is UDP.
                Possible values are: `NONE`, `CLIENT_IP`, `CLIENT_IP_PORT_PROTO`, `CLIENT_IP_PROTO`, `GENERATED_COOKIE`, `HEADER_FIELD`, `HTTP_COOKIE`, `CLIENT_IP_NO_DESTINATION`.
-        :param pulumi.Input[Union['RegionBackendServiceSubsettingArgs', 'RegionBackendServiceSubsettingArgsDict']] subsetting: Subsetting configuration for this BackendService. Currently this is applicable only for Internal TCP/UDP load balancing and Internal HTTP(S) load balancing.
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceSubsettingArgs']] subsetting: Subsetting configuration for this BackendService. Currently this is applicable only for Internal TCP/UDP load balancing and Internal HTTP(S) load balancing.
                Structure is documented below.
         :param pulumi.Input[int] timeout_sec: The backend service timeout has a different meaning depending on the type of load balancer.
                For more information see, [Backend service settings](https://cloud.google.com/compute/docs/reference/rest/v1/backendServices).
@@ -1820,9 +1825,9 @@ class RegionBackendService(pulumi.CustomResource):
             name="rbs-health-check",
             check_interval_sec=1,
             timeout_sec=1,
-            tcp_health_check={
-                "port": 80,
-            })
+            tcp_health_check=gcp.compute.HealthCheckTcpHealthCheckArgs(
+                port=80,
+            ))
         default = gcp.compute.RegionBackendService("default",
             name="region-service",
             region="us-central1",
@@ -1841,10 +1846,10 @@ class RegionBackendService(pulumi.CustomResource):
             region="us-central1",
             protocol="HTTP",
             load_balancing_scheme="EXTERNAL",
-            iap={
-                "oauth2ClientId": "abc",
-                "oauth2ClientSecret": "xyz",
-            })
+            iap=gcp.compute.RegionBackendServiceIapArgs(
+                oauth2_client_id="abc",
+                oauth2_client_secret="xyz",
+            ))
         ```
         ### Region Backend Service Cache
 
@@ -1855,22 +1860,22 @@ class RegionBackendService(pulumi.CustomResource):
         default_region_health_check = gcp.compute.RegionHealthCheck("default",
             name="rbs-health-check",
             region="us-central1",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         default = gcp.compute.RegionBackendService("default",
             name="region-service",
             region="us-central1",
             health_checks=default_region_health_check.id,
             enable_cdn=True,
-            cdn_policy={
-                "cacheMode": "CACHE_ALL_STATIC",
-                "defaultTtl": 3600,
-                "clientTtl": 7200,
-                "maxTtl": 10800,
-                "negativeCaching": True,
-                "signedUrlCacheMaxAgeSec": 7200,
-            },
+            cdn_policy=gcp.compute.RegionBackendServiceCdnPolicyArgs(
+                cache_mode="CACHE_ALL_STATIC",
+                default_ttl=3600,
+                client_ttl=7200,
+                max_ttl=10800,
+                negative_caching=True,
+                signed_url_cache_max_age_sec=7200,
+            ),
             load_balancing_scheme="EXTERNAL",
             protocol="HTTP")
         ```
@@ -1882,9 +1887,9 @@ class RegionBackendService(pulumi.CustomResource):
 
         health_check = gcp.compute.HealthCheck("health_check",
             name="rbs-health-check",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.HealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         default = gcp.compute.RegionBackendService("default",
             region="us-central1",
             name="region-service",
@@ -1902,9 +1907,9 @@ class RegionBackendService(pulumi.CustomResource):
         health_check = gcp.compute.RegionHealthCheck("health_check",
             name="rbs-health-check",
             region="us-central1",
-            tcp_health_check={
-                "port": 80,
-            })
+            tcp_health_check=gcp.compute.RegionHealthCheckTcpHealthCheckArgs(
+                port=80,
+            ))
         default = gcp.compute.RegionBackendService("default",
             region="us-central1",
             name="region-service",
@@ -1921,9 +1926,9 @@ class RegionBackendService(pulumi.CustomResource):
         health_check = gcp.compute.RegionHealthCheck("health_check",
             name="rbs-health-check",
             region="us-central1",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         default = gcp.compute.RegionBackendService("default",
             region="us-central1",
             name="region-service",
@@ -1940,9 +1945,9 @@ class RegionBackendService(pulumi.CustomResource):
 
         health_check = gcp.compute.HealthCheck("health_check",
             name="rbs-health-check",
-            http_health_check={
-                "port": 80,
-            })
+            http_health_check=gcp.compute.HealthCheckHttpHealthCheckArgs(
+                port=80,
+            ))
         default = gcp.compute.RegionBackendService("default",
             region="us-central1",
             name="region-service",
@@ -1951,21 +1956,21 @@ class RegionBackendService(pulumi.CustomResource):
             locality_lb_policy="RING_HASH",
             session_affinity="HTTP_COOKIE",
             protocol="HTTP",
-            circuit_breakers={
-                "maxConnections": 10,
-            },
-            consistent_hash={
-                "httpCookie": {
-                    "ttl": {
-                        "seconds": 11,
-                        "nanos": 1111,
-                    },
-                    "name": "mycookie",
-                },
-            },
-            outlier_detection={
-                "consecutiveErrors": 2,
-            })
+            circuit_breakers=gcp.compute.RegionBackendServiceCircuitBreakersArgs(
+                max_connections=10,
+            ),
+            consistent_hash=gcp.compute.RegionBackendServiceConsistentHashArgs(
+                http_cookie=gcp.compute.RegionBackendServiceConsistentHashHttpCookieArgs(
+                    ttl=gcp.compute.RegionBackendServiceConsistentHashHttpCookieTtlArgs(
+                        seconds=11,
+                        nanos=1111,
+                    ),
+                    name="mycookie",
+                ),
+            ),
+            outlier_detection=gcp.compute.RegionBackendServiceOutlierDetectionArgs(
+                consecutive_errors=2,
+            ))
         ```
         ### Region Backend Service Balancing Mode
 
@@ -1987,15 +1992,15 @@ class RegionBackendService(pulumi.CustomResource):
         instance_template = gcp.compute.InstanceTemplate("instance_template",
             name="template-region-service",
             machine_type="e2-medium",
-            network_interfaces=[{
-                "network": default_network.id,
-                "subnetwork": default_subnetwork.id,
-            }],
-            disks=[{
-                "sourceImage": debian_image.self_link,
-                "autoDelete": True,
-                "boot": True,
-            }],
+            network_interfaces=[gcp.compute.InstanceTemplateNetworkInterfaceArgs(
+                network=default_network.id,
+                subnetwork=default_subnetwork.id,
+            )],
+            disks=[gcp.compute.InstanceTemplateDiskArgs(
+                source_image=debian_image.self_link,
+                auto_delete=True,
+                boot=True,
+            )],
             tags=[
                 "allow-ssh",
                 "load-balanced-backend",
@@ -2003,25 +2008,25 @@ class RegionBackendService(pulumi.CustomResource):
         rigm = gcp.compute.RegionInstanceGroupManager("rigm",
             region="us-central1",
             name="rbs-rigm",
-            versions=[{
-                "instanceTemplate": instance_template.id,
-                "name": "primary",
-            }],
+            versions=[gcp.compute.RegionInstanceGroupManagerVersionArgs(
+                instance_template=instance_template.id,
+                name="primary",
+            )],
             base_instance_name="internal-glb",
             target_size=1)
         default_region_health_check = gcp.compute.RegionHealthCheck("default",
             region="us-central1",
             name="rbs-health-check",
-            http_health_check={
-                "portSpecification": "USE_SERVING_PORT",
-            })
+            http_health_check=gcp.compute.RegionHealthCheckHttpHealthCheckArgs(
+                port_specification="USE_SERVING_PORT",
+            ))
         default = gcp.compute.RegionBackendService("default",
             load_balancing_scheme="INTERNAL_MANAGED",
-            backends=[{
-                "group": rigm.instance_group,
-                "balancingMode": "UTILIZATION",
-                "capacityScaler": 1,
-            }],
+            backends=[gcp.compute.RegionBackendServiceBackendArgs(
+                group=rigm.instance_group,
+                balancing_mode="UTILIZATION",
+                capacity_scaler=1,
+            )],
             region="us-central1",
             name="region-service",
             protocol="HTTP",
@@ -2037,9 +2042,9 @@ class RegionBackendService(pulumi.CustomResource):
         health_check = gcp.compute.RegionHealthCheck("health_check",
             name="rbs-health-check",
             region="us-central1",
-            tcp_health_check={
-                "port": 22,
-            })
+            tcp_health_check=gcp.compute.RegionHealthCheckTcpHealthCheckArgs(
+                port=22,
+            ))
         default = gcp.compute.RegionBackendService("default",
             name="region-service",
             region="us-central1",
@@ -2048,12 +2053,12 @@ class RegionBackendService(pulumi.CustomResource):
             session_affinity="CLIENT_IP",
             protocol="TCP",
             load_balancing_scheme="EXTERNAL",
-            connection_tracking_policy={
-                "trackingMode": "PER_SESSION",
-                "connectionPersistenceOnUnhealthyBackends": "NEVER_PERSIST",
-                "idleTimeoutSec": 60,
-                "enableStrongAffinity": True,
-            })
+            connection_tracking_policy=gcp.compute.RegionBackendServiceConnectionTrackingPolicyArgs(
+                tracking_mode="PER_SESSION",
+                connection_persistence_on_unhealthy_backends="NEVER_PERSIST",
+                idle_timeout_sec=60,
+                enable_strong_affinity=True,
+            ))
         ```
 
         ## Import
@@ -2102,30 +2107,30 @@ class RegionBackendService(pulumi.CustomResource):
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
                  affinity_cookie_ttl_sec: Optional[pulumi.Input[int]] = None,
-                 backends: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RegionBackendServiceBackendArgs', 'RegionBackendServiceBackendArgsDict']]]]] = None,
-                 cdn_policy: Optional[pulumi.Input[Union['RegionBackendServiceCdnPolicyArgs', 'RegionBackendServiceCdnPolicyArgsDict']]] = None,
-                 circuit_breakers: Optional[pulumi.Input[Union['RegionBackendServiceCircuitBreakersArgs', 'RegionBackendServiceCircuitBreakersArgsDict']]] = None,
+                 backends: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['RegionBackendServiceBackendArgs']]]]] = None,
+                 cdn_policy: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceCdnPolicyArgs']]] = None,
+                 circuit_breakers: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceCircuitBreakersArgs']]] = None,
                  connection_draining_timeout_sec: Optional[pulumi.Input[int]] = None,
-                 connection_tracking_policy: Optional[pulumi.Input[Union['RegionBackendServiceConnectionTrackingPolicyArgs', 'RegionBackendServiceConnectionTrackingPolicyArgsDict']]] = None,
-                 consistent_hash: Optional[pulumi.Input[Union['RegionBackendServiceConsistentHashArgs', 'RegionBackendServiceConsistentHashArgsDict']]] = None,
+                 connection_tracking_policy: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceConnectionTrackingPolicyArgs']]] = None,
+                 consistent_hash: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceConsistentHashArgs']]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  enable_cdn: Optional[pulumi.Input[bool]] = None,
-                 failover_policy: Optional[pulumi.Input[Union['RegionBackendServiceFailoverPolicyArgs', 'RegionBackendServiceFailoverPolicyArgsDict']]] = None,
+                 failover_policy: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceFailoverPolicyArgs']]] = None,
                  health_checks: Optional[pulumi.Input[str]] = None,
-                 iap: Optional[pulumi.Input[Union['RegionBackendServiceIapArgs', 'RegionBackendServiceIapArgsDict']]] = None,
+                 iap: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceIapArgs']]] = None,
                  load_balancing_scheme: Optional[pulumi.Input[str]] = None,
                  locality_lb_policy: Optional[pulumi.Input[str]] = None,
-                 log_config: Optional[pulumi.Input[Union['RegionBackendServiceLogConfigArgs', 'RegionBackendServiceLogConfigArgsDict']]] = None,
+                 log_config: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceLogConfigArgs']]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  network: Optional[pulumi.Input[str]] = None,
-                 outlier_detection: Optional[pulumi.Input[Union['RegionBackendServiceOutlierDetectionArgs', 'RegionBackendServiceOutlierDetectionArgsDict']]] = None,
+                 outlier_detection: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceOutlierDetectionArgs']]] = None,
                  port_name: Optional[pulumi.Input[str]] = None,
                  project: Optional[pulumi.Input[str]] = None,
                  protocol: Optional[pulumi.Input[str]] = None,
                  region: Optional[pulumi.Input[str]] = None,
                  security_policy: Optional[pulumi.Input[str]] = None,
                  session_affinity: Optional[pulumi.Input[str]] = None,
-                 subsetting: Optional[pulumi.Input[Union['RegionBackendServiceSubsettingArgs', 'RegionBackendServiceSubsettingArgsDict']]] = None,
+                 subsetting: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceSubsettingArgs']]] = None,
                  timeout_sec: Optional[pulumi.Input[int]] = None,
                  __props__=None):
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
@@ -2177,26 +2182,26 @@ class RegionBackendService(pulumi.CustomResource):
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
             affinity_cookie_ttl_sec: Optional[pulumi.Input[int]] = None,
-            backends: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RegionBackendServiceBackendArgs', 'RegionBackendServiceBackendArgsDict']]]]] = None,
-            cdn_policy: Optional[pulumi.Input[Union['RegionBackendServiceCdnPolicyArgs', 'RegionBackendServiceCdnPolicyArgsDict']]] = None,
-            circuit_breakers: Optional[pulumi.Input[Union['RegionBackendServiceCircuitBreakersArgs', 'RegionBackendServiceCircuitBreakersArgsDict']]] = None,
+            backends: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['RegionBackendServiceBackendArgs']]]]] = None,
+            cdn_policy: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceCdnPolicyArgs']]] = None,
+            circuit_breakers: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceCircuitBreakersArgs']]] = None,
             connection_draining_timeout_sec: Optional[pulumi.Input[int]] = None,
-            connection_tracking_policy: Optional[pulumi.Input[Union['RegionBackendServiceConnectionTrackingPolicyArgs', 'RegionBackendServiceConnectionTrackingPolicyArgsDict']]] = None,
-            consistent_hash: Optional[pulumi.Input[Union['RegionBackendServiceConsistentHashArgs', 'RegionBackendServiceConsistentHashArgsDict']]] = None,
+            connection_tracking_policy: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceConnectionTrackingPolicyArgs']]] = None,
+            consistent_hash: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceConsistentHashArgs']]] = None,
             creation_timestamp: Optional[pulumi.Input[str]] = None,
             description: Optional[pulumi.Input[str]] = None,
             enable_cdn: Optional[pulumi.Input[bool]] = None,
-            failover_policy: Optional[pulumi.Input[Union['RegionBackendServiceFailoverPolicyArgs', 'RegionBackendServiceFailoverPolicyArgsDict']]] = None,
+            failover_policy: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceFailoverPolicyArgs']]] = None,
             fingerprint: Optional[pulumi.Input[str]] = None,
             generated_id: Optional[pulumi.Input[int]] = None,
             health_checks: Optional[pulumi.Input[str]] = None,
-            iap: Optional[pulumi.Input[Union['RegionBackendServiceIapArgs', 'RegionBackendServiceIapArgsDict']]] = None,
+            iap: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceIapArgs']]] = None,
             load_balancing_scheme: Optional[pulumi.Input[str]] = None,
             locality_lb_policy: Optional[pulumi.Input[str]] = None,
-            log_config: Optional[pulumi.Input[Union['RegionBackendServiceLogConfigArgs', 'RegionBackendServiceLogConfigArgsDict']]] = None,
+            log_config: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceLogConfigArgs']]] = None,
             name: Optional[pulumi.Input[str]] = None,
             network: Optional[pulumi.Input[str]] = None,
-            outlier_detection: Optional[pulumi.Input[Union['RegionBackendServiceOutlierDetectionArgs', 'RegionBackendServiceOutlierDetectionArgsDict']]] = None,
+            outlier_detection: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceOutlierDetectionArgs']]] = None,
             port_name: Optional[pulumi.Input[str]] = None,
             project: Optional[pulumi.Input[str]] = None,
             protocol: Optional[pulumi.Input[str]] = None,
@@ -2204,7 +2209,7 @@ class RegionBackendService(pulumi.CustomResource):
             security_policy: Optional[pulumi.Input[str]] = None,
             self_link: Optional[pulumi.Input[str]] = None,
             session_affinity: Optional[pulumi.Input[str]] = None,
-            subsetting: Optional[pulumi.Input[Union['RegionBackendServiceSubsettingArgs', 'RegionBackendServiceSubsettingArgsDict']]] = None,
+            subsetting: Optional[pulumi.Input[pulumi.InputType['RegionBackendServiceSubsettingArgs']]] = None,
             timeout_sec: Optional[pulumi.Input[int]] = None) -> 'RegionBackendService':
         """
         Get an existing RegionBackendService resource's state with the given name, id, and optional extra
@@ -2218,22 +2223,22 @@ class RegionBackendService(pulumi.CustomResource):
                only until the end of the browser session (or equivalent). The
                maximum allowed value for TTL is one day.
                When the load balancing scheme is INTERNAL, this field is not used.
-        :param pulumi.Input[Sequence[pulumi.Input[Union['RegionBackendServiceBackendArgs', 'RegionBackendServiceBackendArgsDict']]]] backends: The set of backends that serve this RegionBackendService.
+        :param pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['RegionBackendServiceBackendArgs']]]] backends: The set of backends that serve this RegionBackendService.
                Structure is documented below.
-        :param pulumi.Input[Union['RegionBackendServiceCdnPolicyArgs', 'RegionBackendServiceCdnPolicyArgsDict']] cdn_policy: Cloud CDN configuration for this BackendService.
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceCdnPolicyArgs']] cdn_policy: Cloud CDN configuration for this BackendService.
                Structure is documented below.
-        :param pulumi.Input[Union['RegionBackendServiceCircuitBreakersArgs', 'RegionBackendServiceCircuitBreakersArgsDict']] circuit_breakers: Settings controlling the volume of connections to a backend service. This field
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceCircuitBreakersArgs']] circuit_breakers: Settings controlling the volume of connections to a backend service. This field
                is applicable only when the `load_balancing_scheme` is set to INTERNAL_MANAGED
                and the `protocol` is set to HTTP, HTTPS, or HTTP2.
                Structure is documented below.
         :param pulumi.Input[int] connection_draining_timeout_sec: Time for which instance will be drained (not accept new
                connections, but still work to finish started).
                From version 6.0.0 ConnectionDrainingTimeoutSec default value will be 300 to match default GCP value.
-        :param pulumi.Input[Union['RegionBackendServiceConnectionTrackingPolicyArgs', 'RegionBackendServiceConnectionTrackingPolicyArgsDict']] connection_tracking_policy: Connection Tracking configuration for this BackendService.
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceConnectionTrackingPolicyArgs']] connection_tracking_policy: Connection Tracking configuration for this BackendService.
                This is available only for Layer 4 Internal Load Balancing and
                Network Load Balancing.
                Structure is documented below.
-        :param pulumi.Input[Union['RegionBackendServiceConsistentHashArgs', 'RegionBackendServiceConsistentHashArgsDict']] consistent_hash: Consistent Hash-based load balancing can be used to provide soft session
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceConsistentHashArgs']] consistent_hash: Consistent Hash-based load balancing can be used to provide soft session
                affinity based on HTTP headers, cookies or other properties. This load balancing
                policy is applicable only for HTTP connections. The affinity to a particular
                destination host will be lost when one or more hosts are added/removed from the
@@ -2243,7 +2248,7 @@ class RegionBackendService(pulumi.CustomResource):
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
         :param pulumi.Input[str] description: An optional description of this resource.
         :param pulumi.Input[bool] enable_cdn: If true, enable Cloud CDN for this RegionBackendService.
-        :param pulumi.Input[Union['RegionBackendServiceFailoverPolicyArgs', 'RegionBackendServiceFailoverPolicyArgsDict']] failover_policy: Policy for failovers.
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceFailoverPolicyArgs']] failover_policy: Policy for failovers.
                Structure is documented below.
         :param pulumi.Input[str] fingerprint: Fingerprint of this resource. A hash of the contents stored in this
                object. This field is used in optimistic locking.
@@ -2253,7 +2258,7 @@ class RegionBackendService(pulumi.CustomResource):
                check can be specified.
                A health check must be specified unless the backend service uses an internet
                or serverless NEG as a backend.
-        :param pulumi.Input[Union['RegionBackendServiceIapArgs', 'RegionBackendServiceIapArgsDict']] iap: Settings for enabling Cloud Identity Aware Proxy
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceIapArgs']] iap: Settings for enabling Cloud Identity Aware Proxy
                Structure is documented below.
         :param pulumi.Input[str] load_balancing_scheme: Indicates what kind of load balancing this regional backend service
                will be used for. A backend service created for one type of load
@@ -2293,6 +2298,7 @@ class RegionBackendService(pulumi.CustomResource):
                instance either reported a valid weight or had
                UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
                equal-weight.
+               
                This field is applicable to either:
                * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
                and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -2300,13 +2306,14 @@ class RegionBackendService(pulumi.CustomResource):
                * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
                Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
                Network Load Balancing. The default is MAGLEV.
+               
                If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
                or RING_HASH, session affinity settings will not take effect.
                Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced
                by a URL map that is bound to target gRPC proxy that has validate_for_proxyless
                field set to true.
                Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`.
-        :param pulumi.Input[Union['RegionBackendServiceLogConfigArgs', 'RegionBackendServiceLogConfigArgsDict']] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceLogConfigArgs']] 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[str] name: Name of the resource. Provided by the client when the resource is
@@ -2341,7 +2348,7 @@ class RegionBackendService(pulumi.CustomResource):
         :param pulumi.Input[str] session_affinity: Type of session affinity to use. The default is NONE. Session affinity is
                not applicable if the protocol is UDP.
                Possible values are: `NONE`, `CLIENT_IP`, `CLIENT_IP_PORT_PROTO`, `CLIENT_IP_PROTO`, `GENERATED_COOKIE`, `HEADER_FIELD`, `HTTP_COOKIE`, `CLIENT_IP_NO_DESTINATION`.
-        :param pulumi.Input[Union['RegionBackendServiceSubsettingArgs', 'RegionBackendServiceSubsettingArgsDict']] subsetting: Subsetting configuration for this BackendService. Currently this is applicable only for Internal TCP/UDP load balancing and Internal HTTP(S) load balancing.
+        :param pulumi.Input[pulumi.InputType['RegionBackendServiceSubsettingArgs']] subsetting: Subsetting configuration for this BackendService. Currently this is applicable only for Internal TCP/UDP load balancing and Internal HTTP(S) load balancing.
                Structure is documented below.
         :param pulumi.Input[int] timeout_sec: The backend service timeout has a different meaning depending on the type of load balancer.
                For more information see, [Backend service settings](https://cloud.google.com/compute/docs/reference/rest/v1/backendServices).
@@ -2580,6 +2587,7 @@ class RegionBackendService(pulumi.CustomResource):
         instance either reported a valid weight or had
         UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
         equal-weight.
+
         This field is applicable to either:
         * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
         and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -2587,6 +2595,7 @@ class RegionBackendService(pulumi.CustomResource):
         * A regional backend service with loadBalancingScheme set to EXTERNAL (External Network
         Load Balancing). Only MAGLEV and WEIGHTED_MAGLEV values are possible for External
         Network Load Balancing. The default is MAGLEV.
+
         If session_affinity is not NONE, and this field is not set to MAGLEV, WEIGHTED_MAGLEV,
         or RING_HASH, session affinity settings will not take effect.
         Only ROUND_ROBIN and RING_HASH are supported when the backend service is referenced