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

pulumi_gcp/container/outputs.py

@@ -170,7 +170,6 @@ __all__ = [
     'ClusterNodePool',
     'ClusterNodePoolAutoConfig',
     'ClusterNodePoolAutoConfigNetworkTags',
-    'ClusterNodePoolAutoConfigNodeKubeletConfig',
     'ClusterNodePoolAutoscaling',
     'ClusterNodePoolDefaults',
     'ClusterNodePoolDefaultsNodeConfigDefaults',
@@ -363,7 +362,6 @@ __all__ = [
     'GetClusterNodePoolResult',
     'GetClusterNodePoolAutoConfigResult',
     'GetClusterNodePoolAutoConfigNetworkTagResult',
-    'GetClusterNodePoolAutoConfigNodeKubeletConfigResult',
     'GetClusterNodePoolAutoscalingResult',
     'GetClusterNodePoolDefaultResult',
     'GetClusterNodePoolDefaultNodeConfigDefaultResult',
@@ -7877,8 +7875,6 @@ 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"
 
@@ -7897,7 +7893,6 @@ 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
@@ -7914,7 +7909,6 @@ 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)
@@ -7922,8 +7916,6 @@ 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)
 
@@ -7962,14 +7954,6 @@ 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]:
@@ -8723,8 +8707,6 @@ 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"
 
@@ -8741,18 +8723,13 @@ 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. 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 'ClusterNodePoolAutoConfigNetworkTagsArgs' network_tags: The network tag config for the cluster's automatically provisioned node pools.
         :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)
 
@@ -8760,19 +8737,10 @@ 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. Structure is documented below.
+        The network tag config for the cluster's automatically provisioned node pools.
         """
         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]]:
@@ -8801,42 +8769,6 @@ 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
@@ -8974,8 +8906,6 @@ 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"
 
@@ -8993,20 +8923,16 @@ 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)
 
@@ -9026,14 +8952,6 @@ 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]:
@@ -10886,8 +10804,6 @@ 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"
 
@@ -10906,7 +10822,6 @@ 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
@@ -10923,7 +10838,6 @@ 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)
@@ -10931,8 +10845,6 @@ 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)
 
@@ -10971,14 +10883,6 @@ 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]:
@@ -14114,8 +14018,6 @@ 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"
 
@@ -14134,13 +14036,11 @@ 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)
@@ -14148,8 +14048,6 @@ 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)
 
@@ -14177,14 +14075,6 @@ 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]:
@@ -17454,19 +17344,16 @@ 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
@@ -17493,14 +17380,6 @@ 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:
@@ -17972,15 +17851,12 @@ 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
@@ -17991,14 +17867,6 @@ 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]:
@@ -18026,24 +17894,6 @@ 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__, *,
@@ -18129,17 +17979,14 @@ 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
@@ -18158,14 +18005,6 @@ 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:
@@ -19361,19 +19200,16 @@ 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
@@ -19400,14 +19236,6 @@ 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: