pulumi-gcp 8.22.0a1741790977__py3-none-any.whl → 8.23.0a1742001198__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
@@ -142,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.
@@ -154,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.
@@ -215,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:
@@ -364,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]]]]:
@@ -542,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.
@@ -554,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")
 
@@ -751,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,
@@ -805,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
@@ -872,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.
@@ -884,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.
@@ -948,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:
@@ -1115,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]]]]:
@@ -1318,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.
@@ -1330,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")
 
@@ -1540,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,
@@ -1868,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
 
@@ -1920,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
@@ -1984,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.
@@ -1996,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.
@@ -2353,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
 
@@ -2400,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,
@@ -2439,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
@@ -2484,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,
@@ -2543,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
@@ -2610,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.
@@ -2622,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.
@@ -2682,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
@@ -2792,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]]]:
@@ -2947,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.
@@ -2959,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/disk.py

@@ -24,6 +24,8 @@ class DiskArgs:
                  access_mode: Optional[pulumi.Input[str]] = None,
                  architecture: Optional[pulumi.Input[str]] = None,
                  async_primary_disk: Optional[pulumi.Input['DiskAsyncPrimaryDiskArgs']] = None,
+                 create_snapshot_before_destroy: Optional[pulumi.Input[bool]] = None,
+                 create_snapshot_before_destroy_prefix: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  disk_encryption_key: Optional[pulumi.Input['DiskDiskEncryptionKeyArgs']] = None,
                  enable_confidential_compute: Optional[pulumi.Input[bool]] = None,
@@ -60,6 +62,10 @@ class DiskArgs:
         :param pulumi.Input[str] architecture: (Optional)
         :param pulumi.Input['DiskAsyncPrimaryDiskArgs'] async_primary_disk: A nested object resource.
                Structure is documented below.
+        :param pulumi.Input[bool] create_snapshot_before_destroy: If set to true, a snapshot of the disk will be created before it is destroyed.
+               If your disk is encrypted with customer managed encryption keys these will be reused for the snapshot creation.
+               The name of the snapshot by default will be `{{disk-name}}-YYYYMMDD-HHmm`
+        :param pulumi.Input[str] create_snapshot_before_destroy_prefix: This will set a custom name prefix for the snapshot that's created when the disk is deleted.
         :param pulumi.Input[str] description: An optional description of this resource. Provide this property when
                you create the resource.
         :param pulumi.Input['DiskDiskEncryptionKeyArgs'] disk_encryption_key: Encrypts the disk using a customer-supplied encryption key.
@@ -185,6 +191,10 @@ class DiskArgs:
             pulumi.set(__self__, "architecture", architecture)
         if async_primary_disk is not None:
             pulumi.set(__self__, "async_primary_disk", async_primary_disk)
+        if create_snapshot_before_destroy is not None:
+            pulumi.set(__self__, "create_snapshot_before_destroy", create_snapshot_before_destroy)
+        if create_snapshot_before_destroy_prefix is not None:
+            pulumi.set(__self__, "create_snapshot_before_destroy_prefix", create_snapshot_before_destroy_prefix)
         if description is not None:
             pulumi.set(__self__, "description", description)
         if disk_encryption_key is not None:
@@ -282,6 +292,32 @@ class DiskArgs:
     def async_primary_disk(self, value: Optional[pulumi.Input['DiskAsyncPrimaryDiskArgs']]):
         pulumi.set(self, "async_primary_disk", value)
 
+    @property
+    @pulumi.getter(name="createSnapshotBeforeDestroy")
+    def create_snapshot_before_destroy(self) -> Optional[pulumi.Input[bool]]:
+        """
+        If set to true, a snapshot of the disk will be created before it is destroyed.
+        If your disk is encrypted with customer managed encryption keys these will be reused for the snapshot creation.
+        The name of the snapshot by default will be `{{disk-name}}-YYYYMMDD-HHmm`
+        """
+        return pulumi.get(self, "create_snapshot_before_destroy")
+
+    @create_snapshot_before_destroy.setter
+    def create_snapshot_before_destroy(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "create_snapshot_before_destroy", value)
+
+    @property
+    @pulumi.getter(name="createSnapshotBeforeDestroyPrefix")
+    def create_snapshot_before_destroy_prefix(self) -> Optional[pulumi.Input[str]]:
+        """
+        This will set a custom name prefix for the snapshot that's created when the disk is deleted.
+        """
+        return pulumi.get(self, "create_snapshot_before_destroy_prefix")
+
+    @create_snapshot_before_destroy_prefix.setter
+    def create_snapshot_before_destroy_prefix(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "create_snapshot_before_destroy_prefix", value)
+
     @property
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[str]]:
@@ -694,6 +730,8 @@ class _DiskState:
                  access_mode: Optional[pulumi.Input[str]] = None,
                  architecture: Optional[pulumi.Input[str]] = None,
                  async_primary_disk: Optional[pulumi.Input['DiskAsyncPrimaryDiskArgs']] = None,
+                 create_snapshot_before_destroy: Optional[pulumi.Input[bool]] = None,
+                 create_snapshot_before_destroy_prefix: Optional[pulumi.Input[str]] = None,
                  creation_timestamp: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  disk_encryption_key: Optional[pulumi.Input['DiskDiskEncryptionKeyArgs']] = None,
@@ -743,6 +781,10 @@ class _DiskState:
         :param pulumi.Input[str] architecture: (Optional)
         :param pulumi.Input['DiskAsyncPrimaryDiskArgs'] async_primary_disk: A nested object resource.
                Structure is documented below.
+        :param pulumi.Input[bool] create_snapshot_before_destroy: If set to true, a snapshot of the disk will be created before it is destroyed.
+               If your disk is encrypted with customer managed encryption keys these will be reused for the snapshot creation.
+               The name of the snapshot by default will be `{{disk-name}}-YYYYMMDD-HHmm`
+        :param pulumi.Input[str] create_snapshot_before_destroy_prefix: This will set a custom name prefix for the snapshot that's created when the disk is deleted.
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
         :param pulumi.Input[str] description: An optional description of this resource. Provide this property when
                you create the resource.
@@ -899,6 +941,10 @@ class _DiskState:
             pulumi.set(__self__, "architecture", architecture)
         if async_primary_disk is not None:
             pulumi.set(__self__, "async_primary_disk", async_primary_disk)
+        if create_snapshot_before_destroy is not None:
+            pulumi.set(__self__, "create_snapshot_before_destroy", create_snapshot_before_destroy)
+        if create_snapshot_before_destroy_prefix is not None:
+            pulumi.set(__self__, "create_snapshot_before_destroy_prefix", create_snapshot_before_destroy_prefix)
         if creation_timestamp is not None:
             pulumi.set(__self__, "creation_timestamp", creation_timestamp)
         if description is not None:
@@ -1022,6 +1068,32 @@ class _DiskState:
     def async_primary_disk(self, value: Optional[pulumi.Input['DiskAsyncPrimaryDiskArgs']]):
         pulumi.set(self, "async_primary_disk", value)
 
+    @property
+    @pulumi.getter(name="createSnapshotBeforeDestroy")
+    def create_snapshot_before_destroy(self) -> Optional[pulumi.Input[bool]]:
+        """
+        If set to true, a snapshot of the disk will be created before it is destroyed.
+        If your disk is encrypted with customer managed encryption keys these will be reused for the snapshot creation.
+        The name of the snapshot by default will be `{{disk-name}}-YYYYMMDD-HHmm`
+        """
+        return pulumi.get(self, "create_snapshot_before_destroy")
+
+    @create_snapshot_before_destroy.setter
+    def create_snapshot_before_destroy(self, value: Optional[pulumi.Input[bool]]):
+        pulumi.set(self, "create_snapshot_before_destroy", value)
+
+    @property
+    @pulumi.getter(name="createSnapshotBeforeDestroyPrefix")
+    def create_snapshot_before_destroy_prefix(self) -> Optional[pulumi.Input[str]]:
+        """
+        This will set a custom name prefix for the snapshot that's created when the disk is deleted.
+        """
+        return pulumi.get(self, "create_snapshot_before_destroy_prefix")
+
+    @create_snapshot_before_destroy_prefix.setter
+    def create_snapshot_before_destroy_prefix(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "create_snapshot_before_destroy_prefix", value)
+
     @property
     @pulumi.getter(name="creationTimestamp")
     def creation_timestamp(self) -> Optional[pulumi.Input[str]]:
@@ -1610,6 +1682,8 @@ class Disk(pulumi.CustomResource):
                  access_mode: Optional[pulumi.Input[str]] = None,
                  architecture: Optional[pulumi.Input[str]] = None,
                  async_primary_disk: Optional[pulumi.Input[Union['DiskAsyncPrimaryDiskArgs', 'DiskAsyncPrimaryDiskArgsDict']]] = None,
+                 create_snapshot_before_destroy: Optional[pulumi.Input[bool]] = None,
+                 create_snapshot_before_destroy_prefix: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  disk_encryption_key: Optional[pulumi.Input[Union['DiskDiskEncryptionKeyArgs', 'DiskDiskEncryptionKeyArgsDict']]] = None,
                  enable_confidential_compute: Optional[pulumi.Input[bool]] = None,
@@ -1766,6 +1840,10 @@ class Disk(pulumi.CustomResource):
         :param pulumi.Input[str] architecture: (Optional)
         :param pulumi.Input[Union['DiskAsyncPrimaryDiskArgs', 'DiskAsyncPrimaryDiskArgsDict']] async_primary_disk: A nested object resource.
                Structure is documented below.
+        :param pulumi.Input[bool] create_snapshot_before_destroy: If set to true, a snapshot of the disk will be created before it is destroyed.
+               If your disk is encrypted with customer managed encryption keys these will be reused for the snapshot creation.
+               The name of the snapshot by default will be `{{disk-name}}-YYYYMMDD-HHmm`
+        :param pulumi.Input[str] create_snapshot_before_destroy_prefix: This will set a custom name prefix for the snapshot that's created when the disk is deleted.
         :param pulumi.Input[str] description: An optional description of this resource. Provide this property when
                you create the resource.
         :param pulumi.Input[Union['DiskDiskEncryptionKeyArgs', 'DiskDiskEncryptionKeyArgsDict']] disk_encryption_key: Encrypts the disk using a customer-supplied encryption key.
@@ -2028,6 +2106,8 @@ class Disk(pulumi.CustomResource):
                  access_mode: Optional[pulumi.Input[str]] = None,
                  architecture: Optional[pulumi.Input[str]] = None,
                  async_primary_disk: Optional[pulumi.Input[Union['DiskAsyncPrimaryDiskArgs', 'DiskAsyncPrimaryDiskArgsDict']]] = None,
+                 create_snapshot_before_destroy: Optional[pulumi.Input[bool]] = None,
+                 create_snapshot_before_destroy_prefix: Optional[pulumi.Input[str]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  disk_encryption_key: Optional[pulumi.Input[Union['DiskDiskEncryptionKeyArgs', 'DiskDiskEncryptionKeyArgsDict']]] = None,
                  enable_confidential_compute: Optional[pulumi.Input[bool]] = None,
@@ -2066,6 +2146,8 @@ class Disk(pulumi.CustomResource):
             __props__.__dict__["access_mode"] = access_mode
             __props__.__dict__["architecture"] = architecture
             __props__.__dict__["async_primary_disk"] = async_primary_disk
+            __props__.__dict__["create_snapshot_before_destroy"] = create_snapshot_before_destroy
+            __props__.__dict__["create_snapshot_before_destroy_prefix"] = create_snapshot_before_destroy_prefix
             __props__.__dict__["description"] = description
             __props__.__dict__["disk_encryption_key"] = disk_encryption_key
             __props__.__dict__["enable_confidential_compute"] = enable_confidential_compute
@@ -2120,6 +2202,8 @@ class Disk(pulumi.CustomResource):
             access_mode: Optional[pulumi.Input[str]] = None,
             architecture: Optional[pulumi.Input[str]] = None,
             async_primary_disk: Optional[pulumi.Input[Union['DiskAsyncPrimaryDiskArgs', 'DiskAsyncPrimaryDiskArgsDict']]] = None,
+            create_snapshot_before_destroy: Optional[pulumi.Input[bool]] = None,
+            create_snapshot_before_destroy_prefix: Optional[pulumi.Input[str]] = None,
             creation_timestamp: Optional[pulumi.Input[str]] = None,
             description: Optional[pulumi.Input[str]] = None,
             disk_encryption_key: Optional[pulumi.Input[Union['DiskDiskEncryptionKeyArgs', 'DiskDiskEncryptionKeyArgsDict']]] = None,
@@ -2174,6 +2258,10 @@ class Disk(pulumi.CustomResource):
         :param pulumi.Input[str] architecture: (Optional)
         :param pulumi.Input[Union['DiskAsyncPrimaryDiskArgs', 'DiskAsyncPrimaryDiskArgsDict']] async_primary_disk: A nested object resource.
                Structure is documented below.
+        :param pulumi.Input[bool] create_snapshot_before_destroy: If set to true, a snapshot of the disk will be created before it is destroyed.
+               If your disk is encrypted with customer managed encryption keys these will be reused for the snapshot creation.
+               The name of the snapshot by default will be `{{disk-name}}-YYYYMMDD-HHmm`
+        :param pulumi.Input[str] create_snapshot_before_destroy_prefix: This will set a custom name prefix for the snapshot that's created when the disk is deleted.
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
         :param pulumi.Input[str] description: An optional description of this resource. Provide this property when
                you create the resource.
@@ -2331,6 +2419,8 @@ class Disk(pulumi.CustomResource):
         __props__.__dict__["access_mode"] = access_mode
         __props__.__dict__["architecture"] = architecture
         __props__.__dict__["async_primary_disk"] = async_primary_disk
+        __props__.__dict__["create_snapshot_before_destroy"] = create_snapshot_before_destroy
+        __props__.__dict__["create_snapshot_before_destroy_prefix"] = create_snapshot_before_destroy_prefix
         __props__.__dict__["creation_timestamp"] = creation_timestamp
         __props__.__dict__["description"] = description
         __props__.__dict__["disk_encryption_key"] = disk_encryption_key
@@ -2401,6 +2491,24 @@ class Disk(pulumi.CustomResource):
         """
         return pulumi.get(self, "async_primary_disk")
 
+    @property
+    @pulumi.getter(name="createSnapshotBeforeDestroy")
+    def create_snapshot_before_destroy(self) -> pulumi.Output[Optional[bool]]:
+        """
+        If set to true, a snapshot of the disk will be created before it is destroyed.
+        If your disk is encrypted with customer managed encryption keys these will be reused for the snapshot creation.
+        The name of the snapshot by default will be `{{disk-name}}-YYYYMMDD-HHmm`
+        """
+        return pulumi.get(self, "create_snapshot_before_destroy")
+
+    @property
+    @pulumi.getter(name="createSnapshotBeforeDestroyPrefix")
+    def create_snapshot_before_destroy_prefix(self) -> pulumi.Output[Optional[str]]:
+        """
+        This will set a custom name prefix for the snapshot that's created when the disk is deleted.
+        """
+        return pulumi.get(self, "create_snapshot_before_destroy_prefix")
+
     @property
     @pulumi.getter(name="creationTimestamp")
     def creation_timestamp(self) -> pulumi.Output[str]: