pulumi-aws-native 1.38.0a1761803003__py3-none-any.whl → 1.38.0a1762272920__py3-none-any.whl

pulumi_aws_native/eks/_inputs.py

@@ -72,6 +72,8 @@ __all__ = [
     'NamespaceConfigPropertiesArgsDict',
     'NodegroupLaunchTemplateSpecificationArgs',
     'NodegroupLaunchTemplateSpecificationArgsDict',
+    'NodegroupNodeRepairConfigOverridesArgs',
+    'NodegroupNodeRepairConfigOverridesArgsDict',
     'NodegroupNodeRepairConfigArgs',
     'NodegroupNodeRepairConfigArgsDict',
     'NodegroupRemoteAccessArgs',
@@ -1645,6 +1647,102 @@ class NodegroupLaunchTemplateSpecificationArgs:
         pulumi.set(self, "version", value)
 
 
+if not MYPY:
+    class NodegroupNodeRepairConfigOverridesArgsDict(TypedDict):
+        """
+        Specify granular overrides for specific repair actions. These overrides control the repair action and the repair delay time before a node is considered eligible for repair. If you use this, you must specify all the values.
+        """
+        min_repair_wait_time_mins: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Specify the minimum time in minutes to wait before attempting to repair a node with this specific NodeMonitoringCondition and NodeUnhealthyReason.
+        """
+        node_monitoring_condition: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Specify an unhealthy condition reported by the node monitoring agent that this override would apply to.
+        """
+        node_unhealthy_reason: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        Specify a reason reported by the node monitoring agent that this override would apply to.
+        """
+        repair_action: NotRequired[pulumi.Input['NodegroupNodeRepairConfigOverridesRepairAction']]
+        """
+        Specify the repair action to take for nodes when all of the specified conditions are met.
+        """
+elif False:
+    NodegroupNodeRepairConfigOverridesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class NodegroupNodeRepairConfigOverridesArgs:
+    def __init__(__self__, *,
+                 min_repair_wait_time_mins: Optional[pulumi.Input[_builtins.int]] = None,
+                 node_monitoring_condition: Optional[pulumi.Input[_builtins.str]] = None,
+                 node_unhealthy_reason: Optional[pulumi.Input[_builtins.str]] = None,
+                 repair_action: Optional[pulumi.Input['NodegroupNodeRepairConfigOverridesRepairAction']] = None):
+        """
+        Specify granular overrides for specific repair actions. These overrides control the repair action and the repair delay time before a node is considered eligible for repair. If you use this, you must specify all the values.
+        :param pulumi.Input[_builtins.int] min_repair_wait_time_mins: Specify the minimum time in minutes to wait before attempting to repair a node with this specific NodeMonitoringCondition and NodeUnhealthyReason.
+        :param pulumi.Input[_builtins.str] node_monitoring_condition: Specify an unhealthy condition reported by the node monitoring agent that this override would apply to.
+        :param pulumi.Input[_builtins.str] node_unhealthy_reason: Specify a reason reported by the node monitoring agent that this override would apply to.
+        :param pulumi.Input['NodegroupNodeRepairConfigOverridesRepairAction'] repair_action: Specify the repair action to take for nodes when all of the specified conditions are met.
+        """
+        if min_repair_wait_time_mins is not None:
+            pulumi.set(__self__, "min_repair_wait_time_mins", min_repair_wait_time_mins)
+        if node_monitoring_condition is not None:
+            pulumi.set(__self__, "node_monitoring_condition", node_monitoring_condition)
+        if node_unhealthy_reason is not None:
+            pulumi.set(__self__, "node_unhealthy_reason", node_unhealthy_reason)
+        if repair_action is not None:
+            pulumi.set(__self__, "repair_action", repair_action)
+
+    @_builtins.property
+    @pulumi.getter(name="minRepairWaitTimeMins")
+    def min_repair_wait_time_mins(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Specify the minimum time in minutes to wait before attempting to repair a node with this specific NodeMonitoringCondition and NodeUnhealthyReason.
+        """
+        return pulumi.get(self, "min_repair_wait_time_mins")
+
+    @min_repair_wait_time_mins.setter
+    def min_repair_wait_time_mins(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "min_repair_wait_time_mins", value)
+
+    @_builtins.property
+    @pulumi.getter(name="nodeMonitoringCondition")
+    def node_monitoring_condition(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Specify an unhealthy condition reported by the node monitoring agent that this override would apply to.
+        """
+        return pulumi.get(self, "node_monitoring_condition")
+
+    @node_monitoring_condition.setter
+    def node_monitoring_condition(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "node_monitoring_condition", value)
+
+    @_builtins.property
+    @pulumi.getter(name="nodeUnhealthyReason")
+    def node_unhealthy_reason(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        Specify a reason reported by the node monitoring agent that this override would apply to.
+        """
+        return pulumi.get(self, "node_unhealthy_reason")
+
+    @node_unhealthy_reason.setter
+    def node_unhealthy_reason(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "node_unhealthy_reason", value)
+
+    @_builtins.property
+    @pulumi.getter(name="repairAction")
+    def repair_action(self) -> Optional[pulumi.Input['NodegroupNodeRepairConfigOverridesRepairAction']]:
+        """
+        Specify the repair action to take for nodes when all of the specified conditions are met.
+        """
+        return pulumi.get(self, "repair_action")
+
+    @repair_action.setter
+    def repair_action(self, value: Optional[pulumi.Input['NodegroupNodeRepairConfigOverridesRepairAction']]):
+        pulumi.set(self, "repair_action", value)
+
+
 if not MYPY:
     class NodegroupNodeRepairConfigArgsDict(TypedDict):
         """
@@ -1654,19 +1752,59 @@ if not MYPY:
         """
         Set this value to true to enable node auto repair for the node group.
         """
+        max_parallel_nodes_repaired_count: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a count of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedPercentage at the same time.
+        """
+        max_parallel_nodes_repaired_percentage: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a percentage of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedCount at the same time.
+        """
+        max_unhealthy_node_threshold_count: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Specify a count threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdPercentage at the same time.
+        """
+        max_unhealthy_node_threshold_percentage: NotRequired[pulumi.Input[_builtins.int]]
+        """
+        Specify a percentage threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdCount at the same time.
+        """
+        node_repair_config_overrides: NotRequired[pulumi.Input[Sequence[pulumi.Input['NodegroupNodeRepairConfigOverridesArgsDict']]]]
+        """
+        Specify granular overrides for specific repair actions. These overrides control the repair action and the repair delay time before a node is considered eligible for repair. If you use this, you must specify all the values.
+        """
 elif False:
     NodegroupNodeRepairConfigArgsDict: TypeAlias = Mapping[str, Any]
 
 @pulumi.input_type
 class NodegroupNodeRepairConfigArgs:
     def __init__(__self__, *,
-                 enabled: Optional[pulumi.Input[_builtins.bool]] = None):
+                 enabled: Optional[pulumi.Input[_builtins.bool]] = None,
+                 max_parallel_nodes_repaired_count: Optional[pulumi.Input[_builtins.int]] = None,
+                 max_parallel_nodes_repaired_percentage: Optional[pulumi.Input[_builtins.int]] = None,
+                 max_unhealthy_node_threshold_count: Optional[pulumi.Input[_builtins.int]] = None,
+                 max_unhealthy_node_threshold_percentage: Optional[pulumi.Input[_builtins.int]] = None,
+                 node_repair_config_overrides: Optional[pulumi.Input[Sequence[pulumi.Input['NodegroupNodeRepairConfigOverridesArgs']]]] = None):
         """
         The node auto repair configuration for node group.
         :param pulumi.Input[_builtins.bool] enabled: Set this value to true to enable node auto repair for the node group.
+        :param pulumi.Input[_builtins.int] max_parallel_nodes_repaired_count: Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a count of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedPercentage at the same time.
+        :param pulumi.Input[_builtins.int] max_parallel_nodes_repaired_percentage: Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a percentage of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedCount at the same time.
+        :param pulumi.Input[_builtins.int] max_unhealthy_node_threshold_count: Specify a count threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdPercentage at the same time.
+        :param pulumi.Input[_builtins.int] max_unhealthy_node_threshold_percentage: Specify a percentage threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdCount at the same time.
+        :param pulumi.Input[Sequence[pulumi.Input['NodegroupNodeRepairConfigOverridesArgs']]] node_repair_config_overrides: Specify granular overrides for specific repair actions. These overrides control the repair action and the repair delay time before a node is considered eligible for repair. If you use this, you must specify all the values.
         """
         if enabled is not None:
             pulumi.set(__self__, "enabled", enabled)
+        if max_parallel_nodes_repaired_count is not None:
+            pulumi.set(__self__, "max_parallel_nodes_repaired_count", max_parallel_nodes_repaired_count)
+        if max_parallel_nodes_repaired_percentage is not None:
+            pulumi.set(__self__, "max_parallel_nodes_repaired_percentage", max_parallel_nodes_repaired_percentage)
+        if max_unhealthy_node_threshold_count is not None:
+            pulumi.set(__self__, "max_unhealthy_node_threshold_count", max_unhealthy_node_threshold_count)
+        if max_unhealthy_node_threshold_percentage is not None:
+            pulumi.set(__self__, "max_unhealthy_node_threshold_percentage", max_unhealthy_node_threshold_percentage)
+        if node_repair_config_overrides is not None:
+            pulumi.set(__self__, "node_repair_config_overrides", node_repair_config_overrides)
 
     @_builtins.property
     @pulumi.getter
@@ -1680,6 +1818,66 @@ class NodegroupNodeRepairConfigArgs:
     def enabled(self, value: Optional[pulumi.Input[_builtins.bool]]):
         pulumi.set(self, "enabled", value)
 
+    @_builtins.property
+    @pulumi.getter(name="maxParallelNodesRepairedCount")
+    def max_parallel_nodes_repaired_count(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a count of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedPercentage at the same time.
+        """
+        return pulumi.get(self, "max_parallel_nodes_repaired_count")
+
+    @max_parallel_nodes_repaired_count.setter
+    def max_parallel_nodes_repaired_count(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "max_parallel_nodes_repaired_count", value)
+
+    @_builtins.property
+    @pulumi.getter(name="maxParallelNodesRepairedPercentage")
+    def max_parallel_nodes_repaired_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a percentage of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedCount at the same time.
+        """
+        return pulumi.get(self, "max_parallel_nodes_repaired_percentage")
+
+    @max_parallel_nodes_repaired_percentage.setter
+    def max_parallel_nodes_repaired_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "max_parallel_nodes_repaired_percentage", value)
+
+    @_builtins.property
+    @pulumi.getter(name="maxUnhealthyNodeThresholdCount")
+    def max_unhealthy_node_threshold_count(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Specify a count threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdPercentage at the same time.
+        """
+        return pulumi.get(self, "max_unhealthy_node_threshold_count")
+
+    @max_unhealthy_node_threshold_count.setter
+    def max_unhealthy_node_threshold_count(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "max_unhealthy_node_threshold_count", value)
+
+    @_builtins.property
+    @pulumi.getter(name="maxUnhealthyNodeThresholdPercentage")
+    def max_unhealthy_node_threshold_percentage(self) -> Optional[pulumi.Input[_builtins.int]]:
+        """
+        Specify a percentage threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdCount at the same time.
+        """
+        return pulumi.get(self, "max_unhealthy_node_threshold_percentage")
+
+    @max_unhealthy_node_threshold_percentage.setter
+    def max_unhealthy_node_threshold_percentage(self, value: Optional[pulumi.Input[_builtins.int]]):
+        pulumi.set(self, "max_unhealthy_node_threshold_percentage", value)
+
+    @_builtins.property
+    @pulumi.getter(name="nodeRepairConfigOverrides")
+    def node_repair_config_overrides(self) -> Optional[pulumi.Input[Sequence[pulumi.Input['NodegroupNodeRepairConfigOverridesArgs']]]]:
+        """
+        Specify granular overrides for specific repair actions. These overrides control the repair action and the repair delay time before a node is considered eligible for repair. If you use this, you must specify all the values.
+        """
+        return pulumi.get(self, "node_repair_config_overrides")
+
+    @node_repair_config_overrides.setter
+    def node_repair_config_overrides(self, value: Optional[pulumi.Input[Sequence[pulumi.Input['NodegroupNodeRepairConfigOverridesArgs']]]]):
+        pulumi.set(self, "node_repair_config_overrides", value)
+
 
 if not MYPY:
     class NodegroupRemoteAccessArgsDict(TypedDict):

pulumi_aws_native/eks/get_nodegroup.py

@@ -14,6 +14,7 @@ else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 from . import outputs
+from ._enums import *
 
 __all__ = [
     'GetNodegroupResult',

pulumi_aws_native/eks/nodegroup.py

@@ -14,6 +14,7 @@ else:
     from typing_extensions import NotRequired, TypedDict, TypeAlias
 from .. import _utilities
 from . import outputs
+from ._enums import *
 from ._inputs import *
 
 __all__ = ['NodegroupArgs', 'Nodegroup']

pulumi_aws_native/eks/outputs.py

@@ -46,6 +46,7 @@ __all__ = [
     'NamespaceConfigProperties',
     'NodegroupLaunchTemplateSpecification',
     'NodegroupNodeRepairConfig',
+    'NodegroupNodeRepairConfigOverrides',
     'NodegroupRemoteAccess',
     'NodegroupScalingConfig',
     'NodegroupTaint',
@@ -1317,14 +1318,59 @@ class NodegroupNodeRepairConfig(dict):
     """
     The node auto repair configuration for node group.
     """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "maxParallelNodesRepairedCount":
+            suggest = "max_parallel_nodes_repaired_count"
+        elif key == "maxParallelNodesRepairedPercentage":
+            suggest = "max_parallel_nodes_repaired_percentage"
+        elif key == "maxUnhealthyNodeThresholdCount":
+            suggest = "max_unhealthy_node_threshold_count"
+        elif key == "maxUnhealthyNodeThresholdPercentage":
+            suggest = "max_unhealthy_node_threshold_percentage"
+        elif key == "nodeRepairConfigOverrides":
+            suggest = "node_repair_config_overrides"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodegroupNodeRepairConfig. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodegroupNodeRepairConfig.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodegroupNodeRepairConfig.__key_warning(key)
+        return super().get(key, default)
+
     def __init__(__self__, *,
-                 enabled: Optional[_builtins.bool] = None):
+                 enabled: Optional[_builtins.bool] = None,
+                 max_parallel_nodes_repaired_count: Optional[_builtins.int] = None,
+                 max_parallel_nodes_repaired_percentage: Optional[_builtins.int] = None,
+                 max_unhealthy_node_threshold_count: Optional[_builtins.int] = None,
+                 max_unhealthy_node_threshold_percentage: Optional[_builtins.int] = None,
+                 node_repair_config_overrides: Optional[Sequence['outputs.NodegroupNodeRepairConfigOverrides']] = None):
         """
         The node auto repair configuration for node group.
         :param _builtins.bool enabled: Set this value to true to enable node auto repair for the node group.
+        :param _builtins.int max_parallel_nodes_repaired_count: Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a count of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedPercentage at the same time.
+        :param _builtins.int max_parallel_nodes_repaired_percentage: Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a percentage of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedCount at the same time.
+        :param _builtins.int max_unhealthy_node_threshold_count: Specify a count threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdPercentage at the same time.
+        :param _builtins.int max_unhealthy_node_threshold_percentage: Specify a percentage threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdCount at the same time.
+        :param Sequence['NodegroupNodeRepairConfigOverrides'] node_repair_config_overrides: Specify granular overrides for specific repair actions. These overrides control the repair action and the repair delay time before a node is considered eligible for repair. If you use this, you must specify all the values.
         """
         if enabled is not None:
             pulumi.set(__self__, "enabled", enabled)
+        if max_parallel_nodes_repaired_count is not None:
+            pulumi.set(__self__, "max_parallel_nodes_repaired_count", max_parallel_nodes_repaired_count)
+        if max_parallel_nodes_repaired_percentage is not None:
+            pulumi.set(__self__, "max_parallel_nodes_repaired_percentage", max_parallel_nodes_repaired_percentage)
+        if max_unhealthy_node_threshold_count is not None:
+            pulumi.set(__self__, "max_unhealthy_node_threshold_count", max_unhealthy_node_threshold_count)
+        if max_unhealthy_node_threshold_percentage is not None:
+            pulumi.set(__self__, "max_unhealthy_node_threshold_percentage", max_unhealthy_node_threshold_percentage)
+        if node_repair_config_overrides is not None:
+            pulumi.set(__self__, "node_repair_config_overrides", node_repair_config_overrides)
 
     @_builtins.property
     @pulumi.getter
@@ -1334,6 +1380,128 @@ class NodegroupNodeRepairConfig(dict):
         """
         return pulumi.get(self, "enabled")
 
+    @_builtins.property
+    @pulumi.getter(name="maxParallelNodesRepairedCount")
+    def max_parallel_nodes_repaired_count(self) -> Optional[_builtins.int]:
+        """
+        Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a count of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedPercentage at the same time.
+        """
+        return pulumi.get(self, "max_parallel_nodes_repaired_count")
+
+    @_builtins.property
+    @pulumi.getter(name="maxParallelNodesRepairedPercentage")
+    def max_parallel_nodes_repaired_percentage(self) -> Optional[_builtins.int]:
+        """
+        Specify the maximum number of nodes that can be repaired concurrently or in parallel, expressed as a percentage of unhealthy nodes. This gives you finer-grained control over the pace of node replacements. When using this, you cannot also set MaxParallelNodesRepairedCount at the same time.
+        """
+        return pulumi.get(self, "max_parallel_nodes_repaired_percentage")
+
+    @_builtins.property
+    @pulumi.getter(name="maxUnhealthyNodeThresholdCount")
+    def max_unhealthy_node_threshold_count(self) -> Optional[_builtins.int]:
+        """
+        Specify a count threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdPercentage at the same time.
+        """
+        return pulumi.get(self, "max_unhealthy_node_threshold_count")
+
+    @_builtins.property
+    @pulumi.getter(name="maxUnhealthyNodeThresholdPercentage")
+    def max_unhealthy_node_threshold_percentage(self) -> Optional[_builtins.int]:
+        """
+        Specify a percentage threshold of unhealthy nodes, above which node auto repair actions will stop. When using this, you cannot also set MaxUnhealthyNodeThresholdCount at the same time.
+        """
+        return pulumi.get(self, "max_unhealthy_node_threshold_percentage")
+
+    @_builtins.property
+    @pulumi.getter(name="nodeRepairConfigOverrides")
+    def node_repair_config_overrides(self) -> Optional[Sequence['outputs.NodegroupNodeRepairConfigOverrides']]:
+        """
+        Specify granular overrides for specific repair actions. These overrides control the repair action and the repair delay time before a node is considered eligible for repair. If you use this, you must specify all the values.
+        """
+        return pulumi.get(self, "node_repair_config_overrides")
+
+
+@pulumi.output_type
+class NodegroupNodeRepairConfigOverrides(dict):
+    """
+    Specify granular overrides for specific repair actions. These overrides control the repair action and the repair delay time before a node is considered eligible for repair. If you use this, you must specify all the values.
+    """
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "minRepairWaitTimeMins":
+            suggest = "min_repair_wait_time_mins"
+        elif key == "nodeMonitoringCondition":
+            suggest = "node_monitoring_condition"
+        elif key == "nodeUnhealthyReason":
+            suggest = "node_unhealthy_reason"
+        elif key == "repairAction":
+            suggest = "repair_action"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in NodegroupNodeRepairConfigOverrides. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        NodegroupNodeRepairConfigOverrides.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        NodegroupNodeRepairConfigOverrides.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 min_repair_wait_time_mins: Optional[_builtins.int] = None,
+                 node_monitoring_condition: Optional[_builtins.str] = None,
+                 node_unhealthy_reason: Optional[_builtins.str] = None,
+                 repair_action: Optional['NodegroupNodeRepairConfigOverridesRepairAction'] = None):
+        """
+        Specify granular overrides for specific repair actions. These overrides control the repair action and the repair delay time before a node is considered eligible for repair. If you use this, you must specify all the values.
+        :param _builtins.int min_repair_wait_time_mins: Specify the minimum time in minutes to wait before attempting to repair a node with this specific NodeMonitoringCondition and NodeUnhealthyReason.
+        :param _builtins.str node_monitoring_condition: Specify an unhealthy condition reported by the node monitoring agent that this override would apply to.
+        :param _builtins.str node_unhealthy_reason: Specify a reason reported by the node monitoring agent that this override would apply to.
+        :param 'NodegroupNodeRepairConfigOverridesRepairAction' repair_action: Specify the repair action to take for nodes when all of the specified conditions are met.
+        """
+        if min_repair_wait_time_mins is not None:
+            pulumi.set(__self__, "min_repair_wait_time_mins", min_repair_wait_time_mins)
+        if node_monitoring_condition is not None:
+            pulumi.set(__self__, "node_monitoring_condition", node_monitoring_condition)
+        if node_unhealthy_reason is not None:
+            pulumi.set(__self__, "node_unhealthy_reason", node_unhealthy_reason)
+        if repair_action is not None:
+            pulumi.set(__self__, "repair_action", repair_action)
+
+    @_builtins.property
+    @pulumi.getter(name="minRepairWaitTimeMins")
+    def min_repair_wait_time_mins(self) -> Optional[_builtins.int]:
+        """
+        Specify the minimum time in minutes to wait before attempting to repair a node with this specific NodeMonitoringCondition and NodeUnhealthyReason.
+        """
+        return pulumi.get(self, "min_repair_wait_time_mins")
+
+    @_builtins.property
+    @pulumi.getter(name="nodeMonitoringCondition")
+    def node_monitoring_condition(self) -> Optional[_builtins.str]:
+        """
+        Specify an unhealthy condition reported by the node monitoring agent that this override would apply to.
+        """
+        return pulumi.get(self, "node_monitoring_condition")
+
+    @_builtins.property
+    @pulumi.getter(name="nodeUnhealthyReason")
+    def node_unhealthy_reason(self) -> Optional[_builtins.str]:
+        """
+        Specify a reason reported by the node monitoring agent that this override would apply to.
+        """
+        return pulumi.get(self, "node_unhealthy_reason")
+
+    @_builtins.property
+    @pulumi.getter(name="repairAction")
+    def repair_action(self) -> Optional['NodegroupNodeRepairConfigOverridesRepairAction']:
+        """
+        Specify the repair action to take for nodes when all of the specified conditions are met.
+        """
+        return pulumi.get(self, "repair_action")
+
 
 @pulumi.output_type
 class NodegroupRemoteAccess(dict):

pulumi_aws_native/glue/__init__.py

@@ -11,12 +11,14 @@ from .crawler import *
 from .database import *
 from .get_crawler import *
 from .get_database import *
+from .get_integration_resource_property import *
 from .get_job import *
 from .get_registry import *
 from .get_schema import *
 from .get_schema_version import *
 from .get_trigger import *
 from .get_usage_profile import *
+from .integration_resource_property import *
 from .job import *
 from .registry import *
 from .schema import *

pulumi_aws_native/glue/_inputs.py

@@ -66,6 +66,10 @@ __all__ = [
     'SchemaVersionSchemaArgsDict',
     'SchemaVersionArgs',
     'SchemaVersionArgsDict',
+    'SourceProcessingPropertiesPropertiesArgs',
+    'SourceProcessingPropertiesPropertiesArgsDict',
+    'TargetProcessingPropertiesPropertiesArgs',
+    'TargetProcessingPropertiesPropertiesArgsDict',
     'TriggerActionArgs',
     'TriggerActionArgsDict',
     'TriggerConditionArgs',
@@ -1980,6 +1984,136 @@ class SchemaVersionArgs:
         pulumi.set(self, "version_number", value)
 
 
+if not MYPY:
+    class SourceProcessingPropertiesPropertiesArgsDict(TypedDict):
+        """
+        The resource properties associated with the integration source.
+        """
+        role_arn: pulumi.Input[_builtins.str]
+        """
+        The IAM role to access the Glue connection.
+        """
+elif False:
+    SourceProcessingPropertiesPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class SourceProcessingPropertiesPropertiesArgs:
+    def __init__(__self__, *,
+                 role_arn: pulumi.Input[_builtins.str]):
+        """
+        The resource properties associated with the integration source.
+        :param pulumi.Input[_builtins.str] role_arn: The IAM role to access the Glue connection.
+        """
+        pulumi.set(__self__, "role_arn", role_arn)
+
+    @_builtins.property
+    @pulumi.getter(name="roleArn")
+    def role_arn(self) -> pulumi.Input[_builtins.str]:
+        """
+        The IAM role to access the Glue connection.
+        """
+        return pulumi.get(self, "role_arn")
+
+    @role_arn.setter
+    def role_arn(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "role_arn", value)
+
+
+if not MYPY:
+    class TargetProcessingPropertiesPropertiesArgsDict(TypedDict):
+        """
+        The resource properties associated with the integration target.
+        """
+        role_arn: pulumi.Input[_builtins.str]
+        """
+        The IAM role to access the Glue database.
+        """
+        connection_name: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The Glue network connection to configure the Glue job running in the customer VPC.
+        """
+        event_bus_arn: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The ARN of an Eventbridge event bus to receive the integration status notification.
+        """
+        kms_arn: NotRequired[pulumi.Input[_builtins.str]]
+        """
+        The ARN of the KMS key used for encryption.
+        """
+elif False:
+    TargetProcessingPropertiesPropertiesArgsDict: TypeAlias = Mapping[str, Any]
+
+@pulumi.input_type
+class TargetProcessingPropertiesPropertiesArgs:
+    def __init__(__self__, *,
+                 role_arn: pulumi.Input[_builtins.str],
+                 connection_name: Optional[pulumi.Input[_builtins.str]] = None,
+                 event_bus_arn: Optional[pulumi.Input[_builtins.str]] = None,
+                 kms_arn: Optional[pulumi.Input[_builtins.str]] = None):
+        """
+        The resource properties associated with the integration target.
+        :param pulumi.Input[_builtins.str] role_arn: The IAM role to access the Glue database.
+        :param pulumi.Input[_builtins.str] connection_name: The Glue network connection to configure the Glue job running in the customer VPC.
+        :param pulumi.Input[_builtins.str] event_bus_arn: The ARN of an Eventbridge event bus to receive the integration status notification.
+        :param pulumi.Input[_builtins.str] kms_arn: The ARN of the KMS key used for encryption.
+        """
+        pulumi.set(__self__, "role_arn", role_arn)
+        if connection_name is not None:
+            pulumi.set(__self__, "connection_name", connection_name)
+        if event_bus_arn is not None:
+            pulumi.set(__self__, "event_bus_arn", event_bus_arn)
+        if kms_arn is not None:
+            pulumi.set(__self__, "kms_arn", kms_arn)
+
+    @_builtins.property
+    @pulumi.getter(name="roleArn")
+    def role_arn(self) -> pulumi.Input[_builtins.str]:
+        """
+        The IAM role to access the Glue database.
+        """
+        return pulumi.get(self, "role_arn")
+
+    @role_arn.setter
+    def role_arn(self, value: pulumi.Input[_builtins.str]):
+        pulumi.set(self, "role_arn", value)
+
+    @_builtins.property
+    @pulumi.getter(name="connectionName")
+    def connection_name(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The Glue network connection to configure the Glue job running in the customer VPC.
+        """
+        return pulumi.get(self, "connection_name")
+
+    @connection_name.setter
+    def connection_name(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "connection_name", value)
+
+    @_builtins.property
+    @pulumi.getter(name="eventBusArn")
+    def event_bus_arn(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The ARN of an Eventbridge event bus to receive the integration status notification.
+        """
+        return pulumi.get(self, "event_bus_arn")
+
+    @event_bus_arn.setter
+    def event_bus_arn(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "event_bus_arn", value)
+
+    @_builtins.property
+    @pulumi.getter(name="kmsArn")
+    def kms_arn(self) -> Optional[pulumi.Input[_builtins.str]]:
+        """
+        The ARN of the KMS key used for encryption.
+        """
+        return pulumi.get(self, "kms_arn")
+
+    @kms_arn.setter
+    def kms_arn(self, value: Optional[pulumi.Input[_builtins.str]]):
+        pulumi.set(self, "kms_arn", value)
+
+
 if not MYPY:
     class TriggerActionArgsDict(TypedDict):
         """