pulumi-aws-native 1.38.0a1761631437__py3-none-any.whl → 1.39.0a1762376209__py3-none-any.whl

pulumi_aws_native/ecs/outputs.py

@@ -43,7 +43,9 @@ __all__ = [
     'ClusterSettings',
     'ServiceAdvancedConfiguration',
     'ServiceAwsVpcConfiguration',
+    'ServiceCanaryConfiguration',
     'ServiceCapacityProviderStrategyItem',
+    'ServiceConnectAccessLogConfiguration',
     'ServiceConnectClientAlias',
     'ServiceConnectConfiguration',
     'ServiceConnectService',
@@ -59,6 +61,7 @@ __all__ = [
     'ServiceDeploymentLifecycleHook',
     'ServiceEbsTagSpecification',
     'ServiceForceNewDeployment',
+    'ServiceLinearConfiguration',
     'ServiceLoadBalancer',
     'ServiceLogConfiguration',
     'ServiceManagedEbsVolumeConfiguration',
@@ -1858,6 +1861,56 @@ class ServiceAwsVpcConfiguration(dict):
         return pulumi.get(self, "subnets")
 
 
+@pulumi.output_type
+class ServiceCanaryConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "canaryBakeTimeInMinutes":
+            suggest = "canary_bake_time_in_minutes"
+        elif key == "canaryPercent":
+            suggest = "canary_percent"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceCanaryConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceCanaryConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceCanaryConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 canary_bake_time_in_minutes: Optional[_builtins.int] = None,
+                 canary_percent: Optional[_builtins.float] = None):
+        """
+        :param _builtins.int canary_bake_time_in_minutes: The amount of time in minutes to wait during the canary phase before shifting the remaining production traffic to the new service revision. Valid values are 0 to 1440 minutes (24 hours). The default value is 10.
+        :param _builtins.float canary_percent: The percentage of production traffic to shift to the new service revision during the canary phase. Valid values are multiples of 0.1 from 0.1 to 100.0. The default value is 5.0.
+        """
+        if canary_bake_time_in_minutes is not None:
+            pulumi.set(__self__, "canary_bake_time_in_minutes", canary_bake_time_in_minutes)
+        if canary_percent is not None:
+            pulumi.set(__self__, "canary_percent", canary_percent)
+
+    @_builtins.property
+    @pulumi.getter(name="canaryBakeTimeInMinutes")
+    def canary_bake_time_in_minutes(self) -> Optional[_builtins.int]:
+        """
+        The amount of time in minutes to wait during the canary phase before shifting the remaining production traffic to the new service revision. Valid values are 0 to 1440 minutes (24 hours). The default value is 10.
+        """
+        return pulumi.get(self, "canary_bake_time_in_minutes")
+
+    @_builtins.property
+    @pulumi.getter(name="canaryPercent")
+    def canary_percent(self) -> Optional[_builtins.float]:
+        """
+        The percentage of production traffic to shift to the new service revision during the canary phase. Valid values are multiples of 0.1 from 0.1 to 100.0. The default value is 5.0.
+        """
+        return pulumi.get(self, "canary_percent")
+
+
 @pulumi.output_type
 class ServiceCapacityProviderStrategyItem(dict):
     """
@@ -1968,6 +2021,57 @@ class ServiceCapacityProviderStrategyItem(dict):
         return pulumi.get(self, "weight")
 
 
+@pulumi.output_type
+class ServiceConnectAccessLogConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "includeQueryParameters":
+            suggest = "include_query_parameters"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceConnectAccessLogConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceConnectAccessLogConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceConnectAccessLogConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 format: 'ServiceConnectAccessLogConfigurationFormat',
+                 include_query_parameters: Optional['ServiceConnectAccessLogConfigurationIncludeQueryParameters'] = None):
+        """
+        :param 'ServiceConnectAccessLogConfigurationFormat' format: The format for Service Connect access log output. Choose TEXT for human-readable logs or JSON for structured data that integrates well with log analysis tools.
+        :param 'ServiceConnectAccessLogConfigurationIncludeQueryParameters' include_query_parameters: Specifies whether to include query parameters in Service Connect access logs.
+               
+               When enabled, query parameters from HTTP requests are included in the access logs. Consider security and privacy implications when enabling this feature, as query parameters may contain sensitive information such as request IDs and tokens. By default, this parameter is `DISABLED` .
+        """
+        pulumi.set(__self__, "format", format)
+        if include_query_parameters is not None:
+            pulumi.set(__self__, "include_query_parameters", include_query_parameters)
+
+    @_builtins.property
+    @pulumi.getter
+    def format(self) -> 'ServiceConnectAccessLogConfigurationFormat':
+        """
+        The format for Service Connect access log output. Choose TEXT for human-readable logs or JSON for structured data that integrates well with log analysis tools.
+        """
+        return pulumi.get(self, "format")
+
+    @_builtins.property
+    @pulumi.getter(name="includeQueryParameters")
+    def include_query_parameters(self) -> Optional['ServiceConnectAccessLogConfigurationIncludeQueryParameters']:
+        """
+        Specifies whether to include query parameters in Service Connect access logs.
+
+        When enabled, query parameters from HTTP requests are included in the access logs. Consider security and privacy implications when enabling this feature, as query parameters may contain sensitive information such as request IDs and tokens. By default, this parameter is `DISABLED` .
+        """
+        return pulumi.get(self, "include_query_parameters")
+
+
 @pulumi.output_type
 class ServiceConnectClientAlias(dict):
     """
@@ -2052,7 +2156,9 @@ class ServiceConnectConfiguration(dict):
     @staticmethod
     def __key_warning(key: str):
         suggest = None
-        if key == "logConfiguration":
+        if key == "accessLogConfiguration":
+            suggest = "access_log_configuration"
+        elif key == "logConfiguration":
             suggest = "log_configuration"
 
         if suggest:
@@ -2068,6 +2174,7 @@ class ServiceConnectConfiguration(dict):
 
     def __init__(__self__, *,
                  enabled: _builtins.bool,
+                 access_log_configuration: Optional['outputs.ServiceConnectAccessLogConfiguration'] = None,
                  log_configuration: Optional['outputs.ServiceLogConfiguration'] = None,
                  namespace: Optional[_builtins.str] = None,
                  services: Optional[Sequence['outputs.ServiceConnectService']] = None):
@@ -2075,6 +2182,9 @@ class ServiceConnectConfiguration(dict):
         The Service Connect configuration of your Amazon ECS service. The configuration for this service to discover and connect to services, and be discovered by, and connected from, other services within a namespace.
          Tasks that run in a namespace can use short names to connect to services in the namespace. Tasks can connect to services across all of the clusters in the namespace. Tasks connect through a managed proxy container that collects logs and metrics for increased visibility. Only the tasks that Amazon ECS services create are supported with Service Connect. For more information, see [Service Connect](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html) in the *Amazon Elastic Container Service Developer Guide*.
         :param _builtins.bool enabled: Specifies whether to use Service Connect with this service.
+        :param 'ServiceConnectAccessLogConfiguration' access_log_configuration: The configuration for Service Connect access logging. Access logs capture detailed information about requests made to your service, including request patterns, response codes, and timing data. They can be useful for debugging connectivity issues, monitoring service performance, and auditing service-to-service communication for security and compliance purposes.
+               
+               > To enable access logs, you must also specify a `logConfiguration` in the `serviceConnectConfiguration` .
         :param 'ServiceLogConfiguration' log_configuration: The log configuration for the container. This parameter maps to ``LogConfig`` in the docker container create command and the ``--log-driver`` option to docker run.
                 By default, containers use the same logging driver that the Docker daemon uses. However, the container might use a different logging driver than the Docker daemon by specifying a log driver configuration in the container definition.
                 Understand the following when specifying a log configuration for your containers.
@@ -2090,6 +2200,8 @@ class ServiceConnectConfiguration(dict):
                 An object selects a port from the task definition, assigns a name for the CMAPlong service, and a list of aliases (endpoints) and ports for client applications to refer to this service.
         """
         pulumi.set(__self__, "enabled", enabled)
+        if access_log_configuration is not None:
+            pulumi.set(__self__, "access_log_configuration", access_log_configuration)
         if log_configuration is not None:
             pulumi.set(__self__, "log_configuration", log_configuration)
         if namespace is not None:
@@ -2105,6 +2217,16 @@ class ServiceConnectConfiguration(dict):
         """
         return pulumi.get(self, "enabled")
 
+    @_builtins.property
+    @pulumi.getter(name="accessLogConfiguration")
+    def access_log_configuration(self) -> Optional['outputs.ServiceConnectAccessLogConfiguration']:
+        """
+        The configuration for Service Connect access logging. Access logs capture detailed information about requests made to your service, including request patterns, response codes, and timing data. They can be useful for debugging connectivity issues, monitoring service performance, and auditing service-to-service communication for security and compliance purposes.
+
+        > To enable access logs, you must also specify a `logConfiguration` in the `serviceConnectConfiguration` .
+        """
+        return pulumi.get(self, "access_log_configuration")
+
     @_builtins.property
     @pulumi.getter(name="logConfiguration")
     def log_configuration(self) -> Optional['outputs.ServiceLogConfiguration']:
@@ -2561,10 +2683,10 @@ class ServiceDeploymentConfiguration(dict):
     def __init__(__self__, *,
                  alarms: Optional['outputs.ServiceDeploymentAlarms'] = None,
                  bake_time_in_minutes: Optional[_builtins.int] = None,
-                 canary_configuration: Optional[Any] = None,
+                 canary_configuration: Optional['outputs.ServiceCanaryConfiguration'] = None,
                  deployment_circuit_breaker: Optional['outputs.ServiceDeploymentCircuitBreaker'] = None,
                  lifecycle_hooks: Optional[Sequence['outputs.ServiceDeploymentLifecycleHook']] = None,
-                 linear_configuration: Optional[Any] = None,
+                 linear_configuration: Optional['outputs.ServiceLinearConfiguration'] = None,
                  maximum_percent: Optional[_builtins.int] = None,
                  minimum_healthy_percent: Optional[_builtins.int] = None,
                  strategy: Optional['ServiceDeploymentConfigurationStrategy'] = None):
@@ -2576,9 +2698,11 @@ class ServiceDeploymentConfiguration(dict):
                  +  For rolling deployments, the value is set to 3 hours (180 minutes).
                  +  When you use an external deployment controller (``EXTERNAL``), or the ACD blue/green deployment controller (``CODE_DEPLOY``), the value is set to 3 hours (180 minutes).
                  +  For all other cases, the value is set to 36 hours (2160 minutes).
+        :param 'ServiceCanaryConfiguration' canary_configuration: Configuration for canary deployment strategy. Only valid when the deployment strategy is `CANARY` . This configuration enables shifting a fixed percentage of traffic for testing, followed by shifting the remaining traffic after a bake period.
         :param 'ServiceDeploymentCircuitBreaker' deployment_circuit_breaker: The deployment circuit breaker can only be used for services using the rolling update (``ECS``) deployment type.
                  The *deployment circuit breaker* determines whether a service deployment will fail if the service can't reach a steady state. If you use the deployment circuit breaker, a service deployment will transition to a failed state and stop launching new tasks. If you use the rollback option, when a service deployment fails, the service is rolled back to the last deployment that completed successfully. For more information, see [Rolling update](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html) in the *Amazon Elastic Container Service Developer Guide*
         :param Sequence['ServiceDeploymentLifecycleHook'] lifecycle_hooks: An array of deployment lifecycle hook objects to run custom logic at specific stages of the deployment lifecycle.
+        :param 'ServiceLinearConfiguration' linear_configuration: Configuration for linear deployment strategy. Only valid when the deployment strategy is `LINEAR` . This configuration enables progressive traffic shifting in equal percentage increments with configurable bake times between each step.
         :param _builtins.int maximum_percent: If a service is using the rolling update (``ECS``) deployment type, the ``maximumPercent`` parameter represents an upper limit on the number of your service's tasks that are allowed in the ``RUNNING`` or ``PENDING`` state during a deployment, as a percentage of the ``desiredCount`` (rounded down to the nearest integer). This parameter enables you to define the deployment batch size. For example, if your service is using the ``REPLICA`` service scheduler and has a ``desiredCount`` of four tasks and a ``maximumPercent`` value of 200%, the scheduler may start four new tasks before stopping the four older tasks (provided that the cluster resources required to do this are available). The default ``maximumPercent`` value for a service using the ``REPLICA`` service scheduler is 200%.
                 The Amazon ECS scheduler uses this parameter to replace unhealthy tasks by starting replacement tasks first and then stopping the unhealthy tasks, as long as cluster resources for starting replacement tasks are available. For more information about how the scheduler replaces unhealthy tasks, see [Amazon ECS services](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs_services.html).
                 If a service is using either the blue/green (``CODE_DEPLOY``) or ``EXTERNAL`` deployment types, and tasks in the service use the EC2 launch type, the *maximum percent* value is set to the default value. The *maximum percent* value is used to define the upper limit on the number of the tasks in the service that remain in the ``RUNNING`` state while the container instances are in the ``DRAINING`` state.
@@ -2645,7 +2769,10 @@ class ServiceDeploymentConfiguration(dict):
 
     @_builtins.property
     @pulumi.getter(name="canaryConfiguration")
-    def canary_configuration(self) -> Optional[Any]:
+    def canary_configuration(self) -> Optional['outputs.ServiceCanaryConfiguration']:
+        """
+        Configuration for canary deployment strategy. Only valid when the deployment strategy is `CANARY` . This configuration enables shifting a fixed percentage of traffic for testing, followed by shifting the remaining traffic after a bake period.
+        """
         return pulumi.get(self, "canary_configuration")
 
     @_builtins.property
@@ -2667,7 +2794,10 @@ class ServiceDeploymentConfiguration(dict):
 
     @_builtins.property
     @pulumi.getter(name="linearConfiguration")
-    def linear_configuration(self) -> Optional[Any]:
+    def linear_configuration(self) -> Optional['outputs.ServiceLinearConfiguration']:
+        """
+        Configuration for linear deployment strategy. Only valid when the deployment strategy is `LINEAR` . This configuration enables progressive traffic shifting in equal percentage increments with configurable bake times between each step.
+        """
         return pulumi.get(self, "linear_configuration")
 
     @_builtins.property
@@ -3062,6 +3192,56 @@ class ServiceForceNewDeployment(dict):
         return pulumi.get(self, "force_new_deployment_nonce")
 
 
+@pulumi.output_type
+class ServiceLinearConfiguration(dict):
+    @staticmethod
+    def __key_warning(key: str):
+        suggest = None
+        if key == "stepBakeTimeInMinutes":
+            suggest = "step_bake_time_in_minutes"
+        elif key == "stepPercent":
+            suggest = "step_percent"
+
+        if suggest:
+            pulumi.log.warn(f"Key '{key}' not found in ServiceLinearConfiguration. Access the value via the '{suggest}' property getter instead.")
+
+    def __getitem__(self, key: str) -> Any:
+        ServiceLinearConfiguration.__key_warning(key)
+        return super().__getitem__(key)
+
+    def get(self, key: str, default = None) -> Any:
+        ServiceLinearConfiguration.__key_warning(key)
+        return super().get(key, default)
+
+    def __init__(__self__, *,
+                 step_bake_time_in_minutes: Optional[_builtins.int] = None,
+                 step_percent: Optional[_builtins.float] = None):
+        """
+        :param _builtins.int step_bake_time_in_minutes: The amount of time in minutes to wait between each traffic shifting step during a linear deployment. Valid values are 0 to 1440 minutes (24 hours). The default value is 6. This bake time is not applied after reaching 100 percent traffic.
+        :param _builtins.float step_percent: The percentage of production traffic to shift in each step during a linear deployment. Valid values are multiples of 0.1 from 3.0 to 100.0. The default value is 10.0.
+        """
+        if step_bake_time_in_minutes is not None:
+            pulumi.set(__self__, "step_bake_time_in_minutes", step_bake_time_in_minutes)
+        if step_percent is not None:
+            pulumi.set(__self__, "step_percent", step_percent)
+
+    @_builtins.property
+    @pulumi.getter(name="stepBakeTimeInMinutes")
+    def step_bake_time_in_minutes(self) -> Optional[_builtins.int]:
+        """
+        The amount of time in minutes to wait between each traffic shifting step during a linear deployment. Valid values are 0 to 1440 minutes (24 hours). The default value is 6. This bake time is not applied after reaching 100 percent traffic.
+        """
+        return pulumi.get(self, "step_bake_time_in_minutes")
+
+    @_builtins.property
+    @pulumi.getter(name="stepPercent")
+    def step_percent(self) -> Optional[_builtins.float]:
+        """
+        The percentage of production traffic to shift in each step during a linear deployment. Valid values are multiples of 0.1 from 3.0 to 100.0. The default value is 10.0.
+        """
+        return pulumi.get(self, "step_percent")
+
+
 @pulumi.output_type
 class ServiceLoadBalancer(dict):
     """
@@ -7055,10 +7235,10 @@ class TaskSetCapacityProviderStrategyItem(dict):
                Base value characteristics:
                
                - Only one capacity provider in a strategy can have a base defined
-               - Default value is `0` if not specified
-               - Valid range: 0 to 100,000
+               - The default value is `0` if not specified
+               - The valid range is 0 to 100,000
                - Base requirements are satisfied first before weight distribution
-        :param _builtins.str capacity_provider: The short name of the capacity provider.
+        :param _builtins.str capacity_provider: The short name of the capacity provider. This can be either an AWS managed capacity provider ( `FARGATE` or `FARGATE_SPOT` ) or the name of a custom capacity provider that you created.
         :param _builtins.int weight: The *weight* value designates the relative percentage of the total number of tasks launched that should use the specified capacity provider. The `weight` value is taken into consideration after the `base` value, if defined, is satisfied.
                
                If no `weight` value is specified, the default value of `0` is used. When multiple capacity providers are specified within a capacity provider strategy, at least one of the capacity providers must have a weight value greater than zero and any capacity providers with a weight of `0` can't be used to place tasks. If you specify multiple capacity providers in a strategy that all have a weight of `0` , any `RunTask` or `CreateService` actions using the capacity provider strategy will fail.
@@ -7066,8 +7246,8 @@ class TaskSetCapacityProviderStrategyItem(dict):
                Weight value characteristics:
                
                - Weight is considered after the base value is satisfied
-               - Default value is `0` if not specified
-               - Valid range: 0 to 1,000
+               - The default value is `0` if not specified
+               - The valid range is 0 to 1,000
                - At least one capacity provider must have a weight greater than zero
                - Capacity providers with weight of `0` cannot place tasks
                
@@ -7098,8 +7278,8 @@ class TaskSetCapacityProviderStrategyItem(dict):
         Base value characteristics:
 
         - Only one capacity provider in a strategy can have a base defined
-        - Default value is `0` if not specified
-        - Valid range: 0 to 100,000
+        - The default value is `0` if not specified
+        - The valid range is 0 to 100,000
         - Base requirements are satisfied first before weight distribution
         """
         return pulumi.get(self, "base")
@@ -7108,7 +7288,7 @@ class TaskSetCapacityProviderStrategyItem(dict):
     @pulumi.getter(name="capacityProvider")
     def capacity_provider(self) -> Optional[_builtins.str]:
         """
-        The short name of the capacity provider.
+        The short name of the capacity provider. This can be either an AWS managed capacity provider ( `FARGATE` or `FARGATE_SPOT` ) or the name of a custom capacity provider that you created.
         """
         return pulumi.get(self, "capacity_provider")
 
@@ -7123,8 +7303,8 @@ class TaskSetCapacityProviderStrategyItem(dict):
         Weight value characteristics:
 
         - Weight is considered after the base value is satisfied
-        - Default value is `0` if not specified
-        - Valid range: 0 to 1,000
+        - The default value is `0` if not specified
+        - The valid range is 0 to 1,000
         - At least one capacity provider must have a weight greater than zero
         - Capacity providers with weight of `0` cannot place tasks
 

pulumi_aws_native/eks/_enums.py

@@ -14,6 +14,7 @@ __all__ = [
     'ClusterLoggingTypeConfigType',
     'ClusterUpgradePolicySupportType',
     'IdentityProviderConfigType',
+    'NodegroupNodeRepairConfigOverridesRepairAction',
 ]
 
 
@@ -82,3 +83,13 @@ class IdentityProviderConfigType(_builtins.str, Enum):
     The type of the identity provider configuration.
     """
     OIDC = "oidc"
+
+
+@pulumi.type_token("aws-native:eks:NodegroupNodeRepairConfigOverridesRepairAction")
+class NodegroupNodeRepairConfigOverridesRepairAction(_builtins.str, Enum):
+    """
+    Specify the repair action to take for nodes when all of the specified conditions are met.
+    """
+    REPLACE = "Replace"
+    REBOOT = "Reboot"
+    NO_ACTION = "NoAction"

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']