aws-cdk-lib 2.138.0__py3-none-any.whl → 2.139.1__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/)
@@ -19340,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.
@@ -23314,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
@@ -23456,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
         '''
@@ -25980,6 +26029,7 @@ class FargateTaskDefinitionAttributes(CommonTaskDefinitionAttributes):
         "cpu": "cpu",
         "ephemeral_storage_gib": "ephemeralStorageGiB",
         "memory_limit_mib": "memoryLimitMiB",
+        "pid_mode": "pidMode",
         "runtime_platform": "runtimePlatform",
     },
 )
@@ -25995,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.
@@ -26007,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):
@@ -26041,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:
@@ -26059,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
 
@@ -26180,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.
@@ -31347,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.'''
@@ -35115,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.
@@ -35685,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]:
@@ -35891,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.
 
@@ -36143,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
         '''
@@ -39539,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.
@@ -40403,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,
@@ -40417,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.
@@ -40432,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,
@@ -42481,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,
@@ -43163,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"""
@@ -44898,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,