aws-cdk-lib 2.218.0__py3-none-any.whl → 2.220.0__py3-none-any.whl

aws_cdk/aws_ecs/__init__.py

@@ -1696,6 +1696,108 @@ ecs.Ec2Service(self, "EC2Service",
 )
 ```
 
+### Managed Instances Capacity Providers
+
+Managed Instances Capacity Providers allow you to use AWS-managed EC2 instances for your ECS tasks while providing more control over instance selection than standard Fargate. AWS handles the instance lifecycle, patching, and maintenance while you can specify detailed instance requirements.
+
+To create a Managed Instances Capacity Provider, you need to specify the required EC2 instance profile, and networking configuration. You can also define detailed instance requirements to control which types of instances are used for your workloads.
+
+```python
+# vpc: ec2.Vpc
+# infrastructure_role: iam.Role
+# instance_profile: iam.InstanceProfile
+
+
+cluster = ecs.Cluster(self, "Cluster", vpc=vpc)
+
+# Create a Managed Instances Capacity Provider
+mi_capacity_provider = ecs.ManagedInstancesCapacityProvider(self, "MICapacityProvider",
+    infrastructure_role=infrastructure_role,
+    ec2_instance_profile=instance_profile,
+    subnets=vpc.private_subnets,
+    security_groups=[ec2.SecurityGroup(self, "MISecurityGroup", vpc=vpc)],
+    instance_requirements=ec2.InstanceRequirementsConfig(
+        v_cpu_count_min=1,
+        memory_min=Size.gibibytes(2),
+        cpu_manufacturers=[ec2.CpuManufacturer.INTEL],
+        accelerator_manufacturers=[ec2.AcceleratorManufacturer.NVIDIA]
+    ),
+    propagate_tags=ecs.PropagateManagedInstancesTags.CAPACITY_PROVIDER
+)
+
+# Add the capacity provider to the cluster
+cluster.add_managed_instances_capacity_provider(mi_capacity_provider)
+
+task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
+
+task_definition.add_container("web",
+    image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
+    memory_reservation_mi_b=256
+)
+
+ecs.Ec2Service(self, "EC2Service",
+    cluster=cluster,
+    task_definition=task_definition,
+    min_healthy_percent=100,
+    capacity_provider_strategies=[ecs.CapacityProviderStrategy(
+        capacity_provider=mi_capacity_provider.capacity_provider_name,
+        weight=1
+    )
+    ]
+)
+```
+
+You can specify detailed instance requirements to control which types of instances are used:
+
+```python
+# infrastructure_role: iam.Role
+# instance_profile: iam.InstanceProfile
+# vpc: ec2.Vpc
+
+
+mi_capacity_provider = ecs.ManagedInstancesCapacityProvider(self, "MICapacityProvider",
+    infrastructure_role=infrastructure_role,
+    ec2_instance_profile=instance_profile,
+    subnets=vpc.private_subnets,
+    instance_requirements=ec2.InstanceRequirementsConfig(
+        # Required: CPU and memory constraints
+        v_cpu_count_min=2,
+        v_cpu_count_max=8,
+        memory_min=Size.gibibytes(4),
+        memory_max=Size.gibibytes(32),
+
+        # CPU preferences
+        cpu_manufacturers=[ec2.CpuManufacturer.INTEL, ec2.CpuManufacturer.AMD],
+        instance_generations=[ec2.InstanceGeneration.CURRENT],
+
+        # Instance type filtering
+        allowed_instance_types=["m5.*", "c5.*"],
+
+        # Performance characteristics
+        burstable_performance=ec2.BurstablePerformance.EXCLUDED,
+        bare_metal=ec2.BareMetal.EXCLUDED,
+
+        # Accelerator requirements (for ML/AI workloads)
+        accelerator_types=[ec2.AcceleratorType.GPU],
+        accelerator_manufacturers=[ec2.AcceleratorManufacturer.NVIDIA],
+        accelerator_names=[ec2.AcceleratorName.T4, ec2.AcceleratorName.V100],
+        accelerator_count_min=1,
+
+        # Storage requirements
+        local_storage=ec2.LocalStorage.REQUIRED,
+        local_storage_types=[ec2.LocalStorageType.SSD],
+        total_local_storage_gBMin=100,
+
+        # Network requirements
+        network_interface_count_min=2,
+        network_bandwidth_gbps_min=10,
+
+        # Cost optimization
+        on_demand_max_price_percentage_over_lowest_price=10
+    )
+)
+```
+
 ### Cluster Default Provider Strategy
 
 A capacity provider strategy determines whether ECS tasks are launched on EC2 instances or Fargate/Fargate Spot. It can be specified at the cluster, service, or task level, and consists of one or more capacity providers. You can specify an optional base and weight value for finer control of how tasks are launched. The `base` specifies a minimum number of tasks on one capacity provider, and the `weight`s of each capacity provider determine how tasks are distributed after `base` is satisfied.
@@ -2271,8 +2373,10 @@ from ..aws_ec2 import (
     IKeyPair as _IKeyPair_bc344eda,
     IMachineImage as _IMachineImage_0e8bd50b,
     ISecurityGroup as _ISecurityGroup_acf8a799,
+    ISubnet as _ISubnet_d57d1229,
     IVpc as _IVpc_f30d5663,
     InstanceArchitecture as _InstanceArchitecture_7721cb36,
+    InstanceRequirementsConfig as _InstanceRequirementsConfig_1b353659,
     InstanceType as _InstanceType_f64915b9,
     MachineImageConfig as _MachineImageConfig_187edaee,
     SubnetSelection as _SubnetSelection_e57d76df,
@@ -2313,6 +2417,7 @@ from ..aws_elasticloadbalancingv2 import (
 from ..aws_iam import (
     Grant as _Grant_a7ae64f8,
     IGrantable as _IGrantable_71c4f5de,
+    IInstanceProfile as _IInstanceProfile_10d5ce2c,
     IRole as _IRole_235f5d8e,
     PolicyStatement as _PolicyStatement_0fe33853,
 )
@@ -6757,6 +6862,8 @@ class CapacityProviderStrategy:
     jsii_struct_bases=[],
     name_mapping={
         "auto_scaling_group_provider": "autoScalingGroupProvider",
+        "cluster_name": "clusterName",
+        "managed_instances_provider": "managedInstancesProvider",
         "name": "name",
         "tags": "tags",
     },
@@ -6766,12 +6873,16 @@ class CfnCapacityProviderProps:
         self,
         *,
         auto_scaling_group_provider: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.AutoScalingGroupProviderProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        cluster_name: typing.Optional[builtins.str] = None,
+        managed_instances_provider: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.ManagedInstancesProviderProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         name: typing.Optional[builtins.str] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
         '''Properties for defining a ``CfnCapacityProvider``.
 
         :param auto_scaling_group_provider: The Auto Scaling group settings for the capacity provider.
+        :param cluster_name: 
+        :param managed_instances_provider: The configuration for the Amazon ECS Managed Instances provider. This includes the infrastructure role, the launch template configuration, and tag propagation settings.
         :param name: The name of the capacity provider. If a name is specified, it cannot start with ``aws`` , ``ecs`` , or ``fargate`` . If no name is specified, a default name in the ``CFNStackName-CFNResourceName-RandomString`` format is used.
         :param tags: The metadata that you apply to the capacity provider to help you categorize and organize it. Each tag consists of a key and an optional value. You define both. The following basic restrictions apply to tags: - Maximum number of tags per resource - 50 - For each resource, each tag key must be unique, and each tag key can have only one value. - Maximum key length - 128 Unicode characters in UTF-8 - Maximum value length - 256 Unicode characters in UTF-8 - If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : /
 
@@ -6799,6 +6910,87 @@ class CfnCapacityProviderProps:
                     ),
                     managed_termination_protection="managedTerminationProtection"
                 ),
+                cluster_name="clusterName",
+                managed_instances_provider=ecs.CfnCapacityProvider.ManagedInstancesProviderProperty(
+                    infrastructure_role_arn="infrastructureRoleArn",
+                    instance_launch_template=ecs.CfnCapacityProvider.InstanceLaunchTemplateProperty(
+                        ec2_instance_profile_arn="ec2InstanceProfileArn",
+                        network_configuration=ecs.CfnCapacityProvider.ManagedInstancesNetworkConfigurationProperty(
+                            subnets=["subnets"],
+            
+                            # the properties below are optional
+                            security_groups=["securityGroups"]
+                        ),
+            
+                        # the properties below are optional
+                        instance_requirements=ecs.CfnCapacityProvider.InstanceRequirementsRequestProperty(
+                            memory_mi_b=ecs.CfnCapacityProvider.MemoryMiBRequestProperty(
+                                min=123,
+            
+                                # the properties below are optional
+                                max=123
+                            ),
+                            v_cpu_count=ecs.CfnCapacityProvider.VCpuCountRangeRequestProperty(
+                                min=123,
+            
+                                # the properties below are optional
+                                max=123
+                            ),
+            
+                            # the properties below are optional
+                            accelerator_count=ecs.CfnCapacityProvider.AcceleratorCountRequestProperty(
+                                max=123,
+                                min=123
+                            ),
+                            accelerator_manufacturers=["acceleratorManufacturers"],
+                            accelerator_names=["acceleratorNames"],
+                            accelerator_total_memory_mi_b=ecs.CfnCapacityProvider.AcceleratorTotalMemoryMiBRequestProperty(
+                                max=123,
+                                min=123
+                            ),
+                            accelerator_types=["acceleratorTypes"],
+                            allowed_instance_types=["allowedInstanceTypes"],
+                            bare_metal="bareMetal",
+                            baseline_ebs_bandwidth_mbps=ecs.CfnCapacityProvider.BaselineEbsBandwidthMbpsRequestProperty(
+                                max=123,
+                                min=123
+                            ),
+                            burstable_performance="burstablePerformance",
+                            cpu_manufacturers=["cpuManufacturers"],
+                            excluded_instance_types=["excludedInstanceTypes"],
+                            instance_generations=["instanceGenerations"],
+                            local_storage="localStorage",
+                            local_storage_types=["localStorageTypes"],
+                            max_spot_price_as_percentage_of_optimal_on_demand_price=123,
+                            memory_gi_bPer_vCpu=ecs.CfnCapacityProvider.MemoryGiBPerVCpuRequestProperty(
+                                max=123,
+                                min=123
+                            ),
+                            network_bandwidth_gbps=ecs.CfnCapacityProvider.NetworkBandwidthGbpsRequestProperty(
+                                max=123,
+                                min=123
+                            ),
+                            network_interface_count=ecs.CfnCapacityProvider.NetworkInterfaceCountRequestProperty(
+                                max=123,
+                                min=123
+                            ),
+                            on_demand_max_price_percentage_over_lowest_price=123,
+                            require_hibernate_support=False,
+                            spot_max_price_percentage_over_lowest_price=123,
+                            total_local_storage_gb=ecs.CfnCapacityProvider.TotalLocalStorageGBRequestProperty(
+                                max=123,
+                                min=123
+                            )
+                        ),
+                        monitoring="monitoring",
+                        storage_configuration=ecs.CfnCapacityProvider.ManagedInstancesStorageConfigurationProperty(
+                            storage_size_gi_b=123
+                        )
+                    ),
+            
+                    # the properties below are optional
+                    propagate_tags="propagateTags"
+                ),
                 name="name",
                 tags=[CfnTag(
                     key="key",
@@ -6809,11 +7001,17 @@ class CfnCapacityProviderProps:
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__48080bdf05dc1c4ca9ab46c833774163f6afcd0d1551b378b8d59e67bc180c3f)
             check_type(argname="argument auto_scaling_group_provider", value=auto_scaling_group_provider, expected_type=type_hints["auto_scaling_group_provider"])
+            check_type(argname="argument cluster_name", value=cluster_name, expected_type=type_hints["cluster_name"])
+            check_type(argname="argument managed_instances_provider", value=managed_instances_provider, expected_type=type_hints["managed_instances_provider"])
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
         if auto_scaling_group_provider is not None:
             self._values["auto_scaling_group_provider"] = auto_scaling_group_provider
+        if cluster_name is not None:
+            self._values["cluster_name"] = cluster_name
+        if managed_instances_provider is not None:
+            self._values["managed_instances_provider"] = managed_instances_provider
         if name is not None:
             self._values["name"] = name
         if tags is not None:
@@ -6830,6 +7028,27 @@ class CfnCapacityProviderProps:
         result = self._values.get("auto_scaling_group_provider")
         return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.AutoScalingGroupProviderProperty"]], result)
 
+    @builtins.property
+    def cluster_name(self) -> typing.Optional[builtins.str]:
+        '''
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-capacityprovider.html#cfn-ecs-capacityprovider-clustername
+        '''
+        result = self._values.get("cluster_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def managed_instances_provider(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.ManagedInstancesProviderProperty"]]:
+        '''The configuration for the Amazon ECS Managed Instances provider.
+
+        This includes the infrastructure role, the launch template configuration, and tag propagation settings.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-capacityprovider.html#cfn-ecs-capacityprovider-managedinstancesprovider
+        '''
+        result = self._values.get("managed_instances_provider")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.ManagedInstancesProviderProperty"]], result)
+
     @builtins.property
     def name(self) -> typing.Optional[builtins.str]:
         '''The name of the capacity provider.
@@ -7370,7 +7589,7 @@ class CfnServiceProps:
         :param enable_ecs_managed_tags: Specifies whether to turn on 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>`_ in the *Amazon Elastic Container Service Developer Guide* . When you use Amazon ECS managed tags, you must set the ``propagateTags`` request parameter.
         :param enable_execute_command: Determines whether the execute command functionality is turned on for the service. If ``true`` , the execute command functionality is turned on for all containers in tasks as part of the service.
         :param force_new_deployment: Determines whether to force a new deployment of the service. By default, deployments aren't forced. You can use this option to start a new deployment with no service definition changes. For example, you can update a service's tasks to use a newer Docker image with the same image/tag combination ( ``my_image:latest`` ) or to roll Fargate tasks onto a newer platform version.
-        :param health_check_grace_period_seconds: The period of time, in seconds, that the Amazon Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing, VPC Lattice, and container health checks after a task has first started. If you do not specify a health check grace period value, the default value of 0 is used. If you do not use any of the health checks, then ``healthCheckGracePeriodSeconds`` is unused. If your service has more running tasks than desired, unhealthy tasks in the grace period might be stopped to reach the desired count.
+        :param health_check_grace_period_seconds: The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing, VPC Lattice, and container health checks after a task has first started. If you do not specify a health check grace period value, the default value of 0 is used. If you do not use any of the health checks, then ``healthCheckGracePeriodSeconds`` is unused. If your service has more running tasks than desired, unhealthy tasks in the grace period might be stopped to reach the desired count.
         :param launch_type: The launch type on which to run your service. For more information, see `Amazon ECS Launch Types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
         :param load_balancers: A list of load balancer objects to associate with the service. If you specify the ``Role`` property, ``LoadBalancers`` must be specified as well. For information about the number of load balancers that you can specify per service, see `Service Load Balancing <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html>`_ in the *Amazon Elastic Container Service Developer Guide* . .. epigraph:: To remove this property from your service resource, specify an empty ``LoadBalancer`` array.
         :param network_configuration: The network configuration for the service. This parameter is required for task definitions that use the ``awsvpc`` network mode to receive their own elastic network interface, and it is not supported for other network modes. For more information, see `Task Networking <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
@@ -7788,7 +8007,7 @@ class CfnServiceProps:
 
     @builtins.property
     def health_check_grace_period_seconds(self) -> typing.Optional[jsii.Number]:
-        '''The period of time, in seconds, that the Amazon Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing, VPC Lattice, and container health checks after a task has first started.
+        '''The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing, VPC Lattice, and container health checks after a task has first started.
 
         If you do not specify a health check grace period value, the default value of 0 is used. If you do not use any of the health checks, then ``healthCheckGracePeriodSeconds`` is unused.
 
@@ -8116,7 +8335,7 @@ class CfnTaskDefinitionProps:
         :param pid_mode: The process namespace to use for the containers in the task. The valid values are ``host`` or ``task`` . On Fargate for Linux containers, the only valid value is ``task`` . For example, monitoring sidecars might need ``pidMode`` to access information about other containers running in the same task. If ``host`` is specified, all containers within the tasks that specified the ``host`` PID mode on the same container instance share the same process namespace with the host Amazon EC2 instance. If ``task`` is specified, all containers within the specified task share the same process namespace. If no value is specified, the default is a private namespace for each container. If the ``host`` PID mode is used, there's a heightened risk of undesired process namespace exposure. .. epigraph:: This parameter is not supported for Windows containers. > This parameter is only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version ``1.4.0`` or later (Linux). This isn't supported for Windows containers on Fargate.
         :param placement_constraints: An array of placement constraint objects to use for tasks. .. epigraph:: This parameter isn't supported for tasks run on AWS Fargate .
         :param proxy_configuration: The configuration details for the App Mesh proxy. Your Amazon ECS container instances require at least version 1.26.0 of the container agent and at least version 1.26.0-1 of the ``ecs-init`` package to use a proxy configuration. If your container instances are launched from the Amazon ECS optimized AMI version ``20190301`` or later, they contain the required versions of the container agent and ``ecs-init`` . For more information, see `Amazon ECS-optimized Linux AMI <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
-        :param requires_compatibilities: The task launch types the task definition was validated against. The valid values are ``EC2`` , ``FARGATE`` , and ``EXTERNAL`` . For more information, see `Amazon ECS launch types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
+        :param requires_compatibilities: The task launch types the task definition was validated against. The valid values are ``MANAGED_INSTANCES`` , ``EC2`` , ``FARGATE`` , and ``EXTERNAL`` . For more information, see `Amazon ECS launch types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
         :param runtime_platform: The operating system that your tasks definitions run on. A platform family is specified only for tasks using the Fargate launch type.
         :param tags: The metadata that you apply to the task definition to help you categorize and organize them. Each tag consists of a key and an optional value. You define both of them. The following basic restrictions apply to tags: - Maximum number of tags per resource - 50 - For each resource, each tag key must be unique, and each tag key can have only one value. - Maximum key length - 128 Unicode characters in UTF-8 - Maximum value length - 256 Unicode characters in UTF-8 - If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : /
         :param task_role_arn: The short name or full Amazon Resource Name (ARN) of the AWS Identity and Access Management role that grants containers in the task permission to call AWS APIs on your behalf. For more information, see `Amazon ECS Task Role <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html>`_ in the *Amazon Elastic Container Service Developer Guide* . IAM roles for tasks on Windows require that the ``-EnableTaskIAMRole`` option is set when you launch the Amazon ECS-optimized Windows AMI. Your containers must also run some configuration code to use the feature. For more information, see `Windows IAM roles for tasks <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows_task_IAM_roles.html>`_ in the *Amazon Elastic Container Service Developer Guide* . .. epigraph:: String validation is done on the ECS side. If an invalid string value is given for ``TaskRoleArn`` , it may cause the Cloudformation job to hang.
@@ -8625,7 +8844,7 @@ class CfnTaskDefinitionProps:
     def requires_compatibilities(self) -> typing.Optional[typing.List[builtins.str]]:
         '''The task launch types the task definition was validated against.
 
-        The valid values are ``EC2`` , ``FARGATE`` , and ``EXTERNAL`` . For more information, see `Amazon ECS launch types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
+        The valid values are ``MANAGED_INSTANCES`` , ``EC2`` , ``FARGATE`` , and ``EXTERNAL`` . For more information, see `Amazon ECS launch types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-taskdefinition.html#cfn-ecs-taskdefinition-requirescompatibilities
         '''
@@ -10174,6 +10393,14 @@ class Compatibility(enum.Enum):
     '''The task can specify either the EC2 or Fargate launch types.'''
     EXTERNAL = "EXTERNAL"
     '''The task should specify the External launch type.'''
+    MANAGED_INSTANCES = "MANAGED_INSTANCES"
+    '''The task should specify the Managed Instances launch type.'''
+    EC2_AND_MANAGED_INSTANCES = "EC2_AND_MANAGED_INSTANCES"
+    '''The task can specify either the EC2 or Managed Instances launch types.'''
+    FARGATE_AND_MANAGED_INSTANCES = "FARGATE_AND_MANAGED_INSTANCES"
+    '''The task can specify either the Fargate or Managed Instances launch types.'''
+    FARGATE_AND_EC2_AND_MANAGED_INSTANCES = "FARGATE_AND_EC2_AND_MANAGED_INSTANCES"
+    '''The task can specify either the Fargate, EC2 or Managed Instances launch types.'''
 
 
 class ContainerDefinition(
@@ -12357,32 +12584,24 @@ class ContainerImage(
 
     Example::
 
-        # vpc: ec2.Vpc
-        
-        
-        cluster = ecs.Cluster(self, "FargateCPCluster",
-            vpc=vpc,
-            enable_fargate_capacity_providers=True
-        )
-        
-        task_definition = ecs.FargateTaskDefinition(self, "TaskDef")
-        
-        task_definition.add_container("web",
-            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")
-        )
-        
-        ecs.FargateService(self, "FargateService",
-            cluster=cluster,
-            task_definition=task_definition,
-            min_healthy_percent=100,
-            capacity_provider_strategies=[ecs.CapacityProviderStrategy(
-                capacity_provider="FARGATE_SPOT",
-                weight=2
-            ), ecs.CapacityProviderStrategy(
-                capacity_provider="FARGATE",
-                weight=1
+        # my_file_system: efs.IFileSystem
+        # my_job_role: iam.Role
+        
+        my_file_system.grant_read(my_job_role)
+        
+        job_defn = batch.EcsJobDefinition(self, "JobDefn",
+            container=batch.EcsEc2ContainerDefinition(self, "containerDefn",
+                image=ecs.ContainerImage.from_registry("public.ecr.aws/amazonlinux/amazonlinux:latest"),
+                memory=cdk.Size.mebibytes(2048),
+                cpu=256,
+                volumes=[batch.EcsVolume.efs(
+                    name="myVolume",
+                    file_system=my_file_system,
+                    container_path="/Volumes/myVolume",
+                    use_job_role=True
+                )],
+                job_role=my_job_role
             )
-            ]
         )
     '''
 
@@ -14348,30 +14567,33 @@ class Ec2ServiceProps(BaseServiceOptions):
 
         Example::
 
-            # vpc: ec2.Vpc
-            
+            # task_definition: ecs.TaskDefinition
+            # cluster: ecs.Cluster
             
-            # Create an ECS cluster
-            cluster = ecs.Cluster(self, "Cluster", vpc=vpc)
             
-            # Add capacity to it
-            cluster.add_capacity("DefaultAutoScalingGroupCapacity",
-                instance_type=ec2.InstanceType("t2.xlarge"),
-                desired_capacity=3
+            # 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
             )
             
-            task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
-            
-            task_definition.add_container("DefaultContainer",
-                image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
-                memory_limit_mi_b=512
+            # Add a port mapping
+            specific_container.add_port_mappings(
+                container_port=7600,
+                protocol=ecs.Protocol.TCP
             )
             
-            # Instantiate an Amazon ECS Service
-            ecs_service = ecs.Ec2Service(self, "Service",
+            ecs.Ec2Service(self, "Service",
                 cluster=cluster,
                 task_definition=task_definition,
-                min_healthy_percent=100
+                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
+                )
             )
         '''
         if isinstance(circuit_breaker, dict):
@@ -21722,6 +21944,12 @@ class ITaskDefinition(_IResource_c80c4260, typing_extensions.Protocol):
         '''Return true if the task definition can be run on a Fargate cluster.'''
         ...
 
+    @builtins.property
+    @jsii.member(jsii_name="isManagedInstancesCompatible")
+    def is_managed_instances_compatible(self) -> builtins.bool:
+        '''Return true if the task definition can be run on Managed Instances.'''
+        ...
+
     @builtins.property
     @jsii.member(jsii_name="networkMode")
     def network_mode(self) -> "NetworkMode":
@@ -21781,6 +22009,12 @@ class _ITaskDefinitionProxy(
         '''Return true if the task definition can be run on a Fargate cluster.'''
         return typing.cast(builtins.bool, jsii.get(self, "isFargateCompatible"))
 
+    @builtins.property
+    @jsii.member(jsii_name="isManagedInstancesCompatible")
+    def is_managed_instances_compatible(self) -> builtins.bool:
+        '''Return true if the task definition can be run on Managed Instances.'''
+        return typing.cast(builtins.bool, jsii.get(self, "isManagedInstancesCompatible"))
+
     @builtins.property
     @jsii.member(jsii_name="networkMode")
     def network_mode(self) -> "NetworkMode":
@@ -22013,6 +22247,16 @@ class InferenceAccelerator:
         )
 
 
+@jsii.enum(jsii_type="aws-cdk-lib.aws_ecs.InstanceMonitoring")
+class InstanceMonitoring(enum.Enum):
+    '''The monitoring configuration for EC2 instances.'''
+
+    BASIC = "BASIC"
+    '''Basic monitoring (5-minute intervals).'''
+    DETAILED = "DETAILED"
+    '''Detailed monitoring (1-minute intervals).'''
+
+
 @jsii.enum(jsii_type="aws-cdk-lib.aws_ecs.IpcMode")
 class IpcMode(enum.Enum):
     '''The IPC resource namespace to use for the containers in the task.'''
@@ -23565,6 +23809,383 @@ class MachineImageType(enum.Enum):
     '''Bottlerocket AMI.'''
 
 
+class ManagedInstancesCapacityProvider(
+    _constructs_77d1e7e8.Construct,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_ecs.ManagedInstancesCapacityProvider",
+):
+    '''A Managed Instances Capacity Provider.
+
+    This allows an ECS cluster to use
+    Managed Instances for task placement with managed infrastructure.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # vpc: ec2.Vpc
+        # infrastructure_role: iam.Role
+        # instance_profile: iam.InstanceProfile
+        
+        
+        cluster = ecs.Cluster(self, "Cluster", vpc=vpc)
+        
+        # Create a Managed Instances Capacity Provider
+        mi_capacity_provider = ecs.ManagedInstancesCapacityProvider(self, "MICapacityProvider",
+            infrastructure_role=infrastructure_role,
+            ec2_instance_profile=instance_profile,
+            subnets=vpc.private_subnets,
+            security_groups=[ec2.SecurityGroup(self, "MISecurityGroup", vpc=vpc)],
+            instance_requirements=ec2.InstanceRequirementsConfig(
+                v_cpu_count_min=1,
+                memory_min=Size.gibibytes(2),
+                cpu_manufacturers=[ec2.CpuManufacturer.INTEL],
+                accelerator_manufacturers=[ec2.AcceleratorManufacturer.NVIDIA]
+            ),
+            propagate_tags=ecs.PropagateManagedInstancesTags.CAPACITY_PROVIDER
+        )
+        
+        # Add the capacity provider to the cluster
+        cluster.add_managed_instances_capacity_provider(mi_capacity_provider)
+        
+        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
+        
+        task_definition.add_container("web",
+            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
+            memory_reservation_mi_b=256
+        )
+        
+        ecs.Ec2Service(self, "EC2Service",
+            cluster=cluster,
+            task_definition=task_definition,
+            min_healthy_percent=100,
+            capacity_provider_strategies=[ecs.CapacityProviderStrategy(
+                capacity_provider=mi_capacity_provider.capacity_provider_name,
+                weight=1
+            )
+            ]
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        ec2_instance_profile: _IInstanceProfile_10d5ce2c,
+        subnets: typing.Sequence[_ISubnet_d57d1229],
+        capacity_provider_name: typing.Optional[builtins.str] = None,
+        infrastructure_role: typing.Optional[_IRole_235f5d8e] = None,
+        instance_requirements: typing.Optional[typing.Union[_InstanceRequirementsConfig_1b353659, typing.Dict[builtins.str, typing.Any]]] = None,
+        monitoring: typing.Optional[InstanceMonitoring] = None,
+        propagate_tags: typing.Optional["PropagateManagedInstancesTags"] = None,
+        security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
+        task_volume_storage: typing.Optional[_Size_7b441c34] = None,
+    ) -> None:
+        '''
+        :param scope: -
+        :param id: -
+        :param ec2_instance_profile: The EC2 instance profile that will be attached to instances launched by this capacity provider. This instance profile must contain the necessary IAM permissions for ECS container instances to register with the cluster and run tasks. At minimum, it should include permissions for ECS agent communication, ECR image pulling, and CloudWatch logging.
+        :param subnets: The VPC subnets where EC2 instances will be launched. This array must be non-empty and should contain subnets from the VPC where you want the managed instances to be deployed.
+        :param capacity_provider_name: The name of the capacity provider. If a name is specified, it cannot start with ``aws``, ``ecs``, or ``fargate``. If no name is specified, a default name in the CFNStackName-CFNResourceName-RandomString format is used. If the stack name starts with ``aws``, ``ecs``, or ``fargate``, a unique resource name is generated that starts with ``cp-``. Default: CloudFormation-generated name
+        :param infrastructure_role: The IAM role that ECS uses to manage the infrastructure for the capacity provider. This role is used by ECS to perform actions such as launching and terminating instances, managing Auto Scaling Groups, and other infrastructure operations required for the managed instances capacity provider. Default: - A new role will be created with the AmazonECSInfrastructureRolePolicyForManagedInstances managed policy
+        :param instance_requirements: The instance requirements configuration for EC2 instance selection. This allows you to specify detailed requirements for instance selection including vCPU count ranges, memory ranges, CPU manufacturers (Intel, AMD, AWS Graviton), instance generations, network performance requirements, and many other criteria. ECS will automatically select appropriate instance types that meet these requirements. Default: - no specific instance requirements, ECS will choose appropriate instances
+        :param monitoring: The CloudWatch monitoring configuration for the EC2 instances. Determines the granularity of CloudWatch metrics collection for the instances. Detailed monitoring incurs additional costs but provides better observability. Default: - no enhanced monitoring (basic monitoring only)
+        :param propagate_tags: Specifies whether to propagate tags from the capacity provider to the launched instances. When set to CAPACITY_PROVIDER, tags applied to the capacity provider resource will be automatically applied to all EC2 instances launched by this capacity provider. Default: PropagateManagedInstancesTags.NONE - no tag propagation
+        :param security_groups: The security groups to associate with the launched EC2 instances. These security groups control the network traffic allowed to and from the instances. If not specified, the default security group of the VPC containing the subnets will be used. Default: - default security group of the VPC
+        :param task_volume_storage: The size of the task volume storage attached to each instance. This storage is used for container images, container logs, and temporary files. Larger storage may be needed for workloads with large container images or applications that generate significant temporary data. Default: Size.gibibytes(80)
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__718bb820f1409b5f15556f2e394659a060bda46e302dbb4e973a6484f24497de)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = ManagedInstancesCapacityProviderProps(
+            ec2_instance_profile=ec2_instance_profile,
+            subnets=subnets,
+            capacity_provider_name=capacity_provider_name,
+            infrastructure_role=infrastructure_role,
+            instance_requirements=instance_requirements,
+            monitoring=monitoring,
+            propagate_tags=propagate_tags,
+            security_groups=security_groups,
+            task_volume_storage=task_volume_storage,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="bind")
+    def bind(self, cluster: ICluster) -> None:
+        '''Associates the capacity provider with the specified cluster.
+
+        This method is called by the cluster when adding the capacity provider.
+
+        :param cluster: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__86f1df235e6255faeece6081f964f386186a84532c53bb8fad57fd4ab50e809d)
+            check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
+        return typing.cast(None, jsii.invoke(self, "bind", [cluster]))
+
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="PROPERTY_INJECTION_ID")
+    def PROPERTY_INJECTION_ID(cls) -> builtins.str:
+        '''Uniquely identifies this class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "PROPERTY_INJECTION_ID"))
+
+    @builtins.property
+    @jsii.member(jsii_name="capacityProviderName")
+    def capacity_provider_name(self) -> builtins.str:
+        '''Capacity provider name.'''
+        return typing.cast(builtins.str, jsii.get(self, "capacityProviderName"))
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_ecs.ManagedInstancesCapacityProviderProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "ec2_instance_profile": "ec2InstanceProfile",
+        "subnets": "subnets",
+        "capacity_provider_name": "capacityProviderName",
+        "infrastructure_role": "infrastructureRole",
+        "instance_requirements": "instanceRequirements",
+        "monitoring": "monitoring",
+        "propagate_tags": "propagateTags",
+        "security_groups": "securityGroups",
+        "task_volume_storage": "taskVolumeStorage",
+    },
+)
+class ManagedInstancesCapacityProviderProps:
+    def __init__(
+        self,
+        *,
+        ec2_instance_profile: _IInstanceProfile_10d5ce2c,
+        subnets: typing.Sequence[_ISubnet_d57d1229],
+        capacity_provider_name: typing.Optional[builtins.str] = None,
+        infrastructure_role: typing.Optional[_IRole_235f5d8e] = None,
+        instance_requirements: typing.Optional[typing.Union[_InstanceRequirementsConfig_1b353659, typing.Dict[builtins.str, typing.Any]]] = None,
+        monitoring: typing.Optional[InstanceMonitoring] = None,
+        propagate_tags: typing.Optional["PropagateManagedInstancesTags"] = None,
+        security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
+        task_volume_storage: typing.Optional[_Size_7b441c34] = None,
+    ) -> None:
+        '''The options for creating a Managed Instances Capacity Provider.
+
+        :param ec2_instance_profile: The EC2 instance profile that will be attached to instances launched by this capacity provider. This instance profile must contain the necessary IAM permissions for ECS container instances to register with the cluster and run tasks. At minimum, it should include permissions for ECS agent communication, ECR image pulling, and CloudWatch logging.
+        :param subnets: The VPC subnets where EC2 instances will be launched. This array must be non-empty and should contain subnets from the VPC where you want the managed instances to be deployed.
+        :param capacity_provider_name: The name of the capacity provider. If a name is specified, it cannot start with ``aws``, ``ecs``, or ``fargate``. If no name is specified, a default name in the CFNStackName-CFNResourceName-RandomString format is used. If the stack name starts with ``aws``, ``ecs``, or ``fargate``, a unique resource name is generated that starts with ``cp-``. Default: CloudFormation-generated name
+        :param infrastructure_role: The IAM role that ECS uses to manage the infrastructure for the capacity provider. This role is used by ECS to perform actions such as launching and terminating instances, managing Auto Scaling Groups, and other infrastructure operations required for the managed instances capacity provider. Default: - A new role will be created with the AmazonECSInfrastructureRolePolicyForManagedInstances managed policy
+        :param instance_requirements: The instance requirements configuration for EC2 instance selection. This allows you to specify detailed requirements for instance selection including vCPU count ranges, memory ranges, CPU manufacturers (Intel, AMD, AWS Graviton), instance generations, network performance requirements, and many other criteria. ECS will automatically select appropriate instance types that meet these requirements. Default: - no specific instance requirements, ECS will choose appropriate instances
+        :param monitoring: The CloudWatch monitoring configuration for the EC2 instances. Determines the granularity of CloudWatch metrics collection for the instances. Detailed monitoring incurs additional costs but provides better observability. Default: - no enhanced monitoring (basic monitoring only)
+        :param propagate_tags: Specifies whether to propagate tags from the capacity provider to the launched instances. When set to CAPACITY_PROVIDER, tags applied to the capacity provider resource will be automatically applied to all EC2 instances launched by this capacity provider. Default: PropagateManagedInstancesTags.NONE - no tag propagation
+        :param security_groups: The security groups to associate with the launched EC2 instances. These security groups control the network traffic allowed to and from the instances. If not specified, the default security group of the VPC containing the subnets will be used. Default: - default security group of the VPC
+        :param task_volume_storage: The size of the task volume storage attached to each instance. This storage is used for container images, container logs, and temporary files. Larger storage may be needed for workloads with large container images or applications that generate significant temporary data. Default: Size.gibibytes(80)
+
+        :exampleMetadata: infused
+
+        Example::
+
+            # vpc: ec2.Vpc
+            # infrastructure_role: iam.Role
+            # instance_profile: iam.InstanceProfile
+            
+            
+            cluster = ecs.Cluster(self, "Cluster", vpc=vpc)
+            
+            # Create a Managed Instances Capacity Provider
+            mi_capacity_provider = ecs.ManagedInstancesCapacityProvider(self, "MICapacityProvider",
+                infrastructure_role=infrastructure_role,
+                ec2_instance_profile=instance_profile,
+                subnets=vpc.private_subnets,
+                security_groups=[ec2.SecurityGroup(self, "MISecurityGroup", vpc=vpc)],
+                instance_requirements=ec2.InstanceRequirementsConfig(
+                    v_cpu_count_min=1,
+                    memory_min=Size.gibibytes(2),
+                    cpu_manufacturers=[ec2.CpuManufacturer.INTEL],
+                    accelerator_manufacturers=[ec2.AcceleratorManufacturer.NVIDIA]
+                ),
+                propagate_tags=ecs.PropagateManagedInstancesTags.CAPACITY_PROVIDER
+            )
+            
+            # Add the capacity provider to the cluster
+            cluster.add_managed_instances_capacity_provider(mi_capacity_provider)
+            
+            task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
+            
+            task_definition.add_container("web",
+                image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
+                memory_reservation_mi_b=256
+            )
+            
+            ecs.Ec2Service(self, "EC2Service",
+                cluster=cluster,
+                task_definition=task_definition,
+                min_healthy_percent=100,
+                capacity_provider_strategies=[ecs.CapacityProviderStrategy(
+                    capacity_provider=mi_capacity_provider.capacity_provider_name,
+                    weight=1
+                )
+                ]
+            )
+        '''
+        if isinstance(instance_requirements, dict):
+            instance_requirements = _InstanceRequirementsConfig_1b353659(**instance_requirements)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__efa15b9a00384128ebdb40ffd56f7e66e8863f1c3a6b8d4cf8bc61fb9e822e92)
+            check_type(argname="argument ec2_instance_profile", value=ec2_instance_profile, expected_type=type_hints["ec2_instance_profile"])
+            check_type(argname="argument subnets", value=subnets, expected_type=type_hints["subnets"])
+            check_type(argname="argument capacity_provider_name", value=capacity_provider_name, expected_type=type_hints["capacity_provider_name"])
+            check_type(argname="argument infrastructure_role", value=infrastructure_role, expected_type=type_hints["infrastructure_role"])
+            check_type(argname="argument instance_requirements", value=instance_requirements, expected_type=type_hints["instance_requirements"])
+            check_type(argname="argument monitoring", value=monitoring, expected_type=type_hints["monitoring"])
+            check_type(argname="argument propagate_tags", value=propagate_tags, expected_type=type_hints["propagate_tags"])
+            check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
+            check_type(argname="argument task_volume_storage", value=task_volume_storage, expected_type=type_hints["task_volume_storage"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "ec2_instance_profile": ec2_instance_profile,
+            "subnets": subnets,
+        }
+        if capacity_provider_name is not None:
+            self._values["capacity_provider_name"] = capacity_provider_name
+        if infrastructure_role is not None:
+            self._values["infrastructure_role"] = infrastructure_role
+        if instance_requirements is not None:
+            self._values["instance_requirements"] = instance_requirements
+        if monitoring is not None:
+            self._values["monitoring"] = monitoring
+        if propagate_tags is not None:
+            self._values["propagate_tags"] = propagate_tags
+        if security_groups is not None:
+            self._values["security_groups"] = security_groups
+        if task_volume_storage is not None:
+            self._values["task_volume_storage"] = task_volume_storage
+
+    @builtins.property
+    def ec2_instance_profile(self) -> _IInstanceProfile_10d5ce2c:
+        '''The EC2 instance profile that will be attached to instances launched by this capacity provider.
+
+        This instance profile must contain the necessary IAM permissions for ECS container instances
+        to register with the cluster and run tasks. At minimum, it should include permissions for
+        ECS agent communication, ECR image pulling, and CloudWatch logging.
+        '''
+        result = self._values.get("ec2_instance_profile")
+        assert result is not None, "Required property 'ec2_instance_profile' is missing"
+        return typing.cast(_IInstanceProfile_10d5ce2c, result)
+
+    @builtins.property
+    def subnets(self) -> typing.List[_ISubnet_d57d1229]:
+        '''The VPC subnets where EC2 instances will be launched.
+
+        This array must be non-empty and should contain subnets from the VPC where you want
+        the managed instances to be deployed.
+        '''
+        result = self._values.get("subnets")
+        assert result is not None, "Required property 'subnets' is missing"
+        return typing.cast(typing.List[_ISubnet_d57d1229], result)
+
+    @builtins.property
+    def capacity_provider_name(self) -> typing.Optional[builtins.str]:
+        '''The name of the capacity provider.
+
+        If a name is specified, it cannot start with ``aws``, ``ecs``, or ``fargate``.
+        If no name is specified, a default name in the CFNStackName-CFNResourceName-RandomString format is used.
+        If the stack name starts with ``aws``, ``ecs``, or ``fargate``, a unique resource name
+        is generated that starts with ``cp-``.
+
+        :default: CloudFormation-generated name
+        '''
+        result = self._values.get("capacity_provider_name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def infrastructure_role(self) -> typing.Optional[_IRole_235f5d8e]:
+        '''The IAM role that ECS uses to manage the infrastructure for the capacity provider.
+
+        This role is used by ECS to perform actions such as launching and terminating instances,
+        managing Auto Scaling Groups, and other infrastructure operations required for the
+        managed instances capacity provider.
+
+        :default: - A new role will be created with the AmazonECSInfrastructureRolePolicyForManagedInstances managed policy
+        '''
+        result = self._values.get("infrastructure_role")
+        return typing.cast(typing.Optional[_IRole_235f5d8e], result)
+
+    @builtins.property
+    def instance_requirements(
+        self,
+    ) -> typing.Optional[_InstanceRequirementsConfig_1b353659]:
+        '''The instance requirements configuration for EC2 instance selection.
+
+        This allows you to specify detailed requirements for instance selection including
+        vCPU count ranges, memory ranges, CPU manufacturers (Intel, AMD, AWS Graviton),
+        instance generations, network performance requirements, and many other criteria.
+        ECS will automatically select appropriate instance types that meet these requirements.
+
+        :default: - no specific instance requirements, ECS will choose appropriate instances
+        '''
+        result = self._values.get("instance_requirements")
+        return typing.cast(typing.Optional[_InstanceRequirementsConfig_1b353659], result)
+
+    @builtins.property
+    def monitoring(self) -> typing.Optional[InstanceMonitoring]:
+        '''The CloudWatch monitoring configuration for the EC2 instances.
+
+        Determines the granularity of CloudWatch metrics collection for the instances.
+        Detailed monitoring incurs additional costs but provides better observability.
+
+        :default: - no enhanced monitoring (basic monitoring only)
+        '''
+        result = self._values.get("monitoring")
+        return typing.cast(typing.Optional[InstanceMonitoring], result)
+
+    @builtins.property
+    def propagate_tags(self) -> typing.Optional["PropagateManagedInstancesTags"]:
+        '''Specifies whether to propagate tags from the capacity provider to the launched instances.
+
+        When set to CAPACITY_PROVIDER, tags applied to the capacity provider resource will be
+        automatically applied to all EC2 instances launched by this capacity provider.
+
+        :default: PropagateManagedInstancesTags.NONE - no tag propagation
+        '''
+        result = self._values.get("propagate_tags")
+        return typing.cast(typing.Optional["PropagateManagedInstancesTags"], result)
+
+    @builtins.property
+    def security_groups(self) -> typing.Optional[typing.List[_ISecurityGroup_acf8a799]]:
+        '''The security groups to associate with the launched EC2 instances.
+
+        These security groups control the network traffic allowed to and from the instances.
+        If not specified, the default security group of the VPC containing the subnets will be used.
+
+        :default: - default security group of the VPC
+        '''
+        result = self._values.get("security_groups")
+        return typing.cast(typing.Optional[typing.List[_ISecurityGroup_acf8a799]], result)
+
+    @builtins.property
+    def task_volume_storage(self) -> typing.Optional[_Size_7b441c34]:
+        '''The size of the task volume storage attached to each instance.
+
+        This storage is used for container images, container logs, and temporary files.
+        Larger storage may be needed for workloads with large container images or
+        applications that generate significant temporary data.
+
+        :default: Size.gibibytes(80)
+        '''
+        result = self._values.get("task_volume_storage")
+        return typing.cast(typing.Optional[_Size_7b441c34], 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 "ManagedInstancesCapacityProviderProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_ecs.ManagedStorageConfiguration",
     jsii_struct_bases=[],
@@ -24560,6 +25181,64 @@ class PrimaryTaskSetReference:
         )
 
 
+@jsii.enum(jsii_type="aws-cdk-lib.aws_ecs.PropagateManagedInstancesTags")
+class PropagateManagedInstancesTags(enum.Enum):
+    '''Propagate tags for Managed Instances.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        # vpc: ec2.Vpc
+        # infrastructure_role: iam.Role
+        # instance_profile: iam.InstanceProfile
+        
+        
+        cluster = ecs.Cluster(self, "Cluster", vpc=vpc)
+        
+        # Create a Managed Instances Capacity Provider
+        mi_capacity_provider = ecs.ManagedInstancesCapacityProvider(self, "MICapacityProvider",
+            infrastructure_role=infrastructure_role,
+            ec2_instance_profile=instance_profile,
+            subnets=vpc.private_subnets,
+            security_groups=[ec2.SecurityGroup(self, "MISecurityGroup", vpc=vpc)],
+            instance_requirements=ec2.InstanceRequirementsConfig(
+                v_cpu_count_min=1,
+                memory_min=Size.gibibytes(2),
+                cpu_manufacturers=[ec2.CpuManufacturer.INTEL],
+                accelerator_manufacturers=[ec2.AcceleratorManufacturer.NVIDIA]
+            ),
+            propagate_tags=ecs.PropagateManagedInstancesTags.CAPACITY_PROVIDER
+        )
+        
+        # Add the capacity provider to the cluster
+        cluster.add_managed_instances_capacity_provider(mi_capacity_provider)
+        
+        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
+        
+        task_definition.add_container("web",
+            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
+            memory_reservation_mi_b=256
+        )
+        
+        ecs.Ec2Service(self, "EC2Service",
+            cluster=cluster,
+            task_definition=task_definition,
+            min_healthy_percent=100,
+            capacity_provider_strategies=[ecs.CapacityProviderStrategy(
+                capacity_provider=mi_capacity_provider.capacity_provider_name,
+                weight=1
+            )
+            ]
+        )
+    '''
+
+    CAPACITY_PROVIDER = "CAPACITY_PROVIDER"
+    '''Propagate tags from the capacity provider.'''
+    NONE = "NONE"
+    '''Do not propagate tags.'''
+
+
 @jsii.enum(jsii_type="aws-cdk-lib.aws_ecs.PropagatedTagSource")
 class PropagatedTagSource(enum.Enum):
     '''Propagate tags from either service or task definition.
@@ -28048,22 +28727,34 @@ class TaskDefinition(
 
     Example::
 
+        import aws_cdk.aws_cloudwatch as cw
+        
         # cluster: ecs.Cluster
         # task_definition: ecs.TaskDefinition
-        # vpc: ec2.Vpc
+        # elb_alarm: cw.Alarm
         
-        service = ecs.FargateService(self, "Service", cluster=cluster, task_definition=task_definition, min_healthy_percent=100)
         
-        lb = elbv2.ApplicationLoadBalancer(self, "LB", vpc=vpc, internet_facing=True)
-        listener = lb.add_listener("Listener", port=80)
-        service.register_load_balancer_targets(
-            container_name="web",
-            container_port=80,
-            new_target_group_id="ECS",
-            listener=ecs.ListenerConfig.application_listener(listener,
-                protocol=elbv2.ApplicationProtocol.HTTPS
+        service = ecs.FargateService(self, "Service",
+            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
             )
         )
+        
+        # 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(),
+            evaluation_periods=2,
+            threshold=80
+        )
+        service.enable_deployment_alarms([cpu_alarm_name],
+            behavior=ecs.AlarmBehavior.FAIL_ON_ALARM
+        )
     '''
 
     def __init__(
@@ -28669,6 +29360,12 @@ class TaskDefinition(
         '''Return true if the task definition can be run on a Fargate cluster.'''
         return typing.cast(builtins.bool, jsii.get(self, "isFargateCompatible"))
 
+    @builtins.property
+    @jsii.member(jsii_name="isManagedInstancesCompatible")
+    def is_managed_instances_compatible(self) -> builtins.bool:
+        '''Return true if the task definition can be run on Managed Instances.'''
+        return typing.cast(builtins.bool, jsii.get(self, "isManagedInstancesCompatible"))
+
     @builtins.property
     @jsii.member(jsii_name="networkMode")
     def network_mode(self) -> NetworkMode:
@@ -30673,11 +31370,9 @@ class CfnCapacityProvider(
     metaclass=jsii.JSIIMeta,
     jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider",
 ):
-    '''Creates a new capacity provider.
+    '''Creates a capacity provider.
 
-    Capacity providers are associated with an Amazon ECS cluster and are used in capacity provider strategies to facilitate cluster auto scaling.
-
-    Only capacity providers that use an Auto Scaling group can be created. Amazon ECS tasks on AWS Fargate use the ``FARGATE`` and ``FARGATE_SPOT`` capacity providers. These providers are available to all accounts in the AWS Regions that AWS Fargate supports.
+    Capacity providers are associated with a cluster and are used in capacity provider strategies to facilitate cluster auto scaling. You can create capacity providers for Amazon ECS Managed Instances and EC2 instances. AWS Fargate has the predefined ``FARGATE`` and ``FARGATE_SPOT`` capacity providers.
 
     :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-capacityprovider.html
     :cloudformationResource: AWS::ECS::CapacityProvider
@@ -30704,6 +31399,87 @@ class CfnCapacityProvider(
                 ),
                 managed_termination_protection="managedTerminationProtection"
             ),
+            cluster_name="clusterName",
+            managed_instances_provider=ecs.CfnCapacityProvider.ManagedInstancesProviderProperty(
+                infrastructure_role_arn="infrastructureRoleArn",
+                instance_launch_template=ecs.CfnCapacityProvider.InstanceLaunchTemplateProperty(
+                    ec2_instance_profile_arn="ec2InstanceProfileArn",
+                    network_configuration=ecs.CfnCapacityProvider.ManagedInstancesNetworkConfigurationProperty(
+                        subnets=["subnets"],
+        
+                        # the properties below are optional
+                        security_groups=["securityGroups"]
+                    ),
+        
+                    # the properties below are optional
+                    instance_requirements=ecs.CfnCapacityProvider.InstanceRequirementsRequestProperty(
+                        memory_mi_b=ecs.CfnCapacityProvider.MemoryMiBRequestProperty(
+                            min=123,
+        
+                            # the properties below are optional
+                            max=123
+                        ),
+                        v_cpu_count=ecs.CfnCapacityProvider.VCpuCountRangeRequestProperty(
+                            min=123,
+        
+                            # the properties below are optional
+                            max=123
+                        ),
+        
+                        # the properties below are optional
+                        accelerator_count=ecs.CfnCapacityProvider.AcceleratorCountRequestProperty(
+                            max=123,
+                            min=123
+                        ),
+                        accelerator_manufacturers=["acceleratorManufacturers"],
+                        accelerator_names=["acceleratorNames"],
+                        accelerator_total_memory_mi_b=ecs.CfnCapacityProvider.AcceleratorTotalMemoryMiBRequestProperty(
+                            max=123,
+                            min=123
+                        ),
+                        accelerator_types=["acceleratorTypes"],
+                        allowed_instance_types=["allowedInstanceTypes"],
+                        bare_metal="bareMetal",
+                        baseline_ebs_bandwidth_mbps=ecs.CfnCapacityProvider.BaselineEbsBandwidthMbpsRequestProperty(
+                            max=123,
+                            min=123
+                        ),
+                        burstable_performance="burstablePerformance",
+                        cpu_manufacturers=["cpuManufacturers"],
+                        excluded_instance_types=["excludedInstanceTypes"],
+                        instance_generations=["instanceGenerations"],
+                        local_storage="localStorage",
+                        local_storage_types=["localStorageTypes"],
+                        max_spot_price_as_percentage_of_optimal_on_demand_price=123,
+                        memory_gi_bPer_vCpu=ecs.CfnCapacityProvider.MemoryGiBPerVCpuRequestProperty(
+                            max=123,
+                            min=123
+                        ),
+                        network_bandwidth_gbps=ecs.CfnCapacityProvider.NetworkBandwidthGbpsRequestProperty(
+                            max=123,
+                            min=123
+                        ),
+                        network_interface_count=ecs.CfnCapacityProvider.NetworkInterfaceCountRequestProperty(
+                            max=123,
+                            min=123
+                        ),
+                        on_demand_max_price_percentage_over_lowest_price=123,
+                        require_hibernate_support=False,
+                        spot_max_price_percentage_over_lowest_price=123,
+                        total_local_storage_gb=ecs.CfnCapacityProvider.TotalLocalStorageGBRequestProperty(
+                            max=123,
+                            min=123
+                        )
+                    ),
+                    monitoring="monitoring",
+                    storage_configuration=ecs.CfnCapacityProvider.ManagedInstancesStorageConfigurationProperty(
+                        storage_size_gi_b=123
+                    )
+                ),
+        
+                # the properties below are optional
+                propagate_tags="propagateTags"
+            ),
             name="name",
             tags=[CfnTag(
                 key="key",
@@ -30718,6 +31494,8 @@ class CfnCapacityProvider(
         id: builtins.str,
         *,
         auto_scaling_group_provider: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.AutoScalingGroupProviderProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        cluster_name: typing.Optional[builtins.str] = None,
+        managed_instances_provider: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.ManagedInstancesProviderProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         name: typing.Optional[builtins.str] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
@@ -30725,6 +31503,8 @@ class CfnCapacityProvider(
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
         :param auto_scaling_group_provider: The Auto Scaling group settings for the capacity provider.
+        :param cluster_name: 
+        :param managed_instances_provider: The configuration for the Amazon ECS Managed Instances provider. This includes the infrastructure role, the launch template configuration, and tag propagation settings.
         :param name: The name of the capacity provider. If a name is specified, it cannot start with ``aws`` , ``ecs`` , or ``fargate`` . If no name is specified, a default name in the ``CFNStackName-CFNResourceName-RandomString`` format is used.
         :param tags: The metadata that you apply to the capacity provider to help you categorize and organize it. Each tag consists of a key and an optional value. You define both. The following basic restrictions apply to tags: - Maximum number of tags per resource - 50 - For each resource, each tag key must be unique, and each tag key can have only one value. - Maximum key length - 128 Unicode characters in UTF-8 - Maximum value length - 256 Unicode characters in UTF-8 - If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : /
         '''
@@ -30734,6 +31514,8 @@ class CfnCapacityProvider(
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         props = CfnCapacityProviderProps(
             auto_scaling_group_provider=auto_scaling_group_provider,
+            cluster_name=cluster_name,
+            managed_instances_provider=managed_instances_provider,
             name=name,
             tags=tags,
         )
@@ -30826,6 +31608,36 @@ class CfnCapacityProvider(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "autoScalingGroupProvider", value) # pyright: ignore[reportArgumentType]
 
+    @builtins.property
+    @jsii.member(jsii_name="clusterName")
+    def cluster_name(self) -> typing.Optional[builtins.str]:
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "clusterName"))
+
+    @cluster_name.setter
+    def cluster_name(self, value: typing.Optional[builtins.str]) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__56e821d6de113ad791628d9a188368814c7c0fb94ce466313a674dfb2a04780b)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "clusterName", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="managedInstancesProvider")
+    def managed_instances_provider(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.ManagedInstancesProviderProperty"]]:
+        '''The configuration for the Amazon ECS Managed Instances provider.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.ManagedInstancesProviderProperty"]], jsii.get(self, "managedInstancesProvider"))
+
+    @managed_instances_provider.setter
+    def managed_instances_provider(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.ManagedInstancesProviderProperty"]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__1eade181f601623fa0955313b90bd74d62cfcd3ee4f4809fd9998abc514cb4bc)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "managedInstancesProvider", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="name")
     def name(self) -> typing.Optional[builtins.str]:
@@ -30852,6 +31664,158 @@ class CfnCapacityProvider(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "tagsRaw", value) # pyright: ignore[reportArgumentType]
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.AcceleratorCountRequestProperty",
+        jsii_struct_bases=[],
+        name_mapping={"max": "max", "min": "min"},
+    )
+    class AcceleratorCountRequestProperty:
+        def __init__(
+            self,
+            *,
+            max: typing.Optional[jsii.Number] = None,
+            min: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''The minimum and maximum number of accelerators (such as GPUs) for instance type selection.
+
+            This is used for workloads that require specific numbers of accelerators.
+
+            :param max: The maximum number of accelerators. Instance types with more accelerators are excluded from selection.
+            :param min: The minimum number of accelerators. Instance types with fewer accelerators are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-acceleratorcountrequest.html
+            :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
+                
+                accelerator_count_request_property = ecs.CfnCapacityProvider.AcceleratorCountRequestProperty(
+                    max=123,
+                    min=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__43d53bcba92c90cf6f4d328d0942a76121d27482644e63c47c94438bbe161846)
+                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
+                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if max is not None:
+                self._values["max"] = max
+            if min is not None:
+                self._values["min"] = min
+
+        @builtins.property
+        def max(self) -> typing.Optional[jsii.Number]:
+            '''The maximum number of accelerators.
+
+            Instance types with more accelerators are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-acceleratorcountrequest.html#cfn-ecs-capacityprovider-acceleratorcountrequest-max
+            '''
+            result = self._values.get("max")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def min(self) -> typing.Optional[jsii.Number]:
+            '''The minimum number of accelerators.
+
+            Instance types with fewer accelerators are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-acceleratorcountrequest.html#cfn-ecs-capacityprovider-acceleratorcountrequest-min
+            '''
+            result = self._values.get("min")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "AcceleratorCountRequestProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.AcceleratorTotalMemoryMiBRequestProperty",
+        jsii_struct_bases=[],
+        name_mapping={"max": "max", "min": "min"},
+    )
+    class AcceleratorTotalMemoryMiBRequestProperty:
+        def __init__(
+            self,
+            *,
+            max: typing.Optional[jsii.Number] = None,
+            min: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''The minimum and maximum total accelerator memory in mebibytes (MiB) for instance type selection.
+
+            This is important for GPU workloads that require specific amounts of video memory.
+
+            :param max: The maximum total accelerator memory in MiB. Instance types with more accelerator memory are excluded from selection.
+            :param min: The minimum total accelerator memory in MiB. Instance types with less accelerator memory are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-acceleratortotalmemorymibrequest.html
+            :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
+                
+                accelerator_total_memory_mi_bRequest_property = ecs.CfnCapacityProvider.AcceleratorTotalMemoryMiBRequestProperty(
+                    max=123,
+                    min=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__05b0b4abd870382eb40911671e91b829abe416723b1b38346d22783d1a2c8f67)
+                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
+                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if max is not None:
+                self._values["max"] = max
+            if min is not None:
+                self._values["min"] = min
+
+        @builtins.property
+        def max(self) -> typing.Optional[jsii.Number]:
+            '''The maximum total accelerator memory in MiB.
+
+            Instance types with more accelerator memory are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-acceleratortotalmemorymibrequest.html#cfn-ecs-capacityprovider-acceleratortotalmemorymibrequest-max
+            '''
+            result = self._values.get("max")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def min(self) -> typing.Optional[jsii.Number]:
+            '''The minimum total accelerator memory in MiB.
+
+            Instance types with less accelerator memory are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-acceleratortotalmemorymibrequest.html#cfn-ecs-capacityprovider-acceleratortotalmemorymibrequest-min
+            '''
+            result = self._values.get("min")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "AcceleratorTotalMemoryMiBRequestProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.AutoScalingGroupProviderProperty",
         jsii_struct_bases=[],
@@ -30979,6 +31943,1141 @@ class CfnCapacityProvider(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.BaselineEbsBandwidthMbpsRequestProperty",
+        jsii_struct_bases=[],
+        name_mapping={"max": "max", "min": "min"},
+    )
+    class BaselineEbsBandwidthMbpsRequestProperty:
+        def __init__(
+            self,
+            *,
+            max: typing.Optional[jsii.Number] = None,
+            min: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''The minimum and maximum baseline Amazon EBS bandwidth in megabits per second (Mbps) for instance type selection.
+
+            This is important for workloads with high storage I/O requirements.
+
+            :param max: The maximum baseline Amazon EBS bandwidth in Mbps. Instance types with higher Amazon EBS bandwidth are excluded from selection.
+            :param min: The minimum baseline Amazon EBS bandwidth in Mbps. Instance types with lower Amazon EBS bandwidth are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-baselineebsbandwidthmbpsrequest.html
+            :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
+                
+                baseline_ebs_bandwidth_mbps_request_property = ecs.CfnCapacityProvider.BaselineEbsBandwidthMbpsRequestProperty(
+                    max=123,
+                    min=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__55f829b236ccb12cc42e7c374a47c6c0909fecf313bf4ebb779169af029b2ba4)
+                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
+                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if max is not None:
+                self._values["max"] = max
+            if min is not None:
+                self._values["min"] = min
+
+        @builtins.property
+        def max(self) -> typing.Optional[jsii.Number]:
+            '''The maximum baseline Amazon EBS bandwidth in Mbps.
+
+            Instance types with higher Amazon EBS bandwidth are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-baselineebsbandwidthmbpsrequest.html#cfn-ecs-capacityprovider-baselineebsbandwidthmbpsrequest-max
+            '''
+            result = self._values.get("max")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def min(self) -> typing.Optional[jsii.Number]:
+            '''The minimum baseline Amazon EBS bandwidth in Mbps.
+
+            Instance types with lower Amazon EBS bandwidth are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-baselineebsbandwidthmbpsrequest.html#cfn-ecs-capacityprovider-baselineebsbandwidthmbpsrequest-min
+            '''
+            result = self._values.get("min")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "BaselineEbsBandwidthMbpsRequestProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.InstanceLaunchTemplateProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "ec2_instance_profile_arn": "ec2InstanceProfileArn",
+            "network_configuration": "networkConfiguration",
+            "instance_requirements": "instanceRequirements",
+            "monitoring": "monitoring",
+            "storage_configuration": "storageConfiguration",
+        },
+    )
+    class InstanceLaunchTemplateProperty:
+        def __init__(
+            self,
+            *,
+            ec2_instance_profile_arn: builtins.str,
+            network_configuration: typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.ManagedInstancesNetworkConfigurationProperty", typing.Dict[builtins.str, typing.Any]]],
+            instance_requirements: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.InstanceRequirementsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            monitoring: typing.Optional[builtins.str] = None,
+            storage_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.ManagedInstancesStorageConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        ) -> None:
+            '''The launch template configuration for Amazon ECS Managed Instances.
+
+            This defines how Amazon ECS launches Amazon EC2 instances, including the instance profile for your tasks, network and storage configuration, capacity options, and instance requirements for flexible instance type selection.
+
+            :param ec2_instance_profile_arn: The Amazon Resource Name (ARN) of the instance profile that Amazon ECS applies to Amazon ECS Managed Instances. This instance profile must include the necessary permissions for your tasks to access AWS services and resources. For more information, see `Amazon ECS instance profile for Managed Instances <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/managed-instances-instance-profile.html>`_ in the *Amazon ECS Developer Guide* .
+            :param network_configuration: The network configuration for Amazon ECS Managed Instances. This specifies the subnets and security groups that instances use for network connectivity.
+            :param instance_requirements: The instance requirements. You can specify:. - The instance types - Instance requirements such as vCPU count, memory, network performance, and accelerator specifications Amazon ECS automatically selects the instances that match the specified criteria.
+            :param monitoring: CloudWatch provides two categories of monitoring: basic monitoring and detailed monitoring. By default, your managed instance is configured for basic monitoring. You can optionally enable detailed monitoring to help you more quickly identify and act on operational issues. You can enable or turn off detailed monitoring at launch or when the managed instance is running or stopped. For more information, see `Detailed monitoring for Amazon ECS Managed Instances <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/detailed-monitoring-managed-instances.html>`_ in the Amazon ECS Developer Guide.
+            :param storage_configuration: The storage configuration for Amazon ECS Managed Instances. This defines the root volume size and type for the instances.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancelaunchtemplate.html
+            :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
+                
+                instance_launch_template_property = ecs.CfnCapacityProvider.InstanceLaunchTemplateProperty(
+                    ec2_instance_profile_arn="ec2InstanceProfileArn",
+                    network_configuration=ecs.CfnCapacityProvider.ManagedInstancesNetworkConfigurationProperty(
+                        subnets=["subnets"],
+                
+                        # the properties below are optional
+                        security_groups=["securityGroups"]
+                    ),
+                
+                    # the properties below are optional
+                    instance_requirements=ecs.CfnCapacityProvider.InstanceRequirementsRequestProperty(
+                        memory_mi_b=ecs.CfnCapacityProvider.MemoryMiBRequestProperty(
+                            min=123,
+                
+                            # the properties below are optional
+                            max=123
+                        ),
+                        v_cpu_count=ecs.CfnCapacityProvider.VCpuCountRangeRequestProperty(
+                            min=123,
+                
+                            # the properties below are optional
+                            max=123
+                        ),
+                
+                        # the properties below are optional
+                        accelerator_count=ecs.CfnCapacityProvider.AcceleratorCountRequestProperty(
+                            max=123,
+                            min=123
+                        ),
+                        accelerator_manufacturers=["acceleratorManufacturers"],
+                        accelerator_names=["acceleratorNames"],
+                        accelerator_total_memory_mi_b=ecs.CfnCapacityProvider.AcceleratorTotalMemoryMiBRequestProperty(
+                            max=123,
+                            min=123
+                        ),
+                        accelerator_types=["acceleratorTypes"],
+                        allowed_instance_types=["allowedInstanceTypes"],
+                        bare_metal="bareMetal",
+                        baseline_ebs_bandwidth_mbps=ecs.CfnCapacityProvider.BaselineEbsBandwidthMbpsRequestProperty(
+                            max=123,
+                            min=123
+                        ),
+                        burstable_performance="burstablePerformance",
+                        cpu_manufacturers=["cpuManufacturers"],
+                        excluded_instance_types=["excludedInstanceTypes"],
+                        instance_generations=["instanceGenerations"],
+                        local_storage="localStorage",
+                        local_storage_types=["localStorageTypes"],
+                        max_spot_price_as_percentage_of_optimal_on_demand_price=123,
+                        memory_gi_bPer_vCpu=ecs.CfnCapacityProvider.MemoryGiBPerVCpuRequestProperty(
+                            max=123,
+                            min=123
+                        ),
+                        network_bandwidth_gbps=ecs.CfnCapacityProvider.NetworkBandwidthGbpsRequestProperty(
+                            max=123,
+                            min=123
+                        ),
+                        network_interface_count=ecs.CfnCapacityProvider.NetworkInterfaceCountRequestProperty(
+                            max=123,
+                            min=123
+                        ),
+                        on_demand_max_price_percentage_over_lowest_price=123,
+                        require_hibernate_support=False,
+                        spot_max_price_percentage_over_lowest_price=123,
+                        total_local_storage_gb=ecs.CfnCapacityProvider.TotalLocalStorageGBRequestProperty(
+                            max=123,
+                            min=123
+                        )
+                    ),
+                    monitoring="monitoring",
+                    storage_configuration=ecs.CfnCapacityProvider.ManagedInstancesStorageConfigurationProperty(
+                        storage_size_gi_b=123
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__cb545da33f3067adee24bf90d3e903b06a7562a7e6ea6b3785f5b0ae6f3e105d)
+                check_type(argname="argument ec2_instance_profile_arn", value=ec2_instance_profile_arn, expected_type=type_hints["ec2_instance_profile_arn"])
+                check_type(argname="argument network_configuration", value=network_configuration, expected_type=type_hints["network_configuration"])
+                check_type(argname="argument instance_requirements", value=instance_requirements, expected_type=type_hints["instance_requirements"])
+                check_type(argname="argument monitoring", value=monitoring, expected_type=type_hints["monitoring"])
+                check_type(argname="argument storage_configuration", value=storage_configuration, expected_type=type_hints["storage_configuration"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "ec2_instance_profile_arn": ec2_instance_profile_arn,
+                "network_configuration": network_configuration,
+            }
+            if instance_requirements is not None:
+                self._values["instance_requirements"] = instance_requirements
+            if monitoring is not None:
+                self._values["monitoring"] = monitoring
+            if storage_configuration is not None:
+                self._values["storage_configuration"] = storage_configuration
+
+        @builtins.property
+        def ec2_instance_profile_arn(self) -> builtins.str:
+            '''The Amazon Resource Name (ARN) of the instance profile that Amazon ECS applies to Amazon ECS Managed Instances.
+
+            This instance profile must include the necessary permissions for your tasks to access AWS services and resources.
+
+            For more information, see `Amazon ECS instance profile for Managed Instances <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/managed-instances-instance-profile.html>`_ in the *Amazon ECS Developer Guide* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancelaunchtemplate.html#cfn-ecs-capacityprovider-instancelaunchtemplate-ec2instanceprofilearn
+            '''
+            result = self._values.get("ec2_instance_profile_arn")
+            assert result is not None, "Required property 'ec2_instance_profile_arn' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def network_configuration(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.ManagedInstancesNetworkConfigurationProperty"]:
+            '''The network configuration for Amazon ECS Managed Instances.
+
+            This specifies the subnets and security groups that instances use for network connectivity.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancelaunchtemplate.html#cfn-ecs-capacityprovider-instancelaunchtemplate-networkconfiguration
+            '''
+            result = self._values.get("network_configuration")
+            assert result is not None, "Required property 'network_configuration' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.ManagedInstancesNetworkConfigurationProperty"], result)
+
+        @builtins.property
+        def instance_requirements(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.InstanceRequirementsRequestProperty"]]:
+            '''The instance requirements. You can specify:.
+
+            - The instance types
+            - Instance requirements such as vCPU count, memory, network performance, and accelerator specifications
+
+            Amazon ECS automatically selects the instances that match the specified criteria.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancelaunchtemplate.html#cfn-ecs-capacityprovider-instancelaunchtemplate-instancerequirements
+            '''
+            result = self._values.get("instance_requirements")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.InstanceRequirementsRequestProperty"]], result)
+
+        @builtins.property
+        def monitoring(self) -> typing.Optional[builtins.str]:
+            '''CloudWatch provides two categories of monitoring: basic monitoring and detailed monitoring.
+
+            By default, your managed instance is configured for basic monitoring. You can optionally enable detailed monitoring to help you more quickly identify and act on operational issues. You can enable or turn off detailed monitoring at launch or when the managed instance is running or stopped. For more information, see `Detailed monitoring for Amazon ECS Managed Instances <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/detailed-monitoring-managed-instances.html>`_ in the Amazon ECS Developer Guide.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancelaunchtemplate.html#cfn-ecs-capacityprovider-instancelaunchtemplate-monitoring
+            '''
+            result = self._values.get("monitoring")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def storage_configuration(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.ManagedInstancesStorageConfigurationProperty"]]:
+            '''The storage configuration for Amazon ECS Managed Instances.
+
+            This defines the root volume size and type for the instances.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancelaunchtemplate.html#cfn-ecs-capacityprovider-instancelaunchtemplate-storageconfiguration
+            '''
+            result = self._values.get("storage_configuration")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.ManagedInstancesStorageConfigurationProperty"]], 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 "InstanceLaunchTemplateProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.InstanceRequirementsRequestProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "memory_mib": "memoryMiB",
+            "v_cpu_count": "vCpuCount",
+            "accelerator_count": "acceleratorCount",
+            "accelerator_manufacturers": "acceleratorManufacturers",
+            "accelerator_names": "acceleratorNames",
+            "accelerator_total_memory_mib": "acceleratorTotalMemoryMiB",
+            "accelerator_types": "acceleratorTypes",
+            "allowed_instance_types": "allowedInstanceTypes",
+            "bare_metal": "bareMetal",
+            "baseline_ebs_bandwidth_mbps": "baselineEbsBandwidthMbps",
+            "burstable_performance": "burstablePerformance",
+            "cpu_manufacturers": "cpuManufacturers",
+            "excluded_instance_types": "excludedInstanceTypes",
+            "instance_generations": "instanceGenerations",
+            "local_storage": "localStorage",
+            "local_storage_types": "localStorageTypes",
+            "max_spot_price_as_percentage_of_optimal_on_demand_price": "maxSpotPriceAsPercentageOfOptimalOnDemandPrice",
+            "memory_gib_per_v_cpu": "memoryGiBPerVCpu",
+            "network_bandwidth_gbps": "networkBandwidthGbps",
+            "network_interface_count": "networkInterfaceCount",
+            "on_demand_max_price_percentage_over_lowest_price": "onDemandMaxPricePercentageOverLowestPrice",
+            "require_hibernate_support": "requireHibernateSupport",
+            "spot_max_price_percentage_over_lowest_price": "spotMaxPricePercentageOverLowestPrice",
+            "total_local_storage_gb": "totalLocalStorageGb",
+        },
+    )
+    class InstanceRequirementsRequestProperty:
+        def __init__(
+            self,
+            *,
+            memory_mib: typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.MemoryMiBRequestProperty", typing.Dict[builtins.str, typing.Any]]],
+            v_cpu_count: typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.VCpuCountRangeRequestProperty", typing.Dict[builtins.str, typing.Any]]],
+            accelerator_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.AcceleratorCountRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            accelerator_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
+            accelerator_names: typing.Optional[typing.Sequence[builtins.str]] = None,
+            accelerator_total_memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.AcceleratorTotalMemoryMiBRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            accelerator_types: typing.Optional[typing.Sequence[builtins.str]] = None,
+            allowed_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
+            bare_metal: typing.Optional[builtins.str] = None,
+            baseline_ebs_bandwidth_mbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.BaselineEbsBandwidthMbpsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            burstable_performance: typing.Optional[builtins.str] = None,
+            cpu_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
+            excluded_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
+            instance_generations: typing.Optional[typing.Sequence[builtins.str]] = None,
+            local_storage: typing.Optional[builtins.str] = None,
+            local_storage_types: typing.Optional[typing.Sequence[builtins.str]] = None,
+            max_spot_price_as_percentage_of_optimal_on_demand_price: typing.Optional[jsii.Number] = None,
+            memory_gib_per_v_cpu: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.MemoryGiBPerVCpuRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            network_bandwidth_gbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.NetworkBandwidthGbpsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            network_interface_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.NetworkInterfaceCountRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            on_demand_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
+            require_hibernate_support: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+            spot_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
+            total_local_storage_gb: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.TotalLocalStorageGBRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        ) -> None:
+            '''The instance requirements for attribute-based instance type selection.
+
+            Instead of specifying exact instance types, you define requirements such as vCPU count, memory size, network performance, and accelerator specifications. Amazon ECS automatically selects Amazon EC2 instance types that match these requirements, providing flexibility and helping to mitigate capacity constraints.
+
+            :param memory_mib: The minimum and maximum amount of memory in mebibytes (MiB) for the instance types. Amazon ECS selects instance types that have memory within this range.
+            :param v_cpu_count: The minimum and maximum number of vCPUs for the instance types. Amazon ECS selects instance types that have vCPU counts within this range.
+            :param accelerator_count: The minimum and maximum number of accelerators for the instance types. This is used when you need instances with specific numbers of GPUs or other accelerators.
+            :param accelerator_manufacturers: The accelerator manufacturers to include. You can specify ``nvidia`` , ``amd`` , ``amazon-web-services`` , or ``xilinx`` depending on your accelerator requirements.
+            :param accelerator_names: The specific accelerator names to include. For example, you can specify ``a100`` , ``v100`` , ``k80`` , or other specific accelerator models.
+            :param accelerator_total_memory_mib: The minimum and maximum total accelerator memory in mebibytes (MiB). This is important for GPU workloads that require specific amounts of video memory.
+            :param accelerator_types: The accelerator types to include. You can specify ``gpu`` for graphics processing units, ``fpga`` for field programmable gate arrays, or ``inference`` for machine learning inference accelerators.
+            :param allowed_instance_types: The instance types to include in the selection. When specified, Amazon ECS only considers these instance types, subject to the other requirements specified.
+            :param bare_metal: Indicates whether to include bare metal instance types. Set to ``included`` to allow bare metal instances, ``excluded`` to exclude them, or ``required`` to use only bare metal instances.
+            :param baseline_ebs_bandwidth_mbps: The minimum and maximum baseline Amazon EBS bandwidth in megabits per second (Mbps). This is important for workloads with high storage I/O requirements.
+            :param burstable_performance: Indicates whether to include burstable performance instance types (T2, T3, T3a, T4g). Set to ``included`` to allow burstable instances, ``excluded`` to exclude them, or ``required`` to use only burstable instances.
+            :param cpu_manufacturers: The CPU manufacturers to include or exclude. You can specify ``intel`` , ``amd`` , or ``amazon-web-services`` to control which CPU types are used for your workloads.
+            :param excluded_instance_types: The instance types to exclude from selection. Use this to prevent Amazon ECS from selecting specific instance types that may not be suitable for your workloads.
+            :param instance_generations: The instance generations to include. You can specify ``current`` to use the latest generation instances, or ``previous`` to include previous generation instances for cost optimization.
+            :param local_storage: Indicates whether to include instance types with local storage. Set to ``included`` to allow local storage, ``excluded`` to exclude it, or ``required`` to use only instances with local storage.
+            :param local_storage_types: The local storage types to include. You can specify ``hdd`` for hard disk drives, ``ssd`` for solid state drives, or both.
+            :param max_spot_price_as_percentage_of_optimal_on_demand_price: The maximum price for Spot instances as a percentage of the optimal On-Demand price. This provides more precise cost control for Spot instance selection.
+            :param memory_gib_per_v_cpu: The minimum and maximum amount of memory per vCPU in gibibytes (GiB). This helps ensure that instance types have the appropriate memory-to-CPU ratio for your workloads.
+            :param network_bandwidth_gbps: The minimum and maximum network bandwidth in gigabits per second (Gbps). This is crucial for network-intensive workloads that require high throughput.
+            :param network_interface_count: The minimum and maximum number of network interfaces for the instance types. This is useful for workloads that require multiple network interfaces.
+            :param on_demand_max_price_percentage_over_lowest_price: The price protection threshold for On-Demand Instances, as a percentage higher than an identified On-Demand price. The identified On-Demand price is the price of the lowest priced current generation C, M, or R instance type with your specified attributes. If no current generation C, M, or R instance type matches your attributes, then the identified price is from either the lowest priced current generation instance types or, failing that, the lowest priced previous generation instance types that match your attributes. When Amazon ECS selects instance types with your attributes, we will exclude instance types whose price exceeds your specified threshold.
+            :param require_hibernate_support: Indicates whether the instance types must support hibernation. When set to ``true`` , only instance types that support hibernation are selected.
+            :param spot_max_price_percentage_over_lowest_price: The maximum price for Spot instances as a percentage over the lowest priced On-Demand instance. This helps control Spot instance costs while maintaining access to capacity.
+            :param total_local_storage_gb: The minimum and maximum total local storage in gigabytes (GB) for instance types with local storage.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html
+            :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
+                
+                instance_requirements_request_property = ecs.CfnCapacityProvider.InstanceRequirementsRequestProperty(
+                    memory_mi_b=ecs.CfnCapacityProvider.MemoryMiBRequestProperty(
+                        min=123,
+                
+                        # the properties below are optional
+                        max=123
+                    ),
+                    v_cpu_count=ecs.CfnCapacityProvider.VCpuCountRangeRequestProperty(
+                        min=123,
+                
+                        # the properties below are optional
+                        max=123
+                    ),
+                
+                    # the properties below are optional
+                    accelerator_count=ecs.CfnCapacityProvider.AcceleratorCountRequestProperty(
+                        max=123,
+                        min=123
+                    ),
+                    accelerator_manufacturers=["acceleratorManufacturers"],
+                    accelerator_names=["acceleratorNames"],
+                    accelerator_total_memory_mi_b=ecs.CfnCapacityProvider.AcceleratorTotalMemoryMiBRequestProperty(
+                        max=123,
+                        min=123
+                    ),
+                    accelerator_types=["acceleratorTypes"],
+                    allowed_instance_types=["allowedInstanceTypes"],
+                    bare_metal="bareMetal",
+                    baseline_ebs_bandwidth_mbps=ecs.CfnCapacityProvider.BaselineEbsBandwidthMbpsRequestProperty(
+                        max=123,
+                        min=123
+                    ),
+                    burstable_performance="burstablePerformance",
+                    cpu_manufacturers=["cpuManufacturers"],
+                    excluded_instance_types=["excludedInstanceTypes"],
+                    instance_generations=["instanceGenerations"],
+                    local_storage="localStorage",
+                    local_storage_types=["localStorageTypes"],
+                    max_spot_price_as_percentage_of_optimal_on_demand_price=123,
+                    memory_gi_bPer_vCpu=ecs.CfnCapacityProvider.MemoryGiBPerVCpuRequestProperty(
+                        max=123,
+                        min=123
+                    ),
+                    network_bandwidth_gbps=ecs.CfnCapacityProvider.NetworkBandwidthGbpsRequestProperty(
+                        max=123,
+                        min=123
+                    ),
+                    network_interface_count=ecs.CfnCapacityProvider.NetworkInterfaceCountRequestProperty(
+                        max=123,
+                        min=123
+                    ),
+                    on_demand_max_price_percentage_over_lowest_price=123,
+                    require_hibernate_support=False,
+                    spot_max_price_percentage_over_lowest_price=123,
+                    total_local_storage_gb=ecs.CfnCapacityProvider.TotalLocalStorageGBRequestProperty(
+                        max=123,
+                        min=123
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__d2fd7f319e7a3e49a0d45d342ee067f3719bf8c8519bbab1a3a3c81f41641bec)
+                check_type(argname="argument memory_mib", value=memory_mib, expected_type=type_hints["memory_mib"])
+                check_type(argname="argument v_cpu_count", value=v_cpu_count, expected_type=type_hints["v_cpu_count"])
+                check_type(argname="argument accelerator_count", value=accelerator_count, expected_type=type_hints["accelerator_count"])
+                check_type(argname="argument accelerator_manufacturers", value=accelerator_manufacturers, expected_type=type_hints["accelerator_manufacturers"])
+                check_type(argname="argument accelerator_names", value=accelerator_names, expected_type=type_hints["accelerator_names"])
+                check_type(argname="argument accelerator_total_memory_mib", value=accelerator_total_memory_mib, expected_type=type_hints["accelerator_total_memory_mib"])
+                check_type(argname="argument accelerator_types", value=accelerator_types, expected_type=type_hints["accelerator_types"])
+                check_type(argname="argument allowed_instance_types", value=allowed_instance_types, expected_type=type_hints["allowed_instance_types"])
+                check_type(argname="argument bare_metal", value=bare_metal, expected_type=type_hints["bare_metal"])
+                check_type(argname="argument baseline_ebs_bandwidth_mbps", value=baseline_ebs_bandwidth_mbps, expected_type=type_hints["baseline_ebs_bandwidth_mbps"])
+                check_type(argname="argument burstable_performance", value=burstable_performance, expected_type=type_hints["burstable_performance"])
+                check_type(argname="argument cpu_manufacturers", value=cpu_manufacturers, expected_type=type_hints["cpu_manufacturers"])
+                check_type(argname="argument excluded_instance_types", value=excluded_instance_types, expected_type=type_hints["excluded_instance_types"])
+                check_type(argname="argument instance_generations", value=instance_generations, expected_type=type_hints["instance_generations"])
+                check_type(argname="argument local_storage", value=local_storage, expected_type=type_hints["local_storage"])
+                check_type(argname="argument local_storage_types", value=local_storage_types, expected_type=type_hints["local_storage_types"])
+                check_type(argname="argument max_spot_price_as_percentage_of_optimal_on_demand_price", value=max_spot_price_as_percentage_of_optimal_on_demand_price, expected_type=type_hints["max_spot_price_as_percentage_of_optimal_on_demand_price"])
+                check_type(argname="argument memory_gib_per_v_cpu", value=memory_gib_per_v_cpu, expected_type=type_hints["memory_gib_per_v_cpu"])
+                check_type(argname="argument network_bandwidth_gbps", value=network_bandwidth_gbps, expected_type=type_hints["network_bandwidth_gbps"])
+                check_type(argname="argument network_interface_count", value=network_interface_count, expected_type=type_hints["network_interface_count"])
+                check_type(argname="argument on_demand_max_price_percentage_over_lowest_price", value=on_demand_max_price_percentage_over_lowest_price, expected_type=type_hints["on_demand_max_price_percentage_over_lowest_price"])
+                check_type(argname="argument require_hibernate_support", value=require_hibernate_support, expected_type=type_hints["require_hibernate_support"])
+                check_type(argname="argument spot_max_price_percentage_over_lowest_price", value=spot_max_price_percentage_over_lowest_price, expected_type=type_hints["spot_max_price_percentage_over_lowest_price"])
+                check_type(argname="argument total_local_storage_gb", value=total_local_storage_gb, expected_type=type_hints["total_local_storage_gb"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "memory_mib": memory_mib,
+                "v_cpu_count": v_cpu_count,
+            }
+            if accelerator_count is not None:
+                self._values["accelerator_count"] = accelerator_count
+            if accelerator_manufacturers is not None:
+                self._values["accelerator_manufacturers"] = accelerator_manufacturers
+            if accelerator_names is not None:
+                self._values["accelerator_names"] = accelerator_names
+            if accelerator_total_memory_mib is not None:
+                self._values["accelerator_total_memory_mib"] = accelerator_total_memory_mib
+            if accelerator_types is not None:
+                self._values["accelerator_types"] = accelerator_types
+            if allowed_instance_types is not None:
+                self._values["allowed_instance_types"] = allowed_instance_types
+            if bare_metal is not None:
+                self._values["bare_metal"] = bare_metal
+            if baseline_ebs_bandwidth_mbps is not None:
+                self._values["baseline_ebs_bandwidth_mbps"] = baseline_ebs_bandwidth_mbps
+            if burstable_performance is not None:
+                self._values["burstable_performance"] = burstable_performance
+            if cpu_manufacturers is not None:
+                self._values["cpu_manufacturers"] = cpu_manufacturers
+            if excluded_instance_types is not None:
+                self._values["excluded_instance_types"] = excluded_instance_types
+            if instance_generations is not None:
+                self._values["instance_generations"] = instance_generations
+            if local_storage is not None:
+                self._values["local_storage"] = local_storage
+            if local_storage_types is not None:
+                self._values["local_storage_types"] = local_storage_types
+            if max_spot_price_as_percentage_of_optimal_on_demand_price is not None:
+                self._values["max_spot_price_as_percentage_of_optimal_on_demand_price"] = max_spot_price_as_percentage_of_optimal_on_demand_price
+            if memory_gib_per_v_cpu is not None:
+                self._values["memory_gib_per_v_cpu"] = memory_gib_per_v_cpu
+            if network_bandwidth_gbps is not None:
+                self._values["network_bandwidth_gbps"] = network_bandwidth_gbps
+            if network_interface_count is not None:
+                self._values["network_interface_count"] = network_interface_count
+            if on_demand_max_price_percentage_over_lowest_price is not None:
+                self._values["on_demand_max_price_percentage_over_lowest_price"] = on_demand_max_price_percentage_over_lowest_price
+            if require_hibernate_support is not None:
+                self._values["require_hibernate_support"] = require_hibernate_support
+            if spot_max_price_percentage_over_lowest_price is not None:
+                self._values["spot_max_price_percentage_over_lowest_price"] = spot_max_price_percentage_over_lowest_price
+            if total_local_storage_gb is not None:
+                self._values["total_local_storage_gb"] = total_local_storage_gb
+
+        @builtins.property
+        def memory_mib(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.MemoryMiBRequestProperty"]:
+            '''The minimum and maximum amount of memory in mebibytes (MiB) for the instance types.
+
+            Amazon ECS selects instance types that have memory within this range.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-memorymib
+            '''
+            result = self._values.get("memory_mib")
+            assert result is not None, "Required property 'memory_mib' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.MemoryMiBRequestProperty"], result)
+
+        @builtins.property
+        def v_cpu_count(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.VCpuCountRangeRequestProperty"]:
+            '''The minimum and maximum number of vCPUs for the instance types.
+
+            Amazon ECS selects instance types that have vCPU counts within this range.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-vcpucount
+            '''
+            result = self._values.get("v_cpu_count")
+            assert result is not None, "Required property 'v_cpu_count' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.VCpuCountRangeRequestProperty"], result)
+
+        @builtins.property
+        def accelerator_count(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.AcceleratorCountRequestProperty"]]:
+            '''The minimum and maximum number of accelerators for the instance types.
+
+            This is used when you need instances with specific numbers of GPUs or other accelerators.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-acceleratorcount
+            '''
+            result = self._values.get("accelerator_count")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.AcceleratorCountRequestProperty"]], result)
+
+        @builtins.property
+        def accelerator_manufacturers(
+            self,
+        ) -> typing.Optional[typing.List[builtins.str]]:
+            '''The accelerator manufacturers to include.
+
+            You can specify ``nvidia`` , ``amd`` , ``amazon-web-services`` , or ``xilinx`` depending on your accelerator requirements.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-acceleratormanufacturers
+            '''
+            result = self._values.get("accelerator_manufacturers")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def accelerator_names(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The specific accelerator names to include.
+
+            For example, you can specify ``a100`` , ``v100`` , ``k80`` , or other specific accelerator models.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-acceleratornames
+            '''
+            result = self._values.get("accelerator_names")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def accelerator_total_memory_mib(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.AcceleratorTotalMemoryMiBRequestProperty"]]:
+            '''The minimum and maximum total accelerator memory in mebibytes (MiB).
+
+            This is important for GPU workloads that require specific amounts of video memory.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-acceleratortotalmemorymib
+            '''
+            result = self._values.get("accelerator_total_memory_mib")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.AcceleratorTotalMemoryMiBRequestProperty"]], result)
+
+        @builtins.property
+        def accelerator_types(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The accelerator types to include.
+
+            You can specify ``gpu`` for graphics processing units, ``fpga`` for field programmable gate arrays, or ``inference`` for machine learning inference accelerators.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-acceleratortypes
+            '''
+            result = self._values.get("accelerator_types")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def allowed_instance_types(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The instance types to include in the selection.
+
+            When specified, Amazon ECS only considers these instance types, subject to the other requirements specified.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-allowedinstancetypes
+            '''
+            result = self._values.get("allowed_instance_types")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def bare_metal(self) -> typing.Optional[builtins.str]:
+            '''Indicates whether to include bare metal instance types.
+
+            Set to ``included`` to allow bare metal instances, ``excluded`` to exclude them, or ``required`` to use only bare metal instances.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-baremetal
+            '''
+            result = self._values.get("bare_metal")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def baseline_ebs_bandwidth_mbps(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.BaselineEbsBandwidthMbpsRequestProperty"]]:
+            '''The minimum and maximum baseline Amazon EBS bandwidth in megabits per second (Mbps).
+
+            This is important for workloads with high storage I/O requirements.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-baselineebsbandwidthmbps
+            '''
+            result = self._values.get("baseline_ebs_bandwidth_mbps")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.BaselineEbsBandwidthMbpsRequestProperty"]], result)
+
+        @builtins.property
+        def burstable_performance(self) -> typing.Optional[builtins.str]:
+            '''Indicates whether to include burstable performance instance types (T2, T3, T3a, T4g).
+
+            Set to ``included`` to allow burstable instances, ``excluded`` to exclude them, or ``required`` to use only burstable instances.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-burstableperformance
+            '''
+            result = self._values.get("burstable_performance")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def cpu_manufacturers(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The CPU manufacturers to include or exclude.
+
+            You can specify ``intel`` , ``amd`` , or ``amazon-web-services`` to control which CPU types are used for your workloads.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-cpumanufacturers
+            '''
+            result = self._values.get("cpu_manufacturers")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def excluded_instance_types(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The instance types to exclude from selection.
+
+            Use this to prevent Amazon ECS from selecting specific instance types that may not be suitable for your workloads.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-excludedinstancetypes
+            '''
+            result = self._values.get("excluded_instance_types")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def instance_generations(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The instance generations to include.
+
+            You can specify ``current`` to use the latest generation instances, or ``previous`` to include previous generation instances for cost optimization.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-instancegenerations
+            '''
+            result = self._values.get("instance_generations")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def local_storage(self) -> typing.Optional[builtins.str]:
+            '''Indicates whether to include instance types with local storage.
+
+            Set to ``included`` to allow local storage, ``excluded`` to exclude it, or ``required`` to use only instances with local storage.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-localstorage
+            '''
+            result = self._values.get("local_storage")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def local_storage_types(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The local storage types to include.
+
+            You can specify ``hdd`` for hard disk drives, ``ssd`` for solid state drives, or both.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-localstoragetypes
+            '''
+            result = self._values.get("local_storage_types")
+            return typing.cast(typing.Optional[typing.List[builtins.str]], result)
+
+        @builtins.property
+        def max_spot_price_as_percentage_of_optimal_on_demand_price(
+            self,
+        ) -> typing.Optional[jsii.Number]:
+            '''The maximum price for Spot instances as a percentage of the optimal On-Demand price.
+
+            This provides more precise cost control for Spot instance selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-maxspotpriceaspercentageofoptimalondemandprice
+            '''
+            result = self._values.get("max_spot_price_as_percentage_of_optimal_on_demand_price")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def memory_gib_per_v_cpu(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.MemoryGiBPerVCpuRequestProperty"]]:
+            '''The minimum and maximum amount of memory per vCPU in gibibytes (GiB).
+
+            This helps ensure that instance types have the appropriate memory-to-CPU ratio for your workloads.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-memorygibpervcpu
+            '''
+            result = self._values.get("memory_gib_per_v_cpu")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.MemoryGiBPerVCpuRequestProperty"]], result)
+
+        @builtins.property
+        def network_bandwidth_gbps(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.NetworkBandwidthGbpsRequestProperty"]]:
+            '''The minimum and maximum network bandwidth in gigabits per second (Gbps).
+
+            This is crucial for network-intensive workloads that require high throughput.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-networkbandwidthgbps
+            '''
+            result = self._values.get("network_bandwidth_gbps")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.NetworkBandwidthGbpsRequestProperty"]], result)
+
+        @builtins.property
+        def network_interface_count(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.NetworkInterfaceCountRequestProperty"]]:
+            '''The minimum and maximum number of network interfaces for the instance types.
+
+            This is useful for workloads that require multiple network interfaces.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-networkinterfacecount
+            '''
+            result = self._values.get("network_interface_count")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.NetworkInterfaceCountRequestProperty"]], result)
+
+        @builtins.property
+        def on_demand_max_price_percentage_over_lowest_price(
+            self,
+        ) -> typing.Optional[jsii.Number]:
+            '''The price protection threshold for On-Demand Instances, as a percentage higher than an identified On-Demand price.
+
+            The identified On-Demand price is the price of the lowest priced current generation C, M, or R instance type with your specified attributes. If no current generation C, M, or R instance type matches your attributes, then the identified price is from either the lowest priced current generation instance types or, failing that, the lowest priced previous generation instance types that match your attributes. When Amazon ECS selects instance types with your attributes, we will exclude instance types whose price exceeds your specified threshold.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-ondemandmaxpricepercentageoverlowestprice
+            '''
+            result = self._values.get("on_demand_max_price_percentage_over_lowest_price")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def require_hibernate_support(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''Indicates whether the instance types must support hibernation.
+
+            When set to ``true`` , only instance types that support hibernation are selected.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-requirehibernatesupport
+            '''
+            result = self._values.get("require_hibernate_support")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
+        @builtins.property
+        def spot_max_price_percentage_over_lowest_price(
+            self,
+        ) -> typing.Optional[jsii.Number]:
+            '''The maximum price for Spot instances as a percentage over the lowest priced On-Demand instance.
+
+            This helps control Spot instance costs while maintaining access to capacity.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-spotmaxpricepercentageoverlowestprice
+            '''
+            result = self._values.get("spot_max_price_percentage_over_lowest_price")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def total_local_storage_gb(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.TotalLocalStorageGBRequestProperty"]]:
+            '''The minimum and maximum total local storage in gigabytes (GB) for instance types with local storage.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-instancerequirementsrequest.html#cfn-ecs-capacityprovider-instancerequirementsrequest-totallocalstoragegb
+            '''
+            result = self._values.get("total_local_storage_gb")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.TotalLocalStorageGBRequestProperty"]], 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 "InstanceRequirementsRequestProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.ManagedInstancesNetworkConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={"subnets": "subnets", "security_groups": "securityGroups"},
+    )
+    class ManagedInstancesNetworkConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            subnets: typing.Sequence[builtins.str],
+            security_groups: typing.Optional[typing.Sequence[builtins.str]] = None,
+        ) -> None:
+            '''The network configuration for Amazon ECS Managed Instances.
+
+            This specifies the VPC subnets and security groups that instances use for network connectivity. Amazon ECS Managed Instances support multiple network modes including ``awsvpc`` (instances receive ENIs for task isolation), ``host`` (instances share network namespace with tasks), and ``none`` (no external network connectivity), ensuring backward compatibility for migrating workloads from Fargate or Amazon EC2.
+
+            :param subnets: The list of subnet IDs where Amazon ECS can launch Amazon ECS Managed Instances. Instances are distributed across the specified subnets for high availability. All subnets must be in the same VPC.
+            :param security_groups: The list of security group IDs to apply to Amazon ECS Managed Instances. These security groups control the network traffic allowed to and from the instances.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-managedinstancesnetworkconfiguration.html
+            :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
+                
+                managed_instances_network_configuration_property = ecs.CfnCapacityProvider.ManagedInstancesNetworkConfigurationProperty(
+                    subnets=["subnets"],
+                
+                    # the properties below are optional
+                    security_groups=["securityGroups"]
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__b8cf486af6edb309081654dbba3fcab445314c93a7a69231f0ca16b32fff9ae0)
+                check_type(argname="argument subnets", value=subnets, expected_type=type_hints["subnets"])
+                check_type(argname="argument security_groups", value=security_groups, expected_type=type_hints["security_groups"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "subnets": subnets,
+            }
+            if security_groups is not None:
+                self._values["security_groups"] = security_groups
+
+        @builtins.property
+        def subnets(self) -> typing.List[builtins.str]:
+            '''The list of subnet IDs where Amazon ECS can launch Amazon ECS Managed Instances.
+
+            Instances are distributed across the specified subnets for high availability. All subnets must be in the same VPC.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-managedinstancesnetworkconfiguration.html#cfn-ecs-capacityprovider-managedinstancesnetworkconfiguration-subnets
+            '''
+            result = self._values.get("subnets")
+            assert result is not None, "Required property 'subnets' is missing"
+            return typing.cast(typing.List[builtins.str], result)
+
+        @builtins.property
+        def security_groups(self) -> typing.Optional[typing.List[builtins.str]]:
+            '''The list of security group IDs to apply to Amazon ECS Managed Instances.
+
+            These security groups control the network traffic allowed to and from the instances.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-managedinstancesnetworkconfiguration.html#cfn-ecs-capacityprovider-managedinstancesnetworkconfiguration-securitygroups
+            '''
+            result = self._values.get("security_groups")
+            return typing.cast(typing.Optional[typing.List[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 "ManagedInstancesNetworkConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.ManagedInstancesProviderProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "infrastructure_role_arn": "infrastructureRoleArn",
+            "instance_launch_template": "instanceLaunchTemplate",
+            "propagate_tags": "propagateTags",
+        },
+    )
+    class ManagedInstancesProviderProperty:
+        def __init__(
+            self,
+            *,
+            infrastructure_role_arn: builtins.str,
+            instance_launch_template: typing.Union[_IResolvable_da3f097b, typing.Union["CfnCapacityProvider.InstanceLaunchTemplateProperty", typing.Dict[builtins.str, typing.Any]]],
+            propagate_tags: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''The configuration for a Amazon ECS Managed Instances provider.
+
+            Amazon ECS uses this configuration to automatically launch, manage, and terminate Amazon EC2 instances on your behalf. Managed instances provide access to the full range of Amazon EC2 instance types and features while offloading infrastructure management to AWS .
+
+            :param infrastructure_role_arn: The Amazon Resource Name (ARN) of the infrastructure role that Amazon ECS assumes to manage instances. This role must include permissions for Amazon EC2 instance lifecycle management, networking, and any additional AWS services required for your workloads. For more information, see `Amazon ECS infrastructure IAM role <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/infrastructure_IAM_role.html>`_ in the *Amazon ECS Developer Guide* .
+            :param instance_launch_template: The launch template that defines how Amazon ECS launches Amazon ECS Managed Instances. This includes the instance profile for your tasks, network and storage configuration, and instance requirements that determine which Amazon EC2 instance types can be used. For more information, see `Store instance launch parameters in Amazon EC2 launch templates <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html>`_ in the *Amazon EC2 User Guide* .
+            :param propagate_tags: Determines whether tags from the capacity provider are automatically applied to Amazon ECS Managed Instances. This helps with cost allocation and resource management by ensuring consistent tagging across your infrastructure.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-managedinstancesprovider.html
+            :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
+                
+                managed_instances_provider_property = ecs.CfnCapacityProvider.ManagedInstancesProviderProperty(
+                    infrastructure_role_arn="infrastructureRoleArn",
+                    instance_launch_template=ecs.CfnCapacityProvider.InstanceLaunchTemplateProperty(
+                        ec2_instance_profile_arn="ec2InstanceProfileArn",
+                        network_configuration=ecs.CfnCapacityProvider.ManagedInstancesNetworkConfigurationProperty(
+                            subnets=["subnets"],
+                
+                            # the properties below are optional
+                            security_groups=["securityGroups"]
+                        ),
+                
+                        # the properties below are optional
+                        instance_requirements=ecs.CfnCapacityProvider.InstanceRequirementsRequestProperty(
+                            memory_mi_b=ecs.CfnCapacityProvider.MemoryMiBRequestProperty(
+                                min=123,
+                
+                                # the properties below are optional
+                                max=123
+                            ),
+                            v_cpu_count=ecs.CfnCapacityProvider.VCpuCountRangeRequestProperty(
+                                min=123,
+                
+                                # the properties below are optional
+                                max=123
+                            ),
+                
+                            # the properties below are optional
+                            accelerator_count=ecs.CfnCapacityProvider.AcceleratorCountRequestProperty(
+                                max=123,
+                                min=123
+                            ),
+                            accelerator_manufacturers=["acceleratorManufacturers"],
+                            accelerator_names=["acceleratorNames"],
+                            accelerator_total_memory_mi_b=ecs.CfnCapacityProvider.AcceleratorTotalMemoryMiBRequestProperty(
+                                max=123,
+                                min=123
+                            ),
+                            accelerator_types=["acceleratorTypes"],
+                            allowed_instance_types=["allowedInstanceTypes"],
+                            bare_metal="bareMetal",
+                            baseline_ebs_bandwidth_mbps=ecs.CfnCapacityProvider.BaselineEbsBandwidthMbpsRequestProperty(
+                                max=123,
+                                min=123
+                            ),
+                            burstable_performance="burstablePerformance",
+                            cpu_manufacturers=["cpuManufacturers"],
+                            excluded_instance_types=["excludedInstanceTypes"],
+                            instance_generations=["instanceGenerations"],
+                            local_storage="localStorage",
+                            local_storage_types=["localStorageTypes"],
+                            max_spot_price_as_percentage_of_optimal_on_demand_price=123,
+                            memory_gi_bPer_vCpu=ecs.CfnCapacityProvider.MemoryGiBPerVCpuRequestProperty(
+                                max=123,
+                                min=123
+                            ),
+                            network_bandwidth_gbps=ecs.CfnCapacityProvider.NetworkBandwidthGbpsRequestProperty(
+                                max=123,
+                                min=123
+                            ),
+                            network_interface_count=ecs.CfnCapacityProvider.NetworkInterfaceCountRequestProperty(
+                                max=123,
+                                min=123
+                            ),
+                            on_demand_max_price_percentage_over_lowest_price=123,
+                            require_hibernate_support=False,
+                            spot_max_price_percentage_over_lowest_price=123,
+                            total_local_storage_gb=ecs.CfnCapacityProvider.TotalLocalStorageGBRequestProperty(
+                                max=123,
+                                min=123
+                            )
+                        ),
+                        monitoring="monitoring",
+                        storage_configuration=ecs.CfnCapacityProvider.ManagedInstancesStorageConfigurationProperty(
+                            storage_size_gi_b=123
+                        )
+                    ),
+                
+                    # the properties below are optional
+                    propagate_tags="propagateTags"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__45a3888e29c1b6fb29bc3dbf90f279f8c543b8924bb51956a75f3290eca0b7c9)
+                check_type(argname="argument infrastructure_role_arn", value=infrastructure_role_arn, expected_type=type_hints["infrastructure_role_arn"])
+                check_type(argname="argument instance_launch_template", value=instance_launch_template, expected_type=type_hints["instance_launch_template"])
+                check_type(argname="argument propagate_tags", value=propagate_tags, expected_type=type_hints["propagate_tags"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "infrastructure_role_arn": infrastructure_role_arn,
+                "instance_launch_template": instance_launch_template,
+            }
+            if propagate_tags is not None:
+                self._values["propagate_tags"] = propagate_tags
+
+        @builtins.property
+        def infrastructure_role_arn(self) -> builtins.str:
+            '''The Amazon Resource Name (ARN) of the infrastructure role that Amazon ECS assumes to manage instances.
+
+            This role must include permissions for Amazon EC2 instance lifecycle management, networking, and any additional AWS services required for your workloads.
+
+            For more information, see `Amazon ECS infrastructure IAM role <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/infrastructure_IAM_role.html>`_ in the *Amazon ECS Developer Guide* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-managedinstancesprovider.html#cfn-ecs-capacityprovider-managedinstancesprovider-infrastructurerolearn
+            '''
+            result = self._values.get("infrastructure_role_arn")
+            assert result is not None, "Required property 'infrastructure_role_arn' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def instance_launch_template(
+            self,
+        ) -> typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.InstanceLaunchTemplateProperty"]:
+            '''The launch template that defines how Amazon ECS launches Amazon ECS Managed Instances.
+
+            This includes the instance profile for your tasks, network and storage configuration, and instance requirements that determine which Amazon EC2 instance types can be used.
+
+            For more information, see `Store instance launch parameters in Amazon EC2 launch templates <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ec2-launch-templates.html>`_ in the *Amazon EC2 User Guide* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-managedinstancesprovider.html#cfn-ecs-capacityprovider-managedinstancesprovider-instancelaunchtemplate
+            '''
+            result = self._values.get("instance_launch_template")
+            assert result is not None, "Required property 'instance_launch_template' is missing"
+            return typing.cast(typing.Union[_IResolvable_da3f097b, "CfnCapacityProvider.InstanceLaunchTemplateProperty"], result)
+
+        @builtins.property
+        def propagate_tags(self) -> typing.Optional[builtins.str]:
+            '''Determines whether tags from the capacity provider are automatically applied to Amazon ECS Managed Instances.
+
+            This helps with cost allocation and resource management by ensuring consistent tagging across your infrastructure.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-managedinstancesprovider.html#cfn-ecs-capacityprovider-managedinstancesprovider-propagatetags
+            '''
+            result = self._values.get("propagate_tags")
+            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 "ManagedInstancesProviderProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.ManagedInstancesStorageConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={"storage_size_gib": "storageSizeGiB"},
+    )
+    class ManagedInstancesStorageConfigurationProperty:
+        def __init__(self, *, storage_size_gib: jsii.Number) -> None:
+            '''The storage configuration for Amazon ECS Managed Instances.
+
+            This defines the root volume configuration for the instances.
+
+            :param storage_size_gib: The size of the tasks volume.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-managedinstancesstorageconfiguration.html
+            :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
+                
+                managed_instances_storage_configuration_property = ecs.CfnCapacityProvider.ManagedInstancesStorageConfigurationProperty(
+                    storage_size_gi_b=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__8d1e06667171eb082ce77bd8060c435a6f130ac6e9384412fb372763b838e22b)
+                check_type(argname="argument storage_size_gib", value=storage_size_gib, expected_type=type_hints["storage_size_gib"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "storage_size_gib": storage_size_gib,
+            }
+
+        @builtins.property
+        def storage_size_gib(self) -> jsii.Number:
+            '''The size of the tasks volume.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-managedinstancesstorageconfiguration.html#cfn-ecs-capacityprovider-managedinstancesstorageconfiguration-storagesizegib
+            '''
+            result = self._values.get("storage_size_gib")
+            assert result is not None, "Required property 'storage_size_gib' is missing"
+            return typing.cast(jsii.Number, 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 "ManagedInstancesStorageConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.ManagedScalingProperty",
         jsii_struct_bases=[],
@@ -31114,6 +33213,468 @@ class CfnCapacityProvider(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.MemoryGiBPerVCpuRequestProperty",
+        jsii_struct_bases=[],
+        name_mapping={"max": "max", "min": "min"},
+    )
+    class MemoryGiBPerVCpuRequestProperty:
+        def __init__(
+            self,
+            *,
+            max: typing.Optional[jsii.Number] = None,
+            min: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''The minimum and maximum amount of memory per vCPU in gibibytes (GiB).
+
+            This helps ensure that instance types have the appropriate memory-to-CPU ratio for your workloads.
+
+            :param max: The maximum amount of memory per vCPU in GiB. Instance types with a higher memory-to-vCPU ratio are excluded from selection.
+            :param min: The minimum amount of memory per vCPU in GiB. Instance types with a lower memory-to-vCPU ratio are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-memorygibpervcpurequest.html
+            :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
+                
+                memory_gi_bPer_vCpu_request_property = ecs.CfnCapacityProvider.MemoryGiBPerVCpuRequestProperty(
+                    max=123,
+                    min=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__01b8a285c0250eb2fa8268dc32a515cb17c662ef0085fef55300ca206a1a746c)
+                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
+                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if max is not None:
+                self._values["max"] = max
+            if min is not None:
+                self._values["min"] = min
+
+        @builtins.property
+        def max(self) -> typing.Optional[jsii.Number]:
+            '''The maximum amount of memory per vCPU in GiB.
+
+            Instance types with a higher memory-to-vCPU ratio are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-memorygibpervcpurequest.html#cfn-ecs-capacityprovider-memorygibpervcpurequest-max
+            '''
+            result = self._values.get("max")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def min(self) -> typing.Optional[jsii.Number]:
+            '''The minimum amount of memory per vCPU in GiB.
+
+            Instance types with a lower memory-to-vCPU ratio are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-memorygibpervcpurequest.html#cfn-ecs-capacityprovider-memorygibpervcpurequest-min
+            '''
+            result = self._values.get("min")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "MemoryGiBPerVCpuRequestProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.MemoryMiBRequestProperty",
+        jsii_struct_bases=[],
+        name_mapping={"min": "min", "max": "max"},
+    )
+    class MemoryMiBRequestProperty:
+        def __init__(
+            self,
+            *,
+            min: jsii.Number,
+            max: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''The minimum and maximum amount of memory in mebibytes (MiB) for instance type selection.
+
+            This ensures that selected instance types have adequate memory for your workloads.
+
+            :param min: The minimum amount of memory in MiB. Instance types with less memory than this value are excluded from selection.
+            :param max: The maximum amount of memory in MiB. Instance types with more memory than this value are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-memorymibrequest.html
+            :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
+                
+                memory_mi_bRequest_property = ecs.CfnCapacityProvider.MemoryMiBRequestProperty(
+                    min=123,
+                
+                    # the properties below are optional
+                    max=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__a69680081ccdd5c785405398f4f1d616d0c97b874ced183049da2f9c6e34787e)
+                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
+                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "min": min,
+            }
+            if max is not None:
+                self._values["max"] = max
+
+        @builtins.property
+        def min(self) -> jsii.Number:
+            '''The minimum amount of memory in MiB.
+
+            Instance types with less memory than this value are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-memorymibrequest.html#cfn-ecs-capacityprovider-memorymibrequest-min
+            '''
+            result = self._values.get("min")
+            assert result is not None, "Required property 'min' is missing"
+            return typing.cast(jsii.Number, result)
+
+        @builtins.property
+        def max(self) -> typing.Optional[jsii.Number]:
+            '''The maximum amount of memory in MiB.
+
+            Instance types with more memory than this value are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-memorymibrequest.html#cfn-ecs-capacityprovider-memorymibrequest-max
+            '''
+            result = self._values.get("max")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "MemoryMiBRequestProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.NetworkBandwidthGbpsRequestProperty",
+        jsii_struct_bases=[],
+        name_mapping={"max": "max", "min": "min"},
+    )
+    class NetworkBandwidthGbpsRequestProperty:
+        def __init__(
+            self,
+            *,
+            max: typing.Optional[jsii.Number] = None,
+            min: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''The minimum and maximum network bandwidth in gigabits per second (Gbps) for instance type selection.
+
+            This is important for network-intensive workloads.
+
+            :param max: The maximum network bandwidth in Gbps. Instance types with higher network bandwidth are excluded from selection.
+            :param min: The minimum network bandwidth in Gbps. Instance types with lower network bandwidth are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-networkbandwidthgbpsrequest.html
+            :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
+                
+                network_bandwidth_gbps_request_property = ecs.CfnCapacityProvider.NetworkBandwidthGbpsRequestProperty(
+                    max=123,
+                    min=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__0b64349de0e0aa036cd2591e8e4db2f873feceecef981a341ecb449ccf6868be)
+                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
+                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if max is not None:
+                self._values["max"] = max
+            if min is not None:
+                self._values["min"] = min
+
+        @builtins.property
+        def max(self) -> typing.Optional[jsii.Number]:
+            '''The maximum network bandwidth in Gbps.
+
+            Instance types with higher network bandwidth are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-networkbandwidthgbpsrequest.html#cfn-ecs-capacityprovider-networkbandwidthgbpsrequest-max
+            '''
+            result = self._values.get("max")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def min(self) -> typing.Optional[jsii.Number]:
+            '''The minimum network bandwidth in Gbps.
+
+            Instance types with lower network bandwidth are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-networkbandwidthgbpsrequest.html#cfn-ecs-capacityprovider-networkbandwidthgbpsrequest-min
+            '''
+            result = self._values.get("min")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "NetworkBandwidthGbpsRequestProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.NetworkInterfaceCountRequestProperty",
+        jsii_struct_bases=[],
+        name_mapping={"max": "max", "min": "min"},
+    )
+    class NetworkInterfaceCountRequestProperty:
+        def __init__(
+            self,
+            *,
+            max: typing.Optional[jsii.Number] = None,
+            min: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''The minimum and maximum number of network interfaces for instance type selection.
+
+            This is useful for workloads that require multiple network interfaces.
+
+            :param max: The maximum number of network interfaces. Instance types that support more network interfaces are excluded from selection.
+            :param min: The minimum number of network interfaces. Instance types that support fewer network interfaces are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-networkinterfacecountrequest.html
+            :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
+                
+                network_interface_count_request_property = ecs.CfnCapacityProvider.NetworkInterfaceCountRequestProperty(
+                    max=123,
+                    min=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__b7767213e94df32328c6564e342330aa95c25ac187a4114099951ea2e0802ddb)
+                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
+                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if max is not None:
+                self._values["max"] = max
+            if min is not None:
+                self._values["min"] = min
+
+        @builtins.property
+        def max(self) -> typing.Optional[jsii.Number]:
+            '''The maximum number of network interfaces.
+
+            Instance types that support more network interfaces are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-networkinterfacecountrequest.html#cfn-ecs-capacityprovider-networkinterfacecountrequest-max
+            '''
+            result = self._values.get("max")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def min(self) -> typing.Optional[jsii.Number]:
+            '''The minimum number of network interfaces.
+
+            Instance types that support fewer network interfaces are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-networkinterfacecountrequest.html#cfn-ecs-capacityprovider-networkinterfacecountrequest-min
+            '''
+            result = self._values.get("min")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "NetworkInterfaceCountRequestProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.TotalLocalStorageGBRequestProperty",
+        jsii_struct_bases=[],
+        name_mapping={"max": "max", "min": "min"},
+    )
+    class TotalLocalStorageGBRequestProperty:
+        def __init__(
+            self,
+            *,
+            max: typing.Optional[jsii.Number] = None,
+            min: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''The minimum and maximum total local storage in gigabytes (GB) for instance types with local storage.
+
+            This is useful for workloads that require local storage for temporary data or caching.
+
+            :param max: The maximum total local storage in GB. Instance types with more local storage are excluded from selection.
+            :param min: The minimum total local storage in GB. Instance types with less local storage are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-totallocalstoragegbrequest.html
+            :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
+                
+                total_local_storage_gBRequest_property = ecs.CfnCapacityProvider.TotalLocalStorageGBRequestProperty(
+                    max=123,
+                    min=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__0b9cda28d66272632c4d42fbe68333883ca70c46c98159c2cd3f806c8bcc87fb)
+                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
+                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if max is not None:
+                self._values["max"] = max
+            if min is not None:
+                self._values["min"] = min
+
+        @builtins.property
+        def max(self) -> typing.Optional[jsii.Number]:
+            '''The maximum total local storage in GB.
+
+            Instance types with more local storage are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-totallocalstoragegbrequest.html#cfn-ecs-capacityprovider-totallocalstoragegbrequest-max
+            '''
+            result = self._values.get("max")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def min(self) -> typing.Optional[jsii.Number]:
+            '''The minimum total local storage in GB.
+
+            Instance types with less local storage are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-totallocalstoragegbrequest.html#cfn-ecs-capacityprovider-totallocalstoragegbrequest-min
+            '''
+            result = self._values.get("min")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "TotalLocalStorageGBRequestProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnCapacityProvider.VCpuCountRangeRequestProperty",
+        jsii_struct_bases=[],
+        name_mapping={"min": "min", "max": "max"},
+    )
+    class VCpuCountRangeRequestProperty:
+        def __init__(
+            self,
+            *,
+            min: jsii.Number,
+            max: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''The minimum and maximum number of vCPUs for instance type selection.
+
+            This allows you to specify a range of vCPU counts that meet your workload requirements.
+
+            :param min: The minimum number of vCPUs. Instance types with fewer vCPUs than this value are excluded from selection.
+            :param max: The maximum number of vCPUs. Instance types with more vCPUs than this value are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-vcpucountrangerequest.html
+            :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
+                
+                v_cpu_count_range_request_property = ecs.CfnCapacityProvider.VCpuCountRangeRequestProperty(
+                    min=123,
+                
+                    # the properties below are optional
+                    max=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__f6d818d37cfd5e478cf4f6075fe0ba45bdd81aa83e9eb5b3f01094a71abf8822)
+                check_type(argname="argument min", value=min, expected_type=type_hints["min"])
+                check_type(argname="argument max", value=max, expected_type=type_hints["max"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "min": min,
+            }
+            if max is not None:
+                self._values["max"] = max
+
+        @builtins.property
+        def min(self) -> jsii.Number:
+            '''The minimum number of vCPUs.
+
+            Instance types with fewer vCPUs than this value are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-vcpucountrangerequest.html#cfn-ecs-capacityprovider-vcpucountrangerequest-min
+            '''
+            result = self._values.get("min")
+            assert result is not None, "Required property 'min' is missing"
+            return typing.cast(jsii.Number, result)
+
+        @builtins.property
+        def max(self) -> typing.Optional[jsii.Number]:
+            '''The maximum number of vCPUs.
+
+            Instance types with more vCPUs than this value are excluded from selection.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-capacityprovider-vcpucountrangerequest.html#cfn-ecs-capacityprovider-vcpucountrangerequest-max
+            '''
+            result = self._values.get("max")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "VCpuCountRangeRequestProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
 
 @jsii.implements(_IInspectable_c2943556, IClusterRef, _ITaggable_36806126)
 class CfnCluster(
@@ -32795,7 +35356,7 @@ class CfnService(
         :param enable_ecs_managed_tags: Specifies whether to turn on 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>`_ in the *Amazon Elastic Container Service Developer Guide* . When you use Amazon ECS managed tags, you must set the ``propagateTags`` request parameter.
         :param enable_execute_command: Determines whether the execute command functionality is turned on for the service. If ``true`` , the execute command functionality is turned on for all containers in tasks as part of the service.
         :param force_new_deployment: Determines whether to force a new deployment of the service. By default, deployments aren't forced. You can use this option to start a new deployment with no service definition changes. For example, you can update a service's tasks to use a newer Docker image with the same image/tag combination ( ``my_image:latest`` ) or to roll Fargate tasks onto a newer platform version.
-        :param health_check_grace_period_seconds: The period of time, in seconds, that the Amazon Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing, VPC Lattice, and container health checks after a task has first started. If you do not specify a health check grace period value, the default value of 0 is used. If you do not use any of the health checks, then ``healthCheckGracePeriodSeconds`` is unused. If your service has more running tasks than desired, unhealthy tasks in the grace period might be stopped to reach the desired count.
+        :param health_check_grace_period_seconds: The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing, VPC Lattice, and container health checks after a task has first started. If you do not specify a health check grace period value, the default value of 0 is used. If you do not use any of the health checks, then ``healthCheckGracePeriodSeconds`` is unused. If your service has more running tasks than desired, unhealthy tasks in the grace period might be stopped to reach the desired count.
         :param launch_type: The launch type on which to run your service. For more information, see `Amazon ECS Launch Types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
         :param load_balancers: A list of load balancer objects to associate with the service. If you specify the ``Role`` property, ``LoadBalancers`` must be specified as well. For information about the number of load balancers that you can specify per service, see `Service Load Balancing <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-load-balancing.html>`_ in the *Amazon Elastic Container Service Developer Guide* . .. epigraph:: To remove this property from your service resource, specify an empty ``LoadBalancer`` array.
         :param network_configuration: The network configuration for the service. This parameter is required for task definitions that use the ``awsvpc`` network mode to receive their own elastic network interface, and it is not supported for other network modes. For more information, see `Task Networking <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-networking.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
@@ -33068,7 +35629,7 @@ class CfnService(
     @builtins.property
     @jsii.member(jsii_name="healthCheckGracePeriodSeconds")
     def health_check_grace_period_seconds(self) -> typing.Optional[jsii.Number]:
-        '''The period of time, in seconds, that the Amazon Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing, VPC Lattice, and container health checks after a task has first started.'''
+        '''The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing, VPC Lattice, and container health checks after a task has first started.'''
         return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "healthCheckGracePeriodSeconds"))
 
     @health_check_grace_period_seconds.setter
@@ -37028,7 +39589,7 @@ class CfnTaskDefinition(
         :param pid_mode: The process namespace to use for the containers in the task. The valid values are ``host`` or ``task`` . On Fargate for Linux containers, the only valid value is ``task`` . For example, monitoring sidecars might need ``pidMode`` to access information about other containers running in the same task. If ``host`` is specified, all containers within the tasks that specified the ``host`` PID mode on the same container instance share the same process namespace with the host Amazon EC2 instance. If ``task`` is specified, all containers within the specified task share the same process namespace. If no value is specified, the default is a private namespace for each container. If the ``host`` PID mode is used, there's a heightened risk of undesired process namespace exposure. .. epigraph:: This parameter is not supported for Windows containers. > This parameter is only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version ``1.4.0`` or later (Linux). This isn't supported for Windows containers on Fargate.
         :param placement_constraints: An array of placement constraint objects to use for tasks. .. epigraph:: This parameter isn't supported for tasks run on AWS Fargate .
         :param proxy_configuration: The configuration details for the App Mesh proxy. Your Amazon ECS container instances require at least version 1.26.0 of the container agent and at least version 1.26.0-1 of the ``ecs-init`` package to use a proxy configuration. If your container instances are launched from the Amazon ECS optimized AMI version ``20190301`` or later, they contain the required versions of the container agent and ``ecs-init`` . For more information, see `Amazon ECS-optimized Linux AMI <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
-        :param requires_compatibilities: The task launch types the task definition was validated against. The valid values are ``EC2`` , ``FARGATE`` , and ``EXTERNAL`` . For more information, see `Amazon ECS launch types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
+        :param requires_compatibilities: The task launch types the task definition was validated against. The valid values are ``MANAGED_INSTANCES`` , ``EC2`` , ``FARGATE`` , and ``EXTERNAL`` . For more information, see `Amazon ECS launch types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/launch_types.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
         :param runtime_platform: The operating system that your tasks definitions run on. A platform family is specified only for tasks using the Fargate launch type.
         :param tags: The metadata that you apply to the task definition to help you categorize and organize them. Each tag consists of a key and an optional value. You define both of them. The following basic restrictions apply to tags: - Maximum number of tags per resource - 50 - For each resource, each tag key must be unique, and each tag key can have only one value. - Maximum key length - 128 Unicode characters in UTF-8 - Maximum value length - 256 Unicode characters in UTF-8 - If your tagging schema is used across multiple services and resources, remember that other services may have restrictions on allowed characters. Generally allowed characters are: letters, numbers, and spaces representable in UTF-8, and the following characters: + - = . _ : /
         :param task_role_arn: The short name or full Amazon Resource Name (ARN) of the AWS Identity and Access Management role that grants containers in the task permission to call AWS APIs on your behalf. For more information, see `Amazon ECS Task Role <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task-iam-roles.html>`_ in the *Amazon Elastic Container Service Developer Guide* . IAM roles for tasks on Windows require that the ``-EnableTaskIAMRole`` option is set when you launch the Amazon ECS-optimized Windows AMI. Your containers must also run some configuration code to use the feature. For more information, see `Windows IAM roles for tasks <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/windows_task_IAM_roles.html>`_ in the *Amazon Elastic Container Service Developer Guide* . .. epigraph:: String validation is done on the ECS side. If an invalid string value is given for ``TaskRoleArn`` , it may cause the Cloudformation job to hang.
@@ -42799,24 +45360,43 @@ class Cluster(
 
     Example::
 
-        from aws_cdk import Tags
+        # vpc: ec2.Vpc
         
         
-        vpc = ec2.Vpc(self, "Vpc", max_azs=1)
-        cluster = ecs.Cluster(self, "EcsCluster", vpc=vpc)
-        task_definition = ecs.FargateTaskDefinition(self, "TaskDef",
-            memory_limit_mi_b=512,
-            cpu=256
+        cluster = ecs.Cluster(self, "Cluster",
+            vpc=vpc
         )
-        task_definition.add_container("WebContainer",
-            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")
+        
+        auto_scaling_group = autoscaling.AutoScalingGroup(self, "ASG",
+            vpc=vpc,
+            instance_type=ec2.InstanceType("t2.micro"),
+            machine_image=ecs.EcsOptimizedImage.amazon_linux2(),
+            min_capacity=0,
+            max_capacity=100
         )
-        Tags.of(task_definition).add("my-tag", "my-tag-value")
-        scheduled_fargate_task = ecs_patterns.ScheduledFargateTask(self, "ScheduledFargateTask",
+        
+        capacity_provider = ecs.AsgCapacityProvider(self, "AsgCapacityProvider",
+            auto_scaling_group=auto_scaling_group,
+            instance_warmup_period=300
+        )
+        cluster.add_asg_capacity_provider(capacity_provider)
+        
+        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
+        
+        task_definition.add_container("web",
+            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
+            memory_reservation_mi_b=256
+        )
+        
+        ecs.Ec2Service(self, "EC2Service",
             cluster=cluster,
             task_definition=task_definition,
-            schedule=appscaling.Schedule.expression("rate(1 minute)"),
-            propagate_tags=ecs.PropagatedTagSource.TASK_DEFINITION
+            min_healthy_percent=100,
+            capacity_provider_strategies=[ecs.CapacityProviderStrategy(
+                capacity_provider=capacity_provider.capacity_provider_name,
+                weight=1
+            )
+            ]
         )
     '''
 
@@ -43145,6 +45725,20 @@ class Cluster(
 
         return typing.cast(_INamespace_6b61e84f, jsii.invoke(self, "addDefaultCloudMapNamespace", [options]))
 
+    @jsii.member(jsii_name="addManagedInstancesCapacityProvider")
+    def add_managed_instances_capacity_provider(
+        self,
+        provider: ManagedInstancesCapacityProvider,
+    ) -> None:
+        '''This method adds a Managed Instances Capacity Provider to a cluster.
+
+        :param provider: the capacity provider to add to this cluster.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__5a82d1be969d3085ebea9661809bac2d0fcfb12723cd197d9b51420e44f7dbe3)
+            check_type(argname="argument provider", value=provider, expected_type=type_hints["provider"])
+        return typing.cast(None, jsii.invoke(self, "addManagedInstancesCapacityProvider", [provider]))
+
     @jsii.member(jsii_name="arnForTasks")
     def arn_for_tasks(self, key_pattern: builtins.str) -> builtins.str:
         '''Returns an ARN that represents all tasks within the cluster that match the task pattern specified.
@@ -43459,6 +46053,15 @@ class Cluster(
         '''The name of the cluster.'''
         return typing.cast(builtins.str, jsii.get(self, "clusterName"))
 
+    @builtins.property
+    @jsii.member(jsii_name="clusterScopedCapacityProviderNames")
+    def cluster_scoped_capacity_provider_names(self) -> typing.List[builtins.str]:
+        '''Getter for _clusterScopedCapacityProviderNames.
+
+        :attribute: true
+        '''
+        return typing.cast(typing.List[builtins.str], jsii.get(self, "clusterScopedCapacityProviderNames"))
+
     @builtins.property
     @jsii.member(jsii_name="connections")
     def connections(self) -> _Connections_0f31fce8:
@@ -44972,30 +47575,33 @@ class Ec2Service(
 
     Example::
 
-        # vpc: ec2.Vpc
-        
+        # task_definition: ecs.TaskDefinition
+        # cluster: ecs.Cluster
         
-        # Create an ECS cluster
-        cluster = ecs.Cluster(self, "Cluster", vpc=vpc)
         
-        # Add capacity to it
-        cluster.add_capacity("DefaultAutoScalingGroupCapacity",
-            instance_type=ec2.InstanceType("t2.xlarge"),
-            desired_capacity=3
+        # 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
         )
         
-        task_definition = ecs.Ec2TaskDefinition(self, "TaskDef")
-        
-        task_definition.add_container("DefaultContainer",
-            image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
-            memory_limit_mi_b=512
+        # Add a port mapping
+        specific_container.add_port_mappings(
+            container_port=7600,
+            protocol=ecs.Protocol.TCP
         )
         
-        # Instantiate an Amazon ECS Service
-        ecs_service = ecs.Ec2Service(self, "Service",
+        ecs.Ec2Service(self, "Service",
             cluster=cluster,
             task_definition=task_definition,
-            min_healthy_percent=100
+            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
+            )
         )
     '''
 
@@ -45953,6 +48559,9 @@ class FargateService(
 ):
     '''This creates a service using the Fargate launch type on an ECS cluster.
 
+    Can also be used with Managed Instances compatible task definitions when using
+    capacity provider strategies.
+
     :resource: AWS::ECS::Service
     :exampleMetadata: infused
 
@@ -46510,6 +49119,7 @@ __all__ = [
     "ITaskDefinitionRef",
     "ITaskSetRef",
     "InferenceAccelerator",
+    "InstanceMonitoring",
     "IpcMode",
     "JournaldLogDriver",
     "JournaldLogDriverProps",
@@ -46525,6 +49135,8 @@ __all__ = [
     "LogDriverConfig",
     "LogDrivers",
     "MachineImageType",
+    "ManagedInstancesCapacityProvider",
+    "ManagedInstancesCapacityProviderProps",
     "ManagedStorageConfiguration",
     "MemoryUtilizationScalingProps",
     "MountPoint",
@@ -46536,6 +49148,7 @@ __all__ = [
     "PortMap",
     "PortMapping",
     "PrimaryTaskSetReference",
+    "PropagateManagedInstancesTags",
     "PropagatedTagSource",
     "Protocol",
     "ProxyConfiguration",
@@ -46914,6 +49527,8 @@ def _typecheckingstub__481a7064afb879135819febdd572a91fb6799e4bfadf66c711f640b51
 def _typecheckingstub__48080bdf05dc1c4ca9ab46c833774163f6afcd0d1551b378b8d59e67bc180c3f(
     *,
     auto_scaling_group_provider: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.AutoScalingGroupProviderProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    cluster_name: typing.Optional[builtins.str] = None,
+    managed_instances_provider: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.ManagedInstancesProviderProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     name: typing.Optional[builtins.str] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
@@ -48323,6 +50938,44 @@ def _typecheckingstub__4028d39adfbd4018be781b02eae5afae009ba3d6754c9cac3c26580b7
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__718bb820f1409b5f15556f2e394659a060bda46e302dbb4e973a6484f24497de(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    ec2_instance_profile: _IInstanceProfile_10d5ce2c,
+    subnets: typing.Sequence[_ISubnet_d57d1229],
+    capacity_provider_name: typing.Optional[builtins.str] = None,
+    infrastructure_role: typing.Optional[_IRole_235f5d8e] = None,
+    instance_requirements: typing.Optional[typing.Union[_InstanceRequirementsConfig_1b353659, typing.Dict[builtins.str, typing.Any]]] = None,
+    monitoring: typing.Optional[InstanceMonitoring] = None,
+    propagate_tags: typing.Optional[PropagateManagedInstancesTags] = None,
+    security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
+    task_volume_storage: typing.Optional[_Size_7b441c34] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__86f1df235e6255faeece6081f964f386186a84532c53bb8fad57fd4ab50e809d(
+    cluster: ICluster,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__efa15b9a00384128ebdb40ffd56f7e66e8863f1c3a6b8d4cf8bc61fb9e822e92(
+    *,
+    ec2_instance_profile: _IInstanceProfile_10d5ce2c,
+    subnets: typing.Sequence[_ISubnet_d57d1229],
+    capacity_provider_name: typing.Optional[builtins.str] = None,
+    infrastructure_role: typing.Optional[_IRole_235f5d8e] = None,
+    instance_requirements: typing.Optional[typing.Union[_InstanceRequirementsConfig_1b353659, typing.Dict[builtins.str, typing.Any]]] = None,
+    monitoring: typing.Optional[InstanceMonitoring] = None,
+    propagate_tags: typing.Optional[PropagateManagedInstancesTags] = None,
+    security_groups: typing.Optional[typing.Sequence[_ISecurityGroup_acf8a799]] = None,
+    task_volume_storage: typing.Optional[_Size_7b441c34] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__2f9a1356d6603371cc25e0653216ab0167448ba43002bef5b32c489376e7fbb9(
     *,
     fargate_ephemeral_storage_kms_key: typing.Optional[_IKey_5f11635f] = None,
@@ -49178,6 +51831,8 @@ def _typecheckingstub__59a913caee739f6d41600bf8ae89985db638913fbcb77a8abd5451cda
     id: builtins.str,
     *,
     auto_scaling_group_provider: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.AutoScalingGroupProviderProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    cluster_name: typing.Optional[builtins.str] = None,
+    managed_instances_provider: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.ManagedInstancesProviderProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     name: typing.Optional[builtins.str] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
@@ -49210,6 +51865,18 @@ def _typecheckingstub__5888da07adc4050987d977b4699983a6760a2abcd538f800018e65953
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__56e821d6de113ad791628d9a188368814c7c0fb94ce466313a674dfb2a04780b(
+    value: typing.Optional[builtins.str],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__1eade181f601623fa0955313b90bd74d62cfcd3ee4f4809fd9998abc514cb4bc(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnCapacityProvider.ManagedInstancesProviderProperty]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__6b097d35daad25c1c594150aba1acbb2fe2a7052d42d247db35563ec5fed6bd4(
     value: typing.Optional[builtins.str],
 ) -> None:
@@ -49222,6 +51889,22 @@ def _typecheckingstub__81c56757bceb2c5880b41cbaabe62c67844b248e61c810588b5c50b5f
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__43d53bcba92c90cf6f4d328d0942a76121d27482644e63c47c94438bbe161846(
+    *,
+    max: typing.Optional[jsii.Number] = None,
+    min: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__05b0b4abd870382eb40911671e91b829abe416723b1b38346d22783d1a2c8f67(
+    *,
+    max: typing.Optional[jsii.Number] = None,
+    min: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__ca441075e92a847965e776db4f5ab9f545ce368b5efa4bc2476d58061dd0b742(
     *,
     auto_scaling_group_arn: builtins.str,
@@ -49232,6 +51915,79 @@ def _typecheckingstub__ca441075e92a847965e776db4f5ab9f545ce368b5efa4bc2476d58061
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__55f829b236ccb12cc42e7c374a47c6c0909fecf313bf4ebb779169af029b2ba4(
+    *,
+    max: typing.Optional[jsii.Number] = None,
+    min: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__cb545da33f3067adee24bf90d3e903b06a7562a7e6ea6b3785f5b0ae6f3e105d(
+    *,
+    ec2_instance_profile_arn: builtins.str,
+    network_configuration: typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.ManagedInstancesNetworkConfigurationProperty, typing.Dict[builtins.str, typing.Any]]],
+    instance_requirements: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.InstanceRequirementsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    monitoring: typing.Optional[builtins.str] = None,
+    storage_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.ManagedInstancesStorageConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__d2fd7f319e7a3e49a0d45d342ee067f3719bf8c8519bbab1a3a3c81f41641bec(
+    *,
+    memory_mib: typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.MemoryMiBRequestProperty, typing.Dict[builtins.str, typing.Any]]],
+    v_cpu_count: typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.VCpuCountRangeRequestProperty, typing.Dict[builtins.str, typing.Any]]],
+    accelerator_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.AcceleratorCountRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    accelerator_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
+    accelerator_names: typing.Optional[typing.Sequence[builtins.str]] = None,
+    accelerator_total_memory_mib: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.AcceleratorTotalMemoryMiBRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    accelerator_types: typing.Optional[typing.Sequence[builtins.str]] = None,
+    allowed_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
+    bare_metal: typing.Optional[builtins.str] = None,
+    baseline_ebs_bandwidth_mbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.BaselineEbsBandwidthMbpsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    burstable_performance: typing.Optional[builtins.str] = None,
+    cpu_manufacturers: typing.Optional[typing.Sequence[builtins.str]] = None,
+    excluded_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
+    instance_generations: typing.Optional[typing.Sequence[builtins.str]] = None,
+    local_storage: typing.Optional[builtins.str] = None,
+    local_storage_types: typing.Optional[typing.Sequence[builtins.str]] = None,
+    max_spot_price_as_percentage_of_optimal_on_demand_price: typing.Optional[jsii.Number] = None,
+    memory_gib_per_v_cpu: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.MemoryGiBPerVCpuRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    network_bandwidth_gbps: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.NetworkBandwidthGbpsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    network_interface_count: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.NetworkInterfaceCountRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    on_demand_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
+    require_hibernate_support: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+    spot_max_price_percentage_over_lowest_price: typing.Optional[jsii.Number] = None,
+    total_local_storage_gb: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.TotalLocalStorageGBRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__b8cf486af6edb309081654dbba3fcab445314c93a7a69231f0ca16b32fff9ae0(
+    *,
+    subnets: typing.Sequence[builtins.str],
+    security_groups: typing.Optional[typing.Sequence[builtins.str]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__45a3888e29c1b6fb29bc3dbf90f279f8c543b8924bb51956a75f3290eca0b7c9(
+    *,
+    infrastructure_role_arn: builtins.str,
+    instance_launch_template: typing.Union[_IResolvable_da3f097b, typing.Union[CfnCapacityProvider.InstanceLaunchTemplateProperty, typing.Dict[builtins.str, typing.Any]]],
+    propagate_tags: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__8d1e06667171eb082ce77bd8060c435a6f130ac6e9384412fb372763b838e22b(
+    *,
+    storage_size_gib: jsii.Number,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__b6ba7d15ac2121ea6e10f20fe3e2441ae17d00f30897db384f8f72e7d6406865(
     *,
     instance_warmup_period: typing.Optional[jsii.Number] = None,
@@ -49243,6 +51999,54 @@ def _typecheckingstub__b6ba7d15ac2121ea6e10f20fe3e2441ae17d00f30897db384f8f72e7d
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__01b8a285c0250eb2fa8268dc32a515cb17c662ef0085fef55300ca206a1a746c(
+    *,
+    max: typing.Optional[jsii.Number] = None,
+    min: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__a69680081ccdd5c785405398f4f1d616d0c97b874ced183049da2f9c6e34787e(
+    *,
+    min: jsii.Number,
+    max: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__0b64349de0e0aa036cd2591e8e4db2f873feceecef981a341ecb449ccf6868be(
+    *,
+    max: typing.Optional[jsii.Number] = None,
+    min: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__b7767213e94df32328c6564e342330aa95c25ac187a4114099951ea2e0802ddb(
+    *,
+    max: typing.Optional[jsii.Number] = None,
+    min: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__0b9cda28d66272632c4d42fbe68333883ca70c46c98159c2cd3f806c8bcc87fb(
+    *,
+    max: typing.Optional[jsii.Number] = None,
+    min: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__f6d818d37cfd5e478cf4f6075fe0ba45bdd81aa83e9eb5b3f01094a71abf8822(
+    *,
+    min: jsii.Number,
+    max: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__ea27f9318b2a509011f1175119715629617e6b8d976d0782e37d54e45f1e94c8(
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
@@ -50683,6 +53487,12 @@ def _typecheckingstub__e4b0382e0260e2588867571eddfb9f2d145389bea69e7e0b00917ba8a
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__5a82d1be969d3085ebea9661809bac2d0fcfb12723cd197d9b51420e44f7dbe3(
+    provider: ManagedInstancesCapacityProvider,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__dc82c424ab5a0b25f0e355e707c39f45826ed166c15976f45690abfa1ffcd30e(
     key_pattern: builtins.str,
 ) -> None: