aws-cdk-lib 2.167.2__py3-none-any.whl → 2.169.0__py3-none-any.whl

aws_cdk/aws_ecs/__init__.py

@@ -8148,6 +8148,7 @@ class CfnService(
         from aws_cdk import aws_ecs as ecs
         
         cfn_service = ecs.CfnService(self, "MyCfnService",
+            availability_zone_rebalancing="availabilityZoneRebalancing",
             capacity_provider_strategy=[ecs.CfnService.CapacityProviderStrategyItemProperty(
                 base=123,
                 capacity_provider="capacityProvider",
@@ -8285,6 +8286,11 @@ class CfnService(
                     throughput=123,
                     volume_type="volumeType"
                 )
+            )],
+            vpc_lattice_configurations=[ecs.CfnService.VpcLatticeConfigurationProperty(
+                port_name="portName",
+                role_arn="roleArn",
+                target_group_arn="targetGroupArn"
             )]
         )
     '''
@@ -8294,6 +8300,7 @@ class CfnService(
         scope: _constructs_77d1e7e8.Construct,
         id: builtins.str,
         *,
+        availability_zone_rebalancing: typing.Optional[builtins.str] = None,
         capacity_provider_strategy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnService.CapacityProviderStrategyItemProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
         cluster: typing.Optional[builtins.str] = None,
         deployment_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnService.DeploymentConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -8317,10 +8324,12 @@ class CfnService(
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
         task_definition: typing.Optional[builtins.str] = None,
         volume_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnService.ServiceVolumeConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        vpc_lattice_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnService.VpcLatticeConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
     ) -> None:
         '''
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
+        :param availability_zone_rebalancing: Default: - "DISABLED"
         :param capacity_provider_strategy: The capacity provider strategy to use for the service. If a ``capacityProviderStrategy`` is specified, the ``launchType`` parameter must be omitted. If no ``capacityProviderStrategy`` or ``launchType`` is specified, the ``defaultCapacityProviderStrategy`` for the cluster is used. A capacity provider strategy may contain a maximum of 6 capacity providers.
         :param cluster: The short name or full Amazon Resource Name (ARN) of the cluster that you run your service on. If you do not specify a cluster, the default cluster is assumed.
         :param deployment_configuration: Optional deployment parameters that control how many tasks run during the deployment and the ordering of stopping and starting tasks.
@@ -8328,7 +8337,7 @@ class CfnService(
         :param desired_count: The number of instantiations of the specified task definition to place and keep running in your service. For new services, if a desired count is not specified, a default value of ``1`` is used. When using the ``DAEMON`` scheduling strategy, the desired count is not required. For existing services, if a desired count is not specified, it is omitted from the operation.
         :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 need to 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 health_check_grace_period_seconds: The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing target health checks after a task has first started. This is only used when your service is configured to use a load balancer. If your service has a load balancer defined and you don't specify a health check grace period value, the default value of ``0`` is used. If you do not use an Elastic Load Balancing, we recommend that you use the ``startPeriod`` in the task definition health check parameters. For more information, see `Health check <https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_HealthCheck.html>`_ . If your service's tasks take a while to start and respond to Elastic Load Balancing health checks, you can specify a health check grace period of up to 2,147,483,647 seconds (about 69 years). During that time, the Amazon ECS service scheduler ignores health check status. This grace period can prevent the service scheduler from marking tasks as unhealthy and stopping them before they have time to come up.
+        :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 don't specify a health check grace period value, the default value of ``0`` is used. If you don't use any of the health checks, then ``healthCheckGracePeriodSeconds`` is unused. If your service's tasks take a while to start and respond to health checks, you can specify a health check grace period of up to 2,147,483,647 seconds (about 69 years). During that time, the Amazon ECS service scheduler ignores health check status. This grace period can prevent the service scheduler from marking tasks as unhealthy and stopping them before they have time to come up.
         :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* .
         :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* .
@@ -8344,12 +8353,14 @@ class CfnService(
         :param tags: The metadata that you apply to the service to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. When a service is deleted, the tags are deleted as well. 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_definition: The ``family`` and ``revision`` ( ``family:revision`` ) or full ARN of the task definition to run in your service. If a ``revision`` isn't specified, the latest ``ACTIVE`` revision is used. A task definition must be specified if the service uses either the ``ECS`` or ``CODE_DEPLOY`` deployment controllers. For more information about deployment types, see `Amazon ECS deployment types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html>`_ .
         :param volume_configurations: The configuration for a volume specified in the task definition as a volume that is configured at launch time. Currently, the only supported volume type is an Amazon EBS volume.
+        :param vpc_lattice_configurations: The VPC Lattice configuration for the service being created.
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__ec1192a1d20e03deef75c7fa1457b92ecf9506c5c5df97b5a4473fc3a9a714ef)
             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 = CfnServiceProps(
+            availability_zone_rebalancing=availability_zone_rebalancing,
             capacity_provider_strategy=capacity_provider_strategy,
             cluster=cluster,
             deployment_configuration=deployment_configuration,
@@ -8373,6 +8384,7 @@ class CfnService(
             tags=tags,
             task_definition=task_definition,
             volume_configurations=volume_configurations,
+            vpc_lattice_configurations=vpc_lattice_configurations,
         )
 
         jsii.create(self.__class__, self, [scope, id, props])
@@ -8436,6 +8448,21 @@ class CfnService(
         '''Tag Manager which manages the tags for this resource.'''
         return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))
 
+    @builtins.property
+    @jsii.member(jsii_name="availabilityZoneRebalancing")
+    def availability_zone_rebalancing(self) -> typing.Optional[builtins.str]:
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "availabilityZoneRebalancing"))
+
+    @availability_zone_rebalancing.setter
+    def availability_zone_rebalancing(
+        self,
+        value: typing.Optional[builtins.str],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__52cbfeaf8fbad41fd40801af6ef8ccd8415f38381fd4fba04e60fdfe449d1ea1)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "availabilityZoneRebalancing", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="capacityProviderStrategy")
     def capacity_provider_strategy(
@@ -8555,7 +8582,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 ECS service scheduler ignores unhealthy Elastic Load Balancing target 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
@@ -8804,6 +8831,24 @@ class CfnService(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "volumeConfigurations", value) # pyright: ignore[reportArgumentType]
 
+    @builtins.property
+    @jsii.member(jsii_name="vpcLatticeConfigurations")
+    def vpc_lattice_configurations(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnService.VpcLatticeConfigurationProperty"]]]]:
+        '''The VPC Lattice configuration for the service being created.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnService.VpcLatticeConfigurationProperty"]]]], jsii.get(self, "vpcLatticeConfigurations"))
+
+    @vpc_lattice_configurations.setter
+    def vpc_lattice_configurations(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnService.VpcLatticeConfigurationProperty"]]]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__e2af64fb9defca157f1246b9e5c27f87c21cd5930eb232ddeb8f17161a2498af)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "vpcLatticeConfigurations", value) # pyright: ignore[reportArgumentType]
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_ecs.CfnService.AwsVpcConfigurationProperty",
         jsii_struct_bases=[],
@@ -11317,11 +11362,106 @@ class CfnService(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnService.VpcLatticeConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "port_name": "portName",
+            "role_arn": "roleArn",
+            "target_group_arn": "targetGroupArn",
+        },
+    )
+    class VpcLatticeConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            port_name: builtins.str,
+            role_arn: builtins.str,
+            target_group_arn: builtins.str,
+        ) -> None:
+            '''The VPC Lattice configuration for your service that holds the information for the target group(s) Amazon ECS tasks will be registered to.
+
+            :param port_name: The name of the port mapping to register in the VPC Lattice target group. This is the name of the ``portMapping`` you defined in your task definition.
+            :param role_arn: The ARN of the IAM role to associate with this VPC Lattice configuration. This is the Amazon ECS infrastructure IAM role that is used to manage your VPC Lattice infrastructure.
+            :param target_group_arn: The full Amazon Resource Name (ARN) of the target group or groups associated with the VPC Lattice configuration that the Amazon ECS tasks will be registered to.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-vpclatticeconfiguration.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
+                
+                vpc_lattice_configuration_property = ecs.CfnService.VpcLatticeConfigurationProperty(
+                    port_name="portName",
+                    role_arn="roleArn",
+                    target_group_arn="targetGroupArn"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__6d05b4cedc8504915f9e19862e91955355b21b1ceedc604b97b7b446d31f62e1)
+                check_type(argname="argument port_name", value=port_name, expected_type=type_hints["port_name"])
+                check_type(argname="argument role_arn", value=role_arn, expected_type=type_hints["role_arn"])
+                check_type(argname="argument target_group_arn", value=target_group_arn, expected_type=type_hints["target_group_arn"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "port_name": port_name,
+                "role_arn": role_arn,
+                "target_group_arn": target_group_arn,
+            }
+
+        @builtins.property
+        def port_name(self) -> builtins.str:
+            '''The name of the port mapping to register in the VPC Lattice target group.
+
+            This is the name of the ``portMapping`` you defined in your task definition.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-vpclatticeconfiguration.html#cfn-ecs-service-vpclatticeconfiguration-portname
+            '''
+            result = self._values.get("port_name")
+            assert result is not None, "Required property 'port_name' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def role_arn(self) -> builtins.str:
+            '''The ARN of the IAM role to associate with this VPC Lattice configuration.
+
+            This is the Amazon ECS infrastructure IAM role that is used to manage your VPC Lattice infrastructure.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-vpclatticeconfiguration.html#cfn-ecs-service-vpclatticeconfiguration-rolearn
+            '''
+            result = self._values.get("role_arn")
+            assert result is not None, "Required property 'role_arn' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def target_group_arn(self) -> builtins.str:
+            '''The full Amazon Resource Name (ARN) of the target group or groups associated with the VPC Lattice configuration that the Amazon ECS tasks will be registered to.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-vpclatticeconfiguration.html#cfn-ecs-service-vpclatticeconfiguration-targetgrouparn
+            '''
+            result = self._values.get("target_group_arn")
+            assert result is not None, "Required property 'target_group_arn' is missing"
+            return typing.cast(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 "VpcLatticeConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
 
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_ecs.CfnServiceProps",
     jsii_struct_bases=[],
     name_mapping={
+        "availability_zone_rebalancing": "availabilityZoneRebalancing",
         "capacity_provider_strategy": "capacityProviderStrategy",
         "cluster": "cluster",
         "deployment_configuration": "deploymentConfiguration",
@@ -11345,12 +11485,14 @@ class CfnService(
         "tags": "tags",
         "task_definition": "taskDefinition",
         "volume_configurations": "volumeConfigurations",
+        "vpc_lattice_configurations": "vpcLatticeConfigurations",
     },
 )
 class CfnServiceProps:
     def __init__(
         self,
         *,
+        availability_zone_rebalancing: typing.Optional[builtins.str] = None,
         capacity_provider_strategy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnService.CapacityProviderStrategyItemProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
         cluster: typing.Optional[builtins.str] = None,
         deployment_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnService.DeploymentConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -11374,9 +11516,11 @@ class CfnServiceProps:
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
         task_definition: typing.Optional[builtins.str] = None,
         volume_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnService.ServiceVolumeConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        vpc_lattice_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnService.VpcLatticeConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     ) -> None:
         '''Properties for defining a ``CfnService``.
 
+        :param availability_zone_rebalancing: Default: - "DISABLED"
         :param capacity_provider_strategy: The capacity provider strategy to use for the service. If a ``capacityProviderStrategy`` is specified, the ``launchType`` parameter must be omitted. If no ``capacityProviderStrategy`` or ``launchType`` is specified, the ``defaultCapacityProviderStrategy`` for the cluster is used. A capacity provider strategy may contain a maximum of 6 capacity providers.
         :param cluster: The short name or full Amazon Resource Name (ARN) of the cluster that you run your service on. If you do not specify a cluster, the default cluster is assumed.
         :param deployment_configuration: Optional deployment parameters that control how many tasks run during the deployment and the ordering of stopping and starting tasks.
@@ -11384,7 +11528,7 @@ class CfnServiceProps:
         :param desired_count: The number of instantiations of the specified task definition to place and keep running in your service. For new services, if a desired count is not specified, a default value of ``1`` is used. When using the ``DAEMON`` scheduling strategy, the desired count is not required. For existing services, if a desired count is not specified, it is omitted from the operation.
         :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 need to 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 health_check_grace_period_seconds: The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing target health checks after a task has first started. This is only used when your service is configured to use a load balancer. If your service has a load balancer defined and you don't specify a health check grace period value, the default value of ``0`` is used. If you do not use an Elastic Load Balancing, we recommend that you use the ``startPeriod`` in the task definition health check parameters. For more information, see `Health check <https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_HealthCheck.html>`_ . If your service's tasks take a while to start and respond to Elastic Load Balancing health checks, you can specify a health check grace period of up to 2,147,483,647 seconds (about 69 years). During that time, the Amazon ECS service scheduler ignores health check status. This grace period can prevent the service scheduler from marking tasks as unhealthy and stopping them before they have time to come up.
+        :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 don't specify a health check grace period value, the default value of ``0`` is used. If you don't use any of the health checks, then ``healthCheckGracePeriodSeconds`` is unused. If your service's tasks take a while to start and respond to health checks, you can specify a health check grace period of up to 2,147,483,647 seconds (about 69 years). During that time, the Amazon ECS service scheduler ignores health check status. This grace period can prevent the service scheduler from marking tasks as unhealthy and stopping them before they have time to come up.
         :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* .
         :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* .
@@ -11400,6 +11544,7 @@ class CfnServiceProps:
         :param tags: The metadata that you apply to the service to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. When a service is deleted, the tags are deleted as well. 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_definition: The ``family`` and ``revision`` ( ``family:revision`` ) or full ARN of the task definition to run in your service. If a ``revision`` isn't specified, the latest ``ACTIVE`` revision is used. A task definition must be specified if the service uses either the ``ECS`` or ``CODE_DEPLOY`` deployment controllers. For more information about deployment types, see `Amazon ECS deployment types <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-types.html>`_ .
         :param volume_configurations: The configuration for a volume specified in the task definition as a volume that is configured at launch time. Currently, the only supported volume type is an Amazon EBS volume.
+        :param vpc_lattice_configurations: The VPC Lattice configuration for the service being created.
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-service.html
         :exampleMetadata: fixture=_generated
@@ -11411,6 +11556,7 @@ class CfnServiceProps:
             from aws_cdk import aws_ecs as ecs
             
             cfn_service_props = ecs.CfnServiceProps(
+                availability_zone_rebalancing="availabilityZoneRebalancing",
                 capacity_provider_strategy=[ecs.CfnService.CapacityProviderStrategyItemProperty(
                     base=123,
                     capacity_provider="capacityProvider",
@@ -11548,11 +11694,17 @@ class CfnServiceProps:
                         throughput=123,
                         volume_type="volumeType"
                     )
+                )],
+                vpc_lattice_configurations=[ecs.CfnService.VpcLatticeConfigurationProperty(
+                    port_name="portName",
+                    role_arn="roleArn",
+                    target_group_arn="targetGroupArn"
                 )]
             )
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__7f93658ccdbf3f250d0d1ce12224e9eddaef71a8f664c6a279122f60df5b8e83)
+            check_type(argname="argument availability_zone_rebalancing", value=availability_zone_rebalancing, expected_type=type_hints["availability_zone_rebalancing"])
             check_type(argname="argument capacity_provider_strategy", value=capacity_provider_strategy, expected_type=type_hints["capacity_provider_strategy"])
             check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
             check_type(argname="argument deployment_configuration", value=deployment_configuration, expected_type=type_hints["deployment_configuration"])
@@ -11576,7 +11728,10 @@ class CfnServiceProps:
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
             check_type(argname="argument task_definition", value=task_definition, expected_type=type_hints["task_definition"])
             check_type(argname="argument volume_configurations", value=volume_configurations, expected_type=type_hints["volume_configurations"])
+            check_type(argname="argument vpc_lattice_configurations", value=vpc_lattice_configurations, expected_type=type_hints["vpc_lattice_configurations"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if availability_zone_rebalancing is not None:
+            self._values["availability_zone_rebalancing"] = availability_zone_rebalancing
         if capacity_provider_strategy is not None:
             self._values["capacity_provider_strategy"] = capacity_provider_strategy
         if cluster is not None:
@@ -11623,6 +11778,18 @@ class CfnServiceProps:
             self._values["task_definition"] = task_definition
         if volume_configurations is not None:
             self._values["volume_configurations"] = volume_configurations
+        if vpc_lattice_configurations is not None:
+            self._values["vpc_lattice_configurations"] = vpc_lattice_configurations
+
+    @builtins.property
+    def availability_zone_rebalancing(self) -> typing.Optional[builtins.str]:
+        '''
+        :default: - "DISABLED"
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-service.html#cfn-ecs-service-availabilityzonerebalancing
+        '''
+        result = self._values.get("availability_zone_rebalancing")
+        return typing.cast(typing.Optional[builtins.str], result)
 
     @builtins.property
     def capacity_provider_strategy(
@@ -11717,13 +11884,11 @@ class CfnServiceProps:
 
     @builtins.property
     def health_check_grace_period_seconds(self) -> typing.Optional[jsii.Number]:
-        '''The period of time, in seconds, that the Amazon ECS service scheduler ignores unhealthy Elastic Load Balancing target health checks after a task has first started.
+        '''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.
 
-        This is only used when your service is configured to use a load balancer. If your service has a load balancer defined and you don't specify a health check grace period value, the default value of ``0`` is used.
+        If you don't specify a health check grace period value, the default value of ``0`` is used. If you don't use any of the health checks, then ``healthCheckGracePeriodSeconds`` is unused.
 
-        If you do not use an Elastic Load Balancing, we recommend that you use the ``startPeriod`` in the task definition health check parameters. For more information, see `Health check <https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_HealthCheck.html>`_ .
-
-        If your service's tasks take a while to start and respond to Elastic Load Balancing health checks, you can specify a health check grace period of up to 2,147,483,647 seconds (about 69 years). During that time, the Amazon ECS service scheduler ignores health check status. This grace period can prevent the service scheduler from marking tasks as unhealthy and stopping them before they have time to come up.
+        If your service's tasks take a while to start and respond to health checks, you can specify a health check grace period of up to 2,147,483,647 seconds (about 69 years). During that time, the Amazon ECS service scheduler ignores health check status. This grace period can prevent the service scheduler from marking tasks as unhealthy and stopping them before they have time to come up.
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-service.html#cfn-ecs-service-healthcheckgraceperiodseconds
         '''
@@ -11950,6 +12115,17 @@ class CfnServiceProps:
         result = self._values.get("volume_configurations")
         return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnService.ServiceVolumeConfigurationProperty]]]], result)
 
+    @builtins.property
+    def vpc_lattice_configurations(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnService.VpcLatticeConfigurationProperty]]]]:
+        '''The VPC Lattice configuration for the service being created.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ecs-service.html#cfn-ecs-service-vpclatticeconfigurations
+        '''
+        result = self._values.get("vpc_lattice_configurations")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnService.VpcLatticeConfigurationProperty]]]], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -12116,6 +12292,7 @@ class CfnTaskDefinition(
                     soft_limit=123
                 )],
                 user="user",
+                version_consistency="versionConsistency",
                 volumes_from=[ecs.CfnTaskDefinition.VolumeFromProperty(
                     read_only=False,
                     source_container="sourceContainer"
@@ -12701,6 +12878,7 @@ class CfnTaskDefinition(
             "system_controls": "systemControls",
             "ulimits": "ulimits",
             "user": "user",
+            "version_consistency": "versionConsistency",
             "volumes_from": "volumesFrom",
             "working_directory": "workingDirectory",
         },
@@ -12748,6 +12926,7 @@ class CfnTaskDefinition(
             system_controls: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskDefinition.SystemControlProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             ulimits: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskDefinition.UlimitProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             user: typing.Optional[builtins.str] = None,
+            version_consistency: typing.Optional[builtins.str] = None,
             volumes_from: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskDefinition.VolumeFromProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             working_directory: typing.Optional[builtins.str] = None,
         ) -> None:
@@ -12794,6 +12973,7 @@ class CfnTaskDefinition(
             :param system_controls: A list of namespaced kernel parameters to set in the container. This parameter maps to ``Sysctls`` in the docker container create command and the ``--sysctl`` option to docker run. For example, you can configure ``net.ipv4.tcp_keepalive_time`` setting to maintain longer lived connections.
             :param ulimits: A list of ``ulimits`` to set in the container. This parameter maps to ``Ulimits`` in the `Create a container <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate>`_ section of the `Docker Remote API <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/>`_ and the ``--ulimit`` option to `docker run <https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/>`_ . Valid naming values are displayed in the `Ulimit <https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_Ulimit.html>`_ data type. This parameter requires version 1.18 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: ``sudo docker version --format '{{.Server.APIVersion}}'`` .. epigraph:: This parameter is not supported for Windows containers.
             :param user: The user to use inside the container. This parameter maps to ``User`` in the docker container create command and the ``--user`` option to docker run. .. epigraph:: When running tasks using the ``host`` network mode, don't run containers using the root user (UID 0). We recommend using a non-root user for better security. You can specify the ``user`` using the following formats. If specifying a UID or GID, you must specify it as a positive integer. - ``user`` - ``user:group`` - ``uid`` - ``uid:gid`` - ``user:gid`` - ``uid:group`` .. epigraph:: This parameter is not supported for Windows containers.
+            :param version_consistency: Default: - "enabled"
             :param volumes_from: Data volumes to mount from another container. This parameter maps to ``VolumesFrom`` in the docker container create command and the ``--volumes-from`` option to docker run.
             :param working_directory: The working directory to run commands inside the container in. This parameter maps to ``WorkingDir`` in the docker container create command and the ``--workdir`` option to docker run.
 
@@ -12935,6 +13115,7 @@ class CfnTaskDefinition(
                         soft_limit=123
                     )],
                     user="user",
+                    version_consistency="versionConsistency",
                     volumes_from=[ecs.CfnTaskDefinition.VolumeFromProperty(
                         read_only=False,
                         source_container="sourceContainer"
@@ -12983,6 +13164,7 @@ class CfnTaskDefinition(
                 check_type(argname="argument system_controls", value=system_controls, expected_type=type_hints["system_controls"])
                 check_type(argname="argument ulimits", value=ulimits, expected_type=type_hints["ulimits"])
                 check_type(argname="argument user", value=user, expected_type=type_hints["user"])
+                check_type(argname="argument version_consistency", value=version_consistency, expected_type=type_hints["version_consistency"])
                 check_type(argname="argument volumes_from", value=volumes_from, expected_type=type_hints["volumes_from"])
                 check_type(argname="argument working_directory", value=working_directory, expected_type=type_hints["working_directory"])
             self._values: typing.Dict[builtins.str, typing.Any] = {
@@ -13063,6 +13245,8 @@ class CfnTaskDefinition(
                 self._values["ulimits"] = ulimits
             if user is not None:
                 self._values["user"] = user
+            if version_consistency is not None:
+                self._values["version_consistency"] = version_consistency
             if volumes_from is not None:
                 self._values["volumes_from"] = volumes_from
             if working_directory is not None:
@@ -13714,6 +13898,16 @@ class CfnTaskDefinition(
             result = self._values.get("user")
             return typing.cast(typing.Optional[builtins.str], result)
 
+        @builtins.property
+        def version_consistency(self) -> typing.Optional[builtins.str]:
+            '''
+            :default: - "enabled"
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-containerdefinition.html#cfn-ecs-taskdefinition-containerdefinition-versionconsistency
+            '''
+            result = self._values.get("version_consistency")
+            return typing.cast(typing.Optional[builtins.str], result)
+
         @builtins.property
         def volumes_from(
             self,
@@ -15677,7 +15871,7 @@ class CfnTaskDefinition(
             :param container_port: The port number on the container that's bound to the user-specified or automatically assigned host port. If you use containers in a task with the ``awsvpc`` or ``host`` network mode, specify the exposed ports using ``containerPort`` . If you use containers in a task with the ``bridge`` network mode and you specify a container port and not a host port, your container automatically receives a host port in the ephemeral port range. For more information, see ``hostPort`` . Port mappings that are automatically assigned in this way do not count toward the 100 reserved ports limit of a container instance.
             :param container_port_range: The port number range on the container that's bound to the dynamically mapped host port range. The following rules apply when you specify a ``containerPortRange`` : - You must use either the ``bridge`` network mode or the ``awsvpc`` network mode. - This parameter is available for both the EC2 and AWS Fargate launch types. - This parameter is available for both the Linux and Windows operating systems. - The container instance must have at least version 1.67.0 of the container agent and at least version 1.67.0-1 of the ``ecs-init`` package - You can specify a maximum of 100 port ranges per container. - You do not specify a ``hostPortRange`` . The value of the ``hostPortRange`` is set as follows: - For containers in a task with the ``awsvpc`` network mode, the ``hostPortRange`` is set to the same value as the ``containerPortRange`` . This is a static mapping strategy. - For containers in a task with the ``bridge`` network mode, the Amazon ECS agent finds open host ports from the default ephemeral range and passes it to docker to bind them to the container ports. - The ``containerPortRange`` valid values are between 1 and 65535. - A port can only be included in one port mapping per container. - You cannot specify overlapping port ranges. - The first port in the range must be less than last port in the range. - Docker recommends that you turn off the docker-proxy in the Docker daemon config file when you have a large number of ports. For more information, see `Issue #11185 <https://docs.aws.amazon.com/https://github.com/moby/moby/issues/11185>`_ on the Github website. For information about how to turn off the docker-proxy in the Docker daemon config file, see `Docker daemon <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/bootstrap_container_instance.html#bootstrap_docker_daemon>`_ in the *Amazon ECS Developer Guide* . You can call ```DescribeTasks`` <https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeTasks.html>`_ to view the ``hostPortRange`` which are the host ports that are bound to the container ports.
             :param host_port: The port number on the container instance to reserve for your container. If you specify a ``containerPortRange`` , leave this field empty and the value of the ``hostPort`` is set as follows: - For containers in a task with the ``awsvpc`` network mode, the ``hostPort`` is set to the same value as the ``containerPort`` . This is a static mapping strategy. - For containers in a task with the ``bridge`` network mode, the Amazon ECS agent finds open ports on the host and automatically binds them to the container ports. This is a dynamic mapping strategy. If you use containers in a task with the ``awsvpc`` or ``host`` network mode, the ``hostPort`` can either be left blank or set to the same value as the ``containerPort`` . If you use containers in a task with the ``bridge`` network mode, you can specify a non-reserved host port for your container port mapping, or you can omit the ``hostPort`` (or set it to ``0`` ) while specifying a ``containerPort`` and your container automatically receives a port in the ephemeral port range for your container instance operating system and Docker version. The default ephemeral port range for Docker version 1.6.0 and later is listed on the instance under ``/proc/sys/net/ipv4/ip_local_port_range`` . If this kernel parameter is unavailable, the default ephemeral port range from 49153 through 65535 (Linux) or 49152 through 65535 (Windows) is used. Do not attempt to specify a host port in the ephemeral port range as these are reserved for automatic assignment. In general, ports below 32768 are outside of the ephemeral port range. The default reserved ports are 22 for SSH, the Docker ports 2375 and 2376, and the Amazon ECS container agent ports 51678-51680. Any host port that was previously specified in a running task is also reserved while the task is running. That is, after a task stops, the host port is released. The current reserved ports are displayed in the ``remainingResources`` of `DescribeContainerInstances <https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_DescribeContainerInstances.html>`_ output. A container instance can have up to 100 reserved ports at a time. This number includes the default reserved ports. Automatically assigned ports aren't included in the 100 reserved ports quota.
-            :param name: The name that's used for the port mapping. This parameter only applies to Service Connect. This parameter is the name that you use in the ``serviceConnectConfiguration`` of a service. The name can include up to 64 characters. The characters can include lowercase letters, numbers, underscores (_), and hyphens (-). The name can't start with a hyphen. For more information, see `Service Connect <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
+            :param name: The name that's used for the port mapping. This parameter is the name that you use in the ``serviceConnectConfiguration`` and the ``vpcLatticeConfigurations`` of a service. The name can include up to 64 characters. The characters can include lowercase letters, numbers, underscores (_), and hyphens (-). The name can't start with a hyphen.
             :param protocol: The protocol used for the port mapping. Valid values are ``tcp`` and ``udp`` . The default is ``tcp`` . ``protocol`` is immutable in a Service Connect service. Updating this field requires a service deletion and redeployment.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-portmapping.html
@@ -15807,9 +16001,7 @@ class CfnTaskDefinition(
         def name(self) -> typing.Optional[builtins.str]:
             '''The name that's used for the port mapping.
 
-            This parameter only applies to Service Connect. This parameter is the name that you use in the ``serviceConnectConfiguration`` of a service. The name can include up to 64 characters. The characters can include lowercase letters, numbers, underscores (_), and hyphens (-). The name can't start with a hyphen.
-
-            For more information, see `Service Connect <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/service-connect.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
+            This parameter is the name that you use in the ``serviceConnectConfiguration`` and the ``vpcLatticeConfigurations`` of a service. The name can include up to 64 characters. The characters can include lowercase letters, numbers, underscores (_), and hyphens (-). The name can't start with a hyphen.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-portmapping.html#cfn-ecs-taskdefinition-portmapping-name
             '''
@@ -17179,6 +17371,7 @@ class CfnTaskDefinitionProps:
                         soft_limit=123
                     )],
                     user="user",
+                    version_consistency="versionConsistency",
                     volumes_from=[ecs.CfnTaskDefinition.VolumeFromProperty(
                         read_only=False,
                         source_container="sourceContainer"
@@ -42480,6 +42673,7 @@ def _typecheckingstub__ec1192a1d20e03deef75c7fa1457b92ecf9506c5c5df97b5a4473fc3a
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
     *,
+    availability_zone_rebalancing: typing.Optional[builtins.str] = None,
     capacity_provider_strategy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnService.CapacityProviderStrategyItemProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     cluster: typing.Optional[builtins.str] = None,
     deployment_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnService.DeploymentConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -42503,6 +42697,7 @@ def _typecheckingstub__ec1192a1d20e03deef75c7fa1457b92ecf9506c5c5df97b5a4473fc3a
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     task_definition: typing.Optional[builtins.str] = None,
     volume_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnService.ServiceVolumeConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    vpc_lattice_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnService.VpcLatticeConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -42519,6 +42714,12 @@ def _typecheckingstub__b2418aef5740852913fc8b9231af6ac6ece638d13d24b7a51e74b98f2
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__52cbfeaf8fbad41fd40801af6ef8ccd8415f38381fd4fba04e60fdfe449d1ea1(
+    value: typing.Optional[builtins.str],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__2cc9404cedce0aac2d2f2061fe9ad3f442cf33919c1a9f64eb934ded9311df13(
     value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnService.CapacityProviderStrategyItemProperty]]]],
 ) -> None:
@@ -42657,6 +42858,12 @@ def _typecheckingstub__f2ac135ae7ca091933f2f2f9baca1914fdf096339b6f1599966b809b9
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__e2af64fb9defca157f1246b9e5c27f87c21cd5930eb232ddeb8f17161a2498af(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnService.VpcLatticeConfigurationProperty]]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__40010db1fb42b63f942b5b11b7277545c2a1bffc42369636da9c14f813a744c5(
     *,
     assign_public_ip: typing.Optional[builtins.str] = None,
@@ -42856,8 +43063,18 @@ def _typecheckingstub__423b1a2c8c794083bf78a0cbae86dce8440201fe1e7b653bc2f6df2fb
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__6d05b4cedc8504915f9e19862e91955355b21b1ceedc604b97b7b446d31f62e1(
+    *,
+    port_name: builtins.str,
+    role_arn: builtins.str,
+    target_group_arn: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__7f93658ccdbf3f250d0d1ce12224e9eddaef71a8f664c6a279122f60df5b8e83(
     *,
+    availability_zone_rebalancing: typing.Optional[builtins.str] = None,
     capacity_provider_strategy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnService.CapacityProviderStrategyItemProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     cluster: typing.Optional[builtins.str] = None,
     deployment_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnService.DeploymentConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -42881,6 +43098,7 @@ def _typecheckingstub__7f93658ccdbf3f250d0d1ce12224e9eddaef71a8f664c6a279122f60d
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     task_definition: typing.Optional[builtins.str] = None,
     volume_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnService.ServiceVolumeConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    vpc_lattice_configurations: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnService.VpcLatticeConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -43073,6 +43291,7 @@ def _typecheckingstub__d367f5be98d90056ca7f199c577c5744b20417ce5d1c8ad339824ec9d
     system_controls: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskDefinition.SystemControlProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     ulimits: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskDefinition.UlimitProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     user: typing.Optional[builtins.str] = None,
+    version_consistency: typing.Optional[builtins.str] = None,
     volumes_from: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskDefinition.VolumeFromProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     working_directory: typing.Optional[builtins.str] = None,
 ) -> None: