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

pulumi_gcp/compute/target_https_proxy.py

@@ -30,8 +30,7 @@ class TargetHttpsProxyArgs:
                  quic_override: Optional[pulumi.Input[str]] = None,
                  server_tls_policy: Optional[pulumi.Input[str]] = None,
                  ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
-                 ssl_policy: Optional[pulumi.Input[str]] = None,
-                 tls_early_data: Optional[pulumi.Input[str]] = None):
+                 ssl_policy: Optional[pulumi.Input[str]] = None):
         """
         The set of arguments for constructing a TargetHttpsProxy resource.
         :param pulumi.Input[str] url_map: A reference to the UrlMap resource that defines the mapping from URL
@@ -87,11 +86,6 @@ class TargetHttpsProxyArgs:
         :param pulumi.Input[str] ssl_policy: A reference to the SslPolicy resource that will be associated with
                the TargetHttpsProxy resource. If not set, the TargetHttpsProxy
                resource will not have any SSL policy configured.
-        :param pulumi.Input[str] tls_early_data: Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-               Early Data allows a TLS resumption handshake to include the initial application payload
-               (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-               This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-               Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
         """
         pulumi.set(__self__, "url_map", url_map)
         if certificate_manager_certificates is not None:
@@ -116,8 +110,6 @@ class TargetHttpsProxyArgs:
             pulumi.set(__self__, "ssl_certificates", ssl_certificates)
         if ssl_policy is not None:
             pulumi.set(__self__, "ssl_policy", ssl_policy)
-        if tls_early_data is not None:
-            pulumi.set(__self__, "tls_early_data", tls_early_data)
 
     @property
     @pulumi.getter(name="urlMap")
@@ -304,22 +296,6 @@ class TargetHttpsProxyArgs:
     def ssl_policy(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "ssl_policy", value)
 
-    @property
-    @pulumi.getter(name="tlsEarlyData")
-    def tls_early_data(self) -> Optional[pulumi.Input[str]]:
-        """
-        Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-        Early Data allows a TLS resumption handshake to include the initial application payload
-        (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-        This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-        Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
-        """
-        return pulumi.get(self, "tls_early_data")
-
-    @tls_early_data.setter
-    def tls_early_data(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "tls_early_data", value)
-
 
 @pulumi.input_type
 class _TargetHttpsProxyState:
@@ -338,7 +314,6 @@ class _TargetHttpsProxyState:
                  server_tls_policy: Optional[pulumi.Input[str]] = None,
                  ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  ssl_policy: Optional[pulumi.Input[str]] = None,
-                 tls_early_data: Optional[pulumi.Input[str]] = None,
                  url_map: Optional[pulumi.Input[str]] = None):
         """
         Input properties used for looking up and filtering TargetHttpsProxy resources.
@@ -393,11 +368,6 @@ class _TargetHttpsProxyState:
         :param pulumi.Input[str] ssl_policy: A reference to the SslPolicy resource that will be associated with
                the TargetHttpsProxy resource. If not set, the TargetHttpsProxy
                resource will not have any SSL policy configured.
-        :param pulumi.Input[str] tls_early_data: Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-               Early Data allows a TLS resumption handshake to include the initial application payload
-               (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-               This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-               Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
         :param pulumi.Input[str] url_map: A reference to the UrlMap resource that defines the mapping from URL
                to the BackendService.
                
@@ -432,8 +402,6 @@ class _TargetHttpsProxyState:
             pulumi.set(__self__, "ssl_certificates", ssl_certificates)
         if ssl_policy is not None:
             pulumi.set(__self__, "ssl_policy", ssl_policy)
-        if tls_early_data is not None:
-            pulumi.set(__self__, "tls_early_data", tls_early_data)
         if url_map is not None:
             pulumi.set(__self__, "url_map", url_map)
 
@@ -642,22 +610,6 @@ class _TargetHttpsProxyState:
     def ssl_policy(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "ssl_policy", value)
 
-    @property
-    @pulumi.getter(name="tlsEarlyData")
-    def tls_early_data(self) -> Optional[pulumi.Input[str]]:
-        """
-        Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-        Early Data allows a TLS resumption handshake to include the initial application payload
-        (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-        This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-        Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
-        """
-        return pulumi.get(self, "tls_early_data")
-
-    @tls_early_data.setter
-    def tls_early_data(self, value: Optional[pulumi.Input[str]]):
-        pulumi.set(self, "tls_early_data", value)
-
     @property
     @pulumi.getter(name="urlMap")
     def url_map(self) -> Optional[pulumi.Input[str]]:
@@ -691,7 +643,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
                  server_tls_policy: Optional[pulumi.Input[str]] = None,
                  ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  ssl_policy: Optional[pulumi.Input[str]] = None,
-                 tls_early_data: Optional[pulumi.Input[str]] = None,
                  url_map: Optional[pulumi.Input[str]] = None,
                  __props__=None):
         """
@@ -979,11 +930,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
         :param pulumi.Input[str] ssl_policy: A reference to the SslPolicy resource that will be associated with
                the TargetHttpsProxy resource. If not set, the TargetHttpsProxy
                resource will not have any SSL policy configured.
-        :param pulumi.Input[str] tls_early_data: Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-               Early Data allows a TLS resumption handshake to include the initial application payload
-               (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-               This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-               Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
         :param pulumi.Input[str] url_map: A reference to the UrlMap resource that defines the mapping from URL
                to the BackendService.
                
@@ -1257,7 +1203,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
                  server_tls_policy: Optional[pulumi.Input[str]] = None,
                  ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  ssl_policy: Optional[pulumi.Input[str]] = None,
-                 tls_early_data: Optional[pulumi.Input[str]] = None,
                  url_map: Optional[pulumi.Input[str]] = None,
                  __props__=None):
         opts = pulumi.ResourceOptions.merge(_utilities.get_resource_opts_defaults(), opts)
@@ -1279,7 +1224,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
             __props__.__dict__["server_tls_policy"] = server_tls_policy
             __props__.__dict__["ssl_certificates"] = ssl_certificates
             __props__.__dict__["ssl_policy"] = ssl_policy
-            __props__.__dict__["tls_early_data"] = tls_early_data
             if url_map is None and not opts.urn:
                 raise TypeError("Missing required property 'url_map'")
             __props__.__dict__["url_map"] = url_map
@@ -1310,7 +1254,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
             server_tls_policy: Optional[pulumi.Input[str]] = None,
             ssl_certificates: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             ssl_policy: Optional[pulumi.Input[str]] = None,
-            tls_early_data: Optional[pulumi.Input[str]] = None,
             url_map: Optional[pulumi.Input[str]] = None) -> 'TargetHttpsProxy':
         """
         Get an existing TargetHttpsProxy resource's state with the given name, id, and optional extra
@@ -1370,11 +1313,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
         :param pulumi.Input[str] ssl_policy: A reference to the SslPolicy resource that will be associated with
                the TargetHttpsProxy resource. If not set, the TargetHttpsProxy
                resource will not have any SSL policy configured.
-        :param pulumi.Input[str] tls_early_data: Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-               Early Data allows a TLS resumption handshake to include the initial application payload
-               (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-               This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-               Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
         :param pulumi.Input[str] url_map: A reference to the UrlMap resource that defines the mapping from URL
                to the BackendService.
                
@@ -1399,7 +1337,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
         __props__.__dict__["server_tls_policy"] = server_tls_policy
         __props__.__dict__["ssl_certificates"] = ssl_certificates
         __props__.__dict__["ssl_policy"] = ssl_policy
-        __props__.__dict__["tls_early_data"] = tls_early_data
         __props__.__dict__["url_map"] = url_map
         return TargetHttpsProxy(resource_name, opts=opts, __props__=__props__)
 
@@ -1552,18 +1489,6 @@ class TargetHttpsProxy(pulumi.CustomResource):
         """
         return pulumi.get(self, "ssl_policy")
 
-    @property
-    @pulumi.getter(name="tlsEarlyData")
-    def tls_early_data(self) -> pulumi.Output[str]:
-        """
-        Specifies whether TLS 1.3 0-RTT Data (“Early Data”) should be accepted for this service.
-        Early Data allows a TLS resumption handshake to include the initial application payload
-        (a HTTP request) alongside the handshake, reducing the effective round trips to “zero”.
-        This applies to TLS 1.3 connections over TCP (HTTP/2) as well as over UDP (QUIC/h3).
-        Possible values are: `STRICT`, `PERMISSIVE`, `DISABLED`.
-        """
-        return pulumi.get(self, "tls_early_data")
-
     @property
     @pulumi.getter(name="urlMap")
     def url_map(self) -> pulumi.Output[str]:

pulumi_gcp/compute/url_map.py

@@ -21,7 +21,6 @@ __all__ = ['URLMapArgs', 'URLMap']
 @pulumi.input_type
 class URLMapArgs:
     def __init__(__self__, *,
-                 default_custom_error_response_policy: Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']] = None,
                  default_route_action: Optional[pulumi.Input['URLMapDefaultRouteActionArgs']] = None,
                  default_service: Optional[pulumi.Input[str]] = None,
                  default_url_redirect: Optional[pulumi.Input['URLMapDefaultUrlRedirectArgs']] = None,
@@ -34,15 +33,6 @@ class URLMapArgs:
                  tests: Optional[pulumi.Input[Sequence[pulumi.Input['URLMapTestArgs']]]] = None):
         """
         The set of arguments for constructing a URLMap resource.
-        :param pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs'] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-               This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               For example, consider a UrlMap with the following configuration:
-               UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-               A RouteRule for /coming_soon/ is configured for the error code 404.
-               If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-               defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-               Structure is documented below.
         :param pulumi.Input['URLMapDefaultRouteActionArgs'] default_route_action: defaultRouteAction takes effect when none of the hostRules match. The load balancer performs advanced routing actions
                like URL rewrites, header transformations, etc. prior to forwarding the request to the selected backend.
                If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set. Conversely if defaultService
@@ -80,8 +70,6 @@ class URLMapArgs:
                tests per UrlMap.
                Structure is documented below.
         """
-        if default_custom_error_response_policy is not None:
-            pulumi.set(__self__, "default_custom_error_response_policy", default_custom_error_response_policy)
         if default_route_action is not None:
             pulumi.set(__self__, "default_route_action", default_route_action)
         if default_service is not None:
@@ -103,26 +91,6 @@ class URLMapArgs:
         if tests is not None:
             pulumi.set(__self__, "tests", tests)
 
-    @property
-    @pulumi.getter(name="defaultCustomErrorResponsePolicy")
-    def default_custom_error_response_policy(self) -> Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']]:
-        """
-        defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-        This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-        For example, consider a UrlMap with the following configuration:
-        UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-        A RouteRule for /coming_soon/ is configured for the error code 404.
-        If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-        When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-        defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "default_custom_error_response_policy")
-
-    @default_custom_error_response_policy.setter
-    def default_custom_error_response_policy(self, value: Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']]):
-        pulumi.set(self, "default_custom_error_response_policy", value)
-
     @property
     @pulumi.getter(name="defaultRouteAction")
     def default_route_action(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionArgs']]:
@@ -274,7 +242,6 @@ class URLMapArgs:
 class _URLMapState:
     def __init__(__self__, *,
                  creation_timestamp: Optional[pulumi.Input[str]] = None,
-                 default_custom_error_response_policy: Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']] = None,
                  default_route_action: Optional[pulumi.Input['URLMapDefaultRouteActionArgs']] = None,
                  default_service: Optional[pulumi.Input[str]] = None,
                  default_url_redirect: Optional[pulumi.Input['URLMapDefaultUrlRedirectArgs']] = None,
@@ -291,15 +258,6 @@ class _URLMapState:
         """
         Input properties used for looking up and filtering URLMap resources.
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
-        :param pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs'] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-               This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               For example, consider a UrlMap with the following configuration:
-               UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-               A RouteRule for /coming_soon/ is configured for the error code 404.
-               If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-               defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-               Structure is documented below.
         :param pulumi.Input['URLMapDefaultRouteActionArgs'] default_route_action: defaultRouteAction takes effect when none of the hostRules match. The load balancer performs advanced routing actions
                like URL rewrites, header transformations, etc. prior to forwarding the request to the selected backend.
                If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set. Conversely if defaultService
@@ -343,8 +301,6 @@ class _URLMapState:
         """
         if creation_timestamp is not None:
             pulumi.set(__self__, "creation_timestamp", creation_timestamp)
-        if default_custom_error_response_policy is not None:
-            pulumi.set(__self__, "default_custom_error_response_policy", default_custom_error_response_policy)
         if default_route_action is not None:
             pulumi.set(__self__, "default_route_action", default_route_action)
         if default_service is not None:
@@ -384,26 +340,6 @@ class _URLMapState:
     def creation_timestamp(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "creation_timestamp", value)
 
-    @property
-    @pulumi.getter(name="defaultCustomErrorResponsePolicy")
-    def default_custom_error_response_policy(self) -> Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']]:
-        """
-        defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-        This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-        For example, consider a UrlMap with the following configuration:
-        UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-        A RouteRule for /coming_soon/ is configured for the error code 404.
-        If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-        When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-        defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "default_custom_error_response_policy")
-
-    @default_custom_error_response_policy.setter
-    def default_custom_error_response_policy(self, value: Optional[pulumi.Input['URLMapDefaultCustomErrorResponsePolicyArgs']]):
-        pulumi.set(self, "default_custom_error_response_policy", value)
-
     @property
     @pulumi.getter(name="defaultRouteAction")
     def default_route_action(self) -> Optional[pulumi.Input['URLMapDefaultRouteActionArgs']]:
@@ -593,7 +529,6 @@ class URLMap(pulumi.CustomResource):
     def __init__(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
-                 default_custom_error_response_policy: Optional[pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']]] = None,
                  default_route_action: Optional[pulumi.Input[Union['URLMapDefaultRouteActionArgs', 'URLMapDefaultRouteActionArgsDict']]] = None,
                  default_service: Optional[pulumi.Input[str]] = None,
                  default_url_redirect: Optional[pulumi.Input[Union['URLMapDefaultUrlRedirectArgs', 'URLMapDefaultUrlRedirectArgsDict']]] = None,
@@ -1188,82 +1123,6 @@ class URLMap(pulumi.CustomResource):
                 ],
             }])
         ```
-        ### Url Map Custom Error Response Policy
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        default = gcp.compute.HttpHealthCheck("default",
-            name="health-check",
-            request_path="/",
-            check_interval_sec=1,
-            timeout_sec=1)
-        example = gcp.compute.BackendService("example",
-            name="login",
-            port_name="http",
-            protocol="HTTP",
-            timeout_sec=10,
-            load_balancing_scheme="EXTERNAL_MANAGED",
-            health_checks=default.id)
-        error_bucket = gcp.storage.Bucket("error",
-            name="static-asset-bucket",
-            location="US")
-        error = gcp.compute.BackendBucket("error",
-            name="error-backend-bucket",
-            bucket_name=error_bucket.name,
-            enable_cdn=True)
-        urlmap = gcp.compute.URLMap("urlmap",
-            name="urlmap",
-            description="a description",
-            default_service=example.id,
-            default_custom_error_response_policy={
-                "errorResponseRules": [{
-                    "matchResponseCodes": ["5xx"],
-                    "path": "/*",
-                    "overrideResponseCode": 502,
-                }],
-                "errorService": error.id,
-            },
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "mysite",
-            }],
-            path_matchers=[{
-                "name": "mysite",
-                "defaultService": example.id,
-                "defaultCustomErrorResponsePolicy": {
-                    "errorResponseRules": [
-                        {
-                            "matchResponseCodes": [
-                                "4xx",
-                                "5xx",
-                            ],
-                            "path": "/login",
-                            "overrideResponseCode": 404,
-                        },
-                        {
-                            "matchResponseCodes": ["503"],
-                            "path": "/example",
-                            "overrideResponseCode": 502,
-                        },
-                    ],
-                    "errorService": error.id,
-                },
-                "pathRules": [{
-                    "paths": ["/*"],
-                    "service": example.id,
-                    "customErrorResponsePolicy": {
-                        "errorResponseRules": [{
-                            "matchResponseCodes": ["4xx"],
-                            "path": "/register",
-                            "overrideResponseCode": 401,
-                        }],
-                        "errorService": error.id,
-                    },
-                }],
-            }])
-        ```
 
         ## Import
 
@@ -1291,15 +1150,6 @@ class URLMap(pulumi.CustomResource):
 
         :param str resource_name: The name of the resource.
         :param pulumi.ResourceOptions opts: Options for the resource.
-        :param pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-               This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               For example, consider a UrlMap with the following configuration:
-               UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-               A RouteRule for /coming_soon/ is configured for the error code 404.
-               If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-               defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-               Structure is documented below.
         :param pulumi.Input[Union['URLMapDefaultRouteActionArgs', 'URLMapDefaultRouteActionArgsDict']] default_route_action: defaultRouteAction takes effect when none of the hostRules match. The load balancer performs advanced routing actions
                like URL rewrites, header transformations, etc. prior to forwarding the request to the selected backend.
                If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set. Conversely if defaultService
@@ -1926,82 +1776,6 @@ class URLMap(pulumi.CustomResource):
                 ],
             }])
         ```
-        ### Url Map Custom Error Response Policy
-
-        ```python
-        import pulumi
-        import pulumi_gcp as gcp
-
-        default = gcp.compute.HttpHealthCheck("default",
-            name="health-check",
-            request_path="/",
-            check_interval_sec=1,
-            timeout_sec=1)
-        example = gcp.compute.BackendService("example",
-            name="login",
-            port_name="http",
-            protocol="HTTP",
-            timeout_sec=10,
-            load_balancing_scheme="EXTERNAL_MANAGED",
-            health_checks=default.id)
-        error_bucket = gcp.storage.Bucket("error",
-            name="static-asset-bucket",
-            location="US")
-        error = gcp.compute.BackendBucket("error",
-            name="error-backend-bucket",
-            bucket_name=error_bucket.name,
-            enable_cdn=True)
-        urlmap = gcp.compute.URLMap("urlmap",
-            name="urlmap",
-            description="a description",
-            default_service=example.id,
-            default_custom_error_response_policy={
-                "errorResponseRules": [{
-                    "matchResponseCodes": ["5xx"],
-                    "path": "/*",
-                    "overrideResponseCode": 502,
-                }],
-                "errorService": error.id,
-            },
-            host_rules=[{
-                "hosts": ["mysite.com"],
-                "pathMatcher": "mysite",
-            }],
-            path_matchers=[{
-                "name": "mysite",
-                "defaultService": example.id,
-                "defaultCustomErrorResponsePolicy": {
-                    "errorResponseRules": [
-                        {
-                            "matchResponseCodes": [
-                                "4xx",
-                                "5xx",
-                            ],
-                            "path": "/login",
-                            "overrideResponseCode": 404,
-                        },
-                        {
-                            "matchResponseCodes": ["503"],
-                            "path": "/example",
-                            "overrideResponseCode": 502,
-                        },
-                    ],
-                    "errorService": error.id,
-                },
-                "pathRules": [{
-                    "paths": ["/*"],
-                    "service": example.id,
-                    "customErrorResponsePolicy": {
-                        "errorResponseRules": [{
-                            "matchResponseCodes": ["4xx"],
-                            "path": "/register",
-                            "overrideResponseCode": 401,
-                        }],
-                        "errorService": error.id,
-                    },
-                }],
-            }])
-        ```
 
         ## Import
 
@@ -2042,7 +1816,6 @@ class URLMap(pulumi.CustomResource):
     def _internal_init(__self__,
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
-                 default_custom_error_response_policy: Optional[pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']]] = None,
                  default_route_action: Optional[pulumi.Input[Union['URLMapDefaultRouteActionArgs', 'URLMapDefaultRouteActionArgsDict']]] = None,
                  default_service: Optional[pulumi.Input[str]] = None,
                  default_url_redirect: Optional[pulumi.Input[Union['URLMapDefaultUrlRedirectArgs', 'URLMapDefaultUrlRedirectArgsDict']]] = None,
@@ -2062,7 +1835,6 @@ class URLMap(pulumi.CustomResource):
                 raise TypeError('__props__ is only valid when passed in combination with a valid opts.id to get an existing resource')
             __props__ = URLMapArgs.__new__(URLMapArgs)
 
-            __props__.__dict__["default_custom_error_response_policy"] = default_custom_error_response_policy
             __props__.__dict__["default_route_action"] = default_route_action
             __props__.__dict__["default_service"] = default_service
             __props__.__dict__["default_url_redirect"] = default_url_redirect
@@ -2088,7 +1860,6 @@ class URLMap(pulumi.CustomResource):
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
             creation_timestamp: Optional[pulumi.Input[str]] = None,
-            default_custom_error_response_policy: Optional[pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']]] = None,
             default_route_action: Optional[pulumi.Input[Union['URLMapDefaultRouteActionArgs', 'URLMapDefaultRouteActionArgsDict']]] = None,
             default_service: Optional[pulumi.Input[str]] = None,
             default_url_redirect: Optional[pulumi.Input[Union['URLMapDefaultUrlRedirectArgs', 'URLMapDefaultUrlRedirectArgsDict']]] = None,
@@ -2110,15 +1881,6 @@ class URLMap(pulumi.CustomResource):
         :param pulumi.Input[str] id: The unique provider ID of the resource to lookup.
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
-        :param pulumi.Input[Union['URLMapDefaultCustomErrorResponsePolicyArgs', 'URLMapDefaultCustomErrorResponsePolicyArgsDict']] default_custom_error_response_policy: defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-               This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               For example, consider a UrlMap with the following configuration:
-               UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-               A RouteRule for /coming_soon/ is configured for the error code 404.
-               If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-               When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-               defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-               Structure is documented below.
         :param pulumi.Input[Union['URLMapDefaultRouteActionArgs', 'URLMapDefaultRouteActionArgsDict']] default_route_action: defaultRouteAction takes effect when none of the hostRules match. The load balancer performs advanced routing actions
                like URL rewrites, header transformations, etc. prior to forwarding the request to the selected backend.
                If defaultRouteAction specifies any weightedBackendServices, defaultService must not be set. Conversely if defaultService
@@ -2165,7 +1927,6 @@ class URLMap(pulumi.CustomResource):
         __props__ = _URLMapState.__new__(_URLMapState)
 
         __props__.__dict__["creation_timestamp"] = creation_timestamp
-        __props__.__dict__["default_custom_error_response_policy"] = default_custom_error_response_policy
         __props__.__dict__["default_route_action"] = default_route_action
         __props__.__dict__["default_service"] = default_service
         __props__.__dict__["default_url_redirect"] = default_url_redirect
@@ -2189,22 +1950,6 @@ class URLMap(pulumi.CustomResource):
         """
         return pulumi.get(self, "creation_timestamp")
 
-    @property
-    @pulumi.getter(name="defaultCustomErrorResponsePolicy")
-    def default_custom_error_response_policy(self) -> pulumi.Output[Optional['outputs.URLMapDefaultCustomErrorResponsePolicy']]:
-        """
-        defaultCustomErrorResponsePolicy specifies how the Load Balancer returns error responses when BackendServiceor BackendBucket responds with an error.
-        This policy takes effect at the PathMatcher level and applies only when no policy has been defined for the error code at lower levels like RouteRule and PathRule within this PathMatcher. If an error code does not have a policy defined in defaultCustomErrorResponsePolicy, then a policy defined for the error code in UrlMap.defaultCustomErrorResponsePolicy takes effect.
-        For example, consider a UrlMap with the following configuration:
-        UrlMap.defaultCustomErrorResponsePolicy is configured with policies for 5xx and 4xx errors
-        A RouteRule for /coming_soon/ is configured for the error code 404.
-        If the request is for www.myotherdomain.com and a 404 is encountered, the policy under UrlMap.defaultCustomErrorResponsePolicy takes effect. If a 404 response is encountered for the request www.example.com/current_events/, the pathMatcher's policy takes effect. If however, the request for www.example.com/coming_soon/ encounters a 404, the policy in RouteRule.customErrorResponsePolicy takes effect. If any of the requests in this example encounter a 500 error code, the policy at UrlMap.defaultCustomErrorResponsePolicy takes effect.
-        When used in conjunction with pathMatcher.defaultRouteAction.retryPolicy, retries take precedence. Only once all retries are exhausted, the defaultCustomErrorResponsePolicy is applied. While attempting a retry, if load balancer is successful in reaching the service, the defaultCustomErrorResponsePolicy is ignored and the response from the service is returned to the client.
-        defaultCustomErrorResponsePolicy is supported only for global external Application Load Balancers.
-        Structure is documented below.
-        """
-        return pulumi.get(self, "default_custom_error_response_policy")
-
     @property
     @pulumi.getter(name="defaultRouteAction")
     def default_route_action(self) -> pulumi.Output[Optional['outputs.URLMapDefaultRouteAction']]:

pulumi_gcp/container/aws_cluster.py

@@ -594,7 +594,7 @@ class AwsCluster(pulumi.CustomResource):
         An Anthos cluster running on AWS.
 
         For more information, see:
-        * [Multicloud overview](https://cloud.google.com/kubernetes-engine/multi-cloud/docs)
+        * [Multicloud overview](https://cloud.google.com/anthos/clusters/docs/multi-cloud)
         ## Example Usage
 
         ### Basic_aws_cluster
@@ -876,7 +876,7 @@ class AwsCluster(pulumi.CustomResource):
         An Anthos cluster running on AWS.
 
         For more information, see:
-        * [Multicloud overview](https://cloud.google.com/kubernetes-engine/multi-cloud/docs)
+        * [Multicloud overview](https://cloud.google.com/anthos/clusters/docs/multi-cloud)
         ## Example Usage
 
         ### Basic_aws_cluster

pulumi_gcp/container/aws_node_pool.py

@@ -561,7 +561,7 @@ class AwsNodePool(pulumi.CustomResource):
         An Anthos node pool running on AWS.
 
         For more information, see:
-        * [Multicloud overview](https://cloud.google.com/kubernetes-engine/multi-cloud/docs)
+        * [Multicloud overview](https://cloud.google.com/anthos/clusters/docs/multi-cloud)
         ## Example Usage
 
         ### Basic_aws_cluster
@@ -983,7 +983,7 @@ class AwsNodePool(pulumi.CustomResource):
         An Anthos node pool running on AWS.
 
         For more information, see:
-        * [Multicloud overview](https://cloud.google.com/kubernetes-engine/multi-cloud/docs)
+        * [Multicloud overview](https://cloud.google.com/anthos/clusters/docs/multi-cloud)
         ## Example Usage
 
         ### Basic_aws_cluster

pulumi_gcp/container/azure_client.py

@@ -268,7 +268,7 @@ class AzureClient(pulumi.CustomResource):
         AzureClient resources hold client authentication information needed by the Anthos Multi-Cloud API to manage Azure resources on your Azure subscription.When an AzureCluster is created, an AzureClient resource needs to be provided and all operations on Azure resources associated to that cluster will authenticate to Azure services using the given client.AzureClient resources are immutable and cannot be modified upon creation.Each AzureClient resource is bound to a single Azure Active Directory Application and tenant.
 
         For more information, see:
-        * [Multicloud overview](https://cloud.google.com/kubernetes-engine/multi-cloud/docs)
+        * [Multicloud overview](https://cloud.google.com/anthos/clusters/docs/multi-cloud)
         ## Example Usage
 
         ### Basic_azure_client
@@ -331,7 +331,7 @@ class AzureClient(pulumi.CustomResource):
         AzureClient resources hold client authentication information needed by the Anthos Multi-Cloud API to manage Azure resources on your Azure subscription.When an AzureCluster is created, an AzureClient resource needs to be provided and all operations on Azure resources associated to that cluster will authenticate to Azure services using the given client.AzureClient resources are immutable and cannot be modified upon creation.Each AzureClient resource is bound to a single Azure Active Directory Application and tenant.
 
         For more information, see:
-        * [Multicloud overview](https://cloud.google.com/kubernetes-engine/multi-cloud/docs)
+        * [Multicloud overview](https://cloud.google.com/anthos/clusters/docs/multi-cloud)
         ## Example Usage
 
         ### Basic_azure_client

pulumi_gcp/container/azure_cluster.py

@@ -671,7 +671,7 @@ class AzureCluster(pulumi.CustomResource):
         An Anthos cluster running on Azure.
 
         For more information, see:
-        * [Multicloud overview](https://cloud.google.com/kubernetes-engine/multi-cloud/docs)
+        * [Multicloud overview](https://cloud.google.com/anthos/clusters/docs/multi-cloud)
         ## Example Usage
 
         ### Basic_azure_cluster
@@ -829,7 +829,7 @@ class AzureCluster(pulumi.CustomResource):
         An Anthos cluster running on Azure.
 
         For more information, see:
-        * [Multicloud overview](https://cloud.google.com/kubernetes-engine/multi-cloud/docs)
+        * [Multicloud overview](https://cloud.google.com/anthos/clusters/docs/multi-cloud)
         ## Example Usage
 
         ### Basic_azure_cluster