pulumi-gcp 8.21.0a1741156431__py3-none-any.whl → 8.22.0__py3-none-any.whl

pulumi_gcp/compute/backend_service.py

@@ -28,6 +28,7 @@ class BackendServiceArgs:
                  compression_mode: Optional[pulumi.Input[str]] = None,
                  connection_draining_timeout_sec: Optional[pulumi.Input[int]] = None,
                  consistent_hash: Optional[pulumi.Input['BackendServiceConsistentHashArgs']] = None,
+                 custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCustomMetricArgs']]]] = None,
                  custom_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  custom_response_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  description: Optional[pulumi.Input[str]] = None,
@@ -78,6 +79,8 @@ class BackendServiceArgs:
                INTERNAL_SELF_MANAGED. This field is only applicable when locality_lb_policy is
                set to MAGLEV or RING_HASH.
                Structure is documented below.
+        :param pulumi.Input[Sequence[pulumi.Input['BackendServiceCustomMetricArgs']]] custom_metrics: List of custom metrics that are used for the WEIGHTED_ROUND_ROBIN locality_lb_policy.
+               Structure is documented below.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] custom_request_headers: Headers that the HTTP/S load balancer should add to proxied
                requests.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] custom_response_headers: Headers that the HTTP/S load balancer should add to proxied
@@ -91,7 +94,8 @@ class BackendServiceArgs:
                A health check must be specified unless the backend service uses an internet
                or serverless NEG as a backend.
                For internal load balancing, a URL to a HealthCheck resource must be specified instead.
-        :param pulumi.Input['BackendServiceIapArgs'] iap: Settings for enabling Cloud Identity Aware Proxy
+        :param pulumi.Input['BackendServiceIapArgs'] iap: Settings for enabling Cloud Identity Aware Proxy.
+               If OAuth client is not set, the Google-managed OAuth client is used.
                Structure is documented below.
         :param pulumi.Input[str] ip_address_selection_policy: Specifies preference of traffic to the backend (from the proxy and from the client for proxyless gRPC).
                Possible values are: `IPV4_ONLY`, `PREFER_IPV6`, `IPV6_ONLY`.
@@ -141,6 +145,12 @@ class BackendServiceArgs:
                instance either reported a valid weight or had
                UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
                equal-weight.
+               * `WEIGHTED_ROUND_ROBIN`: Per-endpoint weighted round-robin Load Balancing using weights computed
+               from Backend reported Custom Metrics. If set, the Backend Service
+               responses are expected to contain non-standard HTTP response header field
+               X-Endpoint-Load-Metrics. The reported metrics
+               to use for computing the weights are specified via the
+               backends[].customMetrics fields.
                locality_lb_policy is applicable to either:
                * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
                and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -153,7 +163,7 @@ class BackendServiceArgs:
                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`.
+               Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`, `WEIGHTED_ROUND_ROBIN`.
         :param pulumi.Input['BackendServiceLogConfigArgs'] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
@@ -214,6 +224,8 @@ class BackendServiceArgs:
             pulumi.set(__self__, "connection_draining_timeout_sec", connection_draining_timeout_sec)
         if consistent_hash is not None:
             pulumi.set(__self__, "consistent_hash", consistent_hash)
+        if custom_metrics is not None:
+            pulumi.set(__self__, "custom_metrics", custom_metrics)
         if custom_request_headers is not None:
             pulumi.set(__self__, "custom_request_headers", custom_request_headers)
         if custom_response_headers is not None:
@@ -363,6 +375,19 @@ class BackendServiceArgs:
     def consistent_hash(self, value: Optional[pulumi.Input['BackendServiceConsistentHashArgs']]):
         pulumi.set(self, "consistent_hash", value)
 
+    @property
+    @pulumi.getter(name="customMetrics")
+    def custom_metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCustomMetricArgs']]]]:
+        """
+        List of custom metrics that are used for the WEIGHTED_ROUND_ROBIN locality_lb_policy.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "custom_metrics")
+
+    @custom_metrics.setter
+    def custom_metrics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCustomMetricArgs']]]]):
+        pulumi.set(self, "custom_metrics", value)
+
     @property
     @pulumi.getter(name="customRequestHeaders")
     def custom_request_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
@@ -446,7 +471,8 @@ class BackendServiceArgs:
     @pulumi.getter
     def iap(self) -> Optional[pulumi.Input['BackendServiceIapArgs']]:
         """
-        Settings for enabling Cloud Identity Aware Proxy
+        Settings for enabling Cloud Identity Aware Proxy.
+        If OAuth client is not set, the Google-managed OAuth client is used.
         Structure is documented below.
         """
         return pulumi.get(self, "iap")
@@ -540,6 +566,12 @@ class BackendServiceArgs:
         instance either reported a valid weight or had
         UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
         equal-weight.
+        * `WEIGHTED_ROUND_ROBIN`: Per-endpoint weighted round-robin Load Balancing using weights computed
+        from Backend reported Custom Metrics. If set, the Backend Service
+        responses are expected to contain non-standard HTTP response header field
+        X-Endpoint-Load-Metrics. The reported metrics
+        to use for computing the weights are specified via the
+        backends[].customMetrics fields.
         locality_lb_policy is applicable to either:
         * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
         and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -552,7 +584,7 @@ class BackendServiceArgs:
         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`.
+        Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`, `WEIGHTED_ROUND_ROBIN`.
         """
         return pulumi.get(self, "locality_lb_policy")
 
@@ -749,6 +781,7 @@ class _BackendServiceState:
                  connection_draining_timeout_sec: Optional[pulumi.Input[int]] = None,
                  consistent_hash: Optional[pulumi.Input['BackendServiceConsistentHashArgs']] = None,
                  creation_timestamp: Optional[pulumi.Input[str]] = None,
+                 custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCustomMetricArgs']]]] = None,
                  custom_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  custom_response_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  description: Optional[pulumi.Input[str]] = None,
@@ -803,6 +836,8 @@ class _BackendServiceState:
                set to MAGLEV or RING_HASH.
                Structure is documented below.
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
+        :param pulumi.Input[Sequence[pulumi.Input['BackendServiceCustomMetricArgs']]] custom_metrics: List of custom metrics that are used for the WEIGHTED_ROUND_ROBIN locality_lb_policy.
+               Structure is documented below.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] custom_request_headers: Headers that the HTTP/S load balancer should add to proxied
                requests.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] custom_response_headers: Headers that the HTTP/S load balancer should add to proxied
@@ -819,7 +854,8 @@ class _BackendServiceState:
                A health check must be specified unless the backend service uses an internet
                or serverless NEG as a backend.
                For internal load balancing, a URL to a HealthCheck resource must be specified instead.
-        :param pulumi.Input['BackendServiceIapArgs'] iap: Settings for enabling Cloud Identity Aware Proxy
+        :param pulumi.Input['BackendServiceIapArgs'] iap: Settings for enabling Cloud Identity Aware Proxy.
+               If OAuth client is not set, the Google-managed OAuth client is used.
                Structure is documented below.
         :param pulumi.Input[str] ip_address_selection_policy: Specifies preference of traffic to the backend (from the proxy and from the client for proxyless gRPC).
                Possible values are: `IPV4_ONLY`, `PREFER_IPV6`, `IPV6_ONLY`.
@@ -869,6 +905,12 @@ class _BackendServiceState:
                instance either reported a valid weight or had
                UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
                equal-weight.
+               * `WEIGHTED_ROUND_ROBIN`: Per-endpoint weighted round-robin Load Balancing using weights computed
+               from Backend reported Custom Metrics. If set, the Backend Service
+               responses are expected to contain non-standard HTTP response header field
+               X-Endpoint-Load-Metrics. The reported metrics
+               to use for computing the weights are specified via the
+               backends[].customMetrics fields.
                locality_lb_policy is applicable to either:
                * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
                and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -881,7 +923,7 @@ class _BackendServiceState:
                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`.
+               Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`, `WEIGHTED_ROUND_ROBIN`.
         :param pulumi.Input['BackendServiceLogConfigArgs'] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
@@ -945,6 +987,8 @@ class _BackendServiceState:
             pulumi.set(__self__, "consistent_hash", consistent_hash)
         if creation_timestamp is not None:
             pulumi.set(__self__, "creation_timestamp", creation_timestamp)
+        if custom_metrics is not None:
+            pulumi.set(__self__, "custom_metrics", custom_metrics)
         if custom_request_headers is not None:
             pulumi.set(__self__, "custom_request_headers", custom_request_headers)
         if custom_response_headers is not None:
@@ -1112,6 +1156,19 @@ class _BackendServiceState:
     def creation_timestamp(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "creation_timestamp", value)
 
+    @property
+    @pulumi.getter(name="customMetrics")
+    def custom_metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCustomMetricArgs']]]]:
+        """
+        List of custom metrics that are used for the WEIGHTED_ROUND_ROBIN locality_lb_policy.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "custom_metrics")
+
+    @custom_metrics.setter
+    def custom_metrics(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['BackendServiceCustomMetricArgs']]]]):
+        pulumi.set(self, "custom_metrics", value)
+
     @property
     @pulumi.getter(name="customRequestHeaders")
     def custom_request_headers(self) -> Optional[pulumi.Input[Sequence[pulumi.Input[str]]]]:
@@ -1220,7 +1277,8 @@ class _BackendServiceState:
     @pulumi.getter
     def iap(self) -> Optional[pulumi.Input['BackendServiceIapArgs']]:
         """
-        Settings for enabling Cloud Identity Aware Proxy
+        Settings for enabling Cloud Identity Aware Proxy.
+        If OAuth client is not set, the Google-managed OAuth client is used.
         Structure is documented below.
         """
         return pulumi.get(self, "iap")
@@ -1314,6 +1372,12 @@ class _BackendServiceState:
         instance either reported a valid weight or had
         UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
         equal-weight.
+        * `WEIGHTED_ROUND_ROBIN`: Per-endpoint weighted round-robin Load Balancing using weights computed
+        from Backend reported Custom Metrics. If set, the Backend Service
+        responses are expected to contain non-standard HTTP response header field
+        X-Endpoint-Load-Metrics. The reported metrics
+        to use for computing the weights are specified via the
+        backends[].customMetrics fields.
         locality_lb_policy is applicable to either:
         * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
         and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -1326,7 +1390,7 @@ class _BackendServiceState:
         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`.
+        Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`, `WEIGHTED_ROUND_ROBIN`.
         """
         return pulumi.get(self, "locality_lb_policy")
 
@@ -1536,6 +1600,7 @@ class BackendService(pulumi.CustomResource):
                  compression_mode: Optional[pulumi.Input[str]] = None,
                  connection_draining_timeout_sec: Optional[pulumi.Input[int]] = None,
                  consistent_hash: Optional[pulumi.Input[Union['BackendServiceConsistentHashArgs', 'BackendServiceConsistentHashArgsDict']]] = None,
+                 custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input[Union['BackendServiceCustomMetricArgs', 'BackendServiceCustomMetricArgsDict']]]]] = None,
                  custom_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  custom_response_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  description: Optional[pulumi.Input[str]] = None,
@@ -1864,6 +1929,52 @@ class BackendService(pulumi.CustomResource):
             load_balancing_scheme="EXTERNAL_MANAGED",
             ip_address_selection_policy="IPV6_ONLY")
         ```
+        ### Backend Service Custom Metrics
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        default = gcp.compute.Network("default", name="network")
+        # Zonal NEG with GCE_VM_IP_PORT
+        default_network_endpoint_group = gcp.compute.NetworkEndpointGroup("default",
+            name="network-endpoint",
+            network=default.id,
+            default_port=90,
+            zone="us-central1-a",
+            network_endpoint_type="GCE_VM_IP_PORT")
+        default_health_check = gcp.compute.HealthCheck("default",
+            name="health-check",
+            timeout_sec=1,
+            check_interval_sec=1,
+            tcp_health_check={
+                "port": 80,
+            })
+        default_backend_service = gcp.compute.BackendService("default",
+            name="backend-service",
+            health_checks=default_health_check.id,
+            load_balancing_scheme="EXTERNAL_MANAGED",
+            locality_lb_policy="WEIGHTED_ROUND_ROBIN",
+            custom_metrics=[{
+                "name": "orca.application_utilization",
+                "dry_run": False,
+            }],
+            backends=[{
+                "group": default_network_endpoint_group.id,
+                "balancing_mode": "CUSTOM_METRICS",
+                "custom_metrics": [
+                    {
+                        "name": "orca.cpu_utilization",
+                        "max_utilization": 0.9,
+                        "dry_run": True,
+                    },
+                    {
+                        "name": "orca.named_metrics.foo",
+                        "dry_run": False,
+                    },
+                ],
+            }])
+        ```
 
         ## Import
 
@@ -1916,6 +2027,8 @@ class BackendService(pulumi.CustomResource):
                INTERNAL_SELF_MANAGED. This field is only applicable when locality_lb_policy is
                set to MAGLEV or RING_HASH.
                Structure is documented below.
+        :param pulumi.Input[Sequence[pulumi.Input[Union['BackendServiceCustomMetricArgs', 'BackendServiceCustomMetricArgsDict']]]] custom_metrics: List of custom metrics that are used for the WEIGHTED_ROUND_ROBIN locality_lb_policy.
+               Structure is documented below.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] custom_request_headers: Headers that the HTTP/S load balancer should add to proxied
                requests.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] custom_response_headers: Headers that the HTTP/S load balancer should add to proxied
@@ -1929,7 +2042,8 @@ class BackendService(pulumi.CustomResource):
                A health check must be specified unless the backend service uses an internet
                or serverless NEG as a backend.
                For internal load balancing, a URL to a HealthCheck resource must be specified instead.
-        :param pulumi.Input[Union['BackendServiceIapArgs', 'BackendServiceIapArgsDict']] iap: Settings for enabling Cloud Identity Aware Proxy
+        :param pulumi.Input[Union['BackendServiceIapArgs', 'BackendServiceIapArgsDict']] iap: Settings for enabling Cloud Identity Aware Proxy.
+               If OAuth client is not set, the Google-managed OAuth client is used.
                Structure is documented below.
         :param pulumi.Input[str] ip_address_selection_policy: Specifies preference of traffic to the backend (from the proxy and from the client for proxyless gRPC).
                Possible values are: `IPV4_ONLY`, `PREFER_IPV6`, `IPV6_ONLY`.
@@ -1979,6 +2093,12 @@ class BackendService(pulumi.CustomResource):
                instance either reported a valid weight or had
                UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
                equal-weight.
+               * `WEIGHTED_ROUND_ROBIN`: Per-endpoint weighted round-robin Load Balancing using weights computed
+               from Backend reported Custom Metrics. If set, the Backend Service
+               responses are expected to contain non-standard HTTP response header field
+               X-Endpoint-Load-Metrics. The reported metrics
+               to use for computing the weights are specified via the
+               backends[].customMetrics fields.
                locality_lb_policy is applicable to either:
                * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
                and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -1991,7 +2111,7 @@ class BackendService(pulumi.CustomResource):
                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`.
+               Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`, `WEIGHTED_ROUND_ROBIN`.
         :param pulumi.Input[Union['BackendServiceLogConfigArgs', 'BackendServiceLogConfigArgsDict']] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
@@ -2348,6 +2468,52 @@ class BackendService(pulumi.CustomResource):
             load_balancing_scheme="EXTERNAL_MANAGED",
             ip_address_selection_policy="IPV6_ONLY")
         ```
+        ### Backend Service Custom Metrics
+
+        ```python
+        import pulumi
+        import pulumi_gcp as gcp
+
+        default = gcp.compute.Network("default", name="network")
+        # Zonal NEG with GCE_VM_IP_PORT
+        default_network_endpoint_group = gcp.compute.NetworkEndpointGroup("default",
+            name="network-endpoint",
+            network=default.id,
+            default_port=90,
+            zone="us-central1-a",
+            network_endpoint_type="GCE_VM_IP_PORT")
+        default_health_check = gcp.compute.HealthCheck("default",
+            name="health-check",
+            timeout_sec=1,
+            check_interval_sec=1,
+            tcp_health_check={
+                "port": 80,
+            })
+        default_backend_service = gcp.compute.BackendService("default",
+            name="backend-service",
+            health_checks=default_health_check.id,
+            load_balancing_scheme="EXTERNAL_MANAGED",
+            locality_lb_policy="WEIGHTED_ROUND_ROBIN",
+            custom_metrics=[{
+                "name": "orca.application_utilization",
+                "dry_run": False,
+            }],
+            backends=[{
+                "group": default_network_endpoint_group.id,
+                "balancing_mode": "CUSTOM_METRICS",
+                "custom_metrics": [
+                    {
+                        "name": "orca.cpu_utilization",
+                        "max_utilization": 0.9,
+                        "dry_run": True,
+                    },
+                    {
+                        "name": "orca.named_metrics.foo",
+                        "dry_run": False,
+                    },
+                ],
+            }])
+        ```
 
         ## Import
 
@@ -2395,6 +2561,7 @@ class BackendService(pulumi.CustomResource):
                  compression_mode: Optional[pulumi.Input[str]] = None,
                  connection_draining_timeout_sec: Optional[pulumi.Input[int]] = None,
                  consistent_hash: Optional[pulumi.Input[Union['BackendServiceConsistentHashArgs', 'BackendServiceConsistentHashArgsDict']]] = None,
+                 custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input[Union['BackendServiceCustomMetricArgs', 'BackendServiceCustomMetricArgsDict']]]]] = None,
                  custom_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  custom_response_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
                  description: Optional[pulumi.Input[str]] = None,
@@ -2434,6 +2601,7 @@ class BackendService(pulumi.CustomResource):
             __props__.__dict__["compression_mode"] = compression_mode
             __props__.__dict__["connection_draining_timeout_sec"] = connection_draining_timeout_sec
             __props__.__dict__["consistent_hash"] = consistent_hash
+            __props__.__dict__["custom_metrics"] = custom_metrics
             __props__.__dict__["custom_request_headers"] = custom_request_headers
             __props__.__dict__["custom_response_headers"] = custom_response_headers
             __props__.__dict__["description"] = description
@@ -2479,6 +2647,7 @@ class BackendService(pulumi.CustomResource):
             connection_draining_timeout_sec: Optional[pulumi.Input[int]] = None,
             consistent_hash: Optional[pulumi.Input[Union['BackendServiceConsistentHashArgs', 'BackendServiceConsistentHashArgsDict']]] = None,
             creation_timestamp: Optional[pulumi.Input[str]] = None,
+            custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input[Union['BackendServiceCustomMetricArgs', 'BackendServiceCustomMetricArgsDict']]]]] = None,
             custom_request_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             custom_response_headers: Optional[pulumi.Input[Sequence[pulumi.Input[str]]]] = None,
             description: Optional[pulumi.Input[str]] = None,
@@ -2538,6 +2707,8 @@ class BackendService(pulumi.CustomResource):
                set to MAGLEV or RING_HASH.
                Structure is documented below.
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
+        :param pulumi.Input[Sequence[pulumi.Input[Union['BackendServiceCustomMetricArgs', 'BackendServiceCustomMetricArgsDict']]]] custom_metrics: List of custom metrics that are used for the WEIGHTED_ROUND_ROBIN locality_lb_policy.
+               Structure is documented below.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] custom_request_headers: Headers that the HTTP/S load balancer should add to proxied
                requests.
         :param pulumi.Input[Sequence[pulumi.Input[str]]] custom_response_headers: Headers that the HTTP/S load balancer should add to proxied
@@ -2554,7 +2725,8 @@ class BackendService(pulumi.CustomResource):
                A health check must be specified unless the backend service uses an internet
                or serverless NEG as a backend.
                For internal load balancing, a URL to a HealthCheck resource must be specified instead.
-        :param pulumi.Input[Union['BackendServiceIapArgs', 'BackendServiceIapArgsDict']] iap: Settings for enabling Cloud Identity Aware Proxy
+        :param pulumi.Input[Union['BackendServiceIapArgs', 'BackendServiceIapArgsDict']] iap: Settings for enabling Cloud Identity Aware Proxy.
+               If OAuth client is not set, the Google-managed OAuth client is used.
                Structure is documented below.
         :param pulumi.Input[str] ip_address_selection_policy: Specifies preference of traffic to the backend (from the proxy and from the client for proxyless gRPC).
                Possible values are: `IPV4_ONLY`, `PREFER_IPV6`, `IPV6_ONLY`.
@@ -2604,6 +2776,12 @@ class BackendService(pulumi.CustomResource):
                instance either reported a valid weight or had
                UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
                equal-weight.
+               * `WEIGHTED_ROUND_ROBIN`: Per-endpoint weighted round-robin Load Balancing using weights computed
+               from Backend reported Custom Metrics. If set, the Backend Service
+               responses are expected to contain non-standard HTTP response header field
+               X-Endpoint-Load-Metrics. The reported metrics
+               to use for computing the weights are specified via the
+               backends[].customMetrics fields.
                locality_lb_policy is applicable to either:
                * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
                and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -2616,7 +2794,7 @@ class BackendService(pulumi.CustomResource):
                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`.
+               Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`, `WEIGHTED_ROUND_ROBIN`.
         :param pulumi.Input[Union['BackendServiceLogConfigArgs', 'BackendServiceLogConfigArgsDict']] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
@@ -2676,6 +2854,7 @@ class BackendService(pulumi.CustomResource):
         __props__.__dict__["connection_draining_timeout_sec"] = connection_draining_timeout_sec
         __props__.__dict__["consistent_hash"] = consistent_hash
         __props__.__dict__["creation_timestamp"] = creation_timestamp
+        __props__.__dict__["custom_metrics"] = custom_metrics
         __props__.__dict__["custom_request_headers"] = custom_request_headers
         __props__.__dict__["custom_response_headers"] = custom_response_headers
         __props__.__dict__["description"] = description
@@ -2786,6 +2965,15 @@ class BackendService(pulumi.CustomResource):
         """
         return pulumi.get(self, "creation_timestamp")
 
+    @property
+    @pulumi.getter(name="customMetrics")
+    def custom_metrics(self) -> pulumi.Output[Optional[Sequence['outputs.BackendServiceCustomMetric']]]:
+        """
+        List of custom metrics that are used for the WEIGHTED_ROUND_ROBIN locality_lb_policy.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "custom_metrics")
+
     @property
     @pulumi.getter(name="customRequestHeaders")
     def custom_request_headers(self) -> pulumi.Output[Optional[Sequence[str]]]:
@@ -2862,7 +3050,8 @@ class BackendService(pulumi.CustomResource):
     @pulumi.getter
     def iap(self) -> pulumi.Output['outputs.BackendServiceIap']:
         """
-        Settings for enabling Cloud Identity Aware Proxy
+        Settings for enabling Cloud Identity Aware Proxy.
+        If OAuth client is not set, the Google-managed OAuth client is used.
         Structure is documented below.
         """
         return pulumi.get(self, "iap")
@@ -2940,6 +3129,12 @@ class BackendService(pulumi.CustomResource):
         instance either reported a valid weight or had
         UNAVAILABLE_WEIGHT. Otherwise, Load Balancing remains
         equal-weight.
+        * `WEIGHTED_ROUND_ROBIN`: Per-endpoint weighted round-robin Load Balancing using weights computed
+        from Backend reported Custom Metrics. If set, the Backend Service
+        responses are expected to contain non-standard HTTP response header field
+        X-Endpoint-Load-Metrics. The reported metrics
+        to use for computing the weights are specified via the
+        backends[].customMetrics fields.
         locality_lb_policy is applicable to either:
         * A regional backend service with the service_protocol set to HTTP, HTTPS, or HTTP2,
         and loadBalancingScheme set to INTERNAL_MANAGED.
@@ -2952,7 +3147,7 @@ class BackendService(pulumi.CustomResource):
         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`.
+        Possible values are: `ROUND_ROBIN`, `LEAST_REQUEST`, `RING_HASH`, `RANDOM`, `ORIGINAL_DESTINATION`, `MAGLEV`, `WEIGHTED_MAGLEV`, `WEIGHTED_ROUND_ROBIN`.
         """
         return pulumi.get(self, "locality_lb_policy")
 

pulumi_gcp/compute/ca_external_account_key.py

@@ -62,15 +62,20 @@ class CaExternalAccountKeyArgs:
 class _CaExternalAccountKeyState:
     def __init__(__self__, *,
                  b64_mac_key: Optional[pulumi.Input[str]] = None,
+                 b64url_mac_key: Optional[pulumi.Input[str]] = None,
                  key_id: Optional[pulumi.Input[str]] = None,
                  location: Optional[pulumi.Input[str]] = None,
                  name: Optional[pulumi.Input[str]] = None,
                  project: Optional[pulumi.Input[str]] = None):
         """
         Input properties used for looking up and filtering CaExternalAccountKey resources.
-        :param pulumi.Input[str] b64_mac_key: Base64-URL-encoded HS256 key. It is generated by the PublicCertificateAuthorityService
+        :param pulumi.Input[str] b64_mac_key: (Deprecated)
+               Base64-URL-encoded HS256 key. It is generated by the PublicCertificateAuthorityService
                when the ExternalAccountKey is created.
                **Note**: This property is sensitive and will not be displayed in the plan.
+        :param pulumi.Input[str] b64url_mac_key: Base64-URL-encoded HS256 key. It is generated by the PublicCertificateAuthorityService
+               when the ExternalAccountKey is created.'
+               **Note**: This property is sensitive and will not be displayed in the plan.
         :param pulumi.Input[str] key_id: It is generated by the PublicCertificateAuthorityService when the ExternalAccountKey is created.
                **Note**: This property is sensitive and will not be displayed in the plan.
         :param pulumi.Input[str] location: Location for the externalAccountKey. Currently only `global` is supported.
@@ -78,8 +83,13 @@ class _CaExternalAccountKeyState:
         :param pulumi.Input[str] project: The ID of the project in which the resource belongs.
                If it is not provided, the provider project is used.
         """
+        if b64_mac_key is not None:
+            warnings.warn("""`b64_mac_key` is deprecated and will be removed in a future major release. Use `b64url_mac_key` instead.""", DeprecationWarning)
+            pulumi.log.warn("""b64_mac_key is deprecated: `b64_mac_key` is deprecated and will be removed in a future major release. Use `b64url_mac_key` instead.""")
         if b64_mac_key is not None:
             pulumi.set(__self__, "b64_mac_key", b64_mac_key)
+        if b64url_mac_key is not None:
+            pulumi.set(__self__, "b64url_mac_key", b64url_mac_key)
         if key_id is not None:
             pulumi.set(__self__, "key_id", key_id)
         if location is not None:
@@ -91,8 +101,10 @@ class _CaExternalAccountKeyState:
 
     @property
     @pulumi.getter(name="b64MacKey")
+    @_utilities.deprecated("""`b64_mac_key` is deprecated and will be removed in a future major release. Use `b64url_mac_key` instead.""")
     def b64_mac_key(self) -> Optional[pulumi.Input[str]]:
         """
+        (Deprecated)
         Base64-URL-encoded HS256 key. It is generated by the PublicCertificateAuthorityService
         when the ExternalAccountKey is created.
         **Note**: This property is sensitive and will not be displayed in the plan.
@@ -103,6 +115,20 @@ class _CaExternalAccountKeyState:
     def b64_mac_key(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "b64_mac_key", value)
 
+    @property
+    @pulumi.getter(name="b64urlMacKey")
+    def b64url_mac_key(self) -> Optional[pulumi.Input[str]]:
+        """
+        Base64-URL-encoded HS256 key. It is generated by the PublicCertificateAuthorityService
+        when the ExternalAccountKey is created.'
+        **Note**: This property is sensitive and will not be displayed in the plan.
+        """
+        return pulumi.get(self, "b64url_mac_key")
+
+    @b64url_mac_key.setter
+    def b64url_mac_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "b64url_mac_key", value)
+
     @property
     @pulumi.getter(name="keyId")
     def key_id(self) -> Optional[pulumi.Input[str]]:
@@ -267,9 +293,10 @@ class CaExternalAccountKey(pulumi.CustomResource):
             __props__.__dict__["location"] = location
             __props__.__dict__["project"] = project
             __props__.__dict__["b64_mac_key"] = None
+            __props__.__dict__["b64url_mac_key"] = None
             __props__.__dict__["key_id"] = None
             __props__.__dict__["name"] = None
-        secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["b64MacKey", "keyId"])
+        secret_opts = pulumi.ResourceOptions(additional_secret_outputs=["b64MacKey", "b64urlMacKey", "keyId"])
         opts = pulumi.ResourceOptions.merge(opts, secret_opts)
         super(CaExternalAccountKey, __self__).__init__(
             'gcp:compute/caExternalAccountKey:CaExternalAccountKey',
@@ -282,6 +309,7 @@ class CaExternalAccountKey(pulumi.CustomResource):
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
             b64_mac_key: Optional[pulumi.Input[str]] = None,
+            b64url_mac_key: Optional[pulumi.Input[str]] = None,
             key_id: Optional[pulumi.Input[str]] = None,
             location: Optional[pulumi.Input[str]] = None,
             name: Optional[pulumi.Input[str]] = None,
@@ -293,9 +321,13 @@ class CaExternalAccountKey(pulumi.CustomResource):
         :param str resource_name: The unique name of the resulting resource.
         :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] b64_mac_key: Base64-URL-encoded HS256 key. It is generated by the PublicCertificateAuthorityService
+        :param pulumi.Input[str] b64_mac_key: (Deprecated)
+               Base64-URL-encoded HS256 key. It is generated by the PublicCertificateAuthorityService
                when the ExternalAccountKey is created.
                **Note**: This property is sensitive and will not be displayed in the plan.
+        :param pulumi.Input[str] b64url_mac_key: Base64-URL-encoded HS256 key. It is generated by the PublicCertificateAuthorityService
+               when the ExternalAccountKey is created.'
+               **Note**: This property is sensitive and will not be displayed in the plan.
         :param pulumi.Input[str] key_id: It is generated by the PublicCertificateAuthorityService when the ExternalAccountKey is created.
                **Note**: This property is sensitive and will not be displayed in the plan.
         :param pulumi.Input[str] location: Location for the externalAccountKey. Currently only `global` is supported.
@@ -308,6 +340,7 @@ class CaExternalAccountKey(pulumi.CustomResource):
         __props__ = _CaExternalAccountKeyState.__new__(_CaExternalAccountKeyState)
 
         __props__.__dict__["b64_mac_key"] = b64_mac_key
+        __props__.__dict__["b64url_mac_key"] = b64url_mac_key
         __props__.__dict__["key_id"] = key_id
         __props__.__dict__["location"] = location
         __props__.__dict__["name"] = name
@@ -316,14 +349,26 @@ class CaExternalAccountKey(pulumi.CustomResource):
 
     @property
     @pulumi.getter(name="b64MacKey")
+    @_utilities.deprecated("""`b64_mac_key` is deprecated and will be removed in a future major release. Use `b64url_mac_key` instead.""")
     def b64_mac_key(self) -> pulumi.Output[str]:
         """
+        (Deprecated)
         Base64-URL-encoded HS256 key. It is generated by the PublicCertificateAuthorityService
         when the ExternalAccountKey is created.
         **Note**: This property is sensitive and will not be displayed in the plan.
         """
         return pulumi.get(self, "b64_mac_key")
 
+    @property
+    @pulumi.getter(name="b64urlMacKey")
+    def b64url_mac_key(self) -> pulumi.Output[str]:
+        """
+        Base64-URL-encoded HS256 key. It is generated by the PublicCertificateAuthorityService
+        when the ExternalAccountKey is created.'
+        **Note**: This property is sensitive and will not be displayed in the plan.
+        """
+        return pulumi.get(self, "b64url_mac_key")
+
     @property
     @pulumi.getter(name="keyId")
     def key_id(self) -> pulumi.Output[str]: