aws-cdk-lib 2.207.0__py3-none-any.whl → 2.209.0__py3-none-any.whl

aws_cdk/aws_ecs/__init__.py

@@ -2118,6 +2118,41 @@ Amazon ECS supports native blue/green deployments that allow you to deploy new v
 
 [Amazon ECS blue/green deployments](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-blue-green.html)
 
+### Using Fargate L2 constructs for Blue/Green Feature
+
+```python
+import aws_cdk.aws_lambda as lambda_
+
+# cluster: ecs.Cluster
+# task_definition: ecs.TaskDefinition
+# lambda_hook: lambda.Function
+# blue_target_group: elbv2.ApplicationTargetGroup
+# green_target_group: elbv2.ApplicationTargetGroup
+# prod_listener_rule: elbv2.ApplicationListenerRule
+
+
+service = ecs.FargateService(self, "Service",
+    cluster=cluster,
+    task_definition=task_definition,
+    deployment_strategy=ecs.DeploymentStrategy.BLUE_GREEN
+)
+
+service.add_lifecycle_hook(ecs.DeploymentLifecycleLambdaTarget(lambda_hook, "PreScaleHook",
+    lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
+))
+
+target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+    container_name="nginx",
+    container_port=80,
+    protocol=ecs.Protocol.TCP
+), ecs.AlternateTarget("AlternateTarget",
+    alternate_target_group=green_target_group,
+    production_listener=ecs.ListenerRuleConfiguration.application_listener_rule(prod_listener_rule)
+))
+
+target.attach_to_application_target_group(blue_target_group)
+```
+
 ### Using Escape Hatches for Blue/Green Features
 
 The new blue/green deployment features are added to CloudFormation but not yet available in the CDK L2 constructs, you can use escape hatches to access them through the L1 (CfnService) construct.
@@ -2338,6 +2373,7 @@ from ..aws_elasticloadbalancingv2 import (
     AddApplicationTargetsProps as _AddApplicationTargetsProps_76c7d190,
     AddNetworkTargetsProps as _AddNetworkTargetsProps_ce6bdf17,
     ApplicationListener as _ApplicationListener_e0620bf5,
+    ApplicationListenerRule as _ApplicationListenerRule_f93ff606,
     ApplicationProtocol as _ApplicationProtocol_aa5e9f29,
     ApplicationProtocolVersion as _ApplicationProtocolVersion_dddfe47b,
     ApplicationTargetGroup as _ApplicationTargetGroup_906fe365,
@@ -2346,6 +2382,7 @@ from ..aws_elasticloadbalancingv2 import (
     IApplicationTargetGroup as _IApplicationTargetGroup_57799827,
     INetworkLoadBalancerTarget as _INetworkLoadBalancerTarget_688b169f,
     INetworkTargetGroup as _INetworkTargetGroup_abca2df7,
+    ITargetGroup as _ITargetGroup_83c6f8c4,
     ListenerCondition as _ListenerCondition_e8416430,
     LoadBalancerTargetProps as _LoadBalancerTargetProps_4c30a73c,
     NetworkListener as _NetworkListener_539c17bf,
@@ -2359,6 +2396,7 @@ from ..aws_iam import (
     PolicyStatement as _PolicyStatement_0fe33853,
 )
 from ..aws_kms import IKey as _IKey_5f11635f
+from ..aws_lambda import IFunction as _IFunction_6adb0ab8
 from ..aws_logs import (
     ILogGroup as _ILogGroup_3c4fa718, RetentionDays as _RetentionDays_070f99f0
 )
@@ -3286,6 +3324,305 @@ class AlarmBehavior(enum.Enum):
     '''
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_ecs.AlternateTargetConfig",
+    jsii_struct_bases=[],
+    name_mapping={
+        "alternate_target_group_arn": "alternateTargetGroupArn",
+        "role_arn": "roleArn",
+        "production_listener_rule": "productionListenerRule",
+        "test_listener_rule": "testListenerRule",
+    },
+)
+class AlternateTargetConfig:
+    def __init__(
+        self,
+        *,
+        alternate_target_group_arn: builtins.str,
+        role_arn: builtins.str,
+        production_listener_rule: typing.Optional[builtins.str] = None,
+        test_listener_rule: typing.Optional[builtins.str] = None,
+    ) -> None:
+        '''Configuration returned by AlternateTargetConfiguration.bind().
+
+        :param alternate_target_group_arn: The ARN of the alternate target group.
+        :param role_arn: The IAM role ARN for the configuration. Default: - a new role will be created
+        :param production_listener_rule: The production listener rule ARN (ALB) or listener ARN (NLB). Default: - none
+        :param test_listener_rule: The test listener rule ARN (ALB) or listener ARN (NLB). Default: - none
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            from aws_cdk import aws_ecs as ecs
+            
+            alternate_target_config = ecs.AlternateTargetConfig(
+                alternate_target_group_arn="alternateTargetGroupArn",
+                role_arn="roleArn",
+            
+                # the properties below are optional
+                production_listener_rule="productionListenerRule",
+                test_listener_rule="testListenerRule"
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__792a358f64361d957b07e1ed7f1116dd993837c77bffc674ebb1385615159cd7)
+            check_type(argname="argument alternate_target_group_arn", value=alternate_target_group_arn, expected_type=type_hints["alternate_target_group_arn"])
+            check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
+            check_type(argname="argument production_listener_rule", value=production_listener_rule, expected_type=type_hints["production_listener_rule"])
+            check_type(argname="argument test_listener_rule", value=test_listener_rule, expected_type=type_hints["test_listener_rule"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "alternate_target_group_arn": alternate_target_group_arn,
+            "role_arn": role_arn,
+        }
+        if production_listener_rule is not None:
+            self._values["production_listener_rule"] = production_listener_rule
+        if test_listener_rule is not None:
+            self._values["test_listener_rule"] = test_listener_rule
+
+    @builtins.property
+    def alternate_target_group_arn(self) -> builtins.str:
+        '''The ARN of the alternate target group.'''
+        result = self._values.get("alternate_target_group_arn")
+        assert result is not None, "Required property 'alternate_target_group_arn' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def role_arn(self) -> builtins.str:
+        '''The IAM role ARN for the configuration.
+
+        :default: - a new role will be created
+        '''
+        result = self._values.get("role_arn")
+        assert result is not None, "Required property 'role_arn' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def production_listener_rule(self) -> typing.Optional[builtins.str]:
+        '''The production listener rule ARN (ALB) or listener ARN (NLB).
+
+        :default: - none
+        '''
+        result = self._values.get("production_listener_rule")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def test_listener_rule(self) -> typing.Optional[builtins.str]:
+        '''The test listener rule ARN (ALB) or listener ARN (NLB).
+
+        :default: - none
+        '''
+        result = self._values.get("test_listener_rule")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "AlternateTargetConfig(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_ecs.AlternateTargetOptions",
+    jsii_struct_bases=[],
+    name_mapping={"role": "role", "test_listener": "testListener"},
+)
+class AlternateTargetOptions:
+    def __init__(
+        self,
+        *,
+        role: typing.Optional[_IRole_235f5d8e] = None,
+        test_listener: typing.Optional["ListenerRuleConfiguration"] = None,
+    ) -> None:
+        '''Options for AlternateTarget configuration.
+
+        :param role: The IAM role for the configuration. Default: - a new role will be created
+        :param test_listener: The test listener configuration. Default: - none
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            from aws_cdk import aws_ecs as ecs
+            from aws_cdk import aws_iam as iam
+            
+            # listener_rule_configuration: ecs.ListenerRuleConfiguration
+            # role: iam.Role
+            
+            alternate_target_options = ecs.AlternateTargetOptions(
+                role=role,
+                test_listener=listener_rule_configuration
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__419cc917bedbbd0a41ca044bcc54720f5a35bdc4f2dca6e11ae40da3ed05758d)
+            check_type(argname="argument role", value=role, expected_type=type_hints["role"])
+            check_type(argname="argument test_listener", value=test_listener, expected_type=type_hints["test_listener"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if role is not None:
+            self._values["role"] = role
+        if test_listener is not None:
+            self._values["test_listener"] = test_listener
+
+    @builtins.property
+    def role(self) -> typing.Optional[_IRole_235f5d8e]:
+        '''The IAM role for the configuration.
+
+        :default: - a new role will be created
+        '''
+        result = self._values.get("role")
+        return typing.cast(typing.Optional[_IRole_235f5d8e], result)
+
+    @builtins.property
+    def test_listener(self) -> typing.Optional["ListenerRuleConfiguration"]:
+        '''The test listener configuration.
+
+        :default: - none
+        '''
+        result = self._values.get("test_listener")
+        return typing.cast(typing.Optional["ListenerRuleConfiguration"], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "AlternateTargetOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_ecs.AlternateTargetProps",
+    jsii_struct_bases=[AlternateTargetOptions],
+    name_mapping={
+        "role": "role",
+        "test_listener": "testListener",
+        "alternate_target_group": "alternateTargetGroup",
+        "production_listener": "productionListener",
+    },
+)
+class AlternateTargetProps(AlternateTargetOptions):
+    def __init__(
+        self,
+        *,
+        role: typing.Optional[_IRole_235f5d8e] = None,
+        test_listener: typing.Optional["ListenerRuleConfiguration"] = None,
+        alternate_target_group: _ITargetGroup_83c6f8c4,
+        production_listener: "ListenerRuleConfiguration",
+    ) -> None:
+        '''Properties for AlternateTarget configuration.
+
+        :param role: The IAM role for the configuration. Default: - a new role will be created
+        :param test_listener: The test listener configuration. Default: - none
+        :param alternate_target_group: The alternate target group.
+        :param production_listener: The production listener rule ARN (ALB) or listener ARN (NLB).
+
+        :exampleMetadata: infused
+
+        Example::
+
+            import aws_cdk.aws_lambda as lambda_
+            
+            # cluster: ecs.Cluster
+            # task_definition: ecs.TaskDefinition
+            # lambda_hook: lambda.Function
+            # blue_target_group: elbv2.ApplicationTargetGroup
+            # green_target_group: elbv2.ApplicationTargetGroup
+            # prod_listener_rule: elbv2.ApplicationListenerRule
+            
+            
+            service = ecs.FargateService(self, "Service",
+                cluster=cluster,
+                task_definition=task_definition,
+                deployment_strategy=ecs.DeploymentStrategy.BLUE_GREEN
+            )
+            
+            service.add_lifecycle_hook(ecs.DeploymentLifecycleLambdaTarget(lambda_hook, "PreScaleHook",
+                lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
+            ))
+            
+            target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+                container_name="nginx",
+                container_port=80,
+                protocol=ecs.Protocol.TCP
+            ), ecs.AlternateTarget("AlternateTarget",
+                alternate_target_group=green_target_group,
+                production_listener=ecs.ListenerRuleConfiguration.application_listener_rule(prod_listener_rule)
+            ))
+            
+            target.attach_to_application_target_group(blue_target_group)
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__308a285b9e7be7ba49d4d78caf88537a973f5504d7b7519fb1fe4ab1c987b690)
+            check_type(argname="argument role", value=role, expected_type=type_hints["role"])
+            check_type(argname="argument test_listener", value=test_listener, expected_type=type_hints["test_listener"])
+            check_type(argname="argument alternate_target_group", value=alternate_target_group, expected_type=type_hints["alternate_target_group"])
+            check_type(argname="argument production_listener", value=production_listener, expected_type=type_hints["production_listener"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "alternate_target_group": alternate_target_group,
+            "production_listener": production_listener,
+        }
+        if role is not None:
+            self._values["role"] = role
+        if test_listener is not None:
+            self._values["test_listener"] = test_listener
+
+    @builtins.property
+    def role(self) -> typing.Optional[_IRole_235f5d8e]:
+        '''The IAM role for the configuration.
+
+        :default: - a new role will be created
+        '''
+        result = self._values.get("role")
+        return typing.cast(typing.Optional[_IRole_235f5d8e], result)
+
+    @builtins.property
+    def test_listener(self) -> typing.Optional["ListenerRuleConfiguration"]:
+        '''The test listener configuration.
+
+        :default: - none
+        '''
+        result = self._values.get("test_listener")
+        return typing.cast(typing.Optional["ListenerRuleConfiguration"], result)
+
+    @builtins.property
+    def alternate_target_group(self) -> _ITargetGroup_83c6f8c4:
+        '''The alternate target group.'''
+        result = self._values.get("alternate_target_group")
+        assert result is not None, "Required property 'alternate_target_group' is missing"
+        return typing.cast(_ITargetGroup_83c6f8c4, result)
+
+    @builtins.property
+    def production_listener(self) -> "ListenerRuleConfiguration":
+        '''The production listener rule ARN (ALB) or listener ARN (NLB).'''
+        result = self._values.get("production_listener")
+        assert result is not None, "Required property 'production_listener' is missing"
+        return typing.cast("ListenerRuleConfiguration", result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "AlternateTargetProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.enum(jsii_type="aws-cdk-lib.aws_ecs.AmiHardwareType")
 class AmiHardwareType(enum.Enum):
     '''The ECS-optimized AMI variant to use.
@@ -5097,15 +5434,18 @@ class BaseMountPoint:
     jsii_struct_bases=[],
     name_mapping={
         "cluster": "cluster",
+        "bake_time": "bakeTime",
         "capacity_provider_strategies": "capacityProviderStrategies",
         "circuit_breaker": "circuitBreaker",
         "cloud_map_options": "cloudMapOptions",
         "deployment_alarms": "deploymentAlarms",
         "deployment_controller": "deploymentController",
+        "deployment_strategy": "deploymentStrategy",
         "desired_count": "desiredCount",
         "enable_ecs_managed_tags": "enableECSManagedTags",
         "enable_execute_command": "enableExecuteCommand",
         "health_check_grace_period": "healthCheckGracePeriod",
+        "lifecycle_hooks": "lifecycleHooks",
         "max_healthy_percent": "maxHealthyPercent",
         "min_healthy_percent": "minHealthyPercent",
         "propagate_tags": "propagateTags",
@@ -5120,15 +5460,18 @@ class BaseServiceOptions:
         self,
         *,
         cluster: "ICluster",
+        bake_time: typing.Optional[_Duration_4839e8c3] = None,
         capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union["CapacityProviderStrategy", typing.Dict[builtins.str, typing.Any]]]] = None,
         circuit_breaker: typing.Optional[typing.Union["DeploymentCircuitBreaker", typing.Dict[builtins.str, typing.Any]]] = None,
         cloud_map_options: typing.Optional[typing.Union["CloudMapOptions", typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_alarms: typing.Optional[typing.Union["DeploymentAlarmConfig", typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_controller: typing.Optional[typing.Union["DeploymentController", typing.Dict[builtins.str, typing.Any]]] = None,
+        deployment_strategy: typing.Optional["DeploymentStrategy"] = None,
         desired_count: typing.Optional[jsii.Number] = None,
         enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
         enable_execute_command: typing.Optional[builtins.bool] = None,
         health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+        lifecycle_hooks: typing.Optional[typing.Sequence["IDeploymentLifecycleHookTarget"]] = None,
         max_healthy_percent: typing.Optional[jsii.Number] = None,
         min_healthy_percent: typing.Optional[jsii.Number] = None,
         propagate_tags: typing.Optional["PropagatedTagSource"] = None,
@@ -5140,15 +5483,18 @@ class BaseServiceOptions:
         '''The properties for the base Ec2Service or FargateService service.
 
         :param cluster: The name of the cluster that hosts the service.
+        :param bake_time: bake time minutes for service. Default: - none
         :param capacity_provider_strategies: A list of Capacity Provider strategies used to place a service. Default: - undefined
         :param circuit_breaker: Whether to enable the deployment circuit breaker. If this property is defined, circuit breaker will be implicitly enabled. Default: - disabled
         :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 deployment_alarms: The alarm(s) to monitor during deployment, and behavior to apply if at least one enters a state of alarm during the deployment or bake time. Default: - No alarms will be monitored during deployment.
         :param deployment_controller: Specifies which deployment controller to use for the service. For more information, see `Amazon ECS Deployment Types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html>`_ Default: - Rolling update (ECS)
+        :param deployment_strategy: The deployment strategy to use for the service. Default: ROLLING
         :param desired_count: The desired number of instantiations of the task definition to keep running on the service. Default: - When creating the service, default is 1; when updating the service, default uses the current task number.
         :param enable_ecs_managed_tags: Specifies whether to enable Amazon ECS managed tags for the tasks within the service. For more information, see `Tagging Your Amazon ECS Resources <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html>`_ Default: false
         :param enable_execute_command: Whether to enable the ability to execute into a container. Default: - undefined
         :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 lifecycle_hooks: The lifecycle hooks to execute during deployment stages. Default: - none;
         :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: - 100 if daemon, otherwise 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: - 0 if daemon, otherwise 50
         :param propagate_tags: Specifies whether to propagate the tags from the task definition or the service to the tasks in the service. Valid values are: PropagatedTagSource.SERVICE, PropagatedTagSource.TASK_DEFINITION or PropagatedTagSource.NONE Default: PropagatedTagSource.NONE
@@ -5171,6 +5517,7 @@ class BaseServiceOptions:
             
             # cluster: ecs.Cluster
             # container_definition: ecs.ContainerDefinition
+            # deployment_lifecycle_hook_target: ecs.IDeploymentLifecycleHookTarget
             # key: kms.Key
             # log_driver: ecs.LogDriver
             # namespace: servicediscovery.INamespace
@@ -5182,6 +5529,7 @@ class BaseServiceOptions:
                 cluster=cluster,
             
                 # the properties below are optional
+                bake_time=cdk.Duration.minutes(30),
                 capacity_provider_strategies=[ecs.CapacityProviderStrategy(
                     capacity_provider="capacityProvider",
             
@@ -5211,10 +5559,12 @@ class BaseServiceOptions:
                 deployment_controller=ecs.DeploymentController(
                     type=ecs.DeploymentControllerType.ECS
                 ),
+                deployment_strategy=ecs.DeploymentStrategy.ROLLING,
                 desired_count=123,
                 enable_eCSManaged_tags=False,
                 enable_execute_command=False,
                 health_check_grace_period=cdk.Duration.minutes(30),
+                lifecycle_hooks=[deployment_lifecycle_hook_target],
                 max_healthy_percent=123,
                 min_healthy_percent=123,
                 propagate_tags=ecs.PropagatedTagSource.SERVICE,
@@ -5256,15 +5606,18 @@ class BaseServiceOptions:
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__c2e0ba28c74987301a54b0d197b791a6a94084b5f40d15304ffabf113b3f7daa)
             check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
+            check_type(argname="argument bake_time", value=bake_time, expected_type=type_hints["bake_time"])
             check_type(argname="argument capacity_provider_strategies", value=capacity_provider_strategies, expected_type=type_hints["capacity_provider_strategies"])
             check_type(argname="argument circuit_breaker", value=circuit_breaker, expected_type=type_hints["circuit_breaker"])
             check_type(argname="argument cloud_map_options", value=cloud_map_options, expected_type=type_hints["cloud_map_options"])
             check_type(argname="argument deployment_alarms", value=deployment_alarms, expected_type=type_hints["deployment_alarms"])
             check_type(argname="argument deployment_controller", value=deployment_controller, expected_type=type_hints["deployment_controller"])
+            check_type(argname="argument deployment_strategy", value=deployment_strategy, expected_type=type_hints["deployment_strategy"])
             check_type(argname="argument desired_count", value=desired_count, expected_type=type_hints["desired_count"])
             check_type(argname="argument enable_ecs_managed_tags", value=enable_ecs_managed_tags, expected_type=type_hints["enable_ecs_managed_tags"])
             check_type(argname="argument enable_execute_command", value=enable_execute_command, expected_type=type_hints["enable_execute_command"])
             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 lifecycle_hooks", value=lifecycle_hooks, expected_type=type_hints["lifecycle_hooks"])
             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"])
             check_type(argname="argument propagate_tags", value=propagate_tags, expected_type=type_hints["propagate_tags"])
@@ -5275,6 +5628,8 @@ class BaseServiceOptions:
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "cluster": cluster,
         }
+        if bake_time is not None:
+            self._values["bake_time"] = bake_time
         if capacity_provider_strategies is not None:
             self._values["capacity_provider_strategies"] = capacity_provider_strategies
         if circuit_breaker is not None:
@@ -5285,6 +5640,8 @@ class BaseServiceOptions:
             self._values["deployment_alarms"] = deployment_alarms
         if deployment_controller is not None:
             self._values["deployment_controller"] = deployment_controller
+        if deployment_strategy is not None:
+            self._values["deployment_strategy"] = deployment_strategy
         if desired_count is not None:
             self._values["desired_count"] = desired_count
         if enable_ecs_managed_tags is not None:
@@ -5293,6 +5650,8 @@ class BaseServiceOptions:
             self._values["enable_execute_command"] = enable_execute_command
         if health_check_grace_period is not None:
             self._values["health_check_grace_period"] = health_check_grace_period
+        if lifecycle_hooks is not None:
+            self._values["lifecycle_hooks"] = lifecycle_hooks
         if max_healthy_percent is not None:
             self._values["max_healthy_percent"] = max_healthy_percent
         if min_healthy_percent is not None:
@@ -5315,6 +5674,15 @@ class BaseServiceOptions:
         assert result is not None, "Required property 'cluster' is missing"
         return typing.cast("ICluster", result)
 
+    @builtins.property
+    def bake_time(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''bake time minutes for service.
+
+        :default: - none
+        '''
+        result = self._values.get("bake_time")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
     @builtins.property
     def capacity_provider_strategies(
         self,
@@ -5368,6 +5736,15 @@ class BaseServiceOptions:
         result = self._values.get("deployment_controller")
         return typing.cast(typing.Optional["DeploymentController"], result)
 
+    @builtins.property
+    def deployment_strategy(self) -> typing.Optional["DeploymentStrategy"]:
+        '''The deployment strategy to use for the service.
+
+        :default: ROLLING
+        '''
+        result = self._values.get("deployment_strategy")
+        return typing.cast(typing.Optional["DeploymentStrategy"], result)
+
     @builtins.property
     def desired_count(self) -> typing.Optional[jsii.Number]:
         '''The desired number of instantiations of the task definition to keep running on the service.
@@ -5410,6 +5787,17 @@ class BaseServiceOptions:
         result = self._values.get("health_check_grace_period")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
+    @builtins.property
+    def lifecycle_hooks(
+        self,
+    ) -> typing.Optional[typing.List["IDeploymentLifecycleHookTarget"]]:
+        '''The lifecycle hooks to execute during deployment stages.
+
+        :default: - none;
+        '''
+        result = self._values.get("lifecycle_hooks")
+        return typing.cast(typing.Optional[typing.List["IDeploymentLifecycleHookTarget"]], 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.
@@ -5500,15 +5888,18 @@ class BaseServiceOptions:
     jsii_struct_bases=[BaseServiceOptions],
     name_mapping={
         "cluster": "cluster",
+        "bake_time": "bakeTime",
         "capacity_provider_strategies": "capacityProviderStrategies",
         "circuit_breaker": "circuitBreaker",
         "cloud_map_options": "cloudMapOptions",
         "deployment_alarms": "deploymentAlarms",
         "deployment_controller": "deploymentController",
+        "deployment_strategy": "deploymentStrategy",
         "desired_count": "desiredCount",
         "enable_ecs_managed_tags": "enableECSManagedTags",
         "enable_execute_command": "enableExecuteCommand",
         "health_check_grace_period": "healthCheckGracePeriod",
+        "lifecycle_hooks": "lifecycleHooks",
         "max_healthy_percent": "maxHealthyPercent",
         "min_healthy_percent": "minHealthyPercent",
         "propagate_tags": "propagateTags",
@@ -5524,15 +5915,18 @@ class BaseServiceProps(BaseServiceOptions):
         self,
         *,
         cluster: "ICluster",
+        bake_time: typing.Optional[_Duration_4839e8c3] = None,
         capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union["CapacityProviderStrategy", typing.Dict[builtins.str, typing.Any]]]] = None,
         circuit_breaker: typing.Optional[typing.Union["DeploymentCircuitBreaker", typing.Dict[builtins.str, typing.Any]]] = None,
         cloud_map_options: typing.Optional[typing.Union["CloudMapOptions", typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_alarms: typing.Optional[typing.Union["DeploymentAlarmConfig", typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_controller: typing.Optional[typing.Union["DeploymentController", typing.Dict[builtins.str, typing.Any]]] = None,
+        deployment_strategy: typing.Optional["DeploymentStrategy"] = None,
         desired_count: typing.Optional[jsii.Number] = None,
         enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
         enable_execute_command: typing.Optional[builtins.bool] = None,
         health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+        lifecycle_hooks: typing.Optional[typing.Sequence["IDeploymentLifecycleHookTarget"]] = None,
         max_healthy_percent: typing.Optional[jsii.Number] = None,
         min_healthy_percent: typing.Optional[jsii.Number] = None,
         propagate_tags: typing.Optional["PropagatedTagSource"] = None,
@@ -5545,15 +5939,18 @@ class BaseServiceProps(BaseServiceOptions):
         '''Complete base service properties that are required to be supplied by the implementation of the BaseService class.
 
         :param cluster: The name of the cluster that hosts the service.
+        :param bake_time: bake time minutes for service. Default: - none
         :param capacity_provider_strategies: A list of Capacity Provider strategies used to place a service. Default: - undefined
         :param circuit_breaker: Whether to enable the deployment circuit breaker. If this property is defined, circuit breaker will be implicitly enabled. Default: - disabled
         :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 deployment_alarms: The alarm(s) to monitor during deployment, and behavior to apply if at least one enters a state of alarm during the deployment or bake time. Default: - No alarms will be monitored during deployment.
         :param deployment_controller: Specifies which deployment controller to use for the service. For more information, see `Amazon ECS Deployment Types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html>`_ Default: - Rolling update (ECS)
+        :param deployment_strategy: The deployment strategy to use for the service. Default: ROLLING
         :param desired_count: The desired number of instantiations of the task definition to keep running on the service. Default: - When creating the service, default is 1; when updating the service, default uses the current task number.
         :param enable_ecs_managed_tags: Specifies whether to enable Amazon ECS managed tags for the tasks within the service. For more information, see `Tagging Your Amazon ECS Resources <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html>`_ Default: false
         :param enable_execute_command: Whether to enable the ability to execute into a container. Default: - undefined
         :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 lifecycle_hooks: The lifecycle hooks to execute during deployment stages. Default: - none;
         :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: - 100 if daemon, otherwise 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: - 0 if daemon, otherwise 50
         :param propagate_tags: Specifies whether to propagate the tags from the task definition or the service to the tasks in the service. Valid values are: PropagatedTagSource.SERVICE, PropagatedTagSource.TASK_DEFINITION or PropagatedTagSource.NONE Default: PropagatedTagSource.NONE
@@ -5577,6 +5974,7 @@ class BaseServiceProps(BaseServiceOptions):
             
             # cluster: ecs.Cluster
             # container_definition: ecs.ContainerDefinition
+            # deployment_lifecycle_hook_target: ecs.IDeploymentLifecycleHookTarget
             # key: kms.Key
             # log_driver: ecs.LogDriver
             # namespace: servicediscovery.INamespace
@@ -5589,6 +5987,7 @@ class BaseServiceProps(BaseServiceOptions):
                 launch_type=ecs.LaunchType.EC2,
             
                 # the properties below are optional
+                bake_time=cdk.Duration.minutes(30),
                 capacity_provider_strategies=[ecs.CapacityProviderStrategy(
                     capacity_provider="capacityProvider",
             
@@ -5618,10 +6017,12 @@ class BaseServiceProps(BaseServiceOptions):
                 deployment_controller=ecs.DeploymentController(
                     type=ecs.DeploymentControllerType.ECS
                 ),
+                deployment_strategy=ecs.DeploymentStrategy.ROLLING,
                 desired_count=123,
                 enable_eCSManaged_tags=False,
                 enable_execute_command=False,
                 health_check_grace_period=cdk.Duration.minutes(30),
+                lifecycle_hooks=[deployment_lifecycle_hook_target],
                 max_healthy_percent=123,
                 min_healthy_percent=123,
                 propagate_tags=ecs.PropagatedTagSource.SERVICE,
@@ -5663,15 +6064,18 @@ class BaseServiceProps(BaseServiceOptions):
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__3ecfd95265b873c2042a9d5cb8465a48f9e325e2271c18461e2b266333563d84)
             check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
+            check_type(argname="argument bake_time", value=bake_time, expected_type=type_hints["bake_time"])
             check_type(argname="argument capacity_provider_strategies", value=capacity_provider_strategies, expected_type=type_hints["capacity_provider_strategies"])
             check_type(argname="argument circuit_breaker", value=circuit_breaker, expected_type=type_hints["circuit_breaker"])
             check_type(argname="argument cloud_map_options", value=cloud_map_options, expected_type=type_hints["cloud_map_options"])
             check_type(argname="argument deployment_alarms", value=deployment_alarms, expected_type=type_hints["deployment_alarms"])
             check_type(argname="argument deployment_controller", value=deployment_controller, expected_type=type_hints["deployment_controller"])
+            check_type(argname="argument deployment_strategy", value=deployment_strategy, expected_type=type_hints["deployment_strategy"])
             check_type(argname="argument desired_count", value=desired_count, expected_type=type_hints["desired_count"])
             check_type(argname="argument enable_ecs_managed_tags", value=enable_ecs_managed_tags, expected_type=type_hints["enable_ecs_managed_tags"])
             check_type(argname="argument enable_execute_command", value=enable_execute_command, expected_type=type_hints["enable_execute_command"])
             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 lifecycle_hooks", value=lifecycle_hooks, expected_type=type_hints["lifecycle_hooks"])
             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"])
             check_type(argname="argument propagate_tags", value=propagate_tags, expected_type=type_hints["propagate_tags"])
@@ -5684,6 +6088,8 @@ class BaseServiceProps(BaseServiceOptions):
             "cluster": cluster,
             "launch_type": launch_type,
         }
+        if bake_time is not None:
+            self._values["bake_time"] = bake_time
         if capacity_provider_strategies is not None:
             self._values["capacity_provider_strategies"] = capacity_provider_strategies
         if circuit_breaker is not None:
@@ -5694,6 +6100,8 @@ class BaseServiceProps(BaseServiceOptions):
             self._values["deployment_alarms"] = deployment_alarms
         if deployment_controller is not None:
             self._values["deployment_controller"] = deployment_controller
+        if deployment_strategy is not None:
+            self._values["deployment_strategy"] = deployment_strategy
         if desired_count is not None:
             self._values["desired_count"] = desired_count
         if enable_ecs_managed_tags is not None:
@@ -5702,6 +6110,8 @@ class BaseServiceProps(BaseServiceOptions):
             self._values["enable_execute_command"] = enable_execute_command
         if health_check_grace_period is not None:
             self._values["health_check_grace_period"] = health_check_grace_period
+        if lifecycle_hooks is not None:
+            self._values["lifecycle_hooks"] = lifecycle_hooks
         if max_healthy_percent is not None:
             self._values["max_healthy_percent"] = max_healthy_percent
         if min_healthy_percent is not None:
@@ -5724,6 +6134,15 @@ class BaseServiceProps(BaseServiceOptions):
         assert result is not None, "Required property 'cluster' is missing"
         return typing.cast("ICluster", result)
 
+    @builtins.property
+    def bake_time(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''bake time minutes for service.
+
+        :default: - none
+        '''
+        result = self._values.get("bake_time")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
     @builtins.property
     def capacity_provider_strategies(
         self,
@@ -5777,6 +6196,15 @@ class BaseServiceProps(BaseServiceOptions):
         result = self._values.get("deployment_controller")
         return typing.cast(typing.Optional["DeploymentController"], result)
 
+    @builtins.property
+    def deployment_strategy(self) -> typing.Optional["DeploymentStrategy"]:
+        '''The deployment strategy to use for the service.
+
+        :default: ROLLING
+        '''
+        result = self._values.get("deployment_strategy")
+        return typing.cast(typing.Optional["DeploymentStrategy"], result)
+
     @builtins.property
     def desired_count(self) -> typing.Optional[jsii.Number]:
         '''The desired number of instantiations of the task definition to keep running on the service.
@@ -5819,6 +6247,17 @@ class BaseServiceProps(BaseServiceOptions):
         result = self._values.get("health_check_grace_period")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
+    @builtins.property
+    def lifecycle_hooks(
+        self,
+    ) -> typing.Optional[typing.List["IDeploymentLifecycleHookTarget"]]:
+        '''The lifecycle hooks to execute during deployment stages.
+
+        :default: - none;
+        '''
+        result = self._values.get("lifecycle_hooks")
+        return typing.cast(typing.Optional[typing.List["IDeploymentLifecycleHookTarget"]], 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.
@@ -9239,11 +9678,14 @@ class CfnService(
             role_arn: typing.Optional[builtins.str] = None,
             test_listener_rule: typing.Optional[builtins.str] = None,
         ) -> None:
-            '''
-            :param alternate_target_group_arn: 
-            :param production_listener_rule: 
-            :param role_arn: 
-            :param test_listener_rule: 
+            '''The advanced settings for a load balancer used in blue/green deployments.
+
+            Specify the alternate target group, listener rules, and IAM role required for traffic shifting during blue/green deployments. For more information, see `Required resources for Amazon ECS blue/green deployments <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/blue-green-deployment-implementation.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
+
+            :param alternate_target_group_arn: The Amazon Resource Name (ARN) of the alternate target group for Amazon ECS blue/green deployments.
+            :param production_listener_rule: The Amazon Resource Name (ARN) that that identifies the production listener rule (in the case of an Application Load Balancer) or listener (in the case for an Network Load Balancer) for routing production traffic.
+            :param role_arn: The Amazon Resource Name (ARN) of the IAM role that grants Amazon ECS permission to call the Elastic Load Balancing APIs for you.
+            :param test_listener_rule: The Amazon Resource Name (ARN) that identifies ) that identifies the test listener rule (in the case of an Application Load Balancer) or listener (in the case for an Network Load Balancer) for routing test traffic.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-advancedconfiguration.html
             :exampleMetadata: fixture=_generated
@@ -9281,7 +9723,8 @@ class CfnService(
 
         @builtins.property
         def alternate_target_group_arn(self) -> builtins.str:
-            '''
+            '''The Amazon Resource Name (ARN) of the alternate target group for Amazon ECS blue/green deployments.
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-advancedconfiguration.html#cfn-ecs-service-advancedconfiguration-alternatetargetgrouparn
             '''
             result = self._values.get("alternate_target_group_arn")
@@ -9290,7 +9733,8 @@ class CfnService(
 
         @builtins.property
         def production_listener_rule(self) -> typing.Optional[builtins.str]:
-            '''
+            '''The Amazon Resource Name (ARN) that that identifies the production listener rule (in the case of an Application Load Balancer) or listener (in the case for an Network Load Balancer) for routing production traffic.
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-advancedconfiguration.html#cfn-ecs-service-advancedconfiguration-productionlistenerrule
             '''
             result = self._values.get("production_listener_rule")
@@ -9298,7 +9742,8 @@ class CfnService(
 
         @builtins.property
         def role_arn(self) -> typing.Optional[builtins.str]:
-            '''
+            '''The Amazon Resource Name (ARN) of the IAM role that grants Amazon ECS permission to call the Elastic Load Balancing APIs for you.
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-advancedconfiguration.html#cfn-ecs-service-advancedconfiguration-rolearn
             '''
             result = self._values.get("role_arn")
@@ -9306,7 +9751,8 @@ class CfnService(
 
         @builtins.property
         def test_listener_rule(self) -> typing.Optional[builtins.str]:
-            '''
+            '''The Amazon Resource Name (ARN) that identifies ) that identifies the test listener rule (in the case of an Application Load Balancer) or listener (in the case for an Network Load Balancer) for routing test traffic.
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-advancedconfiguration.html#cfn-ecs-service-advancedconfiguration-testlistenerrule
             '''
             result = self._values.get("test_listener_rule")
@@ -9741,12 +10187,12 @@ class CfnService(
             '''Optional deployment parameters that control how many tasks run during a deployment and the ordering of stopping and starting tasks.
 
             :param alarms: Information about the CloudWatch alarms.
-            :param bake_time_in_minutes: 
+            :param bake_time_in_minutes: The duration when both blue and green service revisions are running simultaneously after the production traffic has shifted. The following rules apply when you don't specify a value: - For rolling deployments, the value is set to 3 hours (180 minutes). - When you use an external deployment controller ( ``EXTERNAL`` ), or the CodeDeploy 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 deployment_circuit_breaker: .. epigraph:: 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 lifecycle_hooks: 
+            :param lifecycle_hooks: An array of deployment lifecycle hook objects to run custom logic at specific stages of the deployment lifecycle.
             :param 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. .. epigraph:: You can't specify a custom ``maximumPercent`` value for a service that uses either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and has tasks that use the EC2 launch type. If the service uses either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types, and the tasks in the service use the Fargate launch type, the maximum percent value is not used. The value is still returned when describing your service.
             :param minimum_healthy_percent: If a service is using the rolling update ( ``ECS`` ) deployment type, the ``minimumHealthyPercent`` represents a lower limit on the number of your service's tasks that must remain in the ``RUNNING`` state during a deployment, as a percentage of the ``desiredCount`` (rounded up to the nearest integer). This parameter enables you to deploy without using additional cluster capacity. For example, if your service has a ``desiredCount`` of four tasks and a ``minimumHealthyPercent`` of 50%, the service scheduler may stop two existing tasks to free up cluster capacity before starting two new tasks. If any tasks are unhealthy and if ``maximumPercent`` doesn't allow the Amazon ECS scheduler to start replacement tasks, the scheduler stops the unhealthy tasks one-by-one — using the ``minimumHealthyPercent`` as a constraint — to clear up capacity to launch replacement tasks. 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>`_ . For services that *do not* use a load balancer, the following should be noted: - A service is considered healthy if all essential containers within the tasks in the service pass their health checks. - If a task has no essential containers with a health check defined, the service scheduler will wait for 40 seconds after a task reaches a ``RUNNING`` state before the task is counted towards the minimum healthy percent total. - If a task has one or more essential containers with a health check defined, the service scheduler will wait for the task to reach a healthy status before counting it towards the minimum healthy percent total. A task is considered healthy when all essential containers within the task have passed their health checks. The amount of time the service scheduler can wait for is determined by the container health check settings. For services that *do* use a load balancer, the following should be noted: - If a task has no essential containers with a health check defined, the service scheduler will wait for the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total. - If a task has an essential container with a health check defined, the service scheduler will wait for both the task to reach a healthy status and the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total. The default value for a replica service for ``minimumHealthyPercent`` is 100%. The default ``minimumHealthyPercent`` value for a service using the ``DAEMON`` service schedule is 0% for the AWS CLI , the AWS SDKs, and the APIs and 50% for the AWS Management Console. The minimum number of healthy tasks during a deployment is the ``desiredCount`` multiplied by the ``minimumHealthyPercent`` /100, rounded up to the nearest integer value. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the EC2 launch type, the *minimum healthy percent* value is set to the default value. The *minimum healthy percent* value is used to define the lower 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. .. epigraph:: You can't specify a custom ``minimumHealthyPercent`` value for a service that uses either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and has tasks that use the EC2 launch type. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the Fargate launch type, the minimum healthy percent value is not used, although it is returned when describing your service.
-            :param strategy: 
+            :param strategy: The deployment strategy for the service. Choose from these valid values:. - ``ROLLING`` - When you create a service which uses the rolling update ( ``ROLLING`` ) deployment strategy, the Amazon ECS service scheduler replaces the currently running tasks with new tasks. The number of tasks that Amazon ECS adds or removes from the service during a rolling update is controlled by the service deployment configuration. - ``BLUE_GREEN`` - A blue/green deployment strategy ( ``BLUE_GREEN`` ) is a release methodology that reduces downtime and risk by running two identical production environments called blue and green. With Amazon ECS blue/green deployments, you can validate new service revisions before directing production traffic to them. This approach provides a safer way to deploy changes with the ability to quickly roll back if needed.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-deploymentconfiguration.html
             :exampleMetadata: fixture=_generated
@@ -9816,7 +10262,14 @@ class CfnService(
 
         @builtins.property
         def bake_time_in_minutes(self) -> typing.Optional[jsii.Number]:
-            '''
+            '''The duration when both blue and green service revisions are running simultaneously after the production traffic has shifted.
+
+            The following rules apply when you don't specify a value:
+
+            - For rolling deployments, the value is set to 3 hours (180 minutes).
+            - When you use an external deployment controller ( ``EXTERNAL`` ), or the CodeDeploy 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).
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-deploymentconfiguration.html#cfn-ecs-service-deploymentconfiguration-baketimeinminutes
             '''
             result = self._values.get("bake_time_in_minutes")
@@ -9841,7 +10294,8 @@ class CfnService(
         def lifecycle_hooks(
             self,
         ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnService.DeploymentLifecycleHookProperty"]]]]:
-            '''
+            '''An array of deployment lifecycle hook objects to run custom logic at specific stages of the deployment lifecycle.
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-deploymentconfiguration.html#cfn-ecs-service-deploymentconfiguration-lifecyclehooks
             '''
             result = self._values.get("lifecycle_hooks")
@@ -9904,7 +10358,11 @@ class CfnService(
 
         @builtins.property
         def strategy(self) -> typing.Optional[builtins.str]:
-            '''
+            '''The deployment strategy for the service. Choose from these valid values:.
+
+            - ``ROLLING`` - When you create a service which uses the rolling update ( ``ROLLING`` ) deployment strategy, the Amazon ECS service scheduler replaces the currently running tasks with new tasks. The number of tasks that Amazon ECS adds or removes from the service during a rolling update is controlled by the service deployment configuration.
+            - ``BLUE_GREEN`` - A blue/green deployment strategy ( ``BLUE_GREEN`` ) is a release methodology that reduces downtime and risk by running two identical production environments called blue and green. With Amazon ECS blue/green deployments, you can validate new service revisions before directing production traffic to them. This approach provides a safer way to deploy changes with the ability to quickly roll back if needed.
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-deploymentconfiguration.html#cfn-ecs-service-deploymentconfiguration-strategy
             '''
             result = self._values.get("strategy")
@@ -10035,10 +10493,15 @@ class CfnService(
             lifecycle_stages: typing.Sequence[builtins.str],
             role_arn: builtins.str,
         ) -> None:
-            '''
-            :param hook_target_arn: 
-            :param lifecycle_stages: 
-            :param role_arn: 
+            '''A deployment lifecycle hook runs custom logic at specific stages of the deployment process.
+
+            Currently, you can use Lambda functions as hook targets.
+
+            For more information, see `Lifecycle hooks for Amazon ECS service deployments <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-lifecycle-hooks.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
+
+            :param hook_target_arn: The Amazon Resource Name (ARN) of the hook target. Currently, only Lambda function ARNs are supported. You must provide this parameter when configuring a deployment lifecycle hook.
+            :param lifecycle_stages: The lifecycle stages at which to run the hook. Choose from these valid values:. - RECONCILE_SERVICE The reconciliation stage that only happens when you start a new service deployment with more than 1 service revision in an ACTIVE state. You can use a lifecycle hook for this stage. - PRE_SCALE_UP The green service revision has not started. The blue service revision is handling 100% of the production traffic. There is no test traffic. You can use a lifecycle hook for this stage. - POST_SCALE_UP The green service revision has started. The blue service revision is handling 100% of the production traffic. There is no test traffic. You can use a lifecycle hook for this stage. - TEST_TRAFFIC_SHIFT The blue and green service revisions are running. The blue service revision handles 100% of the production traffic. The green service revision is migrating from 0% to 100% of test traffic. You can use a lifecycle hook for this stage. - POST_TEST_TRAFFIC_SHIFT The test traffic shift is complete. The green service revision handles 100% of the test traffic. You can use a lifecycle hook for this stage. - PRODUCTION_TRAFFIC_SHIFT Production traffic is shifting to the green service revision. The green service revision is migrating from 0% to 100% of production traffic. You can use a lifecycle hook for this stage. - POST_PRODUCTION_TRAFFIC_SHIFT The production traffic shift is complete. You can use a lifecycle hook for this stage. You must provide this parameter when configuring a deployment lifecycle hook.
+            :param role_arn: The Amazon Resource Name (ARN) of the IAM role that grants Amazon ECS permission to call Lambda functions on your behalf. For more information, see `Permissions required for Lambda functions in Amazon ECS blue/green deployments <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/blue-green-permissions.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-deploymentlifecyclehook.html
             :exampleMetadata: fixture=_generated
@@ -10068,7 +10531,10 @@ class CfnService(
 
         @builtins.property
         def hook_target_arn(self) -> builtins.str:
-            '''
+            '''The Amazon Resource Name (ARN) of the hook target. Currently, only Lambda function ARNs are supported.
+
+            You must provide this parameter when configuring a deployment lifecycle hook.
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-deploymentlifecyclehook.html#cfn-ecs-service-deploymentlifecyclehook-hooktargetarn
             '''
             result = self._values.get("hook_target_arn")
@@ -10077,7 +10543,52 @@ class CfnService(
 
         @builtins.property
         def lifecycle_stages(self) -> typing.List[builtins.str]:
-            '''
+            '''The lifecycle stages at which to run the hook. Choose from these valid values:.
+
+            - RECONCILE_SERVICE
+
+            The reconciliation stage that only happens when you start a new service deployment with more than 1 service revision in an ACTIVE state.
+
+            You can use a lifecycle hook for this stage.
+
+            - PRE_SCALE_UP
+
+            The green service revision has not started. The blue service revision is handling 100% of the production traffic. There is no test traffic.
+
+            You can use a lifecycle hook for this stage.
+
+            - POST_SCALE_UP
+
+            The green service revision has started. The blue service revision is handling 100% of the production traffic. There is no test traffic.
+
+            You can use a lifecycle hook for this stage.
+
+            - TEST_TRAFFIC_SHIFT
+
+            The blue and green service revisions are running. The blue service revision handles 100% of the production traffic. The green service revision is migrating from 0% to 100% of test traffic.
+
+            You can use a lifecycle hook for this stage.
+
+            - POST_TEST_TRAFFIC_SHIFT
+
+            The test traffic shift is complete. The green service revision handles 100% of the test traffic.
+
+            You can use a lifecycle hook for this stage.
+
+            - PRODUCTION_TRAFFIC_SHIFT
+
+            Production traffic is shifting to the green service revision. The green service revision is migrating from 0% to 100% of production traffic.
+
+            You can use a lifecycle hook for this stage.
+
+            - POST_PRODUCTION_TRAFFIC_SHIFT
+
+            The production traffic shift is complete.
+
+            You can use a lifecycle hook for this stage.
+
+            You must provide this parameter when configuring a deployment lifecycle hook.
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-deploymentlifecyclehook.html#cfn-ecs-service-deploymentlifecyclehook-lifecyclestages
             '''
             result = self._values.get("lifecycle_stages")
@@ -10086,7 +10597,10 @@ class CfnService(
 
         @builtins.property
         def role_arn(self) -> builtins.str:
-            '''
+            '''The Amazon Resource Name (ARN) of the IAM role that grants Amazon ECS permission to call Lambda functions on your behalf.
+
+            For more information, see `Permissions required for Lambda functions in Amazon ECS blue/green deployments <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/blue-green-permissions.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-deploymentlifecyclehook.html#cfn-ecs-service-deploymentlifecyclehook-rolearn
             '''
             result = self._values.get("role_arn")
@@ -10230,7 +10744,7 @@ class CfnService(
 
             Services with tasks that use the ``awsvpc`` network mode (for example, those with the Fargate launch type) only support Application Load Balancers and Network Load Balancers. Classic Load Balancers are not supported. Also, when you create any target groups for these services, you must choose ``ip`` as the target type, not ``instance`` . Tasks that use the ``awsvpc`` network mode are associated with an elastic network interface, not an Amazon EC2 instance.
 
-            :param advanced_configuration: 
+            :param advanced_configuration: The advanced settings for the load balancer used in blue/green deployments. Specify the alternate target group, listener rules, and IAM role required for traffic shifting during blue/green deployments.
             :param container_name: The name of the container (as it appears in a container definition) to associate with the load balancer. You need to specify the container name when configuring the target group for an Amazon ECS load balancer.
             :param container_port: The port on the container to associate with the load balancer. This port must correspond to a ``containerPort`` in the task definition the tasks in the service are using. For tasks that use the EC2 launch type, the container instance they're launched on must allow ingress traffic on the ``hostPort`` of the port mapping.
             :param load_balancer_name: The name of the load balancer to associate with the Amazon ECS service or task set. If you are using an Application Load Balancer or a Network Load Balancer the load balancer name parameter should be omitted.
@@ -10283,7 +10797,10 @@ class CfnService(
         def advanced_configuration(
             self,
         ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnService.AdvancedConfigurationProperty"]]:
-            '''
+            '''The advanced settings for the load balancer used in blue/green deployments.
+
+            Specify the alternate target group, listener rules, and IAM role required for traffic shifting during blue/green deployments.
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-loadbalancer.html#cfn-ecs-service-loadbalancer-advancedconfiguration
             '''
             result = self._values.get("advanced_configuration")
@@ -10902,7 +11419,7 @@ class CfnService(
 
             :param port: The listening port number for the Service Connect proxy. This port is available inside of all of the tasks within the same namespace. To avoid changing your applications in client Amazon ECS services, set this to the same port that the client application uses by default. 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 dns_name: The ``dnsName`` is the name that you use in the applications of client tasks to connect to this service. The name must be a valid DNS name but doesn't need to be fully-qualified. The name can include up to 127 characters. The name can include lowercase letters, numbers, underscores (_), hyphens (-), and periods (.). The name can't start with a hyphen. If this parameter isn't specified, the default value of ``discoveryName.namespace`` is used. If the ``discoveryName`` isn't specified, the port mapping name from the task definition is used in ``portName.namespace`` . To avoid changing your applications in client Amazon ECS services, set this to the same name that the client application uses by default. For example, a few common names are ``database`` , ``db`` , or the lowercase name of a database, such as ``mysql`` or ``redis`` . 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 test_traffic_rules: 
+            :param test_traffic_rules: The configuration for test traffic routing rules used during blue/green deployments with Amazon ECS Service Connect. This allows you to route a portion of traffic to the new service revision of your service for testing before shifting all production traffic.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-serviceconnectclientalias.html
             :exampleMetadata: fixture=_generated
@@ -10976,7 +11493,10 @@ class CfnService(
         def test_traffic_rules(
             self,
         ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnService.ServiceConnectTestTrafficRulesProperty"]]:
-            '''
+            '''The configuration for test traffic routing rules used during blue/green deployments with Amazon ECS Service Connect.
+
+            This allows you to route a portion of traffic to the new service revision of your service for testing before shifting all production traffic.
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-serviceconnectclientalias.html#cfn-ecs-service-serviceconnectclientalias-testtrafficrules
             '''
             result = self._values.get("test_traffic_rules")
@@ -11502,8 +12022,13 @@ class CfnService(
             *,
             header: typing.Union[_IResolvable_da3f097b, typing.Union["CfnService.ServiceConnectTestTrafficRulesHeaderProperty", typing.Dict[builtins.str, typing.Any]]],
         ) -> None:
-            '''
-            :param header: 
+            '''The test traffic routing configuration for Amazon ECS blue/green deployments.
+
+            This configuration allows you to define rules for routing specific traffic to the new service revision during the deployment process, allowing for safe testing before full production traffic shift.
+
+            For more information, see `Service Connect for Amazon ECS blue/green deployments <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect-blue-green.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
+
+            :param header: The HTTP header-based routing rules that determine which requests should be routed to the new service version during blue/green deployment testing. These rules provide fine-grained control over test traffic routing based on request headers.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-serviceconnecttesttrafficrules.html
             :exampleMetadata: fixture=_generated
@@ -11536,7 +12061,10 @@ class CfnService(
         def header(
             self,
         ) -> typing.Union[_IResolvable_da3f097b, "CfnService.ServiceConnectTestTrafficRulesHeaderProperty"]:
-            '''
+            '''The HTTP header-based routing rules that determine which requests should be routed to the new service version during blue/green deployment testing.
+
+            These rules provide fine-grained control over test traffic routing based on request headers.
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-serviceconnecttesttrafficrules.html#cfn-ecs-service-serviceconnecttesttrafficrules-header
             '''
             result = self._values.get("header")
@@ -24332,6 +24860,287 @@ class DeploymentControllerType(enum.Enum):
     '''The external (EXTERNAL) deployment type enables you to use any third-party deployment controller.'''
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_ecs.DeploymentLifecycleHookTargetConfig",
+    jsii_struct_bases=[],
+    name_mapping={
+        "lifecycle_stages": "lifecycleStages",
+        "target_arn": "targetArn",
+        "role": "role",
+    },
+)
+class DeploymentLifecycleHookTargetConfig:
+    def __init__(
+        self,
+        *,
+        lifecycle_stages: typing.Sequence["DeploymentLifecycleStage"],
+        target_arn: builtins.str,
+        role: typing.Optional[_IRole_235f5d8e] = None,
+    ) -> None:
+        '''Configuration for a deployment lifecycle hook target.
+
+        :param lifecycle_stages: The lifecycle stages when this hook should be executed.
+        :param target_arn: The ARN of the target resource.
+        :param role: The IAM role that grants permissions to invoke the target. Default: - a role will be created automatically
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            from aws_cdk import aws_ecs as ecs
+            from aws_cdk import aws_iam as iam
+            
+            # role: iam.Role
+            
+            deployment_lifecycle_hook_target_config = ecs.DeploymentLifecycleHookTargetConfig(
+                lifecycle_stages=[ecs.DeploymentLifecycleStage.RECONCILE_SERVICE],
+                target_arn="targetArn",
+            
+                # the properties below are optional
+                role=role
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__58b105a4a38be4fd4e5d81c3d78a7d0fc4d3120086f0f1235d58be7e964bf172)
+            check_type(argname="argument lifecycle_stages", value=lifecycle_stages, expected_type=type_hints["lifecycle_stages"])
+            check_type(argname="argument target_arn", value=target_arn, expected_type=type_hints["target_arn"])
+            check_type(argname="argument role", value=role, expected_type=type_hints["role"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "lifecycle_stages": lifecycle_stages,
+            "target_arn": target_arn,
+        }
+        if role is not None:
+            self._values["role"] = role
+
+    @builtins.property
+    def lifecycle_stages(self) -> typing.List["DeploymentLifecycleStage"]:
+        '''The lifecycle stages when this hook should be executed.'''
+        result = self._values.get("lifecycle_stages")
+        assert result is not None, "Required property 'lifecycle_stages' is missing"
+        return typing.cast(typing.List["DeploymentLifecycleStage"], result)
+
+    @builtins.property
+    def target_arn(self) -> builtins.str:
+        '''The ARN of the target resource.'''
+        result = self._values.get("target_arn")
+        assert result is not None, "Required property 'target_arn' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def role(self) -> typing.Optional[_IRole_235f5d8e]:
+        '''The IAM role that grants permissions to invoke the target.
+
+        :default: - a role will be created automatically
+        '''
+        result = self._values.get("role")
+        return typing.cast(typing.Optional[_IRole_235f5d8e], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "DeploymentLifecycleHookTargetConfig(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_ecs.DeploymentLifecycleLambdaTargetProps",
+    jsii_struct_bases=[],
+    name_mapping={"lifecycle_stages": "lifecycleStages", "role": "role"},
+)
+class DeploymentLifecycleLambdaTargetProps:
+    def __init__(
+        self,
+        *,
+        lifecycle_stages: typing.Sequence["DeploymentLifecycleStage"],
+        role: typing.Optional[_IRole_235f5d8e] = None,
+    ) -> None:
+        '''Configuration for a lambda deployment lifecycle hook.
+
+        :param lifecycle_stages: The lifecycle stages when this hook should be executed.
+        :param role: The IAM role that grants permissions to invoke the lambda target. Default: - A unique role will be generated for this lambda function.
+
+        :exampleMetadata: infused
+
+        Example::
+
+            import aws_cdk.aws_lambda as lambda_
+            
+            # cluster: ecs.Cluster
+            # task_definition: ecs.TaskDefinition
+            # lambda_hook: lambda.Function
+            # blue_target_group: elbv2.ApplicationTargetGroup
+            # green_target_group: elbv2.ApplicationTargetGroup
+            # prod_listener_rule: elbv2.ApplicationListenerRule
+            
+            
+            service = ecs.FargateService(self, "Service",
+                cluster=cluster,
+                task_definition=task_definition,
+                deployment_strategy=ecs.DeploymentStrategy.BLUE_GREEN
+            )
+            
+            service.add_lifecycle_hook(ecs.DeploymentLifecycleLambdaTarget(lambda_hook, "PreScaleHook",
+                lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
+            ))
+            
+            target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+                container_name="nginx",
+                container_port=80,
+                protocol=ecs.Protocol.TCP
+            ), ecs.AlternateTarget("AlternateTarget",
+                alternate_target_group=green_target_group,
+                production_listener=ecs.ListenerRuleConfiguration.application_listener_rule(prod_listener_rule)
+            ))
+            
+            target.attach_to_application_target_group(blue_target_group)
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__e812b4c257c9817fdc66c09cfbc9ed6c2dae75feb52fdb91c33339837dbb883c)
+            check_type(argname="argument lifecycle_stages", value=lifecycle_stages, expected_type=type_hints["lifecycle_stages"])
+            check_type(argname="argument role", value=role, expected_type=type_hints["role"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "lifecycle_stages": lifecycle_stages,
+        }
+        if role is not None:
+            self._values["role"] = role
+
+    @builtins.property
+    def lifecycle_stages(self) -> typing.List["DeploymentLifecycleStage"]:
+        '''The lifecycle stages when this hook should be executed.'''
+        result = self._values.get("lifecycle_stages")
+        assert result is not None, "Required property 'lifecycle_stages' is missing"
+        return typing.cast(typing.List["DeploymentLifecycleStage"], result)
+
+    @builtins.property
+    def role(self) -> typing.Optional[_IRole_235f5d8e]:
+        '''The IAM role that grants permissions to invoke the lambda target.
+
+        :default: - A unique role will be generated for this lambda function.
+        '''
+        result = self._values.get("role")
+        return typing.cast(typing.Optional[_IRole_235f5d8e], result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "DeploymentLifecycleLambdaTargetProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.aws_ecs.DeploymentLifecycleStage")
+class DeploymentLifecycleStage(enum.Enum):
+    '''Deployment lifecycle stages where hooks can be executed.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_lambda as lambda_
+        
+        # cluster: ecs.Cluster
+        # task_definition: ecs.TaskDefinition
+        # lambda_hook: lambda.Function
+        # blue_target_group: elbv2.ApplicationTargetGroup
+        # green_target_group: elbv2.ApplicationTargetGroup
+        # prod_listener_rule: elbv2.ApplicationListenerRule
+        
+        
+        service = ecs.FargateService(self, "Service",
+            cluster=cluster,
+            task_definition=task_definition,
+            deployment_strategy=ecs.DeploymentStrategy.BLUE_GREEN
+        )
+        
+        service.add_lifecycle_hook(ecs.DeploymentLifecycleLambdaTarget(lambda_hook, "PreScaleHook",
+            lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
+        ))
+        
+        target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+            container_name="nginx",
+            container_port=80,
+            protocol=ecs.Protocol.TCP
+        ), ecs.AlternateTarget("AlternateTarget",
+            alternate_target_group=green_target_group,
+            production_listener=ecs.ListenerRuleConfiguration.application_listener_rule(prod_listener_rule)
+        ))
+        
+        target.attach_to_application_target_group(blue_target_group)
+    '''
+
+    RECONCILE_SERVICE = "RECONCILE_SERVICE"
+    '''Execute during service reconciliation.'''
+    PRE_SCALE_UP = "PRE_SCALE_UP"
+    '''Execute before scaling up tasks.'''
+    POST_SCALE_UP = "POST_SCALE_UP"
+    '''Execute after scaling up tasks.'''
+    TEST_TRAFFIC_SHIFT = "TEST_TRAFFIC_SHIFT"
+    '''Execute during test traffic shift.'''
+    POST_TEST_TRAFFIC_SHIFT = "POST_TEST_TRAFFIC_SHIFT"
+    '''Execute after test traffic shift.'''
+    PRODUCTION_TRAFFIC_SHIFT = "PRODUCTION_TRAFFIC_SHIFT"
+    '''Execute during production traffic shift.'''
+    POST_PRODUCTION_TRAFFIC_SHIFT = "POST_PRODUCTION_TRAFFIC_SHIFT"
+    '''Execute after production traffic shift.'''
+
+
+@jsii.enum(jsii_type="aws-cdk-lib.aws_ecs.DeploymentStrategy")
+class DeploymentStrategy(enum.Enum):
+    '''The deployment stratergy to use for ECS controller.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_lambda as lambda_
+        
+        # cluster: ecs.Cluster
+        # task_definition: ecs.TaskDefinition
+        # lambda_hook: lambda.Function
+        # blue_target_group: elbv2.ApplicationTargetGroup
+        # green_target_group: elbv2.ApplicationTargetGroup
+        # prod_listener_rule: elbv2.ApplicationListenerRule
+        
+        
+        service = ecs.FargateService(self, "Service",
+            cluster=cluster,
+            task_definition=task_definition,
+            deployment_strategy=ecs.DeploymentStrategy.BLUE_GREEN
+        )
+        
+        service.add_lifecycle_hook(ecs.DeploymentLifecycleLambdaTarget(lambda_hook, "PreScaleHook",
+            lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
+        ))
+        
+        target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+            container_name="nginx",
+            container_port=80,
+            protocol=ecs.Protocol.TCP
+        ), ecs.AlternateTarget("AlternateTarget",
+            alternate_target_group=green_target_group,
+            production_listener=ecs.ListenerRuleConfiguration.application_listener_rule(prod_listener_rule)
+        ))
+        
+        target.attach_to_application_target_group(blue_target_group)
+    '''
+
+    ROLLING = "ROLLING"
+    '''Rolling update deployment.'''
+    BLUE_GREEN = "BLUE_GREEN"
+    '''Blue/green deployment.'''
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_ecs.Device",
     jsii_struct_bases=[],
@@ -24934,15 +25743,18 @@ class Ec2ServiceAttributes:
     jsii_struct_bases=[BaseServiceOptions],
     name_mapping={
         "cluster": "cluster",
+        "bake_time": "bakeTime",
         "capacity_provider_strategies": "capacityProviderStrategies",
         "circuit_breaker": "circuitBreaker",
         "cloud_map_options": "cloudMapOptions",
         "deployment_alarms": "deploymentAlarms",
         "deployment_controller": "deploymentController",
+        "deployment_strategy": "deploymentStrategy",
         "desired_count": "desiredCount",
         "enable_ecs_managed_tags": "enableECSManagedTags",
         "enable_execute_command": "enableExecuteCommand",
         "health_check_grace_period": "healthCheckGracePeriod",
+        "lifecycle_hooks": "lifecycleHooks",
         "max_healthy_percent": "maxHealthyPercent",
         "min_healthy_percent": "minHealthyPercent",
         "propagate_tags": "propagateTags",
@@ -24965,15 +25777,18 @@ class Ec2ServiceProps(BaseServiceOptions):
         self,
         *,
         cluster: "ICluster",
+        bake_time: typing.Optional[_Duration_4839e8c3] = None,
         capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
         circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
         cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_alarms: typing.Optional[typing.Union["DeploymentAlarmConfig", typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+        deployment_strategy: typing.Optional[DeploymentStrategy] = None,
         desired_count: typing.Optional[jsii.Number] = None,
         enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
         enable_execute_command: typing.Optional[builtins.bool] = None,
         health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+        lifecycle_hooks: typing.Optional[typing.Sequence["IDeploymentLifecycleHookTarget"]] = None,
         max_healthy_percent: typing.Optional[jsii.Number] = None,
         min_healthy_percent: typing.Optional[jsii.Number] = None,
         propagate_tags: typing.Optional["PropagatedTagSource"] = None,
@@ -24993,15 +25808,18 @@ class Ec2ServiceProps(BaseServiceOptions):
         '''The properties for defining a service using the EC2 launch type.
 
         :param cluster: The name of the cluster that hosts the service.
+        :param bake_time: bake time minutes for service. Default: - none
         :param capacity_provider_strategies: A list of Capacity Provider strategies used to place a service. Default: - undefined
         :param circuit_breaker: Whether to enable the deployment circuit breaker. If this property is defined, circuit breaker will be implicitly enabled. Default: - disabled
         :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 deployment_alarms: The alarm(s) to monitor during deployment, and behavior to apply if at least one enters a state of alarm during the deployment or bake time. Default: - No alarms will be monitored during deployment.
         :param deployment_controller: Specifies which deployment controller to use for the service. For more information, see `Amazon ECS Deployment Types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html>`_ Default: - Rolling update (ECS)
+        :param deployment_strategy: The deployment strategy to use for the service. Default: ROLLING
         :param desired_count: The desired number of instantiations of the task definition to keep running on the service. Default: - When creating the service, default is 1; when updating the service, default uses the current task number.
         :param enable_ecs_managed_tags: Specifies whether to enable Amazon ECS managed tags for the tasks within the service. For more information, see `Tagging Your Amazon ECS Resources <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html>`_ Default: false
         :param enable_execute_command: Whether to enable the ability to execute into a container. Default: - undefined
         :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 lifecycle_hooks: The lifecycle hooks to execute during deployment stages. Default: - none;
         :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: - 100 if daemon, otherwise 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: - 0 if daemon, otherwise 50
         :param propagate_tags: Specifies whether to propagate the tags from the task definition or the service to the tasks in the service. Valid values are: PropagatedTagSource.SERVICE, PropagatedTagSource.TASK_DEFINITION or PropagatedTagSource.NONE Default: PropagatedTagSource.NONE
@@ -25063,15 +25881,18 @@ class Ec2ServiceProps(BaseServiceOptions):
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__95634258086aa3448fbdfd9896017a2cbeb858f382deb61186bb9e22b1ccd366)
             check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
+            check_type(argname="argument bake_time", value=bake_time, expected_type=type_hints["bake_time"])
             check_type(argname="argument capacity_provider_strategies", value=capacity_provider_strategies, expected_type=type_hints["capacity_provider_strategies"])
             check_type(argname="argument circuit_breaker", value=circuit_breaker, expected_type=type_hints["circuit_breaker"])
             check_type(argname="argument cloud_map_options", value=cloud_map_options, expected_type=type_hints["cloud_map_options"])
             check_type(argname="argument deployment_alarms", value=deployment_alarms, expected_type=type_hints["deployment_alarms"])
             check_type(argname="argument deployment_controller", value=deployment_controller, expected_type=type_hints["deployment_controller"])
+            check_type(argname="argument deployment_strategy", value=deployment_strategy, expected_type=type_hints["deployment_strategy"])
             check_type(argname="argument desired_count", value=desired_count, expected_type=type_hints["desired_count"])
             check_type(argname="argument enable_ecs_managed_tags", value=enable_ecs_managed_tags, expected_type=type_hints["enable_ecs_managed_tags"])
             check_type(argname="argument enable_execute_command", value=enable_execute_command, expected_type=type_hints["enable_execute_command"])
             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 lifecycle_hooks", value=lifecycle_hooks, expected_type=type_hints["lifecycle_hooks"])
             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"])
             check_type(argname="argument propagate_tags", value=propagate_tags, expected_type=type_hints["propagate_tags"])
@@ -25091,6 +25912,8 @@ class Ec2ServiceProps(BaseServiceOptions):
             "cluster": cluster,
             "task_definition": task_definition,
         }
+        if bake_time is not None:
+            self._values["bake_time"] = bake_time
         if capacity_provider_strategies is not None:
             self._values["capacity_provider_strategies"] = capacity_provider_strategies
         if circuit_breaker is not None:
@@ -25101,6 +25924,8 @@ class Ec2ServiceProps(BaseServiceOptions):
             self._values["deployment_alarms"] = deployment_alarms
         if deployment_controller is not None:
             self._values["deployment_controller"] = deployment_controller
+        if deployment_strategy is not None:
+            self._values["deployment_strategy"] = deployment_strategy
         if desired_count is not None:
             self._values["desired_count"] = desired_count
         if enable_ecs_managed_tags is not None:
@@ -25109,6 +25934,8 @@ class Ec2ServiceProps(BaseServiceOptions):
             self._values["enable_execute_command"] = enable_execute_command
         if health_check_grace_period is not None:
             self._values["health_check_grace_period"] = health_check_grace_period
+        if lifecycle_hooks is not None:
+            self._values["lifecycle_hooks"] = lifecycle_hooks
         if max_healthy_percent is not None:
             self._values["max_healthy_percent"] = max_healthy_percent
         if min_healthy_percent is not None:
@@ -25145,6 +25972,15 @@ class Ec2ServiceProps(BaseServiceOptions):
         assert result is not None, "Required property 'cluster' is missing"
         return typing.cast("ICluster", result)
 
+    @builtins.property
+    def bake_time(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''bake time minutes for service.
+
+        :default: - none
+        '''
+        result = self._values.get("bake_time")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
     @builtins.property
     def capacity_provider_strategies(
         self,
@@ -25198,6 +26034,15 @@ class Ec2ServiceProps(BaseServiceOptions):
         result = self._values.get("deployment_controller")
         return typing.cast(typing.Optional[DeploymentController], result)
 
+    @builtins.property
+    def deployment_strategy(self) -> typing.Optional[DeploymentStrategy]:
+        '''The deployment strategy to use for the service.
+
+        :default: ROLLING
+        '''
+        result = self._values.get("deployment_strategy")
+        return typing.cast(typing.Optional[DeploymentStrategy], result)
+
     @builtins.property
     def desired_count(self) -> typing.Optional[jsii.Number]:
         '''The desired number of instantiations of the task definition to keep running on the service.
@@ -25240,6 +26085,17 @@ class Ec2ServiceProps(BaseServiceOptions):
         result = self._values.get("health_check_grace_period")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
+    @builtins.property
+    def lifecycle_hooks(
+        self,
+    ) -> typing.Optional[typing.List["IDeploymentLifecycleHookTarget"]]:
+        '''The lifecycle hooks to execute during deployment stages.
+
+        :default: - none;
+        '''
+        result = self._values.get("lifecycle_hooks")
+        return typing.cast(typing.Optional[typing.List["IDeploymentLifecycleHookTarget"]], 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.
@@ -26955,15 +27811,18 @@ class ExternalServiceAttributes:
     jsii_struct_bases=[BaseServiceOptions],
     name_mapping={
         "cluster": "cluster",
+        "bake_time": "bakeTime",
         "capacity_provider_strategies": "capacityProviderStrategies",
         "circuit_breaker": "circuitBreaker",
         "cloud_map_options": "cloudMapOptions",
         "deployment_alarms": "deploymentAlarms",
         "deployment_controller": "deploymentController",
+        "deployment_strategy": "deploymentStrategy",
         "desired_count": "desiredCount",
         "enable_ecs_managed_tags": "enableECSManagedTags",
         "enable_execute_command": "enableExecuteCommand",
         "health_check_grace_period": "healthCheckGracePeriod",
+        "lifecycle_hooks": "lifecycleHooks",
         "max_healthy_percent": "maxHealthyPercent",
         "min_healthy_percent": "minHealthyPercent",
         "propagate_tags": "propagateTags",
@@ -26981,15 +27840,18 @@ class ExternalServiceProps(BaseServiceOptions):
         self,
         *,
         cluster: "ICluster",
+        bake_time: typing.Optional[_Duration_4839e8c3] = None,
         capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
         circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
         cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_alarms: typing.Optional[typing.Union["DeploymentAlarmConfig", typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+        deployment_strategy: typing.Optional[DeploymentStrategy] = None,
         desired_count: typing.Optional[jsii.Number] = None,
         enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
         enable_execute_command: typing.Optional[builtins.bool] = None,
         health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+        lifecycle_hooks: typing.Optional[typing.Sequence["IDeploymentLifecycleHookTarget"]] = None,
         max_healthy_percent: typing.Optional[jsii.Number] = None,
         min_healthy_percent: typing.Optional[jsii.Number] = None,
         propagate_tags: typing.Optional["PropagatedTagSource"] = None,
@@ -27004,15 +27866,18 @@ class ExternalServiceProps(BaseServiceOptions):
         '''The properties for defining a service using the External launch type.
 
         :param cluster: The name of the cluster that hosts the service.
+        :param bake_time: bake time minutes for service. Default: - none
         :param capacity_provider_strategies: A list of Capacity Provider strategies used to place a service. Default: - undefined
         :param circuit_breaker: Whether to enable the deployment circuit breaker. If this property is defined, circuit breaker will be implicitly enabled. Default: - disabled
         :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 deployment_alarms: The alarm(s) to monitor during deployment, and behavior to apply if at least one enters a state of alarm during the deployment or bake time. Default: - No alarms will be monitored during deployment.
         :param deployment_controller: Specifies which deployment controller to use for the service. For more information, see `Amazon ECS Deployment Types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html>`_ Default: - Rolling update (ECS)
+        :param deployment_strategy: The deployment strategy to use for the service. Default: ROLLING
         :param desired_count: The desired number of instantiations of the task definition to keep running on the service. Default: - When creating the service, default is 1; when updating the service, default uses the current task number.
         :param enable_ecs_managed_tags: Specifies whether to enable Amazon ECS managed tags for the tasks within the service. For more information, see `Tagging Your Amazon ECS Resources <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html>`_ Default: false
         :param enable_execute_command: Whether to enable the ability to execute into a container. Default: - undefined
         :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 lifecycle_hooks: The lifecycle hooks to execute during deployment stages. Default: - none;
         :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: - 100 if daemon, otherwise 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: - 0 if daemon, otherwise 50
         :param propagate_tags: Specifies whether to propagate the tags from the task definition or the service to the tasks in the service. Valid values are: PropagatedTagSource.SERVICE, PropagatedTagSource.TASK_DEFINITION or PropagatedTagSource.NONE Default: PropagatedTagSource.NONE
@@ -27057,15 +27922,18 @@ class ExternalServiceProps(BaseServiceOptions):
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__3cc413964caae89bfcfbcabff8356ffe5c054f46824be99731a77b64ec052a8a)
             check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
+            check_type(argname="argument bake_time", value=bake_time, expected_type=type_hints["bake_time"])
             check_type(argname="argument capacity_provider_strategies", value=capacity_provider_strategies, expected_type=type_hints["capacity_provider_strategies"])
             check_type(argname="argument circuit_breaker", value=circuit_breaker, expected_type=type_hints["circuit_breaker"])
             check_type(argname="argument cloud_map_options", value=cloud_map_options, expected_type=type_hints["cloud_map_options"])
             check_type(argname="argument deployment_alarms", value=deployment_alarms, expected_type=type_hints["deployment_alarms"])
             check_type(argname="argument deployment_controller", value=deployment_controller, expected_type=type_hints["deployment_controller"])
+            check_type(argname="argument deployment_strategy", value=deployment_strategy, expected_type=type_hints["deployment_strategy"])
             check_type(argname="argument desired_count", value=desired_count, expected_type=type_hints["desired_count"])
             check_type(argname="argument enable_ecs_managed_tags", value=enable_ecs_managed_tags, expected_type=type_hints["enable_ecs_managed_tags"])
             check_type(argname="argument enable_execute_command", value=enable_execute_command, expected_type=type_hints["enable_execute_command"])
             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 lifecycle_hooks", value=lifecycle_hooks, expected_type=type_hints["lifecycle_hooks"])
             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"])
             check_type(argname="argument propagate_tags", value=propagate_tags, expected_type=type_hints["propagate_tags"])
@@ -27080,6 +27948,8 @@ class ExternalServiceProps(BaseServiceOptions):
             "cluster": cluster,
             "task_definition": task_definition,
         }
+        if bake_time is not None:
+            self._values["bake_time"] = bake_time
         if capacity_provider_strategies is not None:
             self._values["capacity_provider_strategies"] = capacity_provider_strategies
         if circuit_breaker is not None:
@@ -27090,6 +27960,8 @@ class ExternalServiceProps(BaseServiceOptions):
             self._values["deployment_alarms"] = deployment_alarms
         if deployment_controller is not None:
             self._values["deployment_controller"] = deployment_controller
+        if deployment_strategy is not None:
+            self._values["deployment_strategy"] = deployment_strategy
         if desired_count is not None:
             self._values["desired_count"] = desired_count
         if enable_ecs_managed_tags is not None:
@@ -27098,6 +27970,8 @@ class ExternalServiceProps(BaseServiceOptions):
             self._values["enable_execute_command"] = enable_execute_command
         if health_check_grace_period is not None:
             self._values["health_check_grace_period"] = health_check_grace_period
+        if lifecycle_hooks is not None:
+            self._values["lifecycle_hooks"] = lifecycle_hooks
         if max_healthy_percent is not None:
             self._values["max_healthy_percent"] = max_healthy_percent
         if min_healthy_percent is not None:
@@ -27124,6 +27998,15 @@ class ExternalServiceProps(BaseServiceOptions):
         assert result is not None, "Required property 'cluster' is missing"
         return typing.cast("ICluster", result)
 
+    @builtins.property
+    def bake_time(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''bake time minutes for service.
+
+        :default: - none
+        '''
+        result = self._values.get("bake_time")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
     @builtins.property
     def capacity_provider_strategies(
         self,
@@ -27177,6 +28060,15 @@ class ExternalServiceProps(BaseServiceOptions):
         result = self._values.get("deployment_controller")
         return typing.cast(typing.Optional[DeploymentController], result)
 
+    @builtins.property
+    def deployment_strategy(self) -> typing.Optional[DeploymentStrategy]:
+        '''The deployment strategy to use for the service.
+
+        :default: ROLLING
+        '''
+        result = self._values.get("deployment_strategy")
+        return typing.cast(typing.Optional[DeploymentStrategy], result)
+
     @builtins.property
     def desired_count(self) -> typing.Optional[jsii.Number]:
         '''The desired number of instantiations of the task definition to keep running on the service.
@@ -27219,6 +28111,17 @@ class ExternalServiceProps(BaseServiceOptions):
         result = self._values.get("health_check_grace_period")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
+    @builtins.property
+    def lifecycle_hooks(
+        self,
+    ) -> typing.Optional[typing.List["IDeploymentLifecycleHookTarget"]]:
+        '''The lifecycle hooks to execute during deployment stages.
+
+        :default: - none;
+        '''
+        result = self._values.get("lifecycle_hooks")
+        return typing.cast(typing.Optional[typing.List["IDeploymentLifecycleHookTarget"]], 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.
@@ -27799,15 +28702,18 @@ class FargateServiceAttributes:
     jsii_struct_bases=[BaseServiceOptions],
     name_mapping={
         "cluster": "cluster",
+        "bake_time": "bakeTime",
         "capacity_provider_strategies": "capacityProviderStrategies",
         "circuit_breaker": "circuitBreaker",
         "cloud_map_options": "cloudMapOptions",
         "deployment_alarms": "deploymentAlarms",
         "deployment_controller": "deploymentController",
+        "deployment_strategy": "deploymentStrategy",
         "desired_count": "desiredCount",
         "enable_ecs_managed_tags": "enableECSManagedTags",
         "enable_execute_command": "enableExecuteCommand",
         "health_check_grace_period": "healthCheckGracePeriod",
+        "lifecycle_hooks": "lifecycleHooks",
         "max_healthy_percent": "maxHealthyPercent",
         "min_healthy_percent": "minHealthyPercent",
         "propagate_tags": "propagateTags",
@@ -27828,15 +28734,18 @@ class FargateServiceProps(BaseServiceOptions):
         self,
         *,
         cluster: "ICluster",
+        bake_time: typing.Optional[_Duration_4839e8c3] = None,
         capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
         circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
         cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_alarms: typing.Optional[typing.Union["DeploymentAlarmConfig", typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+        deployment_strategy: typing.Optional[DeploymentStrategy] = None,
         desired_count: typing.Optional[jsii.Number] = None,
         enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
         enable_execute_command: typing.Optional[builtins.bool] = None,
         health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+        lifecycle_hooks: typing.Optional[typing.Sequence["IDeploymentLifecycleHookTarget"]] = None,
         max_healthy_percent: typing.Optional[jsii.Number] = None,
         min_healthy_percent: typing.Optional[jsii.Number] = None,
         propagate_tags: typing.Optional["PropagatedTagSource"] = None,
@@ -27854,15 +28763,18 @@ class FargateServiceProps(BaseServiceOptions):
         '''The properties for defining a service using the Fargate launch type.
 
         :param cluster: The name of the cluster that hosts the service.
+        :param bake_time: bake time minutes for service. Default: - none
         :param capacity_provider_strategies: A list of Capacity Provider strategies used to place a service. Default: - undefined
         :param circuit_breaker: Whether to enable the deployment circuit breaker. If this property is defined, circuit breaker will be implicitly enabled. Default: - disabled
         :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 deployment_alarms: The alarm(s) to monitor during deployment, and behavior to apply if at least one enters a state of alarm during the deployment or bake time. Default: - No alarms will be monitored during deployment.
         :param deployment_controller: Specifies which deployment controller to use for the service. For more information, see `Amazon ECS Deployment Types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html>`_ Default: - Rolling update (ECS)
+        :param deployment_strategy: The deployment strategy to use for the service. Default: ROLLING
         :param desired_count: The desired number of instantiations of the task definition to keep running on the service. Default: - When creating the service, default is 1; when updating the service, default uses the current task number.
         :param enable_ecs_managed_tags: Specifies whether to enable Amazon ECS managed tags for the tasks within the service. For more information, see `Tagging Your Amazon ECS Resources <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html>`_ Default: false
         :param enable_execute_command: Whether to enable the ability to execute into a container. Default: - undefined
         :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 lifecycle_hooks: The lifecycle hooks to execute during deployment stages. Default: - none;
         :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: - 100 if daemon, otherwise 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: - 0 if daemon, otherwise 50
         :param propagate_tags: Specifies whether to propagate the tags from the task definition or the service to the tasks in the service. Valid values are: PropagatedTagSource.SERVICE, PropagatedTagSource.TASK_DEFINITION or PropagatedTagSource.NONE Default: PropagatedTagSource.NONE
@@ -27925,15 +28837,18 @@ class FargateServiceProps(BaseServiceOptions):
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__8290283f61f3e2d289b7e7f81cad1a5d1e9ed9dbc07ccce2b57604682a42ded7)
             check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
+            check_type(argname="argument bake_time", value=bake_time, expected_type=type_hints["bake_time"])
             check_type(argname="argument capacity_provider_strategies", value=capacity_provider_strategies, expected_type=type_hints["capacity_provider_strategies"])
             check_type(argname="argument circuit_breaker", value=circuit_breaker, expected_type=type_hints["circuit_breaker"])
             check_type(argname="argument cloud_map_options", value=cloud_map_options, expected_type=type_hints["cloud_map_options"])
             check_type(argname="argument deployment_alarms", value=deployment_alarms, expected_type=type_hints["deployment_alarms"])
             check_type(argname="argument deployment_controller", value=deployment_controller, expected_type=type_hints["deployment_controller"])
+            check_type(argname="argument deployment_strategy", value=deployment_strategy, expected_type=type_hints["deployment_strategy"])
             check_type(argname="argument desired_count", value=desired_count, expected_type=type_hints["desired_count"])
             check_type(argname="argument enable_ecs_managed_tags", value=enable_ecs_managed_tags, expected_type=type_hints["enable_ecs_managed_tags"])
             check_type(argname="argument enable_execute_command", value=enable_execute_command, expected_type=type_hints["enable_execute_command"])
             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 lifecycle_hooks", value=lifecycle_hooks, expected_type=type_hints["lifecycle_hooks"])
             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"])
             check_type(argname="argument propagate_tags", value=propagate_tags, expected_type=type_hints["propagate_tags"])
@@ -27951,6 +28866,8 @@ class FargateServiceProps(BaseServiceOptions):
             "cluster": cluster,
             "task_definition": task_definition,
         }
+        if bake_time is not None:
+            self._values["bake_time"] = bake_time
         if capacity_provider_strategies is not None:
             self._values["capacity_provider_strategies"] = capacity_provider_strategies
         if circuit_breaker is not None:
@@ -27961,6 +28878,8 @@ class FargateServiceProps(BaseServiceOptions):
             self._values["deployment_alarms"] = deployment_alarms
         if deployment_controller is not None:
             self._values["deployment_controller"] = deployment_controller
+        if deployment_strategy is not None:
+            self._values["deployment_strategy"] = deployment_strategy
         if desired_count is not None:
             self._values["desired_count"] = desired_count
         if enable_ecs_managed_tags is not None:
@@ -27969,6 +28888,8 @@ class FargateServiceProps(BaseServiceOptions):
             self._values["enable_execute_command"] = enable_execute_command
         if health_check_grace_period is not None:
             self._values["health_check_grace_period"] = health_check_grace_period
+        if lifecycle_hooks is not None:
+            self._values["lifecycle_hooks"] = lifecycle_hooks
         if max_healthy_percent is not None:
             self._values["max_healthy_percent"] = max_healthy_percent
         if min_healthy_percent is not None:
@@ -28001,6 +28922,15 @@ class FargateServiceProps(BaseServiceOptions):
         assert result is not None, "Required property 'cluster' is missing"
         return typing.cast("ICluster", result)
 
+    @builtins.property
+    def bake_time(self) -> typing.Optional[_Duration_4839e8c3]:
+        '''bake time minutes for service.
+
+        :default: - none
+        '''
+        result = self._values.get("bake_time")
+        return typing.cast(typing.Optional[_Duration_4839e8c3], result)
+
     @builtins.property
     def capacity_provider_strategies(
         self,
@@ -28054,6 +28984,15 @@ class FargateServiceProps(BaseServiceOptions):
         result = self._values.get("deployment_controller")
         return typing.cast(typing.Optional[DeploymentController], result)
 
+    @builtins.property
+    def deployment_strategy(self) -> typing.Optional[DeploymentStrategy]:
+        '''The deployment strategy to use for the service.
+
+        :default: ROLLING
+        '''
+        result = self._values.get("deployment_strategy")
+        return typing.cast(typing.Optional[DeploymentStrategy], result)
+
     @builtins.property
     def desired_count(self) -> typing.Optional[jsii.Number]:
         '''The desired number of instantiations of the task definition to keep running on the service.
@@ -28096,6 +29035,17 @@ class FargateServiceProps(BaseServiceOptions):
         result = self._values.get("health_check_grace_period")
         return typing.cast(typing.Optional[_Duration_4839e8c3], result)
 
+    @builtins.property
+    def lifecycle_hooks(
+        self,
+    ) -> typing.Optional[typing.List["IDeploymentLifecycleHookTarget"]]:
+        '''The lifecycle hooks to execute during deployment stages.
+
+        :default: - none;
+        '''
+        result = self._values.get("lifecycle_hooks")
+        return typing.cast(typing.Optional[typing.List["IDeploymentLifecycleHookTarget"]], 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.
@@ -31739,6 +32689,43 @@ class Host:
         )
 
 
+@jsii.interface(jsii_type="aws-cdk-lib.aws_ecs.IAlternateTarget")
+class IAlternateTarget(typing_extensions.Protocol):
+    '''Interface for configuring alternate target groups for blue/green deployments.'''
+
+    @jsii.member(jsii_name="bind")
+    def bind(self, scope: _constructs_77d1e7e8.IConstruct) -> AlternateTargetConfig:
+        '''Bind this configuration to a service.
+
+        :param scope: The construct scope.
+
+        :return: The configuration to apply to the service
+        '''
+        ...
+
+
+class _IAlternateTargetProxy:
+    '''Interface for configuring alternate target groups for blue/green deployments.'''
+
+    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ecs.IAlternateTarget"
+
+    @jsii.member(jsii_name="bind")
+    def bind(self, scope: _constructs_77d1e7e8.IConstruct) -> AlternateTargetConfig:
+        '''Bind this configuration to a service.
+
+        :param scope: The construct scope.
+
+        :return: The configuration to apply to the service
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__1f10764be69e962209020c3a7e772567f1cbc3d3673cf209506562511ce9cd0a)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+        return typing.cast(AlternateTargetConfig, jsii.invoke(self, "bind", [scope]))
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
+typing.cast(typing.Any, IAlternateTarget).__jsii_proxy_class__ = lambda : _IAlternateTargetProxy
+
+
 @jsii.interface(jsii_type="aws-cdk-lib.aws_ecs.ICluster")
 class ICluster(_IResource_c80c4260, typing_extensions.Protocol):
     '''A regional grouping of one or more container instances on which you can run tasks and services.'''
@@ -31867,6 +32854,45 @@ class _IClusterProxy(
 typing.cast(typing.Any, ICluster).__jsii_proxy_class__ = lambda : _IClusterProxy
 
 
+@jsii.interface(jsii_type="aws-cdk-lib.aws_ecs.IDeploymentLifecycleHookTarget")
+class IDeploymentLifecycleHookTarget(typing_extensions.Protocol):
+    '''Interface for deployment lifecycle hook targets.'''
+
+    @jsii.member(jsii_name="bind")
+    def bind(
+        self,
+        scope: _constructs_77d1e7e8.IConstruct,
+    ) -> DeploymentLifecycleHookTargetConfig:
+        '''Bind this target to a deployment lifecycle hook.
+
+        :param scope: The construct scope.
+        '''
+        ...
+
+
+class _IDeploymentLifecycleHookTargetProxy:
+    '''Interface for deployment lifecycle hook targets.'''
+
+    __jsii_type__: typing.ClassVar[str] = "aws-cdk-lib.aws_ecs.IDeploymentLifecycleHookTarget"
+
+    @jsii.member(jsii_name="bind")
+    def bind(
+        self,
+        scope: _constructs_77d1e7e8.IConstruct,
+    ) -> DeploymentLifecycleHookTargetConfig:
+        '''Bind this target to a deployment lifecycle hook.
+
+        :param scope: The construct scope.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__1cdcc51dc61399e62078243a225e42fd6901317236efebe039a9e3b36834d4b7)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+        return typing.cast(DeploymentLifecycleHookTargetConfig, jsii.invoke(self, "bind", [scope]))
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the interface
+typing.cast(typing.Any, IDeploymentLifecycleHookTarget).__jsii_proxy_class__ = lambda : _IDeploymentLifecycleHookTargetProxy
+
+
 @jsii.interface(jsii_type="aws-cdk-lib.aws_ecs.IEcsLoadBalancerTarget")
 class IEcsLoadBalancerTarget(
     _IApplicationLoadBalancerTarget_fabf9003,
@@ -32941,6 +33967,89 @@ class _ListenerConfigProxy(ListenerConfig):
 typing.cast(typing.Any, ListenerConfig).__jsii_proxy_class__ = lambda : _ListenerConfigProxy
 
 
+class ListenerRuleConfiguration(
+    metaclass=jsii.JSIIAbstractClass,
+    jsii_type="aws-cdk-lib.aws_ecs.ListenerRuleConfiguration",
+):
+    '''Represents a listener configuration for advanced load balancer settings.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_lambda as lambda_
+        
+        # cluster: ecs.Cluster
+        # task_definition: ecs.TaskDefinition
+        # lambda_hook: lambda.Function
+        # blue_target_group: elbv2.ApplicationTargetGroup
+        # green_target_group: elbv2.ApplicationTargetGroup
+        # prod_listener_rule: elbv2.ApplicationListenerRule
+        
+        
+        service = ecs.FargateService(self, "Service",
+            cluster=cluster,
+            task_definition=task_definition,
+            deployment_strategy=ecs.DeploymentStrategy.BLUE_GREEN
+        )
+        
+        service.add_lifecycle_hook(ecs.DeploymentLifecycleLambdaTarget(lambda_hook, "PreScaleHook",
+            lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
+        ))
+        
+        target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+            container_name="nginx",
+            container_port=80,
+            protocol=ecs.Protocol.TCP
+        ), ecs.AlternateTarget("AlternateTarget",
+            alternate_target_group=green_target_group,
+            production_listener=ecs.ListenerRuleConfiguration.application_listener_rule(prod_listener_rule)
+        ))
+        
+        target.attach_to_application_target_group(blue_target_group)
+    '''
+
+    def __init__(self) -> None:
+        jsii.create(self.__class__, self, [])
+
+    @jsii.member(jsii_name="applicationListenerRule")
+    @builtins.classmethod
+    def application_listener_rule(
+        cls,
+        rule: _ApplicationListenerRule_f93ff606,
+    ) -> "ListenerRuleConfiguration":
+        '''Use an Application Load Balancer listener rule.
+
+        :param rule: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__e4bdbe1ec0e220912f9ff8b7769875a4eebd5168734b702329f9d4600ecdb318)
+            check_type(argname="argument rule", value=rule, expected_type=type_hints["rule"])
+        return typing.cast("ListenerRuleConfiguration", jsii.sinvoke(cls, "applicationListenerRule", [rule]))
+
+    @jsii.member(jsii_name="networkListener")
+    @builtins.classmethod
+    def network_listener(
+        cls,
+        listener: _NetworkListener_539c17bf,
+    ) -> "ListenerRuleConfiguration":
+        '''Use a Network Load Balancer listener.
+
+        :param listener: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__c964a7ba26c195318cd3937b823b36facecf4120aeb9196876feb206f6f9855a)
+            check_type(argname="argument listener", value=listener, expected_type=type_hints["listener"])
+        return typing.cast("ListenerRuleConfiguration", jsii.sinvoke(cls, "networkListener", [listener]))
+
+
+class _ListenerRuleConfigurationProxy(ListenerRuleConfiguration):
+    pass
+
+# Adding a "__jsii_proxy_class__(): typing.Type" function to the abstract class
+typing.cast(typing.Any, ListenerRuleConfiguration).__jsii_proxy_class__ = lambda : _ListenerRuleConfigurationProxy
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_ecs.LoadBalancerTargetOptions",
     jsii_struct_bases=[],
@@ -34627,34 +35736,36 @@ class Protocol(enum.Enum):
 
     Example::
 
-        # task_definition: ecs.TaskDefinition
+        import aws_cdk.aws_lambda as lambda_
+        
         # cluster: ecs.Cluster
+        # task_definition: ecs.TaskDefinition
+        # lambda_hook: lambda.Function
+        # blue_target_group: elbv2.ApplicationTargetGroup
+        # green_target_group: elbv2.ApplicationTargetGroup
+        # prod_listener_rule: elbv2.ApplicationListenerRule
         
         
-        # Add a container to the task definition
-        specific_container = task_definition.add_container("Container",
-            image=ecs.ContainerImage.from_registry("/aws/aws-example-app"),
-            memory_limit_mi_b=2048
+        service = ecs.FargateService(self, "Service",
+            cluster=cluster,
+            task_definition=task_definition,
+            deployment_strategy=ecs.DeploymentStrategy.BLUE_GREEN
         )
         
-        # Add a port mapping
-        specific_container.add_port_mappings(
-            container_port=7600,
+        service.add_lifecycle_hook(ecs.DeploymentLifecycleLambdaTarget(lambda_hook, "PreScaleHook",
+            lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
+        ))
+        
+        target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+            container_name="nginx",
+            container_port=80,
             protocol=ecs.Protocol.TCP
-        )
+        ), ecs.AlternateTarget("AlternateTarget",
+            alternate_target_group=green_target_group,
+            production_listener=ecs.ListenerRuleConfiguration.application_listener_rule(prod_listener_rule)
+        ))
         
-        ecs.Ec2Service(self, "Service",
-            cluster=cluster,
-            task_definition=task_definition,
-            min_healthy_percent=100,
-            cloud_map_options=ecs.CloudMapOptions(
-                # Create SRV records - useful for bridge networking
-                dns_record_type=cloudmap.DnsRecordType.SRV,
-                # Targets port TCP port 7600 `specificContainer`
-                container=specific_container,
-                container_port=7600
-            )
-        )
+        target.attach_to_application_target_group(blue_target_group)
     '''
 
     TCP = "TCP"
@@ -39915,6 +41026,89 @@ class WindowsOptimizedVersion(enum.Enum):
     SERVER_2016 = "SERVER_2016"
 
 
+@jsii.implements(IAlternateTarget)
+class AlternateTarget(
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_ecs.AlternateTarget",
+):
+    '''Configuration for alternate target groups used in blue/green deployments with load balancers.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_lambda as lambda_
+        
+        # cluster: ecs.Cluster
+        # task_definition: ecs.TaskDefinition
+        # lambda_hook: lambda.Function
+        # blue_target_group: elbv2.ApplicationTargetGroup
+        # green_target_group: elbv2.ApplicationTargetGroup
+        # prod_listener_rule: elbv2.ApplicationListenerRule
+        
+        
+        service = ecs.FargateService(self, "Service",
+            cluster=cluster,
+            task_definition=task_definition,
+            deployment_strategy=ecs.DeploymentStrategy.BLUE_GREEN
+        )
+        
+        service.add_lifecycle_hook(ecs.DeploymentLifecycleLambdaTarget(lambda_hook, "PreScaleHook",
+            lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
+        ))
+        
+        target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+            container_name="nginx",
+            container_port=80,
+            protocol=ecs.Protocol.TCP
+        ), ecs.AlternateTarget("AlternateTarget",
+            alternate_target_group=green_target_group,
+            production_listener=ecs.ListenerRuleConfiguration.application_listener_rule(prod_listener_rule)
+        ))
+        
+        target.attach_to_application_target_group(blue_target_group)
+    '''
+
+    def __init__(
+        self,
+        id: builtins.str,
+        *,
+        alternate_target_group: _ITargetGroup_83c6f8c4,
+        production_listener: ListenerRuleConfiguration,
+        role: typing.Optional[_IRole_235f5d8e] = None,
+        test_listener: typing.Optional[ListenerRuleConfiguration] = None,
+    ) -> None:
+        '''
+        :param id: -
+        :param alternate_target_group: The alternate target group.
+        :param production_listener: The production listener rule ARN (ALB) or listener ARN (NLB).
+        :param role: The IAM role for the configuration. Default: - a new role will be created
+        :param test_listener: The test listener configuration. Default: - none
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__aa25b044df0e4eef1817fd07bd799a88800df4e6bd79f283ca2657cfee9e4b29)
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = AlternateTargetProps(
+            alternate_target_group=alternate_target_group,
+            production_listener=production_listener,
+            role=role,
+            test_listener=test_listener,
+        )
+
+        jsii.create(self.__class__, self, [id, props])
+
+    @jsii.member(jsii_name="bind")
+    def bind(self, scope: _constructs_77d1e7e8.IConstruct) -> AlternateTargetConfig:
+        '''Bind this configuration to a service.
+
+        :param scope: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__147067753bcb82b7fc98e3b04dd99ea91c99dac8aec50a2f7076d3593aced862)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+        return typing.cast(AlternateTargetConfig, jsii.invoke(self, "bind", [scope]))
+
+
 class AppMeshProxyConfiguration(
     ProxyConfiguration,
     metaclass=jsii.JSIIMeta,
@@ -41192,6 +42386,94 @@ class DeploymentAlarmConfig(DeploymentAlarmOptions):
         )
 
 
+@jsii.implements(IDeploymentLifecycleHookTarget)
+class DeploymentLifecycleLambdaTarget(
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_ecs.DeploymentLifecycleLambdaTarget",
+):
+    '''Use an AWS Lambda function as a deployment lifecycle hook target.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        import aws_cdk.aws_lambda as lambda_
+        
+        # cluster: ecs.Cluster
+        # task_definition: ecs.TaskDefinition
+        # lambda_hook: lambda.Function
+        # blue_target_group: elbv2.ApplicationTargetGroup
+        # green_target_group: elbv2.ApplicationTargetGroup
+        # prod_listener_rule: elbv2.ApplicationListenerRule
+        
+        
+        service = ecs.FargateService(self, "Service",
+            cluster=cluster,
+            task_definition=task_definition,
+            deployment_strategy=ecs.DeploymentStrategy.BLUE_GREEN
+        )
+        
+        service.add_lifecycle_hook(ecs.DeploymentLifecycleLambdaTarget(lambda_hook, "PreScaleHook",
+            lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
+        ))
+        
+        target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+            container_name="nginx",
+            container_port=80,
+            protocol=ecs.Protocol.TCP
+        ), ecs.AlternateTarget("AlternateTarget",
+            alternate_target_group=green_target_group,
+            production_listener=ecs.ListenerRuleConfiguration.application_listener_rule(prod_listener_rule)
+        ))
+        
+        target.attach_to_application_target_group(blue_target_group)
+    '''
+
+    def __init__(
+        self,
+        handler: _IFunction_6adb0ab8,
+        id: builtins.str,
+        *,
+        lifecycle_stages: typing.Sequence[DeploymentLifecycleStage],
+        role: typing.Optional[_IRole_235f5d8e] = None,
+    ) -> None:
+        '''
+        :param handler: -
+        :param id: -
+        :param lifecycle_stages: The lifecycle stages when this hook should be executed.
+        :param role: The IAM role that grants permissions to invoke the lambda target. Default: - A unique role will be generated for this lambda function.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__bddcf05621152ce6e8fd520b5a7bb98f63b4f5805beda123da1f9f542d66294e)
+            check_type(argname="argument handler", value=handler, expected_type=type_hints["handler"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = DeploymentLifecycleLambdaTargetProps(
+            lifecycle_stages=lifecycle_stages, role=role
+        )
+
+        jsii.create(self.__class__, self, [handler, id, props])
+
+    @jsii.member(jsii_name="bind")
+    def bind(
+        self,
+        scope: _constructs_77d1e7e8.IConstruct,
+    ) -> DeploymentLifecycleHookTargetConfig:
+        '''Bind this target to a deployment lifecycle hook.
+
+        :param scope: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__c6510372e5e0e0b1114c294538138af0f03ebd70441a76bddd8496eca40f2fe8)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+        return typing.cast(DeploymentLifecycleHookTargetConfig, jsii.invoke(self, "bind", [scope]))
+
+    @builtins.property
+    @jsii.member(jsii_name="role")
+    def role(self) -> _IRole_235f5d8e:
+        '''The IAM role for the deployment lifecycle hook target.'''
+        return typing.cast(_IRole_235f5d8e, jsii.get(self, "role"))
+
+
 class FireLensLogDriver(
     LogDriver,
     metaclass=jsii.JSIIMeta,
@@ -41877,6 +43159,17 @@ class BaseService(
             check_type(argname="argument service_arn", value=service_arn, expected_type=type_hints["service_arn"])
         return typing.cast(IBaseService, jsii.sinvoke(cls, "fromServiceArnWithCluster", [scope, id, service_arn]))
 
+    @jsii.member(jsii_name="addLifecycleHook")
+    def add_lifecycle_hook(self, target: IDeploymentLifecycleHookTarget) -> None:
+        '''Add a deployment lifecycle hook target.
+
+        :param target: The lifecycle hook target to add.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__480743d611a768bf60af18dc6a08c65385351ccd86b4290955b74d1541662389)
+            check_type(argname="argument target", value=target, expected_type=type_hints["target"])
+        return typing.cast(None, jsii.invoke(self, "addLifecycleHook", [target]))
+
     @jsii.member(jsii_name="addVolume")
     def add_volume(self, volume: ServiceManagedVolume) -> None:
         '''Adds a volume to the Service.
@@ -42084,13 +43377,19 @@ class BaseService(
 
         return typing.cast(None, jsii.invoke(self, "enableServiceConnect", [config]))
 
+    @jsii.member(jsii_name="isUsingECSDeploymentController")
+    def is_using_ecs_deployment_controller(self) -> builtins.bool:
+        '''Checks if the service is using the ECS deployment controller.
+
+        :return: true if the service is using the ECS deployment controller or if no deployment controller is specified (defaults to ECS)
+        '''
+        return typing.cast(builtins.bool, jsii.invoke(self, "isUsingECSDeploymentController", []))
+
     @jsii.member(jsii_name="loadBalancerTarget")
     def load_balancer_target(
         self,
-        *,
-        container_name: builtins.str,
-        container_port: typing.Optional[jsii.Number] = None,
-        protocol: typing.Optional[Protocol] = None,
+        options: typing.Union[LoadBalancerTargetOptions, typing.Dict[builtins.str, typing.Any]],
+        alternate_options: typing.Optional[IAlternateTarget] = None,
     ) -> IEcsLoadBalancerTarget:
         '''Return a load balancing target for a specific container and port.
 
@@ -42101,9 +43400,8 @@ class BaseService(
         Use the return value of this function where you would normally use a load balancer
         target, instead of the ``Service`` object itself.
 
-        :param container_name: The name of the container.
-        :param container_port: The port number of the container. Only applicable when using application/network load balancers. Default: - Container port of the first added port mapping.
-        :param protocol: The protocol used for the port mapping. Only applicable when using application load balancers. Default: Protocol.TCP
+        :param options: -
+        :param alternate_options: -
 
         Example::
 
@@ -42118,13 +43416,11 @@ class BaseService(
                 )]
             )
         '''
-        options = LoadBalancerTargetOptions(
-            container_name=container_name,
-            container_port=container_port,
-            protocol=protocol,
-        )
-
-        return typing.cast(IEcsLoadBalancerTarget, jsii.invoke(self, "loadBalancerTarget", [options]))
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__1326df14b5ec04898722ff6a20f7c785c16a07195cce2a207d19792a2ccec402)
+            check_type(argname="argument options", value=options, expected_type=type_hints["options"])
+            check_type(argname="argument alternate_options", value=alternate_options, expected_type=type_hints["alternate_options"])
+        return typing.cast(IEcsLoadBalancerTarget, jsii.invoke(self, "loadBalancerTarget", [options, alternate_options]))
 
     @jsii.member(jsii_name="metric")
     def metric(
@@ -42497,15 +43793,18 @@ class Ec2Service(
         security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
         vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
         cluster: ICluster,
+        bake_time: typing.Optional[_Duration_4839e8c3] = None,
         capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
         circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
         cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_alarms: typing.Optional[typing.Union[DeploymentAlarmConfig, typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+        deployment_strategy: typing.Optional[DeploymentStrategy] = None,
         desired_count: typing.Optional[jsii.Number] = None,
         enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
         enable_execute_command: typing.Optional[builtins.bool] = None,
         health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+        lifecycle_hooks: typing.Optional[typing.Sequence[IDeploymentLifecycleHookTarget]] = None,
         max_healthy_percent: typing.Optional[jsii.Number] = None,
         min_healthy_percent: typing.Optional[jsii.Number] = None,
         propagate_tags: typing.Optional[PropagatedTagSource] = None,
@@ -42527,15 +43826,18 @@ class Ec2Service(
         :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. This property is only used for tasks that use the awsvpc network mode. Default: - A new security group is created.
         :param vpc_subnets: The subnets to associate with the service. This property is only used for tasks that use the awsvpc network mode. Default: - Public subnets if ``assignPublicIp`` is set, otherwise the first available one of Private, Isolated, Public, in that order.
         :param cluster: The name of the cluster that hosts the service.
+        :param bake_time: bake time minutes for service. Default: - none
         :param capacity_provider_strategies: A list of Capacity Provider strategies used to place a service. Default: - undefined
         :param circuit_breaker: Whether to enable the deployment circuit breaker. If this property is defined, circuit breaker will be implicitly enabled. Default: - disabled
         :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 deployment_alarms: The alarm(s) to monitor during deployment, and behavior to apply if at least one enters a state of alarm during the deployment or bake time. Default: - No alarms will be monitored during deployment.
         :param deployment_controller: Specifies which deployment controller to use for the service. For more information, see `Amazon ECS Deployment Types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html>`_ Default: - Rolling update (ECS)
+        :param deployment_strategy: The deployment strategy to use for the service. Default: ROLLING
         :param desired_count: The desired number of instantiations of the task definition to keep running on the service. Default: - When creating the service, default is 1; when updating the service, default uses the current task number.
         :param enable_ecs_managed_tags: Specifies whether to enable Amazon ECS managed tags for the tasks within the service. For more information, see `Tagging Your Amazon ECS Resources <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html>`_ Default: false
         :param enable_execute_command: Whether to enable the ability to execute into a container. Default: - undefined
         :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 lifecycle_hooks: The lifecycle hooks to execute during deployment stages. Default: - none;
         :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: - 100 if daemon, otherwise 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: - 0 if daemon, otherwise 50
         :param propagate_tags: Specifies whether to propagate the tags from the task definition or the service to the tasks in the service. Valid values are: PropagatedTagSource.SERVICE, PropagatedTagSource.TASK_DEFINITION or PropagatedTagSource.NONE Default: PropagatedTagSource.NONE
@@ -42558,15 +43860,18 @@ class Ec2Service(
             security_groups=security_groups,
             vpc_subnets=vpc_subnets,
             cluster=cluster,
+            bake_time=bake_time,
             capacity_provider_strategies=capacity_provider_strategies,
             circuit_breaker=circuit_breaker,
             cloud_map_options=cloud_map_options,
             deployment_alarms=deployment_alarms,
             deployment_controller=deployment_controller,
+            deployment_strategy=deployment_strategy,
             desired_count=desired_count,
             enable_ecs_managed_tags=enable_ecs_managed_tags,
             enable_execute_command=enable_execute_command,
             health_check_grace_period=health_check_grace_period,
+            lifecycle_hooks=lifecycle_hooks,
             max_healthy_percent=max_healthy_percent,
             min_healthy_percent=min_healthy_percent,
             propagate_tags=propagate_tags,
@@ -42995,15 +44300,18 @@ class ExternalService(
         daemon: typing.Optional[builtins.bool] = None,
         security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
         cluster: ICluster,
+        bake_time: typing.Optional[_Duration_4839e8c3] = None,
         capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
         circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
         cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_alarms: typing.Optional[typing.Union[DeploymentAlarmConfig, typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+        deployment_strategy: typing.Optional[DeploymentStrategy] = None,
         desired_count: typing.Optional[jsii.Number] = None,
         enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
         enable_execute_command: typing.Optional[builtins.bool] = None,
         health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+        lifecycle_hooks: typing.Optional[typing.Sequence[IDeploymentLifecycleHookTarget]] = None,
         max_healthy_percent: typing.Optional[jsii.Number] = None,
         min_healthy_percent: typing.Optional[jsii.Number] = None,
         propagate_tags: typing.Optional[PropagatedTagSource] = None,
@@ -43020,15 +44328,18 @@ class ExternalService(
         :param daemon: By default, service use REPLICA scheduling strategy, this parameter enable DAEMON scheduling strategy. If true, the service scheduler deploys exactly one task on each container instance in your cluster. When you are using this strategy, do not specify a desired number of tasks or any task placement strategies. Tasks using the Fargate launch type or the CODE_DEPLOY or EXTERNAL deployment controller types don't support the DAEMON scheduling strategy. Default: false
         :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 cluster: The name of the cluster that hosts the service.
+        :param bake_time: bake time minutes for service. Default: - none
         :param capacity_provider_strategies: A list of Capacity Provider strategies used to place a service. Default: - undefined
         :param circuit_breaker: Whether to enable the deployment circuit breaker. If this property is defined, circuit breaker will be implicitly enabled. Default: - disabled
         :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 deployment_alarms: The alarm(s) to monitor during deployment, and behavior to apply if at least one enters a state of alarm during the deployment or bake time. Default: - No alarms will be monitored during deployment.
         :param deployment_controller: Specifies which deployment controller to use for the service. For more information, see `Amazon ECS Deployment Types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html>`_ Default: - Rolling update (ECS)
+        :param deployment_strategy: The deployment strategy to use for the service. Default: ROLLING
         :param desired_count: The desired number of instantiations of the task definition to keep running on the service. Default: - When creating the service, default is 1; when updating the service, default uses the current task number.
         :param enable_ecs_managed_tags: Specifies whether to enable Amazon ECS managed tags for the tasks within the service. For more information, see `Tagging Your Amazon ECS Resources <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html>`_ Default: false
         :param enable_execute_command: Whether to enable the ability to execute into a container. Default: - undefined
         :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 lifecycle_hooks: The lifecycle hooks to execute during deployment stages. Default: - none;
         :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: - 100 if daemon, otherwise 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: - 0 if daemon, otherwise 50
         :param propagate_tags: Specifies whether to propagate the tags from the task definition or the service to the tasks in the service. Valid values are: PropagatedTagSource.SERVICE, PropagatedTagSource.TASK_DEFINITION or PropagatedTagSource.NONE Default: PropagatedTagSource.NONE
@@ -43046,15 +44357,18 @@ class ExternalService(
             daemon=daemon,
             security_groups=security_groups,
             cluster=cluster,
+            bake_time=bake_time,
             capacity_provider_strategies=capacity_provider_strategies,
             circuit_breaker=circuit_breaker,
             cloud_map_options=cloud_map_options,
             deployment_alarms=deployment_alarms,
             deployment_controller=deployment_controller,
+            deployment_strategy=deployment_strategy,
             desired_count=desired_count,
             enable_ecs_managed_tags=enable_ecs_managed_tags,
             enable_execute_command=enable_execute_command,
             health_check_grace_period=health_check_grace_period,
+            lifecycle_hooks=lifecycle_hooks,
             max_healthy_percent=max_healthy_percent,
             min_healthy_percent=min_healthy_percent,
             propagate_tags=propagate_tags,
@@ -43228,24 +44542,19 @@ class ExternalService(
     @jsii.member(jsii_name="loadBalancerTarget")
     def load_balancer_target(
         self,
-        *,
-        container_name: builtins.str,
-        container_port: typing.Optional[jsii.Number] = None,
-        protocol: typing.Optional[Protocol] = None,
+        _options: typing.Union[LoadBalancerTargetOptions, typing.Dict[builtins.str, typing.Any]],
+        _alternate_options: typing.Optional[IAlternateTarget] = None,
     ) -> IEcsLoadBalancerTarget:
         '''Overridden method to throw error as ``loadBalancerTarget`` is not supported for external service.
 
-        :param container_name: The name of the container.
-        :param container_port: The port number of the container. Only applicable when using application/network load balancers. Default: - Container port of the first added port mapping.
-        :param protocol: The protocol used for the port mapping. Only applicable when using application load balancers. Default: Protocol.TCP
+        :param _options: -
+        :param _alternate_options: -
         '''
-        _options = LoadBalancerTargetOptions(
-            container_name=container_name,
-            container_port=container_port,
-            protocol=protocol,
-        )
-
-        return typing.cast(IEcsLoadBalancerTarget, jsii.invoke(self, "loadBalancerTarget", [_options]))
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__4cd24799babe0f9419c370222cff02dd9c784b1fd9b652c186a1701c0874337d)
+            check_type(argname="argument _options", value=_options, expected_type=type_hints["_options"])
+            check_type(argname="argument _alternate_options", value=_alternate_options, expected_type=type_hints["_alternate_options"])
+        return typing.cast(IEcsLoadBalancerTarget, jsii.invoke(self, "loadBalancerTarget", [_options, _alternate_options]))
 
     @jsii.member(jsii_name="registerLoadBalancerTargets")
     def register_load_balancer_targets(self, *_targets: EcsTarget) -> None:
@@ -43463,15 +44772,18 @@ class FargateService(
         security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
         vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
         cluster: ICluster,
+        bake_time: typing.Optional[_Duration_4839e8c3] = None,
         capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
         circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
         cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_alarms: typing.Optional[typing.Union[DeploymentAlarmConfig, typing.Dict[builtins.str, typing.Any]]] = None,
         deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+        deployment_strategy: typing.Optional[DeploymentStrategy] = None,
         desired_count: typing.Optional[jsii.Number] = None,
         enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
         enable_execute_command: typing.Optional[builtins.bool] = None,
         health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+        lifecycle_hooks: typing.Optional[typing.Sequence[IDeploymentLifecycleHookTarget]] = None,
         max_healthy_percent: typing.Optional[jsii.Number] = None,
         min_healthy_percent: typing.Optional[jsii.Number] = None,
         propagate_tags: typing.Optional[PropagatedTagSource] = None,
@@ -43491,15 +44803,18 @@ class FargateService(
         :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 vpc_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 cluster: The name of the cluster that hosts the service.
+        :param bake_time: bake time minutes for service. Default: - none
         :param capacity_provider_strategies: A list of Capacity Provider strategies used to place a service. Default: - undefined
         :param circuit_breaker: Whether to enable the deployment circuit breaker. If this property is defined, circuit breaker will be implicitly enabled. Default: - disabled
         :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 deployment_alarms: The alarm(s) to monitor during deployment, and behavior to apply if at least one enters a state of alarm during the deployment or bake time. Default: - No alarms will be monitored during deployment.
         :param deployment_controller: Specifies which deployment controller to use for the service. For more information, see `Amazon ECS Deployment Types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html>`_ Default: - Rolling update (ECS)
+        :param deployment_strategy: The deployment strategy to use for the service. Default: ROLLING
         :param desired_count: The desired number of instantiations of the task definition to keep running on the service. Default: - When creating the service, default is 1; when updating the service, default uses the current task number.
         :param enable_ecs_managed_tags: Specifies whether to enable Amazon ECS managed tags for the tasks within the service. For more information, see `Tagging Your Amazon ECS Resources <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-using-tags.html>`_ Default: false
         :param enable_execute_command: Whether to enable the ability to execute into a container. Default: - undefined
         :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 lifecycle_hooks: The lifecycle hooks to execute during deployment stages. Default: - none;
         :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: - 100 if daemon, otherwise 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: - 0 if daemon, otherwise 50
         :param propagate_tags: Specifies whether to propagate the tags from the task definition or the service to the tasks in the service. Valid values are: PropagatedTagSource.SERVICE, PropagatedTagSource.TASK_DEFINITION or PropagatedTagSource.NONE Default: PropagatedTagSource.NONE
@@ -43520,15 +44835,18 @@ class FargateService(
             security_groups=security_groups,
             vpc_subnets=vpc_subnets,
             cluster=cluster,
+            bake_time=bake_time,
             capacity_provider_strategies=capacity_provider_strategies,
             circuit_breaker=circuit_breaker,
             cloud_map_options=cloud_map_options,
             deployment_alarms=deployment_alarms,
             deployment_controller=deployment_controller,
+            deployment_strategy=deployment_strategy,
             desired_count=desired_count,
             enable_ecs_managed_tags=enable_ecs_managed_tags,
             enable_execute_command=enable_execute_command,
             health_check_grace_period=health_check_grace_period,
+            lifecycle_hooks=lifecycle_hooks,
             max_healthy_percent=max_healthy_percent,
             min_healthy_percent=min_healthy_percent,
             propagate_tags=propagate_tags,
@@ -43800,6 +45118,10 @@ __all__ = [
     "AddAutoScalingGroupCapacityOptions",
     "AddCapacityOptions",
     "AlarmBehavior",
+    "AlternateTarget",
+    "AlternateTargetConfig",
+    "AlternateTargetOptions",
+    "AlternateTargetProps",
     "AmiHardwareType",
     "AppMeshProxyConfiguration",
     "AppMeshProxyConfigurationConfigProps",
@@ -43868,6 +45190,11 @@ __all__ = [
     "DeploymentCircuitBreaker",
     "DeploymentController",
     "DeploymentControllerType",
+    "DeploymentLifecycleHookTargetConfig",
+    "DeploymentLifecycleLambdaTarget",
+    "DeploymentLifecycleLambdaTargetProps",
+    "DeploymentLifecycleStage",
+    "DeploymentStrategy",
     "Device",
     "DevicePermission",
     "DockerVolumeConfiguration",
@@ -43924,8 +45251,10 @@ __all__ = [
     "GenericLogDriverProps",
     "HealthCheck",
     "Host",
+    "IAlternateTarget",
     "IBaseService",
     "ICluster",
+    "IDeploymentLifecycleHookTarget",
     "IEc2Service",
     "IEc2TaskDefinition",
     "IEcsLoadBalancerTarget",
@@ -43946,6 +45275,7 @@ __all__ = [
     "LinuxParameters",
     "LinuxParametersProps",
     "ListenerConfig",
+    "ListenerRuleConfiguration",
     "LoadBalancerTargetOptions",
     "LogDriver",
     "LogDriverConfig",
@@ -44057,6 +45387,34 @@ def _typecheckingstub__64f2d9b3495e3be78346f77d5ad90928968c8ce230e670b6279dc67ad
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__792a358f64361d957b07e1ed7f1116dd993837c77bffc674ebb1385615159cd7(
+    *,
+    alternate_target_group_arn: builtins.str,
+    role_arn: builtins.str,
+    production_listener_rule: typing.Optional[builtins.str] = None,
+    test_listener_rule: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__419cc917bedbbd0a41ca044bcc54720f5a35bdc4f2dca6e11ae40da3ed05758d(
+    *,
+    role: typing.Optional[_IRole_235f5d8e] = None,
+    test_listener: typing.Optional[ListenerRuleConfiguration] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__308a285b9e7be7ba49d4d78caf88537a973f5504d7b7519fb1fe4ab1c987b690(
+    *,
+    role: typing.Optional[_IRole_235f5d8e] = None,
+    test_listener: typing.Optional[ListenerRuleConfiguration] = None,
+    alternate_target_group: _ITargetGroup_83c6f8c4,
+    production_listener: ListenerRuleConfiguration,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__0405fe235aadd4430faf2b963e8de52a23bd867724c74f1f76995c5f208aa3e6(
     *,
     container_name: builtins.str,
@@ -44217,15 +45575,18 @@ def _typecheckingstub__47c51bc38319f21956164fb0fbe2257a72cb1269d763f8a2bf334788b
 def _typecheckingstub__c2e0ba28c74987301a54b0d197b791a6a94084b5f40d15304ffabf113b3f7daa(
     *,
     cluster: ICluster,
+    bake_time: typing.Optional[_Duration_4839e8c3] = None,
     capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
     circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
     cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_alarms: typing.Optional[typing.Union[DeploymentAlarmConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+    deployment_strategy: typing.Optional[DeploymentStrategy] = None,
     desired_count: typing.Optional[jsii.Number] = None,
     enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
     enable_execute_command: typing.Optional[builtins.bool] = None,
     health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+    lifecycle_hooks: typing.Optional[typing.Sequence[IDeploymentLifecycleHookTarget]] = None,
     max_healthy_percent: typing.Optional[jsii.Number] = None,
     min_healthy_percent: typing.Optional[jsii.Number] = None,
     propagate_tags: typing.Optional[PropagatedTagSource] = None,
@@ -44240,15 +45601,18 @@ def _typecheckingstub__c2e0ba28c74987301a54b0d197b791a6a94084b5f40d15304ffabf113
 def _typecheckingstub__3ecfd95265b873c2042a9d5cb8465a48f9e325e2271c18461e2b266333563d84(
     *,
     cluster: ICluster,
+    bake_time: typing.Optional[_Duration_4839e8c3] = None,
     capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
     circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
     cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_alarms: typing.Optional[typing.Union[DeploymentAlarmConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+    deployment_strategy: typing.Optional[DeploymentStrategy] = None,
     desired_count: typing.Optional[jsii.Number] = None,
     enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
     enable_execute_command: typing.Optional[builtins.bool] = None,
     health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+    lifecycle_hooks: typing.Optional[typing.Sequence[IDeploymentLifecycleHookTarget]] = None,
     max_healthy_percent: typing.Optional[jsii.Number] = None,
     min_healthy_percent: typing.Optional[jsii.Number] = None,
     propagate_tags: typing.Optional[PropagatedTagSource] = None,
@@ -46222,6 +47586,23 @@ def _typecheckingstub__919598d1dc3ec32befe4a81bbf3a26a387685443884de6cb597180866
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__58b105a4a38be4fd4e5d81c3d78a7d0fc4d3120086f0f1235d58be7e964bf172(
+    *,
+    lifecycle_stages: typing.Sequence[DeploymentLifecycleStage],
+    target_arn: builtins.str,
+    role: typing.Optional[_IRole_235f5d8e] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__e812b4c257c9817fdc66c09cfbc9ed6c2dae75feb52fdb91c33339837dbb883c(
+    *,
+    lifecycle_stages: typing.Sequence[DeploymentLifecycleStage],
+    role: typing.Optional[_IRole_235f5d8e] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__9cd1dbc2946a0873c593d44d008c4c102f3994a3cd94676ec1816b39d1b46931(
     *,
     host_path: builtins.str,
@@ -46300,15 +47681,18 @@ def _typecheckingstub__ec9bd820dae60c0be34ffc5a5dd28bccc87947dc35dff1502ce12b80a
 def _typecheckingstub__95634258086aa3448fbdfd9896017a2cbeb858f382deb61186bb9e22b1ccd366(
     *,
     cluster: ICluster,
+    bake_time: typing.Optional[_Duration_4839e8c3] = None,
     capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
     circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
     cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_alarms: typing.Optional[typing.Union[DeploymentAlarmConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+    deployment_strategy: typing.Optional[DeploymentStrategy] = None,
     desired_count: typing.Optional[jsii.Number] = None,
     enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
     enable_execute_command: typing.Optional[builtins.bool] = None,
     health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+    lifecycle_hooks: typing.Optional[typing.Sequence[IDeploymentLifecycleHookTarget]] = None,
     max_healthy_percent: typing.Optional[jsii.Number] = None,
     min_healthy_percent: typing.Optional[jsii.Number] = None,
     propagate_tags: typing.Optional[PropagatedTagSource] = None,
@@ -46503,15 +47887,18 @@ def _typecheckingstub__bb8d7316afb3715109dfb05d3b7460700437fb0490a0e47180a1c5ef5
 def _typecheckingstub__3cc413964caae89bfcfbcabff8356ffe5c054f46824be99731a77b64ec052a8a(
     *,
     cluster: ICluster,
+    bake_time: typing.Optional[_Duration_4839e8c3] = None,
     capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
     circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
     cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_alarms: typing.Optional[typing.Union[DeploymentAlarmConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+    deployment_strategy: typing.Optional[DeploymentStrategy] = None,
     desired_count: typing.Optional[jsii.Number] = None,
     enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
     enable_execute_command: typing.Optional[builtins.bool] = None,
     health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+    lifecycle_hooks: typing.Optional[typing.Sequence[IDeploymentLifecycleHookTarget]] = None,
     max_healthy_percent: typing.Optional[jsii.Number] = None,
     min_healthy_percent: typing.Optional[jsii.Number] = None,
     propagate_tags: typing.Optional[PropagatedTagSource] = None,
@@ -46561,15 +47948,18 @@ def _typecheckingstub__85c0463354cc6d5a3da5daace0570a015f941bfeb87bb282346c1e2be
 def _typecheckingstub__8290283f61f3e2d289b7e7f81cad1a5d1e9ed9dbc07ccce2b57604682a42ded7(
     *,
     cluster: ICluster,
+    bake_time: typing.Optional[_Duration_4839e8c3] = None,
     capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
     circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
     cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_alarms: typing.Optional[typing.Union[DeploymentAlarmConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+    deployment_strategy: typing.Optional[DeploymentStrategy] = None,
     desired_count: typing.Optional[jsii.Number] = None,
     enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
     enable_execute_command: typing.Optional[builtins.bool] = None,
     health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+    lifecycle_hooks: typing.Optional[typing.Sequence[IDeploymentLifecycleHookTarget]] = None,
     max_healthy_percent: typing.Optional[jsii.Number] = None,
     min_healthy_percent: typing.Optional[jsii.Number] = None,
     propagate_tags: typing.Optional[PropagatedTagSource] = None,
@@ -46850,6 +48240,18 @@ def _typecheckingstub__0275aca574e1acd41af17b3acaa1528dd0890542d27aeee65489bbd55
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__1f10764be69e962209020c3a7e772567f1cbc3d3673cf209506562511ce9cd0a(
+    scope: _constructs_77d1e7e8.IConstruct,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__1cdcc51dc61399e62078243a225e42fd6901317236efebe039a9e3b36834d4b7(
+    scope: _constructs_77d1e7e8.IConstruct,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__11773db60f5e0800c7efe817fcc41dcf7af2f8e010e72471c80e23766e96c5ab(
     task_definition: TaskDefinition,
 ) -> None:
@@ -46977,6 +48379,18 @@ def _typecheckingstub__ef0bdf65f82e85f94b1db5a37b900ed9f46429089cbcb4c8d29b283f3
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__e4bdbe1ec0e220912f9ff8b7769875a4eebd5168734b702329f9d4600ecdb318(
+    rule: _ApplicationListenerRule_f93ff606,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__c964a7ba26c195318cd3937b823b36facecf4120aeb9196876feb206f6f9855a(
+    listener: _NetworkListener_539c17bf,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__5499166a691d3d9b788ba4a9808f921437da0987c4c4733332600e4e584bf30f(
     *,
     container_name: builtins.str,
@@ -47727,6 +49141,23 @@ def _typecheckingstub__8874c61d65168e60874c9191682af53d5d88352dbfe615fd842f45b2b
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__aa25b044df0e4eef1817fd07bd799a88800df4e6bd79f283ca2657cfee9e4b29(
+    id: builtins.str,
+    *,
+    alternate_target_group: _ITargetGroup_83c6f8c4,
+    production_listener: ListenerRuleConfiguration,
+    role: typing.Optional[_IRole_235f5d8e] = None,
+    test_listener: typing.Optional[ListenerRuleConfiguration] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__147067753bcb82b7fc98e3b04dd99ea91c99dac8aec50a2f7076d3593aced862(
+    scope: _constructs_77d1e7e8.IConstruct,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__6aeeebc397e1073be671305f45ff0de1478d4d043824a139c5e52661f7868baf(
     _scope: _constructs_77d1e7e8.Construct,
     _task_definition: TaskDefinition,
@@ -47946,6 +49377,22 @@ def _typecheckingstub__3407e1eace0b05ee1ef50b2d7263c1462cbbc2df7bfe6d22826f0f94f
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__bddcf05621152ce6e8fd520b5a7bb98f63b4f5805beda123da1f9f542d66294e(
+    handler: _IFunction_6adb0ab8,
+    id: builtins.str,
+    *,
+    lifecycle_stages: typing.Sequence[DeploymentLifecycleStage],
+    role: typing.Optional[_IRole_235f5d8e] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__c6510372e5e0e0b1114c294538138af0f03ebd70441a76bddd8496eca40f2fe8(
+    scope: _constructs_77d1e7e8.IConstruct,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__0f3b91860780f56b42f6ab26d1855c0db28e15ef0dc9bcb868556324ed95a96b(
     _scope: _constructs_77d1e7e8.Construct,
     _container_definition: ContainerDefinition,
@@ -48006,6 +49453,12 @@ def _typecheckingstub__3cd0743b65b66534a274ff34e46f82cd780216193c08611a3b4e166e2
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__480743d611a768bf60af18dc6a08c65385351ccd86b4290955b74d1541662389(
+    target: IDeploymentLifecycleHookTarget,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__e086e1f25717ea297fd9f530033e3685af15b9de3deb30fa9b228c05f8b0bcdc(
     volume: ServiceManagedVolume,
 ) -> None:
@@ -48047,6 +49500,13 @@ def _typecheckingstub__027c7741168086e6dc84ce3b453e99740a28a87dabd7b69b28195c0b3
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__1326df14b5ec04898722ff6a20f7c785c16a07195cce2a207d19792a2ccec402(
+    options: typing.Union[LoadBalancerTargetOptions, typing.Dict[builtins.str, typing.Any]],
+    alternate_options: typing.Optional[IAlternateTarget] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__fb3b6cd83a49e029a6aab0309e4bf6a856a09b82a0d6752ebc4b8057753a9902(
     metric_name: builtins.str,
     *,
@@ -48115,15 +49575,18 @@ def _typecheckingstub__1e578461670bd6cdf856f914534e1feff8905e31d33cd7aea2b9f5151
     security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
     vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
     cluster: ICluster,
+    bake_time: typing.Optional[_Duration_4839e8c3] = None,
     capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
     circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
     cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_alarms: typing.Optional[typing.Union[DeploymentAlarmConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+    deployment_strategy: typing.Optional[DeploymentStrategy] = None,
     desired_count: typing.Optional[jsii.Number] = None,
     enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
     enable_execute_command: typing.Optional[builtins.bool] = None,
     health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+    lifecycle_hooks: typing.Optional[typing.Sequence[IDeploymentLifecycleHookTarget]] = None,
     max_healthy_percent: typing.Optional[jsii.Number] = None,
     min_healthy_percent: typing.Optional[jsii.Number] = None,
     propagate_tags: typing.Optional[PropagatedTagSource] = None,
@@ -48265,15 +49728,18 @@ def _typecheckingstub__6ceef4de126cbb6bd6f379ba0b53be2fb61c35761f50685b5d228c682
     daemon: typing.Optional[builtins.bool] = None,
     security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
     cluster: ICluster,
+    bake_time: typing.Optional[_Duration_4839e8c3] = None,
     capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
     circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
     cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_alarms: typing.Optional[typing.Union[DeploymentAlarmConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+    deployment_strategy: typing.Optional[DeploymentStrategy] = None,
     desired_count: typing.Optional[jsii.Number] = None,
     enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
     enable_execute_command: typing.Optional[builtins.bool] = None,
     health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+    lifecycle_hooks: typing.Optional[typing.Sequence[IDeploymentLifecycleHookTarget]] = None,
     max_healthy_percent: typing.Optional[jsii.Number] = None,
     min_healthy_percent: typing.Optional[jsii.Number] = None,
     propagate_tags: typing.Optional[PropagatedTagSource] = None,
@@ -48319,6 +49785,13 @@ def _typecheckingstub__6a882b6874d4ad85f277f48ab87544e61c1ded22af9e05c1fc5cf0aea
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__4cd24799babe0f9419c370222cff02dd9c784b1fd9b652c186a1701c0874337d(
+    _options: typing.Union[LoadBalancerTargetOptions, typing.Dict[builtins.str, typing.Any]],
+    _alternate_options: typing.Optional[IAlternateTarget] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__8c04543cf19a902fa2afce6445c2c60d81551c375dc4a44e88bef45930d140e4(
     *_targets: EcsTarget,
 ) -> None:
@@ -48371,15 +49844,18 @@ def _typecheckingstub__0ddac6b19472d00f74c1777e699ce5b239dc49e62ff4ab4674c917bbe
     security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
     vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
     cluster: ICluster,
+    bake_time: typing.Optional[_Duration_4839e8c3] = None,
     capacity_provider_strategies: typing.Optional[typing.Sequence[typing.Union[CapacityProviderStrategy, typing.Dict[builtins.str, typing.Any]]]] = None,
     circuit_breaker: typing.Optional[typing.Union[DeploymentCircuitBreaker, typing.Dict[builtins.str, typing.Any]]] = None,
     cloud_map_options: typing.Optional[typing.Union[CloudMapOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_alarms: typing.Optional[typing.Union[DeploymentAlarmConfig, typing.Dict[builtins.str, typing.Any]]] = None,
     deployment_controller: typing.Optional[typing.Union[DeploymentController, typing.Dict[builtins.str, typing.Any]]] = None,
+    deployment_strategy: typing.Optional[DeploymentStrategy] = None,
     desired_count: typing.Optional[jsii.Number] = None,
     enable_ecs_managed_tags: typing.Optional[builtins.bool] = None,
     enable_execute_command: typing.Optional[builtins.bool] = None,
     health_check_grace_period: typing.Optional[_Duration_4839e8c3] = None,
+    lifecycle_hooks: typing.Optional[typing.Sequence[IDeploymentLifecycleHookTarget]] = None,
     max_healthy_percent: typing.Optional[jsii.Number] = None,
     min_healthy_percent: typing.Optional[jsii.Number] = None,
     propagate_tags: typing.Optional[PropagatedTagSource] = None,