pulumi-gcp 8.36.0a1750484065__py3-none-any.whl → 8.37.0__py3-none-any.whl

pulumi_gcp/container/_inputs.py

@@ -238,6 +238,8 @@ __all__ = [
     'ClusterFleetArgsDict',
     'ClusterGatewayApiConfigArgs',
     'ClusterGatewayApiConfigArgsDict',
+    'ClusterGkeAutoUpgradeConfigArgs',
+    'ClusterGkeAutoUpgradeConfigArgsDict',
     'ClusterIdentityServiceConfigArgs',
     'ClusterIdentityServiceConfigArgsDict',
     'ClusterIpAllocationPolicyArgs',
@@ -6528,18 +6530,28 @@ if not MYPY:
         Enable Confidential GKE Nodes for this cluster, to
         enforce encryption of data in-use.
         """
+        confidential_instance_type: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Defines the type of technology used
+        by the confidential node.
+        """
 elif False:
     ClusterConfidentialNodesArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class ClusterConfidentialNodesArgs:
     def __init__(__self__, *,
-                 enabled: pulumi.Input[builtins.bool]):
+                 enabled: pulumi.Input[builtins.bool],
+                 confidential_instance_type: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.bool] enabled: Enable Confidential GKE Nodes for this cluster, to
                enforce encryption of data in-use.
+        :param pulumi.Input[builtins.str] confidential_instance_type: Defines the type of technology used
+               by the confidential node.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
 
     @property
     @pulumi.getter
@@ -6554,6 +6566,19 @@ class ClusterConfidentialNodesArgs:
     def enabled(self, value: pulumi.Input[builtins.bool]):
         pulumi.set(self, "enabled", value)
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Defines the type of technology used
+        by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
+    @confidential_instance_type.setter
+    def confidential_instance_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "confidential_instance_type", value)
+
 
 if not MYPY:
     class ClusterControlPlaneEndpointsConfigArgsDict(TypedDict):
@@ -7134,6 +7159,43 @@ class ClusterGatewayApiConfigArgs:
         pulumi.set(self, "channel", value)
 
 
+if not MYPY:
+    class ClusterGkeAutoUpgradeConfigArgsDict(TypedDict):
+        patch_mode: pulumi.Input[builtins.str]
+        """
+        The selected patch mode.
+        Accepted values are:
+        * ACCELERATED: Upgrades to the latest available patch version in a given minor and release channel.
+        """
+elif False:
+    ClusterGkeAutoUpgradeConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class ClusterGkeAutoUpgradeConfigArgs:
+    def __init__(__self__, *,
+                 patch_mode: pulumi.Input[builtins.str]):
+        """
+        :param pulumi.Input[builtins.str] patch_mode: The selected patch mode.
+               Accepted values are:
+               * ACCELERATED: Upgrades to the latest available patch version in a given minor and release channel.
+        """
+        pulumi.set(__self__, "patch_mode", patch_mode)
+
+    @property
+    @pulumi.getter(name="patchMode")
+    def patch_mode(self) -> pulumi.Input[builtins.str]:
+        """
+        The selected patch mode.
+        Accepted values are:
+        * ACCELERATED: Upgrades to the latest available patch version in a given minor and release channel.
+        """
+        return pulumi.get(self, "patch_mode")
+
+    @patch_mode.setter
+    def patch_mode(self, value: pulumi.Input[builtins.str]):
+        pulumi.set(self, "patch_mode", value)
+
+
 if not MYPY:
     class ClusterIdentityServiceConfigArgsDict(TypedDict):
         enabled: NotRequired[pulumi.Input[builtins.bool]]
@@ -9612,6 +9674,10 @@ if not MYPY:
         """
         Defines whether the instance should have nested virtualization enabled. Defaults to false.
         """
+        performance_monitoring_unit: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Defines the performance monitoring unit [PMU](https://cloud.google.com/compute/docs/pmu-overview) level. Valid values are `ARCHITECTURAL`, `STANDARD`, or `ENHANCED`. Defaults to off.
+        """
 elif False:
     ClusterNodeConfigAdvancedMachineFeaturesArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -9619,14 +9685,18 @@ elif False:
 class ClusterNodeConfigAdvancedMachineFeaturesArgs:
     def __init__(__self__, *,
                  threads_per_core: pulumi.Input[builtins.int],
-                 enable_nested_virtualization: Optional[pulumi.Input[builtins.bool]] = None):
+                 enable_nested_virtualization: Optional[pulumi.Input[builtins.bool]] = None,
+                 performance_monitoring_unit: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.int] threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
         :param pulumi.Input[builtins.bool] enable_nested_virtualization: Defines whether the instance should have nested virtualization enabled. Defaults to false.
+        :param pulumi.Input[builtins.str] performance_monitoring_unit: Defines the performance monitoring unit [PMU](https://cloud.google.com/compute/docs/pmu-overview) level. Valid values are `ARCHITECTURAL`, `STANDARD`, or `ENHANCED`. Defaults to off.
         """
         pulumi.set(__self__, "threads_per_core", threads_per_core)
         if enable_nested_virtualization is not None:
             pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
+        if performance_monitoring_unit is not None:
+            pulumi.set(__self__, "performance_monitoring_unit", performance_monitoring_unit)
 
     @property
     @pulumi.getter(name="threadsPerCore")
@@ -9652,6 +9722,18 @@ class ClusterNodeConfigAdvancedMachineFeaturesArgs:
     def enable_nested_virtualization(self, value: Optional[pulumi.Input[builtins.bool]]):
         pulumi.set(self, "enable_nested_virtualization", value)
 
+    @property
+    @pulumi.getter(name="performanceMonitoringUnit")
+    def performance_monitoring_unit(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Defines the performance monitoring unit [PMU](https://cloud.google.com/compute/docs/pmu-overview) level. Valid values are `ARCHITECTURAL`, `STANDARD`, or `ENHANCED`. Defaults to off.
+        """
+        return pulumi.get(self, "performance_monitoring_unit")
+
+    @performance_monitoring_unit.setter
+    def performance_monitoring_unit(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "performance_monitoring_unit", value)
+
 
 if not MYPY:
     class ClusterNodeConfigConfidentialNodesArgsDict(TypedDict):
@@ -9660,18 +9742,28 @@ if not MYPY:
         Enable Confidential GKE Nodes for this cluster, to
         enforce encryption of data in-use.
         """
+        confidential_instance_type: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Defines the type of technology used
+        by the confidential node.
+        """
 elif False:
     ClusterNodeConfigConfidentialNodesArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class ClusterNodeConfigConfidentialNodesArgs:
     def __init__(__self__, *,
-                 enabled: pulumi.Input[builtins.bool]):
+                 enabled: pulumi.Input[builtins.bool],
+                 confidential_instance_type: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.bool] enabled: Enable Confidential GKE Nodes for this cluster, to
                enforce encryption of data in-use.
+        :param pulumi.Input[builtins.str] confidential_instance_type: Defines the type of technology used
+               by the confidential node.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
 
     @property
     @pulumi.getter
@@ -9686,6 +9778,19 @@ class ClusterNodeConfigConfidentialNodesArgs:
     def enabled(self, value: pulumi.Input[builtins.bool]):
         pulumi.set(self, "enabled", value)
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Defines the type of technology used
+        by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
+    @confidential_instance_type.setter
+    def confidential_instance_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "confidential_instance_type", value)
+
 
 if not MYPY:
     class ClusterNodeConfigContainerdConfigArgsDict(TypedDict):
@@ -12397,7 +12502,7 @@ if not MYPY:
         """
         create_pod_range: NotRequired[pulumi.Input[builtins.bool]]
         """
-        Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified.
+        Whether to create a new range for pod IPs in this node pool. Defaults are provided for pod_range and pod_ipv4_cidr_block if they are not specified.
         """
         enable_private_nodes: NotRequired[pulumi.Input[builtins.bool]]
         """
@@ -12413,11 +12518,11 @@ if not MYPY:
         """
         pod_ipv4_cidr_block: NotRequired[pulumi.Input[builtins.str]]
         """
-        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.
+        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.
         """
         pod_range: NotRequired[pulumi.Input[builtins.str]]
         """
-        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.
+        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.
         """
 elif False:
     ClusterNodePoolNetworkConfigArgsDict: TypeAlias = Mapping[str, Any]
@@ -12436,12 +12541,12 @@ class ClusterNodePoolNetworkConfigArgs:
         """
         :param pulumi.Input[Sequence[pulumi.Input['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 pulumi.Input[Sequence[pulumi.Input['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
-        :param pulumi.Input[builtins.bool] create_pod_range: Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified.
+        :param pulumi.Input[builtins.bool] create_pod_range: Whether to create a new range for pod IPs in this node pool. Defaults are provided for pod_range and pod_ipv4_cidr_block if they are not specified.
         :param pulumi.Input[builtins.bool] enable_private_nodes: Whether nodes have internal IP addresses only.
         :param pulumi.Input['ClusterNodePoolNetworkConfigNetworkPerformanceConfigArgs'] network_performance_config: Network bandwidth tier configuration.
         :param pulumi.Input['ClusterNodePoolNetworkConfigPodCidrOverprovisionConfigArgs'] pod_cidr_overprovision_config: Configuration for node-pool level pod cidr overprovision. If not set, the cluster level setting will be inherited
-        :param pulumi.Input[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 pulumi.Input[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 pulumi.Input[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 pulumi.Input[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.
         """
         if additional_node_network_configs is not None:
             pulumi.set(__self__, "additional_node_network_configs", additional_node_network_configs)
@@ -12488,7 +12593,7 @@ class ClusterNodePoolNetworkConfigArgs:
     @pulumi.getter(name="createPodRange")
     def create_pod_range(self) -> Optional[pulumi.Input[builtins.bool]]:
         """
-        Whether to create a new range for pod IPs in this node pool. Defaults are provided for `pod_range` and `pod_ipv4_cidr_block` if they are not specified.
+        Whether to create a new range for pod IPs in this node pool. Defaults are provided for pod_range and pod_ipv4_cidr_block if they are not specified.
         """
         return pulumi.get(self, "create_pod_range")
 
@@ -12536,7 +12641,7 @@ class ClusterNodePoolNetworkConfigArgs:
     @pulumi.getter(name="podIpv4CidrBlock")
     def pod_ipv4_cidr_block(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        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.
+        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.
         """
         return pulumi.get(self, "pod_ipv4_cidr_block")
 
@@ -12548,7 +12653,7 @@ class ClusterNodePoolNetworkConfigArgs:
     @pulumi.getter(name="podRange")
     def pod_range(self) -> Optional[pulumi.Input[builtins.str]]:
         """
-        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.
+        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.
         """
         return pulumi.get(self, "pod_range")
 
@@ -13866,6 +13971,10 @@ if not MYPY:
         """
         Defines whether the instance should have nested virtualization enabled. Defaults to false.
         """
+        performance_monitoring_unit: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Defines the performance monitoring unit [PMU](https://cloud.google.com/compute/docs/pmu-overview) level. Valid values are `ARCHITECTURAL`, `STANDARD`, or `ENHANCED`. Defaults to off.
+        """
 elif False:
     ClusterNodePoolNodeConfigAdvancedMachineFeaturesArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -13873,14 +13982,18 @@ elif False:
 class ClusterNodePoolNodeConfigAdvancedMachineFeaturesArgs:
     def __init__(__self__, *,
                  threads_per_core: pulumi.Input[builtins.int],
-                 enable_nested_virtualization: Optional[pulumi.Input[builtins.bool]] = None):
+                 enable_nested_virtualization: Optional[pulumi.Input[builtins.bool]] = None,
+                 performance_monitoring_unit: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.int] threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
         :param pulumi.Input[builtins.bool] enable_nested_virtualization: Defines whether the instance should have nested virtualization enabled. Defaults to false.
+        :param pulumi.Input[builtins.str] performance_monitoring_unit: Defines the performance monitoring unit [PMU](https://cloud.google.com/compute/docs/pmu-overview) level. Valid values are `ARCHITECTURAL`, `STANDARD`, or `ENHANCED`. Defaults to off.
         """
         pulumi.set(__self__, "threads_per_core", threads_per_core)
         if enable_nested_virtualization is not None:
             pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
+        if performance_monitoring_unit is not None:
+            pulumi.set(__self__, "performance_monitoring_unit", performance_monitoring_unit)
 
     @property
     @pulumi.getter(name="threadsPerCore")
@@ -13906,6 +14019,18 @@ class ClusterNodePoolNodeConfigAdvancedMachineFeaturesArgs:
     def enable_nested_virtualization(self, value: Optional[pulumi.Input[builtins.bool]]):
         pulumi.set(self, "enable_nested_virtualization", value)
 
+    @property
+    @pulumi.getter(name="performanceMonitoringUnit")
+    def performance_monitoring_unit(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Defines the performance monitoring unit [PMU](https://cloud.google.com/compute/docs/pmu-overview) level. Valid values are `ARCHITECTURAL`, `STANDARD`, or `ENHANCED`. Defaults to off.
+        """
+        return pulumi.get(self, "performance_monitoring_unit")
+
+    @performance_monitoring_unit.setter
+    def performance_monitoring_unit(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "performance_monitoring_unit", value)
+
 
 if not MYPY:
     class ClusterNodePoolNodeConfigConfidentialNodesArgsDict(TypedDict):
@@ -13914,18 +14039,28 @@ if not MYPY:
         Enable Confidential GKE Nodes for this cluster, to
         enforce encryption of data in-use.
         """
+        confidential_instance_type: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Defines the type of technology used
+        by the confidential node.
+        """
 elif False:
     ClusterNodePoolNodeConfigConfidentialNodesArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class ClusterNodePoolNodeConfigConfidentialNodesArgs:
     def __init__(__self__, *,
-                 enabled: pulumi.Input[builtins.bool]):
+                 enabled: pulumi.Input[builtins.bool],
+                 confidential_instance_type: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.bool] enabled: Enable Confidential GKE Nodes for this cluster, to
                enforce encryption of data in-use.
+        :param pulumi.Input[builtins.str] confidential_instance_type: Defines the type of technology used
+               by the confidential node.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
 
     @property
     @pulumi.getter
@@ -13940,6 +14075,19 @@ class ClusterNodePoolNodeConfigConfidentialNodesArgs:
     def enabled(self, value: pulumi.Input[builtins.bool]):
         pulumi.set(self, "enabled", value)
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Defines the type of technology used
+        by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
+    @confidential_instance_type.setter
+    def confidential_instance_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "confidential_instance_type", value)
+
 
 if not MYPY:
     class ClusterNodePoolNodeConfigContainerdConfigArgsDict(TypedDict):
@@ -17735,10 +17883,7 @@ if not MYPY:
         """
         reservation_affinity: NotRequired[pulumi.Input['NodePoolNodeConfigReservationAffinityArgsDict']]
         """
-        The configuration of the desired reservation which instances could take capacity from.
-        Structure is documented below.
-
-        <a name="nested_autoscaling"></a>The `autoscaling` block supports (either total or per zone limits are required):
+        The reservation affinity configuration for the node pool.
         """
         resource_labels: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]]]
         """
@@ -17875,10 +18020,7 @@ class NodePoolNodeConfigArgs:
         :param pulumi.Input[builtins.str] node_group: Setting this field will assign instances of this pool to run on the specified node group. This is useful for running workloads on sole tenant nodes.
         :param pulumi.Input[Sequence[pulumi.Input[builtins.str]]] oauth_scopes: The set of Google API scopes to be made available on all of the node VMs.
         :param pulumi.Input[builtins.bool] preemptible: Whether the nodes are created as preemptible VM instances.
-        :param pulumi.Input['NodePoolNodeConfigReservationAffinityArgs'] reservation_affinity: The configuration of the desired reservation which instances could take capacity from.
-               Structure is documented below.
-               
-               <a name="nested_autoscaling"></a>The `autoscaling` block supports (either total or per zone limits are required):
+        :param pulumi.Input['NodePoolNodeConfigReservationAffinityArgs'] reservation_affinity: The reservation affinity configuration for the node pool.
         :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] resource_labels: The GCE resource labels (a map of key/value pairs) to be applied to the node pool.
         :param pulumi.Input[Mapping[str, pulumi.Input[builtins.str]]] resource_manager_tags: A map of resource manager tags. Resource manager tag keys and values have the same definition as resource manager tags. Keys must be in the format tagKeys/{tag_key_id}, and values are in the format tagValues/456. The field is ignored (both PUT & PATCH) when empty.
         :param pulumi.Input['NodePoolNodeConfigSandboxConfigArgs'] sandbox_config: Sandbox configuration for this node.
@@ -18360,10 +18502,7 @@ class NodePoolNodeConfigArgs:
     @pulumi.getter(name="reservationAffinity")
     def reservation_affinity(self) -> Optional[pulumi.Input['NodePoolNodeConfigReservationAffinityArgs']]:
         """
-        The configuration of the desired reservation which instances could take capacity from.
-        Structure is documented below.
-
-        <a name="nested_autoscaling"></a>The `autoscaling` block supports (either total or per zone limits are required):
+        The reservation affinity configuration for the node pool.
         """
         return pulumi.get(self, "reservation_affinity")
 
@@ -18538,6 +18677,10 @@ if not MYPY:
         """
         Whether the node should have nested virtualization enabled.
         """
+        performance_monitoring_unit: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Level of Performance Monitoring Unit (PMU) requested. If unset, no access to the PMU is assumed.
+        """
 elif False:
     NodePoolNodeConfigAdvancedMachineFeaturesArgsDict: TypeAlias = Mapping[str, Any]
 
@@ -18545,14 +18688,18 @@ elif False:
 class NodePoolNodeConfigAdvancedMachineFeaturesArgs:
     def __init__(__self__, *,
                  threads_per_core: pulumi.Input[builtins.int],
-                 enable_nested_virtualization: Optional[pulumi.Input[builtins.bool]] = None):
+                 enable_nested_virtualization: Optional[pulumi.Input[builtins.bool]] = None,
+                 performance_monitoring_unit: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.int] threads_per_core: The number of threads per physical core. To disable simultaneous multithreading (SMT) set this to 1. If unset, the maximum number of threads supported per core by the underlying processor is assumed.
         :param pulumi.Input[builtins.bool] enable_nested_virtualization: Whether the node should have nested virtualization enabled.
+        :param pulumi.Input[builtins.str] performance_monitoring_unit: Level of Performance Monitoring Unit (PMU) requested. If unset, no access to the PMU is assumed.
         """
         pulumi.set(__self__, "threads_per_core", threads_per_core)
         if enable_nested_virtualization is not None:
             pulumi.set(__self__, "enable_nested_virtualization", enable_nested_virtualization)
+        if performance_monitoring_unit is not None:
+            pulumi.set(__self__, "performance_monitoring_unit", performance_monitoring_unit)
 
     @property
     @pulumi.getter(name="threadsPerCore")
@@ -18578,6 +18725,18 @@ class NodePoolNodeConfigAdvancedMachineFeaturesArgs:
     def enable_nested_virtualization(self, value: Optional[pulumi.Input[builtins.bool]]):
         pulumi.set(self, "enable_nested_virtualization", value)
 
+    @property
+    @pulumi.getter(name="performanceMonitoringUnit")
+    def performance_monitoring_unit(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Level of Performance Monitoring Unit (PMU) requested. If unset, no access to the PMU is assumed.
+        """
+        return pulumi.get(self, "performance_monitoring_unit")
+
+    @performance_monitoring_unit.setter
+    def performance_monitoring_unit(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "performance_monitoring_unit", value)
+
 
 if not MYPY:
     class NodePoolNodeConfigConfidentialNodesArgsDict(TypedDict):
@@ -18585,17 +18744,25 @@ if not MYPY:
         """
         Whether Confidential Nodes feature is enabled for all nodes in this pool.
         """
+        confidential_instance_type: NotRequired[pulumi.Input[builtins.str]]
+        """
+        Defines the type of technology used by the confidential node.
+        """
 elif False:
     NodePoolNodeConfigConfidentialNodesArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class NodePoolNodeConfigConfidentialNodesArgs:
     def __init__(__self__, *,
-                 enabled: pulumi.Input[builtins.bool]):
+                 enabled: pulumi.Input[builtins.bool],
+                 confidential_instance_type: Optional[pulumi.Input[builtins.str]] = None):
         """
         :param pulumi.Input[builtins.bool] enabled: Whether Confidential Nodes feature is enabled for all nodes in this pool.
+        :param pulumi.Input[builtins.str] confidential_instance_type: Defines the type of technology used by the confidential node.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if confidential_instance_type is not None:
+            pulumi.set(__self__, "confidential_instance_type", confidential_instance_type)
 
     @property
     @pulumi.getter
@@ -18609,6 +18776,18 @@ class NodePoolNodeConfigConfidentialNodesArgs:
     def enabled(self, value: pulumi.Input[builtins.bool]):
         pulumi.set(self, "enabled", value)
 
+    @property
+    @pulumi.getter(name="confidentialInstanceType")
+    def confidential_instance_type(self) -> Optional[pulumi.Input[builtins.str]]:
+        """
+        Defines the type of technology used by the confidential node.
+        """
+        return pulumi.get(self, "confidential_instance_type")
+
+    @confidential_instance_type.setter
+    def confidential_instance_type(self, value: Optional[pulumi.Input[builtins.str]]):
+        pulumi.set(self, "confidential_instance_type", value)
+
 
 if not MYPY:
     class NodePoolNodeConfigContainerdConfigArgsDict(TypedDict):