aws-cdk-lib 2.137.0__py3-none-any.whl → 2.139.0__py3-none-any.whl

aws_cdk/aws_ecs/__init__.py

@@ -374,6 +374,23 @@ fargate_task_definition = ecs.FargateTaskDefinition(self, "TaskDef",
 )
 ```
 
+To specify the process namespace to use for the containers in the task, use the `pidMode` property:
+
+```python
+fargate_task_definition = ecs.FargateTaskDefinition(self, "TaskDef",
+    runtime_platform=ecs.RuntimePlatform(
+        operating_system_family=ecs.OperatingSystemFamily.LINUX,
+        cpu_architecture=ecs.CpuArchitecture.ARM64
+    ),
+    memory_limit_mi_b=512,
+    cpu=256,
+    pid_mode=ecs.PidMode.HOST
+)
+```
+
+**Note:** `pidMode` 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.
+
 To add containers to a task definition, call `addContainer()`:
 
 ```python
@@ -613,6 +630,25 @@ task_definition.add_container("container",
 )
 ```
 
+## Docker labels
+
+You can add labels to the container with the `dockerLabels` property or with the `addDockerLabel` method:
+
+```python
+# task_definition: ecs.TaskDefinition
+
+
+container = task_definition.add_container("cont",
+    image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample"),
+    memory_limit_mi_b=1024,
+    docker_labels={
+        "foo": "bar"
+    }
+)
+
+container.add_docker_label("label", "value")
+```
+
 ### Using Windows containers on Fargate
 
 AWS Fargate supports Amazon ECS Windows containers. For more details, please see this [blog post](https://aws.amazon.com/tw/blogs/containers/running-windows-containers-with-amazon-ecs-on-aws-fargate/)
@@ -8997,7 +9033,7 @@ class CfnService(
             :param alarms: Information about the CloudWatch alarms.
             :param deployment_circuit_breaker: .. epigraph:: The deployment circuit breaker can only be used for services using the rolling update ( ``ECS`` ) deployment type. The *deployment circuit breaker* determines whether a service deployment will fail if the service can't reach a steady state. If you use the deployment circuit breaker, a service deployment will transition to a failed state and stop launching new tasks. If you use the rollback option, when a service deployment fails, the service is rolled back to the last deployment that completed successfully. For more information, see `Rolling update <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html>`_ in the *Amazon Elastic Container Service Developer Guide*
             :param maximum_percent: If a service is using the rolling update ( ``ECS`` ) deployment type, the ``maximumPercent`` parameter represents an upper limit on the number of your service's tasks that are allowed in the ``RUNNING`` or ``PENDING`` state during a deployment, as a percentage of the ``desiredCount`` (rounded down to the nearest integer). This parameter enables you to define the deployment batch size. For example, if your service is using the ``REPLICA`` service scheduler and has a ``desiredCount`` of four tasks and a ``maximumPercent`` value of 200%, the scheduler may start four new tasks before stopping the four older tasks (provided that the cluster resources required to do this are available). The default ``maximumPercent`` value for a service using the ``REPLICA`` service scheduler is 200%. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and tasks that use the EC2 launch type, the *maximum percent* value is set to the default value and is used to define the upper limit on the number of the tasks in the service that remain in the ``RUNNING`` state while the container instances are in the ``DRAINING`` state. If the tasks in the service use the Fargate launch type, the maximum percent value is not used, although it is returned when describing your service.
-            :param minimum_healthy_percent: If a service is using the rolling update ( ``ECS`` ) deployment type, the ``minimumHealthyPercent`` represents a lower limit on the number of your service's tasks that must remain in the ``RUNNING`` state during a deployment, as a percentage of the ``desiredCount`` (rounded up to the nearest integer). This parameter enables you to deploy without using additional cluster capacity. For example, if your service has a ``desiredCount`` of four tasks and a ``minimumHealthyPercent`` of 50%, the service scheduler may stop two existing tasks to free up cluster capacity before starting two new tasks. For services that *do not* use a load balancer, the following should be noted: - A service is considered healthy if all essential containers within the tasks in the service pass their health checks. - If a task has no essential containers with a health check defined, the service scheduler will wait for 40 seconds after a task reaches a ``RUNNING`` state before the task is counted towards the minimum healthy percent total. - If a task has one or more essential containers with a health check defined, the service scheduler will wait for the task to reach a healthy status before counting it towards the minimum healthy percent total. A task is considered healthy when all essential containers within the task have passed their health checks. The amount of time the service scheduler can wait for is determined by the container health check settings. For services that *do* use a load balancer, the following should be noted: - If a task has no essential containers with a health check defined, the service scheduler will wait for the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total. - If a task has an essential container with a health check defined, the service scheduler will wait for both the task to reach a healthy status and the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the EC2 launch type, the *minimum healthy percent* value is set to the default value and is used to define the lower limit on the number of the tasks in the service that remain in the ``RUNNING`` state while the container instances are in the ``DRAINING`` state. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the Fargate launch type, the minimum healthy percent value is not used, although it is returned when describing your service.
+            :param minimum_healthy_percent: If a service is using the rolling update ( ``ECS`` ) deployment type, the ``minimumHealthyPercent`` represents a lower limit on the number of your service's tasks that must remain in the ``RUNNING`` state during a deployment, as a percentage of the ``desiredCount`` (rounded up to the nearest integer). This parameter enables you to deploy without using additional cluster capacity. For example, if your service has a ``desiredCount`` of four tasks and a ``minimumHealthyPercent`` of 50%, the service scheduler may stop two existing tasks to free up cluster capacity before starting two new tasks. For services that *do not* use a load balancer, the following should be noted: - A service is considered healthy if all essential containers within the tasks in the service pass their health checks. - If a task has no essential containers with a health check defined, the service scheduler will wait for 40 seconds after a task reaches a ``RUNNING`` state before the task is counted towards the minimum healthy percent total. - If a task has one or more essential containers with a health check defined, the service scheduler will wait for the task to reach a healthy status before counting it towards the minimum healthy percent total. A task is considered healthy when all essential containers within the task have passed their health checks. The amount of time the service scheduler can wait for is determined by the container health check settings. For services that *do* use a load balancer, the following should be noted: - If a task has no essential containers with a health check defined, the service scheduler will wait for the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total. - If a task has an essential container with a health check defined, the service scheduler will wait for both the task to reach a healthy status and the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total. The default value for a replica service for ``minimumHealthyPercent`` is 100%. The default ``minimumHealthyPercent`` value for a service using the ``DAEMON`` service schedule is 0% for the AWS CLI , the AWS SDKs, and the APIs and 50% for the AWS Management Console. The minimum number of healthy tasks during a deployment is the ``desiredCount`` multiplied by the ``minimumHealthyPercent`` /100, rounded up to the nearest integer value. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the EC2 launch type, the *minimum healthy percent* value is set to the default value and is used to define the lower limit on the number of the tasks in the service that remain in the ``RUNNING`` state while the container instances are in the ``DRAINING`` state. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the Fargate launch type, the minimum healthy percent value is not used, although it is returned when describing your service.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-deploymentconfiguration.html
             :exampleMetadata: fixture=_generated
@@ -9094,6 +9130,10 @@ class CfnService(
             - If a task has no essential containers with a health check defined, the service scheduler will wait for the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total.
             - If a task has an essential container with a health check defined, the service scheduler will wait for both the task to reach a healthy status and the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total.
 
+            The default value for a replica service for ``minimumHealthyPercent`` is 100%. The default ``minimumHealthyPercent`` value for a service using the ``DAEMON`` service schedule is 0% for the AWS CLI , the AWS SDKs, and the APIs and 50% for the AWS Management Console.
+
+            The minimum number of healthy tasks during a deployment is the ``desiredCount`` multiplied by the ``minimumHealthyPercent`` /100, rounded up to the nearest integer value.
+
             If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the EC2 launch type, the *minimum healthy percent* value is set to the default value and is used to define the lower limit on the number of the tasks in the service that remain in the ``RUNNING`` state while the container instances are in the ``DRAINING`` state. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the Fargate launch type, the minimum healthy percent value is not used, although it is returned when describing your service.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-deploymentconfiguration.html#cfn-ecs-service-deploymentconfiguration-minimumhealthypercent
@@ -11867,6 +11907,16 @@ class CfnTaskDefinition(
                     transit_encryption="transitEncryption",
                     transit_encryption_port=123
                 ),
+                f_sx_windows_file_server_volume_configuration=ecs.CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty(
+                    file_system_id="fileSystemId",
+                    root_directory="rootDirectory",
+        
+                    # the properties below are optional
+                    authorization_config=ecs.CfnTaskDefinition.FSxAuthorizationConfigProperty(
+                        credentials_parameter="credentialsParameter",
+                        domain="domain"
+                    )
+                ),
                 host=ecs.CfnTaskDefinition.HostVolumePropertiesProperty(
                     source_path="sourcePath"
                 ),
@@ -14004,6 +14054,176 @@ class CfnTaskDefinition(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnTaskDefinition.FSxAuthorizationConfigProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "credentials_parameter": "credentialsParameter",
+            "domain": "domain",
+        },
+    )
+    class FSxAuthorizationConfigProperty:
+        def __init__(
+            self,
+            *,
+            credentials_parameter: builtins.str,
+            domain: builtins.str,
+        ) -> None:
+            '''
+            :param credentials_parameter: 
+            :param domain: 
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxauthorizationconfig.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
+                
+                f_sx_authorization_config_property = ecs.CfnTaskDefinition.FSxAuthorizationConfigProperty(
+                    credentials_parameter="credentialsParameter",
+                    domain="domain"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__f5e3b577af4628d7fb3319bd51694790c1cd0a62eae308c830c9dccee5d8ca1d)
+                check_type(argname="argument credentials_parameter", value=credentials_parameter, expected_type=type_hints["credentials_parameter"])
+                check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "credentials_parameter": credentials_parameter,
+                "domain": domain,
+            }
+
+        @builtins.property
+        def credentials_parameter(self) -> builtins.str:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxauthorizationconfig.html#cfn-ecs-taskdefinition-fsxauthorizationconfig-credentialsparameter
+            '''
+            result = self._values.get("credentials_parameter")
+            assert result is not None, "Required property 'credentials_parameter' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def domain(self) -> builtins.str:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxauthorizationconfig.html#cfn-ecs-taskdefinition-fsxauthorizationconfig-domain
+            '''
+            result = self._values.get("domain")
+            assert result is not None, "Required property 'domain' 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 "FSxAuthorizationConfigProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "file_system_id": "fileSystemId",
+            "root_directory": "rootDirectory",
+            "authorization_config": "authorizationConfig",
+        },
+    )
+    class FSxWindowsFileServerVolumeConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            file_system_id: builtins.str,
+            root_directory: builtins.str,
+            authorization_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskDefinition.FSxAuthorizationConfigProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        ) -> None:
+            '''This parameter is specified when you're using `Amazon FSx for Windows File Server <https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html>`_ file system for task storage.
+
+            For more information and the input format, see `Amazon FSx for Windows File Server volumes <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/wfsx-volumes.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
+
+            :param file_system_id: The Amazon FSx for Windows File Server file system ID to use.
+            :param root_directory: The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.
+            :param authorization_config: The authorization configuration details for the Amazon FSx for Windows File Server file system.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration.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
+                
+                f_sx_windows_file_server_volume_configuration_property = ecs.CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty(
+                    file_system_id="fileSystemId",
+                    root_directory="rootDirectory",
+                
+                    # the properties below are optional
+                    authorization_config=ecs.CfnTaskDefinition.FSxAuthorizationConfigProperty(
+                        credentials_parameter="credentialsParameter",
+                        domain="domain"
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__ef74e299375c10c97a6bb4455d35f14ea7c21e10b612cd0fb3958fd12601168f)
+                check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
+                check_type(argname="argument root_directory", value=root_directory, expected_type=type_hints["root_directory"])
+                check_type(argname="argument authorization_config", value=authorization_config, expected_type=type_hints["authorization_config"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "file_system_id": file_system_id,
+                "root_directory": root_directory,
+            }
+            if authorization_config is not None:
+                self._values["authorization_config"] = authorization_config
+
+        @builtins.property
+        def file_system_id(self) -> builtins.str:
+            '''The Amazon FSx for Windows File Server file system ID to use.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration.html#cfn-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration-filesystemid
+            '''
+            result = self._values.get("file_system_id")
+            assert result is not None, "Required property 'file_system_id' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def root_directory(self) -> builtins.str:
+            '''The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration.html#cfn-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration-rootdirectory
+            '''
+            result = self._values.get("root_directory")
+            assert result is not None, "Required property 'root_directory' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def authorization_config(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTaskDefinition.FSxAuthorizationConfigProperty"]]:
+            '''The authorization configuration details for the Amazon FSx for Windows File Server file system.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration.html#cfn-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration-authorizationconfig
+            '''
+            result = self._values.get("authorization_config")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTaskDefinition.FSxAuthorizationConfigProperty"]], 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 "FSxWindowsFileServerVolumeConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_ecs.CfnTaskDefinition.FirelensConfigurationProperty",
         jsii_struct_bases=[],
