aws-cdk-lib 2.195.0__py3-none-any.whl → 2.224.0__py3-none-any.whl

aws_cdk/aws_ecs_patterns/__init__.py

@@ -72,6 +72,8 @@ Fargate services will use the `LATEST` platform version by default, but you can
 
 Fargate services use the default VPC Security Group unless one or more are provided using the `securityGroups` property in the constructor.
 
+**Security Considerations**: When using custom security groups on your load balancer, the `openListener` property controls whether the load balancer listener allows traffic from anywhere on the internet (0.0.0.0/0). By default, `openListener` is `true`, but it will automatically default to `false` when custom security groups are detected, preventing unintended internet exposure. You can always explicitly set `openListener: true` to override this behavior if needed.
+
 By setting `redirectHTTP` to true, CDK will automatically create a listener on port 80 that redirects HTTP traffic to the HTTPS port.
 
 If you specify the option `recordType` you can decide if you want the construct to use CNAME or Route53-Aliases as record sets.
@@ -249,7 +251,9 @@ load_balanced_fargate_service = ecs_patterns.NetworkMultipleTargetGroupsFargateS
         container_port=90,
         listener="listener2"
     )
-    ]
+    ],
+    min_healthy_percent=100,
+    max_healthy_percent=200
 )
 ```
 
@@ -1143,6 +1147,20 @@ network_load_balanced_fargate_service = ecs_patterns.NetworkLoadBalancedFargateS
 )
 ```
 
+### Set healthCheckGracePeriod for QueueProcessingFargateService
+
+```python
+# vpc: ec2.Vpc
+
+queue_processing_fargate_service = ecs_patterns.QueueProcessingFargateService(self, "Service",
+    vpc=vpc,
+    memory_limit_mi_b=512,
+    image=ecs.ContainerImage.from_registry("test"),
+    min_healthy_percent=100,
+    health_check_grace_period=Duration.seconds(120)
+)
+```
+
 ### Set securityGroups for NetworkLoadBalancedFargateService
 
 ```python
@@ -1584,7 +1602,7 @@ class ApplicationLoadBalancedServiceBase(
         :param protocol_version: The protocol version to use. Default: ApplicationProtocolVersion.HTTP1
         :param public_load_balancer: Determines whether the Load Balancer will be internet-facing. Default: true
         :param record_type: Specifies whether the Route53 record should be a CNAME, an A record using the Alias feature or no record at all. This is useful if you need to work with DNS systems that do not support alias records. Default: ApplicationLoadBalancedServiceRecordType.ALIAS
-        :param redirect_http: Specifies whether the load balancer should redirect traffic on port 80 to port 443 to support HTTP->HTTPS redirects This is only valid if the protocol of the ALB is HTTPS. Default: false
+        :param redirect_http: Specifies whether the load balancer should redirect traffic on port 80 to the {@link listenerPort} to support HTTP->HTTPS redirects. This is only valid if the protocol of the ALB is HTTPS. Default: false
         :param service_name: The name of the service. Default: - CloudFormation-generated name.
         :param ssl_policy: The security policy that defines which ciphers and protocols are supported by the ALB Listener. Default: - The recommended elastic load balancing security policy
         :param target_protocol: The protocol for connections from the load balancer to the ECS tasks. The default target port is determined from the protocol (port 80 for HTTP, port 443 for HTTPS). Default: HTTP.
@@ -1823,7 +1841,7 @@ class ApplicationLoadBalancedServiceBaseProps:
         :param protocol_version: The protocol version to use. Default: ApplicationProtocolVersion.HTTP1
         :param public_load_balancer: Determines whether the Load Balancer will be internet-facing. Default: true
         :param record_type: Specifies whether the Route53 record should be a CNAME, an A record using the Alias feature or no record at all. This is useful if you need to work with DNS systems that do not support alias records. Default: ApplicationLoadBalancedServiceRecordType.ALIAS
-        :param redirect_http: Specifies whether the load balancer should redirect traffic on port 80 to port 443 to support HTTP->HTTPS redirects This is only valid if the protocol of the ALB is HTTPS. Default: false
+        :param redirect_http: Specifies whether the load balancer should redirect traffic on port 80 to the {@link listenerPort} to support HTTP->HTTPS redirects. This is only valid if the protocol of the ALB is HTTPS. Default: false
         :param service_name: The name of the service. Default: - CloudFormation-generated name.
         :param ssl_policy: The security policy that defines which ciphers and protocols are supported by the ALB Listener. Default: - The recommended elastic load balancing security policy
         :param target_protocol: The protocol for connections from the load balancer to the ECS tasks. The default target port is determined from the protocol (port 80 for HTTP, port 443 for HTTPS). Default: HTTP.
@@ -2313,7 +2331,9 @@ class ApplicationLoadBalancedServiceBaseProps:
 
     @builtins.property
     def redirect_http(self) -> typing.Optional[builtins.bool]:
-        '''Specifies whether the load balancer should redirect traffic on port 80 to port 443 to support HTTP->HTTPS redirects This is only valid if the protocol of the ALB is HTTPS.
+        '''Specifies whether the load balancer should redirect traffic on port 80 to the {@link listenerPort} to support HTTP->HTTPS redirects.
+
+        This is only valid if the protocol of the ALB is HTTPS.
 
         :default: false
         '''
@@ -7599,7 +7619,7 @@ class ApplicationLoadBalancedEc2Service(
         :param protocol_version: The protocol version to use. Default: ApplicationProtocolVersion.HTTP1
         :param public_load_balancer: Determines whether the Load Balancer will be internet-facing. Default: true
         :param record_type: Specifies whether the Route53 record should be a CNAME, an A record using the Alias feature or no record at all. This is useful if you need to work with DNS systems that do not support alias records. Default: ApplicationLoadBalancedServiceRecordType.ALIAS
-        :param redirect_http: Specifies whether the load balancer should redirect traffic on port 80 to port 443 to support HTTP->HTTPS redirects This is only valid if the protocol of the ALB is HTTPS. Default: false
+        :param redirect_http: Specifies whether the load balancer should redirect traffic on port 80 to the {@link listenerPort} to support HTTP->HTTPS redirects. This is only valid if the protocol of the ALB is HTTPS. Default: false
         :param service_name: The name of the service. Default: - CloudFormation-generated name.
         :param ssl_policy: The security policy that defines which ciphers and protocols are supported by the ALB Listener. Default: - The recommended elastic load balancing security policy
         :param target_protocol: The protocol for connections from the load balancer to the ECS tasks. The default target port is determined from the protocol (port 80 for HTTP, port 443 for HTTPS). Default: HTTP.
@@ -7777,7 +7797,7 @@ class ApplicationLoadBalancedEc2ServiceProps(ApplicationLoadBalancedServiceBaseP
         :param protocol_version: The protocol version to use. Default: ApplicationProtocolVersion.HTTP1
         :param public_load_balancer: Determines whether the Load Balancer will be internet-facing. Default: true
         :param record_type: Specifies whether the Route53 record should be a CNAME, an A record using the Alias feature or no record at all. This is useful if you need to work with DNS systems that do not support alias records. Default: ApplicationLoadBalancedServiceRecordType.ALIAS
-        :param redirect_http: Specifies whether the load balancer should redirect traffic on port 80 to port 443 to support HTTP->HTTPS redirects This is only valid if the protocol of the ALB is HTTPS. Default: false
+        :param redirect_http: Specifies whether the load balancer should redirect traffic on port 80 to the {@link listenerPort} to support HTTP->HTTPS redirects. This is only valid if the protocol of the ALB is HTTPS. Default: false
         :param service_name: The name of the service. Default: - CloudFormation-generated name.
         :param ssl_policy: The security policy that defines which ciphers and protocols are supported by the ALB Listener. Default: - The recommended elastic load balancing security policy
         :param target_protocol: The protocol for connections from the load balancer to the ECS tasks. The default target port is determined from the protocol (port 80 for HTTP, port 443 for HTTPS). Default: HTTP.
@@ -8208,7 +8228,9 @@ class ApplicationLoadBalancedEc2ServiceProps(ApplicationLoadBalancedServiceBaseP
 
     @builtins.property
     def redirect_http(self) -> typing.Optional[builtins.bool]:
-        '''Specifies whether the load balancer should redirect traffic on port 80 to port 443 to support HTTP->HTTPS redirects This is only valid if the protocol of the ALB is HTTPS.
+        '''Specifies whether the load balancer should redirect traffic on port 80 to the {@link listenerPort} to support HTTP->HTTPS redirects.
+
+        This is only valid if the protocol of the ALB is HTTPS.
 
         :default: false
         '''
@@ -8495,7 +8517,7 @@ class ApplicationLoadBalancedFargateService(
         :param protocol_version: The protocol version to use. Default: ApplicationProtocolVersion.HTTP1
         :param public_load_balancer: Determines whether the Load Balancer will be internet-facing. Default: true
         :param record_type: Specifies whether the Route53 record should be a CNAME, an A record using the Alias feature or no record at all. This is useful if you need to work with DNS systems that do not support alias records. Default: ApplicationLoadBalancedServiceRecordType.ALIAS
-        :param redirect_http: Specifies whether the load balancer should redirect traffic on port 80 to port 443 to support HTTP->HTTPS redirects This is only valid if the protocol of the ALB is HTTPS. Default: false
+        :param redirect_http: Specifies whether the load balancer should redirect traffic on port 80 to the {@link listenerPort} to support HTTP->HTTPS redirects. This is only valid if the protocol of the ALB is HTTPS. Default: false
         :param service_name: The name of the service. Default: - CloudFormation-generated name.
         :param ssl_policy: The security policy that defines which ciphers and protocols are supported by the ALB Listener. Default: - The recommended elastic load balancing security policy
         :param target_protocol: The protocol for connections from the load balancer to the ECS tasks. The default target port is determined from the protocol (port 80 for HTTP, port 443 for HTTPS). Default: HTTP.
@@ -8560,6 +8582,12 @@ class ApplicationLoadBalancedFargateService(
 
         jsii.create(self.__class__, self, [scope, id, props])
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
+    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
+        '''Uniquely identifies this class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))
+
     @builtins.property
     @jsii.member(jsii_name="assignPublicIp")
     def assign_public_ip(self) -> builtins.bool:
@@ -8708,7 +8736,7 @@ class ApplicationLoadBalancedFargateServiceProps(
         :param protocol_version: The protocol version to use. Default: ApplicationProtocolVersion.HTTP1
         :param public_load_balancer: Determines whether the Load Balancer will be internet-facing. Default: true
         :param record_type: Specifies whether the Route53 record should be a CNAME, an A record using the Alias feature or no record at all. This is useful if you need to work with DNS systems that do not support alias records. Default: ApplicationLoadBalancedServiceRecordType.ALIAS
-        :param redirect_http: Specifies whether the load balancer should redirect traffic on port 80 to port 443 to support HTTP->HTTPS redirects This is only valid if the protocol of the ALB is HTTPS. Default: false
+        :param redirect_http: Specifies whether the load balancer should redirect traffic on port 80 to the {@link listenerPort} to support HTTP->HTTPS redirects. This is only valid if the protocol of the ALB is HTTPS. Default: false
         :param service_name: The name of the service. Default: - CloudFormation-generated name.
         :param ssl_policy: The security policy that defines which ciphers and protocols are supported by the ALB Listener. Default: - The recommended elastic load balancing security policy
         :param target_protocol: The protocol for connections from the load balancer to the ECS tasks. The default target port is determined from the protocol (port 80 for HTTP, port 443 for HTTPS). Default: HTTP.
@@ -9177,7 +9205,9 @@ class ApplicationLoadBalancedFargateServiceProps(
 
     @builtins.property
     def redirect_http(self) -> typing.Optional[builtins.bool]:
-        '''Specifies whether the load balancer should redirect traffic on port 80 to port 443 to support HTTP->HTTPS redirects This is only valid if the protocol of the ALB is HTTPS.
+        '''Specifies whether the load balancer should redirect traffic on port 80 to the {@link listenerPort} to support HTTP->HTTPS redirects.
+
+        This is only valid if the protocol of the ALB is HTTPS.
 
         :default: false
         '''
@@ -10064,6 +10094,12 @@ class ApplicationMultipleTargetGroupsFargateService(
 
         jsii.create(self.__class__, self, [scope, id, props])
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
+    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
+        '''Uniquely identifies this class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))
+
     @builtins.property
     @jsii.member(jsii_name="assignPublicIp")
     def assign_public_ip(self) -> builtins.bool:
@@ -11428,6 +11464,12 @@ class NetworkLoadBalancedFargateService(
 
         jsii.create(self.__class__, self, [scope, id, props])
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
+    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
+        '''Uniquely identifies this class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))
+
     @builtins.property
     @jsii.member(jsii_name="assignPublicIp")
     def assign_public_ip(self) -> builtins.bool:
@@ -12650,7 +12692,9 @@ class NetworkMultipleTargetGroupsFargateService(
                 container_port=90,
                 listener="listener2"
             )
-            ]
+            ],
+            min_healthy_percent=100,
+            max_healthy_percent=200
         )
     '''
 
@@ -12660,6 +12704,8 @@ class NetworkMultipleTargetGroupsFargateService(
         id: builtins.str,
         *,
         assign_public_ip: typing.Optional[builtins.bool] = None,
+        max_healthy_percent: typing.Optional[jsii.Number] = None,
+        min_healthy_percent: typing.Optional[jsii.Number] = None,
         cloud_map_options: typing.Optional[typing.Union[_CloudMapOptions_444ee9f2, typing.Dict[builtins.str, typing.Any]]] = None,
         cluster: typing.Optional[_ICluster_16cddd09] = None,
         desired_count: typing.Optional[jsii.Number] = None,
@@ -12684,6 +12730,8 @@ class NetworkMultipleTargetGroupsFargateService(
         :param scope: -
         :param id: -
         :param assign_public_ip: Determines whether the service will be assigned a public IP address. Default: false
+        :param max_healthy_percent: The maximum number of tasks, specified as a percentage of the Amazon ECS service's DesiredCount value, that can run in a service during a deployment. Default: - 200%
+        :param min_healthy_percent: The minimum number of tasks, specified as a percentage of the Amazon ECS service's DesiredCount value, that must continue to run and remain healthy during a deployment. Default: - 50%
         :param cloud_map_options: The options for configuring an Amazon ECS service to use service discovery. Default: - AWS Cloud Map service discovery is not enabled.
         :param cluster: The name of the cluster that hosts the service. If a cluster is specified, the vpc construct should be omitted. Alternatively, you can omit both cluster and vpc. Default: - create a new cluster; if both cluster and vpc are omitted, a new VPC will be created for you.
         :param desired_count: The desired number of instantiations of the task definition to keep running on the service. The minimum value is 1 Default: - The default is 1 for all new services and uses the existing service's desired count when updating an existing service.
@@ -12709,6 +12757,8 @@ class NetworkMultipleTargetGroupsFargateService(
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         props = NetworkMultipleTargetGroupsFargateServiceProps(
             assign_public_ip=assign_public_ip,
+            max_healthy_percent=max_healthy_percent,
+            min_healthy_percent=min_healthy_percent,
             cloud_map_options=cloud_map_options,
             cluster=cluster,
             desired_count=desired_count,
@@ -12731,6 +12781,12 @@ class NetworkMultipleTargetGroupsFargateService(
 
         jsii.create(self.__class__, self, [scope, id, props])
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
+    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
+        '''Uniquely identifies this class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))
+
     @builtins.property
     @jsii.member(jsii_name="assignPublicIp")
     def assign_public_ip(self) -> builtins.bool:
@@ -12786,6 +12842,8 @@ class NetworkMultipleTargetGroupsFargateService(
         "runtime_platform": "runtimePlatform",
         "task_definition": "taskDefinition",
         "assign_public_ip": "assignPublicIp",
+        "max_healthy_percent": "maxHealthyPercent",
+        "min_healthy_percent": "minHealthyPercent",
     },
 )
 class NetworkMultipleTargetGroupsFargateServiceProps(
@@ -12814,6 +12872,8 @@ class NetworkMultipleTargetGroupsFargateServiceProps(
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
         task_definition: typing.Optional[_FargateTaskDefinition_83754b60] = None,
         assign_public_ip: typing.Optional[builtins.bool] = None,
+        max_healthy_percent: typing.Optional[jsii.Number] = None,
+        min_healthy_percent: typing.Optional[jsii.Number] = None,
     ) -> None:
         '''The properties for the NetworkMultipleTargetGroupsFargateService service.
 
@@ -12836,6 +12896,8 @@ class NetworkMultipleTargetGroupsFargateServiceProps(
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
         :param task_definition: The task definition to use for tasks in the service. TaskDefinition or TaskImageOptions must be specified, but not both. [disable-awslint:ref-via-interface] Default: - none
         :param assign_public_ip: Determines whether the service will be assigned a public IP address. Default: false
+        :param max_healthy_percent: The maximum number of tasks, specified as a percentage of the Amazon ECS service's DesiredCount value, that can run in a service during a deployment. Default: - 200%
+        :param min_healthy_percent: The minimum number of tasks, specified as a percentage of the Amazon ECS service's DesiredCount value, that must continue to run and remain healthy during a deployment. Default: - 50%
 
         :exampleMetadata: infused
 
@@ -12871,7 +12933,9 @@ class NetworkMultipleTargetGroupsFargateServiceProps(
                     container_port=90,
                     listener="listener2"
                 )
-                ]
+                ],
+                min_healthy_percent=100,
+                max_healthy_percent=200
             )
         '''
         if isinstance(cloud_map_options, dict):
@@ -12901,6 +12965,8 @@ class NetworkMultipleTargetGroupsFargateServiceProps(
             check_type(argname="argument runtime_platform", value=runtime_platform, expected_type=type_hints["runtime_platform"])
             check_type(argname="argument task_definition", value=task_definition, expected_type=type_hints["task_definition"])
             check_type(argname="argument assign_public_ip", value=assign_public_ip, expected_type=type_hints["assign_public_ip"])
+            check_type(argname="argument max_healthy_percent", value=max_healthy_percent, expected_type=type_hints["max_healthy_percent"])
+            check_type(argname="argument min_healthy_percent", value=min_healthy_percent, expected_type=type_hints["min_healthy_percent"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
         if cloud_map_options is not None:
             self._values["cloud_map_options"] = cloud_map_options
@@ -12940,6 +13006,10 @@ class NetworkMultipleTargetGroupsFargateServiceProps(
             self._values["task_definition"] = task_definition
         if assign_public_ip is not None:
             self._values["assign_public_ip"] = assign_public_ip
+        if max_healthy_percent is not None:
+            self._values["max_healthy_percent"] = max_healthy_percent
+        if min_healthy_percent is not None:
+            self._values["min_healthy_percent"] = min_healthy_percent
 
     @builtins.property
     def cloud_map_options(self) -> typing.Optional[_CloudMapOptions_444ee9f2]:
@@ -13175,6 +13245,24 @@ class NetworkMultipleTargetGroupsFargateServiceProps(
         result = self._values.get("assign_public_ip")
         return typing.cast(typing.Optional[builtins.bool], result)
 
+    @builtins.property
+    def max_healthy_percent(self) -> typing.Optional[jsii.Number]:
+        '''The maximum number of tasks, specified as a percentage of the Amazon ECS service's DesiredCount value, that can run in a service during a deployment.
+
+        :default: - 200%
+        '''
+        result = self._values.get("max_healthy_percent")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def min_healthy_percent(self) -> typing.Optional[jsii.Number]:
+        '''The minimum number of tasks, specified as a percentage of the Amazon ECS service's DesiredCount value, that must continue to run and remain healthy during a deployment.
+
+        :default: - 50%
+        '''
+        result = self._values.get("min_healthy_percent")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -14068,6 +14156,7 @@ class QueueProcessingFargateService(
         assign_public_ip: typing.Optional[builtins.bool] = None,
         container_name: typing.Optional[builtins.str] = None,
         health_check: typing.Optional[typing.Union[_HealthCheck_6459d04f, typing.Dict[builtins.str, typing.Any]]] = None,
+        health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
         security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
         task_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
         capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[_CapacityProviderStrategy_8d7b6657, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -14112,6 +14201,7 @@ class QueueProcessingFargateService(
         :param assign_public_ip: Specifies whether the task's elastic network interface receives a public IP address. If true, each task will receive a public IP address. Default: false
         :param container_name: Optional name for the container added. This name is not used when ``taskDefinition`` is provided. Default: - QueueProcessingContainer
         :param health_check: The health check command and associated configuration parameters for the container. Default: - Health check configuration from container.
+        :param health_check_grace_period: The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing target health checks after a task has first started. Default: - defaults to 60 seconds if at least one load balancer is in-use and it is not already set
         :param security_groups: The security groups to associate with the service. If you do not specify a security group, a new security group is created. Default: - A new security group is created.
         :param task_subnets: The subnets to associate with the service. Default: - Public subnets if ``assignPublicIp`` is set, otherwise the first available one of Private, Isolated, Public, in that order.
         :param capacity_provider_strategies: A list of Capacity Provider strategies used to place a service. Default: - undefined
@@ -14157,6 +14247,7 @@ class QueueProcessingFargateService(
             assign_public_ip=assign_public_ip,
             container_name=container_name,
             health_check=health_check,
+            health_check_grace_period=health_check_grace_period,
             security_groups=security_groups,
             task_subnets=task_subnets,
             capacity_provider_strategies=capacity_provider_strategies,
@@ -14251,6 +14342,7 @@ class QueueProcessingFargateService(
         "assign_public_ip": "assignPublicIp",
         "container_name": "containerName",
         "health_check": "healthCheck",
+        "health_check_grace_period": "healthCheckGracePeriod",
         "security_groups": "securityGroups",
         "task_subnets": "taskSubnets",
     },
@@ -14299,6 +14391,7 @@ class QueueProcessingFargateServiceProps(
         assign_public_ip: typing.Optional[builtins.bool] = None,
         container_name: typing.Optional[builtins.str] = None,
         health_check: typing.Optional[typing.Union[_HealthCheck_6459d04f, typing.Dict[builtins.str, typing.Any]]] = None,
+        health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
         security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
         task_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
@@ -14341,6 +14434,7 @@ class QueueProcessingFargateServiceProps(
         :param assign_public_ip: Specifies whether the task's elastic network interface receives a public IP address. If true, each task will receive a public IP address. Default: false
         :param container_name: Optional name for the container added. This name is not used when ``taskDefinition`` is provided. Default: - QueueProcessingContainer
         :param health_check: The health check command and associated configuration parameters for the container. Default: - Health check configuration from container.
+        :param health_check_grace_period: The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing target health checks after a task has first started. Default: - defaults to 60 seconds if at least one load balancer is in-use and it is not already set
         :param security_groups: The security groups to associate with the service. If you do not specify a security group, a new security group is created. Default: - A new security group is created.
         :param task_subnets: The subnets to associate with the service. Default: - Public subnets if ``assignPublicIp`` is set, otherwise the first available one of Private, Isolated, Public, in that order.
 
@@ -14416,6 +14510,7 @@ class QueueProcessingFargateServiceProps(
             check_type(argname="argument assign_public_ip", value=assign_public_ip, expected_type=type_hints["assign_public_ip"])
             check_type(argname="argument container_name", value=container_name, expected_type=type_hints["container_name"])
             check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
+            check_type(argname="argument health_check_grace_period", value=health_check_grace_period, expected_type=type_hints["health_check_grace_period"])
             check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
             check_type(argname="argument task_subnets", value=task_subnets, expected_type=type_hints["task_subnets"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
@@ -14493,6 +14588,8 @@ class QueueProcessingFargateServiceProps(
             self._values["container_name"] = container_name
         if health_check is not None:
             self._values["health_check"] = health_check
+        if health_check_grace_period is not None:
+            self._values["health_check_grace_period"] = health_check_grace_period
         if security_groups is not None:
             self._values["security_groups"] = security_groups
         if task_subnets is not None:
@@ -14937,6 +15034,15 @@ class QueueProcessingFargateServiceProps(
         result = self._values.get("health_check")
         return typing.cast(typing.Optional[_HealthCheck_6459d04f], result)
 
+    @builtins.property
+    def health_check_grace_period(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing target health checks after a task has first started.
+
+        :default: - defaults to 60 seconds if at least one load balancer is in-use and it is not already set
+        '''
+        result = self._values.get("health_check_grace_period")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
     @builtins.property
     def security_groups(self) -> typing.Optional[typing.List[_ISecurityGroup_acf8a799]]:
         '''The security groups to associate with the service.
@@ -17533,6 +17639,8 @@ def _typecheckingstub__d0896ef010a141982cad4e6363ddf5474e1d63a5c38dc712f84a1d13e
     id: builtins.str,
     *,
     assign_public_ip: typing.Optional[builtins.bool] = None,
+    max_healthy_percent: typing.Optional[jsii.Number] = None,
+    min_healthy_percent: typing.Optional[jsii.Number] = None,
     cloud_map_options: typing.Optional[typing.Union[_CloudMapOptions_444ee9f2, typing.Dict[builtins.str, typing.Any]]] = None,
     cluster: typing.Optional[_ICluster_16cddd09] = None,
     desired_count: typing.Optional[jsii.Number] = None,
@@ -17576,6 +17684,8 @@ def _typecheckingstub__052b2be34bb887cde358099c21efe7f3e968827a5a4e4c975e35f96da
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
     task_definition: typing.Optional[_FargateTaskDefinition_83754b60] = None,
     assign_public_ip: typing.Optional[builtins.bool] = None,
+    max_healthy_percent: typing.Optional[jsii.Number] = None,
+    min_healthy_percent: typing.Optional[jsii.Number] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -17671,6 +17781,7 @@ def _typecheckingstub__f7f1cc7ffec4414918cb71e7371c364ad046987205ab7eb0cbe7ad6fc
     assign_public_ip: typing.Optional[builtins.bool] = None,
     container_name: typing.Optional[builtins.str] = None,
     health_check: typing.Optional[typing.Union[_HealthCheck_6459d04f, typing.Dict[builtins.str, typing.Any]]] = None,
+    health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
     security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
     task_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
     capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[_CapacityProviderStrategy_8d7b6657, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -17750,6 +17861,7 @@ def _typecheckingstub__9959b47db027250927e99f3cbc475109465e4e426a52383adb8d29f22
     assign_public_ip: typing.Optional[builtins.bool] = None,
     container_name: typing.Optional[builtins.str] = None,
     health_check: typing.Optional[typing.Union[_HealthCheck_6459d04f, typing.Dict[builtins.str, typing.Any]]] = None,
+    health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
     security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
     task_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None: