pulumi-gcp 8.28.0a1745598508__py3-none-any.whl → 8.29.0__py3-none-any.whl

pulumi_gcp/compute/outputs.py

@@ -51,6 +51,7 @@ __all__ = [
     'BackendServiceLocalityLbPolicyCustomPolicy',
     'BackendServiceLocalityLbPolicyPolicy',
     'BackendServiceLogConfig',
+    'BackendServiceMaxStreamDuration',
     'BackendServiceOutlierDetection',
     'BackendServiceOutlierDetectionBaseEjectionTime',
     'BackendServiceOutlierDetectionInterval',
@@ -604,6 +605,10 @@ __all__ = [
     'SnapshotIamMemberCondition',
     'SnapshotSnapshotEncryptionKey',
     'SnapshotSourceDiskEncryptionKey',
+    'StoragePoolIamBindingCondition',
+    'StoragePoolIamMemberCondition',
+    'StoragePoolResourceStatus',
+    'StoragePoolStatus',
     'SubnetworkIAMBindingCondition',
     'SubnetworkIAMMemberCondition',
     'SubnetworkLogConfig',
@@ -726,6 +731,7 @@ __all__ = [
     'GetBackendServiceLocalityLbPolicyCustomPolicyResult',
     'GetBackendServiceLocalityLbPolicyPolicyResult',
     'GetBackendServiceLogConfigResult',
+    'GetBackendServiceMaxStreamDurationResult',
     'GetBackendServiceOutlierDetectionResult',
     'GetBackendServiceOutlierDetectionBaseEjectionTimeResult',
     'GetBackendServiceOutlierDetectionIntervalResult',
@@ -968,6 +974,7 @@ __all__ = [
     'GetSecurityPolicyRuleRedirectOptionResult',
     'GetSnapshotSnapshotEncryptionKeyResult',
     'GetSnapshotSourceDiskEncryptionKeyResult',
+    'GetStoragePoolTypesDeprecatedResult',
     'GetSubnetworkSecondaryIpRangeResult',
     'GetSubnetworksSubnetworkResult',
 ]
@@ -1797,10 +1804,13 @@ class BackendBucketCdnPolicy(dict):
         :param builtins.str cache_mode: Specifies the cache setting for all responses from this backend.
                The possible values are: USE_ORIGIN_HEADERS, FORCE_CACHE_ALL and CACHE_ALL_STATIC
                Possible values are: `USE_ORIGIN_HEADERS`, `FORCE_CACHE_ALL`, `CACHE_ALL_STATIC`.
-        :param builtins.int client_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
+        :param builtins.int client_ttl: Specifies the maximum allowed TTL for cached content served by this origin. When the
+               `cache_mode` is set to "USE_ORIGIN_HEADERS", you must omit this field.
         :param builtins.int default_ttl: Specifies the default TTL for cached content served by this origin for responses
-               that do not have an existing valid TTL (max-age or s-max-age).
-        :param builtins.int max_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
+               that do not have an existing valid TTL (max-age or s-max-age). When the `cache_mode`
+               is set to "USE_ORIGIN_HEADERS", you must omit this field.
+        :param builtins.int max_ttl: Specifies the maximum allowed TTL for cached content served by this origin. When the
+               `cache_mode` is set to "USE_ORIGIN_HEADERS", you must omit this field.
         :param builtins.bool negative_caching: Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects.
         :param Sequence['BackendBucketCdnPolicyNegativeCachingPolicyArgs'] negative_caching_policies: Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
                Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.
@@ -1871,7 +1881,8 @@ class BackendBucketCdnPolicy(dict):
     @pulumi.getter(name="clientTtl")
     def client_ttl(self) -> Optional[builtins.int]:
         """
-        Specifies the maximum allowed TTL for cached content served by this origin.
+        Specifies the maximum allowed TTL for cached content served by this origin. When the
+        `cache_mode` is set to "USE_ORIGIN_HEADERS", you must omit this field.
         """
         return pulumi.get(self, "client_ttl")
 
@@ -1880,7 +1891,8 @@ class BackendBucketCdnPolicy(dict):
     def default_ttl(self) -> Optional[builtins.int]:
         """
         Specifies the default TTL for cached content served by this origin for responses
-        that do not have an existing valid TTL (max-age or s-max-age).
+        that do not have an existing valid TTL (max-age or s-max-age). When the `cache_mode`
+        is set to "USE_ORIGIN_HEADERS", you must omit this field.
         """
         return pulumi.get(self, "default_ttl")
 
@@ -1888,7 +1900,8 @@ class BackendBucketCdnPolicy(dict):
     @pulumi.getter(name="maxTtl")
     def max_ttl(self) -> Optional[builtins.int]:
         """
-        Specifies the maximum allowed TTL for cached content served by this origin.
+        Specifies the maximum allowed TTL for cached content served by this origin. When the
+        `cache_mode` is set to "USE_ORIGIN_HEADERS", you must omit this field.
         """
         return pulumi.get(self, "max_ttl")
 
@@ -2172,7 +2185,8 @@ class BackendServiceBackend(dict):
                  max_rate: Optional[builtins.int] = None,
                  max_rate_per_endpoint: Optional[builtins.float] = None,
                  max_rate_per_instance: Optional[builtins.float] = None,
-                 max_utilization: Optional[builtins.float] = None):
+                 max_utilization: Optional[builtins.float] = None,
+                 preference: Optional[builtins.str] = None):
         """
         :param builtins.str group: The fully-qualified URL of an Instance Group or Network Endpoint
                Group resource. In case of instance group this defines the list
@@ -2238,6 +2252,13 @@ class BackendServiceBackend(dict):
                either maxRate or maxRatePerInstance must be set.
         :param builtins.float max_utilization: Used when balancingMode is UTILIZATION. This ratio defines the
                CPU utilization target for the group. Valid range is [0.0, 1.0].
+        :param builtins.str preference: This field indicates whether this backend should be fully utilized before sending traffic to backends
+               with default preference. This field cannot be set when loadBalancingScheme is set to 'EXTERNAL'. The possible values are:
+               - PREFERRED: Backends with this preference level will be filled up to their capacity limits first,
+               based on RTT.
+               - DEFAULT: If preferred backends don't have enough capacity, backends in this layer would be used and
+               traffic would be assigned based on the load balancing algorithm you use. This is the default
+               Possible values are: `PREFERRED`, `DEFAULT`.
         """
         pulumi.set(__self__, "group", group)
         if balancing_mode is not None:
@@ -2262,6 +2283,8 @@ class BackendServiceBackend(dict):
             pulumi.set(__self__, "max_rate_per_instance", max_rate_per_instance)
         if max_utilization is not None:
             pulumi.set(__self__, "max_utilization", max_utilization)
+        if preference is not None:
+            pulumi.set(__self__, "preference", preference)
 
     @property
     @pulumi.getter
@@ -2411,6 +2434,20 @@ class BackendServiceBackend(dict):
         """
         return pulumi.get(self, "max_utilization")
 
+    @property
+    @pulumi.getter
+    def preference(self) -> Optional[builtins.str]:
+        """
+        This field indicates whether this backend should be fully utilized before sending traffic to backends
+        with default preference. This field cannot be set when loadBalancingScheme is set to 'EXTERNAL'. The possible values are:
+        - PREFERRED: Backends with this preference level will be filled up to their capacity limits first,
+        based on RTT.
+        - DEFAULT: If preferred backends don't have enough capacity, backends in this layer would be used and
+        traffic would be assigned based on the load balancing algorithm you use. This is the default
+        Possible values are: `PREFERRED`, `DEFAULT`.
+        """
+        return pulumi.get(self, "preference")
+
 
 @pulumi.output_type
 class BackendServiceBackendCustomMetric(dict):
@@ -2511,6 +2548,8 @@ class BackendServiceCdnPolicy(dict):
             suggest = "negative_caching"
         elif key == "negativeCachingPolicies":
             suggest = "negative_caching_policies"
+        elif key == "requestCoalescing":
+            suggest = "request_coalescing"
         elif key == "serveWhileStale":
             suggest = "serve_while_stale"
         elif key == "signedUrlCacheMaxAgeSec":
@@ -2536,6 +2575,7 @@ class BackendServiceCdnPolicy(dict):
                  max_ttl: Optional[builtins.int] = None,
                  negative_caching: Optional[builtins.bool] = None,
                  negative_caching_policies: Optional[Sequence['outputs.BackendServiceCdnPolicyNegativeCachingPolicy']] = None,
+                 request_coalescing: Optional[builtins.bool] = None,
                  serve_while_stale: Optional[builtins.int] = None,
                  signed_url_cache_max_age_sec: Optional[builtins.int] = None):
         """
@@ -2555,6 +2595,8 @@ class BackendServiceCdnPolicy(dict):
         :param Sequence['BackendServiceCdnPolicyNegativeCachingPolicyArgs'] negative_caching_policies: Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
                Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.
                Structure is documented below.
+        :param builtins.bool request_coalescing: If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests
+               to the origin.
         :param builtins.int serve_while_stale: Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache.
         :param builtins.int signed_url_cache_max_age_sec: Maximum number of seconds the response to a signed URL request
                will be considered fresh, defaults to 1hr (3600s). After this
@@ -2582,6 +2624,8 @@ class BackendServiceCdnPolicy(dict):
             pulumi.set(__self__, "negative_caching", negative_caching)
         if negative_caching_policies is not None:
             pulumi.set(__self__, "negative_caching_policies", negative_caching_policies)
+        if request_coalescing is not None:
+            pulumi.set(__self__, "request_coalescing", request_coalescing)
         if serve_while_stale is not None:
             pulumi.set(__self__, "serve_while_stale", serve_while_stale)
         if signed_url_cache_max_age_sec is not None:
@@ -2659,6 +2703,15 @@ class BackendServiceCdnPolicy(dict):
         """
         return pulumi.get(self, "negative_caching_policies")
 
+    @property
+    @pulumi.getter(name="requestCoalescing")
+    def request_coalescing(self) -> Optional[builtins.bool]:
+        """
+        If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests
+        to the origin.
+        """
+        return pulumi.get(self, "request_coalescing")
+
     @property
     @pulumi.getter(name="serveWhileStale")
     def serve_while_stale(self) -> Optional[builtins.int]:
@@ -3619,7 +3672,11 @@ class BackendServiceLogConfig(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "sampleRate":
+        if key == "optionalFields":
+            suggest = "optional_fields"
+        elif key == "optionalMode":
+            suggest = "optional_mode"
+        elif key == "sampleRate":
             suggest = "sample_rate"
 
         if suggest:
@@ -3635,9 +3692,17 @@ class BackendServiceLogConfig(dict):
 
     def __init__(__self__, *,
                  enable: Optional[builtins.bool] = None,
+                 optional_fields: Optional[Sequence[builtins.str]] = None,
+                 optional_mode: Optional[builtins.str] = None,
                  sample_rate: Optional[builtins.float] = None):
         """
         :param builtins.bool enable: Whether to enable logging for the load balancer traffic served by this backend service.
+        :param Sequence[builtins.str] optional_fields: This field can only be specified if logging is enabled for this backend service and "logConfig.optionalMode"
+               was set to CUSTOM. Contains a list of optional fields you want to include in the logs.
+               For example: serverInstance, serverGkeDetails.cluster, serverGkeDetails.pod.podNamespace
+        :param builtins.str optional_mode: Specifies the optional logging mode for the load balancer traffic.
+               Supported values: INCLUDE_ALL_OPTIONAL, EXCLUDE_ALL_OPTIONAL, CUSTOM.
+               Possible values are: `INCLUDE_ALL_OPTIONAL`, `EXCLUDE_ALL_OPTIONAL`, `CUSTOM`.
         :param builtins.float sample_rate: This field can only be specified if logging is enabled for this backend service. The value of
                the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer
                where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported.
@@ -3645,6 +3710,10 @@ class BackendServiceLogConfig(dict):
         """
         if enable is not None:
             pulumi.set(__self__, "enable", enable)
+        if optional_fields is not None:
+            pulumi.set(__self__, "optional_fields", optional_fields)
+        if optional_mode is not None:
+            pulumi.set(__self__, "optional_mode", optional_mode)
         if sample_rate is not None:
             pulumi.set(__self__, "sample_rate", sample_rate)
 
@@ -3656,6 +3725,26 @@ class BackendServiceLogConfig(dict):
         """
         return pulumi.get(self, "enable")
 
+    @property
+    @pulumi.getter(name="optionalFields")
+    def optional_fields(self) -> Optional[Sequence[builtins.str]]:
+        """
+        This field can only be specified if logging is enabled for this backend service and "logConfig.optionalMode"
+        was set to CUSTOM. Contains a list of optional fields you want to include in the logs.
+        For example: serverInstance, serverGkeDetails.cluster, serverGkeDetails.pod.podNamespace
+        """
+        return pulumi.get(self, "optional_fields")
+
+    @property
+    @pulumi.getter(name="optionalMode")
+    def optional_mode(self) -> Optional[builtins.str]:
+        """
+        Specifies the optional logging mode for the load balancer traffic.
+        Supported values: INCLUDE_ALL_OPTIONAL, EXCLUDE_ALL_OPTIONAL, CUSTOM.
+        Possible values are: `INCLUDE_ALL_OPTIONAL`, `EXCLUDE_ALL_OPTIONAL`, `CUSTOM`.
+        """
+        return pulumi.get(self, "optional_mode")
+
     @property
     @pulumi.getter(name="sampleRate")
     def sample_rate(self) -> Optional[builtins.float]:
@@ -3668,6 +3757,40 @@ class BackendServiceLogConfig(dict):
         return pulumi.get(self, "sample_rate")
 
 
+@pulumi.output_type
+class BackendServiceMaxStreamDuration(dict):
+    def __init__(__self__, *,
+                 seconds: builtins.str,
+                 nanos: Optional[builtins.int] = None):
+        """
+        :param builtins.str seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive. (int64 format)
+        :param builtins.int nanos: Span of time that's a fraction of a second at nanosecond resolution.
+               Durations less than one second are represented with a 0 seconds field and a positive nanos field.
+               Must be from 0 to 999,999,999 inclusive.
+        """
+        pulumi.set(__self__, "seconds", seconds)
+        if nanos is not None:
+            pulumi.set(__self__, "nanos", nanos)
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> builtins.str:
+        """
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive. (int64 format)
+        """
+        return pulumi.get(self, "seconds")
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> Optional[builtins.int]:
+        """
+        Span of time that's a fraction of a second at nanosecond resolution.
+        Durations less than one second are represented with a 0 seconds field and a positive nanos field.
+        Must be from 0 to 999,999,999 inclusive.
+        """
+        return pulumi.get(self, "nanos")
+
+
 @pulumi.output_type
 class BackendServiceOutlierDetection(dict):
     @staticmethod
@@ -16814,6 +16937,8 @@ class InstanceTemplateDiskDiskEncryptionKey(dict):
         suggest = None
         if key == "kmsKeySelfLink":
             suggest = "kms_key_self_link"
+        elif key == "kmsKeyServiceAccount":
+            suggest = "kms_key_service_account"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateDiskDiskEncryptionKey. Access the value via the '{suggest}' property getter instead.")
@@ -16827,20 +16952,37 @@ class InstanceTemplateDiskDiskEncryptionKey(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 kms_key_self_link: builtins.str):
+                 kms_key_self_link: Optional[builtins.str] = None,
+                 kms_key_service_account: Optional[builtins.str] = None):
         """
         :param builtins.str kms_key_self_link: The self link of the encryption key that is stored in Google Cloud KMS
+        :param builtins.str kms_key_service_account: The service account being used for the
+               encryption request for the given KMS key. If absent, the Compute Engine
+               default service account is used.
         """
-        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_self_link is not None:
+            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_service_account is not None:
+            pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
-    def kms_key_self_link(self) -> builtins.str:
+    def kms_key_self_link(self) -> Optional[builtins.str]:
         """
         The self link of the encryption key that is stored in Google Cloud KMS
         """
         return pulumi.get(self, "kms_key_self_link")
 
+    @property
+    @pulumi.getter(name="kmsKeyServiceAccount")
+    def kms_key_service_account(self) -> Optional[builtins.str]:
+        """
+        The service account being used for the
+        encryption request for the given KMS key. If absent, the Compute Engine
+        default service account is used.
+        """
+        return pulumi.get(self, "kms_key_service_account")
+
 
 @pulumi.output_type
 class InstanceTemplateDiskSourceImageEncryptionKey(dict):
@@ -16851,6 +16993,10 @@ class InstanceTemplateDiskSourceImageEncryptionKey(dict):
             suggest = "kms_key_self_link"
         elif key == "kmsKeyServiceAccount":
             suggest = "kms_key_service_account"
+        elif key == "rawKey":
+            suggest = "raw_key"
+        elif key == "rsaEncryptedKey":
+            suggest = "rsa_encrypted_key"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateDiskSourceImageEncryptionKey. Access the value via the '{suggest}' property getter instead.")
@@ -16864,25 +17010,42 @@ class InstanceTemplateDiskSourceImageEncryptionKey(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 kms_key_self_link: builtins.str,
-                 kms_key_service_account: Optional[builtins.str] = None):
+                 kms_key_self_link: Optional[builtins.str] = None,
+                 kms_key_service_account: Optional[builtins.str] = None,
+                 raw_key: Optional[builtins.str] = None,
+                 rsa_encrypted_key: Optional[builtins.str] = None):
         """
         :param builtins.str kms_key_self_link: The self link of the encryption key that is
-               stored in Google Cloud KMS.
+               stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         :param builtins.str kms_key_service_account: The service account being used for the
                encryption request for the given KMS key. If absent, the Compute Engine
                default service account is used.
+        :param builtins.str raw_key: A 256-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+               encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+               to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
+        :param builtins.str rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         """
-        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_self_link is not None:
+            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         if kms_key_service_account is not None:
             pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
+        if raw_key is not None:
+            pulumi.set(__self__, "raw_key", raw_key)
+        if rsa_encrypted_key is not None:
+            pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
-    def kms_key_self_link(self) -> builtins.str:
+    def kms_key_self_link(self) -> Optional[builtins.str]:
         """
         The self link of the encryption key that is
-        stored in Google Cloud KMS.
+        stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
         """
         return pulumi.get(self, "kms_key_self_link")
 
@@ -16896,6 +17059,28 @@ class InstanceTemplateDiskSourceImageEncryptionKey(dict):
         """
         return pulumi.get(self, "kms_key_service_account")
 
+    @property
+    @pulumi.getter(name="rawKey")
+    def raw_key(self) -> Optional[builtins.str]:
+        """
+        A 256-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+        to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "raw_key")
+
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> Optional[builtins.str]:
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
 
 @pulumi.output_type
 class InstanceTemplateDiskSourceSnapshotEncryptionKey(dict):
@@ -16906,6 +17091,10 @@ class InstanceTemplateDiskSourceSnapshotEncryptionKey(dict):
             suggest = "kms_key_self_link"
         elif key == "kmsKeyServiceAccount":
             suggest = "kms_key_service_account"
+        elif key == "rawKey":
+            suggest = "raw_key"
+        elif key == "rsaEncryptedKey":
+            suggest = "rsa_encrypted_key"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in InstanceTemplateDiskSourceSnapshotEncryptionKey. Access the value via the '{suggest}' property getter instead.")
@@ -16919,25 +17108,42 @@ class InstanceTemplateDiskSourceSnapshotEncryptionKey(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 kms_key_self_link: builtins.str,
-                 kms_key_service_account: Optional[builtins.str] = None):
+                 kms_key_self_link: Optional[builtins.str] = None,
+                 kms_key_service_account: Optional[builtins.str] = None,
+                 raw_key: Optional[builtins.str] = None,
+                 rsa_encrypted_key: Optional[builtins.str] = None):
         """
         :param builtins.str kms_key_self_link: The self link of the encryption key that is
-               stored in Google Cloud KMS.
+               stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         :param builtins.str kms_key_service_account: The service account being used for the
                encryption request for the given KMS key. If absent, the Compute Engine
                default service account is used.
+        :param builtins.str raw_key: A 256-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+               encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+               to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
+        :param builtins.str rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         """
-        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_self_link is not None:
+            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         if kms_key_service_account is not None:
             pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
+        if raw_key is not None:
+            pulumi.set(__self__, "raw_key", raw_key)
+        if rsa_encrypted_key is not None:
+            pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
-    def kms_key_self_link(self) -> builtins.str:
+    def kms_key_self_link(self) -> Optional[builtins.str]:
         """
         The self link of the encryption key that is
-        stored in Google Cloud KMS.
+        stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
         """
         return pulumi.get(self, "kms_key_self_link")
 
@@ -16951,6 +17157,28 @@ class InstanceTemplateDiskSourceSnapshotEncryptionKey(dict):
         """
         return pulumi.get(self, "kms_key_service_account")
 
+    @property
+    @pulumi.getter(name="rawKey")
+    def raw_key(self) -> Optional[builtins.str]:
+        """
+        A 256-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+        to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "raw_key")
+
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> Optional[builtins.str]:
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
 
 @pulumi.output_type
 class InstanceTemplateGuestAccelerator(dict):
@@ -27731,6 +27959,8 @@ class RegionInstanceTemplateDiskDiskEncryptionKey(dict):
         suggest = None
         if key == "kmsKeySelfLink":
             suggest = "kms_key_self_link"
+        elif key == "kmsKeyServiceAccount":
+            suggest = "kms_key_service_account"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in RegionInstanceTemplateDiskDiskEncryptionKey. Access the value via the '{suggest}' property getter instead.")
@@ -27744,20 +27974,37 @@ class RegionInstanceTemplateDiskDiskEncryptionKey(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 kms_key_self_link: builtins.str):
+                 kms_key_self_link: Optional[builtins.str] = None,
+                 kms_key_service_account: Optional[builtins.str] = None):
         """
         :param builtins.str kms_key_self_link: The self link of the encryption key that is stored in Google Cloud KMS
+        :param builtins.str kms_key_service_account: The service account being used for the
+               encryption request for the given KMS key. If absent, the Compute Engine
+               default service account is used.
         """
-        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_self_link is not None:
+            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_service_account is not None:
+            pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
-    def kms_key_self_link(self) -> builtins.str:
+    def kms_key_self_link(self) -> Optional[builtins.str]:
         """
         The self link of the encryption key that is stored in Google Cloud KMS
         """
         return pulumi.get(self, "kms_key_self_link")
 
+    @property
+    @pulumi.getter(name="kmsKeyServiceAccount")
+    def kms_key_service_account(self) -> Optional[builtins.str]:
+        """
+        The service account being used for the
+        encryption request for the given KMS key. If absent, the Compute Engine
+        default service account is used.
+        """
+        return pulumi.get(self, "kms_key_service_account")
+
 
 @pulumi.output_type
 class RegionInstanceTemplateDiskSourceImageEncryptionKey(dict):
@@ -27768,6 +28015,10 @@ class RegionInstanceTemplateDiskSourceImageEncryptionKey(dict):
             suggest = "kms_key_self_link"
         elif key == "kmsKeyServiceAccount":
             suggest = "kms_key_service_account"
+        elif key == "rawKey":
+            suggest = "raw_key"
+        elif key == "rsaEncryptedKey":
+            suggest = "rsa_encrypted_key"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in RegionInstanceTemplateDiskSourceImageEncryptionKey. Access the value via the '{suggest}' property getter instead.")
@@ -27781,25 +28032,42 @@ class RegionInstanceTemplateDiskSourceImageEncryptionKey(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 kms_key_self_link: builtins.str,
-                 kms_key_service_account: Optional[builtins.str] = None):
+                 kms_key_self_link: Optional[builtins.str] = None,
+                 kms_key_service_account: Optional[builtins.str] = None,
+                 raw_key: Optional[builtins.str] = None,
+                 rsa_encrypted_key: Optional[builtins.str] = None):
         """
         :param builtins.str kms_key_self_link: The self link of the encryption key that is
-               stored in Google Cloud KMS.
+               stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         :param builtins.str kms_key_service_account: The service account being used for the
                encryption request for the given KMS key. If absent, the Compute Engine
                default service account is used.
+        :param builtins.str raw_key: A 256-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+               encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+               to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
+        :param builtins.str rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         """
-        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_self_link is not None:
+            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         if kms_key_service_account is not None:
             pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
+        if raw_key is not None:
+            pulumi.set(__self__, "raw_key", raw_key)
+        if rsa_encrypted_key is not None:
+            pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
-    def kms_key_self_link(self) -> builtins.str:
+    def kms_key_self_link(self) -> Optional[builtins.str]:
         """
         The self link of the encryption key that is
-        stored in Google Cloud KMS.
+        stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
         """
         return pulumi.get(self, "kms_key_self_link")
 
@@ -27813,6 +28081,28 @@ class RegionInstanceTemplateDiskSourceImageEncryptionKey(dict):
         """
         return pulumi.get(self, "kms_key_service_account")
 
+    @property
+    @pulumi.getter(name="rawKey")
+    def raw_key(self) -> Optional[builtins.str]:
+        """
+        A 256-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+        to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "raw_key")
+
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> Optional[builtins.str]:
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt the given image. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
 
 @pulumi.output_type
 class RegionInstanceTemplateDiskSourceSnapshotEncryptionKey(dict):
@@ -27823,6 +28113,10 @@ class RegionInstanceTemplateDiskSourceSnapshotEncryptionKey(dict):
             suggest = "kms_key_self_link"
         elif key == "kmsKeyServiceAccount":
             suggest = "kms_key_service_account"
+        elif key == "rawKey":
+            suggest = "raw_key"
+        elif key == "rsaEncryptedKey":
+            suggest = "rsa_encrypted_key"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in RegionInstanceTemplateDiskSourceSnapshotEncryptionKey. Access the value via the '{suggest}' property getter instead.")
@@ -27836,25 +28130,42 @@ class RegionInstanceTemplateDiskSourceSnapshotEncryptionKey(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 kms_key_self_link: builtins.str,
-                 kms_key_service_account: Optional[builtins.str] = None):
+                 kms_key_self_link: Optional[builtins.str] = None,
+                 kms_key_service_account: Optional[builtins.str] = None,
+                 raw_key: Optional[builtins.str] = None,
+                 rsa_encrypted_key: Optional[builtins.str] = None):
         """
         :param builtins.str kms_key_self_link: The self link of the encryption key that is
-               stored in Google Cloud KMS.
+               stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         :param builtins.str kms_key_service_account: The service account being used for the
                encryption request for the given KMS key. If absent, the Compute Engine
                default service account is used.
+        :param builtins.str raw_key: A 256-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+               encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+               to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
+        :param builtins.str rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+               (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+               may be set.
         """
-        pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        if kms_key_self_link is not None:
+            pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         if kms_key_service_account is not None:
             pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
+        if raw_key is not None:
+            pulumi.set(__self__, "raw_key", raw_key)
+        if rsa_encrypted_key is not None:
+            pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
-    def kms_key_self_link(self) -> builtins.str:
+    def kms_key_self_link(self) -> Optional[builtins.str]:
         """
         The self link of the encryption key that is
-        stored in Google Cloud KMS.
+        stored in Google Cloud KMS. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
         """
         return pulumi.get(self, "kms_key_self_link")
 
@@ -27868,6 +28179,28 @@ class RegionInstanceTemplateDiskSourceSnapshotEncryptionKey(dict):
         """
         return pulumi.get(self, "kms_key_service_account")
 
+    @property
+    @pulumi.getter(name="rawKey")
+    def raw_key(self) -> Optional[builtins.str]:
+        """
+        A 256-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption),
+        encoded in [RFC 4648 base64](https://tools.ietf.org/html/rfc4648#section-4)
+        to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "raw_key")
+
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> Optional[builtins.str]:
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit [customer-supplied encryption key]
+        (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) to decrypt this snapshot. Only one of `kms_key_self_link`, `rsa_encrypted_key` and `raw_key`
+        may be set.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
 
 @pulumi.output_type
 class RegionInstanceTemplateGuestAccelerator(dict):
@@ -45266,6 +45599,456 @@ class SnapshotSourceDiskEncryptionKey(dict):
         return pulumi.get(self, "rsa_encrypted_key")
 
 
+@pulumi.output_type
+class StoragePoolIamBindingCondition(dict):
+    def __init__(__self__, *,
+                 expression: builtins.str,
+                 title: builtins.str,
+                 description: Optional[builtins.str] = None):
+        """
+        :param builtins.str expression: Textual representation of an expression in Common Expression Language syntax.
+        :param builtins.str title: A title for the expression, i.e. a short string describing its purpose.
+        """
+        pulumi.set(__self__, "expression", expression)
+        pulumi.set(__self__, "title", title)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> builtins.str:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @property
+    @pulumi.getter
+    def title(self) -> builtins.str:
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        return pulumi.get(self, "title")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "description")
+
+
+@pulumi.output_type
+class StoragePoolIamMemberCondition(dict):
+    def __init__(__self__, *,
+                 expression: builtins.str,
+                 title: builtins.str,
+                 description: Optional[builtins.str] = None):
+        """
+        :param builtins.str expression: Textual representation of an expression in Common Expression Language syntax.
+        :param builtins.str title: A title for the expression, i.e. a short string describing its purpose.
+        """
+        pulumi.set(__self__, "expression", expression)
+        pulumi.set(__self__, "title", title)
+        if description is not None:
+            pulumi.set(__self__, "description", description)
+
+    @property
+    @pulumi.getter
+    def expression(self) -> builtins.str:
+        """
+        Textual representation of an expression in Common Expression Language syntax.
+        """
+        return pulumi.get(self, "expression")
+
+    @property
+    @pulumi.getter
+    def title(self) -> builtins.str:
+        """
+        A title for the expression, i.e. a short string describing its purpose.
+        """
+        return pulumi.get(self, "title")
+
+    @property
+    @pulumi.getter
+    def description(self) -> Optional[builtins.str]:
+        return pulumi.get(self, "description")
+
+
+@pulumi.output_type
+class StoragePoolResourceStatus(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "diskCount":
+            suggest = "disk_count"
+        elif key == "lastResizeTimestamp":
+            suggest = "last_resize_timestamp"
+        elif key == "maxTotalProvisionedDiskCapacityGb":
+            suggest = "max_total_provisioned_disk_capacity_gb"
+        elif key == "poolUsedCapacityBytes":
+            suggest = "pool_used_capacity_bytes"
+        elif key == "poolUsedIops":
+            suggest = "pool_used_iops"
+        elif key == "poolUsedThroughput":
+            suggest = "pool_used_throughput"
+        elif key == "poolUserWrittenBytes":
+            suggest = "pool_user_written_bytes"
+        elif key == "totalProvisionedDiskCapacityGb":
+            suggest = "total_provisioned_disk_capacity_gb"
+        elif key == "totalProvisionedDiskIops":
+            suggest = "total_provisioned_disk_iops"
+        elif key == "totalProvisionedDiskThroughput":
+            suggest = "total_provisioned_disk_throughput"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in StoragePoolResourceStatus. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        StoragePoolResourceStatus.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        StoragePoolResourceStatus.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 disk_count: Optional[builtins.str] = None,
+                 last_resize_timestamp: Optional[builtins.str] = None,
+                 max_total_provisioned_disk_capacity_gb: Optional[builtins.str] = None,
+                 pool_used_capacity_bytes: Optional[builtins.str] = None,
+                 pool_used_iops: Optional[builtins.str] = None,
+                 pool_used_throughput: Optional[builtins.str] = None,
+                 pool_user_written_bytes: Optional[builtins.str] = None,
+                 total_provisioned_disk_capacity_gb: Optional[builtins.str] = None,
+                 total_provisioned_disk_iops: Optional[builtins.str] = None,
+                 total_provisioned_disk_throughput: Optional[builtins.str] = None):
+        """
+        :param builtins.str disk_count: (Output)
+               Number of disks used.
+        :param builtins.str last_resize_timestamp: (Output)
+               Timestamp of the last successful resize in RFC3339 text format.
+        :param builtins.str max_total_provisioned_disk_capacity_gb: (Output)
+               Maximum allowed aggregate disk size in gigabytes.
+        :param builtins.str pool_used_capacity_bytes: (Output)
+               Space used by data stored in disks within the storage pool (in bytes).
+               This will reflect the total number of bytes written to the disks in the pool, in contrast to the capacity of those disks.
+        :param builtins.str pool_used_iops: (Output)
+               Sum of all the disks' provisioned IOPS, minus some amount that is allowed per disk that is not counted towards pool's IOPS capacity. For more information, see https://cloud.google.com/compute/docs/disks/storage-pools.
+        :param builtins.str pool_used_throughput: (Output)
+               Sum of all the disks' provisioned throughput in MB/s.
+        :param builtins.str pool_user_written_bytes: (Output)
+               Amount of data written into the pool, before it is compacted.
+        :param builtins.str total_provisioned_disk_capacity_gb: (Output)
+               Sum of all the capacity provisioned in disks in this storage pool.
+               A disk's provisioned capacity is the same as its total capacity.
+        :param builtins.str total_provisioned_disk_iops: (Output)
+               Sum of all the disks' provisioned IOPS.
+        :param builtins.str total_provisioned_disk_throughput: (Output)
+               Sum of all the disks' provisioned throughput in MB/s,
+               minus some amount that is allowed per disk that is not counted towards pool's throughput capacity.
+        """
+        if disk_count is not None:
+            pulumi.set(__self__, "disk_count", disk_count)
+        if last_resize_timestamp is not None:
+            pulumi.set(__self__, "last_resize_timestamp", last_resize_timestamp)
+        if max_total_provisioned_disk_capacity_gb is not None:
+            pulumi.set(__self__, "max_total_provisioned_disk_capacity_gb", max_total_provisioned_disk_capacity_gb)
+        if pool_used_capacity_bytes is not None:
+            pulumi.set(__self__, "pool_used_capacity_bytes", pool_used_capacity_bytes)
+        if pool_used_iops is not None:
+            pulumi.set(__self__, "pool_used_iops", pool_used_iops)
+        if pool_used_throughput is not None:
+            pulumi.set(__self__, "pool_used_throughput", pool_used_throughput)
+        if pool_user_written_bytes is not None:
+            pulumi.set(__self__, "pool_user_written_bytes", pool_user_written_bytes)
+        if total_provisioned_disk_capacity_gb is not None:
+            pulumi.set(__self__, "total_provisioned_disk_capacity_gb", total_provisioned_disk_capacity_gb)
+        if total_provisioned_disk_iops is not None:
+            pulumi.set(__self__, "total_provisioned_disk_iops", total_provisioned_disk_iops)
+        if total_provisioned_disk_throughput is not None:
+            pulumi.set(__self__, "total_provisioned_disk_throughput", total_provisioned_disk_throughput)
+
+    @property
+    @pulumi.getter(name="diskCount")
+    def disk_count(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Number of disks used.
+        """
+        return pulumi.get(self, "disk_count")
+
+    @property
+    @pulumi.getter(name="lastResizeTimestamp")
+    def last_resize_timestamp(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Timestamp of the last successful resize in RFC3339 text format.
+        """
+        return pulumi.get(self, "last_resize_timestamp")
+
+    @property
+    @pulumi.getter(name="maxTotalProvisionedDiskCapacityGb")
+    def max_total_provisioned_disk_capacity_gb(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Maximum allowed aggregate disk size in gigabytes.
+        """
+        return pulumi.get(self, "max_total_provisioned_disk_capacity_gb")
+
+    @property
+    @pulumi.getter(name="poolUsedCapacityBytes")
+    def pool_used_capacity_bytes(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Space used by data stored in disks within the storage pool (in bytes).
+        This will reflect the total number of bytes written to the disks in the pool, in contrast to the capacity of those disks.
+        """
+        return pulumi.get(self, "pool_used_capacity_bytes")
+
+    @property
+    @pulumi.getter(name="poolUsedIops")
+    def pool_used_iops(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Sum of all the disks' provisioned IOPS, minus some amount that is allowed per disk that is not counted towards pool's IOPS capacity. For more information, see https://cloud.google.com/compute/docs/disks/storage-pools.
+        """
+        return pulumi.get(self, "pool_used_iops")
+
+    @property
+    @pulumi.getter(name="poolUsedThroughput")
+    def pool_used_throughput(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Sum of all the disks' provisioned throughput in MB/s.
+        """
+        return pulumi.get(self, "pool_used_throughput")
+
+    @property
+    @pulumi.getter(name="poolUserWrittenBytes")
+    def pool_user_written_bytes(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Amount of data written into the pool, before it is compacted.
+        """
+        return pulumi.get(self, "pool_user_written_bytes")
+
+    @property
+    @pulumi.getter(name="totalProvisionedDiskCapacityGb")
+    def total_provisioned_disk_capacity_gb(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Sum of all the capacity provisioned in disks in this storage pool.
+        A disk's provisioned capacity is the same as its total capacity.
+        """
+        return pulumi.get(self, "total_provisioned_disk_capacity_gb")
+
+    @property
+    @pulumi.getter(name="totalProvisionedDiskIops")
+    def total_provisioned_disk_iops(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Sum of all the disks' provisioned IOPS.
+        """
+        return pulumi.get(self, "total_provisioned_disk_iops")
+
+    @property
+    @pulumi.getter(name="totalProvisionedDiskThroughput")
+    def total_provisioned_disk_throughput(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Sum of all the disks' provisioned throughput in MB/s,
+        minus some amount that is allowed per disk that is not counted towards pool's throughput capacity.
+        """
+        return pulumi.get(self, "total_provisioned_disk_throughput")
+
+
+@pulumi.output_type
+class StoragePoolStatus(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "diskCount":
+            suggest = "disk_count"
+        elif key == "lastResizeTimestamp":
+            suggest = "last_resize_timestamp"
+        elif key == "maxTotalProvisionedDiskCapacityGb":
+            suggest = "max_total_provisioned_disk_capacity_gb"
+        elif key == "poolUsedCapacityBytes":
+            suggest = "pool_used_capacity_bytes"
+        elif key == "poolUsedIops":
+            suggest = "pool_used_iops"
+        elif key == "poolUsedThroughput":
+            suggest = "pool_used_throughput"
+        elif key == "poolUserWrittenBytes":
+            suggest = "pool_user_written_bytes"
+        elif key == "totalProvisionedDiskCapacityGb":
+            suggest = "total_provisioned_disk_capacity_gb"
+        elif key == "totalProvisionedDiskIops":
+            suggest = "total_provisioned_disk_iops"
+        elif key == "totalProvisionedDiskThroughput":
+            suggest = "total_provisioned_disk_throughput"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in StoragePoolStatus. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        StoragePoolStatus.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        StoragePoolStatus.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 disk_count: Optional[builtins.str] = None,
+                 last_resize_timestamp: Optional[builtins.str] = None,
+                 max_total_provisioned_disk_capacity_gb: Optional[builtins.str] = None,
+                 pool_used_capacity_bytes: Optional[builtins.str] = None,
+                 pool_used_iops: Optional[builtins.str] = None,
+                 pool_used_throughput: Optional[builtins.str] = None,
+                 pool_user_written_bytes: Optional[builtins.str] = None,
+                 total_provisioned_disk_capacity_gb: Optional[builtins.str] = None,
+                 total_provisioned_disk_iops: Optional[builtins.str] = None,
+                 total_provisioned_disk_throughput: Optional[builtins.str] = None):
+        """
+        :param builtins.str disk_count: (Output)
+               Number of disks used.
+        :param builtins.str last_resize_timestamp: (Output)
+               Timestamp of the last successful resize in RFC3339 text format.
+        :param builtins.str max_total_provisioned_disk_capacity_gb: (Output)
+               Maximum allowed aggregate disk size in gigabytes.
+        :param builtins.str pool_used_capacity_bytes: (Output)
+               Space used by data stored in disks within the storage pool (in bytes).
+               This will reflect the total number of bytes written to the disks in the pool, in contrast to the capacity of those disks.
+        :param builtins.str pool_used_iops: (Output)
+               Sum of all the disks' provisioned IOPS, minus some amount that is allowed per disk that is not counted towards pool's IOPS capacity. For more information, see https://cloud.google.com/compute/docs/disks/storage-pools.
+        :param builtins.str pool_used_throughput: (Output)
+               Sum of all the disks' provisioned throughput in MB/s.
+        :param builtins.str pool_user_written_bytes: (Output)
+               Amount of data written into the pool, before it is compacted.
+        :param builtins.str total_provisioned_disk_capacity_gb: (Output)
+               Sum of all the capacity provisioned in disks in this storage pool.
+               A disk's provisioned capacity is the same as its total capacity.
+        :param builtins.str total_provisioned_disk_iops: (Output)
+               Sum of all the disks' provisioned IOPS.
+        :param builtins.str total_provisioned_disk_throughput: (Output)
+               Sum of all the disks' provisioned throughput in MB/s,
+               minus some amount that is allowed per disk that is not counted towards pool's throughput capacity.
+        """
+        if disk_count is not None:
+            pulumi.set(__self__, "disk_count", disk_count)
+        if last_resize_timestamp is not None:
+            pulumi.set(__self__, "last_resize_timestamp", last_resize_timestamp)
+        if max_total_provisioned_disk_capacity_gb is not None:
+            pulumi.set(__self__, "max_total_provisioned_disk_capacity_gb", max_total_provisioned_disk_capacity_gb)
+        if pool_used_capacity_bytes is not None:
+            pulumi.set(__self__, "pool_used_capacity_bytes", pool_used_capacity_bytes)
+        if pool_used_iops is not None:
+            pulumi.set(__self__, "pool_used_iops", pool_used_iops)
+        if pool_used_throughput is not None:
+            pulumi.set(__self__, "pool_used_throughput", pool_used_throughput)
+        if pool_user_written_bytes is not None:
+            pulumi.set(__self__, "pool_user_written_bytes", pool_user_written_bytes)
+        if total_provisioned_disk_capacity_gb is not None:
+            pulumi.set(__self__, "total_provisioned_disk_capacity_gb", total_provisioned_disk_capacity_gb)
+        if total_provisioned_disk_iops is not None:
+            pulumi.set(__self__, "total_provisioned_disk_iops", total_provisioned_disk_iops)
+        if total_provisioned_disk_throughput is not None:
+            pulumi.set(__self__, "total_provisioned_disk_throughput", total_provisioned_disk_throughput)
+
+    @property
+    @pulumi.getter(name="diskCount")
+    def disk_count(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Number of disks used.
+        """
+        return pulumi.get(self, "disk_count")
+
+    @property
+    @pulumi.getter(name="lastResizeTimestamp")
+    def last_resize_timestamp(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Timestamp of the last successful resize in RFC3339 text format.
+        """
+        return pulumi.get(self, "last_resize_timestamp")
+
+    @property
+    @pulumi.getter(name="maxTotalProvisionedDiskCapacityGb")
+    def max_total_provisioned_disk_capacity_gb(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Maximum allowed aggregate disk size in gigabytes.
+        """
+        return pulumi.get(self, "max_total_provisioned_disk_capacity_gb")
+
+    @property
+    @pulumi.getter(name="poolUsedCapacityBytes")
+    def pool_used_capacity_bytes(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Space used by data stored in disks within the storage pool (in bytes).
+        This will reflect the total number of bytes written to the disks in the pool, in contrast to the capacity of those disks.
+        """
+        return pulumi.get(self, "pool_used_capacity_bytes")
+
+    @property
+    @pulumi.getter(name="poolUsedIops")
+    def pool_used_iops(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Sum of all the disks' provisioned IOPS, minus some amount that is allowed per disk that is not counted towards pool's IOPS capacity. For more information, see https://cloud.google.com/compute/docs/disks/storage-pools.
+        """
+        return pulumi.get(self, "pool_used_iops")
+
+    @property
+    @pulumi.getter(name="poolUsedThroughput")
+    def pool_used_throughput(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Sum of all the disks' provisioned throughput in MB/s.
+        """
+        return pulumi.get(self, "pool_used_throughput")
+
+    @property
+    @pulumi.getter(name="poolUserWrittenBytes")
+    def pool_user_written_bytes(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Amount of data written into the pool, before it is compacted.
+        """
+        return pulumi.get(self, "pool_user_written_bytes")
+
+    @property
+    @pulumi.getter(name="totalProvisionedDiskCapacityGb")
+    def total_provisioned_disk_capacity_gb(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Sum of all the capacity provisioned in disks in this storage pool.
+        A disk's provisioned capacity is the same as its total capacity.
+        """
+        return pulumi.get(self, "total_provisioned_disk_capacity_gb")
+
+    @property
+    @pulumi.getter(name="totalProvisionedDiskIops")
+    def total_provisioned_disk_iops(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Sum of all the disks' provisioned IOPS.
+        """
+        return pulumi.get(self, "total_provisioned_disk_iops")
+
+    @property
+    @pulumi.getter(name="totalProvisionedDiskThroughput")
+    def total_provisioned_disk_throughput(self) -> Optional[builtins.str]:
+        """
+        (Output)
+        Sum of all the disks' provisioned throughput in MB/s,
+        minus some amount that is allowed per disk that is not counted towards pool's throughput capacity.
+        """
+        return pulumi.get(self, "total_provisioned_disk_throughput")
+
+
 @pulumi.output_type
 class SubnetworkIAMBindingCondition(dict):
     def __init__(__self__, *,
@@ -53114,10 +53897,13 @@ class GetBackendBucketCdnPolicyResult(dict):
         :param Sequence['GetBackendBucketCdnPolicyCacheKeyPolicyArgs'] cache_key_policies: The CacheKeyPolicy for this CdnPolicy.
         :param builtins.str cache_mode: Specifies the cache setting for all responses from this backend.
                The possible values are: USE_ORIGIN_HEADERS, FORCE_CACHE_ALL and CACHE_ALL_STATIC Possible values: ["USE_ORIGIN_HEADERS", "FORCE_CACHE_ALL", "CACHE_ALL_STATIC"]
-        :param builtins.int client_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
+        :param builtins.int client_ttl: Specifies the maximum allowed TTL for cached content served by this origin. When the
+               'cache_mode' is set to "USE_ORIGIN_HEADERS", you must omit this field.
         :param builtins.int default_ttl: Specifies the default TTL for cached content served by this origin for responses
-               that do not have an existing valid TTL (max-age or s-max-age).
-        :param builtins.int max_ttl: Specifies the maximum allowed TTL for cached content served by this origin.
+               that do not have an existing valid TTL (max-age or s-max-age). When the 'cache_mode'
+               is set to "USE_ORIGIN_HEADERS", you must omit this field.
+        :param builtins.int max_ttl: Specifies the maximum allowed TTL for cached content served by this origin. When the
+               'cache_mode' is set to "USE_ORIGIN_HEADERS", you must omit this field.
         :param builtins.bool negative_caching: Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects.
         :param Sequence['GetBackendBucketCdnPolicyNegativeCachingPolicyArgs'] negative_caching_policies: Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
                Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.
@@ -53173,7 +53959,8 @@ class GetBackendBucketCdnPolicyResult(dict):
     @pulumi.getter(name="clientTtl")
     def client_ttl(self) -> builtins.int:
         """
-        Specifies the maximum allowed TTL for cached content served by this origin.
+        Specifies the maximum allowed TTL for cached content served by this origin. When the
+        'cache_mode' is set to "USE_ORIGIN_HEADERS", you must omit this field.
         """
         return pulumi.get(self, "client_ttl")
 
@@ -53182,7 +53969,8 @@ class GetBackendBucketCdnPolicyResult(dict):
     def default_ttl(self) -> builtins.int:
         """
         Specifies the default TTL for cached content served by this origin for responses
-        that do not have an existing valid TTL (max-age or s-max-age).
+        that do not have an existing valid TTL (max-age or s-max-age). When the 'cache_mode'
+        is set to "USE_ORIGIN_HEADERS", you must omit this field.
         """
         return pulumi.get(self, "default_ttl")
 
@@ -53190,7 +53978,8 @@ class GetBackendBucketCdnPolicyResult(dict):
     @pulumi.getter(name="maxTtl")
     def max_ttl(self) -> builtins.int:
         """
-        Specifies the maximum allowed TTL for cached content served by this origin.
+        Specifies the maximum allowed TTL for cached content served by this origin. When the
+        'cache_mode' is set to "USE_ORIGIN_HEADERS", you must omit this field.
         """
         return pulumi.get(self, "max_ttl")
 
@@ -53343,7 +54132,8 @@ class GetBackendServiceBackendResult(dict):
                  max_rate: builtins.int,
                  max_rate_per_endpoint: builtins.float,
                  max_rate_per_instance: builtins.float,
-                 max_utilization: builtins.float):
+                 max_utilization: builtins.float,
+                 preference: builtins.str):
         """
         :param builtins.str balancing_mode: Specifies the balancing mode for this backend.
                
@@ -53415,6 +54205,12 @@ class GetBackendServiceBackendResult(dict):
                either maxRate or maxRatePerInstance must be set.
         :param builtins.float max_utilization: Used when balancingMode is UTILIZATION. This ratio defines the
                CPU utilization target for the group. Valid range is [0.0, 1.0].
+        :param builtins.str preference: This field indicates whether this backend should be fully utilized before sending traffic to backends
+               with default preference. This field cannot be set when loadBalancingScheme is set to 'EXTERNAL'. The possible values are:
+                 - PREFERRED: Backends with this preference level will be filled up to their capacity limits first,
+                   based on RTT.
+                 - DEFAULT: If preferred backends don't have enough capacity, backends in this layer would be used and
+                   traffic would be assigned based on the load balancing algorithm you use. This is the default Possible values: ["PREFERRED", "DEFAULT"]
         """
         pulumi.set(__self__, "balancing_mode", balancing_mode)
         pulumi.set(__self__, "capacity_scaler", capacity_scaler)
@@ -53428,6 +54224,7 @@ class GetBackendServiceBackendResult(dict):
         pulumi.set(__self__, "max_rate_per_endpoint", max_rate_per_endpoint)
         pulumi.set(__self__, "max_rate_per_instance", max_rate_per_instance)
         pulumi.set(__self__, "max_utilization", max_utilization)
+        pulumi.set(__self__, "preference", preference)
 
     @property
     @pulumi.getter(name="balancingMode")
@@ -53583,6 +54380,19 @@ class GetBackendServiceBackendResult(dict):
         """
         return pulumi.get(self, "max_utilization")
 
+    @property
+    @pulumi.getter
+    def preference(self) -> builtins.str:
+        """
+        This field indicates whether this backend should be fully utilized before sending traffic to backends
+        with default preference. This field cannot be set when loadBalancingScheme is set to 'EXTERNAL'. The possible values are:
+          - PREFERRED: Backends with this preference level will be filled up to their capacity limits first,
+            based on RTT.
+          - DEFAULT: If preferred backends don't have enough capacity, backends in this layer would be used and
+            traffic would be assigned based on the load balancing algorithm you use. This is the default Possible values: ["PREFERRED", "DEFAULT"]
+        """
+        return pulumi.get(self, "preference")
+
 
 @pulumi.output_type
 class GetBackendServiceBackendCustomMetricResult(dict):
@@ -53643,6 +54453,7 @@ class GetBackendServiceCdnPolicyResult(dict):
                  max_ttl: builtins.int,
                  negative_caching: builtins.bool,
                  negative_caching_policies: Sequence['outputs.GetBackendServiceCdnPolicyNegativeCachingPolicyResult'],
+                 request_coalescing: builtins.bool,
                  serve_while_stale: builtins.int,
                  signed_url_cache_max_age_sec: builtins.int):
         """
@@ -53658,6 +54469,8 @@ class GetBackendServiceCdnPolicyResult(dict):
         :param builtins.bool negative_caching: Negative caching allows per-status code TTLs to be set, in order to apply fine-grained caching for common errors or redirects.
         :param Sequence['GetBackendServiceCdnPolicyNegativeCachingPolicyArgs'] negative_caching_policies: Sets a cache TTL for the specified HTTP status code. negativeCaching must be enabled to configure negativeCachingPolicy.
                Omitting the policy and leaving negativeCaching enabled will use Cloud CDN's default cache TTLs.
+        :param builtins.bool request_coalescing: If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests
+               to the origin.
         :param builtins.int serve_while_stale: Serve existing content from the cache (if available) when revalidating content with the origin, or when an error is encountered when refreshing the cache.
         :param builtins.int signed_url_cache_max_age_sec: Maximum number of seconds the response to a signed URL request
                will be considered fresh, defaults to 1hr (3600s). After this
@@ -53678,6 +54491,7 @@ class GetBackendServiceCdnPolicyResult(dict):
         pulumi.set(__self__, "max_ttl", max_ttl)
         pulumi.set(__self__, "negative_caching", negative_caching)
         pulumi.set(__self__, "negative_caching_policies", negative_caching_policies)
+        pulumi.set(__self__, "request_coalescing", request_coalescing)
         pulumi.set(__self__, "serve_while_stale", serve_while_stale)
         pulumi.set(__self__, "signed_url_cache_max_age_sec", signed_url_cache_max_age_sec)
 
@@ -53749,6 +54563,15 @@ class GetBackendServiceCdnPolicyResult(dict):
         """
         return pulumi.get(self, "negative_caching_policies")
 
+    @property
+    @pulumi.getter(name="requestCoalescing")
+    def request_coalescing(self) -> builtins.bool:
+        """
+        If true then Cloud CDN will combine multiple concurrent cache fill requests into a small number of requests
+        to the origin.
+        """
+        return pulumi.get(self, "request_coalescing")
+
     @property
     @pulumi.getter(name="serveWhileStale")
     def serve_while_stale(self) -> builtins.int:
@@ -54383,15 +55206,24 @@ class GetBackendServiceLocalityLbPolicyPolicyResult(dict):
 class GetBackendServiceLogConfigResult(dict):
     def __init__(__self__, *,
                  enable: builtins.bool,
+                 optional_fields: Sequence[builtins.str],
+                 optional_mode: builtins.str,
                  sample_rate: builtins.float):
         """
         :param builtins.bool enable: Whether to enable logging for the load balancer traffic served by this backend service.
+        :param Sequence[builtins.str] optional_fields: This field can only be specified if logging is enabled for this backend service and "logConfig.optionalMode"
+               was set to CUSTOM. Contains a list of optional fields you want to include in the logs.
+               For example: serverInstance, serverGkeDetails.cluster, serverGkeDetails.pod.podNamespace
+        :param builtins.str optional_mode: Specifies the optional logging mode for the load balancer traffic.
+               Supported values: INCLUDE_ALL_OPTIONAL, EXCLUDE_ALL_OPTIONAL, CUSTOM. Possible values: ["INCLUDE_ALL_OPTIONAL", "EXCLUDE_ALL_OPTIONAL", "CUSTOM"]
         :param builtins.float sample_rate: This field can only be specified if logging is enabled for this backend service. The value of
                the field must be in [0, 1]. This configures the sampling rate of requests to the load balancer
                where 1.0 means all logged requests are reported and 0.0 means no logged requests are reported.
                The default value is 1.0.
         """
         pulumi.set(__self__, "enable", enable)
+        pulumi.set(__self__, "optional_fields", optional_fields)
+        pulumi.set(__self__, "optional_mode", optional_mode)
         pulumi.set(__self__, "sample_rate", sample_rate)
 
     @property
@@ -54402,6 +55234,25 @@ class GetBackendServiceLogConfigResult(dict):
         """
         return pulumi.get(self, "enable")
 
+    @property
+    @pulumi.getter(name="optionalFields")
+    def optional_fields(self) -> Sequence[builtins.str]:
+        """
+        This field can only be specified if logging is enabled for this backend service and "logConfig.optionalMode"
+        was set to CUSTOM. Contains a list of optional fields you want to include in the logs.
+        For example: serverInstance, serverGkeDetails.cluster, serverGkeDetails.pod.podNamespace
+        """
+        return pulumi.get(self, "optional_fields")
+
+    @property
+    @pulumi.getter(name="optionalMode")
+    def optional_mode(self) -> builtins.str:
+        """
+        Specifies the optional logging mode for the load balancer traffic.
+        Supported values: INCLUDE_ALL_OPTIONAL, EXCLUDE_ALL_OPTIONAL, CUSTOM. Possible values: ["INCLUDE_ALL_OPTIONAL", "EXCLUDE_ALL_OPTIONAL", "CUSTOM"]
+        """
+        return pulumi.get(self, "optional_mode")
+
     @property
     @pulumi.getter(name="sampleRate")
     def sample_rate(self) -> builtins.float:
@@ -54414,6 +55265,39 @@ class GetBackendServiceLogConfigResult(dict):
         return pulumi.get(self, "sample_rate")
 
 
+@pulumi.output_type
+class GetBackendServiceMaxStreamDurationResult(dict):
+    def __init__(__self__, *,
+                 nanos: builtins.int,
+                 seconds: builtins.str):
+        """
+        :param builtins.int nanos: Span of time that's a fraction of a second at nanosecond resolution.
+               Durations less than one second are represented with a 0 seconds field and a positive nanos field.
+               Must be from 0 to 999,999,999 inclusive.
+        :param builtins.str seconds: Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive. (int64 format)
+        """
+        pulumi.set(__self__, "nanos", nanos)
+        pulumi.set(__self__, "seconds", seconds)
+
+    @property
+    @pulumi.getter
+    def nanos(self) -> builtins.int:
+        """
+        Span of time that's a fraction of a second at nanosecond resolution.
+        Durations less than one second are represented with a 0 seconds field and a positive nanos field.
+        Must be from 0 to 999,999,999 inclusive.
+        """
+        return pulumi.get(self, "nanos")
+
+    @property
+    @pulumi.getter
+    def seconds(self) -> builtins.str:
+        """
+        Span of time at a resolution of a second. Must be from 0 to 315,576,000,000 inclusive. (int64 format)
+        """
+        return pulumi.get(self, "seconds")
+
+
 @pulumi.output_type
 class GetBackendServiceOutlierDetectionResult(dict):
     def __init__(__self__, *,
@@ -59786,11 +60670,14 @@ class GetInstanceTemplateDiskResult(dict):
 @pulumi.output_type
 class GetInstanceTemplateDiskDiskEncryptionKeyResult(dict):
     def __init__(__self__, *,
-                 kms_key_self_link: builtins.str):
+                 kms_key_self_link: builtins.str,
+                 kms_key_service_account: builtins.str):
         """
         :param builtins.str kms_key_self_link: The self link of the encryption key that is stored in Google Cloud KMS
+        :param builtins.str kms_key_service_account: The service account being used for the encryption request for the given KMS key. If absent, the Compute Engine default service account is used.
         """
         pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
@@ -59800,20 +60687,34 @@ class GetInstanceTemplateDiskDiskEncryptionKeyResult(dict):
         """
         return pulumi.get(self, "kms_key_self_link")
 
+    @property
+    @pulumi.getter(name="kmsKeyServiceAccount")
+    def kms_key_service_account(self) -> builtins.str:
+        """
+        The service account being used for the encryption request for the given KMS key. If absent, the Compute Engine default service account is used.
+        """
+        return pulumi.get(self, "kms_key_service_account")
+
 
 @pulumi.output_type
 class GetInstanceTemplateDiskSourceImageEncryptionKeyResult(dict):
     def __init__(__self__, *,
                  kms_key_self_link: builtins.str,
-                 kms_key_service_account: builtins.str):
+                 kms_key_service_account: builtins.str,
+                 raw_key: builtins.str,
+                 rsa_encrypted_key: builtins.str):
         """
         :param builtins.str kms_key_self_link: The self link of the encryption key that is stored in Google Cloud KMS
         :param builtins.str kms_key_service_account: The service account being used for the encryption
                request for the given KMS key. If absent, the Compute
                Engine default service account is used.
+        :param builtins.str raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in RFC 4648 base64 to either encrypt or decrypt this resource. Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
+        :param builtins.str rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit customer-supplied encryption key to either encrypt or decrypt this resource. Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
         """
         pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
+        pulumi.set(__self__, "raw_key", raw_key)
+        pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
@@ -59833,20 +60734,42 @@ class GetInstanceTemplateDiskSourceImageEncryptionKeyResult(dict):
         """
         return pulumi.get(self, "kms_key_service_account")
 
+    @property
+    @pulumi.getter(name="rawKey")
+    def raw_key(self) -> builtins.str:
+        """
+        Specifies a 256-bit customer-supplied encryption key, encoded in RFC 4648 base64 to either encrypt or decrypt this resource. Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
+        """
+        return pulumi.get(self, "raw_key")
+
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> builtins.str:
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit customer-supplied encryption key to either encrypt or decrypt this resource. Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
 
 @pulumi.output_type
 class GetInstanceTemplateDiskSourceSnapshotEncryptionKeyResult(dict):
     def __init__(__self__, *,
                  kms_key_self_link: builtins.str,
-                 kms_key_service_account: builtins.str):
+                 kms_key_service_account: builtins.str,
+                 raw_key: builtins.str,
+                 rsa_encrypted_key: builtins.str):
         """
         :param builtins.str kms_key_self_link: The self link of the encryption key that is stored in Google Cloud KMS
         :param builtins.str kms_key_service_account: The service account being used for the encryption
                request for the given KMS key. If absent, the Compute
                Engine default service account is used.
+        :param builtins.str raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in RFC 4648 base64 to either encrypt or decrypt this resource. Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
+        :param builtins.str rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit customer-supplied encryption key to either encrypt or decrypt this resource. Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
         """
         pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
+        pulumi.set(__self__, "raw_key", raw_key)
+        pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
@@ -59866,6 +60789,22 @@ class GetInstanceTemplateDiskSourceSnapshotEncryptionKeyResult(dict):
         """
         return pulumi.get(self, "kms_key_service_account")
 
+    @property
+    @pulumi.getter(name="rawKey")
+    def raw_key(self) -> builtins.str:
+        """
+        Specifies a 256-bit customer-supplied encryption key, encoded in RFC 4648 base64 to either encrypt or decrypt this resource. Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
+        """
+        return pulumi.get(self, "raw_key")
+
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> builtins.str:
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit customer-supplied encryption key to either encrypt or decrypt this resource. Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
 
 @pulumi.output_type
 class GetInstanceTemplateGuestAcceleratorResult(dict):
@@ -63795,11 +64734,14 @@ class GetRegionInstanceTemplateDiskResult(dict):
 @pulumi.output_type
 class GetRegionInstanceTemplateDiskDiskEncryptionKeyResult(dict):
     def __init__(__self__, *,
-                 kms_key_self_link: builtins.str):
+                 kms_key_self_link: builtins.str,
+                 kms_key_service_account: builtins.str):
         """
         :param builtins.str kms_key_self_link: The self link of the encryption key that is stored in Google Cloud KMS
+        :param builtins.str kms_key_service_account: The service account being used for the encryption request for the given KMS key. If absent, the Compute Engine default service account is used.
         """
         pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
+        pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
@@ -63809,20 +64751,34 @@ class GetRegionInstanceTemplateDiskDiskEncryptionKeyResult(dict):
         """
         return pulumi.get(self, "kms_key_self_link")
 
+    @property
+    @pulumi.getter(name="kmsKeyServiceAccount")
+    def kms_key_service_account(self) -> builtins.str:
+        """
+        The service account being used for the encryption request for the given KMS key. If absent, the Compute Engine default service account is used.
+        """
+        return pulumi.get(self, "kms_key_service_account")
+
 
 @pulumi.output_type
 class GetRegionInstanceTemplateDiskSourceImageEncryptionKeyResult(dict):
     def __init__(__self__, *,
                  kms_key_self_link: builtins.str,
-                 kms_key_service_account: builtins.str):
+                 kms_key_service_account: builtins.str,
+                 raw_key: builtins.str,
+                 rsa_encrypted_key: builtins.str):
         """
         :param builtins.str kms_key_self_link: The self link of the encryption key that is stored in Google Cloud KMS
         :param builtins.str kms_key_service_account: The service account being used for the encryption
                request for the given KMS key. If absent, the Compute
                Engine default service account is used.
+        :param builtins.str raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in RFC 4648 base64 to either encrypt or decrypt this resource.  Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
+        :param builtins.str rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit customer-supplied encryption key to either encrypt or decrypt this resource.  Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
         """
         pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
+        pulumi.set(__self__, "raw_key", raw_key)
+        pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
@@ -63842,20 +64798,42 @@ class GetRegionInstanceTemplateDiskSourceImageEncryptionKeyResult(dict):
         """
         return pulumi.get(self, "kms_key_service_account")
 
+    @property
+    @pulumi.getter(name="rawKey")
+    def raw_key(self) -> builtins.str:
+        """
+        Specifies a 256-bit customer-supplied encryption key, encoded in RFC 4648 base64 to either encrypt or decrypt this resource.  Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
+        """
+        return pulumi.get(self, "raw_key")
+
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> builtins.str:
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit customer-supplied encryption key to either encrypt or decrypt this resource.  Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
 
 @pulumi.output_type
 class GetRegionInstanceTemplateDiskSourceSnapshotEncryptionKeyResult(dict):
     def __init__(__self__, *,
                  kms_key_self_link: builtins.str,
-                 kms_key_service_account: builtins.str):
+                 kms_key_service_account: builtins.str,
+                 raw_key: builtins.str,
+                 rsa_encrypted_key: builtins.str):
         """
         :param builtins.str kms_key_self_link: The self link of the encryption key that is stored in Google Cloud KMS
         :param builtins.str kms_key_service_account: The service account being used for the encryption
                request for the given KMS key. If absent, the Compute
                Engine default service account is used.
+        :param builtins.str raw_key: Specifies a 256-bit customer-supplied encryption key, encoded in RFC 4648 base64 to either encrypt or decrypt this resource. Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
+        :param builtins.str rsa_encrypted_key: Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit customer-supplied encryption key to either encrypt or decrypt this resource.  Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
         """
         pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         pulumi.set(__self__, "kms_key_service_account", kms_key_service_account)
+        pulumi.set(__self__, "raw_key", raw_key)
+        pulumi.set(__self__, "rsa_encrypted_key", rsa_encrypted_key)
 
     @property
     @pulumi.getter(name="kmsKeySelfLink")
@@ -63875,6 +64853,22 @@ class GetRegionInstanceTemplateDiskSourceSnapshotEncryptionKeyResult(dict):
         """
         return pulumi.get(self, "kms_key_service_account")
 
+    @property
+    @pulumi.getter(name="rawKey")
+    def raw_key(self) -> builtins.str:
+        """
+        Specifies a 256-bit customer-supplied encryption key, encoded in RFC 4648 base64 to either encrypt or decrypt this resource. Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
+        """
+        return pulumi.get(self, "raw_key")
+
+    @property
+    @pulumi.getter(name="rsaEncryptedKey")
+    def rsa_encrypted_key(self) -> builtins.str:
+        """
+        Specifies an RFC 4648 base64 encoded, RSA-wrapped 2048-bit customer-supplied encryption key to either encrypt or decrypt this resource.  Only one of kms_key_self_link, rsa_encrypted_key and raw_key may be set.
+        """
+        return pulumi.get(self, "rsa_encrypted_key")
+
 
 @pulumi.output_type
 class GetRegionInstanceTemplateGuestAcceleratorResult(dict):
@@ -68334,6 +69328,84 @@ class GetSnapshotSourceDiskEncryptionKeyResult(dict):
         return pulumi.get(self, "rsa_encrypted_key")
 
 
+@pulumi.output_type
+class GetStoragePoolTypesDeprecatedResult(dict):
+    def __init__(__self__, *,
+                 deleted: builtins.str,
+                 deprecated: builtins.str,
+                 obsolete: builtins.str,
+                 replacement: builtins.str,
+                 state: builtins.str):
+        """
+        :param builtins.str deleted: An optional RFC3339 timestamp on or after which the state of this resource is intended to change to DELETED.
+               This is only informational and the status will not change unless the client explicitly changes it.
+        :param builtins.str deprecated: An optional RFC3339 timestamp on or after which the state of this resource is intended to change to DEPRECATED.
+               This is only informational and the status will not change unless the client explicitly changes it.
+        :param builtins.str obsolete: An optional RFC3339 timestamp on or after which the state of this resource is intended to change to OBSOLETE.
+               This is only informational and the status will not change unless the client explicitly changes it.
+        :param builtins.str replacement: The URL of the suggested replacement for a deprecated resource.
+               The suggested replacement resource must be the same kind of resource as the deprecated resource.
+        :param builtins.str state: The deprecation state of this resource. This can be ACTIVE, DEPRECATED, OBSOLETE, or DELETED.
+               Operations which communicate the end of life date for an image, can use ACTIVE.
+               Operations which create a new resource using a DEPRECATED resource will return successfully,
+               but with a warning indicating the deprecated resource and recommending its replacement.
+               Operations which use OBSOLETE or DELETED resources will be rejected and result in an error.
+        """
+        pulumi.set(__self__, "deleted", deleted)
+        pulumi.set(__self__, "deprecated", deprecated)
+        pulumi.set(__self__, "obsolete", obsolete)
+        pulumi.set(__self__, "replacement", replacement)
+        pulumi.set(__self__, "state", state)
+
+    @property
+    @pulumi.getter
+    def deleted(self) -> builtins.str:
+        """
+        An optional RFC3339 timestamp on or after which the state of this resource is intended to change to DELETED.
+        This is only informational and the status will not change unless the client explicitly changes it.
+        """
+        return pulumi.get(self, "deleted")
+
+    @property
+    @pulumi.getter
+    def deprecated(self) -> builtins.str:
+        """
+        An optional RFC3339 timestamp on or after which the state of this resource is intended to change to DEPRECATED.
+        This is only informational and the status will not change unless the client explicitly changes it.
+        """
+        return pulumi.get(self, "deprecated")
+
+    @property
+    @pulumi.getter
+    def obsolete(self) -> builtins.str:
+        """
+        An optional RFC3339 timestamp on or after which the state of this resource is intended to change to OBSOLETE.
+        This is only informational and the status will not change unless the client explicitly changes it.
+        """
+        return pulumi.get(self, "obsolete")
+
+    @property
+    @pulumi.getter
+    def replacement(self) -> builtins.str:
+        """
+        The URL of the suggested replacement for a deprecated resource.
+        The suggested replacement resource must be the same kind of resource as the deprecated resource.
+        """
+        return pulumi.get(self, "replacement")
+
+    @property
+    @pulumi.getter
+    def state(self) -> builtins.str:
+        """
+        The deprecation state of this resource. This can be ACTIVE, DEPRECATED, OBSOLETE, or DELETED.
+        Operations which communicate the end of life date for an image, can use ACTIVE.
+        Operations which create a new resource using a DEPRECATED resource will return successfully,
+        but with a warning indicating the deprecated resource and recommending its replacement.
+        Operations which use OBSOLETE or DELETED resources will be rejected and result in an error.
+        """
+        return pulumi.get(self, "state")
+
+
 @pulumi.output_type
 class GetSubnetworkSecondaryIpRangeResult(dict):
     def __init__(__self__, *,