pulumi-gcp 8.41.0a1755297349__py3-none-any.whl → 8.42.0a1756095712__py3-none-any.whl

pulumi_gcp/container/outputs.py

@@ -154,6 +154,7 @@ __all__ = [
     'ClusterNetworkPolicy',
     'ClusterNodeConfig',
     'ClusterNodeConfigAdvancedMachineFeatures',
+    'ClusterNodeConfigBootDisk',
     'ClusterNodeConfigConfidentialNodes',
     'ClusterNodeConfigContainerdConfig',
     'ClusterNodeConfigContainerdConfigPrivateRegistryAccessConfig',
@@ -170,6 +171,9 @@ __all__ = [
     'ClusterNodeConfigGvnic',
     'ClusterNodeConfigHostMaintenancePolicy',
     'ClusterNodeConfigKubeletConfig',
+    'ClusterNodeConfigKubeletConfigEvictionMinimumReclaim',
+    'ClusterNodeConfigKubeletConfigEvictionSoft',
+    'ClusterNodeConfigKubeletConfigEvictionSoftGracePeriod',
     'ClusterNodeConfigLinuxNodeConfig',
     'ClusterNodeConfigLinuxNodeConfigHugepagesConfig',
     'ClusterNodeConfigLocalNvmeSsdBlockConfig',
@@ -203,6 +207,7 @@ __all__ = [
     'ClusterNodePoolNetworkConfigPodCidrOverprovisionConfig',
     'ClusterNodePoolNodeConfig',
     'ClusterNodePoolNodeConfigAdvancedMachineFeatures',
+    'ClusterNodePoolNodeConfigBootDisk',
     'ClusterNodePoolNodeConfigConfidentialNodes',
     'ClusterNodePoolNodeConfigContainerdConfig',
     'ClusterNodePoolNodeConfigContainerdConfigPrivateRegistryAccessConfig',
@@ -219,6 +224,9 @@ __all__ = [
     'ClusterNodePoolNodeConfigGvnic',
     'ClusterNodePoolNodeConfigHostMaintenancePolicy',
     'ClusterNodePoolNodeConfigKubeletConfig',
+    'ClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaim',
+    'ClusterNodePoolNodeConfigKubeletConfigEvictionSoft',
+    'ClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod',
     'ClusterNodePoolNodeConfigLinuxNodeConfig',
     'ClusterNodePoolNodeConfigLinuxNodeConfigHugepagesConfig',
     'ClusterNodePoolNodeConfigLocalNvmeSsdBlockConfig',
@@ -267,6 +275,7 @@ __all__ = [
     'NodePoolNetworkConfigPodCidrOverprovisionConfig',
     'NodePoolNodeConfig',
     'NodePoolNodeConfigAdvancedMachineFeatures',
+    'NodePoolNodeConfigBootDisk',
     'NodePoolNodeConfigConfidentialNodes',
     'NodePoolNodeConfigContainerdConfig',
     'NodePoolNodeConfigContainerdConfigPrivateRegistryAccessConfig',
@@ -283,6 +292,9 @@ __all__ = [
     'NodePoolNodeConfigGvnic',
     'NodePoolNodeConfigHostMaintenancePolicy',
     'NodePoolNodeConfigKubeletConfig',
+    'NodePoolNodeConfigKubeletConfigEvictionMinimumReclaim',
+    'NodePoolNodeConfigKubeletConfigEvictionSoft',
+    'NodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod',
     'NodePoolNodeConfigLinuxNodeConfig',
     'NodePoolNodeConfigLinuxNodeConfigHugepagesConfig',
     'NodePoolNodeConfigLocalNvmeSsdBlockConfig',
@@ -369,6 +381,7 @@ __all__ = [
     'GetClusterNetworkPolicyResult',
     'GetClusterNodeConfigResult',
     'GetClusterNodeConfigAdvancedMachineFeatureResult',
+    'GetClusterNodeConfigBootDiskResult',
     'GetClusterNodeConfigConfidentialNodeResult',
     'GetClusterNodeConfigContainerdConfigResult',
     'GetClusterNodeConfigContainerdConfigPrivateRegistryAccessConfigResult',
@@ -385,6 +398,9 @@ __all__ = [
     'GetClusterNodeConfigGvnicResult',
     'GetClusterNodeConfigHostMaintenancePolicyResult',
     'GetClusterNodeConfigKubeletConfigResult',
+    'GetClusterNodeConfigKubeletConfigEvictionMinimumReclaimResult',
+    'GetClusterNodeConfigKubeletConfigEvictionSoftResult',
+    'GetClusterNodeConfigKubeletConfigEvictionSoftGracePeriodResult',
     'GetClusterNodeConfigLinuxNodeConfigResult',
     'GetClusterNodeConfigLinuxNodeConfigHugepagesConfigResult',
     'GetClusterNodeConfigLocalNvmeSsdBlockConfigResult',
@@ -418,6 +434,7 @@ __all__ = [
     'GetClusterNodePoolNetworkConfigPodCidrOverprovisionConfigResult',
     'GetClusterNodePoolNodeConfigResult',
     'GetClusterNodePoolNodeConfigAdvancedMachineFeatureResult',
+    'GetClusterNodePoolNodeConfigBootDiskResult',
     'GetClusterNodePoolNodeConfigConfidentialNodeResult',
     'GetClusterNodePoolNodeConfigContainerdConfigResult',
     'GetClusterNodePoolNodeConfigContainerdConfigPrivateRegistryAccessConfigResult',
@@ -434,6 +451,9 @@ __all__ = [
     'GetClusterNodePoolNodeConfigGvnicResult',
     'GetClusterNodePoolNodeConfigHostMaintenancePolicyResult',
     'GetClusterNodePoolNodeConfigKubeletConfigResult',
+    'GetClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaimResult',
+    'GetClusterNodePoolNodeConfigKubeletConfigEvictionSoftResult',
+    'GetClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriodResult',
     'GetClusterNodePoolNodeConfigLinuxNodeConfigResult',
     'GetClusterNodePoolNodeConfigLinuxNodeConfigHugepagesConfigResult',
     'GetClusterNodePoolNodeConfigLocalNvmeSsdBlockConfigResult',
@@ -7248,6 +7268,8 @@ class ClusterNodeConfig(dict):
         suggest = None
         if key == "advancedMachineFeatures":
             suggest = "advanced_machine_features"
+        elif key == "bootDisk":
+            suggest = "boot_disk"
         elif key == "bootDiskKmsKey":
             suggest = "boot_disk_kms_key"
         elif key == "confidentialNodes":
@@ -7336,6 +7358,7 @@ class ClusterNodeConfig(dict):
 
     def __init__(__self__, *,
                  advanced_machine_features: Optional['outputs.ClusterNodeConfigAdvancedMachineFeatures'] = None,
+                 boot_disk: Optional['outputs.ClusterNodeConfigBootDisk'] = None,
                  boot_disk_kms_key: Optional[_builtins.str] = None,
                  confidential_nodes: Optional['outputs.ClusterNodeConfigConfidentialNodes'] = None,
                  containerd_config: Optional['outputs.ClusterNodeConfigContainerdConfig'] = None,
@@ -7383,13 +7406,15 @@ class ClusterNodeConfig(dict):
         """
         :param 'ClusterNodeConfigAdvancedMachineFeaturesArgs' advanced_machine_features: Specifies options for controlling
                advanced machine features. Structure is documented below.
+        :param 'ClusterNodeConfigBootDiskArgs' boot_disk: Configuration of the node pool boot disk. Structure is documented below
         :param _builtins.str boot_disk_kms_key: The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: <https://cloud.google.com/compute/docs/disks/customer-managed-encryption>
         :param 'ClusterNodeConfigConfidentialNodesArgs' confidential_nodes: Configuration for Confidential Nodes feature. Structure is documented below.
         :param 'ClusterNodeConfigContainerdConfigArgs' containerd_config: Parameters to customize containerd runtime. Structure is documented below.
         :param _builtins.int disk_size_gb: Size of the disk attached to each node, specified
-               in GB. The smallest allowed disk size is 10GB. Defaults to 100GB.
+               in GB. The smallest allowed disk size is 10GB. Defaults to 100GB. This is being migrated to `boot_disk.size_gb`, and must match if specified in both places.
+               Prefer configuring `boot_disk`.
         :param _builtins.str disk_type: Type of the disk attached to each node
-               (e.g. 'pd-standard', 'pd-balanced' or 'pd-ssd'). If unspecified, the default disk type is 'pd-balanced'
+               (e.g. 'pd-standard', 'pd-balanced' or 'pd-ssd'). If unspecified, the default disk type is 'pd-balanced' This is being migrated to `boot_disk.disk_type`, and must match if specified in both places. Prefer configuring `boot_disk`.
         :param Sequence['ClusterNodeConfigEffectiveTaintArgs'] effective_taints: List of kubernetes taints applied to each node. Structure is documented above.
         :param _builtins.bool enable_confidential_storage: Enabling Confidential Storage will create boot disk with confidential mode. It is disabled by default.
         :param 'ClusterNodeConfigEphemeralStorageConfigArgs' ephemeral_storage_config: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk. Structure is documented below.
@@ -7469,7 +7494,7 @@ class ClusterNodeConfig(dict):
         :param _builtins.str service_account: The service account to be used by the Node VMs.
                If not specified, the "default" service account is used.
         :param 'ClusterNodeConfigShieldedInstanceConfigArgs' shielded_instance_config: Shielded Instance options. Structure is documented below.
-        :param 'ClusterNodeConfigSoleTenantConfigArgs' sole_tenant_config: Allows specifying multiple [node affinities](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes#node_affinity_and_anti-affinity) useful for running workloads on [sole tenant nodes](https://cloud.google.com/kubernetes-engine/docs/how-to/sole-tenancy). `node_affinity` structure is documented below.
+        :param 'ClusterNodeConfigSoleTenantConfigArgs' sole_tenant_config: Allows specifying multiple [node affinities](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes#node_affinity_and_anti-affinity) useful for running workloads on [sole tenant nodes](https://cloud.google.com/kubernetes-engine/docs/how-to/sole-tenancy). Structure is documented below.
         :param _builtins.bool spot: A boolean that represents whether the underlying node VMs are spot.
                See the [official documentation](https://cloud.google.com/kubernetes-engine/docs/concepts/spot-vms)
                for more information. Defaults to false.
@@ -7490,6 +7515,8 @@ class ClusterNodeConfig(dict):
         """
         if advanced_machine_features is not None:
             pulumi.set(__self__, "advanced_machine_features", advanced_machine_features)
+        if boot_disk is not None:
+            pulumi.set(__self__, "boot_disk", boot_disk)
         if boot_disk_kms_key is not None:
             pulumi.set(__self__, "boot_disk_kms_key", boot_disk_kms_key)
         if confidential_nodes is not None:
@@ -7588,6 +7615,14 @@ class ClusterNodeConfig(dict):
         """
         return pulumi.get(self, "advanced_machine_features")
 
+    @_builtins.property
+    @pulumi.getter(name="bootDisk")
+    def boot_disk(self) -> Optional['outputs.ClusterNodeConfigBootDisk']:
+        """
+        Configuration of the node pool boot disk. Structure is documented below
+        """
+        return pulumi.get(self, "boot_disk")
+
     @_builtins.property
     @pulumi.getter(name="bootDiskKmsKey")
     def boot_disk_kms_key(self) -> Optional[_builtins.str]:
@@ -7617,7 +7652,8 @@ class ClusterNodeConfig(dict):
     def disk_size_gb(self) -> Optional[_builtins.int]:
         """
         Size of the disk attached to each node, specified
-        in GB. The smallest allowed disk size is 10GB. Defaults to 100GB.
+        in GB. The smallest allowed disk size is 10GB. Defaults to 100GB. This is being migrated to `boot_disk.size_gb`, and must match if specified in both places.
+        Prefer configuring `boot_disk`.
         """
         return pulumi.get(self, "disk_size_gb")
 
@@ -7626,7 +7662,7 @@ class ClusterNodeConfig(dict):
     def disk_type(self) -> Optional[_builtins.str]:
         """
         Type of the disk attached to each node
-        (e.g. 'pd-standard', 'pd-balanced' or 'pd-ssd'). If unspecified, the default disk type is 'pd-balanced'
+        (e.g. 'pd-standard', 'pd-balanced' or 'pd-ssd'). If unspecified, the default disk type is 'pd-balanced' This is being migrated to `boot_disk.disk_type`, and must match if specified in both places. Prefer configuring `boot_disk`.
         """
         return pulumi.get(self, "disk_type")
 
@@ -7937,7 +7973,7 @@ class ClusterNodeConfig(dict):
     @pulumi.getter(name="soleTenantConfig")
     def sole_tenant_config(self) -> Optional['outputs.ClusterNodeConfigSoleTenantConfig']:
         """
-        Allows specifying multiple [node affinities](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes#node_affinity_and_anti-affinity) useful for running workloads on [sole tenant nodes](https://cloud.google.com/kubernetes-engine/docs/how-to/sole-tenancy). `node_affinity` structure is documented below.
+        Allows specifying multiple [node affinities](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes#node_affinity_and_anti-affinity) useful for running workloads on [sole tenant nodes](https://cloud.google.com/kubernetes-engine/docs/how-to/sole-tenancy). Structure is documented below.
         """
         return pulumi.get(self, "sole_tenant_config")
 
@@ -8064,6 +8100,88 @@ class ClusterNodeConfigAdvancedMachineFeatures(dict):
         return pulumi.get(self, "performance_monitoring_unit")
 
 
+@pulumi.output_type
+class ClusterNodeConfigBootDisk(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "diskType":
+            suggest = "disk_type"
+        elif key == "provisionedIops":
+            suggest = "provisioned_iops"
+        elif key == "provisionedThroughput":
+            suggest = "provisioned_throughput"
+        elif key == "sizeGb":
+            suggest = "size_gb"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeConfigBootDisk. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeConfigBootDisk.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeConfigBootDisk.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 disk_type: Optional[_builtins.str] = None,
+                 provisioned_iops: Optional[_builtins.int] = None,
+                 provisioned_throughput: Optional[_builtins.int] = None,
+                 size_gb: Optional[_builtins.int] = None):
+        """
+        :param _builtins.str disk_type: Type of the disk attached to each node
+               (e.g. 'pd-standard', 'pd-balanced', 'pd-ssd', 'hyperdisk-balanced'). If unspecified, the default disk type is 'pd-balanced' This is being migrated from `node_config.disk_type`, and must match if specified in both places. Prefer using this field.
+        :param _builtins.int provisioned_iops: Configure disk IOPs. This is only valid if the `disk_type` is 'hyperdisk-balanced'. See [performance limit documention](https://cloud.google.com/compute/docs/disks/hyperdisk-perf-limits) for more information about valid values.
+        :param _builtins.int provisioned_throughput: Configure disk throughput. This is only valid if the `disk_type` is 'hyperdisk-balanced'. See [performance limit documention](https://cloud.google.com/compute/docs/disks/hyperdisk-perf-limits) for more information about valid values.
+        :param _builtins.int size_gb: Size of the disk attached to each node, specified
+               in GB. The smallest allowed disk size is 10GB. Defaults to 100GB. This is being migrated from `node_config.disk_size_gb`, and must match if specified in both places. Prefer using this field.
+        """
+        if disk_type is not None:
+            pulumi.set(__self__, "disk_type", disk_type)
+        if provisioned_iops is not None:
+            pulumi.set(__self__, "provisioned_iops", provisioned_iops)
+        if provisioned_throughput is not None:
+            pulumi.set(__self__, "provisioned_throughput", provisioned_throughput)
+        if size_gb is not None:
+            pulumi.set(__self__, "size_gb", size_gb)
+
+    @_builtins.property
+    @pulumi.getter(name="diskType")
+    def disk_type(self) -> Optional[_builtins.str]:
+        """
+        Type of the disk attached to each node
+        (e.g. 'pd-standard', 'pd-balanced', 'pd-ssd', 'hyperdisk-balanced'). If unspecified, the default disk type is 'pd-balanced' This is being migrated from `node_config.disk_type`, and must match if specified in both places. Prefer using this field.
+        """
+        return pulumi.get(self, "disk_type")
+
+    @_builtins.property
+    @pulumi.getter(name="provisionedIops")
+    def provisioned_iops(self) -> Optional[_builtins.int]:
+        """
+        Configure disk IOPs. This is only valid if the `disk_type` is 'hyperdisk-balanced'. See [performance limit documention](https://cloud.google.com/compute/docs/disks/hyperdisk-perf-limits) for more information about valid values.
+        """
+        return pulumi.get(self, "provisioned_iops")
+
+    @_builtins.property
+    @pulumi.getter(name="provisionedThroughput")
+    def provisioned_throughput(self) -> Optional[_builtins.int]:
+        """
+        Configure disk throughput. This is only valid if the `disk_type` is 'hyperdisk-balanced'. See [performance limit documention](https://cloud.google.com/compute/docs/disks/hyperdisk-perf-limits) for more information about valid values.
+        """
+        return pulumi.get(self, "provisioned_throughput")
+
+    @_builtins.property
+    @pulumi.getter(name="sizeGb")
+    def size_gb(self) -> Optional[_builtins.int]:
+        """
+        Size of the disk attached to each node, specified
+        in GB. The smallest allowed disk size is 10GB. Defaults to 100GB. This is being migrated from `node_config.disk_size_gb`, and must match if specified in both places. Prefer using this field.
+        """
+        return pulumi.get(self, "size_gb")
+
+
 @pulumi.output_type
 class ClusterNodeConfigConfidentialNodes(dict):
     @staticmethod
@@ -8697,6 +8815,14 @@ class ClusterNodeConfigKubeletConfig(dict):
             suggest = "cpu_cfs_quota_period"
         elif key == "cpuManagerPolicy":
             suggest = "cpu_manager_policy"
+        elif key == "evictionMaxPodGracePeriodSeconds":
+            suggest = "eviction_max_pod_grace_period_seconds"
+        elif key == "evictionMinimumReclaim":
+            suggest = "eviction_minimum_reclaim"
+        elif key == "evictionSoft":
+            suggest = "eviction_soft"
+        elif key == "evictionSoftGracePeriod":
+            suggest = "eviction_soft_grace_period"
         elif key == "imageGcHighThresholdPercent":
             suggest = "image_gc_high_threshold_percent"
         elif key == "imageGcLowThresholdPercent":
@@ -8707,8 +8833,12 @@ class ClusterNodeConfigKubeletConfig(dict):
             suggest = "image_minimum_gc_age"
         elif key == "insecureKubeletReadonlyPortEnabled":
             suggest = "insecure_kubelet_readonly_port_enabled"
+        elif key == "maxParallelImagePulls":
+            suggest = "max_parallel_image_pulls"
         elif key == "podPidsLimit":
             suggest = "pod_pids_limit"
+        elif key == "singleProcessOomKill":
+            suggest = "single_process_oom_kill"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ClusterNodeConfigKubeletConfig. Access the value via the '{suggest}' property getter instead.")
@@ -8728,12 +8858,18 @@ class ClusterNodeConfigKubeletConfig(dict):
                  cpu_cfs_quota: Optional[_builtins.bool] = None,
                  cpu_cfs_quota_period: Optional[_builtins.str] = None,
                  cpu_manager_policy: Optional[_builtins.str] = None,
+                 eviction_max_pod_grace_period_seconds: Optional[_builtins.int] = None,
+                 eviction_minimum_reclaim: Optional['outputs.ClusterNodeConfigKubeletConfigEvictionMinimumReclaim'] = None,
+                 eviction_soft: Optional['outputs.ClusterNodeConfigKubeletConfigEvictionSoft'] = None,
+                 eviction_soft_grace_period: Optional['outputs.ClusterNodeConfigKubeletConfigEvictionSoftGracePeriod'] = None,
                  image_gc_high_threshold_percent: Optional[_builtins.int] = None,
                  image_gc_low_threshold_percent: Optional[_builtins.int] = None,
                  image_maximum_gc_age: Optional[_builtins.str] = None,
                  image_minimum_gc_age: Optional[_builtins.str] = None,
                  insecure_kubelet_readonly_port_enabled: Optional[_builtins.str] = None,
-                 pod_pids_limit: Optional[_builtins.int] = None):
+                 max_parallel_image_pulls: Optional[_builtins.int] = None,
+                 pod_pids_limit: Optional[_builtins.int] = None,
+                 single_process_oom_kill: Optional[_builtins.bool] = None):
         """
         :param Sequence[_builtins.str] allowed_unsafe_sysctls: Defines a comma-separated allowlist of unsafe sysctls or sysctl patterns which can be set on the Pods. The allowed sysctl groups are `kernel.shm*`, `kernel.msg*`, `kernel.sem`, `fs.mqueue.*`, and `net.*`.
         :param _builtins.int container_log_max_files: Defines the maximum number of container log files that can be present for a container. The integer must be between 2 and 10, inclusive.
@@ -8753,12 +8889,18 @@ class ClusterNodeConfigKubeletConfig(dict):
                One of `"none"` or `"static"`. If unset (or set to the empty string `""`), the API will treat the field as if set to "none".
                Prior to the 6.4.0 this field was marked as required. The workaround for the required field
                is setting the empty string `""`, which will function identically to not setting this field.
+        :param _builtins.int eviction_max_pod_grace_period_seconds: Defines the maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met. The integer must be positive and not exceed 300.
+        :param 'ClusterNodeConfigKubeletConfigEvictionMinimumReclaimArgs' eviction_minimum_reclaim: Defines a map of signal names to percentage that defines minimum reclaims. It describes the minimum amount of a given resource the kubelet will reclaim when performing a pod eviction. Structure is documented below.
+        :param 'ClusterNodeConfigKubeletConfigEvictionSoftArgs' eviction_soft: Defines a map of signal names to quantities or percentage that defines soft eviction thresholds. Structure is documented below.
+        :param 'ClusterNodeConfigKubeletConfigEvictionSoftGracePeriodArgs' eviction_soft_grace_period: Defines a map of signal names to durations that defines grace periods for soft eviction thresholds. Each soft eviction threshold must have a corresponding grace period. Structure is documented below.
         :param _builtins.int image_gc_high_threshold_percent: Defines the percent of disk usage after which image garbage collection is always run. The integer must be between 10 and 85, inclusive.
         :param _builtins.int image_gc_low_threshold_percent: Defines the percent of disk usage before which image garbage collection is never run. Lowest disk usage to garbage collect to. The integer must be between 10 and 85, inclusive.
         :param _builtins.str image_maximum_gc_age: Defines the maximum age an image can be unused before it is garbage collected. Specified as a sequence of decimal numbers, each with optional fraction and a unit suffix, such as `"300s"`, `"1.5m"`, and `"2h45m"`. Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
         :param _builtins.str image_minimum_gc_age: Defines the minimum age for an unused image before it is garbage collected. Specified as a sequence of decimal numbers, each with optional fraction and a unit suffix, such as `"300s"`, `"1.5m"`. The value cannot be greater than "2m".
         :param _builtins.str insecure_kubelet_readonly_port_enabled: Controls whether the kubelet read-only port is enabled. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        :param _builtins.int max_parallel_image_pulls: Set the maximum number of image pulls in parallel. The integer must be between 2 and 5, inclusive.
         :param _builtins.int pod_pids_limit: Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
+        :param _builtins.bool single_process_oom_kill: Defines whether to enable single process OOM killer. If true, the processes in the container will be OOM killed individually instead of as a group.
         """
         if allowed_unsafe_sysctls is not None:
             pulumi.set(__self__, "allowed_unsafe_sysctls", allowed_unsafe_sysctls)
@@ -8772,6 +8914,14 @@ class ClusterNodeConfigKubeletConfig(dict):
             pulumi.set(__self__, "cpu_cfs_quota_period", cpu_cfs_quota_period)
         if cpu_manager_policy is not None:
             pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
+        if eviction_max_pod_grace_period_seconds is not None:
+            pulumi.set(__self__, "eviction_max_pod_grace_period_seconds", eviction_max_pod_grace_period_seconds)
+        if eviction_minimum_reclaim is not None:
+            pulumi.set(__self__, "eviction_minimum_reclaim", eviction_minimum_reclaim)
+        if eviction_soft is not None:
+            pulumi.set(__self__, "eviction_soft", eviction_soft)
+        if eviction_soft_grace_period is not None:
+            pulumi.set(__self__, "eviction_soft_grace_period", eviction_soft_grace_period)
         if image_gc_high_threshold_percent is not None:
             pulumi.set(__self__, "image_gc_high_threshold_percent", image_gc_high_threshold_percent)
         if image_gc_low_threshold_percent is not None:
@@ -8782,8 +8932,12 @@ class ClusterNodeConfigKubeletConfig(dict):
             pulumi.set(__self__, "image_minimum_gc_age", image_minimum_gc_age)
         if insecure_kubelet_readonly_port_enabled is not None:
             pulumi.set(__self__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
+        if max_parallel_image_pulls is not None:
+            pulumi.set(__self__, "max_parallel_image_pulls", max_parallel_image_pulls)
         if pod_pids_limit is not None:
             pulumi.set(__self__, "pod_pids_limit", pod_pids_limit)
+        if single_process_oom_kill is not None:
+            pulumi.set(__self__, "single_process_oom_kill", single_process_oom_kill)
 
     @_builtins.property
     @pulumi.getter(name="allowedUnsafeSysctls")
@@ -8845,6 +8999,38 @@ class ClusterNodeConfigKubeletConfig(dict):
         """
         return pulumi.get(self, "cpu_manager_policy")
 
+    @_builtins.property
+    @pulumi.getter(name="evictionMaxPodGracePeriodSeconds")
+    def eviction_max_pod_grace_period_seconds(self) -> Optional[_builtins.int]:
+        """
+        Defines the maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met. The integer must be positive and not exceed 300.
+        """
+        return pulumi.get(self, "eviction_max_pod_grace_period_seconds")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionMinimumReclaim")
+    def eviction_minimum_reclaim(self) -> Optional['outputs.ClusterNodeConfigKubeletConfigEvictionMinimumReclaim']:
+        """
+        Defines a map of signal names to percentage that defines minimum reclaims. It describes the minimum amount of a given resource the kubelet will reclaim when performing a pod eviction. Structure is documented below.
+        """
+        return pulumi.get(self, "eviction_minimum_reclaim")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionSoft")
+    def eviction_soft(self) -> Optional['outputs.ClusterNodeConfigKubeletConfigEvictionSoft']:
+        """
+        Defines a map of signal names to quantities or percentage that defines soft eviction thresholds. Structure is documented below.
+        """
+        return pulumi.get(self, "eviction_soft")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionSoftGracePeriod")
+    def eviction_soft_grace_period(self) -> Optional['outputs.ClusterNodeConfigKubeletConfigEvictionSoftGracePeriod']:
+        """
+        Defines a map of signal names to durations that defines grace periods for soft eviction thresholds. Each soft eviction threshold must have a corresponding grace period. Structure is documented below.
+        """
+        return pulumi.get(self, "eviction_soft_grace_period")
+
     @_builtins.property
     @pulumi.getter(name="imageGcHighThresholdPercent")
     def image_gc_high_threshold_percent(self) -> Optional[_builtins.int]:
@@ -8885,6 +9071,14 @@ class ClusterNodeConfigKubeletConfig(dict):
         """
         return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
 
+    @_builtins.property
+    @pulumi.getter(name="maxParallelImagePulls")
+    def max_parallel_image_pulls(self) -> Optional[_builtins.int]:
+        """
+        Set the maximum number of image pulls in parallel. The integer must be between 2 and 5, inclusive.
+        """
+        return pulumi.get(self, "max_parallel_image_pulls")
+
     @_builtins.property
     @pulumi.getter(name="podPidsLimit")
     def pod_pids_limit(self) -> Optional[_builtins.int]:
@@ -8893,6 +9087,332 @@ class ClusterNodeConfigKubeletConfig(dict):
         """
         return pulumi.get(self, "pod_pids_limit")
 
+    @_builtins.property
+    @pulumi.getter(name="singleProcessOomKill")
+    def single_process_oom_kill(self) -> Optional[_builtins.bool]:
+        """
+        Defines whether to enable single process OOM killer. If true, the processes in the container will be OOM killed individually instead of as a group.
+        """
+        return pulumi.get(self, "single_process_oom_kill")
+
+
+@pulumi.output_type
+class ClusterNodeConfigKubeletConfigEvictionMinimumReclaim(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "imagefsAvailable":
+            suggest = "imagefs_available"
+        elif key == "imagefsInodesFree":
+            suggest = "imagefs_inodes_free"
+        elif key == "memoryAvailable":
+            suggest = "memory_available"
+        elif key == "nodefsAvailable":
+            suggest = "nodefs_available"
+        elif key == "nodefsInodesFree":
+            suggest = "nodefs_inodes_free"
+        elif key == "pidAvailable":
+            suggest = "pid_available"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeConfigKubeletConfigEvictionMinimumReclaim. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeConfigKubeletConfigEvictionMinimumReclaim.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeConfigKubeletConfigEvictionMinimumReclaim.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 imagefs_available: Optional[_builtins.str] = None,
+                 imagefs_inodes_free: Optional[_builtins.str] = None,
+                 memory_available: Optional[_builtins.str] = None,
+                 nodefs_available: Optional[_builtins.str] = None,
+                 nodefs_inodes_free: Optional[_builtins.str] = None,
+                 pid_available: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str imagefs_available: Defines percentage of minimum reclaim for imagefs.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        :param _builtins.str imagefs_inodes_free: Defines percentage of minimum reclaim for imagefs.inodesFree. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        :param _builtins.str memory_available: Defines percentage of minimum reclaim for memory.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        :param _builtins.str nodefs_available: Defines percentage of minimum reclaim for nodefs.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        :param _builtins.str nodefs_inodes_free: Defines percentage of minimum reclaim for nodefs.inodesFree. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        :param _builtins.str pid_available: Defines percentage of minimum reclaim for pid.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        if imagefs_available is not None:
+            pulumi.set(__self__, "imagefs_available", imagefs_available)
+        if imagefs_inodes_free is not None:
+            pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        if memory_available is not None:
+            pulumi.set(__self__, "memory_available", memory_available)
+        if nodefs_available is not None:
+            pulumi.set(__self__, "nodefs_available", nodefs_available)
+        if nodefs_inodes_free is not None:
+            pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        if pid_available is not None:
+            pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for imagefs.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for imagefs.inodesFree. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for memory.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for nodefs.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for nodefs.inodesFree. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for pid.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        return pulumi.get(self, "pid_available")
+
+
+@pulumi.output_type
+class ClusterNodeConfigKubeletConfigEvictionSoft(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "imagefsAvailable":
+            suggest = "imagefs_available"
+        elif key == "imagefsInodesFree":
+            suggest = "imagefs_inodes_free"
+        elif key == "memoryAvailable":
+            suggest = "memory_available"
+        elif key == "nodefsAvailable":
+            suggest = "nodefs_available"
+        elif key == "nodefsInodesFree":
+            suggest = "nodefs_inodes_free"
+        elif key == "pidAvailable":
+            suggest = "pid_available"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeConfigKubeletConfigEvictionSoft. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeConfigKubeletConfigEvictionSoft.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeConfigKubeletConfigEvictionSoft.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 imagefs_available: Optional[_builtins.str] = None,
+                 imagefs_inodes_free: Optional[_builtins.str] = None,
+                 memory_available: Optional[_builtins.str] = None,
+                 nodefs_available: Optional[_builtins.str] = None,
+                 nodefs_inodes_free: Optional[_builtins.str] = None,
+                 pid_available: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str imagefs_available: Defines percentage of soft eviction threshold for imagefs.available. The value must be a percentage between `15%` and `50%`, such as `"20%"`.
+        :param _builtins.str imagefs_inodes_free: Defines percentage of soft eviction threshold for imagefs.inodesFree. The value must be a percentage between `5%` and `50%`, such as `"20%"`.
+        :param _builtins.str memory_available: Defines quantity of soft eviction threshold for memory.available. The value must be a quantity, such as `"100Mi"`. The value must be greater than or equal to the GKE default hard eviction threshold of `"100Mi"` and less than 50% of machine memory.
+        :param _builtins.str nodefs_available: Defines percentage of soft eviction threshold for nodefs.available. The value must be a percentage between `10%` and `50%`, such as `"20%"`.
+        :param _builtins.str nodefs_inodes_free: Defines percentage of soft eviction threshold for nodefs.inodesFree. The value must be a percentage between `5%` and `50%`, such as `"20%"`.
+        :param _builtins.str pid_available: Defines percentage of soft eviction threshold for pid.available. The value must be a percentage between `10%` and `50%`, such as `"20%"`.
+        """
+        if imagefs_available is not None:
+            pulumi.set(__self__, "imagefs_available", imagefs_available)
+        if imagefs_inodes_free is not None:
+            pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        if memory_available is not None:
+            pulumi.set(__self__, "memory_available", memory_available)
+        if nodefs_available is not None:
+            pulumi.set(__self__, "nodefs_available", nodefs_available)
+        if nodefs_inodes_free is not None:
+            pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        if pid_available is not None:
+            pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for imagefs.available. The value must be a percentage between `15%` and `50%`, such as `"20%"`.
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for imagefs.inodesFree. The value must be a percentage between `5%` and `50%`, such as `"20%"`.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> Optional[_builtins.str]:
+        """
+        Defines quantity of soft eviction threshold for memory.available. The value must be a quantity, such as `"100Mi"`. The value must be greater than or equal to the GKE default hard eviction threshold of `"100Mi"` and less than 50% of machine memory.
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for nodefs.available. The value must be a percentage between `10%` and `50%`, such as `"20%"`.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for nodefs.inodesFree. The value must be a percentage between `5%` and `50%`, such as `"20%"`.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for pid.available. The value must be a percentage between `10%` and `50%`, such as `"20%"`.
+        """
+        return pulumi.get(self, "pid_available")
+
+
+@pulumi.output_type
+class ClusterNodeConfigKubeletConfigEvictionSoftGracePeriod(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "imagefsAvailable":
+            suggest = "imagefs_available"
+        elif key == "imagefsInodesFree":
+            suggest = "imagefs_inodes_free"
+        elif key == "memoryAvailable":
+            suggest = "memory_available"
+        elif key == "nodefsAvailable":
+            suggest = "nodefs_available"
+        elif key == "nodefsInodesFree":
+            suggest = "nodefs_inodes_free"
+        elif key == "pidAvailable":
+            suggest = "pid_available"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeConfigKubeletConfigEvictionSoftGracePeriod. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeConfigKubeletConfigEvictionSoftGracePeriod.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeConfigKubeletConfigEvictionSoftGracePeriod.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 imagefs_available: Optional[_builtins.str] = None,
+                 imagefs_inodes_free: Optional[_builtins.str] = None,
+                 memory_available: Optional[_builtins.str] = None,
+                 nodefs_available: Optional[_builtins.str] = None,
+                 nodefs_inodes_free: Optional[_builtins.str] = None,
+                 pid_available: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str imagefs_available: Defines grace period for the imagefs.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        :param _builtins.str imagefs_inodes_free: Defines grace period for the imagefs.inodesFree soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        :param _builtins.str memory_available: Defines grace period for the memory.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`, such as `"30s"`, `"1m30s"`, `"2.5m"`. Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
+        :param _builtins.str nodefs_available: Defines grace period for the nodefs.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        :param _builtins.str nodefs_inodes_free: Defines grace period for the nodefs.inodesFree soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        :param _builtins.str pid_available: Defines grace period for the pid.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        """
+        if imagefs_available is not None:
+            pulumi.set(__self__, "imagefs_available", imagefs_available)
+        if imagefs_inodes_free is not None:
+            pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        if memory_available is not None:
+            pulumi.set(__self__, "memory_available", memory_available)
+        if nodefs_available is not None:
+            pulumi.set(__self__, "nodefs_available", nodefs_available)
+        if nodefs_inodes_free is not None:
+            pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        if pid_available is not None:
+            pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the imagefs.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the imagefs.inodesFree soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the memory.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`, such as `"30s"`, `"1m30s"`, `"2.5m"`. Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the nodefs.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the nodefs.inodesFree soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the pid.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        """
+        return pulumi.get(self, "pid_available")
+
 
 @pulumi.output_type
 class ClusterNodeConfigLinuxNodeConfig(dict):
@@ -8903,6 +9423,10 @@ class ClusterNodeConfigLinuxNodeConfig(dict):
             suggest = "cgroup_mode"
         elif key == "hugepagesConfig":
             suggest = "hugepages_config"
+        elif key == "transparentHugepageDefrag":
+            suggest = "transparent_hugepage_defrag"
+        elif key == "transparentHugepageEnabled":
+            suggest = "transparent_hugepage_enabled"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ClusterNodeConfigLinuxNodeConfig. Access the value via the '{suggest}' property getter instead.")
@@ -8918,7 +9442,9 @@ class ClusterNodeConfigLinuxNodeConfig(dict):
     def __init__(__self__, *,
                  cgroup_mode: Optional[_builtins.str] = None,
                  hugepages_config: Optional['outputs.ClusterNodeConfigLinuxNodeConfigHugepagesConfig'] = None,
-                 sysctls: Optional[Mapping[str, _builtins.str]] = None):
+                 sysctls: Optional[Mapping[str, _builtins.str]] = None,
+                 transparent_hugepage_defrag: Optional[_builtins.str] = None,
+                 transparent_hugepage_enabled: Optional[_builtins.str] = None):
         """
         :param _builtins.str cgroup_mode: Possible cgroup modes that can be used.
                Accepted values are:
@@ -8930,6 +9456,8 @@ class ClusterNodeConfigLinuxNodeConfig(dict):
                and all pods running on the nodes. Specified as a map from the key, such as
                `net.core.wmem_max`, to a string value. Currently supported attributes can be found [here](https://cloud.google.com/sdk/gcloud/reference/beta/container/node-pools/create#--system-config-from-file).
                Note that validations happen all server side. All attributes are optional.
+        :param _builtins.str transparent_hugepage_defrag: The Linux kernel transparent hugepage defrag setting.
+        :param _builtins.str transparent_hugepage_enabled: The Linux kernel transparent hugepage setting.
         """
         if cgroup_mode is not None:
             pulumi.set(__self__, "cgroup_mode", cgroup_mode)
@@ -8937,6 +9465,10 @@ class ClusterNodeConfigLinuxNodeConfig(dict):
             pulumi.set(__self__, "hugepages_config", hugepages_config)
         if sysctls is not None:
             pulumi.set(__self__, "sysctls", sysctls)
+        if transparent_hugepage_defrag is not None:
+            pulumi.set(__self__, "transparent_hugepage_defrag", transparent_hugepage_defrag)
+        if transparent_hugepage_enabled is not None:
+            pulumi.set(__self__, "transparent_hugepage_enabled", transparent_hugepage_enabled)
 
     @_builtins.property
     @pulumi.getter(name="cgroupMode")
@@ -8969,6 +9501,22 @@ class ClusterNodeConfigLinuxNodeConfig(dict):
         """
         return pulumi.get(self, "sysctls")
 
+    @_builtins.property
+    @pulumi.getter(name="transparentHugepageDefrag")
+    def transparent_hugepage_defrag(self) -> Optional[_builtins.str]:
+        """
+        The Linux kernel transparent hugepage defrag setting.
+        """
+        return pulumi.get(self, "transparent_hugepage_defrag")
+
+    @_builtins.property
+    @pulumi.getter(name="transparentHugepageEnabled")
+    def transparent_hugepage_enabled(self) -> Optional[_builtins.str]:
+        """
+        The Linux kernel transparent hugepage setting.
+        """
+        return pulumi.get(self, "transparent_hugepage_enabled")
+
 
 @pulumi.output_type
 class ClusterNodeConfigLinuxNodeConfigHugepagesConfig(dict):
@@ -9281,6 +9829,8 @@ class ClusterNodeConfigSoleTenantConfig(dict):
         suggest = None
         if key == "nodeAffinities":
             suggest = "node_affinities"
+        elif key == "minNodeCpus":
+            suggest = "min_node_cpus"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ClusterNodeConfigSoleTenantConfig. Access the value via the '{suggest}' property getter instead.")
@@ -9294,20 +9844,32 @@ class ClusterNodeConfigSoleTenantConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 node_affinities: Sequence['outputs.ClusterNodeConfigSoleTenantConfigNodeAffinity']):
+                 node_affinities: Sequence['outputs.ClusterNodeConfigSoleTenantConfigNodeAffinity'],
+                 min_node_cpus: Optional[_builtins.int] = None):
         """
-        :param Sequence['ClusterNodeConfigSoleTenantConfigNodeAffinityArgs'] node_affinities: .
+        :param Sequence['ClusterNodeConfigSoleTenantConfigNodeAffinityArgs'] node_affinities: The node affinity settings for the sole tenant node pool. Structure is documented below.
+        :param _builtins.int min_node_cpus: Specifies the minimum number of vCPUs that each sole tenant node must have to use CPU overcommit. If not specified, the CPU overcommit feeature is disabled. The value should be greater than or equal to half of the machine type's CPU count.
         """
         pulumi.set(__self__, "node_affinities", node_affinities)
+        if min_node_cpus is not None:
+            pulumi.set(__self__, "min_node_cpus", min_node_cpus)
 
     @_builtins.property
     @pulumi.getter(name="nodeAffinities")
     def node_affinities(self) -> Sequence['outputs.ClusterNodeConfigSoleTenantConfigNodeAffinity']:
         """
-        .
+        The node affinity settings for the sole tenant node pool. Structure is documented below.
         """
         return pulumi.get(self, "node_affinities")
 
+    @_builtins.property
+    @pulumi.getter(name="minNodeCpus")
+    def min_node_cpus(self) -> Optional[_builtins.int]:
+        """
+        Specifies the minimum number of vCPUs that each sole tenant node must have to use CPU overcommit. If not specified, the CPU overcommit feeature is disabled. The value should be greater than or equal to half of the machine type's CPU count.
+        """
+        return pulumi.get(self, "min_node_cpus")
+
 
 @pulumi.output_type
 class ClusterNodeConfigSoleTenantConfigNodeAffinity(dict):
@@ -10648,6 +11210,8 @@ class ClusterNodePoolNodeConfig(dict):
         suggest = None
         if key == "advancedMachineFeatures":
             suggest = "advanced_machine_features"
+        elif key == "bootDisk":
+            suggest = "boot_disk"
         elif key == "bootDiskKmsKey":
             suggest = "boot_disk_kms_key"
         elif key == "confidentialNodes":
@@ -10736,6 +11300,7 @@ class ClusterNodePoolNodeConfig(dict):
 
     def __init__(__self__, *,
                  advanced_machine_features: Optional['outputs.ClusterNodePoolNodeConfigAdvancedMachineFeatures'] = None,
+                 boot_disk: Optional['outputs.ClusterNodePoolNodeConfigBootDisk'] = None,
                  boot_disk_kms_key: Optional[_builtins.str] = None,
                  confidential_nodes: Optional['outputs.ClusterNodePoolNodeConfigConfidentialNodes'] = None,
                  containerd_config: Optional['outputs.ClusterNodePoolNodeConfigContainerdConfig'] = None,
@@ -10783,13 +11348,15 @@ class ClusterNodePoolNodeConfig(dict):
         """
         :param 'ClusterNodePoolNodeConfigAdvancedMachineFeaturesArgs' advanced_machine_features: Specifies options for controlling
                advanced machine features. Structure is documented below.
+        :param 'ClusterNodePoolNodeConfigBootDiskArgs' boot_disk: Configuration of the node pool boot disk. Structure is documented below
         :param _builtins.str boot_disk_kms_key: The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool. This should be of the form projects/[KEY_PROJECT_ID]/locations/[LOCATION]/keyRings/[RING_NAME]/cryptoKeys/[KEY_NAME]. For more information about protecting resources with Cloud KMS Keys please see: <https://cloud.google.com/compute/docs/disks/customer-managed-encryption>
         :param 'ClusterNodePoolNodeConfigConfidentialNodesArgs' confidential_nodes: Configuration for Confidential Nodes feature. Structure is documented below.
         :param 'ClusterNodePoolNodeConfigContainerdConfigArgs' containerd_config: Parameters to customize containerd runtime. Structure is documented below.
         :param _builtins.int disk_size_gb: Size of the disk attached to each node, specified
-               in GB. The smallest allowed disk size is 10GB. Defaults to 100GB.
+               in GB. The smallest allowed disk size is 10GB. Defaults to 100GB. This is being migrated to `boot_disk.size_gb`, and must match if specified in both places.
+               Prefer configuring `boot_disk`.
         :param _builtins.str disk_type: Type of the disk attached to each node
-               (e.g. 'pd-standard', 'pd-balanced' or 'pd-ssd'). If unspecified, the default disk type is 'pd-balanced'
+               (e.g. 'pd-standard', 'pd-balanced' or 'pd-ssd'). If unspecified, the default disk type is 'pd-balanced' This is being migrated to `boot_disk.disk_type`, and must match if specified in both places. Prefer configuring `boot_disk`.
         :param Sequence['ClusterNodePoolNodeConfigEffectiveTaintArgs'] effective_taints: List of kubernetes taints applied to each node. Structure is documented above.
         :param _builtins.bool enable_confidential_storage: Enabling Confidential Storage will create boot disk with confidential mode. It is disabled by default.
         :param 'ClusterNodePoolNodeConfigEphemeralStorageConfigArgs' ephemeral_storage_config: Parameters for the ephemeral storage filesystem. If unspecified, ephemeral storage is backed by the boot disk. Structure is documented below.
@@ -10869,7 +11436,7 @@ class ClusterNodePoolNodeConfig(dict):
         :param _builtins.str service_account: The service account to be used by the Node VMs.
                If not specified, the "default" service account is used.
         :param 'ClusterNodePoolNodeConfigShieldedInstanceConfigArgs' shielded_instance_config: Shielded Instance options. Structure is documented below.
-        :param 'ClusterNodePoolNodeConfigSoleTenantConfigArgs' sole_tenant_config: Allows specifying multiple [node affinities](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes#node_affinity_and_anti-affinity) useful for running workloads on [sole tenant nodes](https://cloud.google.com/kubernetes-engine/docs/how-to/sole-tenancy). `node_affinity` structure is documented below.
+        :param 'ClusterNodePoolNodeConfigSoleTenantConfigArgs' sole_tenant_config: Allows specifying multiple [node affinities](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes#node_affinity_and_anti-affinity) useful for running workloads on [sole tenant nodes](https://cloud.google.com/kubernetes-engine/docs/how-to/sole-tenancy). Structure is documented below.
         :param _builtins.bool spot: A boolean that represents whether the underlying node VMs are spot.
                See the [official documentation](https://cloud.google.com/kubernetes-engine/docs/concepts/spot-vms)
                for more information. Defaults to false.
@@ -10890,6 +11457,8 @@ class ClusterNodePoolNodeConfig(dict):
         """
         if advanced_machine_features is not None:
             pulumi.set(__self__, "advanced_machine_features", advanced_machine_features)
+        if boot_disk is not None:
+            pulumi.set(__self__, "boot_disk", boot_disk)
         if boot_disk_kms_key is not None:
             pulumi.set(__self__, "boot_disk_kms_key", boot_disk_kms_key)
         if confidential_nodes is not None:
@@ -10988,6 +11557,14 @@ class ClusterNodePoolNodeConfig(dict):
         """
         return pulumi.get(self, "advanced_machine_features")
 
+    @_builtins.property
+    @pulumi.getter(name="bootDisk")
+    def boot_disk(self) -> Optional['outputs.ClusterNodePoolNodeConfigBootDisk']:
+        """
+        Configuration of the node pool boot disk. Structure is documented below
+        """
+        return pulumi.get(self, "boot_disk")
+
     @_builtins.property
     @pulumi.getter(name="bootDiskKmsKey")
     def boot_disk_kms_key(self) -> Optional[_builtins.str]:
@@ -11017,7 +11594,8 @@ class ClusterNodePoolNodeConfig(dict):
     def disk_size_gb(self) -> Optional[_builtins.int]:
         """
         Size of the disk attached to each node, specified
-        in GB. The smallest allowed disk size is 10GB. Defaults to 100GB.
+        in GB. The smallest allowed disk size is 10GB. Defaults to 100GB. This is being migrated to `boot_disk.size_gb`, and must match if specified in both places.
+        Prefer configuring `boot_disk`.
         """
         return pulumi.get(self, "disk_size_gb")
 
@@ -11026,7 +11604,7 @@ class ClusterNodePoolNodeConfig(dict):
     def disk_type(self) -> Optional[_builtins.str]:
         """
         Type of the disk attached to each node
-        (e.g. 'pd-standard', 'pd-balanced' or 'pd-ssd'). If unspecified, the default disk type is 'pd-balanced'
+        (e.g. 'pd-standard', 'pd-balanced' or 'pd-ssd'). If unspecified, the default disk type is 'pd-balanced' This is being migrated to `boot_disk.disk_type`, and must match if specified in both places. Prefer configuring `boot_disk`.
         """
         return pulumi.get(self, "disk_type")
 
@@ -11337,7 +11915,7 @@ class ClusterNodePoolNodeConfig(dict):
     @pulumi.getter(name="soleTenantConfig")
     def sole_tenant_config(self) -> Optional['outputs.ClusterNodePoolNodeConfigSoleTenantConfig']:
         """
-        Allows specifying multiple [node affinities](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes#node_affinity_and_anti-affinity) useful for running workloads on [sole tenant nodes](https://cloud.google.com/kubernetes-engine/docs/how-to/sole-tenancy). `node_affinity` structure is documented below.
+        Allows specifying multiple [node affinities](https://cloud.google.com/compute/docs/nodes/sole-tenant-nodes#node_affinity_and_anti-affinity) useful for running workloads on [sole tenant nodes](https://cloud.google.com/kubernetes-engine/docs/how-to/sole-tenancy). Structure is documented below.
         """
         return pulumi.get(self, "sole_tenant_config")
 
@@ -11465,59 +12043,141 @@ class ClusterNodePoolNodeConfigAdvancedMachineFeatures(dict):
 
 
 @pulumi.output_type
-class ClusterNodePoolNodeConfigConfidentialNodes(dict):
+class ClusterNodePoolNodeConfigBootDisk(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "confidentialInstanceType":
-            suggest = "confidential_instance_type"
+        if key == "diskType":
+            suggest = "disk_type"
+        elif key == "provisionedIops":
+            suggest = "provisioned_iops"
+        elif key == "provisionedThroughput":
+            suggest = "provisioned_throughput"
+        elif key == "sizeGb":
+            suggest = "size_gb"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolNodeConfigConfidentialNodes. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolNodeConfigBootDisk. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        ClusterNodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        ClusterNodePoolNodeConfigBootDisk.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        ClusterNodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        ClusterNodePoolNodeConfigBootDisk.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 enabled: _builtins.bool,
-                 confidential_instance_type: Optional[_builtins.str] = None):
+                 disk_type: Optional[_builtins.str] = None,
+                 provisioned_iops: Optional[_builtins.int] = None,
+                 provisioned_throughput: Optional[_builtins.int] = None,
+                 size_gb: Optional[_builtins.int] = None):
         """
-        :param _builtins.bool enabled: Enable Confidential GKE Nodes for this cluster, to
-               enforce encryption of data in-use.
-        :param _builtins.str confidential_instance_type: Defines the type of technology used
-               by the confidential node.
+        :param _builtins.str disk_type: Type of the disk attached to each node
+               (e.g. 'pd-standard', 'pd-balanced', 'pd-ssd', 'hyperdisk-balanced'). If unspecified, the default disk type is 'pd-balanced' This is being migrated from `node_config.disk_type`, and must match if specified in both places. Prefer using this field.
+        :param _builtins.int provisioned_iops: Configure disk IOPs. This is only valid if the `disk_type` is 'hyperdisk-balanced'. See [performance limit documention](https://cloud.google.com/compute/docs/disks/hyperdisk-perf-limits) for more information about valid values.
+        :param _builtins.int provisioned_throughput: Configure disk throughput. This is only valid if the `disk_type` is 'hyperdisk-balanced'. See [performance limit documention](https://cloud.google.com/compute/docs/disks/hyperdisk-perf-limits) for more information about valid values.
+        :param _builtins.int size_gb: Size of the disk attached to each node, specified
+               in GB. The smallest allowed disk size is 10GB. Defaults to 100GB. This is being migrated from `node_config.disk_size_gb`, and must match if specified in both places. Prefer using this field.
         """
-        pulumi.set(__self__, "enabled", enabled)
-        if confidential_instance_type is not None:
-            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
+        if disk_type is not None:
+            pulumi.set(__self__, "disk_type", disk_type)
+        if provisioned_iops is not None:
+            pulumi.set(__self__, "provisioned_iops", provisioned_iops)
+        if provisioned_throughput is not None:
+            pulumi.set(__self__, "provisioned_throughput", provisioned_throughput)
+        if size_gb is not None:
+            pulumi.set(__self__, "size_gb", size_gb)
 
     @_builtins.property
-    @pulumi.getter
-    def enabled(self) -> _builtins.bool:
+    @pulumi.getter(name="diskType")
+    def disk_type(self) -> Optional[_builtins.str]:
         """
-        Enable Confidential GKE Nodes for this cluster, to
-        enforce encryption of data in-use.
+        Type of the disk attached to each node
+        (e.g. 'pd-standard', 'pd-balanced', 'pd-ssd', 'hyperdisk-balanced'). If unspecified, the default disk type is 'pd-balanced' This is being migrated from `node_config.disk_type`, and must match if specified in both places. Prefer using this field.
         """
-        return pulumi.get(self, "enabled")
+        return pulumi.get(self, "disk_type")
 
     @_builtins.property
-    @pulumi.getter(name="confidentialInstanceType")
-    def confidential_instance_type(self) -> Optional[_builtins.str]:
+    @pulumi.getter(name="provisionedIops")
+    def provisioned_iops(self) -> Optional[_builtins.int]:
         """
-        Defines the type of technology used
-        by the confidential node.
+        Configure disk IOPs. This is only valid if the `disk_type` is 'hyperdisk-balanced'. See [performance limit documention](https://cloud.google.com/compute/docs/disks/hyperdisk-perf-limits) for more information about valid values.
         """
-        return pulumi.get(self, "confidential_instance_type")
+        return pulumi.get(self, "provisioned_iops")
 
+    @_builtins.property
+    @pulumi.getter(name="provisionedThroughput")
+    def provisioned_throughput(self) -> Optional[_builtins.int]:
+        """
+        Configure disk throughput. This is only valid if the `disk_type` is 'hyperdisk-balanced'. See [performance limit documention](https://cloud.google.com/compute/docs/disks/hyperdisk-perf-limits) for more information about valid values.
+        """
+        return pulumi.get(self, "provisioned_throughput")
 
-@pulumi.output_type
-class ClusterNodePoolNodeConfigContainerdConfig(dict):
-    @staticmethod
+    @_builtins.property
+    @pulumi.getter(name="sizeGb")
+    def size_gb(self) -> Optional[_builtins.int]:
+        """
+        Size of the disk attached to each node, specified
+        in GB. The smallest allowed disk size is 10GB. Defaults to 100GB. This is being migrated from `node_config.disk_size_gb`, and must match if specified in both places. Prefer using this field.
+        """
+        return pulumi.get(self, "size_gb")
+
+
+@pulumi.output_type
+class ClusterNodePoolNodeConfigConfidentialNodes(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "confidentialInstanceType":
+            suggest = "confidential_instance_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolNodeConfigConfidentialNodes. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enabled: _builtins.bool,
+                 confidential_instance_type: Optional[_builtins.str] = None):
+        """
+        :param _builtins.bool enabled: Enable Confidential GKE Nodes for this cluster, to
+               enforce encryption of data in-use.
+        :param _builtins.str confidential_instance_type: Defines the type of technology used
+               by the confidential node.
+        """
+        pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
+
+    @_builtins.property
+    @pulumi.getter
+    def enabled(self) -> _builtins.bool:
+        """
+        Enable Confidential GKE Nodes for this cluster, to
+        enforce encryption of data in-use.
+        """
+        return pulumi.get(self, "enabled")
+
+    @_builtins.property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[_builtins.str]:
+        """
+        Defines the type of technology used
+        by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
+
+@pulumi.output_type
+class ClusterNodePoolNodeConfigContainerdConfig(dict):
+    @staticmethod
     def __key_warning(key: str):
         suggest = None
         if key == "privateRegistryAccessConfig":
@@ -12097,6 +12757,14 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
             suggest = "cpu_cfs_quota_period"
         elif key == "cpuManagerPolicy":
             suggest = "cpu_manager_policy"
+        elif key == "evictionMaxPodGracePeriodSeconds":
+            suggest = "eviction_max_pod_grace_period_seconds"
+        elif key == "evictionMinimumReclaim":
+            suggest = "eviction_minimum_reclaim"
+        elif key == "evictionSoft":
+            suggest = "eviction_soft"
+        elif key == "evictionSoftGracePeriod":
+            suggest = "eviction_soft_grace_period"
         elif key == "imageGcHighThresholdPercent":
             suggest = "image_gc_high_threshold_percent"
         elif key == "imageGcLowThresholdPercent":
@@ -12107,8 +12775,12 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
             suggest = "image_minimum_gc_age"
         elif key == "insecureKubeletReadonlyPortEnabled":
             suggest = "insecure_kubelet_readonly_port_enabled"
+        elif key == "maxParallelImagePulls":
+            suggest = "max_parallel_image_pulls"
         elif key == "podPidsLimit":
             suggest = "pod_pids_limit"
+        elif key == "singleProcessOomKill":
+            suggest = "single_process_oom_kill"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolNodeConfigKubeletConfig. Access the value via the '{suggest}' property getter instead.")
@@ -12128,12 +12800,18 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
                  cpu_cfs_quota: Optional[_builtins.bool] = None,
                  cpu_cfs_quota_period: Optional[_builtins.str] = None,
                  cpu_manager_policy: Optional[_builtins.str] = None,
+                 eviction_max_pod_grace_period_seconds: Optional[_builtins.int] = None,
+                 eviction_minimum_reclaim: Optional['outputs.ClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaim'] = None,
+                 eviction_soft: Optional['outputs.ClusterNodePoolNodeConfigKubeletConfigEvictionSoft'] = None,
+                 eviction_soft_grace_period: Optional['outputs.ClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod'] = None,
                  image_gc_high_threshold_percent: Optional[_builtins.int] = None,
                  image_gc_low_threshold_percent: Optional[_builtins.int] = None,
                  image_maximum_gc_age: Optional[_builtins.str] = None,
                  image_minimum_gc_age: Optional[_builtins.str] = None,
                  insecure_kubelet_readonly_port_enabled: Optional[_builtins.str] = None,
-                 pod_pids_limit: Optional[_builtins.int] = None):
+                 max_parallel_image_pulls: Optional[_builtins.int] = None,
+                 pod_pids_limit: Optional[_builtins.int] = None,
+                 single_process_oom_kill: Optional[_builtins.bool] = None):
         """
         :param Sequence[_builtins.str] allowed_unsafe_sysctls: Defines a comma-separated allowlist of unsafe sysctls or sysctl patterns which can be set on the Pods. The allowed sysctl groups are `kernel.shm*`, `kernel.msg*`, `kernel.sem`, `fs.mqueue.*`, and `net.*`.
         :param _builtins.int container_log_max_files: Defines the maximum number of container log files that can be present for a container. The integer must be between 2 and 10, inclusive.
@@ -12153,12 +12831,18 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
                One of `"none"` or `"static"`. If unset (or set to the empty string `""`), the API will treat the field as if set to "none".
                Prior to the 6.4.0 this field was marked as required. The workaround for the required field
                is setting the empty string `""`, which will function identically to not setting this field.
+        :param _builtins.int eviction_max_pod_grace_period_seconds: Defines the maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met. The integer must be positive and not exceed 300.
+        :param 'ClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaimArgs' eviction_minimum_reclaim: Defines a map of signal names to percentage that defines minimum reclaims. It describes the minimum amount of a given resource the kubelet will reclaim when performing a pod eviction. Structure is documented below.
+        :param 'ClusterNodePoolNodeConfigKubeletConfigEvictionSoftArgs' eviction_soft: Defines a map of signal names to quantities or percentage that defines soft eviction thresholds. Structure is documented below.
+        :param 'ClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriodArgs' eviction_soft_grace_period: Defines a map of signal names to durations that defines grace periods for soft eviction thresholds. Each soft eviction threshold must have a corresponding grace period. Structure is documented below.
         :param _builtins.int image_gc_high_threshold_percent: Defines the percent of disk usage after which image garbage collection is always run. The integer must be between 10 and 85, inclusive.
         :param _builtins.int image_gc_low_threshold_percent: Defines the percent of disk usage before which image garbage collection is never run. Lowest disk usage to garbage collect to. The integer must be between 10 and 85, inclusive.
         :param _builtins.str image_maximum_gc_age: Defines the maximum age an image can be unused before it is garbage collected. Specified as a sequence of decimal numbers, each with optional fraction and a unit suffix, such as `"300s"`, `"1.5m"`, and `"2h45m"`. Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h". The value must be a positive duration.
         :param _builtins.str image_minimum_gc_age: Defines the minimum age for an unused image before it is garbage collected. Specified as a sequence of decimal numbers, each with optional fraction and a unit suffix, such as `"300s"`, `"1.5m"`. The value cannot be greater than "2m".
         :param _builtins.str insecure_kubelet_readonly_port_enabled: Controls whether the kubelet read-only port is enabled. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        :param _builtins.int max_parallel_image_pulls: Set the maximum number of image pulls in parallel. The integer must be between 2 and 5, inclusive.
         :param _builtins.int pod_pids_limit: Controls the maximum number of processes allowed to run in a pod. The value must be greater than or equal to 1024 and less than 4194304.
+        :param _builtins.bool single_process_oom_kill: Defines whether to enable single process OOM killer. If true, the processes in the container will be OOM killed individually instead of as a group.
         """
         if allowed_unsafe_sysctls is not None:
             pulumi.set(__self__, "allowed_unsafe_sysctls", allowed_unsafe_sysctls)
@@ -12172,6 +12856,14 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
             pulumi.set(__self__, "cpu_cfs_quota_period", cpu_cfs_quota_period)
         if cpu_manager_policy is not None:
             pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
+        if eviction_max_pod_grace_period_seconds is not None:
+            pulumi.set(__self__, "eviction_max_pod_grace_period_seconds", eviction_max_pod_grace_period_seconds)
+        if eviction_minimum_reclaim is not None:
+            pulumi.set(__self__, "eviction_minimum_reclaim", eviction_minimum_reclaim)
+        if eviction_soft is not None:
+            pulumi.set(__self__, "eviction_soft", eviction_soft)
+        if eviction_soft_grace_period is not None:
+            pulumi.set(__self__, "eviction_soft_grace_period", eviction_soft_grace_period)
         if image_gc_high_threshold_percent is not None:
             pulumi.set(__self__, "image_gc_high_threshold_percent", image_gc_high_threshold_percent)
         if image_gc_low_threshold_percent is not None:
@@ -12182,8 +12874,12 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
             pulumi.set(__self__, "image_minimum_gc_age", image_minimum_gc_age)
         if insecure_kubelet_readonly_port_enabled is not None:
             pulumi.set(__self__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
+        if max_parallel_image_pulls is not None:
+            pulumi.set(__self__, "max_parallel_image_pulls", max_parallel_image_pulls)
         if pod_pids_limit is not None:
             pulumi.set(__self__, "pod_pids_limit", pod_pids_limit)
+        if single_process_oom_kill is not None:
+            pulumi.set(__self__, "single_process_oom_kill", single_process_oom_kill)
 
     @_builtins.property
     @pulumi.getter(name="allowedUnsafeSysctls")
@@ -12245,6 +12941,38 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
         """
         return pulumi.get(self, "cpu_manager_policy")
 
+    @_builtins.property
+    @pulumi.getter(name="evictionMaxPodGracePeriodSeconds")
+    def eviction_max_pod_grace_period_seconds(self) -> Optional[_builtins.int]:
+        """
+        Defines the maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met. The integer must be positive and not exceed 300.
+        """
+        return pulumi.get(self, "eviction_max_pod_grace_period_seconds")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionMinimumReclaim")
+    def eviction_minimum_reclaim(self) -> Optional['outputs.ClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaim']:
+        """
+        Defines a map of signal names to percentage that defines minimum reclaims. It describes the minimum amount of a given resource the kubelet will reclaim when performing a pod eviction. Structure is documented below.
+        """
+        return pulumi.get(self, "eviction_minimum_reclaim")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionSoft")
+    def eviction_soft(self) -> Optional['outputs.ClusterNodePoolNodeConfigKubeletConfigEvictionSoft']:
+        """
+        Defines a map of signal names to quantities or percentage that defines soft eviction thresholds. Structure is documented below.
+        """
+        return pulumi.get(self, "eviction_soft")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionSoftGracePeriod")
+    def eviction_soft_grace_period(self) -> Optional['outputs.ClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod']:
+        """
+        Defines a map of signal names to durations that defines grace periods for soft eviction thresholds. Each soft eviction threshold must have a corresponding grace period. Structure is documented below.
+        """
+        return pulumi.get(self, "eviction_soft_grace_period")
+
     @_builtins.property
     @pulumi.getter(name="imageGcHighThresholdPercent")
     def image_gc_high_threshold_percent(self) -> Optional[_builtins.int]:
@@ -12285,6 +13013,14 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
         """
         return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
 
+    @_builtins.property
+    @pulumi.getter(name="maxParallelImagePulls")
+    def max_parallel_image_pulls(self) -> Optional[_builtins.int]:
+        """
+        Set the maximum number of image pulls in parallel. The integer must be between 2 and 5, inclusive.
+        """
+        return pulumi.get(self, "max_parallel_image_pulls")
+
     @_builtins.property
     @pulumi.getter(name="podPidsLimit")
     def pod_pids_limit(self) -> Optional[_builtins.int]:
@@ -12293,6 +13029,332 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
         """
         return pulumi.get(self, "pod_pids_limit")
 
+    @_builtins.property
+    @pulumi.getter(name="singleProcessOomKill")
+    def single_process_oom_kill(self) -> Optional[_builtins.bool]:
+        """
+        Defines whether to enable single process OOM killer. If true, the processes in the container will be OOM killed individually instead of as a group.
+        """
+        return pulumi.get(self, "single_process_oom_kill")
+
+
+@pulumi.output_type
+class ClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaim(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "imagefsAvailable":
+            suggest = "imagefs_available"
+        elif key == "imagefsInodesFree":
+            suggest = "imagefs_inodes_free"
+        elif key == "memoryAvailable":
+            suggest = "memory_available"
+        elif key == "nodefsAvailable":
+            suggest = "nodefs_available"
+        elif key == "nodefsInodesFree":
+            suggest = "nodefs_inodes_free"
+        elif key == "pidAvailable":
+            suggest = "pid_available"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaim. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaim.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaim.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 imagefs_available: Optional[_builtins.str] = None,
+                 imagefs_inodes_free: Optional[_builtins.str] = None,
+                 memory_available: Optional[_builtins.str] = None,
+                 nodefs_available: Optional[_builtins.str] = None,
+                 nodefs_inodes_free: Optional[_builtins.str] = None,
+                 pid_available: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str imagefs_available: Defines percentage of minimum reclaim for imagefs.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        :param _builtins.str imagefs_inodes_free: Defines percentage of minimum reclaim for imagefs.inodesFree. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        :param _builtins.str memory_available: Defines percentage of minimum reclaim for memory.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        :param _builtins.str nodefs_available: Defines percentage of minimum reclaim for nodefs.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        :param _builtins.str nodefs_inodes_free: Defines percentage of minimum reclaim for nodefs.inodesFree. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        :param _builtins.str pid_available: Defines percentage of minimum reclaim for pid.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        if imagefs_available is not None:
+            pulumi.set(__self__, "imagefs_available", imagefs_available)
+        if imagefs_inodes_free is not None:
+            pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        if memory_available is not None:
+            pulumi.set(__self__, "memory_available", memory_available)
+        if nodefs_available is not None:
+            pulumi.set(__self__, "nodefs_available", nodefs_available)
+        if nodefs_inodes_free is not None:
+            pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        if pid_available is not None:
+            pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for imagefs.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for imagefs.inodesFree. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for memory.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for nodefs.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for nodefs.inodesFree. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for pid.available. The value must be a percentage no more than `"10%"`, such as `"5%"`.
+        """
+        return pulumi.get(self, "pid_available")
+
+
+@pulumi.output_type
+class ClusterNodePoolNodeConfigKubeletConfigEvictionSoft(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "imagefsAvailable":
+            suggest = "imagefs_available"
+        elif key == "imagefsInodesFree":
+            suggest = "imagefs_inodes_free"
+        elif key == "memoryAvailable":
+            suggest = "memory_available"
+        elif key == "nodefsAvailable":
+            suggest = "nodefs_available"
+        elif key == "nodefsInodesFree":
+            suggest = "nodefs_inodes_free"
+        elif key == "pidAvailable":
+            suggest = "pid_available"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolNodeConfigKubeletConfigEvictionSoft. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodePoolNodeConfigKubeletConfigEvictionSoft.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodePoolNodeConfigKubeletConfigEvictionSoft.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 imagefs_available: Optional[_builtins.str] = None,
+                 imagefs_inodes_free: Optional[_builtins.str] = None,
+                 memory_available: Optional[_builtins.str] = None,
+                 nodefs_available: Optional[_builtins.str] = None,
+                 nodefs_inodes_free: Optional[_builtins.str] = None,
+                 pid_available: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str imagefs_available: Defines percentage of soft eviction threshold for imagefs.available. The value must be a percentage between `15%` and `50%`, such as `"20%"`.
+        :param _builtins.str imagefs_inodes_free: Defines percentage of soft eviction threshold for imagefs.inodesFree. The value must be a percentage between `5%` and `50%`, such as `"20%"`.
+        :param _builtins.str memory_available: Defines quantity of soft eviction threshold for memory.available. The value must be a quantity, such as `"100Mi"`. The value must be greater than or equal to the GKE default hard eviction threshold of `"100Mi"` and less than 50% of machine memory.
+        :param _builtins.str nodefs_available: Defines percentage of soft eviction threshold for nodefs.available. The value must be a percentage between `10%` and `50%`, such as `"20%"`.
+        :param _builtins.str nodefs_inodes_free: Defines percentage of soft eviction threshold for nodefs.inodesFree. The value must be a percentage between `5%` and `50%`, such as `"20%"`.
+        :param _builtins.str pid_available: Defines percentage of soft eviction threshold for pid.available. The value must be a percentage between `10%` and `50%`, such as `"20%"`.
+        """
+        if imagefs_available is not None:
+            pulumi.set(__self__, "imagefs_available", imagefs_available)
+        if imagefs_inodes_free is not None:
+            pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        if memory_available is not None:
+            pulumi.set(__self__, "memory_available", memory_available)
+        if nodefs_available is not None:
+            pulumi.set(__self__, "nodefs_available", nodefs_available)
+        if nodefs_inodes_free is not None:
+            pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        if pid_available is not None:
+            pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for imagefs.available. The value must be a percentage between `15%` and `50%`, such as `"20%"`.
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for imagefs.inodesFree. The value must be a percentage between `5%` and `50%`, such as `"20%"`.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> Optional[_builtins.str]:
+        """
+        Defines quantity of soft eviction threshold for memory.available. The value must be a quantity, such as `"100Mi"`. The value must be greater than or equal to the GKE default hard eviction threshold of `"100Mi"` and less than 50% of machine memory.
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for nodefs.available. The value must be a percentage between `10%` and `50%`, such as `"20%"`.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for nodefs.inodesFree. The value must be a percentage between `5%` and `50%`, such as `"20%"`.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for pid.available. The value must be a percentage between `10%` and `50%`, such as `"20%"`.
+        """
+        return pulumi.get(self, "pid_available")
+
+
+@pulumi.output_type
+class ClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "imagefsAvailable":
+            suggest = "imagefs_available"
+        elif key == "imagefsInodesFree":
+            suggest = "imagefs_inodes_free"
+        elif key == "memoryAvailable":
+            suggest = "memory_available"
+        elif key == "nodefsAvailable":
+            suggest = "nodefs_available"
+        elif key == "nodefsInodesFree":
+            suggest = "nodefs_inodes_free"
+        elif key == "pidAvailable":
+            suggest = "pid_available"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 imagefs_available: Optional[_builtins.str] = None,
+                 imagefs_inodes_free: Optional[_builtins.str] = None,
+                 memory_available: Optional[_builtins.str] = None,
+                 nodefs_available: Optional[_builtins.str] = None,
+                 nodefs_inodes_free: Optional[_builtins.str] = None,
+                 pid_available: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str imagefs_available: Defines grace period for the imagefs.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        :param _builtins.str imagefs_inodes_free: Defines grace period for the imagefs.inodesFree soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        :param _builtins.str memory_available: Defines grace period for the memory.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`, such as `"30s"`, `"1m30s"`, `"2.5m"`. Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
+        :param _builtins.str nodefs_available: Defines grace period for the nodefs.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        :param _builtins.str nodefs_inodes_free: Defines grace period for the nodefs.inodesFree soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        :param _builtins.str pid_available: Defines grace period for the pid.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        """
+        if imagefs_available is not None:
+            pulumi.set(__self__, "imagefs_available", imagefs_available)
+        if imagefs_inodes_free is not None:
+            pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        if memory_available is not None:
+            pulumi.set(__self__, "memory_available", memory_available)
+        if nodefs_available is not None:
+            pulumi.set(__self__, "nodefs_available", nodefs_available)
+        if nodefs_inodes_free is not None:
+            pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        if pid_available is not None:
+            pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the imagefs.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the imagefs.inodesFree soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the memory.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`, such as `"30s"`, `"1m30s"`, `"2.5m"`. Valid time units are "ns", "us" (or "µs"), "ms", "s", "m", "h".
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the nodefs.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the nodefs.inodesFree soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the pid.available soft eviction threshold. The value must be a positive duration string no more than `"5m"`.
+        """
+        return pulumi.get(self, "pid_available")
+
 
 @pulumi.output_type
 class ClusterNodePoolNodeConfigLinuxNodeConfig(dict):
@@ -12303,6 +13365,10 @@ class ClusterNodePoolNodeConfigLinuxNodeConfig(dict):
             suggest = "cgroup_mode"
         elif key == "hugepagesConfig":
             suggest = "hugepages_config"
+        elif key == "transparentHugepageDefrag":
+            suggest = "transparent_hugepage_defrag"
+        elif key == "transparentHugepageEnabled":
+            suggest = "transparent_hugepage_enabled"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolNodeConfigLinuxNodeConfig. Access the value via the '{suggest}' property getter instead.")
@@ -12318,7 +13384,9 @@ class ClusterNodePoolNodeConfigLinuxNodeConfig(dict):
     def __init__(__self__, *,
                  cgroup_mode: Optional[_builtins.str] = None,
                  hugepages_config: Optional['outputs.ClusterNodePoolNodeConfigLinuxNodeConfigHugepagesConfig'] = None,
-                 sysctls: Optional[Mapping[str, _builtins.str]] = None):
+                 sysctls: Optional[Mapping[str, _builtins.str]] = None,
+                 transparent_hugepage_defrag: Optional[_builtins.str] = None,
+                 transparent_hugepage_enabled: Optional[_builtins.str] = None):
         """
         :param _builtins.str cgroup_mode: Possible cgroup modes that can be used.
                Accepted values are:
@@ -12330,6 +13398,8 @@ class ClusterNodePoolNodeConfigLinuxNodeConfig(dict):
                and all pods running on the nodes. Specified as a map from the key, such as
                `net.core.wmem_max`, to a string value. Currently supported attributes can be found [here](https://cloud.google.com/sdk/gcloud/reference/beta/container/node-pools/create#--system-config-from-file).
                Note that validations happen all server side. All attributes are optional.
+        :param _builtins.str transparent_hugepage_defrag: The Linux kernel transparent hugepage defrag setting.
+        :param _builtins.str transparent_hugepage_enabled: The Linux kernel transparent hugepage setting.
         """
         if cgroup_mode is not None:
             pulumi.set(__self__, "cgroup_mode", cgroup_mode)
@@ -12337,6 +13407,10 @@ class ClusterNodePoolNodeConfigLinuxNodeConfig(dict):
             pulumi.set(__self__, "hugepages_config", hugepages_config)
         if sysctls is not None:
             pulumi.set(__self__, "sysctls", sysctls)
+        if transparent_hugepage_defrag is not None:
+            pulumi.set(__self__, "transparent_hugepage_defrag", transparent_hugepage_defrag)
+        if transparent_hugepage_enabled is not None:
+            pulumi.set(__self__, "transparent_hugepage_enabled", transparent_hugepage_enabled)
 
     @_builtins.property
     @pulumi.getter(name="cgroupMode")
@@ -12369,6 +13443,22 @@ class ClusterNodePoolNodeConfigLinuxNodeConfig(dict):
         """
         return pulumi.get(self, "sysctls")
 
+    @_builtins.property
+    @pulumi.getter(name="transparentHugepageDefrag")
+    def transparent_hugepage_defrag(self) -> Optional[_builtins.str]:
+        """
+        The Linux kernel transparent hugepage defrag setting.
+        """
+        return pulumi.get(self, "transparent_hugepage_defrag")
+
+    @_builtins.property
+    @pulumi.getter(name="transparentHugepageEnabled")
+    def transparent_hugepage_enabled(self) -> Optional[_builtins.str]:
+        """
+        The Linux kernel transparent hugepage setting.
+        """
+        return pulumi.get(self, "transparent_hugepage_enabled")
+
 
 @pulumi.output_type
 class ClusterNodePoolNodeConfigLinuxNodeConfigHugepagesConfig(dict):
@@ -12681,6 +13771,8 @@ class ClusterNodePoolNodeConfigSoleTenantConfig(dict):
         suggest = None
         if key == "nodeAffinities":
             suggest = "node_affinities"
+        elif key == "minNodeCpus":
+            suggest = "min_node_cpus"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolNodeConfigSoleTenantConfig. Access the value via the '{suggest}' property getter instead.")
@@ -12694,20 +13786,32 @@ class ClusterNodePoolNodeConfigSoleTenantConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 node_affinities: Sequence['outputs.ClusterNodePoolNodeConfigSoleTenantConfigNodeAffinity']):
+                 node_affinities: Sequence['outputs.ClusterNodePoolNodeConfigSoleTenantConfigNodeAffinity'],
+                 min_node_cpus: Optional[_builtins.int] = None):
         """
-        :param Sequence['ClusterNodePoolNodeConfigSoleTenantConfigNodeAffinityArgs'] node_affinities: .
+        :param Sequence['ClusterNodePoolNodeConfigSoleTenantConfigNodeAffinityArgs'] node_affinities: The node affinity settings for the sole tenant node pool. Structure is documented below.
+        :param _builtins.int min_node_cpus: Specifies the minimum number of vCPUs that each sole tenant node must have to use CPU overcommit. If not specified, the CPU overcommit feeature is disabled. The value should be greater than or equal to half of the machine type's CPU count.
         """
         pulumi.set(__self__, "node_affinities", node_affinities)
+        if min_node_cpus is not None:
+            pulumi.set(__self__, "min_node_cpus", min_node_cpus)
 
     @_builtins.property
     @pulumi.getter(name="nodeAffinities")
     def node_affinities(self) -> Sequence['outputs.ClusterNodePoolNodeConfigSoleTenantConfigNodeAffinity']:
         """
-        .
+        The node affinity settings for the sole tenant node pool. Structure is documented below.
         """
         return pulumi.get(self, "node_affinities")
 
+    @_builtins.property
+    @pulumi.getter(name="minNodeCpus")
+    def min_node_cpus(self) -> Optional[_builtins.int]:
+        """
+        Specifies the minimum number of vCPUs that each sole tenant node must have to use CPU overcommit. If not specified, the CPU overcommit feeature is disabled. The value should be greater than or equal to half of the machine type's CPU count.
+        """
+        return pulumi.get(self, "min_node_cpus")
+
 
 @pulumi.output_type
 class ClusterNodePoolNodeConfigSoleTenantConfigNodeAffinity(dict):
@@ -14638,6 +15742,8 @@ class NodePoolNodeConfig(dict):
         suggest = None
         if key == "advancedMachineFeatures":
             suggest = "advanced_machine_features"
+        elif key == "bootDisk":
+            suggest = "boot_disk"
         elif key == "bootDiskKmsKey":
             suggest = "boot_disk_kms_key"
         elif key == "confidentialNodes":
@@ -14726,6 +15832,7 @@ class NodePoolNodeConfig(dict):
 
     def __init__(__self__, *,
                  advanced_machine_features: Optional['outputs.NodePoolNodeConfigAdvancedMachineFeatures'] = None,
+                 boot_disk: Optional['outputs.NodePoolNodeConfigBootDisk'] = None,
                  boot_disk_kms_key: Optional[_builtins.str] = None,
                  confidential_nodes: Optional['outputs.NodePoolNodeConfigConfidentialNodes'] = None,
                  containerd_config: Optional['outputs.NodePoolNodeConfigContainerdConfig'] = None,
@@ -14772,6 +15879,7 @@ class NodePoolNodeConfig(dict):
                  workload_metadata_config: Optional['outputs.NodePoolNodeConfigWorkloadMetadataConfig'] = None):
         """
         :param 'NodePoolNodeConfigAdvancedMachineFeaturesArgs' advanced_machine_features: Specifies options for controlling advanced machine features.
+        :param 'NodePoolNodeConfigBootDiskArgs' boot_disk: Boot disk configuration for node pools nodes.
         :param _builtins.str boot_disk_kms_key: The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool.
         :param 'NodePoolNodeConfigConfidentialNodesArgs' confidential_nodes: Configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
         :param 'NodePoolNodeConfigContainerdConfigArgs' containerd_config: Parameters for containerd configuration.
@@ -14819,6 +15927,8 @@ class NodePoolNodeConfig(dict):
         """
         if advanced_machine_features is not None:
             pulumi.set(__self__, "advanced_machine_features", advanced_machine_features)
+        if boot_disk is not None:
+            pulumi.set(__self__, "boot_disk", boot_disk)
         if boot_disk_kms_key is not None:
             pulumi.set(__self__, "boot_disk_kms_key", boot_disk_kms_key)
         if confidential_nodes is not None:
@@ -14916,6 +16026,14 @@ class NodePoolNodeConfig(dict):
         """
         return pulumi.get(self, "advanced_machine_features")
 
+    @_builtins.property
+    @pulumi.getter(name="bootDisk")
+    def boot_disk(self) -> Optional['outputs.NodePoolNodeConfigBootDisk']:
+        """
+        Boot disk configuration for node pools nodes.
+        """
+        return pulumi.get(self, "boot_disk")
+
     @_builtins.property
     @pulumi.getter(name="bootDiskKmsKey")
     def boot_disk_kms_key(self) -> Optional[_builtins.str]:
@@ -15333,46 +16451,124 @@ class NodePoolNodeConfigAdvancedMachineFeatures(dict):
 
 
 @pulumi.output_type
-class NodePoolNodeConfigConfidentialNodes(dict):
+class NodePoolNodeConfigBootDisk(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "confidentialInstanceType":
-            suggest = "confidential_instance_type"
+        if key == "diskType":
+            suggest = "disk_type"
+        elif key == "provisionedIops":
+            suggest = "provisioned_iops"
+        elif key == "provisionedThroughput":
+            suggest = "provisioned_throughput"
+        elif key == "sizeGb":
+            suggest = "size_gb"
 
         if suggest:
-            pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeConfigConfidentialNodes. Access the value via the '{suggest}' property getter instead.")
+            pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeConfigBootDisk. Access the value via the '{suggest}' property getter instead.")
 
     def __getitem__(self, key: str) -> Any:
-        NodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        NodePoolNodeConfigBootDisk.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        NodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        NodePoolNodeConfigBootDisk.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 enabled: _builtins.bool,
-                 confidential_instance_type: Optional[_builtins.str] = None):
+                 disk_type: Optional[_builtins.str] = None,
+                 provisioned_iops: Optional[_builtins.int] = None,
+                 provisioned_throughput: Optional[_builtins.int] = None,
+                 size_gb: Optional[_builtins.int] = None):
         """
-        :param _builtins.bool enabled: Whether Confidential Nodes feature is enabled for all nodes in this pool.
-        :param _builtins.str confidential_instance_type: Defines the type of technology used by the confidential node.
+        :param _builtins.str disk_type: Type of the disk attached to each node. Such as pd-standard, pd-balanced or pd-ssd
+        :param _builtins.int provisioned_iops: Configured IOPs provisioning. Only valid with disk type hyperdisk-balanced.
+        :param _builtins.int provisioned_throughput: Configured throughput provisioning. Only valid with disk type hyperdisk-balanced.
+        :param _builtins.int size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB.
         """
-        pulumi.set(__self__, "enabled", enabled)
-        if confidential_instance_type is not None:
-            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
+        if disk_type is not None:
+            pulumi.set(__self__, "disk_type", disk_type)
+        if provisioned_iops is not None:
+            pulumi.set(__self__, "provisioned_iops", provisioned_iops)
+        if provisioned_throughput is not None:
+            pulumi.set(__self__, "provisioned_throughput", provisioned_throughput)
+        if size_gb is not None:
+            pulumi.set(__self__, "size_gb", size_gb)
 
     @_builtins.property
-    @pulumi.getter
-    def enabled(self) -> _builtins.bool:
+    @pulumi.getter(name="diskType")
+    def disk_type(self) -> Optional[_builtins.str]:
         """
-        Whether Confidential Nodes feature is enabled for all nodes in this pool.
+        Type of the disk attached to each node. Such as pd-standard, pd-balanced or pd-ssd
         """
-        return pulumi.get(self, "enabled")
+        return pulumi.get(self, "disk_type")
 
     @_builtins.property
-    @pulumi.getter(name="confidentialInstanceType")
-    def confidential_instance_type(self) -> Optional[_builtins.str]:
+    @pulumi.getter(name="provisionedIops")
+    def provisioned_iops(self) -> Optional[_builtins.int]:
+        """
+        Configured IOPs provisioning. Only valid with disk type hyperdisk-balanced.
+        """
+        return pulumi.get(self, "provisioned_iops")
+
+    @_builtins.property
+    @pulumi.getter(name="provisionedThroughput")
+    def provisioned_throughput(self) -> Optional[_builtins.int]:
+        """
+        Configured throughput provisioning. Only valid with disk type hyperdisk-balanced.
+        """
+        return pulumi.get(self, "provisioned_throughput")
+
+    @_builtins.property
+    @pulumi.getter(name="sizeGb")
+    def size_gb(self) -> Optional[_builtins.int]:
+        """
+        Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB.
+        """
+        return pulumi.get(self, "size_gb")
+
+
+@pulumi.output_type
+class NodePoolNodeConfigConfidentialNodes(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "confidentialInstanceType":
+            suggest = "confidential_instance_type"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeConfigConfidentialNodes. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodePoolNodeConfigConfidentialNodes.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enabled: _builtins.bool,
+                 confidential_instance_type: Optional[_builtins.str] = None):
+        """
+        :param _builtins.bool enabled: Whether Confidential Nodes feature is enabled for all nodes in this pool.
+        :param _builtins.str confidential_instance_type: Defines the type of technology used by the confidential node.
+        """
+        pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
+
+    @_builtins.property
+    @pulumi.getter
+    def enabled(self) -> _builtins.bool:
+        """
+        Whether Confidential Nodes feature is enabled for all nodes in this pool.
+        """
+        return pulumi.get(self, "enabled")
+
+    @_builtins.property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[_builtins.str]:
         """
         Defines the type of technology used by the confidential node.
         """
@@ -15945,6 +17141,14 @@ class NodePoolNodeConfigKubeletConfig(dict):
             suggest = "cpu_cfs_quota_period"
         elif key == "cpuManagerPolicy":
             suggest = "cpu_manager_policy"
+        elif key == "evictionMaxPodGracePeriodSeconds":
+            suggest = "eviction_max_pod_grace_period_seconds"
+        elif key == "evictionMinimumReclaim":
+            suggest = "eviction_minimum_reclaim"
+        elif key == "evictionSoft":
+            suggest = "eviction_soft"
+        elif key == "evictionSoftGracePeriod":
+            suggest = "eviction_soft_grace_period"
         elif key == "imageGcHighThresholdPercent":
             suggest = "image_gc_high_threshold_percent"
         elif key == "imageGcLowThresholdPercent":
@@ -15955,8 +17159,12 @@ class NodePoolNodeConfigKubeletConfig(dict):
             suggest = "image_minimum_gc_age"
         elif key == "insecureKubeletReadonlyPortEnabled":
             suggest = "insecure_kubelet_readonly_port_enabled"
+        elif key == "maxParallelImagePulls":
+            suggest = "max_parallel_image_pulls"
         elif key == "podPidsLimit":
             suggest = "pod_pids_limit"
+        elif key == "singleProcessOomKill":
+            suggest = "single_process_oom_kill"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeConfigKubeletConfig. Access the value via the '{suggest}' property getter instead.")
@@ -15976,12 +17184,18 @@ class NodePoolNodeConfigKubeletConfig(dict):
                  cpu_cfs_quota: Optional[_builtins.bool] = None,
                  cpu_cfs_quota_period: Optional[_builtins.str] = None,
                  cpu_manager_policy: Optional[_builtins.str] = None,
+                 eviction_max_pod_grace_period_seconds: Optional[_builtins.int] = None,
+                 eviction_minimum_reclaim: Optional['outputs.NodePoolNodeConfigKubeletConfigEvictionMinimumReclaim'] = None,
+                 eviction_soft: Optional['outputs.NodePoolNodeConfigKubeletConfigEvictionSoft'] = None,
+                 eviction_soft_grace_period: Optional['outputs.NodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod'] = None,
                  image_gc_high_threshold_percent: Optional[_builtins.int] = None,
                  image_gc_low_threshold_percent: Optional[_builtins.int] = None,
                  image_maximum_gc_age: Optional[_builtins.str] = None,
                  image_minimum_gc_age: Optional[_builtins.str] = None,
                  insecure_kubelet_readonly_port_enabled: Optional[_builtins.str] = None,
-                 pod_pids_limit: Optional[_builtins.int] = None):
+                 max_parallel_image_pulls: Optional[_builtins.int] = None,
+                 pod_pids_limit: Optional[_builtins.int] = None,
+                 single_process_oom_kill: Optional[_builtins.bool] = None):
         """
         :param Sequence[_builtins.str] allowed_unsafe_sysctls: Defines a comma-separated allowlist of unsafe sysctls or sysctl patterns which can be set on the Pods.
         :param _builtins.int container_log_max_files: Defines the maximum number of container log files that can be present for a container.
@@ -15989,12 +17203,18 @@ class NodePoolNodeConfigKubeletConfig(dict):
         :param _builtins.bool cpu_cfs_quota: Enable CPU CFS quota enforcement for containers that specify CPU limits.
         :param _builtins.str cpu_cfs_quota_period: Set the CPU CFS quota period value 'cpu.cfs_period_us'.
         :param _builtins.str cpu_manager_policy: Control the CPU management policy on the node.
+        :param _builtins.int eviction_max_pod_grace_period_seconds: Defines the maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met.
+        :param 'NodePoolNodeConfigKubeletConfigEvictionMinimumReclaimArgs' eviction_minimum_reclaim: Defines a map of signal names to percentage that defines minimum reclaims. It describes the minimum amount of a given resource the kubelet will reclaim when performing a pod eviction.
+        :param 'NodePoolNodeConfigKubeletConfigEvictionSoftArgs' eviction_soft: Defines a map of signal names to quantities or percentage that defines soft eviction thresholds.
+        :param 'NodePoolNodeConfigKubeletConfigEvictionSoftGracePeriodArgs' eviction_soft_grace_period: Defines a map of signal names to durations that defines grace periods for soft eviction thresholds. Each soft eviction threshold must have a corresponding grace period.
         :param _builtins.int image_gc_high_threshold_percent: Defines the percent of disk usage after which image garbage collection is always run.
         :param _builtins.int image_gc_low_threshold_percent: Defines the percent of disk usage before which image garbage collection is never run. Lowest disk usage to garbage collect to.
         :param _builtins.str image_maximum_gc_age: Defines the maximum age an image can be unused before it is garbage collected.
         :param _builtins.str image_minimum_gc_age: Defines the minimum age for an unused image before it is garbage collected.
         :param _builtins.str insecure_kubelet_readonly_port_enabled: Controls whether the kubelet read-only port is enabled. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        :param _builtins.int max_parallel_image_pulls: Set the maximum number of image pulls in parallel.
         :param _builtins.int pod_pids_limit: Controls the maximum number of processes allowed to run in a pod.
+        :param _builtins.bool single_process_oom_kill: Defines whether to enable single process OOM killer.
         """
         if allowed_unsafe_sysctls is not None:
             pulumi.set(__self__, "allowed_unsafe_sysctls", allowed_unsafe_sysctls)
@@ -16008,6 +17228,14 @@ class NodePoolNodeConfigKubeletConfig(dict):
             pulumi.set(__self__, "cpu_cfs_quota_period", cpu_cfs_quota_period)
         if cpu_manager_policy is not None:
             pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
+        if eviction_max_pod_grace_period_seconds is not None:
+            pulumi.set(__self__, "eviction_max_pod_grace_period_seconds", eviction_max_pod_grace_period_seconds)
+        if eviction_minimum_reclaim is not None:
+            pulumi.set(__self__, "eviction_minimum_reclaim", eviction_minimum_reclaim)
+        if eviction_soft is not None:
+            pulumi.set(__self__, "eviction_soft", eviction_soft)
+        if eviction_soft_grace_period is not None:
+            pulumi.set(__self__, "eviction_soft_grace_period", eviction_soft_grace_period)
         if image_gc_high_threshold_percent is not None:
             pulumi.set(__self__, "image_gc_high_threshold_percent", image_gc_high_threshold_percent)
         if image_gc_low_threshold_percent is not None:
@@ -16018,8 +17246,12 @@ class NodePoolNodeConfigKubeletConfig(dict):
             pulumi.set(__self__, "image_minimum_gc_age", image_minimum_gc_age)
         if insecure_kubelet_readonly_port_enabled is not None:
             pulumi.set(__self__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
+        if max_parallel_image_pulls is not None:
+            pulumi.set(__self__, "max_parallel_image_pulls", max_parallel_image_pulls)
         if pod_pids_limit is not None:
             pulumi.set(__self__, "pod_pids_limit", pod_pids_limit)
+        if single_process_oom_kill is not None:
+            pulumi.set(__self__, "single_process_oom_kill", single_process_oom_kill)
 
     @_builtins.property
     @pulumi.getter(name="allowedUnsafeSysctls")
@@ -16069,6 +17301,38 @@ class NodePoolNodeConfigKubeletConfig(dict):
         """
         return pulumi.get(self, "cpu_manager_policy")
 
+    @_builtins.property
+    @pulumi.getter(name="evictionMaxPodGracePeriodSeconds")
+    def eviction_max_pod_grace_period_seconds(self) -> Optional[_builtins.int]:
+        """
+        Defines the maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met.
+        """
+        return pulumi.get(self, "eviction_max_pod_grace_period_seconds")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionMinimumReclaim")
+    def eviction_minimum_reclaim(self) -> Optional['outputs.NodePoolNodeConfigKubeletConfigEvictionMinimumReclaim']:
+        """
+        Defines a map of signal names to percentage that defines minimum reclaims. It describes the minimum amount of a given resource the kubelet will reclaim when performing a pod eviction.
+        """
+        return pulumi.get(self, "eviction_minimum_reclaim")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionSoft")
+    def eviction_soft(self) -> Optional['outputs.NodePoolNodeConfigKubeletConfigEvictionSoft']:
+        """
+        Defines a map of signal names to quantities or percentage that defines soft eviction thresholds.
+        """
+        return pulumi.get(self, "eviction_soft")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionSoftGracePeriod")
+    def eviction_soft_grace_period(self) -> Optional['outputs.NodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod']:
+        """
+        Defines a map of signal names to durations that defines grace periods for soft eviction thresholds. Each soft eviction threshold must have a corresponding grace period.
+        """
+        return pulumi.get(self, "eviction_soft_grace_period")
+
     @_builtins.property
     @pulumi.getter(name="imageGcHighThresholdPercent")
     def image_gc_high_threshold_percent(self) -> Optional[_builtins.int]:
@@ -16109,6 +17373,14 @@ class NodePoolNodeConfigKubeletConfig(dict):
         """
         return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
 
+    @_builtins.property
+    @pulumi.getter(name="maxParallelImagePulls")
+    def max_parallel_image_pulls(self) -> Optional[_builtins.int]:
+        """
+        Set the maximum number of image pulls in parallel.
+        """
+        return pulumi.get(self, "max_parallel_image_pulls")
+
     @_builtins.property
     @pulumi.getter(name="podPidsLimit")
     def pod_pids_limit(self) -> Optional[_builtins.int]:
@@ -16117,6 +17389,332 @@ class NodePoolNodeConfigKubeletConfig(dict):
         """
         return pulumi.get(self, "pod_pids_limit")
 
+    @_builtins.property
+    @pulumi.getter(name="singleProcessOomKill")
+    def single_process_oom_kill(self) -> Optional[_builtins.bool]:
+        """
+        Defines whether to enable single process OOM killer.
+        """
+        return pulumi.get(self, "single_process_oom_kill")
+
+
+@pulumi.output_type
+class NodePoolNodeConfigKubeletConfigEvictionMinimumReclaim(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "imagefsAvailable":
+            suggest = "imagefs_available"
+        elif key == "imagefsInodesFree":
+            suggest = "imagefs_inodes_free"
+        elif key == "memoryAvailable":
+            suggest = "memory_available"
+        elif key == "nodefsAvailable":
+            suggest = "nodefs_available"
+        elif key == "nodefsInodesFree":
+            suggest = "nodefs_inodes_free"
+        elif key == "pidAvailable":
+            suggest = "pid_available"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeConfigKubeletConfigEvictionMinimumReclaim. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodePoolNodeConfigKubeletConfigEvictionMinimumReclaim.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodePoolNodeConfigKubeletConfigEvictionMinimumReclaim.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 imagefs_available: Optional[_builtins.str] = None,
+                 imagefs_inodes_free: Optional[_builtins.str] = None,
+                 memory_available: Optional[_builtins.str] = None,
+                 nodefs_available: Optional[_builtins.str] = None,
+                 nodefs_inodes_free: Optional[_builtins.str] = None,
+                 pid_available: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str imagefs_available: Defines percentage of minimum reclaim for imagefs.available.
+        :param _builtins.str imagefs_inodes_free: Defines percentage of minimum reclaim for imagefs.inodesFree.
+        :param _builtins.str memory_available: Defines percentage of minimum reclaim for memory.available.
+        :param _builtins.str nodefs_available: Defines percentage of minimum reclaim for nodefs.available.
+        :param _builtins.str nodefs_inodes_free: Defines percentage of minimum reclaim for nodefs.inodesFree.
+        :param _builtins.str pid_available: Defines percentage of minimum reclaim for pid.available.
+        """
+        if imagefs_available is not None:
+            pulumi.set(__self__, "imagefs_available", imagefs_available)
+        if imagefs_inodes_free is not None:
+            pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        if memory_available is not None:
+            pulumi.set(__self__, "memory_available", memory_available)
+        if nodefs_available is not None:
+            pulumi.set(__self__, "nodefs_available", nodefs_available)
+        if nodefs_inodes_free is not None:
+            pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        if pid_available is not None:
+            pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for imagefs.available.
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for imagefs.inodesFree.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for memory.available.
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for nodefs.available.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for nodefs.inodesFree.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of minimum reclaim for pid.available.
+        """
+        return pulumi.get(self, "pid_available")
+
+
+@pulumi.output_type
+class NodePoolNodeConfigKubeletConfigEvictionSoft(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "imagefsAvailable":
+            suggest = "imagefs_available"
+        elif key == "imagefsInodesFree":
+            suggest = "imagefs_inodes_free"
+        elif key == "memoryAvailable":
+            suggest = "memory_available"
+        elif key == "nodefsAvailable":
+            suggest = "nodefs_available"
+        elif key == "nodefsInodesFree":
+            suggest = "nodefs_inodes_free"
+        elif key == "pidAvailable":
+            suggest = "pid_available"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeConfigKubeletConfigEvictionSoft. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodePoolNodeConfigKubeletConfigEvictionSoft.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodePoolNodeConfigKubeletConfigEvictionSoft.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 imagefs_available: Optional[_builtins.str] = None,
+                 imagefs_inodes_free: Optional[_builtins.str] = None,
+                 memory_available: Optional[_builtins.str] = None,
+                 nodefs_available: Optional[_builtins.str] = None,
+                 nodefs_inodes_free: Optional[_builtins.str] = None,
+                 pid_available: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str imagefs_available: Defines percentage of soft eviction threshold for imagefs.available.
+        :param _builtins.str imagefs_inodes_free: Defines percentage of soft eviction threshold for imagefs.inodesFree.
+        :param _builtins.str memory_available: Defines quantity of soft eviction threshold for memory.available.
+        :param _builtins.str nodefs_available: Defines percentage of soft eviction threshold for nodefs.available.
+        :param _builtins.str nodefs_inodes_free: Defines percentage of soft eviction threshold for nodefs.inodesFree.
+        :param _builtins.str pid_available: Defines percentage of soft eviction threshold for pid.available.
+        """
+        if imagefs_available is not None:
+            pulumi.set(__self__, "imagefs_available", imagefs_available)
+        if imagefs_inodes_free is not None:
+            pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        if memory_available is not None:
+            pulumi.set(__self__, "memory_available", memory_available)
+        if nodefs_available is not None:
+            pulumi.set(__self__, "nodefs_available", nodefs_available)
+        if nodefs_inodes_free is not None:
+            pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        if pid_available is not None:
+            pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for imagefs.available.
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for imagefs.inodesFree.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> Optional[_builtins.str]:
+        """
+        Defines quantity of soft eviction threshold for memory.available.
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for nodefs.available.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for nodefs.inodesFree.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> Optional[_builtins.str]:
+        """
+        Defines percentage of soft eviction threshold for pid.available.
+        """
+        return pulumi.get(self, "pid_available")
+
+
+@pulumi.output_type
+class NodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "imagefsAvailable":
+            suggest = "imagefs_available"
+        elif key == "imagefsInodesFree":
+            suggest = "imagefs_inodes_free"
+        elif key == "memoryAvailable":
+            suggest = "memory_available"
+        elif key == "nodefsAvailable":
+            suggest = "nodefs_available"
+        elif key == "nodefsInodesFree":
+            suggest = "nodefs_inodes_free"
+        elif key == "pidAvailable":
+            suggest = "pid_available"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 imagefs_available: Optional[_builtins.str] = None,
+                 imagefs_inodes_free: Optional[_builtins.str] = None,
+                 memory_available: Optional[_builtins.str] = None,
+                 nodefs_available: Optional[_builtins.str] = None,
+                 nodefs_inodes_free: Optional[_builtins.str] = None,
+                 pid_available: Optional[_builtins.str] = None):
+        """
+        :param _builtins.str imagefs_available: Defines grace period for the imagefs.available soft eviction threshold
+        :param _builtins.str imagefs_inodes_free: Defines grace period for the imagefs.inodesFree soft eviction threshold.
+        :param _builtins.str memory_available: Defines grace period for the memory.available soft eviction threshold.
+        :param _builtins.str nodefs_available: Defines grace period for the nodefs.available soft eviction threshold.
+        :param _builtins.str nodefs_inodes_free: Defines grace period for the nodefs.inodesFree soft eviction threshold.
+        :param _builtins.str pid_available: Defines grace period for the pid.available soft eviction threshold.
+        """
+        if imagefs_available is not None:
+            pulumi.set(__self__, "imagefs_available", imagefs_available)
+        if imagefs_inodes_free is not None:
+            pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        if memory_available is not None:
+            pulumi.set(__self__, "memory_available", memory_available)
+        if nodefs_available is not None:
+            pulumi.set(__self__, "nodefs_available", nodefs_available)
+        if nodefs_inodes_free is not None:
+            pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        if pid_available is not None:
+            pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the imagefs.available soft eviction threshold
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the imagefs.inodesFree soft eviction threshold.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the memory.available soft eviction threshold.
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the nodefs.available soft eviction threshold.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the nodefs.inodesFree soft eviction threshold.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> Optional[_builtins.str]:
+        """
+        Defines grace period for the pid.available soft eviction threshold.
+        """
+        return pulumi.get(self, "pid_available")
+
 
 @pulumi.output_type
 class NodePoolNodeConfigLinuxNodeConfig(dict):
@@ -16127,6 +17725,10 @@ class NodePoolNodeConfigLinuxNodeConfig(dict):
             suggest = "cgroup_mode"
         elif key == "hugepagesConfig":
             suggest = "hugepages_config"
+        elif key == "transparentHugepageDefrag":
+            suggest = "transparent_hugepage_defrag"
+        elif key == "transparentHugepageEnabled":
+            suggest = "transparent_hugepage_enabled"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeConfigLinuxNodeConfig. Access the value via the '{suggest}' property getter instead.")
@@ -16142,11 +17744,15 @@ class NodePoolNodeConfigLinuxNodeConfig(dict):
     def __init__(__self__, *,
                  cgroup_mode: Optional[_builtins.str] = None,
                  hugepages_config: Optional['outputs.NodePoolNodeConfigLinuxNodeConfigHugepagesConfig'] = None,
-                 sysctls: Optional[Mapping[str, _builtins.str]] = None):
+                 sysctls: Optional[Mapping[str, _builtins.str]] = None,
+                 transparent_hugepage_defrag: Optional[_builtins.str] = None,
+                 transparent_hugepage_enabled: Optional[_builtins.str] = None):
         """
         :param _builtins.str cgroup_mode: cgroupMode specifies the cgroup mode to be used on the node.
         :param 'NodePoolNodeConfigLinuxNodeConfigHugepagesConfigArgs' hugepages_config: Amounts for 2M and 1G hugepages.
         :param Mapping[str, _builtins.str] sysctls: The Linux kernel parameters to be applied to the nodes and all pods running on the nodes.
+        :param _builtins.str transparent_hugepage_defrag: The Linux kernel transparent hugepage defrag setting.
+        :param _builtins.str transparent_hugepage_enabled: The Linux kernel transparent hugepage setting.
         """
         if cgroup_mode is not None:
             pulumi.set(__self__, "cgroup_mode", cgroup_mode)
@@ -16154,6 +17760,10 @@ class NodePoolNodeConfigLinuxNodeConfig(dict):
             pulumi.set(__self__, "hugepages_config", hugepages_config)
         if sysctls is not None:
             pulumi.set(__self__, "sysctls", sysctls)
+        if transparent_hugepage_defrag is not None:
+            pulumi.set(__self__, "transparent_hugepage_defrag", transparent_hugepage_defrag)
+        if transparent_hugepage_enabled is not None:
+            pulumi.set(__self__, "transparent_hugepage_enabled", transparent_hugepage_enabled)
 
     @_builtins.property
     @pulumi.getter(name="cgroupMode")
@@ -16179,6 +17789,22 @@ class NodePoolNodeConfigLinuxNodeConfig(dict):
         """
         return pulumi.get(self, "sysctls")
 
+    @_builtins.property
+    @pulumi.getter(name="transparentHugepageDefrag")
+    def transparent_hugepage_defrag(self) -> Optional[_builtins.str]:
+        """
+        The Linux kernel transparent hugepage defrag setting.
+        """
+        return pulumi.get(self, "transparent_hugepage_defrag")
+
+    @_builtins.property
+    @pulumi.getter(name="transparentHugepageEnabled")
+    def transparent_hugepage_enabled(self) -> Optional[_builtins.str]:
+        """
+        The Linux kernel transparent hugepage setting.
+        """
+        return pulumi.get(self, "transparent_hugepage_enabled")
+
 
 @pulumi.output_type
 class NodePoolNodeConfigLinuxNodeConfigHugepagesConfig(dict):
@@ -16475,6 +18101,8 @@ class NodePoolNodeConfigSoleTenantConfig(dict):
         suggest = None
         if key == "nodeAffinities":
             suggest = "node_affinities"
+        elif key == "minNodeCpus":
+            suggest = "min_node_cpus"
 
         if suggest:
             pulumi.log.warn(f"Key '{key}' not found in NodePoolNodeConfigSoleTenantConfig. Access the value via the '{suggest}' property getter instead.")
@@ -16488,11 +18116,15 @@ class NodePoolNodeConfigSoleTenantConfig(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 node_affinities: Sequence['outputs.NodePoolNodeConfigSoleTenantConfigNodeAffinity']):
+                 node_affinities: Sequence['outputs.NodePoolNodeConfigSoleTenantConfigNodeAffinity'],
+                 min_node_cpus: Optional[_builtins.int] = None):
         """
         :param Sequence['NodePoolNodeConfigSoleTenantConfigNodeAffinityArgs'] node_affinities: .
+        :param _builtins.int min_node_cpus: Specifies the minimum number of vCPUs that each sole tenant node must have to use CPU overcommit. If not specified, the CPU overcommit feature is disabled.
         """
         pulumi.set(__self__, "node_affinities", node_affinities)
+        if min_node_cpus is not None:
+            pulumi.set(__self__, "min_node_cpus", min_node_cpus)
 
     @_builtins.property
     @pulumi.getter(name="nodeAffinities")
@@ -16502,6 +18134,14 @@ class NodePoolNodeConfigSoleTenantConfig(dict):
         """
         return pulumi.get(self, "node_affinities")
 
+    @_builtins.property
+    @pulumi.getter(name="minNodeCpus")
+    def min_node_cpus(self) -> Optional[_builtins.int]:
+        """
+        Specifies the minimum number of vCPUs that each sole tenant node must have to use CPU overcommit. If not specified, the CPU overcommit feature is disabled.
+        """
+        return pulumi.get(self, "min_node_cpus")
+
 
 @pulumi.output_type
 class NodePoolNodeConfigSoleTenantConfigNodeAffinity(dict):
@@ -18938,6 +20578,7 @@ class GetClusterNodeConfigResult(dict):
     def __init__(__self__, *,
                  advanced_machine_features: Sequence['outputs.GetClusterNodeConfigAdvancedMachineFeatureResult'],
                  boot_disk_kms_key: _builtins.str,
+                 boot_disks: Sequence['outputs.GetClusterNodeConfigBootDiskResult'],
                  confidential_nodes: Sequence['outputs.GetClusterNodeConfigConfidentialNodeResult'],
                  containerd_configs: Sequence['outputs.GetClusterNodeConfigContainerdConfigResult'],
                  disk_size_gb: _builtins.int,
@@ -18984,6 +20625,7 @@ class GetClusterNodeConfigResult(dict):
         """
         :param Sequence['GetClusterNodeConfigAdvancedMachineFeatureArgs'] advanced_machine_features: Specifies options for controlling advanced machine features.
         :param _builtins.str boot_disk_kms_key: The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool.
+        :param Sequence['GetClusterNodeConfigBootDiskArgs'] boot_disks: Boot disk configuration for node pools nodes.
         :param Sequence['GetClusterNodeConfigConfidentialNodeArgs'] confidential_nodes: Configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
         :param Sequence['GetClusterNodeConfigContainerdConfigArgs'] containerd_configs: Parameters for containerd configuration.
         :param _builtins.int disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB.
@@ -19030,6 +20672,7 @@ class GetClusterNodeConfigResult(dict):
         """
         pulumi.set(__self__, "advanced_machine_features", advanced_machine_features)
         pulumi.set(__self__, "boot_disk_kms_key", boot_disk_kms_key)
+        pulumi.set(__self__, "boot_disks", boot_disks)
         pulumi.set(__self__, "confidential_nodes", confidential_nodes)
         pulumi.set(__self__, "containerd_configs", containerd_configs)
         pulumi.set(__self__, "disk_size_gb", disk_size_gb)
@@ -19090,6 +20733,14 @@ class GetClusterNodeConfigResult(dict):
         """
         return pulumi.get(self, "boot_disk_kms_key")
 
+    @_builtins.property
+    @pulumi.getter(name="bootDisks")
+    def boot_disks(self) -> Sequence['outputs.GetClusterNodeConfigBootDiskResult']:
+        """
+        Boot disk configuration for node pools nodes.
+        """
+        return pulumi.get(self, "boot_disks")
+
     @_builtins.property
     @pulumi.getter(name="confidentialNodes")
     def confidential_nodes(self) -> Sequence['outputs.GetClusterNodeConfigConfidentialNodeResult']:
@@ -19475,6 +21126,57 @@ class GetClusterNodeConfigAdvancedMachineFeatureResult(dict):
         return pulumi.get(self, "threads_per_core")
 
 
+@pulumi.output_type
+class GetClusterNodeConfigBootDiskResult(dict):
+    def __init__(__self__, *,
+                 disk_type: _builtins.str,
+                 provisioned_iops: _builtins.int,
+                 provisioned_throughput: _builtins.int,
+                 size_gb: _builtins.int):
+        """
+        :param _builtins.str disk_type: Type of the disk attached to each node. Such as pd-standard, pd-balanced or pd-ssd
+        :param _builtins.int provisioned_iops: Configured IOPs provisioning. Only valid with disk type hyperdisk-balanced.
+        :param _builtins.int provisioned_throughput: Configured throughput provisioning. Only valid with disk type hyperdisk-balanced.
+        :param _builtins.int size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB.
+        """
+        pulumi.set(__self__, "disk_type", disk_type)
+        pulumi.set(__self__, "provisioned_iops", provisioned_iops)
+        pulumi.set(__self__, "provisioned_throughput", provisioned_throughput)
+        pulumi.set(__self__, "size_gb", size_gb)
+
+    @_builtins.property
+    @pulumi.getter(name="diskType")
+    def disk_type(self) -> _builtins.str:
+        """
+        Type of the disk attached to each node. Such as pd-standard, pd-balanced or pd-ssd
+        """
+        return pulumi.get(self, "disk_type")
+
+    @_builtins.property
+    @pulumi.getter(name="provisionedIops")
+    def provisioned_iops(self) -> _builtins.int:
+        """
+        Configured IOPs provisioning. Only valid with disk type hyperdisk-balanced.
+        """
+        return pulumi.get(self, "provisioned_iops")
+
+    @_builtins.property
+    @pulumi.getter(name="provisionedThroughput")
+    def provisioned_throughput(self) -> _builtins.int:
+        """
+        Configured throughput provisioning. Only valid with disk type hyperdisk-balanced.
+        """
+        return pulumi.get(self, "provisioned_throughput")
+
+    @_builtins.property
+    @pulumi.getter(name="sizeGb")
+    def size_gb(self) -> _builtins.int:
+        """
+        Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB.
+        """
+        return pulumi.get(self, "size_gb")
+
+
 @pulumi.output_type
 class GetClusterNodeConfigConfidentialNodeResult(dict):
     def __init__(__self__, *,
@@ -19875,12 +21577,18 @@ class GetClusterNodeConfigKubeletConfigResult(dict):
                  cpu_cfs_quota: _builtins.bool,
                  cpu_cfs_quota_period: _builtins.str,
                  cpu_manager_policy: _builtins.str,
+                 eviction_max_pod_grace_period_seconds: _builtins.int,
+                 eviction_minimum_reclaims: Sequence['outputs.GetClusterNodeConfigKubeletConfigEvictionMinimumReclaimResult'],
+                 eviction_soft_grace_periods: Sequence['outputs.GetClusterNodeConfigKubeletConfigEvictionSoftGracePeriodResult'],
+                 eviction_softs: Sequence['outputs.GetClusterNodeConfigKubeletConfigEvictionSoftResult'],
                  image_gc_high_threshold_percent: _builtins.int,
                  image_gc_low_threshold_percent: _builtins.int,
                  image_maximum_gc_age: _builtins.str,
                  image_minimum_gc_age: _builtins.str,
                  insecure_kubelet_readonly_port_enabled: _builtins.str,
-                 pod_pids_limit: _builtins.int):
+                 max_parallel_image_pulls: _builtins.int,
+                 pod_pids_limit: _builtins.int,
+                 single_process_oom_kill: _builtins.bool):
         """
         :param Sequence[_builtins.str] allowed_unsafe_sysctls: Defines a comma-separated allowlist of unsafe sysctls or sysctl patterns which can be set on the Pods.
         :param _builtins.int container_log_max_files: Defines the maximum number of container log files that can be present for a container.
@@ -19888,12 +21596,18 @@ class GetClusterNodeConfigKubeletConfigResult(dict):
         :param _builtins.bool cpu_cfs_quota: Enable CPU CFS quota enforcement for containers that specify CPU limits.
         :param _builtins.str cpu_cfs_quota_period: Set the CPU CFS quota period value 'cpu.cfs_period_us'.
         :param _builtins.str cpu_manager_policy: Control the CPU management policy on the node.
+        :param _builtins.int eviction_max_pod_grace_period_seconds: Defines the maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met.
+        :param Sequence['GetClusterNodeConfigKubeletConfigEvictionMinimumReclaimArgs'] eviction_minimum_reclaims: Defines a map of signal names to percentage that defines minimum reclaims. It describes the minimum amount of a given resource the kubelet will reclaim when performing a pod eviction.
+        :param Sequence['GetClusterNodeConfigKubeletConfigEvictionSoftGracePeriodArgs'] eviction_soft_grace_periods: Defines a map of signal names to durations that defines grace periods for soft eviction thresholds. Each soft eviction threshold must have a corresponding grace period.
+        :param Sequence['GetClusterNodeConfigKubeletConfigEvictionSoftArgs'] eviction_softs: Defines a map of signal names to quantities or percentage that defines soft eviction thresholds.
         :param _builtins.int image_gc_high_threshold_percent: Defines the percent of disk usage after which image garbage collection is always run.
         :param _builtins.int image_gc_low_threshold_percent: Defines the percent of disk usage before which image garbage collection is never run. Lowest disk usage to garbage collect to.
         :param _builtins.str image_maximum_gc_age: Defines the maximum age an image can be unused before it is garbage collected.
         :param _builtins.str image_minimum_gc_age: Defines the minimum age for an unused image before it is garbage collected.
         :param _builtins.str insecure_kubelet_readonly_port_enabled: Controls whether the kubelet read-only port is enabled. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        :param _builtins.int max_parallel_image_pulls: Set the maximum number of image pulls in parallel.
         :param _builtins.int pod_pids_limit: Controls the maximum number of processes allowed to run in a pod.
+        :param _builtins.bool single_process_oom_kill: Defines whether to enable single process OOM killer.
         """
         pulumi.set(__self__, "allowed_unsafe_sysctls", allowed_unsafe_sysctls)
         pulumi.set(__self__, "container_log_max_files", container_log_max_files)
@@ -19901,12 +21615,18 @@ class GetClusterNodeConfigKubeletConfigResult(dict):
         pulumi.set(__self__, "cpu_cfs_quota", cpu_cfs_quota)
         pulumi.set(__self__, "cpu_cfs_quota_period", cpu_cfs_quota_period)
         pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
+        pulumi.set(__self__, "eviction_max_pod_grace_period_seconds", eviction_max_pod_grace_period_seconds)
+        pulumi.set(__self__, "eviction_minimum_reclaims", eviction_minimum_reclaims)
+        pulumi.set(__self__, "eviction_soft_grace_periods", eviction_soft_grace_periods)
+        pulumi.set(__self__, "eviction_softs", eviction_softs)
         pulumi.set(__self__, "image_gc_high_threshold_percent", image_gc_high_threshold_percent)
         pulumi.set(__self__, "image_gc_low_threshold_percent", image_gc_low_threshold_percent)
         pulumi.set(__self__, "image_maximum_gc_age", image_maximum_gc_age)
         pulumi.set(__self__, "image_minimum_gc_age", image_minimum_gc_age)
         pulumi.set(__self__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
+        pulumi.set(__self__, "max_parallel_image_pulls", max_parallel_image_pulls)
         pulumi.set(__self__, "pod_pids_limit", pod_pids_limit)
+        pulumi.set(__self__, "single_process_oom_kill", single_process_oom_kill)
 
     @_builtins.property
     @pulumi.getter(name="allowedUnsafeSysctls")
@@ -19957,15 +21677,47 @@ class GetClusterNodeConfigKubeletConfigResult(dict):
         return pulumi.get(self, "cpu_manager_policy")
 
     @_builtins.property
-    @pulumi.getter(name="imageGcHighThresholdPercent")
-    def image_gc_high_threshold_percent(self) -> _builtins.int:
+    @pulumi.getter(name="evictionMaxPodGracePeriodSeconds")
+    def eviction_max_pod_grace_period_seconds(self) -> _builtins.int:
         """
-        Defines the percent of disk usage after which image garbage collection is always run.
+        Defines the maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met.
         """
-        return pulumi.get(self, "image_gc_high_threshold_percent")
+        return pulumi.get(self, "eviction_max_pod_grace_period_seconds")
 
     @_builtins.property
-    @pulumi.getter(name="imageGcLowThresholdPercent")
+    @pulumi.getter(name="evictionMinimumReclaims")
+    def eviction_minimum_reclaims(self) -> Sequence['outputs.GetClusterNodeConfigKubeletConfigEvictionMinimumReclaimResult']:
+        """
+        Defines a map of signal names to percentage that defines minimum reclaims. It describes the minimum amount of a given resource the kubelet will reclaim when performing a pod eviction.
+        """
+        return pulumi.get(self, "eviction_minimum_reclaims")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionSoftGracePeriods")
+    def eviction_soft_grace_periods(self) -> Sequence['outputs.GetClusterNodeConfigKubeletConfigEvictionSoftGracePeriodResult']:
+        """
+        Defines a map of signal names to durations that defines grace periods for soft eviction thresholds. Each soft eviction threshold must have a corresponding grace period.
+        """
+        return pulumi.get(self, "eviction_soft_grace_periods")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionSofts")
+    def eviction_softs(self) -> Sequence['outputs.GetClusterNodeConfigKubeletConfigEvictionSoftResult']:
+        """
+        Defines a map of signal names to quantities or percentage that defines soft eviction thresholds.
+        """
+        return pulumi.get(self, "eviction_softs")
+
+    @_builtins.property
+    @pulumi.getter(name="imageGcHighThresholdPercent")
+    def image_gc_high_threshold_percent(self) -> _builtins.int:
+        """
+        Defines the percent of disk usage after which image garbage collection is always run.
+        """
+        return pulumi.get(self, "image_gc_high_threshold_percent")
+
+    @_builtins.property
+    @pulumi.getter(name="imageGcLowThresholdPercent")
     def image_gc_low_threshold_percent(self) -> _builtins.int:
         """
         Defines the percent of disk usage before which image garbage collection is never run. Lowest disk usage to garbage collect to.
@@ -19996,6 +21748,14 @@ class GetClusterNodeConfigKubeletConfigResult(dict):
         """
         return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
 
+    @_builtins.property
+    @pulumi.getter(name="maxParallelImagePulls")
+    def max_parallel_image_pulls(self) -> _builtins.int:
+        """
+        Set the maximum number of image pulls in parallel.
+        """
+        return pulumi.get(self, "max_parallel_image_pulls")
+
     @_builtins.property
     @pulumi.getter(name="podPidsLimit")
     def pod_pids_limit(self) -> _builtins.int:
@@ -20004,21 +21764,254 @@ class GetClusterNodeConfigKubeletConfigResult(dict):
         """
         return pulumi.get(self, "pod_pids_limit")
 
+    @_builtins.property
+    @pulumi.getter(name="singleProcessOomKill")
+    def single_process_oom_kill(self) -> _builtins.bool:
+        """
+        Defines whether to enable single process OOM killer.
+        """
+        return pulumi.get(self, "single_process_oom_kill")
+
+
+@pulumi.output_type
+class GetClusterNodeConfigKubeletConfigEvictionMinimumReclaimResult(dict):
+    def __init__(__self__, *,
+                 imagefs_available: _builtins.str,
+                 imagefs_inodes_free: _builtins.str,
+                 memory_available: _builtins.str,
+                 nodefs_available: _builtins.str,
+                 nodefs_inodes_free: _builtins.str,
+                 pid_available: _builtins.str):
+        """
+        :param _builtins.str imagefs_available: Defines percentage of minimum reclaim for imagefs.available.
+        :param _builtins.str imagefs_inodes_free: Defines percentage of minimum reclaim for imagefs.inodesFree.
+        :param _builtins.str memory_available: Defines percentage of minimum reclaim for memory.available.
+        :param _builtins.str nodefs_available: Defines percentage of minimum reclaim for nodefs.available.
+        :param _builtins.str nodefs_inodes_free: Defines percentage of minimum reclaim for nodefs.inodesFree.
+        :param _builtins.str pid_available: Defines percentage of minimum reclaim for pid.available.
+        """
+        pulumi.set(__self__, "imagefs_available", imagefs_available)
+        pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        pulumi.set(__self__, "memory_available", memory_available)
+        pulumi.set(__self__, "nodefs_available", nodefs_available)
+        pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> _builtins.str:
+        """
+        Defines percentage of minimum reclaim for imagefs.available.
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> _builtins.str:
+        """
+        Defines percentage of minimum reclaim for imagefs.inodesFree.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> _builtins.str:
+        """
+        Defines percentage of minimum reclaim for memory.available.
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> _builtins.str:
+        """
+        Defines percentage of minimum reclaim for nodefs.available.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> _builtins.str:
+        """
+        Defines percentage of minimum reclaim for nodefs.inodesFree.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> _builtins.str:
+        """
+        Defines percentage of minimum reclaim for pid.available.
+        """
+        return pulumi.get(self, "pid_available")
+
+
+@pulumi.output_type
+class GetClusterNodeConfigKubeletConfigEvictionSoftResult(dict):
+    def __init__(__self__, *,
+                 imagefs_available: _builtins.str,
+                 imagefs_inodes_free: _builtins.str,
+                 memory_available: _builtins.str,
+                 nodefs_available: _builtins.str,
+                 nodefs_inodes_free: _builtins.str,
+                 pid_available: _builtins.str):
+        """
+        :param _builtins.str imagefs_available: Defines percentage of soft eviction threshold for imagefs.available.
+        :param _builtins.str imagefs_inodes_free: Defines percentage of soft eviction threshold for imagefs.inodesFree.
+        :param _builtins.str memory_available: Defines quantity of soft eviction threshold for memory.available.
+        :param _builtins.str nodefs_available: Defines percentage of soft eviction threshold for nodefs.available.
+        :param _builtins.str nodefs_inodes_free: Defines percentage of soft eviction threshold for nodefs.inodesFree.
+        :param _builtins.str pid_available: Defines percentage of soft eviction threshold for pid.available.
+        """
+        pulumi.set(__self__, "imagefs_available", imagefs_available)
+        pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        pulumi.set(__self__, "memory_available", memory_available)
+        pulumi.set(__self__, "nodefs_available", nodefs_available)
+        pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> _builtins.str:
+        """
+        Defines percentage of soft eviction threshold for imagefs.available.
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> _builtins.str:
+        """
+        Defines percentage of soft eviction threshold for imagefs.inodesFree.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> _builtins.str:
+        """
+        Defines quantity of soft eviction threshold for memory.available.
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> _builtins.str:
+        """
+        Defines percentage of soft eviction threshold for nodefs.available.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> _builtins.str:
+        """
+        Defines percentage of soft eviction threshold for nodefs.inodesFree.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> _builtins.str:
+        """
+        Defines percentage of soft eviction threshold for pid.available.
+        """
+        return pulumi.get(self, "pid_available")
+
+
+@pulumi.output_type
+class GetClusterNodeConfigKubeletConfigEvictionSoftGracePeriodResult(dict):
+    def __init__(__self__, *,
+                 imagefs_available: _builtins.str,
+                 imagefs_inodes_free: _builtins.str,
+                 memory_available: _builtins.str,
+                 nodefs_available: _builtins.str,
+                 nodefs_inodes_free: _builtins.str,
+                 pid_available: _builtins.str):
+        """
+        :param _builtins.str imagefs_available: Defines grace period for the imagefs.available soft eviction threshold
+        :param _builtins.str imagefs_inodes_free: Defines grace period for the imagefs.inodesFree soft eviction threshold.
+        :param _builtins.str memory_available: Defines grace period for the memory.available soft eviction threshold.
+        :param _builtins.str nodefs_available: Defines grace period for the nodefs.available soft eviction threshold.
+        :param _builtins.str nodefs_inodes_free: Defines grace period for the nodefs.inodesFree soft eviction threshold.
+        :param _builtins.str pid_available: Defines grace period for the pid.available soft eviction threshold.
+        """
+        pulumi.set(__self__, "imagefs_available", imagefs_available)
+        pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        pulumi.set(__self__, "memory_available", memory_available)
+        pulumi.set(__self__, "nodefs_available", nodefs_available)
+        pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> _builtins.str:
+        """
+        Defines grace period for the imagefs.available soft eviction threshold
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> _builtins.str:
+        """
+        Defines grace period for the imagefs.inodesFree soft eviction threshold.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> _builtins.str:
+        """
+        Defines grace period for the memory.available soft eviction threshold.
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> _builtins.str:
+        """
+        Defines grace period for the nodefs.available soft eviction threshold.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> _builtins.str:
+        """
+        Defines grace period for the nodefs.inodesFree soft eviction threshold.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> _builtins.str:
+        """
+        Defines grace period for the pid.available soft eviction threshold.
+        """
+        return pulumi.get(self, "pid_available")
+
 
 @pulumi.output_type
 class GetClusterNodeConfigLinuxNodeConfigResult(dict):
     def __init__(__self__, *,
                  cgroup_mode: _builtins.str,
                  hugepages_configs: Sequence['outputs.GetClusterNodeConfigLinuxNodeConfigHugepagesConfigResult'],
-                 sysctls: Mapping[str, _builtins.str]):
+                 sysctls: Mapping[str, _builtins.str],
+                 transparent_hugepage_defrag: _builtins.str,
+                 transparent_hugepage_enabled: _builtins.str):
         """
         :param _builtins.str cgroup_mode: cgroupMode specifies the cgroup mode to be used on the node.
         :param Sequence['GetClusterNodeConfigLinuxNodeConfigHugepagesConfigArgs'] hugepages_configs: Amounts for 2M and 1G hugepages.
         :param Mapping[str, _builtins.str] sysctls: The Linux kernel parameters to be applied to the nodes and all pods running on the nodes.
+        :param _builtins.str transparent_hugepage_defrag: The Linux kernel transparent hugepage defrag setting.
+        :param _builtins.str transparent_hugepage_enabled: The Linux kernel transparent hugepage setting.
         """
         pulumi.set(__self__, "cgroup_mode", cgroup_mode)
         pulumi.set(__self__, "hugepages_configs", hugepages_configs)
         pulumi.set(__self__, "sysctls", sysctls)
+        pulumi.set(__self__, "transparent_hugepage_defrag", transparent_hugepage_defrag)
+        pulumi.set(__self__, "transparent_hugepage_enabled", transparent_hugepage_enabled)
 
     @_builtins.property
     @pulumi.getter(name="cgroupMode")
@@ -20044,6 +22037,22 @@ class GetClusterNodeConfigLinuxNodeConfigResult(dict):
         """
         return pulumi.get(self, "sysctls")
 
+    @_builtins.property
+    @pulumi.getter(name="transparentHugepageDefrag")
+    def transparent_hugepage_defrag(self) -> _builtins.str:
+        """
+        The Linux kernel transparent hugepage defrag setting.
+        """
+        return pulumi.get(self, "transparent_hugepage_defrag")
+
+    @_builtins.property
+    @pulumi.getter(name="transparentHugepageEnabled")
+    def transparent_hugepage_enabled(self) -> _builtins.str:
+        """
+        The Linux kernel transparent hugepage setting.
+        """
+        return pulumi.get(self, "transparent_hugepage_enabled")
+
 
 @pulumi.output_type
 class GetClusterNodeConfigLinuxNodeConfigHugepagesConfigResult(dict):
@@ -20211,12 +22220,23 @@ class GetClusterNodeConfigShieldedInstanceConfigResult(dict):
 @pulumi.output_type
 class GetClusterNodeConfigSoleTenantConfigResult(dict):
     def __init__(__self__, *,
+                 min_node_cpus: _builtins.int,
                  node_affinities: Sequence['outputs.GetClusterNodeConfigSoleTenantConfigNodeAffinityResult']):
         """
+        :param _builtins.int min_node_cpus: Specifies the minimum number of vCPUs that each sole tenant node must have to use CPU overcommit. If not specified, the CPU overcommit feature is disabled.
         :param Sequence['GetClusterNodeConfigSoleTenantConfigNodeAffinityArgs'] node_affinities: .
         """
+        pulumi.set(__self__, "min_node_cpus", min_node_cpus)
         pulumi.set(__self__, "node_affinities", node_affinities)
 
+    @_builtins.property
+    @pulumi.getter(name="minNodeCpus")
+    def min_node_cpus(self) -> _builtins.int:
+        """
+        Specifies the minimum number of vCPUs that each sole tenant node must have to use CPU overcommit. If not specified, the CPU overcommit feature is disabled.
+        """
+        return pulumi.get(self, "min_node_cpus")
+
     @_builtins.property
     @pulumi.getter(name="nodeAffinities")
     def node_affinities(self) -> Sequence['outputs.GetClusterNodeConfigSoleTenantConfigNodeAffinityResult']:
@@ -21108,6 +23128,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
     def __init__(__self__, *,
                  advanced_machine_features: Sequence['outputs.GetClusterNodePoolNodeConfigAdvancedMachineFeatureResult'],
                  boot_disk_kms_key: _builtins.str,
+                 boot_disks: Sequence['outputs.GetClusterNodePoolNodeConfigBootDiskResult'],
                  confidential_nodes: Sequence['outputs.GetClusterNodePoolNodeConfigConfidentialNodeResult'],
                  containerd_configs: Sequence['outputs.GetClusterNodePoolNodeConfigContainerdConfigResult'],
                  disk_size_gb: _builtins.int,
@@ -21154,6 +23175,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
         """
         :param Sequence['GetClusterNodePoolNodeConfigAdvancedMachineFeatureArgs'] advanced_machine_features: Specifies options for controlling advanced machine features.
         :param _builtins.str boot_disk_kms_key: The Customer Managed Encryption Key used to encrypt the boot disk attached to each node in the node pool.
+        :param Sequence['GetClusterNodePoolNodeConfigBootDiskArgs'] boot_disks: Boot disk configuration for node pools nodes.
         :param Sequence['GetClusterNodePoolNodeConfigConfidentialNodeArgs'] confidential_nodes: Configuration for the confidential nodes feature, which makes nodes run on confidential VMs.
         :param Sequence['GetClusterNodePoolNodeConfigContainerdConfigArgs'] containerd_configs: Parameters for containerd configuration.
         :param _builtins.int disk_size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB.
@@ -21200,6 +23222,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
         """
         pulumi.set(__self__, "advanced_machine_features", advanced_machine_features)
         pulumi.set(__self__, "boot_disk_kms_key", boot_disk_kms_key)
+        pulumi.set(__self__, "boot_disks", boot_disks)
         pulumi.set(__self__, "confidential_nodes", confidential_nodes)
         pulumi.set(__self__, "containerd_configs", containerd_configs)
         pulumi.set(__self__, "disk_size_gb", disk_size_gb)
@@ -21260,6 +23283,14 @@ class GetClusterNodePoolNodeConfigResult(dict):
         """
         return pulumi.get(self, "boot_disk_kms_key")
 
+    @_builtins.property
+    @pulumi.getter(name="bootDisks")
+    def boot_disks(self) -> Sequence['outputs.GetClusterNodePoolNodeConfigBootDiskResult']:
+        """
+        Boot disk configuration for node pools nodes.
+        """
+        return pulumi.get(self, "boot_disks")
+
     @_builtins.property
     @pulumi.getter(name="confidentialNodes")
     def confidential_nodes(self) -> Sequence['outputs.GetClusterNodePoolNodeConfigConfidentialNodeResult']:
@@ -21645,6 +23676,57 @@ class GetClusterNodePoolNodeConfigAdvancedMachineFeatureResult(dict):
         return pulumi.get(self, "threads_per_core")
 
 
+@pulumi.output_type
+class GetClusterNodePoolNodeConfigBootDiskResult(dict):
+    def __init__(__self__, *,
+                 disk_type: _builtins.str,
+                 provisioned_iops: _builtins.int,
+                 provisioned_throughput: _builtins.int,
+                 size_gb: _builtins.int):
+        """
+        :param _builtins.str disk_type: Type of the disk attached to each node. Such as pd-standard, pd-balanced or pd-ssd
+        :param _builtins.int provisioned_iops: Configured IOPs provisioning. Only valid with disk type hyperdisk-balanced.
+        :param _builtins.int provisioned_throughput: Configured throughput provisioning. Only valid with disk type hyperdisk-balanced.
+        :param _builtins.int size_gb: Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB.
+        """
+        pulumi.set(__self__, "disk_type", disk_type)
+        pulumi.set(__self__, "provisioned_iops", provisioned_iops)
+        pulumi.set(__self__, "provisioned_throughput", provisioned_throughput)
+        pulumi.set(__self__, "size_gb", size_gb)
+
+    @_builtins.property
+    @pulumi.getter(name="diskType")
+    def disk_type(self) -> _builtins.str:
+        """
+        Type of the disk attached to each node. Such as pd-standard, pd-balanced or pd-ssd
+        """
+        return pulumi.get(self, "disk_type")
+
+    @_builtins.property
+    @pulumi.getter(name="provisionedIops")
+    def provisioned_iops(self) -> _builtins.int:
+        """
+        Configured IOPs provisioning. Only valid with disk type hyperdisk-balanced.
+        """
+        return pulumi.get(self, "provisioned_iops")
+
+    @_builtins.property
+    @pulumi.getter(name="provisionedThroughput")
+    def provisioned_throughput(self) -> _builtins.int:
+        """
+        Configured throughput provisioning. Only valid with disk type hyperdisk-balanced.
+        """
+        return pulumi.get(self, "provisioned_throughput")
+
+    @_builtins.property
+    @pulumi.getter(name="sizeGb")
+    def size_gb(self) -> _builtins.int:
+        """
+        Size of the disk attached to each node, specified in GB. The smallest allowed disk size is 10GB.
+        """
+        return pulumi.get(self, "size_gb")
+
+
 @pulumi.output_type
 class GetClusterNodePoolNodeConfigConfidentialNodeResult(dict):
     def __init__(__self__, *,
@@ -22045,12 +24127,18 @@ class GetClusterNodePoolNodeConfigKubeletConfigResult(dict):
                  cpu_cfs_quota: _builtins.bool,
                  cpu_cfs_quota_period: _builtins.str,
                  cpu_manager_policy: _builtins.str,
+                 eviction_max_pod_grace_period_seconds: _builtins.int,
+                 eviction_minimum_reclaims: Sequence['outputs.GetClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaimResult'],
+                 eviction_soft_grace_periods: Sequence['outputs.GetClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriodResult'],
+                 eviction_softs: Sequence['outputs.GetClusterNodePoolNodeConfigKubeletConfigEvictionSoftResult'],
                  image_gc_high_threshold_percent: _builtins.int,
                  image_gc_low_threshold_percent: _builtins.int,
                  image_maximum_gc_age: _builtins.str,
                  image_minimum_gc_age: _builtins.str,
                  insecure_kubelet_readonly_port_enabled: _builtins.str,
-                 pod_pids_limit: _builtins.int):
+                 max_parallel_image_pulls: _builtins.int,
+                 pod_pids_limit: _builtins.int,
+                 single_process_oom_kill: _builtins.bool):
         """
         :param Sequence[_builtins.str] allowed_unsafe_sysctls: Defines a comma-separated allowlist of unsafe sysctls or sysctl patterns which can be set on the Pods.
         :param _builtins.int container_log_max_files: Defines the maximum number of container log files that can be present for a container.
@@ -22058,12 +24146,18 @@ class GetClusterNodePoolNodeConfigKubeletConfigResult(dict):
         :param _builtins.bool cpu_cfs_quota: Enable CPU CFS quota enforcement for containers that specify CPU limits.
         :param _builtins.str cpu_cfs_quota_period: Set the CPU CFS quota period value 'cpu.cfs_period_us'.
         :param _builtins.str cpu_manager_policy: Control the CPU management policy on the node.
+        :param _builtins.int eviction_max_pod_grace_period_seconds: Defines the maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met.
+        :param Sequence['GetClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaimArgs'] eviction_minimum_reclaims: Defines a map of signal names to percentage that defines minimum reclaims. It describes the minimum amount of a given resource the kubelet will reclaim when performing a pod eviction.
+        :param Sequence['GetClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriodArgs'] eviction_soft_grace_periods: Defines a map of signal names to durations that defines grace periods for soft eviction thresholds. Each soft eviction threshold must have a corresponding grace period.
+        :param Sequence['GetClusterNodePoolNodeConfigKubeletConfigEvictionSoftArgs'] eviction_softs: Defines a map of signal names to quantities or percentage that defines soft eviction thresholds.
         :param _builtins.int image_gc_high_threshold_percent: Defines the percent of disk usage after which image garbage collection is always run.
         :param _builtins.int image_gc_low_threshold_percent: Defines the percent of disk usage before which image garbage collection is never run. Lowest disk usage to garbage collect to.
         :param _builtins.str image_maximum_gc_age: Defines the maximum age an image can be unused before it is garbage collected.
         :param _builtins.str image_minimum_gc_age: Defines the minimum age for an unused image before it is garbage collected.
         :param _builtins.str insecure_kubelet_readonly_port_enabled: Controls whether the kubelet read-only port is enabled. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        :param _builtins.int max_parallel_image_pulls: Set the maximum number of image pulls in parallel.
         :param _builtins.int pod_pids_limit: Controls the maximum number of processes allowed to run in a pod.
+        :param _builtins.bool single_process_oom_kill: Defines whether to enable single process OOM killer.
         """
         pulumi.set(__self__, "allowed_unsafe_sysctls", allowed_unsafe_sysctls)
         pulumi.set(__self__, "container_log_max_files", container_log_max_files)
@@ -22071,12 +24165,18 @@ class GetClusterNodePoolNodeConfigKubeletConfigResult(dict):
         pulumi.set(__self__, "cpu_cfs_quota", cpu_cfs_quota)
         pulumi.set(__self__, "cpu_cfs_quota_period", cpu_cfs_quota_period)
         pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
+        pulumi.set(__self__, "eviction_max_pod_grace_period_seconds", eviction_max_pod_grace_period_seconds)
+        pulumi.set(__self__, "eviction_minimum_reclaims", eviction_minimum_reclaims)
+        pulumi.set(__self__, "eviction_soft_grace_periods", eviction_soft_grace_periods)
+        pulumi.set(__self__, "eviction_softs", eviction_softs)
         pulumi.set(__self__, "image_gc_high_threshold_percent", image_gc_high_threshold_percent)
         pulumi.set(__self__, "image_gc_low_threshold_percent", image_gc_low_threshold_percent)
         pulumi.set(__self__, "image_maximum_gc_age", image_maximum_gc_age)
         pulumi.set(__self__, "image_minimum_gc_age", image_minimum_gc_age)
         pulumi.set(__self__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
+        pulumi.set(__self__, "max_parallel_image_pulls", max_parallel_image_pulls)
         pulumi.set(__self__, "pod_pids_limit", pod_pids_limit)
+        pulumi.set(__self__, "single_process_oom_kill", single_process_oom_kill)
 
     @_builtins.property
     @pulumi.getter(name="allowedUnsafeSysctls")
@@ -22126,6 +24226,38 @@ class GetClusterNodePoolNodeConfigKubeletConfigResult(dict):
         """
         return pulumi.get(self, "cpu_manager_policy")
 
+    @_builtins.property
+    @pulumi.getter(name="evictionMaxPodGracePeriodSeconds")
+    def eviction_max_pod_grace_period_seconds(self) -> _builtins.int:
+        """
+        Defines the maximum allowed grace period (in seconds) to use when terminating pods in response to a soft eviction threshold being met.
+        """
+        return pulumi.get(self, "eviction_max_pod_grace_period_seconds")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionMinimumReclaims")
+    def eviction_minimum_reclaims(self) -> Sequence['outputs.GetClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaimResult']:
+        """
+        Defines a map of signal names to percentage that defines minimum reclaims. It describes the minimum amount of a given resource the kubelet will reclaim when performing a pod eviction.
+        """
+        return pulumi.get(self, "eviction_minimum_reclaims")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionSoftGracePeriods")
+    def eviction_soft_grace_periods(self) -> Sequence['outputs.GetClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriodResult']:
+        """
+        Defines a map of signal names to durations that defines grace periods for soft eviction thresholds. Each soft eviction threshold must have a corresponding grace period.
+        """
+        return pulumi.get(self, "eviction_soft_grace_periods")
+
+    @_builtins.property
+    @pulumi.getter(name="evictionSofts")
+    def eviction_softs(self) -> Sequence['outputs.GetClusterNodePoolNodeConfigKubeletConfigEvictionSoftResult']:
+        """
+        Defines a map of signal names to quantities or percentage that defines soft eviction thresholds.
+        """
+        return pulumi.get(self, "eviction_softs")
+
     @_builtins.property
     @pulumi.getter(name="imageGcHighThresholdPercent")
     def image_gc_high_threshold_percent(self) -> _builtins.int:
@@ -22166,6 +24298,14 @@ class GetClusterNodePoolNodeConfigKubeletConfigResult(dict):
         """
         return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
 
+    @_builtins.property
+    @pulumi.getter(name="maxParallelImagePulls")
+    def max_parallel_image_pulls(self) -> _builtins.int:
+        """
+        Set the maximum number of image pulls in parallel.
+        """
+        return pulumi.get(self, "max_parallel_image_pulls")
+
     @_builtins.property
     @pulumi.getter(name="podPidsLimit")
     def pod_pids_limit(self) -> _builtins.int:
@@ -22174,21 +24314,254 @@ class GetClusterNodePoolNodeConfigKubeletConfigResult(dict):
         """
         return pulumi.get(self, "pod_pids_limit")
 
+    @_builtins.property
+    @pulumi.getter(name="singleProcessOomKill")
+    def single_process_oom_kill(self) -> _builtins.bool:
+        """
+        Defines whether to enable single process OOM killer.
+        """
+        return pulumi.get(self, "single_process_oom_kill")
+
+
+@pulumi.output_type
+class GetClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaimResult(dict):
+    def __init__(__self__, *,
+                 imagefs_available: _builtins.str,
+                 imagefs_inodes_free: _builtins.str,
+                 memory_available: _builtins.str,
+                 nodefs_available: _builtins.str,
+                 nodefs_inodes_free: _builtins.str,
+                 pid_available: _builtins.str):
+        """
+        :param _builtins.str imagefs_available: Defines percentage of minimum reclaim for imagefs.available.
+        :param _builtins.str imagefs_inodes_free: Defines percentage of minimum reclaim for imagefs.inodesFree.
+        :param _builtins.str memory_available: Defines percentage of minimum reclaim for memory.available.
+        :param _builtins.str nodefs_available: Defines percentage of minimum reclaim for nodefs.available.
+        :param _builtins.str nodefs_inodes_free: Defines percentage of minimum reclaim for nodefs.inodesFree.
+        :param _builtins.str pid_available: Defines percentage of minimum reclaim for pid.available.
+        """
+        pulumi.set(__self__, "imagefs_available", imagefs_available)
+        pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        pulumi.set(__self__, "memory_available", memory_available)
+        pulumi.set(__self__, "nodefs_available", nodefs_available)
+        pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> _builtins.str:
+        """
+        Defines percentage of minimum reclaim for imagefs.available.
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> _builtins.str:
+        """
+        Defines percentage of minimum reclaim for imagefs.inodesFree.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> _builtins.str:
+        """
+        Defines percentage of minimum reclaim for memory.available.
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> _builtins.str:
+        """
+        Defines percentage of minimum reclaim for nodefs.available.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> _builtins.str:
+        """
+        Defines percentage of minimum reclaim for nodefs.inodesFree.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> _builtins.str:
+        """
+        Defines percentage of minimum reclaim for pid.available.
+        """
+        return pulumi.get(self, "pid_available")
+
+
+@pulumi.output_type
+class GetClusterNodePoolNodeConfigKubeletConfigEvictionSoftResult(dict):
+    def __init__(__self__, *,
+                 imagefs_available: _builtins.str,
+                 imagefs_inodes_free: _builtins.str,
+                 memory_available: _builtins.str,
+                 nodefs_available: _builtins.str,
+                 nodefs_inodes_free: _builtins.str,
+                 pid_available: _builtins.str):
+        """
+        :param _builtins.str imagefs_available: Defines percentage of soft eviction threshold for imagefs.available.
+        :param _builtins.str imagefs_inodes_free: Defines percentage of soft eviction threshold for imagefs.inodesFree.
+        :param _builtins.str memory_available: Defines quantity of soft eviction threshold for memory.available.
+        :param _builtins.str nodefs_available: Defines percentage of soft eviction threshold for nodefs.available.
+        :param _builtins.str nodefs_inodes_free: Defines percentage of soft eviction threshold for nodefs.inodesFree.
+        :param _builtins.str pid_available: Defines percentage of soft eviction threshold for pid.available.
+        """
+        pulumi.set(__self__, "imagefs_available", imagefs_available)
+        pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        pulumi.set(__self__, "memory_available", memory_available)
+        pulumi.set(__self__, "nodefs_available", nodefs_available)
+        pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> _builtins.str:
+        """
+        Defines percentage of soft eviction threshold for imagefs.available.
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> _builtins.str:
+        """
+        Defines percentage of soft eviction threshold for imagefs.inodesFree.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> _builtins.str:
+        """
+        Defines quantity of soft eviction threshold for memory.available.
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> _builtins.str:
+        """
+        Defines percentage of soft eviction threshold for nodefs.available.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> _builtins.str:
+        """
+        Defines percentage of soft eviction threshold for nodefs.inodesFree.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> _builtins.str:
+        """
+        Defines percentage of soft eviction threshold for pid.available.
+        """
+        return pulumi.get(self, "pid_available")
+
+
+@pulumi.output_type
+class GetClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriodResult(dict):
+    def __init__(__self__, *,
+                 imagefs_available: _builtins.str,
+                 imagefs_inodes_free: _builtins.str,
+                 memory_available: _builtins.str,
+                 nodefs_available: _builtins.str,
+                 nodefs_inodes_free: _builtins.str,
+                 pid_available: _builtins.str):
+        """
+        :param _builtins.str imagefs_available: Defines grace period for the imagefs.available soft eviction threshold
+        :param _builtins.str imagefs_inodes_free: Defines grace period for the imagefs.inodesFree soft eviction threshold.
+        :param _builtins.str memory_available: Defines grace period for the memory.available soft eviction threshold.
+        :param _builtins.str nodefs_available: Defines grace period for the nodefs.available soft eviction threshold.
+        :param _builtins.str nodefs_inodes_free: Defines grace period for the nodefs.inodesFree soft eviction threshold.
+        :param _builtins.str pid_available: Defines grace period for the pid.available soft eviction threshold.
+        """
+        pulumi.set(__self__, "imagefs_available", imagefs_available)
+        pulumi.set(__self__, "imagefs_inodes_free", imagefs_inodes_free)
+        pulumi.set(__self__, "memory_available", memory_available)
+        pulumi.set(__self__, "nodefs_available", nodefs_available)
+        pulumi.set(__self__, "nodefs_inodes_free", nodefs_inodes_free)
+        pulumi.set(__self__, "pid_available", pid_available)
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> _builtins.str:
+        """
+        Defines grace period for the imagefs.available soft eviction threshold
+        """
+        return pulumi.get(self, "imagefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> _builtins.str:
+        """
+        Defines grace period for the imagefs.inodesFree soft eviction threshold.
+        """
+        return pulumi.get(self, "imagefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> _builtins.str:
+        """
+        Defines grace period for the memory.available soft eviction threshold.
+        """
+        return pulumi.get(self, "memory_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsAvailable")
+    def nodefs_available(self) -> _builtins.str:
+        """
+        Defines grace period for the nodefs.available soft eviction threshold.
+        """
+        return pulumi.get(self, "nodefs_available")
+
+    @_builtins.property
+    @pulumi.getter(name="nodefsInodesFree")
+    def nodefs_inodes_free(self) -> _builtins.str:
+        """
+        Defines grace period for the nodefs.inodesFree soft eviction threshold.
+        """
+        return pulumi.get(self, "nodefs_inodes_free")
+
+    @_builtins.property
+    @pulumi.getter(name="pidAvailable")
+    def pid_available(self) -> _builtins.str:
+        """
+        Defines grace period for the pid.available soft eviction threshold.
+        """
+        return pulumi.get(self, "pid_available")
+
 
 @pulumi.output_type
 class GetClusterNodePoolNodeConfigLinuxNodeConfigResult(dict):
     def __init__(__self__, *,
                  cgroup_mode: _builtins.str,
                  hugepages_configs: Sequence['outputs.GetClusterNodePoolNodeConfigLinuxNodeConfigHugepagesConfigResult'],
-                 sysctls: Mapping[str, _builtins.str]):
+                 sysctls: Mapping[str, _builtins.str],
+                 transparent_hugepage_defrag: _builtins.str,
+                 transparent_hugepage_enabled: _builtins.str):
         """
         :param _builtins.str cgroup_mode: cgroupMode specifies the cgroup mode to be used on the node.
         :param Sequence['GetClusterNodePoolNodeConfigLinuxNodeConfigHugepagesConfigArgs'] hugepages_configs: Amounts for 2M and 1G hugepages.
         :param Mapping[str, _builtins.str] sysctls: The Linux kernel parameters to be applied to the nodes and all pods running on the nodes.
+        :param _builtins.str transparent_hugepage_defrag: The Linux kernel transparent hugepage defrag setting.
+        :param _builtins.str transparent_hugepage_enabled: The Linux kernel transparent hugepage setting.
         """
         pulumi.set(__self__, "cgroup_mode", cgroup_mode)
         pulumi.set(__self__, "hugepages_configs", hugepages_configs)
         pulumi.set(__self__, "sysctls", sysctls)
+        pulumi.set(__self__, "transparent_hugepage_defrag", transparent_hugepage_defrag)
+        pulumi.set(__self__, "transparent_hugepage_enabled", transparent_hugepage_enabled)
 
     @_builtins.property
     @pulumi.getter(name="cgroupMode")
@@ -22214,6 +24587,22 @@ class GetClusterNodePoolNodeConfigLinuxNodeConfigResult(dict):
         """
         return pulumi.get(self, "sysctls")
 
+    @_builtins.property
+    @pulumi.getter(name="transparentHugepageDefrag")
+    def transparent_hugepage_defrag(self) -> _builtins.str:
+        """
+        The Linux kernel transparent hugepage defrag setting.
+        """
+        return pulumi.get(self, "transparent_hugepage_defrag")
+
+    @_builtins.property
+    @pulumi.getter(name="transparentHugepageEnabled")
+    def transparent_hugepage_enabled(self) -> _builtins.str:
+        """
+        The Linux kernel transparent hugepage setting.
+        """
+        return pulumi.get(self, "transparent_hugepage_enabled")
+
 
 @pulumi.output_type
 class GetClusterNodePoolNodeConfigLinuxNodeConfigHugepagesConfigResult(dict):
@@ -22381,12 +24770,23 @@ class GetClusterNodePoolNodeConfigShieldedInstanceConfigResult(dict):
 @pulumi.output_type
 class GetClusterNodePoolNodeConfigSoleTenantConfigResult(dict):
     def __init__(__self__, *,
+                 min_node_cpus: _builtins.int,
                  node_affinities: Sequence['outputs.GetClusterNodePoolNodeConfigSoleTenantConfigNodeAffinityResult']):
         """
+        :param _builtins.int min_node_cpus: Specifies the minimum number of vCPUs that each sole tenant node must have to use CPU overcommit. If not specified, the CPU overcommit feature is disabled.
         :param Sequence['GetClusterNodePoolNodeConfigSoleTenantConfigNodeAffinityArgs'] node_affinities: .
         """
+        pulumi.set(__self__, "min_node_cpus", min_node_cpus)
         pulumi.set(__self__, "node_affinities", node_affinities)
 
+    @_builtins.property
+    @pulumi.getter(name="minNodeCpus")
+    def min_node_cpus(self) -> _builtins.int:
+        """
+        Specifies the minimum number of vCPUs that each sole tenant node must have to use CPU overcommit. If not specified, the CPU overcommit feature is disabled.
+        """
+        return pulumi.get(self, "min_node_cpus")
+
     @_builtins.property
     @pulumi.getter(name="nodeAffinities")
     def node_affinities(self) -> Sequence['outputs.GetClusterNodePoolNodeConfigSoleTenantConfigNodeAffinityResult']: