pulumi-gcp 8.22.0a1741329280__py3-none-any.whl → 8.22.0a1741888019__py3-none-any.whl

pulumi_gcp/compute/region_backend_service.py

@@ -28,6 +28,7 @@ class RegionBackendServiceArgs:
                  connection_draining_timeout_sec: Optional[pulumi.Input[int]] = None,
                  connection_tracking_policy: Optional[pulumi.Input['RegionBackendServiceConnectionTrackingPolicyArgs']] = None,
                  consistent_hash: Optional[pulumi.Input['RegionBackendServiceConsistentHashArgs']] = None,
+                 custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceCustomMetricArgs']]]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  enable_cdn: Optional[pulumi.Input[bool]] = None,
                  failover_policy: Optional[pulumi.Input['RegionBackendServiceFailoverPolicyArgs']] = None,
@@ -77,6 +78,8 @@ class RegionBackendServiceArgs:
                destination service. This field specifies parameters that control consistent
                hashing.
                This field only applies when all of the following are true -
+        :param pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceCustomMetricArgs']]] custom_metrics: List of custom metrics that are used for the WEIGHTED_ROUND_ROBIN locality_lb_policy.
+               Structure is documented below.
         :param pulumi.Input[str] description: An optional description of this resource.
         :param pulumi.Input[bool] enable_cdn: If true, enable Cloud CDN for this RegionBackendService.
         :param pulumi.Input['RegionBackendServiceFailoverPolicyArgs'] failover_policy: Policy for failovers.
@@ -130,6 +133,12 @@ class RegionBackendServiceArgs:
                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.
@@ -142,7 +151,7 @@ class RegionBackendServiceArgs:
                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['RegionBackendServiceLogConfigArgs'] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
@@ -204,6 +213,8 @@ class RegionBackendServiceArgs:
             pulumi.set(__self__, "connection_tracking_policy", connection_tracking_policy)
         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 description is not None:
             pulumi.set(__self__, "description", description)
         if enable_cdn is not None:
@@ -350,6 +361,19 @@ class RegionBackendServiceArgs:
     def consistent_hash(self, value: Optional[pulumi.Input['RegionBackendServiceConsistentHashArgs']]):
         pulumi.set(self, "consistent_hash", value)
 
+    @property
+    @pulumi.getter(name="customMetrics")
+    def custom_metrics(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceCustomMetricArgs']]]]:
+        """
+        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['RegionBackendServiceCustomMetricArgs']]]]):
+        pulumi.set(self, "custom_metrics", value)
+
     @property
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[str]]:
@@ -484,6 +508,12 @@ class RegionBackendServiceArgs:
         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.
@@ -496,7 +526,7 @@ class RegionBackendServiceArgs:
         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")
 
@@ -705,6 +735,7 @@ class _RegionBackendServiceState:
                  connection_tracking_policy: Optional[pulumi.Input['RegionBackendServiceConnectionTrackingPolicyArgs']] = None,
                  consistent_hash: Optional[pulumi.Input['RegionBackendServiceConsistentHashArgs']] = None,
                  creation_timestamp: Optional[pulumi.Input[str]] = None,
+                 custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceCustomMetricArgs']]]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  enable_cdn: Optional[pulumi.Input[bool]] = None,
                  failover_policy: Optional[pulumi.Input['RegionBackendServiceFailoverPolicyArgs']] = None,
@@ -758,6 +789,8 @@ class _RegionBackendServiceState:
                hashing.
                This field only applies when all of the following are true -
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
+        :param pulumi.Input[Sequence[pulumi.Input['RegionBackendServiceCustomMetricArgs']]] custom_metrics: List of custom metrics that are used for the WEIGHTED_ROUND_ROBIN locality_lb_policy.
+               Structure is documented below.
         :param pulumi.Input[str] description: An optional description of this resource.
         :param pulumi.Input[bool] enable_cdn: If true, enable Cloud CDN for this RegionBackendService.
         :param pulumi.Input['RegionBackendServiceFailoverPolicyArgs'] failover_policy: Policy for failovers.
@@ -814,6 +847,12 @@ class _RegionBackendServiceState:
                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.
@@ -826,7 +865,7 @@ class _RegionBackendServiceState:
                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['RegionBackendServiceLogConfigArgs'] log_config: This field denotes the logging options for the load balancer traffic served by this backend service.
                If logging is enabled, logs will be exported to Stackdriver.
                Structure is documented below.
@@ -891,6 +930,8 @@ class _RegionBackendServiceState:
             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 description is not None:
             pulumi.set(__self__, "description", description)
         if enable_cdn is not None:
@@ -1055,6 +1096,19 @@ class _RegionBackendServiceState:
     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['RegionBackendServiceCustomMetricArgs']]]]:
+        """
+        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['RegionBackendServiceCustomMetricArgs']]]]):
+        pulumi.set(self, "custom_metrics", value)
+
     @property
     @pulumi.getter
     def description(self) -> Optional[pulumi.Input[str]]:
@@ -1214,6 +1268,12 @@ class _RegionBackendServiceState:
         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.
@@ -1226,7 +1286,7 @@ class _RegionBackendServiceState:
         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")
 
@@ -1448,6 +1508,7 @@ class RegionBackendService(pulumi.CustomResource):
                  connection_draining_timeout_sec: Optional[pulumi.Input[int]] = None,
                  connection_tracking_policy: Optional[pulumi.Input[Union['RegionBackendServiceConnectionTrackingPolicyArgs', 'RegionBackendServiceConnectionTrackingPolicyArgsDict']]] = None,
                  consistent_hash: Optional[pulumi.Input[Union['RegionBackendServiceConsistentHashArgs', 'RegionBackendServiceConsistentHashArgsDict']]] = None,
+                 custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RegionBackendServiceCustomMetricArgs', 'RegionBackendServiceCustomMetricArgsDict']]]]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  enable_cdn: Optional[pulumi.Input[bool]] = None,
                  failover_policy: Optional[pulumi.Input[Union['RegionBackendServiceFailoverPolicyArgs', 'RegionBackendServiceFailoverPolicyArgsDict']]] = None,
@@ -1775,6 +1836,51 @@ class RegionBackendService(pulumi.CustomResource):
             protocol="HTTP",
             ip_address_selection_policy="IPV6_ONLY")
         ```
+        ### Region Backend Service Ilb 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")
+        health_check = gcp.compute.HealthCheck("health_check",
+            name="rbs-health-check",
+            http_health_check={
+                "port": 80,
+            })
+        default_region_backend_service = gcp.compute.RegionBackendService("default",
+            region="us-central1",
+            name="region-service",
+            health_checks=health_check.id,
+            load_balancing_scheme="INTERNAL_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
 
@@ -1834,6 +1940,8 @@ class RegionBackendService(pulumi.CustomResource):
                destination service. This field specifies parameters that control consistent
                hashing.
                This field only applies when all of the following are true -
+        :param pulumi.Input[Sequence[pulumi.Input[Union['RegionBackendServiceCustomMetricArgs', 'RegionBackendServiceCustomMetricArgsDict']]]] custom_metrics: List of custom metrics that are used for the WEIGHTED_ROUND_ROBIN locality_lb_policy.
+               Structure is documented below.
         :param pulumi.Input[str] description: An optional description of this resource.
         :param pulumi.Input[bool] enable_cdn: If true, enable Cloud CDN for this RegionBackendService.
         :param pulumi.Input[Union['RegionBackendServiceFailoverPolicyArgs', 'RegionBackendServiceFailoverPolicyArgsDict']] failover_policy: Policy for failovers.
@@ -1887,6 +1995,12 @@ class RegionBackendService(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.
@@ -1899,7 +2013,7 @@ class RegionBackendService(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['RegionBackendServiceLogConfigArgs', 'RegionBackendServiceLogConfigArgsDict']] 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.
@@ -2258,6 +2372,51 @@ class RegionBackendService(pulumi.CustomResource):
             protocol="HTTP",
             ip_address_selection_policy="IPV6_ONLY")
         ```
+        ### Region Backend Service Ilb 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")
+        health_check = gcp.compute.HealthCheck("health_check",
+            name="rbs-health-check",
+            http_health_check={
+                "port": 80,
+            })
+        default_region_backend_service = gcp.compute.RegionBackendService("default",
+            region="us-central1",
+            name="region-service",
+            health_checks=health_check.id,
+            load_balancing_scheme="INTERNAL_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
 
@@ -2311,6 +2470,7 @@ class RegionBackendService(pulumi.CustomResource):
                  connection_draining_timeout_sec: Optional[pulumi.Input[int]] = None,
                  connection_tracking_policy: Optional[pulumi.Input[Union['RegionBackendServiceConnectionTrackingPolicyArgs', 'RegionBackendServiceConnectionTrackingPolicyArgsDict']]] = None,
                  consistent_hash: Optional[pulumi.Input[Union['RegionBackendServiceConsistentHashArgs', 'RegionBackendServiceConsistentHashArgsDict']]] = None,
+                 custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RegionBackendServiceCustomMetricArgs', 'RegionBackendServiceCustomMetricArgsDict']]]]] = None,
                  description: Optional[pulumi.Input[str]] = None,
                  enable_cdn: Optional[pulumi.Input[bool]] = None,
                  failover_policy: Optional[pulumi.Input[Union['RegionBackendServiceFailoverPolicyArgs', 'RegionBackendServiceFailoverPolicyArgsDict']]] = None,
@@ -2348,6 +2508,7 @@ class RegionBackendService(pulumi.CustomResource):
             __props__.__dict__["connection_draining_timeout_sec"] = connection_draining_timeout_sec
             __props__.__dict__["connection_tracking_policy"] = connection_tracking_policy
             __props__.__dict__["consistent_hash"] = consistent_hash
+            __props__.__dict__["custom_metrics"] = custom_metrics
             __props__.__dict__["description"] = description
             __props__.__dict__["enable_cdn"] = enable_cdn
             __props__.__dict__["failover_policy"] = failover_policy
@@ -2391,6 +2552,7 @@ class RegionBackendService(pulumi.CustomResource):
             connection_tracking_policy: Optional[pulumi.Input[Union['RegionBackendServiceConnectionTrackingPolicyArgs', 'RegionBackendServiceConnectionTrackingPolicyArgsDict']]] = None,
             consistent_hash: Optional[pulumi.Input[Union['RegionBackendServiceConsistentHashArgs', 'RegionBackendServiceConsistentHashArgsDict']]] = None,
             creation_timestamp: Optional[pulumi.Input[str]] = None,
+            custom_metrics: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RegionBackendServiceCustomMetricArgs', 'RegionBackendServiceCustomMetricArgsDict']]]]] = None,
             description: Optional[pulumi.Input[str]] = None,
             enable_cdn: Optional[pulumi.Input[bool]] = None,
             failover_policy: Optional[pulumi.Input[Union['RegionBackendServiceFailoverPolicyArgs', 'RegionBackendServiceFailoverPolicyArgsDict']]] = None,
@@ -2449,6 +2611,8 @@ class RegionBackendService(pulumi.CustomResource):
                hashing.
                This field only applies when all of the following are true -
         :param pulumi.Input[str] creation_timestamp: Creation timestamp in RFC3339 text format.
+        :param pulumi.Input[Sequence[pulumi.Input[Union['RegionBackendServiceCustomMetricArgs', 'RegionBackendServiceCustomMetricArgsDict']]]] custom_metrics: List of custom metrics that are used for the WEIGHTED_ROUND_ROBIN locality_lb_policy.
+               Structure is documented below.
         :param pulumi.Input[str] description: An optional description of this resource.
         :param pulumi.Input[bool] enable_cdn: If true, enable Cloud CDN for this RegionBackendService.
         :param pulumi.Input[Union['RegionBackendServiceFailoverPolicyArgs', 'RegionBackendServiceFailoverPolicyArgsDict']] failover_policy: Policy for failovers.
@@ -2505,6 +2669,12 @@ class RegionBackendService(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.
@@ -2517,7 +2687,7 @@ class RegionBackendService(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['RegionBackendServiceLogConfigArgs', 'RegionBackendServiceLogConfigArgsDict']] 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.
@@ -2578,6 +2748,7 @@ class RegionBackendService(pulumi.CustomResource):
         __props__.__dict__["connection_tracking_policy"] = connection_tracking_policy
         __props__.__dict__["consistent_hash"] = consistent_hash
         __props__.__dict__["creation_timestamp"] = creation_timestamp
+        __props__.__dict__["custom_metrics"] = custom_metrics
         __props__.__dict__["description"] = description
         __props__.__dict__["enable_cdn"] = enable_cdn
         __props__.__dict__["failover_policy"] = failover_policy
@@ -2687,6 +2858,15 @@ class RegionBackendService(pulumi.CustomResource):
         """
         return pulumi.get(self, "creation_timestamp")
 
+    @property
+    @pulumi.getter(name="customMetrics")
+    def custom_metrics(self) -> pulumi.Output[Optional[Sequence['outputs.RegionBackendServiceCustomMetric']]]:
+        """
+        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
     def description(self) -> pulumi.Output[Optional[str]]:
@@ -2810,6 +2990,12 @@ class RegionBackendService(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.
@@ -2822,7 +3008,7 @@ class RegionBackendService(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/region_disk.py

@@ -23,6 +23,8 @@ class RegionDiskArgs:
     def __init__(__self__, *,
                  replica_zones: pulumi.Input[Sequence[pulumi.Input[str]]],
                  async_primary_disk: Optional[pulumi.Input['RegionDiskAsyncPrimaryDiskArgs']] = 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['RegionDiskDiskEncryptionKeyArgs']] = None,
                  guest_os_features: Optional[pulumi.Input[Sequence[pulumi.Input['RegionDiskGuestOsFeatureArgs']]]] = None,
@@ -46,6 +48,10 @@ class RegionDiskArgs:
                - - -
         :param pulumi.Input['RegionDiskAsyncPrimaryDiskArgs'] 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['RegionDiskDiskEncryptionKeyArgs'] disk_encryption_key: Encrypts the disk using a customer-supplied encryption key.
@@ -115,6 +121,10 @@ class RegionDiskArgs:
         pulumi.set(__self__, "replica_zones", replica_zones)
         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:
@@ -177,6 +187,32 @@ class RegionDiskArgs:
     def async_primary_disk(self, value: Optional[pulumi.Input['RegionDiskAsyncPrimaryDiskArgs']]):
         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]]:
@@ -413,6 +449,8 @@ class RegionDiskArgs:
 class _RegionDiskState:
     def __init__(__self__, *,
                  async_primary_disk: Optional[pulumi.Input['RegionDiskAsyncPrimaryDiskArgs']] = 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['RegionDiskDiskEncryptionKeyArgs']] = None,
@@ -443,6 +481,10 @@ class _RegionDiskState:
         Input properties used for looking up and filtering RegionDisk resources.
         :param pulumi.Input['RegionDiskAsyncPrimaryDiskArgs'] 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.
@@ -535,6 +577,10 @@ class _RegionDiskState:
         """
         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:
@@ -604,6 +650,32 @@ class _RegionDiskState:
     def async_primary_disk(self, value: Optional[pulumi.Input['RegionDiskAsyncPrimaryDiskArgs']]):
         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]]:
@@ -987,6 +1059,8 @@ class RegionDisk(pulumi.CustomResource):
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
                  async_primary_disk: Optional[pulumi.Input[Union['RegionDiskAsyncPrimaryDiskArgs', 'RegionDiskAsyncPrimaryDiskArgsDict']]] = 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['RegionDiskDiskEncryptionKeyArgs', 'RegionDiskDiskEncryptionKeyArgsDict']]] = None,
                  guest_os_features: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RegionDiskGuestOsFeatureArgs', 'RegionDiskGuestOsFeatureArgsDict']]]]] = None,
@@ -1027,6 +1101,9 @@ class RegionDisk(pulumi.CustomResource):
         * How-to Guides
             * [Adding or Resizing Regional Persistent Disks](https://cloud.google.com/compute/docs/disks/regional-persistent-disk)
 
+        > **Warning:** All arguments including the following potentially sensitive
+        values will be stored in the raw state as plain text: `disk_encryption_key.raw_key`, `disk_encryption_key.rsa_encrypted_key`.
+
         ## Example Usage
 
         ### Region Disk Basic
@@ -1147,6 +1224,10 @@ class RegionDisk(pulumi.CustomResource):
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[Union['RegionDiskAsyncPrimaryDiskArgs', 'RegionDiskAsyncPrimaryDiskArgsDict']] 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['RegionDiskDiskEncryptionKeyArgs', 'RegionDiskDiskEncryptionKeyArgsDict']] disk_encryption_key: Encrypts the disk using a customer-supplied encryption key.
@@ -1246,6 +1327,9 @@ class RegionDisk(pulumi.CustomResource):
         * How-to Guides
             * [Adding or Resizing Regional Persistent Disks](https://cloud.google.com/compute/docs/disks/regional-persistent-disk)
 
+        > **Warning:** All arguments including the following potentially sensitive
+        values will be stored in the raw state as plain text: `disk_encryption_key.raw_key`, `disk_encryption_key.rsa_encrypted_key`.
+
         ## Example Usage
 
         ### Region Disk Basic
@@ -1378,6 +1462,8 @@ class RegionDisk(pulumi.CustomResource):
                  resource_name: str,
                  opts: Optional[pulumi.ResourceOptions] = None,
                  async_primary_disk: Optional[pulumi.Input[Union['RegionDiskAsyncPrimaryDiskArgs', 'RegionDiskAsyncPrimaryDiskArgsDict']]] = 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['RegionDiskDiskEncryptionKeyArgs', 'RegionDiskDiskEncryptionKeyArgsDict']]] = None,
                  guest_os_features: Optional[pulumi.Input[Sequence[pulumi.Input[Union['RegionDiskGuestOsFeatureArgs', 'RegionDiskGuestOsFeatureArgsDict']]]]] = None,
@@ -1404,6 +1490,8 @@ class RegionDisk(pulumi.CustomResource):
             __props__ = RegionDiskArgs.__new__(RegionDiskArgs)
 
             __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__["guest_os_features"] = guest_os_features
@@ -1445,6 +1533,8 @@ class RegionDisk(pulumi.CustomResource):
             id: pulumi.Input[str],
             opts: Optional[pulumi.ResourceOptions] = None,
             async_primary_disk: Optional[pulumi.Input[Union['RegionDiskAsyncPrimaryDiskArgs', 'RegionDiskAsyncPrimaryDiskArgsDict']]] = 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['RegionDiskDiskEncryptionKeyArgs', 'RegionDiskDiskEncryptionKeyArgsDict']]] = None,
@@ -1480,6 +1570,10 @@ class RegionDisk(pulumi.CustomResource):
         :param pulumi.ResourceOptions opts: Options for the resource.
         :param pulumi.Input[Union['RegionDiskAsyncPrimaryDiskArgs', 'RegionDiskAsyncPrimaryDiskArgsDict']] 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.
@@ -1575,6 +1669,8 @@ class RegionDisk(pulumi.CustomResource):
         __props__ = _RegionDiskState.__new__(_RegionDiskState)
 
         __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
@@ -1612,6 +1708,24 @@ class RegionDisk(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]: