aws-cdk-lib 2.209.1__py3-none-any.whl → 2.211.0__py3-none-any.whl

aws_cdk/aws_ecs/__init__.py

@@ -2118,8 +2118,6 @@ 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_
 
@@ -2141,99 +2139,17 @@ service.add_lifecycle_hook(ecs.DeploymentLifecycleLambdaTarget(lambda_hook, "Pre
     lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
 ))
 
-target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+target = service.load_balancer_target(
     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.
-
-#### Load Balancer Advanced Configuration
-
-Configure advanced load balancer settings for blue/green deployments with alternate target groups and listener rules:
-
-```python
-# service: ecs.FargateService
-
-
-cfn_service = service.node.default_child
-cfn_service.load_balancers = [ecs.CfnService.LoadBalancerProperty(
-    container_name="web",
-    container_port=80,
-    target_group_arn="arn:aws:elasticloadbalancing:region:account:targetgroup/production",
-    advanced_configuration=ecs.CfnService.AdvancedConfigurationProperty(
-        alternate_target_group_arn="arn:aws:elasticloadbalancing:region:account:targetgroup/test",
-        production_listener_rule="arn:aws:elasticloadbalancing:region:account:listener-rule/production-rule",
-        test_listener_rule="arn:aws:elasticloadbalancing:region:account:listener-rule/test-rule",
-        role_arn="arn:aws:iam::account:role/ecs-blue-green-role"
+    protocol=ecs.Protocol.TCP,
+    alternate_target=ecs.AlternateTarget("AlternateTarget",
+        alternate_target_group=green_target_group,
+        production_listener=ecs.ListenerRuleConfiguration.application_listener_rule(prod_listener_rule)
     )
-)]
-```
-
-#### Blue/Green Deployment Configuration
-
-Configure deployment strategy with bake time and lifecycle hooks:
-
-```python
-# service: ecs.FargateService
-
-
-cfn_service = service.node.default_child
-cfn_service.deployment_configuration = ecs.CfnService.DeploymentConfigurationProperty(
-    maximum_percent=200,
-    minimum_healthy_percent=100,
-    strategy="BLUE_GREEN",
-    bake_time_in_minutes=15,
-    lifecycle_hooks=[ecs.CfnService.DeploymentLifecycleHookProperty(
-        hook_target_arn="arn:aws:lambda:region:account:function:pre-deployment-hook",
-        role_arn="arn:aws:iam::account:role/deployment-hook-role",
-        lifecycle_stages=["PRE_STOP", "POST_START"]
-    )]
 )
-```
-
-#### Service Connect Test Traffic Rules
-
-Configure test traffic routing for Service Connect during blue/green deployments:
-
-```python
-# cluster: ecs.Cluster
-# task_definition: ecs.TaskDefinition
 
-
-service = ecs.FargateService(self, "Service",
-    cluster=cluster,
-    task_definition=task_definition
-)
-
-cfn_service = service.node.default_child
-cfn_service.service_connect_configuration = ecs.CfnService.ServiceConnectConfigurationProperty(
-    enabled=True,
-    services=[ecs.CfnService.ServiceConnectServiceProperty(
-        port_name="api",
-        client_aliases=[ecs.CfnService.ServiceConnectClientAliasProperty(
-            port=80,
-            dns_name="my-service",
-            test_traffic_rules=ecs.CfnService.ServiceConnectTestTrafficRulesProperty(
-                header=ecs.CfnService.ServiceConnectTestTrafficRulesHeaderProperty(
-                    name="x-canary-test",
-                    value=ecs.CfnService.ServiceConnectTestTrafficRulesHeaderValueProperty(
-                        exact="beta-version"
-                    )
-                )
-            )
-        )]
-    )]
-)
+target.attach_to_application_target_group(blue_target_group)
 ```
 
 ## Daemon Scheduling Strategy
@@ -2643,7 +2559,7 @@ class AddCapacityOptions(
         :param key_name: (deprecated) Name of SSH keypair to grant access to instances. ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified You can either specify ``keyPair`` or ``keyName``, not both. Default: - No SSH access will be possible.
         :param key_pair: The SSH keypair to grant access to the instance. Feature flag ``AUTOSCALING_GENERATE_LAUNCH_TEMPLATE`` must be enabled to use this property. ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified. You can either specify ``keyPair`` or ``keyName``, not both. Default: - No SSH access will be possible.
         :param max_capacity: Maximum number of instances in the fleet. Default: desiredCapacity
-        :param max_instance_lifetime: The maximum amount of time that an instance can be in service. The maximum duration applies to all current and future instances in the group. As an instance approaches its maximum duration, it is terminated and replaced, and cannot be used again. You must specify a value of at least 604,800 seconds (7 days). To clear a previously set value, leave this property undefined. Default: none
+        :param max_instance_lifetime: The maximum amount of time that an instance can be in service. The maximum duration applies to all current and future instances in the group. As an instance approaches its maximum duration, it is terminated and replaced, and cannot be used again. You must specify a value of at least 86,400 seconds (one day). To clear a previously set value, leave this property undefined. Default: none
         :param min_capacity: Minimum number of instances in the fleet. Default: 1
         :param new_instances_protected_from_scale_in: Whether newly-launched instances are protected from termination by Amazon EC2 Auto Scaling when scaling in. By default, Auto Scaling can terminate an instance at any time after launch when scaling in an Auto Scaling Group, subject to the group's termination policy. However, you may wish to protect newly-launched instances from being scaled in if they are going to run critical applications that should not be prematurely terminated. This flag must be enabled if the Auto Scaling Group will be associated with an ECS Capacity Provider with managed termination protection. Default: false
         :param notifications: Configure autoscaling group to send notifications about fleet changes to an SNS topic(s). Default: - No fleet change notifications will be sent.
@@ -3065,7 +2981,7 @@ class AddCapacityOptions(
         to all current and future instances in the group. As an instance approaches its maximum duration,
         it is terminated and replaced, and cannot be used again.
 
-        You must specify a value of at least 604,800 seconds (7 days). To clear a previously set value,
+        You must specify a value of at least 86,400 seconds (one day). To clear a previously set value,
         leave this property undefined.
 
         :default: none
@@ -3553,14 +3469,15 @@ class AlternateTargetProps(AlternateTargetOptions):
                 lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
             ))
             
-            target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+            target = service.load_balancer_target(
                 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)
-            ))
+                protocol=ecs.Protocol.TCP,
+                alternate_target=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)
         '''
@@ -9081,23 +8998,184 @@ class CfnService(
 
     :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-service.html
     :cloudformationResource: AWS::ECS::Service
-    :exampleMetadata: infused
+    :exampleMetadata: fixture=_generated
 
     Example::
 
-        # service: ecs.FargateService
+        # 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
+        
+        cfn_service = ecs.CfnService(self, "MyCfnService",
+            availability_zone_rebalancing="availabilityZoneRebalancing",
+            capacity_provider_strategy=[ecs.CfnService.CapacityProviderStrategyItemProperty(
+                base=123,
+                capacity_provider="capacityProvider",
+                weight=123
+            )],
+            cluster="cluster",
+            deployment_configuration=ecs.CfnService.DeploymentConfigurationProperty(
+                alarms=ecs.CfnService.DeploymentAlarmsProperty(
+                    alarm_names=["alarmNames"],
+                    enable=False,
+                    rollback=False
+                ),
+                bake_time_in_minutes=123,
+                deployment_circuit_breaker=ecs.CfnService.DeploymentCircuitBreakerProperty(
+                    enable=False,
+                    rollback=False
+                ),
+                lifecycle_hooks=[ecs.CfnService.DeploymentLifecycleHookProperty(
+                    hook_target_arn="hookTargetArn",
+                    lifecycle_stages=["lifecycleStages"],
+                    role_arn="roleArn"
+                )],
+                maximum_percent=123,
+                minimum_healthy_percent=123,
+                strategy="strategy"
+            ),
+            deployment_controller=ecs.CfnService.DeploymentControllerProperty(
+                type="type"
+            ),
+            desired_count=123,
+            enable_ecs_managed_tags=False,
+            enable_execute_command=False,
+            health_check_grace_period_seconds=123,
+            launch_type="launchType",
+            load_balancers=[ecs.CfnService.LoadBalancerProperty(
+                advanced_configuration=ecs.CfnService.AdvancedConfigurationProperty(
+                    alternate_target_group_arn="alternateTargetGroupArn",
+        
+                    # the properties below are optional
+                    production_listener_rule="productionListenerRule",
+                    role_arn="roleArn",
+                    test_listener_rule="testListenerRule"
+                ),
+                container_name="containerName",
+                container_port=123,
+                load_balancer_name="loadBalancerName",
+                target_group_arn="targetGroupArn"
+            )],
+            network_configuration=ecs.CfnService.NetworkConfigurationProperty(
+                awsvpc_configuration=ecs.CfnService.AwsVpcConfigurationProperty(
+                    assign_public_ip="assignPublicIp",
+                    security_groups=["securityGroups"],
+                    subnets=["subnets"]
+                )
+            ),
+            placement_constraints=[ecs.CfnService.PlacementConstraintProperty(
+                type="type",
+        
+                # the properties below are optional
+                expression="expression"
+            )],
+            placement_strategies=[ecs.CfnService.PlacementStrategyProperty(
+                type="type",
+        
+                # the properties below are optional
+                field="field"
+            )],
+            platform_version="platformVersion",
+            propagate_tags="propagateTags",
+            role="role",
+            scheduling_strategy="schedulingStrategy",
+            service_connect_configuration=ecs.CfnService.ServiceConnectConfigurationProperty(
+                enabled=False,
+        
+                # the properties below are optional
+                log_configuration=ecs.CfnService.LogConfigurationProperty(
+                    log_driver="logDriver",
+                    options={
+                        "options_key": "options"
+                    },
+                    secret_options=[ecs.CfnService.SecretProperty(
+                        name="name",
+                        value_from="valueFrom"
+                    )]
+                ),
+                namespace="namespace",
+                services=[ecs.CfnService.ServiceConnectServiceProperty(
+                    port_name="portName",
+        
+                    # the properties below are optional
+                    client_aliases=[ecs.CfnService.ServiceConnectClientAliasProperty(
+                        port=123,
         
+                        # the properties below are optional
+                        dns_name="dnsName",
+                        test_traffic_rules=ecs.CfnService.ServiceConnectTestTrafficRulesProperty(
+                            header=ecs.CfnService.ServiceConnectTestTrafficRulesHeaderProperty(
+                                name="name",
+        
+                                # the properties below are optional
+                                value=ecs.CfnService.ServiceConnectTestTrafficRulesHeaderValueProperty(
+                                    exact="exact"
+                                )
+                            )
+                        )
+                    )],
+                    discovery_name="discoveryName",
+                    ingress_port_override=123,
+                    timeout=ecs.CfnService.TimeoutConfigurationProperty(
+                        idle_timeout_seconds=123,
+                        per_request_timeout_seconds=123
+                    ),
+                    tls=ecs.CfnService.ServiceConnectTlsConfigurationProperty(
+                        issuer_certificate_authority=ecs.CfnService.ServiceConnectTlsCertificateAuthorityProperty(
+                            aws_pca_authority_arn="awsPcaAuthorityArn"
+                        ),
         
-        cfn_service = service.node.default_child
-        cfn_service.deployment_configuration = ecs.CfnService.DeploymentConfigurationProperty(
-            maximum_percent=200,
-            minimum_healthy_percent=100,
-            strategy="BLUE_GREEN",
-            bake_time_in_minutes=15,
-            lifecycle_hooks=[ecs.CfnService.DeploymentLifecycleHookProperty(
-                hook_target_arn="arn:aws:lambda:region:account:function:pre-deployment-hook",
-                role_arn="arn:aws:iam::account:role/deployment-hook-role",
-                lifecycle_stages=["PRE_STOP", "POST_START"]
+                        # the properties below are optional
+                        kms_key="kmsKey",
+                        role_arn="roleArn"
+                    )
+                )]
+            ),
+            service_name="serviceName",
+            service_registries=[ecs.CfnService.ServiceRegistryProperty(
+                container_name="containerName",
+                container_port=123,
+                port=123,
+                registry_arn="registryArn"
+            )],
+            tags=[CfnTag(
+                key="key",
+                value="value"
+            )],
+            task_definition="taskDefinition",
+            volume_configurations=[ecs.CfnService.ServiceVolumeConfigurationProperty(
+                name="name",
+        
+                # the properties below are optional
+                managed_ebs_volume=ecs.CfnService.ServiceManagedEBSVolumeConfigurationProperty(
+                    role_arn="roleArn",
+        
+                    # the properties below are optional
+                    encrypted=False,
+                    filesystem_type="filesystemType",
+                    iops=123,
+                    kms_key_id="kmsKeyId",
+                    size_in_gi_b=123,
+                    snapshot_id="snapshotId",
+                    tag_specifications=[ecs.CfnService.EBSTagSpecificationProperty(
+                        resource_type="resourceType",
+        
+                        # the properties below are optional
+                        propagate_tags="propagateTags",
+                        tags=[CfnTag(
+                            key="key",
+                            value="value"
+                        )]
+                    )],
+                    throughput=123,
+                    volume_initialization_rate=123,
+                    volume_type="volumeType"
+                )
+            )],
+            vpc_lattice_configurations=[ecs.CfnService.VpcLatticeConfigurationProperty(
+                port_name="portName",
+                role_arn="roleArn",
+                target_group_arn="targetGroupArn"
             )]
         )
     '''
@@ -9136,7 +9214,7 @@ class CfnService(
         '''
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
-        :param availability_zone_rebalancing: Indicates whether to use Availability Zone rebalancing for the service. For more information, see `Balancing an Amazon ECS service across Availability Zones <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-rebalancing.html>`_ in the **Amazon Elastic Container Service Developer Guide** . Default: - "DISABLED"
+        :param availability_zone_rebalancing: Indicates whether to use Availability Zone rebalancing for the service. For more information, see `Balancing an Amazon ECS service across Availability Zones <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-rebalancing.html>`_ in the **Amazon Elastic Container Service Developer Guide** . Default: - "ENABLED"
         :param capacity_provider_strategy: The capacity provider strategy to use for the service. If a ``capacityProviderStrategy`` is specified, the ``launchType`` parameter must be omitted. If no ``capacityProviderStrategy`` or ``launchType`` is specified, the ``defaultCapacityProviderStrategy`` for the cluster is used. A capacity provider strategy can contain a maximum of 20 capacity providers. .. epigraph:: To remove this property from your service resource, specify an empty ``CapacityProviderStrategyItem`` array.
         :param cluster: The short name or full Amazon Resource Name (ARN) of the cluster that you run your service on. If you do not specify a cluster, the default cluster is assumed.
         :param deployment_configuration: Optional deployment parameters that control how many tasks run during the deployment and the ordering of stopping and starting tasks.
@@ -12995,7 +13073,7 @@ class CfnServiceProps:
     ) -> None:
         '''Properties for defining a ``CfnService``.
 
-        :param availability_zone_rebalancing: Indicates whether to use Availability Zone rebalancing for the service. For more information, see `Balancing an Amazon ECS service across Availability Zones <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-rebalancing.html>`_ in the **Amazon Elastic Container Service Developer Guide** . Default: - "DISABLED"
+        :param availability_zone_rebalancing: Indicates whether to use Availability Zone rebalancing for the service. For more information, see `Balancing an Amazon ECS service across Availability Zones <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-rebalancing.html>`_ in the **Amazon Elastic Container Service Developer Guide** . Default: - "ENABLED"
         :param capacity_provider_strategy: The capacity provider strategy to use for the service. If a ``capacityProviderStrategy`` is specified, the ``launchType`` parameter must be omitted. If no ``capacityProviderStrategy`` or ``launchType`` is specified, the ``defaultCapacityProviderStrategy`` for the cluster is used. A capacity provider strategy can contain a maximum of 20 capacity providers. .. epigraph:: To remove this property from your service resource, specify an empty ``CapacityProviderStrategyItem`` array.
         :param cluster: The short name or full Amazon Resource Name (ARN) of the cluster that you run your service on. If you do not specify a cluster, the default cluster is assumed.
         :param deployment_configuration: Optional deployment parameters that control how many tasks run during the deployment and the ordering of stopping and starting tasks.
@@ -13288,7 +13366,7 @@ class CfnServiceProps:
 
         For more information, see `Balancing an Amazon ECS service across Availability Zones <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-rebalancing.html>`_ in the **Amazon Elastic Container Service Developer Guide** .
 
-        :default: - "DISABLED"
+        :default: - "ENABLED"
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-service.html#cfn-ecs-service-availabilityzonerebalancing
         '''
@@ -24990,14 +25068,15 @@ class DeploymentLifecycleLambdaTargetProps:
                 lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
             ))
             
-            target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+            target = service.load_balancer_target(
                 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)
-            ))
+                protocol=ecs.Protocol.TCP,
+                alternate_target=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)
         '''
@@ -25067,14 +25146,15 @@ class DeploymentLifecycleStage(enum.Enum):
             lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
         ))
         
-        target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+        target = service.load_balancer_target(
             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)
-        ))
+            protocol=ecs.Protocol.TCP,
+            alternate_target=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)
     '''
@@ -25123,14 +25203,15 @@ class DeploymentStrategy(enum.Enum):
             lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
         ))
         
-        target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+        target = service.load_balancer_target(
             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)
-        ))
+            protocol=ecs.Protocol.TCP,
+            alternate_target=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)
     '''
@@ -25829,7 +25910,7 @@ class Ec2ServiceProps(BaseServiceOptions):
         :param volume_configurations: Configuration details for a volume used by the service. This allows you to specify details about the EBS volume that can be attched to ECS tasks. Default: - undefined
         :param task_definition: The task definition to use for tasks in the service. [disable-awslint:ref-via-interface]
         :param assign_public_ip: Specifies whether the task's elastic network interface receives a public IP address. If true, each task will receive a public IP address. This property is only used for tasks that use the awsvpc network mode. Default: false
-        :param availability_zone_rebalancing: Whether to use Availability Zone rebalancing for the service. If enabled: ``maxHealthyPercent`` must be greater than 100; ``daemon`` must be false; if there are any ``placementStrategies``, the first must be "spread across Availability Zones"; there must be no ``placementConstraints`` using ``attribute:ecs.availability-zone``, and the service must not be a target of a Classic Load Balancer. Default: AvailabilityZoneRebalancing.DISABLED
+        :param availability_zone_rebalancing: Whether to use Availability Zone rebalancing for the service. If enabled: ``maxHealthyPercent`` must be greater than 100; ``daemon`` must be false; if there are any ``placementStrategies``, the first must be "spread across Availability Zones"; there must be no ``placementConstraints`` using ``attribute:ecs.availability-zone``, and the service must not be a target of a Classic Load Balancer. Default: AvailabilityZoneRebalancing.ENABLED
         :param daemon: Specifies whether the service will use the 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. Default: false
         :param placement_constraints: The placement constraints to use for tasks in the service. For more information, see `Amazon ECS Task Placement Constraints <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html>`_. Default: - No constraints.
         :param placement_strategies: The placement strategies to use for tasks in the service. For more information, see `Amazon ECS Task Placement Strategies <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-strategies.html>`_. Default: - No strategies.
@@ -26203,7 +26284,7 @@ class Ec2ServiceProps(BaseServiceOptions):
         must be no ``placementConstraints`` using ``attribute:ecs.availability-zone``, and the
         service must not be a target of a Classic Load Balancer.
 
-        :default: AvailabilityZoneRebalancing.DISABLED
+        :default: AvailabilityZoneRebalancing.ENABLED
 
         :see: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-rebalancing.html
         '''
@@ -28784,7 +28865,7 @@ class FargateServiceProps(BaseServiceOptions):
         :param volume_configurations: Configuration details for a volume used by the service. This allows you to specify details about the EBS volume that can be attched to ECS tasks. Default: - undefined
         :param task_definition: The task definition to use for tasks in the service. [disable-awslint:ref-via-interface]
         :param assign_public_ip: Specifies whether the task's elastic network interface receives a public IP address. If true, each task will receive a public IP address. Default: false
-        :param availability_zone_rebalancing: Whether to use Availability Zone rebalancing for the service. If enabled, ``maxHealthyPercent`` must be greater than 100, and the service must not be a target of a Classic Load Balancer. Default: AvailabilityZoneRebalancing.DISABLED
+        :param availability_zone_rebalancing: Whether to use Availability Zone rebalancing for the service. If enabled, ``maxHealthyPercent`` must be greater than 100, and the service must not be a target of a Classic Load Balancer. Default: AvailabilityZoneRebalancing.ENABLED
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :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.
@@ -28797,28 +28878,34 @@ class FargateServiceProps(BaseServiceOptions):
             
             # cluster: ecs.Cluster
             # task_definition: ecs.TaskDefinition
-            # elb_alarm: cw.Alarm
-            
             
+            service_name = "MyFargateService"
             service = ecs.FargateService(self, "Service",
+                service_name=service_name,
                 cluster=cluster,
                 task_definition=task_definition,
-                min_healthy_percent=100,
-                deployment_alarms=ecs.DeploymentAlarmConfig(
-                    alarm_names=[elb_alarm.alarm_name],
-                    behavior=ecs.AlarmBehavior.ROLLBACK_ON_ALARM
-                )
+                min_healthy_percent=100
             )
             
-            # Defining a deployment alarm after the service has been created
-            cpu_alarm_name = "MyCpuMetricAlarm"
-            cw.Alarm(self, "CPUAlarm",
-                alarm_name=cpu_alarm_name,
-                metric=service.metric_cpu_utilization(),
+            cpu_metric = cw.Metric(
+                metric_name="CPUUtilization",
+                namespace="AWS/ECS",
+                period=Duration.minutes(5),
+                statistic="Average",
+                dimensions_map={
+                    "ClusterName": cluster.cluster_name,
+                    # Using `service.serviceName` here will cause a circular dependency
+                    "ServiceName": service_name
+                }
+            )
+            my_alarm = cw.Alarm(self, "CPUAlarm",
+                alarm_name="cpuAlarmName",
+                metric=cpu_metric,
                 evaluation_periods=2,
                 threshold=80
             )
-            service.enable_deployment_alarms([cpu_alarm_name],
+            
+            service.enable_deployment_alarms([my_alarm.alarm_name],
                 behavior=ecs.AlarmBehavior.FAIL_ON_ALARM
             )
         '''
@@ -29149,7 +29236,7 @@ class FargateServiceProps(BaseServiceOptions):
         If enabled, ``maxHealthyPercent`` must be greater than 100, and the service must not be a target
         of a Classic Load Balancer.
 
-        :default: AvailabilityZoneRebalancing.DISABLED
+        :default: AvailabilityZoneRebalancing.ENABLED
 
         :see: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-rebalancing.html
         '''
@@ -33997,14 +34084,15 @@ class ListenerRuleConfiguration(
             lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
         ))
         
-        target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+        target = service.load_balancer_target(
             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)
-        ))
+            protocol=ecs.Protocol.TCP,
+            alternate_target=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)
     '''
@@ -34055,6 +34143,7 @@ typing.cast(typing.Any, ListenerRuleConfiguration).__jsii_proxy_class__ = lambda
     jsii_struct_bases=[],
     name_mapping={
         "container_name": "containerName",
+        "alternate_target": "alternateTarget",
         "container_port": "containerPort",
         "protocol": "protocol",
     },
@@ -34064,6 +34153,7 @@ class LoadBalancerTargetOptions:
         self,
         *,
         container_name: builtins.str,
+        alternate_target: typing.Optional[IAlternateTarget] = None,
         container_port: typing.Optional[jsii.Number] = None,
         protocol: typing.Optional["Protocol"] = None,
     ) -> None:
@@ -34072,6 +34162,7 @@ class LoadBalancerTargetOptions:
         The port mapping for it must already have been created through addPortMapping().
 
         :param container_name: The name of the container.
+        :param alternate_target: Alternate target configuration for blue/green deployments. Default: - No alternate target configuration
         :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
 
@@ -34095,11 +34186,14 @@ class LoadBalancerTargetOptions:
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__5499166a691d3d9b788ba4a9808f921437da0987c4c4733332600e4e584bf30f)
             check_type(argname="argument container_name", value=container_name, expected_type=type_hints["container_name"])
+            check_type(argname="argument alternate_target", value=alternate_target, expected_type=type_hints["alternate_target"])
             check_type(argname="argument container_port", value=container_port, expected_type=type_hints["container_port"])
             check_type(argname="argument protocol", value=protocol, expected_type=type_hints["protocol"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "container_name": container_name,
         }
+        if alternate_target is not None:
+            self._values["alternate_target"] = alternate_target
         if container_port is not None:
             self._values["container_port"] = container_port
         if protocol is not None:
@@ -34112,6 +34206,15 @@ class LoadBalancerTargetOptions:
         assert result is not None, "Required property 'container_name' is missing"
         return typing.cast(builtins.str, result)
 
+    @builtins.property
+    def alternate_target(self) -> typing.Optional[IAlternateTarget]:
+        '''Alternate target configuration for blue/green deployments.
+
+        :default: - No alternate target configuration
+        '''
+        result = self._values.get("alternate_target")
+        return typing.cast(typing.Optional[IAlternateTarget], result)
+
     @builtins.property
     def container_port(self) -> typing.Optional[jsii.Number]:
         '''The port number of the container.
@@ -35756,14 +35859,15 @@ class Protocol(enum.Enum):
             lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
         ))
         
-        target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+        target = service.load_balancer_target(
             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)
-        ))
+            protocol=ecs.Protocol.TCP,
+            alternate_target=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)
     '''
@@ -41057,14 +41161,15 @@ class AlternateTarget(
             lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
         ))
         
-        target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+        target = service.load_balancer_target(
             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)
-        ))
+            protocol=ecs.Protocol.TCP,
+            alternate_target=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)
     '''
@@ -41838,7 +41943,7 @@ class Cluster(
         :param key_name: (deprecated) Name of SSH keypair to grant access to instances. ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified You can either specify ``keyPair`` or ``keyName``, not both. Default: - No SSH access will be possible.
         :param key_pair: The SSH keypair to grant access to the instance. Feature flag ``AUTOSCALING_GENERATE_LAUNCH_TEMPLATE`` must be enabled to use this property. ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified. You can either specify ``keyPair`` or ``keyName``, not both. Default: - No SSH access will be possible.
         :param max_capacity: Maximum number of instances in the fleet. Default: desiredCapacity
-        :param max_instance_lifetime: The maximum amount of time that an instance can be in service. The maximum duration applies to all current and future instances in the group. As an instance approaches its maximum duration, it is terminated and replaced, and cannot be used again. You must specify a value of at least 604,800 seconds (7 days). To clear a previously set value, leave this property undefined. Default: none
+        :param max_instance_lifetime: The maximum amount of time that an instance can be in service. The maximum duration applies to all current and future instances in the group. As an instance approaches its maximum duration, it is terminated and replaced, and cannot be used again. You must specify a value of at least 86,400 seconds (one day). To clear a previously set value, leave this property undefined. Default: none
         :param min_capacity: Minimum number of instances in the fleet. Default: 1
         :param new_instances_protected_from_scale_in: Whether newly-launched instances are protected from termination by Amazon EC2 Auto Scaling when scaling in. By default, Auto Scaling can terminate an instance at any time after launch when scaling in an Auto Scaling Group, subject to the group's termination policy. However, you may wish to protect newly-launched instances from being scaled in if they are going to run critical applications that should not be prematurely terminated. This flag must be enabled if the Auto Scaling Group will be associated with an ECS Capacity Provider with managed termination protection. Default: false
         :param notifications: Configure autoscaling group to send notifications about fleet changes to an SNS topic(s). Default: - No fleet change notifications will be sent.
@@ -42417,14 +42522,15 @@ class DeploymentLifecycleLambdaTarget(
             lifecycle_stages=[ecs.DeploymentLifecycleStage.PRE_SCALE_UP]
         ))
         
-        target = service.load_balancer_target(ecs.LoadBalancerTargetOptions(
+        target = service.load_balancer_target(
             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)
-        ))
+            protocol=ecs.Protocol.TCP,
+            alternate_target=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)
     '''
@@ -43388,8 +43494,11 @@ class BaseService(
     @jsii.member(jsii_name="loadBalancerTarget")
     def load_balancer_target(
         self,
-        options: typing.Union[LoadBalancerTargetOptions, typing.Dict[builtins.str, typing.Any]],
-        alternate_options: typing.Optional[IAlternateTarget] = None,
+        *,
+        container_name: builtins.str,
+        alternate_target: typing.Optional[IAlternateTarget] = None,
+        container_port: typing.Optional[jsii.Number] = None,
+        protocol: typing.Optional[Protocol] = None,
     ) -> IEcsLoadBalancerTarget:
         '''Return a load balancing target for a specific container and port.
 
@@ -43400,8 +43509,10 @@ 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 options: -
-        :param alternate_options: -
+        :param container_name: The name of the container.
+        :param alternate_target: Alternate target configuration for blue/green deployments. Default: - No alternate target configuration
+        :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
 
         Example::
 
@@ -43416,11 +43527,14 @@ class BaseService(
                 )]
             )
         '''
-        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]))
+        options = LoadBalancerTargetOptions(
+            container_name=container_name,
+            alternate_target=alternate_target,
+            container_port=container_port,
+            protocol=protocol,
+        )
+
+        return typing.cast(IEcsLoadBalancerTarget, jsii.invoke(self, "loadBalancerTarget", [options]))
 
     @jsii.member(jsii_name="metric")
     def metric(
@@ -43819,7 +43933,7 @@ class Ec2Service(
         :param id: -
         :param task_definition: The task definition to use for tasks in the service. [disable-awslint:ref-via-interface]
         :param assign_public_ip: Specifies whether the task's elastic network interface receives a public IP address. If true, each task will receive a public IP address. This property is only used for tasks that use the awsvpc network mode. Default: false
-        :param availability_zone_rebalancing: Whether to use Availability Zone rebalancing for the service. If enabled: ``maxHealthyPercent`` must be greater than 100; ``daemon`` must be false; if there are any ``placementStrategies``, the first must be "spread across Availability Zones"; there must be no ``placementConstraints`` using ``attribute:ecs.availability-zone``, and the service must not be a target of a Classic Load Balancer. Default: AvailabilityZoneRebalancing.DISABLED
+        :param availability_zone_rebalancing: Whether to use Availability Zone rebalancing for the service. If enabled: ``maxHealthyPercent`` must be greater than 100; ``daemon`` must be false; if there are any ``placementStrategies``, the first must be "spread across Availability Zones"; there must be no ``placementConstraints`` using ``attribute:ecs.availability-zone``, and the service must not be a target of a Classic Load Balancer. Default: AvailabilityZoneRebalancing.ENABLED
         :param daemon: Specifies whether the service will use the 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. Default: false
         :param placement_constraints: The placement constraints to use for tasks in the service. For more information, see `Amazon ECS Task Placement Constraints <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-constraints.html>`_. Default: - No constraints.
         :param placement_strategies: The placement strategies to use for tasks in the service. For more information, see `Amazon ECS Task Placement Strategies <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-placement-strategies.html>`_. Default: - No strategies.
@@ -44542,19 +44656,27 @@ class ExternalService(
     @jsii.member(jsii_name="loadBalancerTarget")
     def load_balancer_target(
         self,
-        _options: typing.Union[LoadBalancerTargetOptions, typing.Dict[builtins.str, typing.Any]],
-        _alternate_options: typing.Optional[IAlternateTarget] = None,
+        *,
+        container_name: builtins.str,
+        alternate_target: typing.Optional[IAlternateTarget] = None,
+        container_port: typing.Optional[jsii.Number] = None,
+        protocol: typing.Optional[Protocol] = None,
     ) -> IEcsLoadBalancerTarget:
         '''Overridden method to throw error as ``loadBalancerTarget`` is not supported for external service.
 
-        :param _options: -
-        :param _alternate_options: -
+        :param container_name: The name of the container.
+        :param alternate_target: Alternate target configuration for blue/green deployments. Default: - No alternate target configuration
+        :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
         '''
-        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]))
+        _options = LoadBalancerTargetOptions(
+            container_name=container_name,
+            alternate_target=alternate_target,
+            container_port=container_port,
+            protocol=protocol,
+        )
+
+        return typing.cast(IEcsLoadBalancerTarget, jsii.invoke(self, "loadBalancerTarget", [_options]))
 
     @jsii.member(jsii_name="registerLoadBalancerTargets")
     def register_load_balancer_targets(self, *_targets: EcsTarget) -> None:
@@ -44734,28 +44856,34 @@ class FargateService(
         
         # cluster: ecs.Cluster
         # task_definition: ecs.TaskDefinition
-        # elb_alarm: cw.Alarm
-        
         
+        service_name = "MyFargateService"
         service = ecs.FargateService(self, "Service",
+            service_name=service_name,
             cluster=cluster,
             task_definition=task_definition,
-            min_healthy_percent=100,
-            deployment_alarms=ecs.DeploymentAlarmConfig(
-                alarm_names=[elb_alarm.alarm_name],
-                behavior=ecs.AlarmBehavior.ROLLBACK_ON_ALARM
-            )
+            min_healthy_percent=100
         )
         
-        # Defining a deployment alarm after the service has been created
-        cpu_alarm_name = "MyCpuMetricAlarm"
-        cw.Alarm(self, "CPUAlarm",
-            alarm_name=cpu_alarm_name,
-            metric=service.metric_cpu_utilization(),
+        cpu_metric = cw.Metric(
+            metric_name="CPUUtilization",
+            namespace="AWS/ECS",
+            period=Duration.minutes(5),
+            statistic="Average",
+            dimensions_map={
+                "ClusterName": cluster.cluster_name,
+                # Using `service.serviceName` here will cause a circular dependency
+                "ServiceName": service_name
+            }
+        )
+        my_alarm = cw.Alarm(self, "CPUAlarm",
+            alarm_name="cpuAlarmName",
+            metric=cpu_metric,
             evaluation_periods=2,
             threshold=80
         )
-        service.enable_deployment_alarms([cpu_alarm_name],
+        
+        service.enable_deployment_alarms([my_alarm.alarm_name],
             behavior=ecs.AlarmBehavior.FAIL_ON_ALARM
         )
     '''
@@ -44798,7 +44926,7 @@ class FargateService(
         :param id: -
         :param task_definition: The task definition to use for tasks in the service. [disable-awslint:ref-via-interface]
         :param assign_public_ip: Specifies whether the task's elastic network interface receives a public IP address. If true, each task will receive a public IP address. Default: false
-        :param availability_zone_rebalancing: Whether to use Availability Zone rebalancing for the service. If enabled, ``maxHealthyPercent`` must be greater than 100, and the service must not be a target of a Classic Load Balancer. Default: AvailabilityZoneRebalancing.DISABLED
+        :param availability_zone_rebalancing: Whether to use Availability Zone rebalancing for the service. If enabled, ``maxHealthyPercent`` must be greater than 100, and the service must not be a target of a Classic Load Balancer. Default: AvailabilityZoneRebalancing.ENABLED
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :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.
@@ -48394,6 +48522,7 @@ def _typecheckingstub__c964a7ba26c195318cd3937b823b36facecf4120aeb9196876feb206f
 def _typecheckingstub__5499166a691d3d9b788ba4a9808f921437da0987c4c4733332600e4e584bf30f(
     *,
     container_name: builtins.str,
+    alternate_target: typing.Optional[IAlternateTarget] = None,
     container_port: typing.Optional[jsii.Number] = None,
     protocol: typing.Optional[Protocol] = None,
 ) -> None:
@@ -49500,13 +49629,6 @@ 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,
     *,
@@ -49785,13 +49907,6 @@ 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: