pulumi-gcp 8.31.0a1747205151__py3-none-any.whl → 8.32.0__py3-none-any.whl

pulumi_gcp/compute/outputs.py

@@ -88,6 +88,7 @@ __all__ = [
     'GlobalForwardingRuleServiceDirectoryRegistrations',
     'HaVpnGatewayVpnInterface',
     'HealthCheckGrpcHealthCheck',
+    'HealthCheckGrpcTlsHealthCheck',
     'HealthCheckHttp2HealthCheck',
     'HealthCheckHttpHealthCheck',
     'HealthCheckHttpsHealthCheck',
@@ -330,6 +331,7 @@ __all__ = [
     'RegionDiskIamMemberCondition',
     'RegionDiskSourceSnapshotEncryptionKey',
     'RegionHealthCheckGrpcHealthCheck',
+    'RegionHealthCheckGrpcTlsHealthCheck',
     'RegionHealthCheckHttp2HealthCheck',
     'RegionHealthCheckHttpHealthCheck',
     'RegionHealthCheckHttpsHealthCheck',
@@ -755,6 +757,7 @@ __all__ = [
     'GetGlobalForwardingRuleServiceDirectoryRegistrationResult',
     'GetHcVpnGatewayVpnInterfaceResult',
     'GetHealthCheckGrpcHealthCheckResult',
+    'GetHealthCheckGrpcTlsHealthCheckResult',
     'GetHealthCheckHttp2HealthCheckResult',
     'GetHealthCheckHttpHealthCheckResult',
     'GetHealthCheckHttpsHealthCheckResult',
@@ -6839,6 +6842,96 @@ class HealthCheckGrpcHealthCheck(dict):
         return pulumi.get(self, "port_specification")
 
 
+@pulumi.output_type
+class HealthCheckGrpcTlsHealthCheck(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "grpcServiceName":
+            suggest = "grpc_service_name"
+        elif key == "portSpecification":
+            suggest = "port_specification"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in HealthCheckGrpcTlsHealthCheck. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        HealthCheckGrpcTlsHealthCheck.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        HealthCheckGrpcTlsHealthCheck.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 grpc_service_name: Optional[builtins.str] = None,
+                 port: Optional[builtins.int] = None,
+                 port_specification: Optional[builtins.str] = None):
+        """
+        :param builtins.str grpc_service_name: The gRPC service name for the health check.
+               The value of grpcServiceName has the following meanings by convention:
+               - Empty serviceName means the overall status of all services at the backend.
+               - Non-empty serviceName means the health of that gRPC service, as defined by the owner of the service.
+               The grpcServiceName can only be ASCII.
+        :param builtins.int port: The port number for the health check request.
+               Must be specified if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
+        :param builtins.str port_specification: Specifies how port is selected for health checking, can be one of the
+               following values:
+               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
+               * `USE_NAMED_PORT`: Not supported for GRPC with TLS health checking.
+               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
+               network endpoint is used for health checking. For other backends, the
+               port or named port specified in the Backend Service is used for health
+               checking.
+               If not specified, gRPC with TLS health check follows behavior specified in the `port` field.
+               Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
+        """
+        if grpc_service_name is not None:
+            pulumi.set(__self__, "grpc_service_name", grpc_service_name)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if port_specification is not None:
+            pulumi.set(__self__, "port_specification", port_specification)
+
+    @property
+    @pulumi.getter(name="grpcServiceName")
+    def grpc_service_name(self) -> Optional[builtins.str]:
+        """
+        The gRPC service name for the health check.
+        The value of grpcServiceName has the following meanings by convention:
+        - Empty serviceName means the overall status of all services at the backend.
+        - Non-empty serviceName means the health of that gRPC service, as defined by the owner of the service.
+        The grpcServiceName can only be ASCII.
+        """
+        return pulumi.get(self, "grpc_service_name")
+
+    @property
+    @pulumi.getter
+    def port(self) -> Optional[builtins.int]:
+        """
+        The port number for the health check request.
+        Must be specified if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
+        """
+        return pulumi.get(self, "port")
+
+    @property
+    @pulumi.getter(name="portSpecification")
+    def port_specification(self) -> Optional[builtins.str]:
+        """
+        Specifies how port is selected for health checking, can be one of the
+        following values:
+        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
+        * `USE_NAMED_PORT`: Not supported for GRPC with TLS health checking.
+        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
+        network endpoint is used for health checking. For other backends, the
+        port or named port specified in the Backend Service is used for health
+        checking.
+        If not specified, gRPC with TLS health check follows behavior specified in the `port` field.
+        Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
+        """
+        return pulumi.get(self, "port_specification")
+
+
 @pulumi.output_type
 class HealthCheckHttp2HealthCheck(dict):
     @staticmethod
@@ -8569,6 +8662,8 @@ class InstanceAttachedDisk(dict):
             suggest = "disk_encryption_key_sha256"
         elif key == "diskEncryptionServiceAccount":
             suggest = "disk_encryption_service_account"
+        elif key == "forceAttach":
+            suggest = "force_attach"
         elif key == "kmsKeySelfLink":
             suggest = "kms_key_self_link"
 
@@ -8590,6 +8685,7 @@ class InstanceAttachedDisk(dict):
                  disk_encryption_key_rsa: Optional[builtins.str] = None,
                  disk_encryption_key_sha256: Optional[builtins.str] = None,
                  disk_encryption_service_account: Optional[builtins.str] = None,
+                 force_attach: Optional[builtins.bool] = None,
                  kms_key_self_link: Optional[builtins.str] = None,
                  mode: Optional[builtins.str] = None):
         """
@@ -8608,6 +8704,7 @@ class InstanceAttachedDisk(dict):
                encoded SHA-256 hash of the [customer-supplied encryption key]
                (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) that protects this resource.
         :param builtins.str disk_encryption_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.bool force_attach: Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
         :param builtins.str kms_key_self_link: The self_link of the encryption key that is
                stored in Google Cloud KMS to encrypt this disk. Only one of `kms_key_self_link`, `disk_encryption_key_rsa` and `disk_encryption_key_raw`
                may be set.
@@ -8627,6 +8724,8 @@ class InstanceAttachedDisk(dict):
             pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
         if disk_encryption_service_account is not None:
             pulumi.set(__self__, "disk_encryption_service_account", disk_encryption_service_account)
+        if force_attach is not None:
+            pulumi.set(__self__, "force_attach", force_attach)
         if kms_key_self_link is not None:
             pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         if mode is not None:
@@ -8689,6 +8788,14 @@ class InstanceAttachedDisk(dict):
         """
         return pulumi.get(self, "disk_encryption_service_account")
 
+    @property
+    @pulumi.getter(name="forceAttach")
+    def force_attach(self) -> Optional[builtins.bool]:
+        """
+        Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
+        """
+        return pulumi.get(self, "force_attach")
+
     @property
     @pulumi.getter(name="kmsKeySelfLink")
     def kms_key_self_link(self) -> Optional[builtins.str]:
@@ -8728,6 +8835,8 @@ class InstanceBootDisk(dict):
             suggest = "disk_encryption_key_sha256"
         elif key == "diskEncryptionServiceAccount":
             suggest = "disk_encryption_service_account"
+        elif key == "forceAttach":
+            suggest = "force_attach"
         elif key == "guestOsFeatures":
             suggest = "guest_os_features"
         elif key == "initializeParams":
@@ -8753,6 +8862,7 @@ class InstanceBootDisk(dict):
                  disk_encryption_key_rsa: Optional[builtins.str] = None,
                  disk_encryption_key_sha256: Optional[builtins.str] = None,
                  disk_encryption_service_account: Optional[builtins.str] = None,
+                 force_attach: Optional[builtins.bool] = None,
                  guest_os_features: Optional[Sequence[builtins.str]] = None,
                  initialize_params: Optional['outputs.InstanceBootDiskInitializeParams'] = None,
                  interface: Optional[builtins.str] = None,
@@ -8775,6 +8885,9 @@ class InstanceBootDisk(dict):
                encoded SHA-256 hash of the [customer-supplied encryption key]
                (https://cloud.google.com/compute/docs/disks/customer-supplied-encryption) that protects this resource.
         :param builtins.str disk_encryption_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.bool force_attach: boolean field that determines whether to force attach the regional
+               disk even if it's currently attached to another instance. If you try to force attach a zonal
+               disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
         :param Sequence[builtins.str] guest_os_features: A list of features to enable on the guest operating system. Applicable only for bootable images. Read [Enabling guest operating system features](https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#guest-os-features) to see a list of available options.
         :param 'InstanceBootDiskInitializeParamsArgs' initialize_params: Parameters for a new disk that will be created
                alongside the new instance. Either `initialize_params` or `source` must be set.
@@ -8802,6 +8915,8 @@ class InstanceBootDisk(dict):
             pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
         if disk_encryption_service_account is not None:
             pulumi.set(__self__, "disk_encryption_service_account", disk_encryption_service_account)
+        if force_attach is not None:
+            pulumi.set(__self__, "force_attach", force_attach)
         if guest_os_features is not None:
             pulumi.set(__self__, "guest_os_features", guest_os_features)
         if initialize_params is not None:
@@ -8872,6 +8987,16 @@ class InstanceBootDisk(dict):
         """
         return pulumi.get(self, "disk_encryption_service_account")
 
+    @property
+    @pulumi.getter(name="forceAttach")
+    def force_attach(self) -> Optional[builtins.bool]:
+        """
+        boolean field that determines whether to force attach the regional
+        disk even if it's currently attached to another instance. If you try to force attach a zonal
+        disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
+        """
+        return pulumi.get(self, "force_attach")
+
     @property
     @pulumi.getter(name="guestOsFeatures")
     def guest_os_features(self) -> Optional[Sequence[builtins.str]]:
@@ -9566,6 +9691,8 @@ class InstanceFromMachineImageAttachedDisk(dict):
             suggest = "disk_encryption_key_sha256"
         elif key == "diskEncryptionServiceAccount":
             suggest = "disk_encryption_service_account"
+        elif key == "forceAttach":
+            suggest = "force_attach"
         elif key == "kmsKeySelfLink":
             suggest = "kms_key_self_link"
 
@@ -9587,6 +9714,7 @@ class InstanceFromMachineImageAttachedDisk(dict):
                  disk_encryption_key_rsa: Optional[builtins.str] = None,
                  disk_encryption_key_sha256: Optional[builtins.str] = None,
                  disk_encryption_service_account: Optional[builtins.str] = None,
+                 force_attach: Optional[builtins.bool] = None,
                  kms_key_self_link: Optional[builtins.str] = None,
                  mode: Optional[builtins.str] = None):
         """
@@ -9596,6 +9724,7 @@ class InstanceFromMachineImageAttachedDisk(dict):
         :param builtins.str disk_encryption_key_rsa: 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, disk_encryption_key_rsa and disk_encryption_key_raw may be set.
         :param builtins.str disk_encryption_key_sha256: The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied encryption key that protects this resource.
         :param builtins.str disk_encryption_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.bool force_attach: Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
         :param builtins.str kms_key_self_link: The self_link of the encryption key that is stored in Google Cloud KMS to encrypt this disk. Only one of kms_key_self_link, disk_encryption_key_rsa and disk_encryption_key_raw may be set.
         :param builtins.str mode: Read/write mode for the disk. One of "READ_ONLY" or "READ_WRITE".
         """
@@ -9610,6 +9739,8 @@ class InstanceFromMachineImageAttachedDisk(dict):
             pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
         if disk_encryption_service_account is not None:
             pulumi.set(__self__, "disk_encryption_service_account", disk_encryption_service_account)
+        if force_attach is not None:
+            pulumi.set(__self__, "force_attach", force_attach)
         if kms_key_self_link is not None:
             pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         if mode is not None:
@@ -9663,6 +9794,14 @@ class InstanceFromMachineImageAttachedDisk(dict):
         """
         return pulumi.get(self, "disk_encryption_service_account")
 
+    @property
+    @pulumi.getter(name="forceAttach")
+    def force_attach(self) -> Optional[builtins.bool]:
+        """
+        Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
+        """
+        return pulumi.get(self, "force_attach")
+
     @property
     @pulumi.getter(name="kmsKeySelfLink")
     def kms_key_self_link(self) -> Optional[builtins.str]:
@@ -9697,6 +9836,8 @@ class InstanceFromMachineImageBootDisk(dict):
             suggest = "disk_encryption_key_sha256"
         elif key == "diskEncryptionServiceAccount":
             suggest = "disk_encryption_service_account"
+        elif key == "forceAttach":
+            suggest = "force_attach"
         elif key == "guestOsFeatures":
             suggest = "guest_os_features"
         elif key == "initializeParams":
@@ -9722,6 +9863,7 @@ class InstanceFromMachineImageBootDisk(dict):
                  disk_encryption_key_rsa: Optional[builtins.str] = None,
                  disk_encryption_key_sha256: Optional[builtins.str] = None,
                  disk_encryption_service_account: Optional[builtins.str] = None,
+                 force_attach: Optional[builtins.bool] = None,
                  guest_os_features: Optional[Sequence[builtins.str]] = None,
                  initialize_params: Optional['outputs.InstanceFromMachineImageBootDiskInitializeParams'] = None,
                  interface: Optional[builtins.str] = None,
@@ -9735,6 +9877,7 @@ class InstanceFromMachineImageBootDisk(dict):
         :param builtins.str disk_encryption_key_rsa: 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, disk_encryption_key_raw and disk_encryption_key_rsa may be set.
         :param builtins.str disk_encryption_key_sha256: The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied encryption key that protects this resource.
         :param builtins.str disk_encryption_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.bool force_attach: Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
         :param Sequence[builtins.str] guest_os_features: A list of features to enable on the guest operating system. Applicable only for bootable images.
         :param 'InstanceFromMachineImageBootDiskInitializeParamsArgs' initialize_params: Parameters with which a disk was created alongside the instance.
         :param builtins.str interface: The disk interface used for attaching this disk. One of SCSI or NVME. (This field is shared with attached_disk and only used for specific cases, please don't specify this field without advice from Google.)
@@ -9754,6 +9897,8 @@ class InstanceFromMachineImageBootDisk(dict):
             pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
         if disk_encryption_service_account is not None:
             pulumi.set(__self__, "disk_encryption_service_account", disk_encryption_service_account)
+        if force_attach is not None:
+            pulumi.set(__self__, "force_attach", force_attach)
         if guest_os_features is not None:
             pulumi.set(__self__, "guest_os_features", guest_os_features)
         if initialize_params is not None:
@@ -9815,6 +9960,14 @@ class InstanceFromMachineImageBootDisk(dict):
         """
         return pulumi.get(self, "disk_encryption_service_account")
 
+    @property
+    @pulumi.getter(name="forceAttach")
+    def force_attach(self) -> Optional[builtins.bool]:
+        """
+        Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
+        """
+        return pulumi.get(self, "force_attach")
+
     @property
     @pulumi.getter(name="guestOsFeatures")
     def guest_os_features(self) -> Optional[Sequence[builtins.str]]:
@@ -11823,6 +11976,8 @@ class InstanceFromTemplateAttachedDisk(dict):
             suggest = "disk_encryption_key_sha256"
         elif key == "diskEncryptionServiceAccount":
             suggest = "disk_encryption_service_account"
+        elif key == "forceAttach":
+            suggest = "force_attach"
         elif key == "kmsKeySelfLink":
             suggest = "kms_key_self_link"
 
@@ -11844,6 +11999,7 @@ class InstanceFromTemplateAttachedDisk(dict):
                  disk_encryption_key_rsa: Optional[builtins.str] = None,
                  disk_encryption_key_sha256: Optional[builtins.str] = None,
                  disk_encryption_service_account: Optional[builtins.str] = None,
+                 force_attach: Optional[builtins.bool] = None,
                  kms_key_self_link: Optional[builtins.str] = None,
                  mode: Optional[builtins.str] = None):
         """
@@ -11853,6 +12009,7 @@ class InstanceFromTemplateAttachedDisk(dict):
         :param builtins.str disk_encryption_key_rsa: 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, disk_encryption_key_rsa and disk_encryption_key_raw may be set.
         :param builtins.str disk_encryption_key_sha256: The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied encryption key that protects this resource.
         :param builtins.str disk_encryption_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.bool force_attach: Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
         :param builtins.str kms_key_self_link: The self_link of the encryption key that is stored in Google Cloud KMS to encrypt this disk. Only one of kms_key_self_link, disk_encryption_key_rsa and disk_encryption_key_raw may be set.
         :param builtins.str mode: Read/write mode for the disk. One of "READ_ONLY" or "READ_WRITE".
         """
@@ -11867,6 +12024,8 @@ class InstanceFromTemplateAttachedDisk(dict):
             pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
         if disk_encryption_service_account is not None:
             pulumi.set(__self__, "disk_encryption_service_account", disk_encryption_service_account)
+        if force_attach is not None:
+            pulumi.set(__self__, "force_attach", force_attach)
         if kms_key_self_link is not None:
             pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         if mode is not None:
@@ -11920,6 +12079,14 @@ class InstanceFromTemplateAttachedDisk(dict):
         """
         return pulumi.get(self, "disk_encryption_service_account")
 
+    @property
+    @pulumi.getter(name="forceAttach")
+    def force_attach(self) -> Optional[builtins.bool]:
+        """
+        Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
+        """
+        return pulumi.get(self, "force_attach")
+
     @property
     @pulumi.getter(name="kmsKeySelfLink")
     def kms_key_self_link(self) -> Optional[builtins.str]:
@@ -11954,6 +12121,8 @@ class InstanceFromTemplateBootDisk(dict):
             suggest = "disk_encryption_key_sha256"
         elif key == "diskEncryptionServiceAccount":
             suggest = "disk_encryption_service_account"
+        elif key == "forceAttach":
+            suggest = "force_attach"
         elif key == "guestOsFeatures":
             suggest = "guest_os_features"
         elif key == "initializeParams":
@@ -11979,6 +12148,7 @@ class InstanceFromTemplateBootDisk(dict):
                  disk_encryption_key_rsa: Optional[builtins.str] = None,
                  disk_encryption_key_sha256: Optional[builtins.str] = None,
                  disk_encryption_service_account: Optional[builtins.str] = None,
+                 force_attach: Optional[builtins.bool] = None,
                  guest_os_features: Optional[Sequence[builtins.str]] = None,
                  initialize_params: Optional['outputs.InstanceFromTemplateBootDiskInitializeParams'] = None,
                  interface: Optional[builtins.str] = None,
@@ -11992,6 +12162,7 @@ class InstanceFromTemplateBootDisk(dict):
         :param builtins.str disk_encryption_key_rsa: 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, disk_encryption_key_raw and disk_encryption_key_rsa may be set.
         :param builtins.str disk_encryption_key_sha256: The RFC 4648 base64 encoded SHA-256 hash of the customer-supplied encryption key that protects this resource.
         :param builtins.str disk_encryption_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.bool force_attach: Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
         :param Sequence[builtins.str] guest_os_features: A list of features to enable on the guest operating system. Applicable only for bootable images.
         :param 'InstanceFromTemplateBootDiskInitializeParamsArgs' initialize_params: Parameters with which a disk was created alongside the instance.
         :param builtins.str interface: The disk interface used for attaching this disk. One of SCSI or NVME. (This field is shared with attached_disk and only used for specific cases, please don't specify this field without advice from Google.)
@@ -12011,6 +12182,8 @@ class InstanceFromTemplateBootDisk(dict):
             pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
         if disk_encryption_service_account is not None:
             pulumi.set(__self__, "disk_encryption_service_account", disk_encryption_service_account)
+        if force_attach is not None:
+            pulumi.set(__self__, "force_attach", force_attach)
         if guest_os_features is not None:
             pulumi.set(__self__, "guest_os_features", guest_os_features)
         if initialize_params is not None:
@@ -12072,6 +12245,14 @@ class InstanceFromTemplateBootDisk(dict):
         """
         return pulumi.get(self, "disk_encryption_service_account")
 
+    @property
+    @pulumi.getter(name="forceAttach")
+    def force_attach(self) -> Optional[builtins.bool]:
+        """
+        Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
+        """
+        return pulumi.get(self, "force_attach")
+
     @property
     @pulumi.getter(name="guestOsFeatures")
     def guest_os_features(self) -> Optional[Sequence[builtins.str]]:
@@ -16571,6 +16752,8 @@ class InstanceTemplateDisk(dict):
             suggest = "disk_size_gb"
         elif key == "diskType":
             suggest = "disk_type"
+        elif key == "guestOsFeatures":
+            suggest = "guest_os_features"
         elif key == "provisionedIops":
             suggest = "provisioned_iops"
         elif key == "provisionedThroughput":
@@ -16600,6 +16783,7 @@ class InstanceTemplateDisk(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 architecture: Optional[builtins.str] = None,
                  auto_delete: Optional[builtins.bool] = None,
                  boot: Optional[builtins.bool] = None,
                  device_name: Optional[builtins.str] = None,
@@ -16607,6 +16791,7 @@ class InstanceTemplateDisk(dict):
                  disk_name: Optional[builtins.str] = None,
                  disk_size_gb: Optional[builtins.int] = None,
                  disk_type: Optional[builtins.str] = None,
+                 guest_os_features: Optional[Sequence[builtins.str]] = None,
                  interface: Optional[builtins.str] = None,
                  labels: Optional[Mapping[str, builtins.str]] = None,
                  mode: Optional[builtins.str] = None,
@@ -16621,6 +16806,7 @@ class InstanceTemplateDisk(dict):
                  source_snapshot_encryption_key: Optional['outputs.InstanceTemplateDiskSourceSnapshotEncryptionKey'] = None,
                  type: Optional[builtins.str] = None):
         """
+        :param builtins.str architecture: The architecture of the attached disk. Valid values are `ARM64` or `x86_64`.
         :param builtins.bool auto_delete: Whether or not the disk should be auto-deleted.
                This defaults to true.
         :param builtins.bool boot: Indicates that this is a boot disk.
@@ -16643,6 +16829,7 @@ class InstanceTemplateDisk(dict):
                the size must be exactly 375GB.
         :param builtins.str disk_type: The GCE disk type. Such as `"pd-ssd"`, `"local-ssd"`,
                `"pd-balanced"` or `"pd-standard"`, `"hyperdisk-balanced"`, `"hyperdisk-throughput"` or `"hyperdisk-extreme"`.
+        :param Sequence[builtins.str] guest_os_features: A list of features to enable on the guest operating system. Applicable only for bootable images. Read [Enabling guest operating system features](https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#guest-os-features) to see a list of available options.
         :param builtins.str interface: Specifies the disk interface to use for attaching this disk,
                which is either SCSI or NVME. The default is SCSI. Persistent disks must always use SCSI
                and the request will fail if you attempt to attach a persistent disk in any other format
@@ -16685,6 +16872,8 @@ class InstanceTemplateDisk(dict):
         :param builtins.str type: The type of GCE disk, can be either `"SCRATCH"` or
                `"PERSISTENT"`.
         """
+        if architecture is not None:
+            pulumi.set(__self__, "architecture", architecture)
         if auto_delete is not None:
             pulumi.set(__self__, "auto_delete", auto_delete)
         if boot is not None:
@@ -16699,6 +16888,8 @@ class InstanceTemplateDisk(dict):
             pulumi.set(__self__, "disk_size_gb", disk_size_gb)
         if disk_type is not None:
             pulumi.set(__self__, "disk_type", disk_type)
+        if guest_os_features is not None:
+            pulumi.set(__self__, "guest_os_features", guest_os_features)
         if interface is not None:
             pulumi.set(__self__, "interface", interface)
         if labels is not None:
@@ -16726,6 +16917,14 @@ class InstanceTemplateDisk(dict):
         if type is not None:
             pulumi.set(__self__, "type", type)
 
+    @property
+    @pulumi.getter
+    def architecture(self) -> Optional[builtins.str]:
+        """
+        The architecture of the attached disk. Valid values are `ARM64` or `x86_64`.
+        """
+        return pulumi.get(self, "architecture")
+
     @property
     @pulumi.getter(name="autoDelete")
     def auto_delete(self) -> Optional[builtins.bool]:
@@ -16797,6 +16996,14 @@ class InstanceTemplateDisk(dict):
         """
         return pulumi.get(self, "disk_type")
 
+    @property
+    @pulumi.getter(name="guestOsFeatures")
+    def guest_os_features(self) -> Optional[Sequence[builtins.str]]:
+        """
+        A list of features to enable on the guest operating system. Applicable only for bootable images. Read [Enabling guest operating system features](https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#guest-os-features) to see a list of available options.
+        """
+        return pulumi.get(self, "guest_os_features")
+
     @property
     @pulumi.getter
     def interface(self) -> Optional[builtins.str]:
@@ -25626,6 +25833,96 @@ class RegionHealthCheckGrpcHealthCheck(dict):
         return pulumi.get(self, "port_specification")
 
 
+@pulumi.output_type
+class RegionHealthCheckGrpcTlsHealthCheck(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "grpcServiceName":
+            suggest = "grpc_service_name"
+        elif key == "portSpecification":
+            suggest = "port_specification"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in RegionHealthCheckGrpcTlsHealthCheck. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        RegionHealthCheckGrpcTlsHealthCheck.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        RegionHealthCheckGrpcTlsHealthCheck.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 grpc_service_name: Optional[builtins.str] = None,
+                 port: Optional[builtins.int] = None,
+                 port_specification: Optional[builtins.str] = None):
+        """
+        :param builtins.str grpc_service_name: The gRPC service name for the health check.
+               The value of grpcServiceName has the following meanings by convention:
+               * Empty serviceName means the overall status of all services at the backend.
+               * Non-empty serviceName means the health of that gRPC service, as defined by the owner of the service.
+               The grpcServiceName can only be ASCII.
+        :param builtins.int port: The port number for the health check request.
+               Must be specified if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
+        :param builtins.str port_specification: Specifies how port is selected for health checking, can be one of the
+               following values:
+               * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
+               * `USE_NAMED_PORT`: Not supported for GRPC with TLS health checking.
+               * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
+               network endpoint is used for health checking. For other backends, the
+               port or named port specified in the Backend Service is used for health
+               checking.
+               If not specified, gRPC health check follows behavior specified in the `port` field.
+               Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
+        """
+        if grpc_service_name is not None:
+            pulumi.set(__self__, "grpc_service_name", grpc_service_name)
+        if port is not None:
+            pulumi.set(__self__, "port", port)
+        if port_specification is not None:
+            pulumi.set(__self__, "port_specification", port_specification)
+
+    @property
+    @pulumi.getter(name="grpcServiceName")
+    def grpc_service_name(self) -> Optional[builtins.str]:
+        """
+        The gRPC service name for the health check.
+        The value of grpcServiceName has the following meanings by convention:
+        * Empty serviceName means the overall status of all services at the backend.
+        * Non-empty serviceName means the health of that gRPC service, as defined by the owner of the service.
+        The grpcServiceName can only be ASCII.
+        """
+        return pulumi.get(self, "grpc_service_name")
+
+    @property
+    @pulumi.getter
+    def port(self) -> Optional[builtins.int]:
+        """
+        The port number for the health check request.
+        Must be specified if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
+        """
+        return pulumi.get(self, "port")
+
+    @property
+    @pulumi.getter(name="portSpecification")
+    def port_specification(self) -> Optional[builtins.str]:
+        """
+        Specifies how port is selected for health checking, can be one of the
+        following values:
+        * `USE_FIXED_PORT`: The port number in `port` is used for health checking.
+        * `USE_NAMED_PORT`: Not supported for GRPC with TLS health checking.
+        * `USE_SERVING_PORT`: For NetworkEndpointGroup, the port specified for each
+        network endpoint is used for health checking. For other backends, the
+        port or named port specified in the Backend Service is used for health
+        checking.
+        If not specified, gRPC health check follows behavior specified in the `port` field.
+        Possible values are: `USE_FIXED_PORT`, `USE_NAMED_PORT`, `USE_SERVING_PORT`.
+        """
+        return pulumi.get(self, "port_specification")
+
+
 @pulumi.output_type
 class RegionHealthCheckHttp2HealthCheck(dict):
     @staticmethod
@@ -27593,6 +27890,8 @@ class RegionInstanceTemplateDisk(dict):
             suggest = "disk_size_gb"
         elif key == "diskType":
             suggest = "disk_type"
+        elif key == "guestOsFeatures":
+            suggest = "guest_os_features"
         elif key == "provisionedIops":
             suggest = "provisioned_iops"
         elif key == "provisionedThroughput":
@@ -27622,6 +27921,7 @@ class RegionInstanceTemplateDisk(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 architecture: Optional[builtins.str] = None,
                  auto_delete: Optional[builtins.bool] = None,
                  boot: Optional[builtins.bool] = None,
                  device_name: Optional[builtins.str] = None,
@@ -27629,6 +27929,7 @@ class RegionInstanceTemplateDisk(dict):
                  disk_name: Optional[builtins.str] = None,
                  disk_size_gb: Optional[builtins.int] = None,
                  disk_type: Optional[builtins.str] = None,
+                 guest_os_features: Optional[Sequence[builtins.str]] = None,
                  interface: Optional[builtins.str] = None,
                  labels: Optional[Mapping[str, builtins.str]] = None,
                  mode: Optional[builtins.str] = None,
@@ -27643,6 +27944,7 @@ class RegionInstanceTemplateDisk(dict):
                  source_snapshot_encryption_key: Optional['outputs.RegionInstanceTemplateDiskSourceSnapshotEncryptionKey'] = None,
                  type: Optional[builtins.str] = None):
         """
+        :param builtins.str architecture: The architecture of the attached disk. Valid values are `ARM64` or `x86_64`.
         :param builtins.bool auto_delete: Whether or not the disk should be auto-deleted.
                This defaults to true.
         :param builtins.bool boot: Indicates that this is a boot disk.
@@ -27665,6 +27967,7 @@ class RegionInstanceTemplateDisk(dict):
                the size must be exactly 375GB.
         :param builtins.str disk_type: The GCE disk type. Such as `"pd-ssd"`, `"local-ssd"`,
                `"pd-balanced"` or `"pd-standard"`.
+        :param Sequence[builtins.str] guest_os_features: A list of features to enable on the guest operating system. Applicable only for bootable images. Read [Enabling guest operating system features](https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#guest-os-features) to see a list of available options.
         :param builtins.str interface: Specifies the disk interface to use for attaching this disk,
                which is either SCSI or NVME. The default is SCSI. Persistent disks must always use SCSI
                and the request will fail if you attempt to attach a persistent disk in any other format
@@ -27707,6 +28010,8 @@ class RegionInstanceTemplateDisk(dict):
         :param builtins.str type: The type of GCE disk, can be either `"SCRATCH"` or
                `"PERSISTENT"`.
         """
+        if architecture is not None:
+            pulumi.set(__self__, "architecture", architecture)
         if auto_delete is not None:
             pulumi.set(__self__, "auto_delete", auto_delete)
         if boot is not None:
@@ -27721,6 +28026,8 @@ class RegionInstanceTemplateDisk(dict):
             pulumi.set(__self__, "disk_size_gb", disk_size_gb)
         if disk_type is not None:
             pulumi.set(__self__, "disk_type", disk_type)
+        if guest_os_features is not None:
+            pulumi.set(__self__, "guest_os_features", guest_os_features)
         if interface is not None:
             pulumi.set(__self__, "interface", interface)
         if labels is not None:
@@ -27748,6 +28055,14 @@ class RegionInstanceTemplateDisk(dict):
         if type is not None:
             pulumi.set(__self__, "type", type)
 
+    @property
+    @pulumi.getter
+    def architecture(self) -> Optional[builtins.str]:
+        """
+        The architecture of the attached disk. Valid values are `ARM64` or `x86_64`.
+        """
+        return pulumi.get(self, "architecture")
+
     @property
     @pulumi.getter(name="autoDelete")
     def auto_delete(self) -> Optional[builtins.bool]:
@@ -27819,6 +28134,14 @@ class RegionInstanceTemplateDisk(dict):
         """
         return pulumi.get(self, "disk_type")
 
+    @property
+    @pulumi.getter(name="guestOsFeatures")
+    def guest_os_features(self) -> Optional[Sequence[builtins.str]]:
+        """
+        A list of features to enable on the guest operating system. Applicable only for bootable images. Read [Enabling guest operating system features](https://cloud.google.com/compute/docs/images/create-delete-deprecate-private-images#guest-os-features) to see a list of available options.
+        """
+        return pulumi.get(self, "guest_os_features")
+
     @property
     @pulumi.getter
     def interface(self) -> Optional[builtins.str]:
@@ -57234,6 +57557,80 @@ class GetHealthCheckGrpcHealthCheckResult(dict):
         return pulumi.get(self, "port_specification")
 
 
+@pulumi.output_type
+class GetHealthCheckGrpcTlsHealthCheckResult(dict):
+    def __init__(__self__, *,
+                 grpc_service_name: builtins.str,
+                 port: builtins.int,
+                 port_specification: builtins.str):
+        """
+        :param builtins.str grpc_service_name: The gRPC service name for the health check.
+               The value of grpcServiceName has the following meanings by convention:
+                 - Empty serviceName means the overall status of all services at the backend.
+                 - Non-empty serviceName means the health of that gRPC service, as defined by the owner of the service.
+               The grpcServiceName can only be ASCII.
+        :param builtins.int port: The port number for the health check request.
+               Must be specified if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
+        :param builtins.str port_specification: Specifies how port is selected for health checking, can be one of the
+               following values:
+               
+                 * 'USE_FIXED_PORT': The port number in 'port' is used for health checking.
+               
+                 * 'USE_NAMED_PORT': Not supported for GRPC with TLS health checking.
+               
+                 * 'USE_SERVING_PORT': For NetworkEndpointGroup, the port specified for each
+                 network endpoint is used for health checking. For other backends, the
+                 port or named port specified in the Backend Service is used for health
+                 checking.
+               
+               If not specified, gRPC with TLS health check follows behavior specified in the 'port' field. Possible values: ["USE_FIXED_PORT", "USE_NAMED_PORT", "USE_SERVING_PORT"]
+        """
+        pulumi.set(__self__, "grpc_service_name", grpc_service_name)
+        pulumi.set(__self__, "port", port)
+        pulumi.set(__self__, "port_specification", port_specification)
+
+    @property
+    @pulumi.getter(name="grpcServiceName")
+    def grpc_service_name(self) -> builtins.str:
+        """
+        The gRPC service name for the health check.
+        The value of grpcServiceName has the following meanings by convention:
+          - Empty serviceName means the overall status of all services at the backend.
+          - Non-empty serviceName means the health of that gRPC service, as defined by the owner of the service.
+        The grpcServiceName can only be ASCII.
+        """
+        return pulumi.get(self, "grpc_service_name")
+
+    @property
+    @pulumi.getter
+    def port(self) -> builtins.int:
+        """
+        The port number for the health check request.
+        Must be specified if port_specification is USE_FIXED_PORT. Valid values are 1 through 65535.
+        """
+        return pulumi.get(self, "port")
+
+    @property
+    @pulumi.getter(name="portSpecification")
+    def port_specification(self) -> builtins.str:
+        """
+        Specifies how port is selected for health checking, can be one of the
+        following values:
+
+          * 'USE_FIXED_PORT': The port number in 'port' is used for health checking.
+
+          * 'USE_NAMED_PORT': Not supported for GRPC with TLS health checking.
+
+          * 'USE_SERVING_PORT': For NetworkEndpointGroup, the port specified for each
+          network endpoint is used for health checking. For other backends, the
+          port or named port specified in the Backend Service is used for health
+          checking.
+
+        If not specified, gRPC with TLS health check follows behavior specified in the 'port' field. Possible values: ["USE_FIXED_PORT", "USE_NAMED_PORT", "USE_SERVING_PORT"]
+        """
+        return pulumi.get(self, "port_specification")
+
+
 @pulumi.output_type
 class GetHealthCheckHttp2HealthCheckResult(dict):
     def __init__(__self__, *,
@@ -58078,6 +58475,7 @@ class GetInstanceAttachedDiskResult(dict):
                  disk_encryption_key_rsa: builtins.str,
                  disk_encryption_key_sha256: builtins.str,
                  disk_encryption_service_account: builtins.str,
+                 force_attach: builtins.bool,
                  kms_key_self_link: builtins.str,
                  mode: builtins.str,
                  source: builtins.str):
@@ -58090,6 +58488,7 @@ class GetInstanceAttachedDiskResult(dict):
                encoded SHA-256 hash of the [customer-supplied encryption key]
                (<https://cloud.google.com/compute/docs/disks/customer-supplied-encryption>) that protects this resource.
         :param builtins.str disk_encryption_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.bool force_attach: Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
         :param builtins.str kms_key_self_link: The self_link of the encryption key that is stored in Google Cloud KMS to encrypt this disk. Only one of kms_key_self_link, disk_encryption_key_rsa and disk_encryption_key_raw may be set.
         :param builtins.str mode: Read/write mode for the disk. One of `"READ_ONLY"` or `"READ_WRITE"`.
         :param builtins.str source: The self_link of the disk attached to this instance.
@@ -58099,6 +58498,7 @@ class GetInstanceAttachedDiskResult(dict):
         pulumi.set(__self__, "disk_encryption_key_rsa", disk_encryption_key_rsa)
         pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
         pulumi.set(__self__, "disk_encryption_service_account", disk_encryption_service_account)
+        pulumi.set(__self__, "force_attach", force_attach)
         pulumi.set(__self__, "kms_key_self_link", kms_key_self_link)
         pulumi.set(__self__, "mode", mode)
         pulumi.set(__self__, "source", source)
@@ -58146,6 +58546,14 @@ class GetInstanceAttachedDiskResult(dict):
         """
         return pulumi.get(self, "disk_encryption_service_account")
 
+    @property
+    @pulumi.getter(name="forceAttach")
+    def force_attach(self) -> builtins.bool:
+        """
+        Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
+        """
+        return pulumi.get(self, "force_attach")
+
     @property
     @pulumi.getter(name="kmsKeySelfLink")
     def kms_key_self_link(self) -> builtins.str:
@@ -58180,6 +58588,7 @@ class GetInstanceBootDiskResult(dict):
                  disk_encryption_key_rsa: builtins.str,
                  disk_encryption_key_sha256: builtins.str,
                  disk_encryption_service_account: builtins.str,
+                 force_attach: builtins.bool,
                  guest_os_features: Sequence[builtins.str],
                  initialize_params: Sequence['outputs.GetInstanceBootDiskInitializeParamResult'],
                  interface: builtins.str,
@@ -58196,6 +58605,7 @@ class GetInstanceBootDiskResult(dict):
                encoded SHA-256 hash of the [customer-supplied encryption key]
                (<https://cloud.google.com/compute/docs/disks/customer-supplied-encryption>) that protects this resource.
         :param builtins.str disk_encryption_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.bool force_attach: Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
         :param Sequence[builtins.str] guest_os_features: A list of features to enable on the guest operating system. Applicable only for bootable images.
         :param Sequence['GetInstanceBootDiskInitializeParamArgs'] initialize_params: Parameters with which a disk was created alongside the instance.
                Structure is documented below.
@@ -58210,6 +58620,7 @@ class GetInstanceBootDiskResult(dict):
         pulumi.set(__self__, "disk_encryption_key_rsa", disk_encryption_key_rsa)
         pulumi.set(__self__, "disk_encryption_key_sha256", disk_encryption_key_sha256)
         pulumi.set(__self__, "disk_encryption_service_account", disk_encryption_service_account)
+        pulumi.set(__self__, "force_attach", force_attach)
         pulumi.set(__self__, "guest_os_features", guest_os_features)
         pulumi.set(__self__, "initialize_params", initialize_params)
         pulumi.set(__self__, "interface", interface)
@@ -58268,6 +58679,14 @@ class GetInstanceBootDiskResult(dict):
         """
         return pulumi.get(self, "disk_encryption_service_account")
 
+    @property
+    @pulumi.getter(name="forceAttach")
+    def force_attach(self) -> builtins.bool:
+        """
+        Whether to force attach the regional disk even if it's currently attached to another instance. If you try to force attach a zonal disk to an instance, you will receive an error. Setting this parameter cause VM recreation.
+        """
+        return pulumi.get(self, "force_attach")
+
     @property
     @pulumi.getter(name="guestOsFeatures")
     def guest_os_features(self) -> Sequence[builtins.str]:
@@ -60383,6 +60802,7 @@ class GetInstanceTemplateConfidentialInstanceConfigResult(dict):
 @pulumi.output_type
 class GetInstanceTemplateDiskResult(dict):
     def __init__(__self__, *,
+                 architecture: builtins.str,
                  auto_delete: builtins.bool,
                  boot: builtins.bool,
                  device_name: builtins.str,
@@ -60390,6 +60810,7 @@ class GetInstanceTemplateDiskResult(dict):
                  disk_name: builtins.str,
                  disk_size_gb: builtins.int,
                  disk_type: builtins.str,
+                 guest_os_features: Sequence[builtins.str],
                  interface: builtins.str,
                  labels: Mapping[str, builtins.str],
                  mode: builtins.str,
@@ -60404,6 +60825,7 @@ class GetInstanceTemplateDiskResult(dict):
                  source_snapshot_encryption_keys: Sequence['outputs.GetInstanceTemplateDiskSourceSnapshotEncryptionKeyResult'],
                  type: builtins.str):
         """
+        :param builtins.str architecture: The architecture of the image. Allowed values are ARM64 or X86_64.
         :param builtins.bool auto_delete: Whether or not the disk should be auto-deleted.
                This defaults to true.
         :param builtins.bool boot: Indicates that this is a boot disk.
@@ -60418,6 +60840,7 @@ class GetInstanceTemplateDiskResult(dict):
                the size must be exactly 375GB.
         :param builtins.str disk_type: The GCE disk type. Such as `"pd-ssd"`, `"local-ssd"`,
                `"pd-balanced"` or `"pd-standard"`.
+        :param Sequence[builtins.str] guest_os_features: A list of features to enable on the guest operating system. Applicable only for bootable images.
         :param builtins.str interface: Specifies the disk interface to use for attaching this disk,
                which is either SCSI or NVME. The default is SCSI. Persistent disks must always use SCSI
                and the request will fail if you attempt to attach a persistent disk in any other format
@@ -60459,6 +60882,7 @@ class GetInstanceTemplateDiskResult(dict):
         :param Sequence['GetInstanceTemplateDiskSourceSnapshotEncryptionKeyArgs'] source_snapshot_encryption_keys: The customer-supplied encryption key of the source snapshot.
         :param builtins.str type: The accelerator type resource to expose to this instance. E.g. `nvidia-tesla-k80`.
         """
+        pulumi.set(__self__, "architecture", architecture)
         pulumi.set(__self__, "auto_delete", auto_delete)
         pulumi.set(__self__, "boot", boot)
         pulumi.set(__self__, "device_name", device_name)
@@ -60466,6 +60890,7 @@ class GetInstanceTemplateDiskResult(dict):
         pulumi.set(__self__, "disk_name", disk_name)
         pulumi.set(__self__, "disk_size_gb", disk_size_gb)
         pulumi.set(__self__, "disk_type", disk_type)
+        pulumi.set(__self__, "guest_os_features", guest_os_features)
         pulumi.set(__self__, "interface", interface)
         pulumi.set(__self__, "labels", labels)
         pulumi.set(__self__, "mode", mode)
@@ -60480,6 +60905,14 @@ class GetInstanceTemplateDiskResult(dict):
         pulumi.set(__self__, "source_snapshot_encryption_keys", source_snapshot_encryption_keys)
         pulumi.set(__self__, "type", type)
 
+    @property
+    @pulumi.getter
+    def architecture(self) -> builtins.str:
+        """
+        The architecture of the image. Allowed values are ARM64 or X86_64.
+        """
+        return pulumi.get(self, "architecture")
+
     @property
     @pulumi.getter(name="autoDelete")
     def auto_delete(self) -> builtins.bool:
@@ -60543,6 +60976,14 @@ class GetInstanceTemplateDiskResult(dict):
         """
         return pulumi.get(self, "disk_type")
 
+    @property
+    @pulumi.getter(name="guestOsFeatures")
+    def guest_os_features(self) -> Sequence[builtins.str]:
+        """
+        A list of features to enable on the guest operating system. Applicable only for bootable images.
+        """
+        return pulumi.get(self, "guest_os_features")
+
     @property
     @pulumi.getter
     def interface(self) -> builtins.str:
@@ -64447,6 +64888,7 @@ class GetRegionInstanceTemplateConfidentialInstanceConfigResult(dict):
 @pulumi.output_type
 class GetRegionInstanceTemplateDiskResult(dict):
     def __init__(__self__, *,
+                 architecture: builtins.str,
                  auto_delete: builtins.bool,
                  boot: builtins.bool,
                  device_name: builtins.str,
@@ -64454,6 +64896,7 @@ class GetRegionInstanceTemplateDiskResult(dict):
                  disk_name: builtins.str,
                  disk_size_gb: builtins.int,
                  disk_type: builtins.str,
+                 guest_os_features: Sequence[builtins.str],
                  interface: builtins.str,
                  labels: Mapping[str, builtins.str],
                  mode: builtins.str,
@@ -64468,6 +64911,7 @@ class GetRegionInstanceTemplateDiskResult(dict):
                  source_snapshot_encryption_keys: Sequence['outputs.GetRegionInstanceTemplateDiskSourceSnapshotEncryptionKeyResult'],
                  type: builtins.str):
         """
+        :param builtins.str architecture: The architecture of the image. Allowed values are ARM64 or X86_64.
         :param builtins.bool auto_delete: Whether or not the disk should be auto-deleted.
                This defaults to true.
         :param builtins.bool boot: Indicates that this is a boot disk.
@@ -64482,6 +64926,7 @@ class GetRegionInstanceTemplateDiskResult(dict):
                the size must be exactly 375GB.
         :param builtins.str disk_type: The GCE disk type. Such as `"pd-ssd"`, `"local-ssd"`,
                `"pd-balanced"` or `"pd-standard"`.
+        :param Sequence[builtins.str] guest_os_features: A list of features to enable on the guest operating system. Applicable only for bootable images.
         :param builtins.str interface: Specifies the disk interface to use for attaching this disk,
                which is either SCSI or NVME. The default is SCSI. Persistent disks must always use SCSI
                and the request will fail if you attempt to attach a persistent disk in any other format
@@ -64523,6 +64968,7 @@ class GetRegionInstanceTemplateDiskResult(dict):
         :param Sequence['GetRegionInstanceTemplateDiskSourceSnapshotEncryptionKeyArgs'] source_snapshot_encryption_keys: The customer-supplied encryption key of the source snapshot.
         :param builtins.str type: The accelerator type resource to expose to this instance. E.g. `nvidia-tesla-k80`.
         """
+        pulumi.set(__self__, "architecture", architecture)
         pulumi.set(__self__, "auto_delete", auto_delete)
         pulumi.set(__self__, "boot", boot)
         pulumi.set(__self__, "device_name", device_name)
@@ -64530,6 +64976,7 @@ class GetRegionInstanceTemplateDiskResult(dict):
         pulumi.set(__self__, "disk_name", disk_name)
         pulumi.set(__self__, "disk_size_gb", disk_size_gb)
         pulumi.set(__self__, "disk_type", disk_type)
+        pulumi.set(__self__, "guest_os_features", guest_os_features)
         pulumi.set(__self__, "interface", interface)
         pulumi.set(__self__, "labels", labels)
         pulumi.set(__self__, "mode", mode)
@@ -64544,6 +64991,14 @@ class GetRegionInstanceTemplateDiskResult(dict):
         pulumi.set(__self__, "source_snapshot_encryption_keys", source_snapshot_encryption_keys)
         pulumi.set(__self__, "type", type)
 
+    @property
+    @pulumi.getter
+    def architecture(self) -> builtins.str:
+        """
+        The architecture of the image. Allowed values are ARM64 or X86_64.
+        """
+        return pulumi.get(self, "architecture")
+
     @property
     @pulumi.getter(name="autoDelete")
     def auto_delete(self) -> builtins.bool:
@@ -64607,6 +65062,14 @@ class GetRegionInstanceTemplateDiskResult(dict):
         """
         return pulumi.get(self, "disk_type")
 
+    @property
+    @pulumi.getter(name="guestOsFeatures")
+    def guest_os_features(self) -> Sequence[builtins.str]:
+        """
+        A list of features to enable on the guest operating system. Applicable only for bootable images.
+        """
+        return pulumi.get(self, "guest_os_features")
+
     @property
     @pulumi.getter
     def interface(self) -> builtins.str: