pulumi-gcp 8.17.0a1738274430__py3-none-any.whl → 8.18.0__py3-none-any.whl

pulumi_gcp/container/_inputs.py

@@ -6398,16 +6398,16 @@ class ClusterClusterAutoscalingAutoProvisioningDefaultsUpgradeSettingsBlueGreenS
 
 if not MYPY:
     class ClusterClusterAutoscalingResourceLimitArgsDict(TypedDict):
+        maximum: pulumi.Input[int]
+        """
+        Maximum amount of the resource in the cluster.
+        """
         resource_type: pulumi.Input[str]
         """
         The type of the resource. For example, `cpu` and
         `memory`.  See the [guide to using Node Auto-Provisioning](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning)
         for a list of types.
         """
-        maximum: NotRequired[pulumi.Input[int]]
-        """
-        Maximum amount of the resource in the cluster.
-        """
         minimum: NotRequired[pulumi.Input[int]]
         """
         Minimum amount of the resource in the cluster.
@@ -6418,22 +6418,33 @@ elif False:
 @pulumi.input_type
 class ClusterClusterAutoscalingResourceLimitArgs:
     def __init__(__self__, *,
+                 maximum: pulumi.Input[int],
                  resource_type: pulumi.Input[str],
-                 maximum: Optional[pulumi.Input[int]] = None,
                  minimum: Optional[pulumi.Input[int]] = None):
         """
+        :param pulumi.Input[int] maximum: Maximum amount of the resource in the cluster.
         :param pulumi.Input[str] resource_type: The type of the resource. For example, `cpu` and
                `memory`.  See the [guide to using Node Auto-Provisioning](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning)
                for a list of types.
-        :param pulumi.Input[int] maximum: Maximum amount of the resource in the cluster.
         :param pulumi.Input[int] minimum: Minimum amount of the resource in the cluster.
         """
+        pulumi.set(__self__, "maximum", maximum)
         pulumi.set(__self__, "resource_type", resource_type)
-        if maximum is not None:
-            pulumi.set(__self__, "maximum", maximum)
         if minimum is not None:
             pulumi.set(__self__, "minimum", minimum)
 
+    @property
+    @pulumi.getter
+    def maximum(self) -> pulumi.Input[int]:
+        """
+        Maximum amount of the resource in the cluster.
+        """
+        return pulumi.get(self, "maximum")
+
+    @maximum.setter
+    def maximum(self, value: pulumi.Input[int]):
+        pulumi.set(self, "maximum", value)
+
     @property
     @pulumi.getter(name="resourceType")
     def resource_type(self) -> pulumi.Input[str]:
@@ -6448,18 +6459,6 @@ class ClusterClusterAutoscalingResourceLimitArgs:
     def resource_type(self, value: pulumi.Input[str]):
         pulumi.set(self, "resource_type", value)
 
-    @property
-    @pulumi.getter
-    def maximum(self) -> Optional[pulumi.Input[int]]:
-        """
-        Maximum amount of the resource in the cluster.
-        """
-        return pulumi.get(self, "maximum")
-
-    @maximum.setter
-    def maximum(self, value: Optional[pulumi.Input[int]]):
-        pulumi.set(self, "maximum", value)
-
     @property
     @pulumi.getter
     def minimum(self) -> Optional[pulumi.Input[int]]:
@@ -8491,6 +8490,10 @@ if not MYPY:
         Defaults to `e2-medium`. To create a custom machine type, value should be set as specified
         [here](https://cloud.google.com/compute/docs/reference/latest/instances#machineType).
         """
+        max_run_duration: NotRequired[pulumi.Input[str]]
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
         metadata: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
         """
         The metadata key/value pairs assigned to instances in
@@ -8620,6 +8623,7 @@ class ClusterNodeConfigArgs:
                  local_ssd_encryption_mode: Optional[pulumi.Input[str]] = None,
                  logging_variant: Optional[pulumi.Input[str]] = None,
                  machine_type: Optional[pulumi.Input[str]] = None,
+                 max_run_duration: Optional[pulumi.Input[str]] = None,
                  metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  min_cpu_platform: Optional[pulumi.Input[str]] = None,
                  node_group: Optional[pulumi.Input[str]] = None,
@@ -8697,6 +8701,7 @@ class ClusterNodeConfigArgs:
         :param pulumi.Input[str] machine_type: The name of a Google Compute Engine machine type.
                Defaults to `e2-medium`. To create a custom machine type, value should be set as specified
                [here](https://cloud.google.com/compute/docs/reference/latest/instances#machineType).
+        :param pulumi.Input[str] max_run_duration: The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: The metadata key/value pairs assigned to instances in
                the cluster. From GKE `1.12` onwards, `disable-legacy-endpoints` is set to
                `true` by the API; if `metadata` is set but that default value is not
@@ -8791,6 +8796,8 @@ class ClusterNodeConfigArgs:
             pulumi.set(__self__, "logging_variant", logging_variant)
         if machine_type is not None:
             pulumi.set(__self__, "machine_type", machine_type)
+        if max_run_duration is not None:
+            pulumi.set(__self__, "max_run_duration", max_run_duration)
         if metadata is not None:
             pulumi.set(__self__, "metadata", metadata)
         if min_cpu_platform is not None:
@@ -9150,6 +9157,18 @@ class ClusterNodeConfigArgs:
     def machine_type(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "machine_type", value)
 
+    @property
+    @pulumi.getter(name="maxRunDuration")
+    def max_run_duration(self) -> Optional[pulumi.Input[str]]:
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
+        return pulumi.get(self, "max_run_duration")
+
+    @max_run_duration.setter
+    def max_run_duration(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "max_run_duration", value)
+
     @property
     @pulumi.getter
     def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
@@ -12481,6 +12500,10 @@ if not MYPY:
         Defaults to `e2-medium`. To create a custom machine type, value should be set as specified
         [here](https://cloud.google.com/compute/docs/reference/latest/instances#machineType).
         """
+        max_run_duration: NotRequired[pulumi.Input[str]]
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
         metadata: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
         """
         The metadata key/value pairs assigned to instances in
@@ -12610,6 +12633,7 @@ class ClusterNodePoolNodeConfigArgs:
                  local_ssd_encryption_mode: Optional[pulumi.Input[str]] = None,
                  logging_variant: Optional[pulumi.Input[str]] = None,
                  machine_type: Optional[pulumi.Input[str]] = None,
+                 max_run_duration: Optional[pulumi.Input[str]] = None,
                  metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  min_cpu_platform: Optional[pulumi.Input[str]] = None,
                  node_group: Optional[pulumi.Input[str]] = None,
@@ -12687,6 +12711,7 @@ class ClusterNodePoolNodeConfigArgs:
         :param pulumi.Input[str] machine_type: The name of a Google Compute Engine machine type.
                Defaults to `e2-medium`. To create a custom machine type, value should be set as specified
                [here](https://cloud.google.com/compute/docs/reference/latest/instances#machineType).
+        :param pulumi.Input[str] max_run_duration: The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: The metadata key/value pairs assigned to instances in
                the cluster. From GKE `1.12` onwards, `disable-legacy-endpoints` is set to
                `true` by the API; if `metadata` is set but that default value is not
@@ -12781,6 +12806,8 @@ class ClusterNodePoolNodeConfigArgs:
             pulumi.set(__self__, "logging_variant", logging_variant)
         if machine_type is not None:
             pulumi.set(__self__, "machine_type", machine_type)
+        if max_run_duration is not None:
+            pulumi.set(__self__, "max_run_duration", max_run_duration)
         if metadata is not None:
             pulumi.set(__self__, "metadata", metadata)
         if min_cpu_platform is not None:
@@ -13140,6 +13167,18 @@ class ClusterNodePoolNodeConfigArgs:
     def machine_type(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "machine_type", value)
 
+    @property
+    @pulumi.getter(name="maxRunDuration")
+    def max_run_duration(self) -> Optional[pulumi.Input[str]]:
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
+        return pulumi.get(self, "max_run_duration")
+
+    @max_run_duration.setter
+    def max_run_duration(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "max_run_duration", value)
+
     @property
     @pulumi.getter
     def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:
@@ -16986,6 +17025,10 @@ if not MYPY:
         """
         The name of a Google Compute Engine machine type.
         """
+        max_run_duration: NotRequired[pulumi.Input[str]]
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
         metadata: NotRequired[pulumi.Input[Mapping[str, pulumi.Input[str]]]]
         """
         The metadata key/value pairs assigned to instances in the cluster.
@@ -17091,6 +17134,7 @@ class NodePoolNodeConfigArgs:
                  local_ssd_encryption_mode: Optional[pulumi.Input[str]] = None,
                  logging_variant: Optional[pulumi.Input[str]] = None,
                  machine_type: Optional[pulumi.Input[str]] = None,
+                 max_run_duration: Optional[pulumi.Input[str]] = None,
                  metadata: Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]] = None,
                  min_cpu_platform: Optional[pulumi.Input[str]] = None,
                  node_group: Optional[pulumi.Input[str]] = None,
@@ -17134,6 +17178,7 @@ class NodePoolNodeConfigArgs:
         :param pulumi.Input[str] local_ssd_encryption_mode: LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
         :param pulumi.Input[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.
         :param pulumi.Input[str] machine_type: The name of a Google Compute Engine machine type.
+        :param pulumi.Input[str] max_run_duration: The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
         :param pulumi.Input[Mapping[str, pulumi.Input[str]]] metadata: The metadata key/value pairs assigned to instances in the cluster.
         :param pulumi.Input[str] min_cpu_platform: Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform.
         :param pulumi.Input[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.
@@ -17204,6 +17249,8 @@ class NodePoolNodeConfigArgs:
             pulumi.set(__self__, "logging_variant", logging_variant)
         if machine_type is not None:
             pulumi.set(__self__, "machine_type", machine_type)
+        if max_run_duration is not None:
+            pulumi.set(__self__, "max_run_duration", max_run_duration)
         if metadata is not None:
             pulumi.set(__self__, "metadata", metadata)
         if min_cpu_platform is not None:
@@ -17529,6 +17576,18 @@ class NodePoolNodeConfigArgs:
     def machine_type(self, value: Optional[pulumi.Input[str]]):
         pulumi.set(self, "machine_type", value)
 
+    @property
+    @pulumi.getter(name="maxRunDuration")
+    def max_run_duration(self) -> Optional[pulumi.Input[str]]:
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
+        return pulumi.get(self, "max_run_duration")
+
+    @max_run_duration.setter
+    def max_run_duration(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "max_run_duration", value)
+
     @property
     @pulumi.getter
     def metadata(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[str]]]]:

pulumi_gcp/container/outputs.py

@@ -5287,22 +5287,29 @@ class ClusterClusterAutoscalingResourceLimit(dict):
         return super().get(key, default)
 
     def __init__(__self__, *,
+                 maximum: int,
                  resource_type: str,
-                 maximum: Optional[int] = None,
                  minimum: Optional[int] = None):
         """
+        :param int maximum: Maximum amount of the resource in the cluster.
         :param str resource_type: The type of the resource. For example, `cpu` and
                `memory`.  See the [guide to using Node Auto-Provisioning](https://cloud.google.com/kubernetes-engine/docs/how-to/node-auto-provisioning)
                for a list of types.
-        :param int maximum: Maximum amount of the resource in the cluster.
         :param int minimum: Minimum amount of the resource in the cluster.
         """
+        pulumi.set(__self__, "maximum", maximum)
         pulumi.set(__self__, "resource_type", resource_type)
-        if maximum is not None:
-            pulumi.set(__self__, "maximum", maximum)
         if minimum is not None:
             pulumi.set(__self__, "minimum", minimum)
 
+    @property
+    @pulumi.getter
+    def maximum(self) -> int:
+        """
+        Maximum amount of the resource in the cluster.
+        """
+        return pulumi.get(self, "maximum")
+
     @property
     @pulumi.getter(name="resourceType")
     def resource_type(self) -> str:
@@ -5313,14 +5320,6 @@ class ClusterClusterAutoscalingResourceLimit(dict):
         """
         return pulumi.get(self, "resource_type")
 
-    @property
-    @pulumi.getter
-    def maximum(self) -> Optional[int]:
-        """
-        Maximum amount of the resource in the cluster.
-        """
-        return pulumi.get(self, "maximum")
-
     @property
     @pulumi.getter
     def minimum(self) -> Optional[int]:
@@ -6925,6 +6924,8 @@ class ClusterNodeConfig(dict):
             suggest = "logging_variant"
         elif key == "machineType":
             suggest = "machine_type"
+        elif key == "maxRunDuration":
+            suggest = "max_run_duration"
         elif key == "minCpuPlatform":
             suggest = "min_cpu_platform"
         elif key == "nodeGroup":
@@ -6988,6 +6989,7 @@ class ClusterNodeConfig(dict):
                  local_ssd_encryption_mode: Optional[str] = None,
                  logging_variant: Optional[str] = None,
                  machine_type: Optional[str] = None,
+                 max_run_duration: Optional[str] = None,
                  metadata: Optional[Mapping[str, str]] = None,
                  min_cpu_platform: Optional[str] = None,
                  node_group: Optional[str] = None,
@@ -7065,6 +7067,7 @@ class ClusterNodeConfig(dict):
         :param str machine_type: The name of a Google Compute Engine machine type.
                Defaults to `e2-medium`. To create a custom machine type, value should be set as specified
                [here](https://cloud.google.com/compute/docs/reference/latest/instances#machineType).
+        :param str max_run_duration: The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
         :param Mapping[str, str] metadata: The metadata key/value pairs assigned to instances in
                the cluster. From GKE `1.12` onwards, `disable-legacy-endpoints` is set to
                `true` by the API; if `metadata` is set but that default value is not
@@ -7159,6 +7162,8 @@ class ClusterNodeConfig(dict):
             pulumi.set(__self__, "logging_variant", logging_variant)
         if machine_type is not None:
             pulumi.set(__self__, "machine_type", machine_type)
+        if max_run_duration is not None:
+            pulumi.set(__self__, "max_run_duration", max_run_duration)
         if metadata is not None:
             pulumi.set(__self__, "metadata", metadata)
         if min_cpu_platform is not None:
@@ -7422,6 +7427,14 @@ class ClusterNodeConfig(dict):
         """
         return pulumi.get(self, "machine_type")
 
+    @property
+    @pulumi.getter(name="maxRunDuration")
+    def max_run_duration(self) -> Optional[str]:
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
+        return pulumi.get(self, "max_run_duration")
+
     @property
     @pulumi.getter
     def metadata(self) -> Optional[Mapping[str, str]]:
@@ -10085,6 +10098,8 @@ class ClusterNodePoolNodeConfig(dict):
             suggest = "logging_variant"
         elif key == "machineType":
             suggest = "machine_type"
+        elif key == "maxRunDuration":
+            suggest = "max_run_duration"
         elif key == "minCpuPlatform":
             suggest = "min_cpu_platform"
         elif key == "nodeGroup":
@@ -10148,6 +10163,7 @@ class ClusterNodePoolNodeConfig(dict):
                  local_ssd_encryption_mode: Optional[str] = None,
                  logging_variant: Optional[str] = None,
                  machine_type: Optional[str] = None,
+                 max_run_duration: Optional[str] = None,
                  metadata: Optional[Mapping[str, str]] = None,
                  min_cpu_platform: Optional[str] = None,
                  node_group: Optional[str] = None,
@@ -10225,6 +10241,7 @@ class ClusterNodePoolNodeConfig(dict):
         :param str machine_type: The name of a Google Compute Engine machine type.
                Defaults to `e2-medium`. To create a custom machine type, value should be set as specified
                [here](https://cloud.google.com/compute/docs/reference/latest/instances#machineType).
+        :param str max_run_duration: The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
         :param Mapping[str, str] metadata: The metadata key/value pairs assigned to instances in
                the cluster. From GKE `1.12` onwards, `disable-legacy-endpoints` is set to
                `true` by the API; if `metadata` is set but that default value is not
@@ -10319,6 +10336,8 @@ class ClusterNodePoolNodeConfig(dict):
             pulumi.set(__self__, "logging_variant", logging_variant)
         if machine_type is not None:
             pulumi.set(__self__, "machine_type", machine_type)
+        if max_run_duration is not None:
+            pulumi.set(__self__, "max_run_duration", max_run_duration)
         if metadata is not None:
             pulumi.set(__self__, "metadata", metadata)
         if min_cpu_platform is not None:
@@ -10582,6 +10601,14 @@ class ClusterNodePoolNodeConfig(dict):
         """
         return pulumi.get(self, "machine_type")
 
+    @property
+    @pulumi.getter(name="maxRunDuration")
+    def max_run_duration(self) -> Optional[str]:
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
+        return pulumi.get(self, "max_run_duration")
+
     @property
     @pulumi.getter
     def metadata(self) -> Optional[Mapping[str, str]]:
@@ -13668,6 +13695,8 @@ class NodePoolNodeConfig(dict):
             suggest = "logging_variant"
         elif key == "machineType":
             suggest = "machine_type"
+        elif key == "maxRunDuration":
+            suggest = "max_run_duration"
         elif key == "minCpuPlatform":
             suggest = "min_cpu_platform"
         elif key == "nodeGroup":
@@ -13731,6 +13760,7 @@ class NodePoolNodeConfig(dict):
                  local_ssd_encryption_mode: Optional[str] = None,
                  logging_variant: Optional[str] = None,
                  machine_type: Optional[str] = None,
+                 max_run_duration: Optional[str] = None,
                  metadata: Optional[Mapping[str, str]] = None,
                  min_cpu_platform: Optional[str] = None,
                  node_group: Optional[str] = None,
@@ -13774,6 +13804,7 @@ class NodePoolNodeConfig(dict):
         :param str local_ssd_encryption_mode: LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
         :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.
         :param str machine_type: The name of a Google Compute Engine machine type.
+        :param str max_run_duration: The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
         :param Mapping[str, str] metadata: The metadata key/value pairs assigned to instances in the cluster.
         :param str min_cpu_platform: Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform.
         :param 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.
@@ -13844,6 +13875,8 @@ class NodePoolNodeConfig(dict):
             pulumi.set(__self__, "logging_variant", logging_variant)
         if machine_type is not None:
             pulumi.set(__self__, "machine_type", machine_type)
+        if max_run_duration is not None:
+            pulumi.set(__self__, "max_run_duration", max_run_duration)
         if metadata is not None:
             pulumi.set(__self__, "metadata", metadata)
         if min_cpu_platform is not None:
@@ -14073,6 +14106,14 @@ class NodePoolNodeConfig(dict):
         """
         return pulumi.get(self, "machine_type")
 
+    @property
+    @pulumi.getter(name="maxRunDuration")
+    def max_run_duration(self) -> Optional[str]:
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
+        return pulumi.get(self, "max_run_duration")
+
     @property
     @pulumi.getter
     def metadata(self) -> Optional[Mapping[str, str]]:
@@ -17525,6 +17566,7 @@ class GetClusterNodeConfigResult(dict):
                  local_ssd_encryption_mode: str,
                  logging_variant: str,
                  machine_type: str,
+                 max_run_duration: str,
                  metadata: Mapping[str, str],
                  min_cpu_platform: str,
                  node_group: str,
@@ -17568,6 +17610,7 @@ class GetClusterNodeConfigResult(dict):
         :param str local_ssd_encryption_mode: LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
         :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.
         :param str machine_type: The name of a Google Compute Engine machine type.
+        :param str max_run_duration: The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
         :param Mapping[str, str] metadata: The metadata key/value pairs assigned to instances in the cluster.
         :param str min_cpu_platform: Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform.
         :param 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.
@@ -17611,6 +17654,7 @@ class GetClusterNodeConfigResult(dict):
         pulumi.set(__self__, "local_ssd_encryption_mode", local_ssd_encryption_mode)
         pulumi.set(__self__, "logging_variant", logging_variant)
         pulumi.set(__self__, "machine_type", machine_type)
+        pulumi.set(__self__, "max_run_duration", max_run_duration)
         pulumi.set(__self__, "metadata", metadata)
         pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
         pulumi.set(__self__, "node_group", node_group)
@@ -17822,6 +17866,14 @@ class GetClusterNodeConfigResult(dict):
         """
         return pulumi.get(self, "machine_type")
 
+    @property
+    @pulumi.getter(name="maxRunDuration")
+    def max_run_duration(self) -> str:
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
+        return pulumi.get(self, "max_run_duration")
+
     @property
     @pulumi.getter
     def metadata(self) -> Mapping[str, str]:
@@ -19523,6 +19575,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
                  local_ssd_encryption_mode: str,
                  logging_variant: str,
                  machine_type: str,
+                 max_run_duration: str,
                  metadata: Mapping[str, str],
                  min_cpu_platform: str,
                  node_group: str,
@@ -19566,6 +19619,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
         :param str local_ssd_encryption_mode: LocalSsdEncryptionMode specified the method used for encrypting the local SSDs attached to the node.
         :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.
         :param str machine_type: The name of a Google Compute Engine machine type.
+        :param str max_run_duration: The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
         :param Mapping[str, str] metadata: The metadata key/value pairs assigned to instances in the cluster.
         :param str min_cpu_platform: Minimum CPU platform to be used by this instance. The instance may be scheduled on the specified or newer CPU platform.
         :param 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.
@@ -19609,6 +19663,7 @@ class GetClusterNodePoolNodeConfigResult(dict):
         pulumi.set(__self__, "local_ssd_encryption_mode", local_ssd_encryption_mode)
         pulumi.set(__self__, "logging_variant", logging_variant)
         pulumi.set(__self__, "machine_type", machine_type)
+        pulumi.set(__self__, "max_run_duration", max_run_duration)
         pulumi.set(__self__, "metadata", metadata)
         pulumi.set(__self__, "min_cpu_platform", min_cpu_platform)
         pulumi.set(__self__, "node_group", node_group)
@@ -19820,6 +19875,14 @@ class GetClusterNodePoolNodeConfigResult(dict):
         """
         return pulumi.get(self, "machine_type")
 
+    @property
+    @pulumi.getter(name="maxRunDuration")
+    def max_run_duration(self) -> str:
+        """
+        The runtime of each node in the node pool in seconds, terminated by 's'. Example: "3600s".
+        """
+        return pulumi.get(self, "max_run_duration")
+
     @property
     @pulumi.getter
     def metadata(self) -> Mapping[str, str]:

pulumi_gcp/dataproc/_inputs.py

@@ -243,6 +243,8 @@ __all__ = [
     'MetastoreServiceScheduledBackupArgsDict',
     'MetastoreServiceTelemetryConfigArgs',
     'MetastoreServiceTelemetryConfigArgsDict',
+    'WorkflowTemplateEncryptionConfigArgs',
+    'WorkflowTemplateEncryptionConfigArgsDict',
     'WorkflowTemplateJobArgs',
     'WorkflowTemplateJobArgsDict',
     'WorkflowTemplateJobHadoopJobArgs',
@@ -10187,6 +10189,38 @@ class MetastoreServiceTelemetryConfigArgs:
         pulumi.set(self, "log_format", value)
 
 
+if not MYPY:
+    class WorkflowTemplateEncryptionConfigArgsDict(TypedDict):
+        kms_key: NotRequired[pulumi.Input[str]]
+        """
+        Optional. The Cloud KMS key name to use for encryption.
+        """
+elif False:
+    WorkflowTemplateEncryptionConfigArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class WorkflowTemplateEncryptionConfigArgs:
+    def __init__(__self__, *,
+                 kms_key: Optional[pulumi.Input[str]] = None):
+        """
+        :param pulumi.Input[str] kms_key: Optional. The Cloud KMS key name to use for encryption.
+        """
+        if kms_key is not None:
+            pulumi.set(__self__, "kms_key", kms_key)
+
+    @property
+    @pulumi.getter(name="kmsKey")
+    def kms_key(self) -> Optional[pulumi.Input[str]]:
+        """
+        Optional. The Cloud KMS key name to use for encryption.
+        """
+        return pulumi.get(self, "kms_key")
+
+    @kms_key.setter
+    def kms_key(self, value: Optional[pulumi.Input[str]]):
+        pulumi.set(self, "kms_key", value)
+
+
 if not MYPY:
     class WorkflowTemplateJobArgsDict(TypedDict):
         step_id: pulumi.Input[str]

pulumi_gcp/dataproc/outputs.py

@@ -130,6 +130,7 @@ __all__ = [
     'MetastoreServiceScalingConfigAutoscalingConfigLimitConfig',
     'MetastoreServiceScheduledBackup',
     'MetastoreServiceTelemetryConfig',
+    'WorkflowTemplateEncryptionConfig',
     'WorkflowTemplateJob',
     'WorkflowTemplateJobHadoopJob',
     'WorkflowTemplateJobHadoopJobLoggingConfig',
@@ -8160,6 +8161,42 @@ class MetastoreServiceTelemetryConfig(dict):
         return pulumi.get(self, "log_format")
 
 
+@pulumi.output_type
+class WorkflowTemplateEncryptionConfig(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "kmsKey":
+            suggest = "kms_key"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in WorkflowTemplateEncryptionConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        WorkflowTemplateEncryptionConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        WorkflowTemplateEncryptionConfig.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 kms_key: Optional[str] = None):
+        """
+        :param str kms_key: Optional. The Cloud KMS key name to use for encryption.
+        """
+        if kms_key is not None:
+            pulumi.set(__self__, "kms_key", kms_key)
+
+    @property
+    @pulumi.getter(name="kmsKey")
+    def kms_key(self) -> Optional[str]:
+        """
+        Optional. The Cloud KMS key name to use for encryption.
+        """
+        return pulumi.get(self, "kms_key")
+
+
 @pulumi.output_type
 class WorkflowTemplateJob(dict):
     @staticmethod