pulumi-gcp 8.40.0a1754721948__py3-none-any.whl → 8.41.0__py3-none-any.whl

pulumi_gcp/container/outputs.py

@@ -97,6 +97,7 @@ __all__ = [
     'ClusterAddonsConfigHttpLoadBalancing',
     'ClusterAddonsConfigIstioConfig',
     'ClusterAddonsConfigKalmConfig',
+    'ClusterAddonsConfigLustreCsiDriverConfig',
     'ClusterAddonsConfigNetworkPolicyConfig',
     'ClusterAddonsConfigParallelstoreCsiDriverConfig',
     'ClusterAddonsConfigRayOperatorConfig',
@@ -131,6 +132,7 @@ __all__ = [
     'ClusterGkeAutoUpgradeConfig',
     'ClusterIdentityServiceConfig',
     'ClusterIpAllocationPolicy',
+    'ClusterIpAllocationPolicyAdditionalIpRangesConfig',
     'ClusterIpAllocationPolicyAdditionalPodRangesConfig',
     'ClusterIpAllocationPolicyPodCidrOverprovisionConfig',
     'ClusterLoggingConfig',
@@ -152,6 +154,7 @@ __all__ = [
     'ClusterNetworkPolicy',
     'ClusterNodeConfig',
     'ClusterNodeConfigAdvancedMachineFeatures',
+    'ClusterNodeConfigBootDisk',
     'ClusterNodeConfigConfidentialNodes',
     'ClusterNodeConfigContainerdConfig',
     'ClusterNodeConfigContainerdConfigPrivateRegistryAccessConfig',
@@ -168,6 +171,9 @@ __all__ = [
     'ClusterNodeConfigGvnic',
     'ClusterNodeConfigHostMaintenancePolicy',
     'ClusterNodeConfigKubeletConfig',
+    'ClusterNodeConfigKubeletConfigEvictionMinimumReclaim',
+    'ClusterNodeConfigKubeletConfigEvictionSoft',
+    'ClusterNodeConfigKubeletConfigEvictionSoftGracePeriod',
     'ClusterNodeConfigLinuxNodeConfig',
     'ClusterNodeConfigLinuxNodeConfigHugepagesConfig',
     'ClusterNodeConfigLocalNvmeSsdBlockConfig',
@@ -201,6 +207,7 @@ __all__ = [
     'ClusterNodePoolNetworkConfigPodCidrOverprovisionConfig',
     'ClusterNodePoolNodeConfig',
     'ClusterNodePoolNodeConfigAdvancedMachineFeatures',
+    'ClusterNodePoolNodeConfigBootDisk',
     'ClusterNodePoolNodeConfigConfidentialNodes',
     'ClusterNodePoolNodeConfigContainerdConfig',
     'ClusterNodePoolNodeConfigContainerdConfigPrivateRegistryAccessConfig',
@@ -217,6 +224,9 @@ __all__ = [
     'ClusterNodePoolNodeConfigGvnic',
     'ClusterNodePoolNodeConfigHostMaintenancePolicy',
     'ClusterNodePoolNodeConfigKubeletConfig',
+    'ClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaim',
+    'ClusterNodePoolNodeConfigKubeletConfigEvictionSoft',
+    'ClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod',
     'ClusterNodePoolNodeConfigLinuxNodeConfig',
     'ClusterNodePoolNodeConfigLinuxNodeConfigHugepagesConfig',
     'ClusterNodePoolNodeConfigLocalNvmeSsdBlockConfig',
@@ -243,6 +253,7 @@ __all__ = [
     'ClusterPrivateClusterConfigMasterGlobalAccessConfig',
     'ClusterProtectConfig',
     'ClusterProtectConfigWorkloadConfig',
+    'ClusterRbacBindingConfig',
     'ClusterReleaseChannel',
     'ClusterResourceUsageExportConfig',
     'ClusterResourceUsageExportConfigBigqueryDestination',
@@ -264,6 +275,7 @@ __all__ = [
     'NodePoolNetworkConfigPodCidrOverprovisionConfig',
     'NodePoolNodeConfig',
     'NodePoolNodeConfigAdvancedMachineFeatures',
+    'NodePoolNodeConfigBootDisk',
     'NodePoolNodeConfigConfidentialNodes',
     'NodePoolNodeConfigContainerdConfig',
     'NodePoolNodeConfigContainerdConfigPrivateRegistryAccessConfig',
@@ -280,6 +292,9 @@ __all__ = [
     'NodePoolNodeConfigGvnic',
     'NodePoolNodeConfigHostMaintenancePolicy',
     'NodePoolNodeConfigKubeletConfig',
+    'NodePoolNodeConfigKubeletConfigEvictionMinimumReclaim',
+    'NodePoolNodeConfigKubeletConfigEvictionSoft',
+    'NodePoolNodeConfigKubeletConfigEvictionSoftGracePeriod',
     'NodePoolNodeConfigLinuxNodeConfig',
     'NodePoolNodeConfigLinuxNodeConfigHugepagesConfig',
     'NodePoolNodeConfigLocalNvmeSsdBlockConfig',
@@ -309,6 +324,7 @@ __all__ = [
     'GetClusterAddonsConfigHttpLoadBalancingResult',
     'GetClusterAddonsConfigIstioConfigResult',
     'GetClusterAddonsConfigKalmConfigResult',
+    'GetClusterAddonsConfigLustreCsiDriverConfigResult',
     'GetClusterAddonsConfigNetworkPolicyConfigResult',
     'GetClusterAddonsConfigParallelstoreCsiDriverConfigResult',
     'GetClusterAddonsConfigRayOperatorConfigResult',
@@ -343,6 +359,7 @@ __all__ = [
     'GetClusterGkeAutoUpgradeConfigResult',
     'GetClusterIdentityServiceConfigResult',
     'GetClusterIpAllocationPolicyResult',
+    'GetClusterIpAllocationPolicyAdditionalIpRangesConfigResult',
     'GetClusterIpAllocationPolicyAdditionalPodRangesConfigResult',
     'GetClusterIpAllocationPolicyPodCidrOverprovisionConfigResult',
     'GetClusterLoggingConfigResult',
@@ -364,6 +381,7 @@ __all__ = [
     'GetClusterNetworkPolicyResult',
     'GetClusterNodeConfigResult',
     'GetClusterNodeConfigAdvancedMachineFeatureResult',
+    'GetClusterNodeConfigBootDiskResult',
     'GetClusterNodeConfigConfidentialNodeResult',
     'GetClusterNodeConfigContainerdConfigResult',
     'GetClusterNodeConfigContainerdConfigPrivateRegistryAccessConfigResult',
@@ -380,6 +398,9 @@ __all__ = [
     'GetClusterNodeConfigGvnicResult',
     'GetClusterNodeConfigHostMaintenancePolicyResult',
     'GetClusterNodeConfigKubeletConfigResult',
+    'GetClusterNodeConfigKubeletConfigEvictionMinimumReclaimResult',
+    'GetClusterNodeConfigKubeletConfigEvictionSoftResult',
+    'GetClusterNodeConfigKubeletConfigEvictionSoftGracePeriodResult',
     'GetClusterNodeConfigLinuxNodeConfigResult',
     'GetClusterNodeConfigLinuxNodeConfigHugepagesConfigResult',
     'GetClusterNodeConfigLocalNvmeSsdBlockConfigResult',
@@ -413,6 +434,7 @@ __all__ = [
     'GetClusterNodePoolNetworkConfigPodCidrOverprovisionConfigResult',
     'GetClusterNodePoolNodeConfigResult',
     'GetClusterNodePoolNodeConfigAdvancedMachineFeatureResult',
+    'GetClusterNodePoolNodeConfigBootDiskResult',
     'GetClusterNodePoolNodeConfigConfidentialNodeResult',
     'GetClusterNodePoolNodeConfigContainerdConfigResult',
     'GetClusterNodePoolNodeConfigContainerdConfigPrivateRegistryAccessConfigResult',
@@ -429,6 +451,9 @@ __all__ = [
     'GetClusterNodePoolNodeConfigGvnicResult',
     'GetClusterNodePoolNodeConfigHostMaintenancePolicyResult',
     'GetClusterNodePoolNodeConfigKubeletConfigResult',
+    'GetClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaimResult',
+    'GetClusterNodePoolNodeConfigKubeletConfigEvictionSoftResult',
+    'GetClusterNodePoolNodeConfigKubeletConfigEvictionSoftGracePeriodResult',
     'GetClusterNodePoolNodeConfigLinuxNodeConfigResult',
     'GetClusterNodePoolNodeConfigLinuxNodeConfigHugepagesConfigResult',
     'GetClusterNodePoolNodeConfigLocalNvmeSsdBlockConfigResult',
@@ -455,6 +480,7 @@ __all__ = [
     'GetClusterPrivateClusterConfigMasterGlobalAccessConfigResult',
     'GetClusterProtectConfigResult',
     'GetClusterProtectConfigWorkloadConfigResult',
+    'GetClusterRbacBindingConfigResult',
     'GetClusterReleaseChannelResult',
     'GetClusterResourceUsageExportConfigResult',
     'GetClusterResourceUsageExportConfigBigqueryDestinationResult',
@@ -3919,6 +3945,8 @@ class ClusterAddonsConfig(dict):
             suggest = "istio_config"
         elif key == "kalmConfig":
             suggest = "kalm_config"
+        elif key == "lustreCsiDriverConfig":
+            suggest = "lustre_csi_driver_config"
         elif key == "networkPolicyConfig":
             suggest = "network_policy_config"
         elif key == "parallelstoreCsiDriverConfig":
@@ -3951,6 +3979,7 @@ class ClusterAddonsConfig(dict):
                  http_load_balancing: Optional['outputs.ClusterAddonsConfigHttpLoadBalancing'] = None,
                  istio_config: Optional['outputs.ClusterAddonsConfigIstioConfig'] = None,
                  kalm_config: Optional['outputs.ClusterAddonsConfigKalmConfig'] = None,
+                 lustre_csi_driver_config: Optional['outputs.ClusterAddonsConfigLustreCsiDriverConfig'] = None,
                  network_policy_config: Optional['outputs.ClusterAddonsConfigNetworkPolicyConfig'] = None,
                  parallelstore_csi_driver_config: Optional['outputs.ClusterAddonsConfigParallelstoreCsiDriverConfig'] = None,
                  ray_operator_configs: Optional[Sequence['outputs.ClusterAddonsConfigRayOperatorConfig']] = None,
@@ -3991,6 +4020,16 @@ class ClusterAddonsConfig(dict):
                Structure is documented below.
         :param 'ClusterAddonsConfigKalmConfigArgs' kalm_config: .
                Configuration for the KALM addon, which manages the lifecycle of k8s. It is disabled by default; Set `enabled = true` to enable.
+        :param 'ClusterAddonsConfigLustreCsiDriverConfigArgs' lustre_csi_driver_config: The status of the Lustre CSI driver addon,
+               which allows the usage of a Lustre instances as volumes.
+               It is disabled by default for Standard clusters; set `enabled = true` to enable.
+               It is disabled by default for Autopilot clusters; set `enabled = true` to enable.
+               Lustre CSI Driver Config has optional subfield
+               `enable_legacy_lustre_port` which allows the Lustre CSI driver to initialize LNet (the virtual networklayer for Lustre kernel module) using port 6988.
+               This flag is required to workaround a port conflict with the gke-metadata-server on GKE nodes.
+               See [Enable Lustre CSI driver](https://cloud.google.com/kubernetes-engine/docs/how-to/persistent-volumes/lustre-csi-driver-new-volume) for more information.
+               
+               This example `addons_config` disables two addons:
         :param 'ClusterAddonsConfigNetworkPolicyConfigArgs' network_policy_config: Whether we should enable the network policy addon
                for the master.  This must be enabled in order to enable network policy for the nodes.
                To enable this, you must also define a `network_policy` block,
@@ -4002,8 +4041,6 @@ class ClusterAddonsConfig(dict):
                It is disabled by default for Standard clusters; set `enabled = true` to enable.
                It is enabled by default for Autopilot clusters with version 1.29 or later; set `enabled = true` to enable it explicitly.
                See [Enable the Parallelstore CSI driver](https://cloud.google.com/kubernetes-engine/docs/how-to/persistent-volumes/parallelstore-csi-new-volume#enable) for more information.
-               
-               This example `addons_config` disables two addons:
         :param Sequence['ClusterAddonsConfigRayOperatorConfigArgs'] ray_operator_configs: . The status of the [Ray Operator
                addon](https://cloud.google.com/kubernetes-engine/docs/add-on/ray-on-gke/concepts/overview).
                It is disabled by default. Set `enabled = true` to enable. The minimum
@@ -4042,6 +4079,8 @@ class ClusterAddonsConfig(dict):
             pulumi.set(__self__, "istio_config", istio_config)
         if kalm_config is not None:
             pulumi.set(__self__, "kalm_config", kalm_config)
+        if lustre_csi_driver_config is not None:
+            pulumi.set(__self__, "lustre_csi_driver_config", lustre_csi_driver_config)
         if network_policy_config is not None:
             pulumi.set(__self__, "network_policy_config", network_policy_config)
         if parallelstore_csi_driver_config is not None:
@@ -4163,6 +4202,23 @@ class ClusterAddonsConfig(dict):
         """
         return pulumi.get(self, "kalm_config")
 
+    @_builtins.property
+    @pulumi.getter(name="lustreCsiDriverConfig")
+    def lustre_csi_driver_config(self) -> Optional['outputs.ClusterAddonsConfigLustreCsiDriverConfig']:
+        """
+        The status of the Lustre CSI driver addon,
+        which allows the usage of a Lustre instances as volumes.
+        It is disabled by default for Standard clusters; set `enabled = true` to enable.
+        It is disabled by default for Autopilot clusters; set `enabled = true` to enable.
+        Lustre CSI Driver Config has optional subfield
+        `enable_legacy_lustre_port` which allows the Lustre CSI driver to initialize LNet (the virtual networklayer for Lustre kernel module) using port 6988.
+        This flag is required to workaround a port conflict with the gke-metadata-server on GKE nodes.
+        See [Enable Lustre CSI driver](https://cloud.google.com/kubernetes-engine/docs/how-to/persistent-volumes/lustre-csi-driver-new-volume) for more information.
+
+        This example `addons_config` disables two addons:
+        """
+        return pulumi.get(self, "lustre_csi_driver_config")
+
     @_builtins.property
     @pulumi.getter(name="networkPolicyConfig")
     def network_policy_config(self) -> Optional['outputs.ClusterAddonsConfigNetworkPolicyConfig']:
@@ -4185,8 +4241,6 @@ class ClusterAddonsConfig(dict):
         It is disabled by default for Standard clusters; set `enabled = true` to enable.
         It is enabled by default for Autopilot clusters with version 1.29 or later; set `enabled = true` to enable it explicitly.
         See [Enable the Parallelstore CSI driver](https://cloud.google.com/kubernetes-engine/docs/how-to/persistent-volumes/parallelstore-csi-new-volume#enable) for more information.
-
-        This example `addons_config` disables two addons:
         """
         return pulumi.get(self, "parallelstore_csi_driver_config")
 
@@ -4429,6 +4483,55 @@ class ClusterAddonsConfigKalmConfig(dict):
         return pulumi.get(self, "enabled")
 
 
+@pulumi.output_type
+class ClusterAddonsConfigLustreCsiDriverConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "enableLegacyLustrePort":
+            suggest = "enable_legacy_lustre_port"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterAddonsConfigLustreCsiDriverConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterAddonsConfigLustreCsiDriverConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterAddonsConfigLustreCsiDriverConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enabled: _builtins.bool,
+                 enable_legacy_lustre_port: Optional[_builtins.bool] = None):
+        """
+        :param _builtins.bool enabled: Whether the Lustre CSI driver is enabled for this cluster.
+        :param _builtins.bool enable_legacy_lustre_port: If set to true, the Lustre CSI driver will initialize LNet (the virtual network layer for Lustre kernel module) using port 6988.
+               										This flag is required to workaround a port conflict with the gke-metadata-server on GKE nodes.
+        """
+        pulumi.set(__self__, "enabled", enabled)
+        if enable_legacy_lustre_port is not None:
+            pulumi.set(__self__, "enable_legacy_lustre_port", enable_legacy_lustre_port)
+
+    @_builtins.property
+    @pulumi.getter
+    def enabled(self) -> _builtins.bool:
+        """
+        Whether the Lustre CSI driver is enabled for this cluster.
+        """
+        return pulumi.get(self, "enabled")
+
+    @_builtins.property
+    @pulumi.getter(name="enableLegacyLustrePort")
+    def enable_legacy_lustre_port(self) -> Optional[_builtins.bool]:
+        """
+        If set to true, the Lustre CSI driver will initialize LNet (the virtual network layer for Lustre kernel module) using port 6988.
+        										This flag is required to workaround a port conflict with the gke-metadata-server on GKE nodes.
+        """
+        return pulumi.get(self, "enable_legacy_lustre_port")
+
+
 @pulumi.output_type
 class ClusterAddonsConfigNetworkPolicyConfig(dict):
     def __init__(__self__, *,
@@ -5975,7 +6078,9 @@ class ClusterIpAllocationPolicy(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "additionalPodRangesConfig":
+        if key == "additionalIpRangesConfigs":
+            suggest = "additional_ip_ranges_configs"
+        elif key == "additionalPodRangesConfig":
             suggest = "additional_pod_ranges_config"
         elif key == "clusterIpv4CidrBlock":
             suggest = "cluster_ipv4_cidr_block"
@@ -6002,6 +6107,7 @@ class ClusterIpAllocationPolicy(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 additional_ip_ranges_configs: Optional[Sequence['outputs.ClusterIpAllocationPolicyAdditionalIpRangesConfig']] = None,
                  additional_pod_ranges_config: Optional['outputs.ClusterIpAllocationPolicyAdditionalPodRangesConfig'] = None,
                  cluster_ipv4_cidr_block: Optional[_builtins.str] = None,
                  cluster_secondary_range_name: Optional[_builtins.str] = None,
@@ -6010,6 +6116,8 @@ class ClusterIpAllocationPolicy(dict):
                  services_secondary_range_name: Optional[_builtins.str] = None,
                  stack_type: Optional[_builtins.str] = None):
         """
+        :param Sequence['ClusterIpAllocationPolicyAdditionalIpRangesConfigArgs'] additional_ip_ranges_configs: The configuration for individual additional subnetworks attached to the cluster.
+               Structure is documented below.
         :param 'ClusterIpAllocationPolicyAdditionalPodRangesConfigArgs' additional_pod_ranges_config: The configuration for additional pod secondary ranges at
                the cluster level. Used for Autopilot clusters and Standard clusters with which control of the
                secondary Pod IP address assignment to node pools isn't needed. Structure is documented below.
@@ -6035,6 +6143,8 @@ class ClusterIpAllocationPolicy(dict):
                Default value is `IPV4`.
                Possible values are `IPV4` and `IPV4_IPV6`.
         """
+        if additional_ip_ranges_configs is not None:
+            pulumi.set(__self__, "additional_ip_ranges_configs", additional_ip_ranges_configs)
         if additional_pod_ranges_config is not None:
             pulumi.set(__self__, "additional_pod_ranges_config", additional_pod_ranges_config)
         if cluster_ipv4_cidr_block is not None:
@@ -6050,6 +6160,15 @@ class ClusterIpAllocationPolicy(dict):
         if stack_type is not None:
             pulumi.set(__self__, "stack_type", stack_type)
 
+    @_builtins.property
+    @pulumi.getter(name="additionalIpRangesConfigs")
+    def additional_ip_ranges_configs(self) -> Optional[Sequence['outputs.ClusterIpAllocationPolicyAdditionalIpRangesConfig']]:
+        """
+        The configuration for individual additional subnetworks attached to the cluster.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "additional_ip_ranges_configs")
+
     @_builtins.property
     @pulumi.getter(name="additionalPodRangesConfig")
     def additional_pod_ranges_config(self) -> Optional['outputs.ClusterIpAllocationPolicyAdditionalPodRangesConfig']:
@@ -6124,6 +6243,53 @@ class ClusterIpAllocationPolicy(dict):
         return pulumi.get(self, "stack_type")
 
 
+@pulumi.output_type
+class ClusterIpAllocationPolicyAdditionalIpRangesConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "podIpv4RangeNames":
+            suggest = "pod_ipv4_range_names"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterIpAllocationPolicyAdditionalIpRangesConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterIpAllocationPolicyAdditionalIpRangesConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterIpAllocationPolicyAdditionalIpRangesConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 subnetwork: _builtins.str,
+                 pod_ipv4_range_names: Optional[Sequence[_builtins.str]] = None):
+        """
+        :param _builtins.str subnetwork: Name of the subnetwork. This can be the full path of the subnetwork or just the name.
+        :param Sequence[_builtins.str] pod_ipv4_range_names: List of secondary ranges names within this subnetwork that can be used for pod IPs.
+        """
+        pulumi.set(__self__, "subnetwork", subnetwork)
+        if pod_ipv4_range_names is not None:
+            pulumi.set(__self__, "pod_ipv4_range_names", pod_ipv4_range_names)
+
+    @_builtins.property
+    @pulumi.getter
+    def subnetwork(self) -> _builtins.str:
+        """
+        Name of the subnetwork. This can be the full path of the subnetwork or just the name.
+        """
+        return pulumi.get(self, "subnetwork")
+
+    @_builtins.property
+    @pulumi.getter(name="podIpv4RangeNames")
+    def pod_ipv4_range_names(self) -> Optional[Sequence[_builtins.str]]:
+        """
+        List of secondary ranges names within this subnetwork that can be used for pod IPs.
+        """
+        return pulumi.get(self, "pod_ipv4_range_names")
+
+
 @pulumi.output_type
 class ClusterIpAllocationPolicyAdditionalPodRangesConfig(dict):
     @staticmethod
@@ -7102,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":
@@ -7190,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,
@@ -7237,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.
@@ -7323,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.
@@ -7344,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:
@@ -7442,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]:
@@ -7471,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")
 
@@ -7480,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")
 
@@ -7791,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")
 
@@ -7918,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
@@ -8551,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":
@@ -8561,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.")
@@ -8582,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.
@@ -8607,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)
@@ -8626,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:
@@ -8636,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")
@@ -8699,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]:
@@ -8739,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]:
@@ -8747,146 +9087,500 @@ 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 ClusterNodeConfigLinuxNodeConfig(dict):
+class ClusterNodeConfigKubeletConfigEvictionMinimumReclaim(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "cgroupMode":
-            suggest = "cgroup_mode"
-        elif key == "hugepagesConfig":
-            suggest = "hugepages_config"
+        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 ClusterNodeConfigLinuxNodeConfig. Access the value via the '{suggest}' property getter instead.")
+            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:
-        ClusterNodeConfigLinuxNodeConfig.__key_warning(key)
+        ClusterNodeConfigKubeletConfigEvictionMinimumReclaim.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        ClusterNodeConfigLinuxNodeConfig.__key_warning(key)
+        ClusterNodeConfigKubeletConfigEvictionMinimumReclaim.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 cgroup_mode: Optional[_builtins.str] = None,
-                 hugepages_config: Optional['outputs.ClusterNodeConfigLinuxNodeConfigHugepagesConfig'] = None,
-                 sysctls: Optional[Mapping[str, _builtins.str]] = None):
+                 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 cgroup_mode: Possible cgroup modes that can be used.
-               Accepted values are:
-               * `CGROUP_MODE_UNSPECIFIED`: CGROUP_MODE_UNSPECIFIED is when unspecified cgroup configuration is used. The default for the GKE node OS image will be used.
-               * `CGROUP_MODE_V1`: CGROUP_MODE_V1 specifies to use cgroupv1 for the cgroup configuration on the node image.
-               * `CGROUP_MODE_V2`: CGROUP_MODE_V2 specifies to use cgroupv2 for the cgroup configuration on the node image.
-        :param 'ClusterNodeConfigLinuxNodeConfigHugepagesConfigArgs' hugepages_config: Amounts for 2M and 1G hugepages. Structure is documented below.
-        :param Mapping[str, _builtins.str] sysctls: The Linux kernel parameters to be applied to the nodes
-               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 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 cgroup_mode is not None:
-            pulumi.set(__self__, "cgroup_mode", cgroup_mode)
-        if hugepages_config is not None:
-            pulumi.set(__self__, "hugepages_config", hugepages_config)
-        if sysctls is not None:
-            pulumi.set(__self__, "sysctls", sysctls)
+        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="cgroupMode")
-    def cgroup_mode(self) -> Optional[_builtins.str]:
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> Optional[_builtins.str]:
         """
-        Possible cgroup modes that can be used.
-        Accepted values are:
-        * `CGROUP_MODE_UNSPECIFIED`: CGROUP_MODE_UNSPECIFIED is when unspecified cgroup configuration is used. The default for the GKE node OS image will be used.
-        * `CGROUP_MODE_V1`: CGROUP_MODE_V1 specifies to use cgroupv1 for the cgroup configuration on the node image.
-        * `CGROUP_MODE_V2`: CGROUP_MODE_V2 specifies to use cgroupv2 for the cgroup configuration on the node image.
+        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, "cgroup_mode")
+        return pulumi.get(self, "imagefs_available")
 
     @_builtins.property
-    @pulumi.getter(name="hugepagesConfig")
-    def hugepages_config(self) -> Optional['outputs.ClusterNodeConfigLinuxNodeConfigHugepagesConfig']:
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> Optional[_builtins.str]:
         """
-        Amounts for 2M and 1G hugepages. Structure is documented below.
+        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, "hugepages_config")
+        return pulumi.get(self, "imagefs_inodes_free")
 
     @_builtins.property
-    @pulumi.getter
-    def sysctls(self) -> Optional[Mapping[str, _builtins.str]]:
+    @pulumi.getter(name="memoryAvailable")
+    def memory_available(self) -> Optional[_builtins.str]:
         """
-        The Linux kernel parameters to be applied to the nodes
-        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.
+        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, "sysctls")
+        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 ClusterNodeConfigLinuxNodeConfigHugepagesConfig(dict):
+class ClusterNodeConfigKubeletConfigEvictionSoft(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "hugepageSize1g":
-            suggest = "hugepage_size1g"
-        elif key == "hugepageSize2m":
-            suggest = "hugepage_size2m"
+        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 ClusterNodeConfigLinuxNodeConfigHugepagesConfig. Access the value via the '{suggest}' property getter instead.")
+            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:
-        ClusterNodeConfigLinuxNodeConfigHugepagesConfig.__key_warning(key)
+        ClusterNodeConfigKubeletConfigEvictionSoft.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
-        ClusterNodeConfigLinuxNodeConfigHugepagesConfig.__key_warning(key)
+        ClusterNodeConfigKubeletConfigEvictionSoft.__key_warning(key)
         return super().get(key, default)
 
     def __init__(__self__, *,
-                 hugepage_size1g: Optional[_builtins.int] = None,
-                 hugepage_size2m: Optional[_builtins.int] = None):
+                 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.int hugepage_size1g: Amount of 1G hugepages.
-        :param _builtins.int hugepage_size2m: Amount of 2M hugepages.
+        :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 hugepage_size1g is not None:
-            pulumi.set(__self__, "hugepage_size1g", hugepage_size1g)
-        if hugepage_size2m is not None:
-            pulumi.set(__self__, "hugepage_size2m", hugepage_size2m)
+        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="hugepageSize1g")
-    def hugepage_size1g(self) -> Optional[_builtins.int]:
+    @pulumi.getter(name="imagefsAvailable")
+    def imagefs_available(self) -> Optional[_builtins.str]:
         """
-        Amount of 1G hugepages.
+        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, "hugepage_size1g")
+        return pulumi.get(self, "imagefs_available")
 
     @_builtins.property
-    @pulumi.getter(name="hugepageSize2m")
-    def hugepage_size2m(self) -> Optional[_builtins.int]:
+    @pulumi.getter(name="imagefsInodesFree")
+    def imagefs_inodes_free(self) -> Optional[_builtins.str]:
         """
-        Amount of 2M hugepages.
+        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, "hugepage_size2m")
+        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 ClusterNodeConfigLocalNvmeSsdBlockConfig(dict):
+class ClusterNodeConfigKubeletConfigEvictionSoftGracePeriod(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "localSsdCount":
-            suggest = "local_ssd_count"
+        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 ClusterNodeConfigLocalNvmeSsdBlockConfig. Access the value via the '{suggest}' property getter instead.")
+            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:
-        ClusterNodeConfigLocalNvmeSsdBlockConfig.__key_warning(key)
+        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):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "cgroupMode":
+            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.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeConfigLinuxNodeConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeConfigLinuxNodeConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 cgroup_mode: Optional[_builtins.str] = None,
+                 hugepages_config: Optional['outputs.ClusterNodeConfigLinuxNodeConfigHugepagesConfig'] = 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:
+               * `CGROUP_MODE_UNSPECIFIED`: CGROUP_MODE_UNSPECIFIED is when unspecified cgroup configuration is used. The default for the GKE node OS image will be used.
+               * `CGROUP_MODE_V1`: CGROUP_MODE_V1 specifies to use cgroupv1 for the cgroup configuration on the node image.
+               * `CGROUP_MODE_V2`: CGROUP_MODE_V2 specifies to use cgroupv2 for the cgroup configuration on the node image.
+        :param 'ClusterNodeConfigLinuxNodeConfigHugepagesConfigArgs' hugepages_config: Amounts for 2M and 1G hugepages. Structure is documented below.
+        :param Mapping[str, _builtins.str] sysctls: The Linux kernel parameters to be applied to the nodes
+               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)
+        if hugepages_config is not None:
+            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")
+    def cgroup_mode(self) -> Optional[_builtins.str]:
+        """
+        Possible cgroup modes that can be used.
+        Accepted values are:
+        * `CGROUP_MODE_UNSPECIFIED`: CGROUP_MODE_UNSPECIFIED is when unspecified cgroup configuration is used. The default for the GKE node OS image will be used.
+        * `CGROUP_MODE_V1`: CGROUP_MODE_V1 specifies to use cgroupv1 for the cgroup configuration on the node image.
+        * `CGROUP_MODE_V2`: CGROUP_MODE_V2 specifies to use cgroupv2 for the cgroup configuration on the node image.
+        """
+        return pulumi.get(self, "cgroup_mode")
+
+    @_builtins.property
+    @pulumi.getter(name="hugepagesConfig")
+    def hugepages_config(self) -> Optional['outputs.ClusterNodeConfigLinuxNodeConfigHugepagesConfig']:
+        """
+        Amounts for 2M and 1G hugepages. Structure is documented below.
+        """
+        return pulumi.get(self, "hugepages_config")
+
+    @_builtins.property
+    @pulumi.getter
+    def sysctls(self) -> Optional[Mapping[str, _builtins.str]]:
+        """
+        The Linux kernel parameters to be applied to the nodes
+        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.
+        """
+        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):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "hugepageSize1g":
+            suggest = "hugepage_size1g"
+        elif key == "hugepageSize2m":
+            suggest = "hugepage_size2m"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeConfigLinuxNodeConfigHugepagesConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeConfigLinuxNodeConfigHugepagesConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodeConfigLinuxNodeConfigHugepagesConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 hugepage_size1g: Optional[_builtins.int] = None,
+                 hugepage_size2m: Optional[_builtins.int] = None):
+        """
+        :param _builtins.int hugepage_size1g: Amount of 1G hugepages.
+        :param _builtins.int hugepage_size2m: Amount of 2M hugepages.
+        """
+        if hugepage_size1g is not None:
+            pulumi.set(__self__, "hugepage_size1g", hugepage_size1g)
+        if hugepage_size2m is not None:
+            pulumi.set(__self__, "hugepage_size2m", hugepage_size2m)
+
+    @_builtins.property
+    @pulumi.getter(name="hugepageSize1g")
+    def hugepage_size1g(self) -> Optional[_builtins.int]:
+        """
+        Amount of 1G hugepages.
+        """
+        return pulumi.get(self, "hugepage_size1g")
+
+    @_builtins.property
+    @pulumi.getter(name="hugepageSize2m")
+    def hugepage_size2m(self) -> Optional[_builtins.int]:
+        """
+        Amount of 2M hugepages.
+        """
+        return pulumi.get(self, "hugepage_size2m")
+
+
+@pulumi.output_type
+class ClusterNodeConfigLocalNvmeSsdBlockConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "localSsdCount":
+            suggest = "local_ssd_count"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodeConfigLocalNvmeSsdBlockConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodeConfigLocalNvmeSsdBlockConfig.__key_warning(key)
         return super().__getitem__(key)
 
     def get(self, key: str, default = None) -> Any:
@@ -9135,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.")
@@ -9148,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):
@@ -10230,7 +10938,8 @@ class ClusterNodePoolNetworkConfig(dict):
                  network_performance_config: Optional['outputs.ClusterNodePoolNetworkConfigNetworkPerformanceConfig'] = None,
                  pod_cidr_overprovision_config: Optional['outputs.ClusterNodePoolNetworkConfigPodCidrOverprovisionConfig'] = None,
                  pod_ipv4_cidr_block: Optional[_builtins.str] = None,
-                 pod_range: Optional[_builtins.str] = None):
+                 pod_range: Optional[_builtins.str] = None,
+                 subnetwork: Optional[_builtins.str] = None):
         """
         :param Sequence['ClusterNodePoolNetworkConfigAdditionalNodeNetworkConfigArgs'] additional_node_network_configs: We specify the additional node networks for this node pool using this list. Each node network corresponds to an additional interface
         :param Sequence['ClusterNodePoolNetworkConfigAdditionalPodNetworkConfigArgs'] additional_pod_network_configs: We specify the additional pod networks for this node pool using this list. Each pod network corresponds to an additional alias IP range for the node
@@ -10240,6 +10949,8 @@ class ClusterNodePoolNetworkConfig(dict):
         :param 'ClusterNodePoolNetworkConfigPodCidrOverprovisionConfigArgs' pod_cidr_overprovision_config: Configuration for node-pool level pod cidr overprovision. If not set, the cluster level setting will be inherited
         :param _builtins.str pod_ipv4_cidr_block: The IP address range for pod IPs in this node pool. Only applicable if create_pod_range is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. /14) to have a range chosen with a specific netmask. Set to a CIDR notation (e.g. 10.96.0.0/14) to pick a specific range to use.
         :param _builtins.str pod_range: The ID of the secondary range for pod IPs. If create_pod_range is true, this ID is used for the new range. If create_pod_range is false, uses an existing secondary range with this ID.
+        :param _builtins.str subnetwork: The name or self_link of the Google Compute Engine
+               subnetwork in which the cluster's instances are launched.
         """
         if additional_node_network_configs is not None:
             pulumi.set(__self__, "additional_node_network_configs", additional_node_network_configs)
@@ -10257,6 +10968,8 @@ class ClusterNodePoolNetworkConfig(dict):
             pulumi.set(__self__, "pod_ipv4_cidr_block", pod_ipv4_cidr_block)
         if pod_range is not None:
             pulumi.set(__self__, "pod_range", pod_range)
+        if subnetwork is not None:
+            pulumi.set(__self__, "subnetwork", subnetwork)
 
     @_builtins.property
     @pulumi.getter(name="additionalNodeNetworkConfigs")
@@ -10322,6 +11035,15 @@ class ClusterNodePoolNetworkConfig(dict):
         """
         return pulumi.get(self, "pod_range")
 
+    @_builtins.property
+    @pulumi.getter
+    def subnetwork(self) -> Optional[_builtins.str]:
+        """
+        The name or self_link of the Google Compute Engine
+        subnetwork in which the cluster's instances are launched.
+        """
+        return pulumi.get(self, "subnetwork")
+
 
 @pulumi.output_type
 class ClusterNodePoolNetworkConfigAdditionalNodeNetworkConfig(dict):
@@ -10488,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":
@@ -10576,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,
@@ -10623,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.
@@ -10709,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.
@@ -10730,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:
@@ -10828,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]:
@@ -10857,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")
 
@@ -10866,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")
 
@@ -11177,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")
 
@@ -11304,6 +12042,88 @@ class ClusterNodePoolNodeConfigAdvancedMachineFeatures(dict):
         return pulumi.get(self, "performance_monitoring_unit")
 
 
+@pulumi.output_type
+class ClusterNodePoolNodeConfigBootDisk(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 ClusterNodePoolNodeConfigBootDisk. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodePoolNodeConfigBootDisk.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodePoolNodeConfigBootDisk.__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 ClusterNodePoolNodeConfigConfidentialNodes(dict):
     @staticmethod
@@ -11937,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":
@@ -11947,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.")
@@ -11968,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.
@@ -11993,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)
@@ -12012,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:
@@ -12022,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")
@@ -12086,20 +12942,52 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
         return pulumi.get(self, "cpu_manager_policy")
 
     @_builtins.property
-    @pulumi.getter(name="imageGcHighThresholdPercent")
-    def image_gc_high_threshold_percent(self) -> Optional[_builtins.int]:
+    @pulumi.getter(name="evictionMaxPodGracePeriodSeconds")
+    def eviction_max_pod_grace_period_seconds(self) -> Optional[_builtins.int]:
         """
-        Defines the percent of disk usage after which image garbage collection is always run. The integer must be between 10 and 85, inclusive.
+        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, "image_gc_high_threshold_percent")
+        return pulumi.get(self, "eviction_max_pod_grace_period_seconds")
 
     @_builtins.property
-    @pulumi.getter(name="imageGcLowThresholdPercent")
-    def image_gc_low_threshold_percent(self) -> Optional[_builtins.int]:
+    @pulumi.getter(name="evictionMinimumReclaim")
+    def eviction_minimum_reclaim(self) -> Optional['outputs.ClusterNodePoolNodeConfigKubeletConfigEvictionMinimumReclaim']:
         """
-        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.
+        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, "image_gc_low_threshold_percent")
+        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]:
+        """
+        Defines the percent of disk usage after which image garbage collection is always run. The integer must be between 10 and 85, inclusive.
+        """
+        return pulumi.get(self, "image_gc_high_threshold_percent")
+
+    @_builtins.property
+    @pulumi.getter(name="imageGcLowThresholdPercent")
+    def image_gc_low_threshold_percent(self) -> Optional[_builtins.int]:
+        """
+        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.
+        """
+        return pulumi.get(self, "image_gc_low_threshold_percent")
 
     @_builtins.property
     @pulumi.getter(name="imageMaximumGcAge")
@@ -12125,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]:
@@ -12133,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):
@@ -12143,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.")
@@ -12158,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:
@@ -12170,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)
@@ -12177,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")
@@ -12209,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):
@@ -12521,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.")
@@ -12534,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):
@@ -13377,6 +14641,56 @@ class ClusterProtectConfigWorkloadConfig(dict):
         return pulumi.get(self, "audit_mode")
 
 
+@pulumi.output_type
+class ClusterRbacBindingConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "enableInsecureBindingSystemAuthenticated":
+            suggest = "enable_insecure_binding_system_authenticated"
+        elif key == "enableInsecureBindingSystemUnauthenticated":
+            suggest = "enable_insecure_binding_system_unauthenticated"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterRbacBindingConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterRbacBindingConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterRbacBindingConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 enable_insecure_binding_system_authenticated: Optional[_builtins.bool] = None,
+                 enable_insecure_binding_system_unauthenticated: Optional[_builtins.bool] = None):
+        """
+        :param _builtins.bool enable_insecure_binding_system_authenticated: Setting this to true will allow any ClusterRoleBinding and RoleBinding with subjects system:authenticated.
+        :param _builtins.bool enable_insecure_binding_system_unauthenticated: Setting this to true will allow any ClusterRoleBinding and RoleBinding with subjects system:anonymous or system:unauthenticated.
+        """
+        if enable_insecure_binding_system_authenticated is not None:
+            pulumi.set(__self__, "enable_insecure_binding_system_authenticated", enable_insecure_binding_system_authenticated)
+        if enable_insecure_binding_system_unauthenticated is not None:
+            pulumi.set(__self__, "enable_insecure_binding_system_unauthenticated", enable_insecure_binding_system_unauthenticated)
+
+    @_builtins.property
+    @pulumi.getter(name="enableInsecureBindingSystemAuthenticated")
+    def enable_insecure_binding_system_authenticated(self) -> Optional[_builtins.bool]:
+        """
+        Setting this to true will allow any ClusterRoleBinding and RoleBinding with subjects system:authenticated.
+        """
+        return pulumi.get(self, "enable_insecure_binding_system_authenticated")
+
+    @_builtins.property
+    @pulumi.getter(name="enableInsecureBindingSystemUnauthenticated")
+    def enable_insecure_binding_system_unauthenticated(self) -> Optional[_builtins.bool]:
+        """
+        Setting this to true will allow any ClusterRoleBinding and RoleBinding with subjects system:anonymous or system:unauthenticated.
+        """
+        return pulumi.get(self, "enable_insecure_binding_system_unauthenticated")
+
+
 @pulumi.output_type
 class ClusterReleaseChannel(dict):
     def __init__(__self__, *,
@@ -14166,7 +15480,8 @@ class NodePoolNetworkConfig(dict):
                  network_performance_config: Optional['outputs.NodePoolNetworkConfigNetworkPerformanceConfig'] = None,
                  pod_cidr_overprovision_config: Optional['outputs.NodePoolNetworkConfigPodCidrOverprovisionConfig'] = None,
                  pod_ipv4_cidr_block: Optional[_builtins.str] = None,
-                 pod_range: Optional[_builtins.str] = None):
+                 pod_range: Optional[_builtins.str] = None,
+                 subnetwork: Optional[_builtins.str] = None):
         """
         :param Sequence['NodePoolNetworkConfigAdditionalNodeNetworkConfigArgs'] additional_node_network_configs: We specify the additional node networks for this node pool using this list. Each node network corresponds to an additional interface.
                Structure is documented below
@@ -14178,6 +15493,7 @@ class NodePoolNetworkConfig(dict):
         :param 'NodePoolNetworkConfigPodCidrOverprovisionConfigArgs' pod_cidr_overprovision_config: Configuration for node-pool level pod cidr overprovision. If not set, the cluster level setting will be inherited. Structure is documented below.
         :param _builtins.str pod_ipv4_cidr_block: The IP address range for pod IPs in this node pool. Only applicable if createPodRange is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. /14) to have a range chosen with a specific netmask. Set to a CIDR notation (e.g. 10.96.0.0/14) to pick a specific range to use.
         :param _builtins.str pod_range: The ID of the secondary range for pod IPs. If `create_pod_range` is true, this ID is used for the new range. If `create_pod_range` is false, uses an existing secondary range with this ID.
+        :param _builtins.str subnetwork: The subnetwork path for the node pool. Format: `projects/{project}/regions/{region}/subnetworks/{subnetwork}`. If the cluster is associated with multiple subnetworks, the subnetwork for the node pool is picked based on the IP utilization during node pool creation and is immutable
         """
         if additional_node_network_configs is not None:
             pulumi.set(__self__, "additional_node_network_configs", additional_node_network_configs)
@@ -14195,6 +15511,8 @@ class NodePoolNetworkConfig(dict):
             pulumi.set(__self__, "pod_ipv4_cidr_block", pod_ipv4_cidr_block)
         if pod_range is not None:
             pulumi.set(__self__, "pod_range", pod_range)
+        if subnetwork is not None:
+            pulumi.set(__self__, "subnetwork", subnetwork)
 
     @_builtins.property
     @pulumi.getter(name="additionalNodeNetworkConfigs")
@@ -14262,6 +15580,14 @@ class NodePoolNetworkConfig(dict):
         """
         return pulumi.get(self, "pod_range")
 
+    @_builtins.property
+    @pulumi.getter
+    def subnetwork(self) -> Optional[_builtins.str]:
+        """
+        The subnetwork path for the node pool. Format: `projects/{project}/regions/{region}/subnetworks/{subnetwork}`. If the cluster is associated with multiple subnetworks, the subnetwork for the node pool is picked based on the IP utilization during node pool creation and is immutable
+        """
+        return pulumi.get(self, "subnetwork")
+
 
 @pulumi.output_type
 class NodePoolNetworkConfigAdditionalNodeNetworkConfig(dict):
@@ -14416,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":
@@ -14504,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,
@@ -14550,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.
@@ -14597,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:
@@ -14694,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]:
@@ -15110,6 +16450,84 @@ class NodePoolNodeConfigAdvancedMachineFeatures(dict):
         return pulumi.get(self, "performance_monitoring_unit")
 
 
+@pulumi.output_type
+class NodePoolNodeConfigBootDisk(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 NodePoolNodeConfigBootDisk. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodePoolNodeConfigBootDisk.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodePoolNodeConfigBootDisk.__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. 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.
+        """
+        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. 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) -> 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
@@ -15723,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":
@@ -15733,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.")
@@ -15754,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.
@@ -15767,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)
@@ -15786,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:
@@ -15796,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")
@@ -15847,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]:
@@ -15887,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]:
@@ -15895,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):
@@ -15905,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.")
@@ -15920,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)
@@ -15932,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")
@@ -15957,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):
@@ -16253,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.")
@@ -16266,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")
@@ -16280,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):
@@ -16704,6 +18566,7 @@ class GetClusterAddonsConfigResult(dict):
                  http_load_balancings: Sequence['outputs.GetClusterAddonsConfigHttpLoadBalancingResult'],
                  istio_configs: Sequence['outputs.GetClusterAddonsConfigIstioConfigResult'],
                  kalm_configs: Sequence['outputs.GetClusterAddonsConfigKalmConfigResult'],
+                 lustre_csi_driver_configs: Sequence['outputs.GetClusterAddonsConfigLustreCsiDriverConfigResult'],
                  network_policy_configs: Sequence['outputs.GetClusterAddonsConfigNetworkPolicyConfigResult'],
                  parallelstore_csi_driver_configs: Sequence['outputs.GetClusterAddonsConfigParallelstoreCsiDriverConfigResult'],
                  ray_operator_configs: Sequence['outputs.GetClusterAddonsConfigRayOperatorConfigResult'],
@@ -16720,6 +18583,7 @@ class GetClusterAddonsConfigResult(dict):
         :param Sequence['GetClusterAddonsConfigHttpLoadBalancingArgs'] http_load_balancings: The status of the HTTP (L7) load balancing controller addon, which makes it easy to set up HTTP load balancers for services in a cluster. It is enabled by default; set disabled = true to disable.
         :param Sequence['GetClusterAddonsConfigIstioConfigArgs'] istio_configs: The status of the Istio addon.
         :param Sequence['GetClusterAddonsConfigKalmConfigArgs'] kalm_configs: Configuration for the KALM addon, which manages the lifecycle of k8s. It is disabled by default; Set enabled = true to enable.
+        :param Sequence['GetClusterAddonsConfigLustreCsiDriverConfigArgs'] lustre_csi_driver_configs: Configuration for the Lustre CSI driver. Defaults to disabled; set enabled = true to enable.
         :param Sequence['GetClusterAddonsConfigNetworkPolicyConfigArgs'] network_policy_configs: Whether we should enable the network policy addon for the master. This must be enabled in order to enable network policy for the nodes. To enable this, you must also define a network_policy block, otherwise nothing will happen. It can only be disabled if the nodes already do not have network policies enabled. Defaults to disabled; set disabled = false to enable.
         :param Sequence['GetClusterAddonsConfigParallelstoreCsiDriverConfigArgs'] parallelstore_csi_driver_configs: The status of the Parallelstore CSI driver addon, which allows the usage of Parallelstore instances as volumes. Defaults to disabled; set enabled = true to enable.
         :param Sequence['GetClusterAddonsConfigRayOperatorConfigArgs'] ray_operator_configs: The status of the Ray Operator addon, which enabled management of Ray AI/ML jobs on GKE. Defaults to disabled; set enabled = true to enable.
@@ -16736,6 +18600,7 @@ class GetClusterAddonsConfigResult(dict):
         pulumi.set(__self__, "http_load_balancings", http_load_balancings)
         pulumi.set(__self__, "istio_configs", istio_configs)
         pulumi.set(__self__, "kalm_configs", kalm_configs)
+        pulumi.set(__self__, "lustre_csi_driver_configs", lustre_csi_driver_configs)
         pulumi.set(__self__, "network_policy_configs", network_policy_configs)
         pulumi.set(__self__, "parallelstore_csi_driver_configs", parallelstore_csi_driver_configs)
         pulumi.set(__self__, "ray_operator_configs", ray_operator_configs)
@@ -16829,6 +18694,14 @@ class GetClusterAddonsConfigResult(dict):
         """
         return pulumi.get(self, "kalm_configs")
 
+    @_builtins.property
+    @pulumi.getter(name="lustreCsiDriverConfigs")
+    def lustre_csi_driver_configs(self) -> Sequence['outputs.GetClusterAddonsConfigLustreCsiDriverConfigResult']:
+        """
+        Configuration for the Lustre CSI driver. Defaults to disabled; set enabled = true to enable.
+        """
+        return pulumi.get(self, "lustre_csi_driver_configs")
+
     @_builtins.property
     @pulumi.getter(name="networkPolicyConfigs")
     def network_policy_configs(self) -> Sequence['outputs.GetClusterAddonsConfigNetworkPolicyConfigResult']:
@@ -17018,6 +18891,37 @@ class GetClusterAddonsConfigKalmConfigResult(dict):
         return pulumi.get(self, "enabled")
 
 
+@pulumi.output_type
+class GetClusterAddonsConfigLustreCsiDriverConfigResult(dict):
+    def __init__(__self__, *,
+                 enable_legacy_lustre_port: _builtins.bool,
+                 enabled: _builtins.bool):
+        """
+        :param _builtins.bool enable_legacy_lustre_port: If set to true, the Lustre CSI driver will initialize LNet (the virtual network layer for Lustre kernel module) using port 6988.
+               										This flag is required to workaround a port conflict with the gke-metadata-server on GKE nodes.
+        :param _builtins.bool enabled: Whether the Lustre CSI driver is enabled for this cluster.
+        """
+        pulumi.set(__self__, "enable_legacy_lustre_port", enable_legacy_lustre_port)
+        pulumi.set(__self__, "enabled", enabled)
+
+    @_builtins.property
+    @pulumi.getter(name="enableLegacyLustrePort")
+    def enable_legacy_lustre_port(self) -> _builtins.bool:
+        """
+        If set to true, the Lustre CSI driver will initialize LNet (the virtual network layer for Lustre kernel module) using port 6988.
+        										This flag is required to workaround a port conflict with the gke-metadata-server on GKE nodes.
+        """
+        return pulumi.get(self, "enable_legacy_lustre_port")
+
+    @_builtins.property
+    @pulumi.getter
+    def enabled(self) -> _builtins.bool:
+        """
+        Whether the Lustre CSI driver is enabled for this cluster.
+        """
+        return pulumi.get(self, "enabled")
+
+
 @pulumi.output_type
 class GetClusterAddonsConfigNetworkPolicyConfigResult(dict):
     def __init__(__self__, *,
@@ -18039,6 +19943,7 @@ class GetClusterIdentityServiceConfigResult(dict):
 @pulumi.output_type
 class GetClusterIpAllocationPolicyResult(dict):
     def __init__(__self__, *,
+                 additional_ip_ranges_configs: Sequence['outputs.GetClusterIpAllocationPolicyAdditionalIpRangesConfigResult'],
                  additional_pod_ranges_configs: Sequence['outputs.GetClusterIpAllocationPolicyAdditionalPodRangesConfigResult'],
                  cluster_ipv4_cidr_block: _builtins.str,
                  cluster_secondary_range_name: _builtins.str,
@@ -18047,6 +19952,7 @@ class GetClusterIpAllocationPolicyResult(dict):
                  services_secondary_range_name: _builtins.str,
                  stack_type: _builtins.str):
         """
+        :param Sequence['GetClusterIpAllocationPolicyAdditionalIpRangesConfigArgs'] additional_ip_ranges_configs: AdditionalIPRangesConfig is the configuration for individual additional subnetworks attached to the cluster
         :param Sequence['GetClusterIpAllocationPolicyAdditionalPodRangesConfigArgs'] additional_pod_ranges_configs: AdditionalPodRangesConfig is the configuration for additional pod secondary ranges supporting the ClusterUpdate message.
         :param _builtins.str cluster_ipv4_cidr_block: The IP address range for the cluster pod IPs. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. /14) to have a range chosen with a specific netmask. Set to a CIDR notation (e.g. 10.96.0.0/14) from the RFC-1918 private networks (e.g. 10.0.0.0/8, 172.16.0.0/12, 192.168.0.0/16) to pick a specific range to use.
         :param _builtins.str cluster_secondary_range_name: The name of the existing secondary range in the cluster's subnetwork to use for pod IP addresses. Alternatively, cluster_ipv4_cidr_block can be used to automatically create a GKE-managed one.
@@ -18055,6 +19961,7 @@ class GetClusterIpAllocationPolicyResult(dict):
         :param _builtins.str services_secondary_range_name: The name of the existing secondary range in the cluster's subnetwork to use for service ClusterIPs. Alternatively, services_ipv4_cidr_block can be used to automatically create a GKE-managed one.
         :param _builtins.str stack_type: The IP Stack type of the cluster. Choose between IPV4 and IPV4_IPV6. Default type is IPV4 Only if not set
         """
+        pulumi.set(__self__, "additional_ip_ranges_configs", additional_ip_ranges_configs)
         pulumi.set(__self__, "additional_pod_ranges_configs", additional_pod_ranges_configs)
         pulumi.set(__self__, "cluster_ipv4_cidr_block", cluster_ipv4_cidr_block)
         pulumi.set(__self__, "cluster_secondary_range_name", cluster_secondary_range_name)
@@ -18063,6 +19970,14 @@ class GetClusterIpAllocationPolicyResult(dict):
         pulumi.set(__self__, "services_secondary_range_name", services_secondary_range_name)
         pulumi.set(__self__, "stack_type", stack_type)
 
+    @_builtins.property
+    @pulumi.getter(name="additionalIpRangesConfigs")
+    def additional_ip_ranges_configs(self) -> Sequence['outputs.GetClusterIpAllocationPolicyAdditionalIpRangesConfigResult']:
+        """
+        AdditionalIPRangesConfig is the configuration for individual additional subnetworks attached to the cluster
+        """
+        return pulumi.get(self, "additional_ip_ranges_configs")
+
     @_builtins.property
     @pulumi.getter(name="additionalPodRangesConfigs")
     def additional_pod_ranges_configs(self) -> Sequence['outputs.GetClusterIpAllocationPolicyAdditionalPodRangesConfigResult']:
@@ -18120,6 +20035,35 @@ class GetClusterIpAllocationPolicyResult(dict):
         return pulumi.get(self, "stack_type")
 
 
+@pulumi.output_type
+class GetClusterIpAllocationPolicyAdditionalIpRangesConfigResult(dict):
+    def __init__(__self__, *,
+                 pod_ipv4_range_names: Sequence[_builtins.str],
+                 subnetwork: _builtins.str):
+        """
+        :param Sequence[_builtins.str] pod_ipv4_range_names: List of secondary ranges names within this subnetwork that can be used for pod IPs.
+        :param _builtins.str subnetwork: Name of the subnetwork. This can be the full path of the subnetwork or just the name.
+        """
+        pulumi.set(__self__, "pod_ipv4_range_names", pod_ipv4_range_names)
+        pulumi.set(__self__, "subnetwork", subnetwork)
+
+    @_builtins.property
+    @pulumi.getter(name="podIpv4RangeNames")
+    def pod_ipv4_range_names(self) -> Sequence[_builtins.str]:
+        """
+        List of secondary ranges names within this subnetwork that can be used for pod IPs.
+        """
+        return pulumi.get(self, "pod_ipv4_range_names")
+
+    @_builtins.property
+    @pulumi.getter
+    def subnetwork(self) -> _builtins.str:
+        """
+        Name of the subnetwork. This can be the full path of the subnetwork or just the name.
+        """
+        return pulumi.get(self, "subnetwork")
+
+
 @pulumi.output_type
 class GetClusterIpAllocationPolicyAdditionalPodRangesConfigResult(dict):
     def __init__(__self__, *,
@@ -18634,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,
@@ -18680,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.
@@ -18726,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)
@@ -18786,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']:
@@ -19171,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__, *,
@@ -19571,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.
@@ -19584,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)
@@ -19597,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")
@@ -19653,32 +21677,64 @@ 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")
-    def image_gc_low_threshold_percent(self) -> _builtins.int:
+    @pulumi.getter(name="evictionMinimumReclaims")
+    def eviction_minimum_reclaims(self) -> Sequence['outputs.GetClusterNodeConfigKubeletConfigEvictionMinimumReclaimResult']:
         """
-        Defines the percent of disk usage before which image garbage collection is never run. Lowest disk usage to garbage collect to.
+        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, "image_gc_low_threshold_percent")
+        return pulumi.get(self, "eviction_minimum_reclaims")
 
     @_builtins.property
-    @pulumi.getter(name="imageMaximumGcAge")
-    def image_maximum_gc_age(self) -> _builtins.str:
+    @pulumi.getter(name="evictionSoftGracePeriods")
+    def eviction_soft_grace_periods(self) -> Sequence['outputs.GetClusterNodeConfigKubeletConfigEvictionSoftGracePeriodResult']:
         """
-        Defines the maximum age an image can be unused before it is garbage collected.
+        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, "image_maximum_gc_age")
+        return pulumi.get(self, "eviction_soft_grace_periods")
 
     @_builtins.property
-    @pulumi.getter(name="imageMinimumGcAge")
-    def image_minimum_gc_age(self) -> _builtins.str:
+    @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.
+        """
+        return pulumi.get(self, "image_gc_low_threshold_percent")
+
+    @_builtins.property
+    @pulumi.getter(name="imageMaximumGcAge")
+    def image_maximum_gc_age(self) -> _builtins.str:
+        """
+        Defines the maximum age an image can be unused before it is garbage collected.
+        """
+        return pulumi.get(self, "image_maximum_gc_age")
+
+    @_builtins.property
+    @pulumi.getter(name="imageMinimumGcAge")
+    def image_minimum_gc_age(self) -> _builtins.str:
         """
         Defines the minimum age for an unused image before it is garbage collected.
         """
@@ -19692,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:
@@ -19700,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")
@@ -19740,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):
@@ -19907,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']:
@@ -20604,7 +22928,8 @@ class GetClusterNodePoolNetworkConfigResult(dict):
                  network_performance_configs: Sequence['outputs.GetClusterNodePoolNetworkConfigNetworkPerformanceConfigResult'],
                  pod_cidr_overprovision_configs: Sequence['outputs.GetClusterNodePoolNetworkConfigPodCidrOverprovisionConfigResult'],
                  pod_ipv4_cidr_block: _builtins.str,
-                 pod_range: _builtins.str):
+                 pod_range: _builtins.str,
+                 subnetwork: _builtins.str):
         """
         :param Sequence['GetClusterNodePoolNetworkConfigAdditionalNodeNetworkConfigArgs'] additional_node_network_configs: We specify the additional node networks for this node pool using this list. Each node network corresponds to an additional interface
         :param Sequence['GetClusterNodePoolNetworkConfigAdditionalPodNetworkConfigArgs'] additional_pod_network_configs: We specify the additional pod networks for this node pool using this list. Each pod network corresponds to an additional alias IP range for the node
@@ -20614,6 +22939,7 @@ class GetClusterNodePoolNetworkConfigResult(dict):
         :param Sequence['GetClusterNodePoolNetworkConfigPodCidrOverprovisionConfigArgs'] pod_cidr_overprovision_configs: Configuration for node-pool level pod cidr overprovision. If not set, the cluster level setting will be inherited
         :param _builtins.str pod_ipv4_cidr_block: The IP address range for pod IPs in this node pool. Only applicable if create_pod_range is true. Set to blank to have a range chosen with the default size. Set to /netmask (e.g. /14) to have a range chosen with a specific netmask. Set to a CIDR notation (e.g. 10.96.0.0/14) to pick a specific range to use.
         :param _builtins.str pod_range: The ID of the secondary range for pod IPs. If create_pod_range is true, this ID is used for the new range. If create_pod_range is false, uses an existing secondary range with this ID.
+        :param _builtins.str subnetwork: The subnetwork path for the node pool. Format: projects/{project}/regions/{region}/subnetworks/{subnetwork} . If the cluster is associated with multiple subnetworks, the subnetwork for the node pool is picked based on the IP utilization during node pool creation and is immutable.
         """
         pulumi.set(__self__, "additional_node_network_configs", additional_node_network_configs)
         pulumi.set(__self__, "additional_pod_network_configs", additional_pod_network_configs)
@@ -20623,6 +22949,7 @@ class GetClusterNodePoolNetworkConfigResult(dict):
         pulumi.set(__self__, "pod_cidr_overprovision_configs", pod_cidr_overprovision_configs)
         pulumi.set(__self__, "pod_ipv4_cidr_block", pod_ipv4_cidr_block)
         pulumi.set(__self__, "pod_range", pod_range)
+        pulumi.set(__self__, "subnetwork", subnetwork)
 
     @_builtins.property
     @pulumi.getter(name="additionalNodeNetworkConfigs")
@@ -20688,6 +23015,14 @@ class GetClusterNodePoolNetworkConfigResult(dict):
         """
         return pulumi.get(self, "pod_range")
 
+    @_builtins.property
+    @pulumi.getter
+    def subnetwork(self) -> _builtins.str:
+        """
+        The subnetwork path for the node pool. Format: projects/{project}/regions/{region}/subnetworks/{subnetwork} . If the cluster is associated with multiple subnetworks, the subnetwork for the node pool is picked based on the IP utilization during node pool creation and is immutable.
+        """
+        return pulumi.get(self, "subnetwork")
+
 
 @pulumi.output_type
 class GetClusterNodePoolNetworkConfigAdditionalNodeNetworkConfigResult(dict):
@@ -20793,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,
@@ -20839,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.
@@ -20885,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)
@@ -20945,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']:
@@ -21330,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__, *,
@@ -21730,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.
@@ -21743,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)
@@ -21756,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")
@@ -21811,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:
@@ -21851,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:
@@ -21859,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")
@@ -21899,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):
@@ -22066,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']:
@@ -22653,6 +25368,35 @@ class GetClusterProtectConfigWorkloadConfigResult(dict):
         return pulumi.get(self, "audit_mode")
 
 
+@pulumi.output_type
+class GetClusterRbacBindingConfigResult(dict):
+    def __init__(__self__, *,
+                 enable_insecure_binding_system_authenticated: _builtins.bool,
+                 enable_insecure_binding_system_unauthenticated: _builtins.bool):
+        """
+        :param _builtins.bool enable_insecure_binding_system_authenticated: Setting this to true will allow any ClusterRoleBinding and RoleBinding with subjects system:authenticated.
+        :param _builtins.bool enable_insecure_binding_system_unauthenticated: Setting this to true will allow any ClusterRoleBinding and RoleBinding with subjects system:anonymous or system:unauthenticated.
+        """
+        pulumi.set(__self__, "enable_insecure_binding_system_authenticated", enable_insecure_binding_system_authenticated)
+        pulumi.set(__self__, "enable_insecure_binding_system_unauthenticated", enable_insecure_binding_system_unauthenticated)
+
+    @_builtins.property
+    @pulumi.getter(name="enableInsecureBindingSystemAuthenticated")
+    def enable_insecure_binding_system_authenticated(self) -> _builtins.bool:
+        """
+        Setting this to true will allow any ClusterRoleBinding and RoleBinding with subjects system:authenticated.
+        """
+        return pulumi.get(self, "enable_insecure_binding_system_authenticated")
+
+    @_builtins.property
+    @pulumi.getter(name="enableInsecureBindingSystemUnauthenticated")
+    def enable_insecure_binding_system_unauthenticated(self) -> _builtins.bool:
+        """
+        Setting this to true will allow any ClusterRoleBinding and RoleBinding with subjects system:anonymous or system:unauthenticated.
+        """
+        return pulumi.get(self, "enable_insecure_binding_system_unauthenticated")
+
+
 @pulumi.output_type
 class GetClusterReleaseChannelResult(dict):
     def __init__(__self__, *,