@@ -16067,6 +16287,7 @@ class CfnTaskDefinition(
             "configured_at_launch": "configuredAtLaunch",
             "docker_volume_configuration": "dockerVolumeConfiguration",
             "efs_volume_configuration": "efsVolumeConfiguration",
+            "f_sx_windows_file_server_volume_configuration": "fSxWindowsFileServerVolumeConfiguration",
             "host": "host",
             "name": "name",
         },
@@ -16078,6 +16299,7 @@ class CfnTaskDefinition(
             configured_at_launch: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
             docker_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskDefinition.DockerVolumeConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             efs_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskDefinition.EFSVolumeConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            f_sx_windows_file_server_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             host: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskDefinition.HostVolumePropertiesProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             name: typing.Optional[builtins.str] = None,
         ) -> None:
@@ -16088,6 +16310,7 @@ class CfnTaskDefinition(
             :param configured_at_launch: Indicates whether the volume should be configured at launch time. This is used to create Amazon EBS volumes for standalone tasks or tasks created as part of a service. Each task definition revision may only have one volume configured at launch in the volume configuration. To configure a volume at launch time, use this task definition revision and specify a ``volumeConfigurations`` object when calling the ``CreateService`` , ``UpdateService`` , ``RunTask`` or ``StartTask`` APIs.
             :param docker_volume_configuration: This parameter is specified when you use Docker volumes. Windows containers only support the use of the ``local`` driver. To use bind mounts, specify the ``host`` parameter instead. .. epigraph:: Docker volumes aren't supported by tasks run on AWS Fargate .
             :param efs_volume_configuration: This parameter is specified when you use an Amazon Elastic File System file system for task storage.
+            :param f_sx_windows_file_server_volume_configuration: This parameter is specified when you use Amazon FSx for Windows File Server file system for task storage.
             :param host: This parameter is specified when you use bind mount host volumes. The contents of the ``host`` parameter determine whether your bind mount host volume persists on the host container instance and where it's stored. If the ``host`` parameter is empty, then the Docker daemon assigns a host path for your data volume. However, the data isn't guaranteed to persist after the containers that are associated with it stop running. Windows containers can mount whole directories on the same drive as ``$env:ProgramData`` . Windows containers can't mount directories on a different drive, and mount point can't be across drives. For example, you can mount ``C:\\my\\path:C:\\my\\path`` and ``D:\\:D:\\`` , but not ``D:\\my\\path:C:\\my\\path`` or ``D:\\:C:\\my\\path`` .
             :param name: The name of the volume. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. When using a volume configured at launch, the ``name`` is required and must also be specified as the volume name in the ``ServiceVolumeConfiguration`` or ``TaskVolumeConfiguration`` parameter when creating your service or standalone task. For all other types of volumes, this name is referenced in the ``sourceVolume`` parameter of the ``mountPoints`` object in the container definition. When a volume is using the ``efsVolumeConfiguration`` , the name is required.
 
@@ -16125,6 +16348,16 @@ class CfnTaskDefinition(
                         transit_encryption="transitEncryption",
                         transit_encryption_port=123
                     ),
+                    f_sx_windows_file_server_volume_configuration=ecs.CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty(
+                        file_system_id="fileSystemId",
+                        root_directory="rootDirectory",
+                
+                        # the properties below are optional
+                        authorization_config=ecs.CfnTaskDefinition.FSxAuthorizationConfigProperty(
+                            credentials_parameter="credentialsParameter",
+                            domain="domain"
+                        )
+                    ),
                     host=ecs.CfnTaskDefinition.HostVolumePropertiesProperty(
                         source_path="sourcePath"
                     ),
@@ -16136,6 +16369,7 @@ class CfnTaskDefinition(
                 check_type(argname="argument configured_at_launch", value=configured_at_launch, expected_type=type_hints["configured_at_launch"])
                 check_type(argname="argument docker_volume_configuration", value=docker_volume_configuration, expected_type=type_hints["docker_volume_configuration"])
                 check_type(argname="argument efs_volume_configuration", value=efs_volume_configuration, expected_type=type_hints["efs_volume_configuration"])
+                check_type(argname="argument f_sx_windows_file_server_volume_configuration", value=f_sx_windows_file_server_volume_configuration, expected_type=type_hints["f_sx_windows_file_server_volume_configuration"])
                 check_type(argname="argument host", value=host, expected_type=type_hints["host"])
                 check_type(argname="argument name", value=name, expected_type=type_hints["name"])
             self._values: typing.Dict[builtins.str, typing.Any] = {}
@@ -16145,6 +16379,8 @@ class CfnTaskDefinition(
                 self._values["docker_volume_configuration"] = docker_volume_configuration
             if efs_volume_configuration is not None:
                 self._values["efs_volume_configuration"] = efs_volume_configuration
+            if f_sx_windows_file_server_volume_configuration is not None:
+                self._values["f_sx_windows_file_server_volume_configuration"] = f_sx_windows_file_server_volume_configuration
             if host is not None:
                 self._values["host"] = host
             if name is not None:
@@ -16192,6 +16428,17 @@ class CfnTaskDefinition(
             result = self._values.get("efs_volume_configuration")
             return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTaskDefinition.EFSVolumeConfigurationProperty"]], result)
 
+        @builtins.property
+        def f_sx_windows_file_server_volume_configuration(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty"]]:
+            '''This parameter is specified when you use Amazon FSx for Windows File Server file system for task storage.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-volume.html#cfn-ecs-taskdefinition-volume-fsxwindowsfileservervolumeconfiguration
+            '''
+            result = self._values.get("f_sx_windows_file_server_volume_configuration")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty"]], result)
+
         @builtins.property
         def host(
             self,
@@ -16504,6 +16751,16 @@ class CfnTaskDefinitionProps:
                         transit_encryption="transitEncryption",
                         transit_encryption_port=123
                     ),
+                    f_sx_windows_file_server_volume_configuration=ecs.CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty(
+                        file_system_id="fileSystemId",
+                        root_directory="rootDirectory",
+            
+                        # the properties below are optional
+                        authorization_config=ecs.CfnTaskDefinition.FSxAuthorizationConfigProperty(
+                            credentials_parameter="credentialsParameter",
+                            domain="domain"
+                        )
+                    ),
                     host=ecs.CfnTaskDefinition.HostVolumePropertiesProperty(
                         source_path="sourcePath"
                     ),
@@ -19119,6 +19376,19 @@ class ContainerDefinition(
             check_type(argname="argument container_dependencies", value=container_dependencies, expected_type=typing.Tuple[type_hints["container_dependencies"], ...]) # pyright: ignore [reportGeneralTypeIssues]
         return typing.cast(None, jsii.invoke(self, "addContainerDependencies", [*container_dependencies]))
 
+    @jsii.member(jsii_name="addDockerLabel")
+    def add_docker_label(self, name: builtins.str, value: builtins.str) -> None:
+        '''This method adds a Docker label to the container.
+
+        :param name: -
+        :param value: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__de228f279641285922f39a7d85fc376918c045b328369fc61474e4677857075b)
+            check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        return typing.cast(None, jsii.invoke(self, "addDockerLabel", [name, value]))
+
     @jsii.member(jsii_name="addEnvironment")
     def add_environment(self, name: builtins.str, value: builtins.str) -> None:
         '''This method adds an environment variable to the container.
@@ -23093,7 +23363,7 @@ class Ec2TaskDefinitionProps(CommonTaskDefinitionProps):
         :param inference_accelerators: The inference accelerators to use for the containers in the task. Not supported in Fargate. Default: - No inference accelerators.
         :param ipc_mode: The IPC resource namespace to use for the containers in the task. Not supported in Fargate and Windows containers. Default: - IpcMode used by the task is not specified
         :param network_mode: The Docker networking mode to use for the containers in the task. The valid values are NONE, BRIDGE, AWS_VPC, and HOST. Default: - NetworkMode.BRIDGE for EC2 tasks, AWS_VPC for Fargate tasks.
-        :param pid_mode: The process namespace to use for the containers in the task. Not supported in Fargate and Windows containers. Default: - PidMode used by the task is not specified
+        :param pid_mode: The process namespace to use for the containers in the task. Not supported in Windows containers. Default: - PidMode used by the task is not specified
         :param placement_constraints: An array of placement constraint objects to use for the task. You can specify a maximum of 10 constraints per task (this limit includes constraints in the task definition and those specified at run time). Default: - No placement constraints.
 
         :exampleMetadata: infused
@@ -23235,7 +23505,7 @@ class Ec2TaskDefinitionProps(CommonTaskDefinitionProps):
     def pid_mode(self) -> typing.Optional["PidMode"]:
         '''The process namespace to use for the containers in the task.
 
-        Not supported in Fargate and Windows containers.
+        Not supported in Windows containers.
 
         :default: - PidMode used by the task is not specified
         '''
@@ -25759,6 +26029,7 @@ class FargateTaskDefinitionAttributes(CommonTaskDefinitionAttributes):
         "cpu": "cpu",
         "ephemeral_storage_gib": "ephemeralStorageGiB",
         "memory_limit_mib": "memoryLimitMiB",
+        "pid_mode": "pidMode",
         "runtime_platform": "runtimePlatform",
     },
 )
@@ -25774,6 +26045,7 @@ class FargateTaskDefinitionProps(CommonTaskDefinitionProps):
         cpu: typing.Optional[jsii.Number] = None,
         ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
+        pid_mode: typing.Optional["PidMode"] = None,
         runtime_platform: typing.Optional[typing.Union["RuntimePlatform", typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
         '''The properties for a task definition.
@@ -25786,26 +26058,21 @@ class FargateTaskDefinitionProps(CommonTaskDefinitionProps):
         :param cpu: The number of cpu units used by the task. For tasks using the Fargate launch type, this field is required and you must use one of the following values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) 512 (.5 vCPU) - Available memory values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) 1024 (1 vCPU) - Available memory values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) 2048 (2 vCPU) - Available memory values: Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) 4096 (4 vCPU) - Available memory values: Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) 8192 (8 vCPU) - Available memory values: Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) 16384 (16 vCPU) - Available memory values: Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) Default: 256
         :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The maximum supported value is 200 GiB. NOTE: This parameter is only supported for tasks hosted on AWS Fargate using platform version 1.4.0 or later. Default: 20
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. For tasks using the Fargate launch type, this field is required and you must use one of the following values, which determines your range of valid values for the cpu parameter: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25 vCPU) 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values: 512 (.5 vCPU) 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU) Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available cpu values: 2048 (2 vCPU) Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU) Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) - Available cpu values: 8192 (8 vCPU) Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) - Available cpu values: 16384 (16 vCPU) Default: 512
+        :param pid_mode: The process namespace to use for the containers in the task. Only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version 1.4.0 or later (Linux). Not supported in Windows containers. Default: - PidMode used by the task is not specified
         :param runtime_platform: The operating system that your task definitions are running on. A runtimePlatform is supported only for tasks using the Fargate launch type. Default: - Undefined.
 
         :exampleMetadata: infused
 
         Example::
 
-            # Create a Task Definition for the Windows container to start
-            task_definition = ecs.FargateTaskDefinition(self, "TaskDef",
+            fargate_task_definition = ecs.FargateTaskDefinition(self, "TaskDef",
                 runtime_platform=ecs.RuntimePlatform(
-                    operating_system_family=ecs.OperatingSystemFamily.WINDOWS_SERVER_2019_CORE,
-                    cpu_architecture=ecs.CpuArchitecture.X86_64
+                    operating_system_family=ecs.OperatingSystemFamily.LINUX,
+                    cpu_architecture=ecs.CpuArchitecture.ARM64
                 ),
-                cpu=1024,
-                memory_limit_mi_b=2048
-            )
-            
-            task_definition.add_container("windowsservercore",
-                logging=ecs.LogDriver.aws_logs(stream_prefix="win-iis-on-fargate"),
-                port_mappings=[ecs.PortMapping(container_port=80)],
-                image=ecs.ContainerImage.from_registry("mcr.microsoft.com/windows/servercore/iis:windowsservercore-ltsc2019")
+                memory_limit_mi_b=512,
+                cpu=256,
+                pid_mode=ecs.PidMode.HOST
             )
         '''
         if isinstance(runtime_platform, dict):
@@ -25820,6 +26087,7 @@ class FargateTaskDefinitionProps(CommonTaskDefinitionProps):
             check_type(argname="argument cpu", value=cpu, expected_type=type_hints["cpu"])
             check_type(argname="argument ephemeral_storage_gib", value=ephemeral_storage_gib, expected_type=type_hints["ephemeral_storage_gib"])
             check_type(argname="argument memory_limit_mib", value=memory_limit_mib, expected_type=type_hints["memory_limit_mib"])
+            check_type(argname="argument pid_mode", value=pid_mode, expected_type=type_hints["pid_mode"])
             check_type(argname="argument runtime_platform", value=runtime_platform, expected_type=type_hints["runtime_platform"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
         if execution_role is not None:
@@ -25838,6 +26106,8 @@ class FargateTaskDefinitionProps(CommonTaskDefinitionProps):
             self._values["ephemeral_storage_gib"] = ephemeral_storage_gib
         if memory_limit_mib is not None:
             self._values["memory_limit_mib"] = memory_limit_mib
+        if pid_mode is not None:
+            self._values["pid_mode"] = pid_mode
         if runtime_platform is not None:
             self._values["runtime_platform"] = runtime_platform
 
@@ -25959,6 +26229,19 @@ class FargateTaskDefinitionProps(CommonTaskDefinitionProps):
         result = self._values.get("memory_limit_mib")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def pid_mode(self) -> typing.Optional["PidMode"]:
+        '''The process namespace to use for the containers in the task.
+
+        Only supported for tasks that are hosted on AWS Fargate if the tasks
+        are using platform version 1.4.0 or later (Linux).
+        Not supported in Windows containers.
+
+        :default: - PidMode used by the task is not specified
+        '''
+        result = self._values.get("pid_mode")
+        return typing.cast(typing.Optional["PidMode"], result)
+
     @builtins.property
     def runtime_platform(self) -> typing.Optional["RuntimePlatform"]:
         '''The operating system that your task definitions are running on.
@@ -31126,7 +31409,22 @@ class OperatingSystemFamily(
 
 @jsii.enum(jsii_type="aws-cdk-lib.aws_ecs.PidMode")
 class PidMode(enum.Enum):
-    '''The process namespace to use for the containers in the task.'''
+    '''The process namespace to use for the containers in the task.
+
+    :exampleMetadata: infused
+
+    Example::
+
+        fargate_task_definition = ecs.FargateTaskDefinition(self, "TaskDef",
+            runtime_platform=ecs.RuntimePlatform(
+                operating_system_family=ecs.OperatingSystemFamily.LINUX,
+                cpu_architecture=ecs.CpuArchitecture.ARM64
+            ),
+            memory_limit_mi_b=512,
+            cpu=256,
+            pid_mode=ecs.PidMode.HOST
+        )
+    '''
 
     HOST = "HOST"
     '''If host is specified, then 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.'''
@@ -34894,7 +35192,7 @@ class TaskDefinition(
         :param ipc_mode: The IPC resource namespace to use for the containers in the task. Not supported in Fargate and Windows containers. Default: - IpcMode used by the task is not specified
         :param memory_mib: The amount (in MiB) of memory used by the task. If using the EC2 launch type, this field is optional and any value can be used. If using the Fargate launch type, this field is required and you must use one of the following values, which determines your range of valid values for the cpu parameter: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25 vCPU) 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values: 512 (.5 vCPU) 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU) Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available cpu values: 2048 (2 vCPU) Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU) Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) - Available cpu values: 8192 (8 vCPU) Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) - Available cpu values: 16384 (16 vCPU) Default: - Memory used by task is not specified.
         :param network_mode: The networking mode to use for the containers in the task. On Fargate, the only supported networking mode is AwsVpc. Default: - NetworkMode.Bridge for EC2 & External tasks, AwsVpc for Fargate tasks.
-        :param pid_mode: The process namespace to use for the containers in the task. Not supported in Fargate and Windows containers. Default: - PidMode used by the task is not specified
+        :param pid_mode: The process namespace to use for the containers in the task. Only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version 1.4.0 or later (Linux). Not supported in Windows containers. Default: - PidMode used by the task is not specified
         :param placement_constraints: The placement constraints to use for tasks in the service. You can specify a maximum of 10 constraints per task (this limit includes constraints in the task definition and those specified at run time). Not supported in Fargate. Default: - No placement constraints.
         :param runtime_platform: The operating system that your task definitions are running on. A runtimePlatform is supported only for tasks using the Fargate launch type. Default: - Undefined.
         :param execution_role: The name of the IAM task execution role that grants the ECS agent permission to call AWS APIs on your behalf. The role will be used to retrieve container images from ECR and create CloudWatch log groups. Default: - An execution role will be automatically created if you use ECR images in your task definition.
@@ -35464,6 +35762,17 @@ class TaskDefinition(
         '''Execution role for this task definition.'''
         return typing.cast(typing.Optional[_IRole_235f5d8e], jsii.get(self, "executionRole"))
 
+    @builtins.property
+    @jsii.member(jsii_name="pidMode")
+    def pid_mode(self) -> typing.Optional[PidMode]:
+        '''The process namespace to use for the containers in the task.
+
+        Only supported for tasks that are hosted on AWS Fargate if the tasks
+        are using platform version 1.4.0 or later (Linux).
+        Not supported in Windows containers.
+        '''
+        return typing.cast(typing.Optional[PidMode], jsii.get(self, "pidMode"))
+
     @builtins.property
     @jsii.member(jsii_name="referencesSecretJsonField")
     def references_secret_json_field(self) -> typing.Optional[builtins.bool]:
@@ -35670,7 +35979,7 @@ class TaskDefinitionProps(CommonTaskDefinitionProps):
         :param ipc_mode: The IPC resource namespace to use for the containers in the task. Not supported in Fargate and Windows containers. Default: - IpcMode used by the task is not specified
         :param memory_mib: The amount (in MiB) of memory used by the task. If using the EC2 launch type, this field is optional and any value can be used. If using the Fargate launch type, this field is required and you must use one of the following values, which determines your range of valid values for the cpu parameter: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25 vCPU) 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values: 512 (.5 vCPU) 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU) Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available cpu values: 2048 (2 vCPU) Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU) Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) - Available cpu values: 8192 (8 vCPU) Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) - Available cpu values: 16384 (16 vCPU) Default: - Memory used by task is not specified.
         :param network_mode: The networking mode to use for the containers in the task. On Fargate, the only supported networking mode is AwsVpc. Default: - NetworkMode.Bridge for EC2 & External tasks, AwsVpc for Fargate tasks.
-        :param pid_mode: The process namespace to use for the containers in the task. Not supported in Fargate and Windows containers. Default: - PidMode used by the task is not specified
+        :param pid_mode: The process namespace to use for the containers in the task. Only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version 1.4.0 or later (Linux). Not supported in Windows containers. Default: - PidMode used by the task is not specified
         :param placement_constraints: The placement constraints to use for tasks in the service. You can specify a maximum of 10 constraints per task (this limit includes constraints in the task definition and those specified at run time). Not supported in Fargate. Default: - No placement constraints.
         :param runtime_platform: The operating system that your task definitions are running on. A runtimePlatform is supported only for tasks using the Fargate launch type. Default: - Undefined.
 
@@ -35922,7 +36231,9 @@ class TaskDefinitionProps(CommonTaskDefinitionProps):
     def pid_mode(self) -> typing.Optional[PidMode]:
         '''The process namespace to use for the containers in the task.
 
-        Not supported in Fargate and Windows containers.
+        Only supported for tasks that are hosted on AWS Fargate if the tasks
+        are using platform version 1.4.0 or later (Linux).
+        Not supported in Windows containers.
 
         :default: - PidMode used by the task is not specified
         '''
@@ -39318,7 +39629,7 @@ class Ec2TaskDefinition(
         :param inference_accelerators: The inference accelerators to use for the containers in the task. Not supported in Fargate. Default: - No inference accelerators.
         :param ipc_mode: The IPC resource namespace to use for the containers in the task. Not supported in Fargate and Windows containers. Default: - IpcMode used by the task is not specified
         :param network_mode: The Docker networking mode to use for the containers in the task. The valid values are NONE, BRIDGE, AWS_VPC, and HOST. Default: - NetworkMode.BRIDGE for EC2 tasks, AWS_VPC for Fargate tasks.
-        :param pid_mode: The process namespace to use for the containers in the task. Not supported in Fargate and Windows containers. Default: - PidMode used by the task is not specified
+        :param pid_mode: The process namespace to use for the containers in the task. Not supported in Windows containers. Default: - PidMode used by the task is not specified
         :param placement_constraints: An array of placement constraint objects to use for the task. You can specify a maximum of 10 constraints per task (this limit includes constraints in the task definition and those specified at run time). Default: - No placement constraints.
         :param execution_role: The name of the IAM task execution role that grants the ECS agent permission to call AWS APIs on your behalf. The role will be used to retrieve container images from ECR and create CloudWatch log groups. Default: - An execution role will be automatically created if you use ECR images in your task definition.
         :param family: The name of a family that this task definition is registered to. A family groups multiple versions of a task definition. Default: - Automatically generated name.
@@ -40182,6 +40493,7 @@ class FargateTaskDefinition(
         cpu: typing.Optional[jsii.Number] = None,
         ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
+        pid_mode: typing.Optional[PidMode] = None,
         runtime_platform: typing.Optional[typing.Union[RuntimePlatform, typing.Dict[builtins.str, typing.Any]]] = None,
         execution_role: typing.Optional[_IRole_235f5d8e] = None,
         family: typing.Optional[builtins.str] = None,
@@ -40196,6 +40508,7 @@ class FargateTaskDefinition(
         :param cpu: The number of cpu units used by the task. For tasks using the Fargate launch type, this field is required and you must use one of the following values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) 512 (.5 vCPU) - Available memory values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) 1024 (1 vCPU) - Available memory values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) 2048 (2 vCPU) - Available memory values: Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) 4096 (4 vCPU) - Available memory values: Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) 8192 (8 vCPU) - Available memory values: Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) 16384 (16 vCPU) - Available memory values: Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) Default: 256
         :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The maximum supported value is 200 GiB. NOTE: This parameter is only supported for tasks hosted on AWS Fargate using platform version 1.4.0 or later. Default: 20
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. For tasks using the Fargate launch type, this field is required and you must use one of the following values, which determines your range of valid values for the cpu parameter: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25 vCPU) 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values: 512 (.5 vCPU) 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU) Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available cpu values: 2048 (2 vCPU) Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU) Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) - Available cpu values: 8192 (8 vCPU) Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) - Available cpu values: 16384 (16 vCPU) Default: 512
+        :param pid_mode: The process namespace to use for the containers in the task. Only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version 1.4.0 or later (Linux). Not supported in Windows containers. Default: - PidMode used by the task is not specified
         :param runtime_platform: The operating system that your task definitions are running on. A runtimePlatform is supported only for tasks using the Fargate launch type. Default: - Undefined.
         :param execution_role: The name of the IAM task execution role that grants the ECS agent permission to call AWS APIs on your behalf. The role will be used to retrieve container images from ECR and create CloudWatch log groups. Default: - An execution role will be automatically created if you use ECR images in your task definition.
         :param family: The name of a family that this task definition is registered to. A family groups multiple versions of a task definition. Default: - Automatically generated name.
@@ -40211,6 +40524,7 @@ class FargateTaskDefinition(
             cpu=cpu,
             ephemeral_storage_gib=ephemeral_storage_gib,
             memory_limit_mib=memory_limit_mib,
+            pid_mode=pid_mode,
             runtime_platform=runtime_platform,
             execution_role=execution_role,
             family=family,
@@ -41747,6 +42061,23 @@ def _typecheckingstub__fdddb0d48923d3583475a8b34d0a6079606e57e6de57c6ca22978691d
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__f5e3b577af4628d7fb3319bd51694790c1cd0a62eae308c830c9dccee5d8ca1d(
+    *,
+    credentials_parameter: builtins.str,
+    domain: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__ef74e299375c10c97a6bb4455d35f14ea7c21e10b612cd0fb3958fd12601168f(
+    *,
+    file_system_id: builtins.str,
+    root_directory: builtins.str,
+    authorization_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskDefinition.FSxAuthorizationConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__6a1cd84d62e34083a37bc4c25d849ac547dacc5fe8a4db04170cf83e3cd1e9d3(
     *,
     options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Mapping[builtins.str, builtins.str]]] = None,
@@ -41935,6 +42266,7 @@ def _typecheckingstub__0b8eeaf561ff6334fbacca7f706104a9a5e10a366526af78d2a6b7173
     configured_at_launch: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     docker_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskDefinition.DockerVolumeConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     efs_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskDefinition.EFSVolumeConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    f_sx_windows_file_server_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     host: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskDefinition.HostVolumePropertiesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     name: typing.Optional[builtins.str] = None,
 ) -> None:
@@ -42242,6 +42574,13 @@ def _typecheckingstub__eaae7939e3070d8ba1648d9807145fdc669cf24de157aecd86b7964eb
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__de228f279641285922f39a7d85fc376918c045b328369fc61474e4677857075b(
+    name: builtins.str,
+    value: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__bd4e688cf16aa827db1051180c9efb1f81ef776616c928afb625422d094bcca6(
     name: builtins.str,
     value: builtins.str,
@@ -42924,6 +43263,7 @@ def _typecheckingstub__da4d0b48fbacde979163c93d7fd8d5697220f750806124aabb65f0c3d
     cpu: typing.Optional[jsii.Number] = None,
     ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
+    pid_mode: typing.Optional[PidMode] = None,
     runtime_platform: typing.Optional[typing.Union[RuntimePlatform, typing.Dict[builtins.str, typing.Any]]] = None,
 ) -> None:
     """Type checking stubs"""
@@ -44659,6 +44999,7 @@ def _typecheckingstub__d6eac52d828f2df0ab5e16014f889cf23534875319ae4b479cd554d53
     cpu: typing.Optional[jsii.Number] = None,
     ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
+    pid_mode: typing.Optional[PidMode] = None,
     runtime_platform: typing.Optional[typing.Union[RuntimePlatform, typing.Dict[builtins.str, typing.Any]]] = None,
     execution_role: typing.Optional[_IRole_235f5d8e] = None,
     family: typing.Optional[builtins.str] = None,