pulumi-gcp 8.1.0a1726293903__py3-none-any.whl → 8.2.0__py3-none-any.whl

pulumi_gcp/container/outputs.py

@@ -27,6 +27,7 @@ __all__ = [
     'AttachedClusterOidcConfig',
     'AttachedClusterProxyConfig',
     'AttachedClusterProxyConfigKubernetesSecret',
+    'AttachedClusterSecurityPostureConfig',
     'AttachedClusterWorkloadIdentityConfig',
     'AwsClusterAuthorization',
     'AwsClusterAuthorizationAdminGroup',
@@ -170,6 +171,7 @@ __all__ = [
     'ClusterNodePool',
     'ClusterNodePoolAutoConfig',
     'ClusterNodePoolAutoConfigNetworkTags',
+    'ClusterNodePoolAutoConfigNodeKubeletConfig',
     'ClusterNodePoolAutoscaling',
     'ClusterNodePoolDefaults',
     'ClusterNodePoolDefaultsNodeConfigDefaults',
@@ -362,6 +364,7 @@ __all__ = [
     'GetClusterNodePoolResult',
     'GetClusterNodePoolAutoConfigResult',
     'GetClusterNodePoolAutoConfigNetworkTagResult',
+    'GetClusterNodePoolAutoConfigNodeKubeletConfigResult',
     'GetClusterNodePoolAutoscalingResult',
     'GetClusterNodePoolDefaultResult',
     'GetClusterNodePoolDefaultNodeConfigDefaultResult',
@@ -837,6 +840,43 @@ class AttachedClusterProxyConfigKubernetesSecret(dict):
         return pulumi.get(self, "namespace")
 
 
+@pulumi.output_type
+class AttachedClusterSecurityPostureConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "vulnerabilityMode":
+            suggest = "vulnerability_mode"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in AttachedClusterSecurityPostureConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        AttachedClusterSecurityPostureConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        AttachedClusterSecurityPostureConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 vulnerability_mode: str):
+        """
+        :param str vulnerability_mode: Sets the mode of the Kubernetes security posture API's workload vulnerability scanning.
+               Possible values are: `VULNERABILITY_DISABLED`, `VULNERABILITY_ENTERPRISE`.
+        """
+        pulumi.set(__self__, "vulnerability_mode", vulnerability_mode)
+
+    @property
+    @pulumi.getter(name="vulnerabilityMode")
+    def vulnerability_mode(self) -> str:
+        """
+        Sets the mode of the Kubernetes security posture API's workload vulnerability scanning.
+        Possible values are: `VULNERABILITY_DISABLED`, `VULNERABILITY_ENTERPRISE`.
+        """
+        return pulumi.get(self, "vulnerability_mode")
+
+
 @pulumi.output_type
 class AttachedClusterWorkloadIdentityConfig(dict):
     @staticmethod
@@ -6629,6 +6669,8 @@ class ClusterNodeConfig(dict):
             suggest = "shielded_instance_config"
         elif key == "soleTenantConfig":
             suggest = "sole_tenant_config"
+        elif key == "storagePools":
+            suggest = "storage_pools"
         elif key == "workloadMetadataConfig":
             suggest = "workload_metadata_config"
 
@@ -6681,6 +6723,7 @@ class ClusterNodeConfig(dict):
                  shielded_instance_config: Optional['outputs.ClusterNodeConfigShieldedInstanceConfig'] = None,
                  sole_tenant_config: Optional['outputs.ClusterNodeConfigSoleTenantConfig'] = None,
                  spot: Optional[bool] = None,
+                 storage_pools: Optional[Sequence[str]] = None,
                  tags: Optional[Sequence[str]] = None,
                  taints: Optional[Sequence['outputs.ClusterNodeConfigTaint']] = None,
                  workload_metadata_config: Optional['outputs.ClusterNodeConfigWorkloadMetadataConfig'] = None):
@@ -6771,6 +6814,7 @@ class ClusterNodeConfig(dict):
         :param 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.
+        :param Sequence[str] storage_pools: The list of Storage Pools where boot disks are provisioned.
         :param Sequence[str] tags: The list of instance tags applied to all nodes. Tags are used to identify
                valid sources or targets for network firewalls.
         :param Sequence['ClusterNodeConfigTaintArgs'] taints: A list of [Kubernetes taints](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/)
@@ -6858,6 +6902,8 @@ class ClusterNodeConfig(dict):
             pulumi.set(__self__, "sole_tenant_config", sole_tenant_config)
         if spot is not None:
             pulumi.set(__self__, "spot", spot)
+        if storage_pools is not None:
+            pulumi.set(__self__, "storage_pools", storage_pools)
         if tags is not None:
             pulumi.set(__self__, "tags", tags)
         if taints is not None:
@@ -7210,6 +7256,14 @@ class ClusterNodeConfig(dict):
         """
         return pulumi.get(self, "spot")
 
+    @property
+    @pulumi.getter(name="storagePools")
+    def storage_pools(self) -> Optional[Sequence[str]]:
+        """
+        The list of Storage Pools where boot disks are provisioned.
+        """
+        return pulumi.get(self, "storage_pools")
+
     @property
     @pulumi.getter
     def tags(self) -> Optional[Sequence[str]]:
@@ -7875,6 +7929,8 @@ class ClusterNodeConfigKubeletConfig(dict):
             suggest = "cpu_cfs_quota"
         elif key == "cpuCfsQuotaPeriod":
             suggest = "cpu_cfs_quota_period"
+        elif key == "insecureKubeletReadonlyPortEnabled":
+            suggest = "insecure_kubelet_readonly_port_enabled"
         elif key == "podPidsLimit":
             suggest = "pod_pids_limit"
 
@@ -7893,6 +7949,7 @@ class ClusterNodeConfigKubeletConfig(dict):
                  cpu_manager_policy: str,
                  cpu_cfs_quota: Optional[bool] = None,
                  cpu_cfs_quota_period: Optional[str] = None,
+                 insecure_kubelet_readonly_port_enabled: Optional[str] = None,
                  pod_pids_limit: Optional[int] = None):
         """
         :param str cpu_manager_policy: The CPU management policy on the node. See
@@ -7909,6 +7966,7 @@ class ClusterNodeConfigKubeletConfig(dict):
                value and accepts an invalid `default` value instead. While this remains true,
                not specifying the `kubelet_config` block should be the equivalent of specifying
                `none`.
+        :param 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 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.
         """
         pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
@@ -7916,6 +7974,8 @@ class ClusterNodeConfigKubeletConfig(dict):
             pulumi.set(__self__, "cpu_cfs_quota", cpu_cfs_quota)
         if cpu_cfs_quota_period is not None:
             pulumi.set(__self__, "cpu_cfs_quota_period", cpu_cfs_quota_period)
+        if insecure_kubelet_readonly_port_enabled is not None:
+            pulumi.set(__self__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
         if pod_pids_limit is not None:
             pulumi.set(__self__, "pod_pids_limit", pod_pids_limit)
 
@@ -7954,6 +8014,14 @@ class ClusterNodeConfigKubeletConfig(dict):
         """
         return pulumi.get(self, "cpu_cfs_quota_period")
 
+    @property
+    @pulumi.getter(name="insecureKubeletReadonlyPortEnabled")
+    def insecure_kubelet_readonly_port_enabled(self) -> Optional[str]:
+        """
+        Controls whether the kubelet read-only port is enabled. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        """
+        return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
+
     @property
     @pulumi.getter(name="podPidsLimit")
     def pod_pids_limit(self) -> Optional[int]:
@@ -8707,6 +8775,8 @@ class ClusterNodePoolAutoConfig(dict):
         suggest = None
         if key == "networkTags":
             suggest = "network_tags"
+        elif key == "nodeKubeletConfig":
+            suggest = "node_kubelet_config"
         elif key == "resourceManagerTags":
             suggest = "resource_manager_tags"
 
@@ -8723,13 +8793,18 @@ class ClusterNodePoolAutoConfig(dict):
 
     def __init__(__self__, *,
                  network_tags: Optional['outputs.ClusterNodePoolAutoConfigNetworkTags'] = None,
+                 node_kubelet_config: Optional['outputs.ClusterNodePoolAutoConfigNodeKubeletConfig'] = None,
                  resource_manager_tags: Optional[Mapping[str, str]] = None):
         """
-        :param 'ClusterNodePoolAutoConfigNetworkTagsArgs' network_tags: The network tag config for the cluster's automatically provisioned node pools.
+        :param 'ClusterNodePoolAutoConfigNetworkTagsArgs' network_tags: The network tag config for the cluster's automatically provisioned node pools. Structure is documented below.
+        :param 'ClusterNodePoolAutoConfigNodeKubeletConfigArgs' node_kubelet_config: Kubelet configuration for Autopilot clusters. Currently, only `insecure_kubelet_readonly_port_enabled` is supported here.
+               Structure is documented below.
         :param Mapping[str, str] resource_manager_tags: A map of resource manager tag keys and values to be attached to the nodes for managing Compute Engine firewalls using Network Firewall Policies. Tags must be according to specifications found [here](https://cloud.google.com/vpc/docs/tags-firewalls-overview#specifications). A maximum of 5 tag key-value pairs can be specified. Existing tags will be replaced with new values. Tags must be in one of the following formats ([KEY]=[VALUE]) 1. `tagKeys/{tag_key_id}=tagValues/{tag_value_id}` 2. `{org_id}/{tag_key_name}={tag_value_name}` 3. `{project_id}/{tag_key_name}={tag_value_name}`.
         """
         if network_tags is not None:
             pulumi.set(__self__, "network_tags", network_tags)
+        if node_kubelet_config is not None:
+            pulumi.set(__self__, "node_kubelet_config", node_kubelet_config)
         if resource_manager_tags is not None:
             pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
 
@@ -8737,10 +8812,19 @@ class ClusterNodePoolAutoConfig(dict):
     @pulumi.getter(name="networkTags")
     def network_tags(self) -> Optional['outputs.ClusterNodePoolAutoConfigNetworkTags']:
         """
-        The network tag config for the cluster's automatically provisioned node pools.
+        The network tag config for the cluster's automatically provisioned node pools. Structure is documented below.
         """
         return pulumi.get(self, "network_tags")
 
+    @property
+    @pulumi.getter(name="nodeKubeletConfig")
+    def node_kubelet_config(self) -> Optional['outputs.ClusterNodePoolAutoConfigNodeKubeletConfig']:
+        """
+        Kubelet configuration for Autopilot clusters. Currently, only `insecure_kubelet_readonly_port_enabled` is supported here.
+        Structure is documented below.
+        """
+        return pulumi.get(self, "node_kubelet_config")
+
     @property
     @pulumi.getter(name="resourceManagerTags")
     def resource_manager_tags(self) -> Optional[Mapping[str, str]]:
@@ -8769,6 +8853,42 @@ class ClusterNodePoolAutoConfigNetworkTags(dict):
         return pulumi.get(self, "tags")
 
 
+@pulumi.output_type
+class ClusterNodePoolAutoConfigNodeKubeletConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "insecureKubeletReadonlyPortEnabled":
+            suggest = "insecure_kubelet_readonly_port_enabled"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ClusterNodePoolAutoConfigNodeKubeletConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ClusterNodePoolAutoConfigNodeKubeletConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ClusterNodePoolAutoConfigNodeKubeletConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 insecure_kubelet_readonly_port_enabled: Optional[str] = None):
+        """
+        :param 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`.
+        """
+        if insecure_kubelet_readonly_port_enabled is not None:
+            pulumi.set(__self__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
+
+    @property
+    @pulumi.getter(name="insecureKubeletReadonlyPortEnabled")
+    def insecure_kubelet_readonly_port_enabled(self) -> Optional[str]:
+        """
+        Controls whether the kubelet read-only port is enabled. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        """
+        return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
+
+
 @pulumi.output_type
 class ClusterNodePoolAutoscaling(dict):
     @staticmethod
@@ -8906,6 +9026,8 @@ class ClusterNodePoolDefaultsNodeConfigDefaults(dict):
             suggest = "containerd_config"
         elif key == "gcfsConfig":
             suggest = "gcfs_config"
+        elif key == "insecureKubeletReadonlyPortEnabled":
+            suggest = "insecure_kubelet_readonly_port_enabled"
         elif key == "loggingVariant":
             suggest = "logging_variant"
 
@@ -8923,16 +9045,20 @@ class ClusterNodePoolDefaultsNodeConfigDefaults(dict):
     def __init__(__self__, *,
                  containerd_config: Optional['outputs.ClusterNodePoolDefaultsNodeConfigDefaultsContainerdConfig'] = None,
                  gcfs_config: Optional['outputs.ClusterNodePoolDefaultsNodeConfigDefaultsGcfsConfig'] = None,
+                 insecure_kubelet_readonly_port_enabled: Optional[str] = None,
                  logging_variant: Optional[str] = None):
         """
         :param 'ClusterNodePoolDefaultsNodeConfigDefaultsContainerdConfigArgs' containerd_config: Parameters for containerd configuration.
         :param 'ClusterNodePoolDefaultsNodeConfigDefaultsGcfsConfigArgs' gcfs_config: The default Google Container Filesystem (GCFS) configuration at the cluster level. e.g. enable [image streaming](https://cloud.google.com/kubernetes-engine/docs/how-to/image-streaming) across all the node pools within the cluster. Structure is documented below.
+        :param str insecure_kubelet_readonly_port_enabled: Controls whether the kubelet read-only port is enabled for newly created node pools in the cluster. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
         :param str logging_variant: The type of logging agent that is deployed by default for newly created node pools in the cluster. Valid values include DEFAULT and MAX_THROUGHPUT. See [Increasing logging agent throughput](https://cloud.google.com/stackdriver/docs/solutions/gke/managing-logs#throughput) for more information.
         """
         if containerd_config is not None:
             pulumi.set(__self__, "containerd_config", containerd_config)
         if gcfs_config is not None:
             pulumi.set(__self__, "gcfs_config", gcfs_config)
+        if insecure_kubelet_readonly_port_enabled is not None:
+            pulumi.set(__self__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
         if logging_variant is not None:
             pulumi.set(__self__, "logging_variant", logging_variant)
 
@@ -8952,6 +9078,14 @@ class ClusterNodePoolDefaultsNodeConfigDefaults(dict):
         """
         return pulumi.get(self, "gcfs_config")
 
+    @property
+    @pulumi.getter(name="insecureKubeletReadonlyPortEnabled")
+    def insecure_kubelet_readonly_port_enabled(self) -> Optional[str]:
+        """
+        Controls whether the kubelet read-only port is enabled for newly created node pools in the cluster. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        """
+        return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
+
     @property
     @pulumi.getter(name="loggingVariant")
     def logging_variant(self) -> Optional[str]:
@@ -9558,6 +9692,8 @@ class ClusterNodePoolNodeConfig(dict):
             suggest = "shielded_instance_config"
         elif key == "soleTenantConfig":
             suggest = "sole_tenant_config"
+        elif key == "storagePools":
+            suggest = "storage_pools"
         elif key == "workloadMetadataConfig":
             suggest = "workload_metadata_config"
 
@@ -9610,6 +9746,7 @@ class ClusterNodePoolNodeConfig(dict):
                  shielded_instance_config: Optional['outputs.ClusterNodePoolNodeConfigShieldedInstanceConfig'] = None,
                  sole_tenant_config: Optional['outputs.ClusterNodePoolNodeConfigSoleTenantConfig'] = None,
                  spot: Optional[bool] = None,
+                 storage_pools: Optional[Sequence[str]] = None,
                  tags: Optional[Sequence[str]] = None,
                  taints: Optional[Sequence['outputs.ClusterNodePoolNodeConfigTaint']] = None,
                  workload_metadata_config: Optional['outputs.ClusterNodePoolNodeConfigWorkloadMetadataConfig'] = None):
@@ -9700,6 +9837,7 @@ class ClusterNodePoolNodeConfig(dict):
         :param 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.
+        :param Sequence[str] storage_pools: The list of Storage Pools where boot disks are provisioned.
         :param Sequence[str] tags: The list of instance tags applied to all nodes. Tags are used to identify
                valid sources or targets for network firewalls.
         :param Sequence['ClusterNodePoolNodeConfigTaintArgs'] taints: A list of [Kubernetes taints](https://kubernetes.io/docs/concepts/configuration/taint-and-toleration/)
@@ -9787,6 +9925,8 @@ class ClusterNodePoolNodeConfig(dict):
             pulumi.set(__self__, "sole_tenant_config", sole_tenant_config)
         if spot is not None:
             pulumi.set(__self__, "spot", spot)
+        if storage_pools is not None:
+            pulumi.set(__self__, "storage_pools", storage_pools)
         if tags is not None:
             pulumi.set(__self__, "tags", tags)
         if taints is not None:
@@ -10139,6 +10279,14 @@ class ClusterNodePoolNodeConfig(dict):
         """
         return pulumi.get(self, "spot")
 
+    @property
+    @pulumi.getter(name="storagePools")
+    def storage_pools(self) -> Optional[Sequence[str]]:
+        """
+        The list of Storage Pools where boot disks are provisioned.
+        """
+        return pulumi.get(self, "storage_pools")
+
     @property
     @pulumi.getter
     def tags(self) -> Optional[Sequence[str]]:
@@ -10804,6 +10952,8 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
             suggest = "cpu_cfs_quota"
         elif key == "cpuCfsQuotaPeriod":
             suggest = "cpu_cfs_quota_period"
+        elif key == "insecureKubeletReadonlyPortEnabled":
+            suggest = "insecure_kubelet_readonly_port_enabled"
         elif key == "podPidsLimit":
             suggest = "pod_pids_limit"
 
@@ -10822,6 +10972,7 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
                  cpu_manager_policy: str,
                  cpu_cfs_quota: Optional[bool] = None,
                  cpu_cfs_quota_period: Optional[str] = None,
+                 insecure_kubelet_readonly_port_enabled: Optional[str] = None,
                  pod_pids_limit: Optional[int] = None):
         """
         :param str cpu_manager_policy: The CPU management policy on the node. See
@@ -10838,6 +10989,7 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
                value and accepts an invalid `default` value instead. While this remains true,
                not specifying the `kubelet_config` block should be the equivalent of specifying
                `none`.
+        :param 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 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.
         """
         pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
@@ -10845,6 +10997,8 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
             pulumi.set(__self__, "cpu_cfs_quota", cpu_cfs_quota)
         if cpu_cfs_quota_period is not None:
             pulumi.set(__self__, "cpu_cfs_quota_period", cpu_cfs_quota_period)
+        if insecure_kubelet_readonly_port_enabled is not None:
+            pulumi.set(__self__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
         if pod_pids_limit is not None:
             pulumi.set(__self__, "pod_pids_limit", pod_pids_limit)
 
@@ -10883,6 +11037,14 @@ class ClusterNodePoolNodeConfigKubeletConfig(dict):
         """
         return pulumi.get(self, "cpu_cfs_quota_period")
 
+    @property
+    @pulumi.getter(name="insecureKubeletReadonlyPortEnabled")
+    def insecure_kubelet_readonly_port_enabled(self) -> Optional[str]:
+        """
+        Controls whether the kubelet read-only port is enabled. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        """
+        return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
+
     @property
     @pulumi.getter(name="podPidsLimit")
     def pod_pids_limit(self) -> Optional[int]:
@@ -12900,6 +13062,8 @@ class NodePoolNodeConfig(dict):
             suggest = "shielded_instance_config"
         elif key == "soleTenantConfig":
             suggest = "sole_tenant_config"
+        elif key == "storagePools":
+            suggest = "storage_pools"
         elif key == "workloadMetadataConfig":
             suggest = "workload_metadata_config"
 
@@ -12952,6 +13116,7 @@ class NodePoolNodeConfig(dict):
                  shielded_instance_config: Optional['outputs.NodePoolNodeConfigShieldedInstanceConfig'] = None,
                  sole_tenant_config: Optional['outputs.NodePoolNodeConfigSoleTenantConfig'] = None,
                  spot: Optional[bool] = None,
+                 storage_pools: Optional[Sequence[str]] = None,
                  tags: Optional[Sequence[str]] = None,
                  taints: Optional[Sequence['outputs.NodePoolNodeConfigTaint']] = None,
                  workload_metadata_config: Optional['outputs.NodePoolNodeConfigWorkloadMetadataConfig'] = None):
@@ -12996,6 +13161,7 @@ class NodePoolNodeConfig(dict):
         :param 'NodePoolNodeConfigShieldedInstanceConfigArgs' shielded_instance_config: Shielded Instance options.
         :param 'NodePoolNodeConfigSoleTenantConfigArgs' sole_tenant_config: Node affinity options for sole tenant node pools.
         :param bool spot: Whether the nodes are created as spot VM instances.
+        :param Sequence[str] storage_pools: The list of Storage Pools where boot disks are provisioned.
         :param Sequence[str] tags: The list of instance tags applied to all nodes.
         :param Sequence['NodePoolNodeConfigTaintArgs'] taints: List of Kubernetes taints to be applied to each node.
         :param 'NodePoolNodeConfigWorkloadMetadataConfigArgs' workload_metadata_config: The workload metadata configuration for this node.
@@ -13074,6 +13240,8 @@ class NodePoolNodeConfig(dict):
             pulumi.set(__self__, "sole_tenant_config", sole_tenant_config)
         if spot is not None:
             pulumi.set(__self__, "spot", spot)
+        if storage_pools is not None:
+            pulumi.set(__self__, "storage_pools", storage_pools)
         if tags is not None:
             pulumi.set(__self__, "tags", tags)
         if taints is not None:
@@ -13380,6 +13548,14 @@ class NodePoolNodeConfig(dict):
         """
         return pulumi.get(self, "spot")
 
+    @property
+    @pulumi.getter(name="storagePools")
+    def storage_pools(self) -> Optional[Sequence[str]]:
+        """
+        The list of Storage Pools where boot disks are provisioned.
+        """
+        return pulumi.get(self, "storage_pools")
+
     @property
     @pulumi.getter
     def tags(self) -> Optional[Sequence[str]]:
@@ -14018,6 +14194,8 @@ class NodePoolNodeConfigKubeletConfig(dict):
             suggest = "cpu_cfs_quota"
         elif key == "cpuCfsQuotaPeriod":
             suggest = "cpu_cfs_quota_period"
+        elif key == "insecureKubeletReadonlyPortEnabled":
+            suggest = "insecure_kubelet_readonly_port_enabled"
         elif key == "podPidsLimit":
             suggest = "pod_pids_limit"
 
@@ -14036,11 +14214,13 @@ class NodePoolNodeConfigKubeletConfig(dict):
                  cpu_manager_policy: str,
                  cpu_cfs_quota: Optional[bool] = None,
                  cpu_cfs_quota_period: Optional[str] = None,
+                 insecure_kubelet_readonly_port_enabled: Optional[str] = None,
                  pod_pids_limit: Optional[int] = None):
         """
         :param str cpu_manager_policy: Control the CPU management policy on the node.
         :param bool cpu_cfs_quota: Enable CPU CFS quota enforcement for containers that specify CPU limits.
         :param str cpu_cfs_quota_period: Set the CPU CFS quota period value 'cpu.cfs_period_us'.
+        :param 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 int pod_pids_limit: Controls the maximum number of processes allowed to run in a pod.
         """
         pulumi.set(__self__, "cpu_manager_policy", cpu_manager_policy)
@@ -14048,6 +14228,8 @@ class NodePoolNodeConfigKubeletConfig(dict):
             pulumi.set(__self__, "cpu_cfs_quota", cpu_cfs_quota)
         if cpu_cfs_quota_period is not None:
             pulumi.set(__self__, "cpu_cfs_quota_period", cpu_cfs_quota_period)
+        if insecure_kubelet_readonly_port_enabled is not None:
+            pulumi.set(__self__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
         if pod_pids_limit is not None:
             pulumi.set(__self__, "pod_pids_limit", pod_pids_limit)
 
@@ -14075,6 +14257,14 @@ class NodePoolNodeConfigKubeletConfig(dict):
         """
         return pulumi.get(self, "cpu_cfs_quota_period")
 
+    @property
+    @pulumi.getter(name="insecureKubeletReadonlyPortEnabled")
+    def insecure_kubelet_readonly_port_enabled(self) -> Optional[str]:
+        """
+        Controls whether the kubelet read-only port is enabled. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        """
+        return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
+
     @property
     @pulumi.getter(name="podPidsLimit")
     def pod_pids_limit(self) -> Optional[int]:
@@ -16533,6 +16723,7 @@ class GetClusterNodeConfigResult(dict):
                  shielded_instance_configs: Sequence['outputs.GetClusterNodeConfigShieldedInstanceConfigResult'],
                  sole_tenant_configs: Sequence['outputs.GetClusterNodeConfigSoleTenantConfigResult'],
                  spot: bool,
+                 storage_pools: Sequence[str],
                  tags: Sequence[str],
                  taints: Sequence['outputs.GetClusterNodeConfigTaintResult'],
                  workload_metadata_configs: Sequence['outputs.GetClusterNodeConfigWorkloadMetadataConfigResult']):
@@ -16574,6 +16765,7 @@ class GetClusterNodeConfigResult(dict):
         :param Sequence['GetClusterNodeConfigShieldedInstanceConfigArgs'] shielded_instance_configs: Shielded Instance options.
         :param Sequence['GetClusterNodeConfigSoleTenantConfigArgs'] sole_tenant_configs: Node affinity options for sole tenant node pools.
         :param bool spot: Whether the nodes are created as spot VM instances.
+        :param Sequence[str] storage_pools: The list of Storage Pools where boot disks are provisioned.
         :param Sequence[str] tags: The list of instance tags applied to all nodes.
         :param Sequence['GetClusterNodeConfigTaintArgs'] taints: List of Kubernetes taints to be applied to each node.
         :param Sequence['GetClusterNodeConfigWorkloadMetadataConfigArgs'] workload_metadata_configs: The workload metadata configuration for this node.
@@ -16615,6 +16807,7 @@ class GetClusterNodeConfigResult(dict):
         pulumi.set(__self__, "shielded_instance_configs", shielded_instance_configs)
         pulumi.set(__self__, "sole_tenant_configs", sole_tenant_configs)
         pulumi.set(__self__, "spot", spot)
+        pulumi.set(__self__, "storage_pools", storage_pools)
         pulumi.set(__self__, "tags", tags)
         pulumi.set(__self__, "taints", taints)
         pulumi.set(__self__, "workload_metadata_configs", workload_metadata_configs)
@@ -16915,6 +17108,14 @@ class GetClusterNodeConfigResult(dict):
         """
         return pulumi.get(self, "spot")
 
+    @property
+    @pulumi.getter(name="storagePools")
+    def storage_pools(self) -> Sequence[str]:
+        """
+        The list of Storage Pools where boot disks are provisioned.
+        """
+        return pulumi.get(self, "storage_pools")
+
     @property
     @pulumi.getter
     def tags(self) -> Sequence[str]:
@@ -17344,16 +17545,19 @@ class GetClusterNodeConfigKubeletConfigResult(dict):
                  cpu_cfs_quota: bool,
                  cpu_cfs_quota_period: str,
                  cpu_manager_policy: str,
+                 insecure_kubelet_readonly_port_enabled: str,
                  pod_pids_limit: int):
         """
         :param bool cpu_cfs_quota: Enable CPU CFS quota enforcement for containers that specify CPU limits.
         :param str cpu_cfs_quota_period: Set the CPU CFS quota period value 'cpu.cfs_period_us'.
         :param str cpu_manager_policy: Control the CPU management policy on the node.
+        :param 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 int pod_pids_limit: Controls the maximum number of processes allowed to run in a pod.
         """
         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__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
         pulumi.set(__self__, "pod_pids_limit", pod_pids_limit)
 
     @property
@@ -17380,6 +17584,14 @@ class GetClusterNodeConfigKubeletConfigResult(dict):
         """
         return pulumi.get(self, "cpu_manager_policy")
 
+    @property
+    @pulumi.getter(name="insecureKubeletReadonlyPortEnabled")
+    def insecure_kubelet_readonly_port_enabled(self) -> str:
+        """
+        Controls whether the kubelet read-only port is enabled. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        """
+        return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
+
     @property
     @pulumi.getter(name="podPidsLimit")
     def pod_pids_limit(self) -> int:
@@ -17851,12 +18063,15 @@ class GetClusterNodePoolResult(dict):
 class GetClusterNodePoolAutoConfigResult(dict):
     def __init__(__self__, *,
                  network_tags: Sequence['outputs.GetClusterNodePoolAutoConfigNetworkTagResult'],
+                 node_kubelet_configs: Sequence['outputs.GetClusterNodePoolAutoConfigNodeKubeletConfigResult'],
                  resource_manager_tags: Mapping[str, str]):
         """
         :param Sequence['GetClusterNodePoolAutoConfigNetworkTagArgs'] network_tags: Collection of Compute Engine network tags that can be applied to a node's underlying VM instance.
+        :param Sequence['GetClusterNodePoolAutoConfigNodeKubeletConfigArgs'] node_kubelet_configs: Node kubelet configs.
         :param Mapping[str, 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.
         """
         pulumi.set(__self__, "network_tags", network_tags)
+        pulumi.set(__self__, "node_kubelet_configs", node_kubelet_configs)
         pulumi.set(__self__, "resource_manager_tags", resource_manager_tags)
 
     @property
@@ -17867,6 +18082,14 @@ class GetClusterNodePoolAutoConfigResult(dict):
         """
         return pulumi.get(self, "network_tags")
 
+    @property
+    @pulumi.getter(name="nodeKubeletConfigs")
+    def node_kubelet_configs(self) -> Sequence['outputs.GetClusterNodePoolAutoConfigNodeKubeletConfigResult']:
+        """
+        Node kubelet configs.
+        """
+        return pulumi.get(self, "node_kubelet_configs")
+
     @property
     @pulumi.getter(name="resourceManagerTags")
     def resource_manager_tags(self) -> Mapping[str, str]:
@@ -17894,6 +18117,24 @@ class GetClusterNodePoolAutoConfigNetworkTagResult(dict):
         return pulumi.get(self, "tags")
 
 
+@pulumi.output_type
+class GetClusterNodePoolAutoConfigNodeKubeletConfigResult(dict):
+    def __init__(__self__, *,
+                 insecure_kubelet_readonly_port_enabled: str):
+        """
+        :param 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`.
+        """
+        pulumi.set(__self__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
+
+    @property
+    @pulumi.getter(name="insecureKubeletReadonlyPortEnabled")
+    def insecure_kubelet_readonly_port_enabled(self) -> str:
+        """
+        Controls whether the kubelet read-only port is enabled. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        """
+        return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
+
+
 @pulumi.output_type
 class GetClusterNodePoolAutoscalingResult(dict):
     def __init__(__self__, *,
@@ -17979,14 +18220,17 @@ class GetClusterNodePoolDefaultNodeConfigDefaultResult(dict):
     def __init__(__self__, *,
                  containerd_configs: Sequence['outputs.GetClusterNodePoolDefaultNodeConfigDefaultContainerdConfigResult'],
                  gcfs_configs: Sequence['outputs.GetClusterNodePoolDefaultNodeConfigDefaultGcfsConfigResult'],
+                 insecure_kubelet_readonly_port_enabled: str,
                  logging_variant: str):
         """
         :param Sequence['GetClusterNodePoolDefaultNodeConfigDefaultContainerdConfigArgs'] containerd_configs: Parameters for containerd configuration.
         :param Sequence['GetClusterNodePoolDefaultNodeConfigDefaultGcfsConfigArgs'] gcfs_configs: GCFS configuration for this node.
+        :param 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 str logging_variant: Type of logging agent that is used as the default value for node pools in the cluster. Valid values include DEFAULT and MAX_THROUGHPUT.
         """
         pulumi.set(__self__, "containerd_configs", containerd_configs)
         pulumi.set(__self__, "gcfs_configs", gcfs_configs)
+        pulumi.set(__self__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
         pulumi.set(__self__, "logging_variant", logging_variant)
 
     @property
@@ -18005,6 +18249,14 @@ class GetClusterNodePoolDefaultNodeConfigDefaultResult(dict):
         """
         return pulumi.get(self, "gcfs_configs")
 
+    @property
+    @pulumi.getter(name="insecureKubeletReadonlyPortEnabled")
+    def insecure_kubelet_readonly_port_enabled(self) -> str:
+        """
+        Controls whether the kubelet read-only port is enabled. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        """
+        return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
+
     @property
     @pulumi.getter(name="loggingVariant")
     def logging_variant(self) -> str:
@@ -18389,6 +18641,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
                  shielded_instance_configs: Sequence['outputs.GetClusterNodePoolNodeConfigShieldedInstanceConfigResult'],
                  sole_tenant_configs: Sequence['outputs.GetClusterNodePoolNodeConfigSoleTenantConfigResult'],
                  spot: bool,
+                 storage_pools: Sequence[str],
                  tags: Sequence[str],
                  taints: Sequence['outputs.GetClusterNodePoolNodeConfigTaintResult'],
                  workload_metadata_configs: Sequence['outputs.GetClusterNodePoolNodeConfigWorkloadMetadataConfigResult']):
@@ -18430,6 +18683,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
         :param Sequence['GetClusterNodePoolNodeConfigShieldedInstanceConfigArgs'] shielded_instance_configs: Shielded Instance options.
         :param Sequence['GetClusterNodePoolNodeConfigSoleTenantConfigArgs'] sole_tenant_configs: Node affinity options for sole tenant node pools.
         :param bool spot: Whether the nodes are created as spot VM instances.
+        :param Sequence[str] storage_pools: The list of Storage Pools where boot disks are provisioned.
         :param Sequence[str] tags: The list of instance tags applied to all nodes.
         :param Sequence['GetClusterNodePoolNodeConfigTaintArgs'] taints: List of Kubernetes taints to be applied to each node.
         :param Sequence['GetClusterNodePoolNodeConfigWorkloadMetadataConfigArgs'] workload_metadata_configs: The workload metadata configuration for this node.
@@ -18471,6 +18725,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
         pulumi.set(__self__, "shielded_instance_configs", shielded_instance_configs)
         pulumi.set(__self__, "sole_tenant_configs", sole_tenant_configs)
         pulumi.set(__self__, "spot", spot)
+        pulumi.set(__self__, "storage_pools", storage_pools)
         pulumi.set(__self__, "tags", tags)
         pulumi.set(__self__, "taints", taints)
         pulumi.set(__self__, "workload_metadata_configs", workload_metadata_configs)
@@ -18771,6 +19026,14 @@ class GetClusterNodePoolNodeConfigResult(dict):
         """
         return pulumi.get(self, "spot")
 
+    @property
+    @pulumi.getter(name="storagePools")
+    def storage_pools(self) -> Sequence[str]:
+        """
+        The list of Storage Pools where boot disks are provisioned.
+        """
+        return pulumi.get(self, "storage_pools")
+
     @property
     @pulumi.getter
     def tags(self) -> Sequence[str]:
@@ -19200,16 +19463,19 @@ class GetClusterNodePoolNodeConfigKubeletConfigResult(dict):
                  cpu_cfs_quota: bool,
                  cpu_cfs_quota_period: str,
                  cpu_manager_policy: str,
+                 insecure_kubelet_readonly_port_enabled: str,
                  pod_pids_limit: int):
         """
         :param bool cpu_cfs_quota: Enable CPU CFS quota enforcement for containers that specify CPU limits.
         :param str cpu_cfs_quota_period: Set the CPU CFS quota period value 'cpu.cfs_period_us'.
         :param str cpu_manager_policy: Control the CPU management policy on the node.
+        :param 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 int pod_pids_limit: Controls the maximum number of processes allowed to run in a pod.
         """
         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__, "insecure_kubelet_readonly_port_enabled", insecure_kubelet_readonly_port_enabled)
         pulumi.set(__self__, "pod_pids_limit", pod_pids_limit)
 
     @property
@@ -19236,6 +19502,14 @@ class GetClusterNodePoolNodeConfigKubeletConfigResult(dict):
         """
         return pulumi.get(self, "cpu_manager_policy")
 
+    @property
+    @pulumi.getter(name="insecureKubeletReadonlyPortEnabled")
+    def insecure_kubelet_readonly_port_enabled(self) -> str:
+        """
+        Controls whether the kubelet read-only port is enabled. It is strongly recommended to set this to `FALSE`. Possible values: `TRUE`, `FALSE`.
+        """
+        return pulumi.get(self, "insecure_kubelet_readonly_port_enabled")
+
     @property
     @pulumi.getter(name="podPidsLimit")
     def pod_pids_limit(self) -> int: