aws-cdk-lib 2.129.0__py3-none-any.whl → 2.131.0__py3-none-any.whl

aws_cdk/aws_ecs_patterns/__init__.py

@@ -1091,6 +1091,35 @@ scheduled_fargate_task = ecs_patterns.ScheduledFargateTask(self, "ScheduledFarga
     ]
 )
 ```
+
+### Use custom ephemeral storage for ECS Fargate tasks
+
+You can pass a custom ephemeral storage (21GiB - 200GiB) to ECS Fargate tasks on Fargate Platform Version 1.4.0 or later.
+
+```python
+vpc = ec2.Vpc(self, "Vpc", max_azs=2, restrict_default_security_group=False)
+cluster = ecs.Cluster(self, "FargateCluster", vpc=vpc)
+
+application_load_balanced_fargate_service = ecs_patterns.ApplicationLoadBalancedFargateService(self, "ALBFargateServiceWithCustomEphemeralStorage",
+    cluster=cluster,
+    memory_limit_mi_b=1024,
+    cpu=512,
+    ephemeral_storage_gi_b=21,
+    task_image_options=ecsPatterns.ApplicationLoadBalancedTaskImageOptions(
+        image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")
+    )
+)
+
+network_load_balanced_fargate_service = ecs_patterns.NetworkLoadBalancedFargateService(self, "NLBFargateServiceWithCustomEphemeralStorage",
+    cluster=cluster,
+    memory_limit_mi_b=1024,
+    cpu=512,
+    ephemeral_storage_gi_b=200,
+    task_image_options=ecsPatterns.NetworkLoadBalancedTaskImageOptions(
+        image=ecs.ContainerImage.from_registry("amazon/amazon-ecs-sample")
+    )
+)
+```
 '''
 import abc
 import builtins
@@ -3591,6 +3620,7 @@ class ApplicationTargetProps:
     jsii_struct_bases=[],
     name_mapping={
         "cpu": "cpu",
+        "ephemeral_storage_gib": "ephemeralStorageGiB",
         "memory_limit_mib": "memoryLimitMiB",
         "platform_version": "platformVersion",
         "runtime_platform": "runtimePlatform",
@@ -3602,6 +3632,7 @@ class FargateServiceBaseProps:
         self,
         *,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -3609,6 +3640,7 @@ class FargateServiceBaseProps:
     ) -> None:
         '''
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -3629,6 +3661,7 @@ class FargateServiceBaseProps:
             
             fargate_service_base_props = ecs_patterns.FargateServiceBaseProps(
                 cpu=123,
+                ephemeral_storage_gi_b=123,
                 memory_limit_mi_b=123,
                 platform_version=ecs.FargatePlatformVersion.LATEST,
                 runtime_platform=ecs.RuntimePlatform(
@@ -3643,6 +3676,7 @@ class FargateServiceBaseProps:
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__be57306e3f86de996d7bf3938a60ebd3f8fd4e38da3fbde2b8a23f728f3a7ef7)
             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 platform_version", value=platform_version, expected_type=type_hints["platform_version"])
             check_type(argname="argument runtime_platform", value=runtime_platform, expected_type=type_hints["runtime_platform"])
@@ -3650,6 +3684,8 @@ class FargateServiceBaseProps:
         self._values: typing.Dict[builtins.str, typing.Any] = {}
         if cpu is not None:
             self._values["cpu"] = cpu
+        if ephemeral_storage_gib is not None:
+            self._values["ephemeral_storage_gib"] = ephemeral_storage_gib
         if memory_limit_mib is not None:
             self._values["memory_limit_mib"] = memory_limit_mib
         if platform_version is not None:
@@ -3686,6 +3722,19 @@ class FargateServiceBaseProps:
         result = self._values.get("cpu")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def ephemeral_storage_gib(self) -> typing.Optional[jsii.Number]:
+        '''The amount (in GiB) of ephemeral storage to be allocated to the task.
+
+        The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB.
+
+        Only supported in Fargate platform version 1.4.0 or later.
+
+        :default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
+        '''
+        result = self._values.get("ephemeral_storage_gib")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def memory_limit_mib(self) -> typing.Optional[jsii.Number]:
         '''The amount (in MiB) of memory used by the task.
@@ -8103,6 +8152,7 @@ class ApplicationLoadBalancedFargateService(
         task_image_options: typing.Optional[typing.Union[ApplicationLoadBalancedTaskImageOptions, typing.Dict[builtins.str, typing.Any]]] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -8147,6 +8197,7 @@ class ApplicationLoadBalancedFargateService(
         :param task_image_options: The properties required to create a new task definition. TaskDefinition or TaskImageOptions must be specified, but not both. Default: none
         :param vpc: The VPC where the container instances will be launched or the elastic network interfaces (ENIs) will be deployed. If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster. Default: - uses the VPC defined in the cluster or creates a new VPC.
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -8192,6 +8243,7 @@ class ApplicationLoadBalancedFargateService(
             task_image_options=task_image_options,
             vpc=vpc,
             cpu=cpu,
+            ephemeral_storage_gib=ephemeral_storage_gib,
             memory_limit_mib=memory_limit_mib,
             platform_version=platform_version,
             runtime_platform=runtime_platform,
@@ -8256,6 +8308,7 @@ class ApplicationLoadBalancedFargateService(
         "task_image_options": "taskImageOptions",
         "vpc": "vpc",
         "cpu": "cpu",
+        "ephemeral_storage_gib": "ephemeralStorageGiB",
         "memory_limit_mib": "memoryLimitMiB",
         "platform_version": "platformVersion",
         "runtime_platform": "runtimePlatform",
@@ -8304,6 +8357,7 @@ class ApplicationLoadBalancedFargateServiceProps(
         task_image_options: typing.Optional[typing.Union[ApplicationLoadBalancedTaskImageOptions, typing.Dict[builtins.str, typing.Any]]] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -8346,6 +8400,7 @@ class ApplicationLoadBalancedFargateServiceProps(
         :param task_image_options: The properties required to create a new task definition. TaskDefinition or TaskImageOptions must be specified, but not both. Default: none
         :param vpc: The VPC where the container instances will be launched or the elastic network interfaces (ENIs) will be deployed. If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster. Default: - uses the VPC defined in the cluster or creates a new VPC.
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -8422,6 +8477,7 @@ class ApplicationLoadBalancedFargateServiceProps(
             check_type(argname="argument task_image_options", value=task_image_options, expected_type=type_hints["task_image_options"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
             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 platform_version", value=platform_version, expected_type=type_hints["platform_version"])
             check_type(argname="argument runtime_platform", value=runtime_platform, expected_type=type_hints["runtime_platform"])
@@ -8493,6 +8549,8 @@ class ApplicationLoadBalancedFargateServiceProps(
             self._values["vpc"] = vpc
         if cpu is not None:
             self._values["cpu"] = cpu
+        if ephemeral_storage_gib is not None:
+            self._values["ephemeral_storage_gib"] = ephemeral_storage_gib
         if memory_limit_mib is not None:
             self._values["memory_limit_mib"] = memory_limit_mib
         if platform_version is not None:
@@ -8863,6 +8921,19 @@ class ApplicationLoadBalancedFargateServiceProps(
         result = self._values.get("cpu")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def ephemeral_storage_gib(self) -> typing.Optional[jsii.Number]:
+        '''The amount (in GiB) of ephemeral storage to be allocated to the task.
+
+        The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB.
+
+        Only supported in Fargate platform version 1.4.0 or later.
+
+        :default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
+        '''
+        result = self._values.get("ephemeral_storage_gib")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def memory_limit_mib(self) -> typing.Optional[jsii.Number]:
         '''The amount (in MiB) of memory used by the task.
@@ -9571,6 +9642,7 @@ class ApplicationMultipleTargetGroupsFargateService(
         task_image_options: typing.Optional[typing.Union[ApplicationLoadBalancedTaskImageProps, typing.Dict[builtins.str, typing.Any]]] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -9594,6 +9666,7 @@ class ApplicationMultipleTargetGroupsFargateService(
         :param task_image_options: The properties required to create a new task definition. Only one of TaskDefinition or TaskImageOptions must be specified. Default: none
         :param vpc: The VPC where the container instances will be launched or the elastic network interfaces (ENIs) will be deployed. If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster. Default: - uses the VPC defined in the cluster or creates a new VPC.
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -9618,6 +9691,7 @@ class ApplicationMultipleTargetGroupsFargateService(
             task_image_options=task_image_options,
             vpc=vpc,
             cpu=cpu,
+            ephemeral_storage_gib=ephemeral_storage_gib,
             memory_limit_mib=memory_limit_mib,
             platform_version=platform_version,
             runtime_platform=runtime_platform,
@@ -9675,6 +9749,7 @@ class ApplicationMultipleTargetGroupsFargateService(
         "task_image_options": "taskImageOptions",
         "vpc": "vpc",
         "cpu": "cpu",
+        "ephemeral_storage_gib": "ephemeralStorageGiB",
         "memory_limit_mib": "memoryLimitMiB",
         "platform_version": "platformVersion",
         "runtime_platform": "runtimePlatform",
@@ -9702,6 +9777,7 @@ class ApplicationMultipleTargetGroupsFargateServiceProps(
         task_image_options: typing.Optional[typing.Union[ApplicationLoadBalancedTaskImageProps, typing.Dict[builtins.str, typing.Any]]] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -9723,6 +9799,7 @@ class ApplicationMultipleTargetGroupsFargateServiceProps(
         :param task_image_options: The properties required to create a new task definition. Only one of TaskDefinition or TaskImageOptions must be specified. Default: none
         :param vpc: The VPC where the container instances will be launched or the elastic network interfaces (ENIs) will be deployed. If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster. Default: - uses the VPC defined in the cluster or creates a new VPC.
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -9814,6 +9891,7 @@ class ApplicationMultipleTargetGroupsFargateServiceProps(
             check_type(argname="argument task_image_options", value=task_image_options, expected_type=type_hints["task_image_options"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
             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 platform_version", value=platform_version, expected_type=type_hints["platform_version"])
             check_type(argname="argument runtime_platform", value=runtime_platform, expected_type=type_hints["runtime_platform"])
@@ -9846,6 +9924,8 @@ class ApplicationMultipleTargetGroupsFargateServiceProps(
             self._values["vpc"] = vpc
         if cpu is not None:
             self._values["cpu"] = cpu
+        if ephemeral_storage_gib is not None:
+            self._values["ephemeral_storage_gib"] = ephemeral_storage_gib
         if memory_limit_mib is not None:
             self._values["memory_limit_mib"] = memory_limit_mib
         if platform_version is not None:
@@ -10011,6 +10091,19 @@ class ApplicationMultipleTargetGroupsFargateServiceProps(
         result = self._values.get("cpu")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def ephemeral_storage_gib(self) -> typing.Optional[jsii.Number]:
+        '''The amount (in GiB) of ephemeral storage to be allocated to the task.
+
+        The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB.
+
+        Only supported in Fargate platform version 1.4.0 or later.
+
+        :default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
+        '''
+        result = self._values.get("ephemeral_storage_gib")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def memory_limit_mib(self) -> typing.Optional[jsii.Number]:
         '''The amount (in MiB) of memory used by the task.
@@ -10820,6 +10913,7 @@ class NetworkLoadBalancedFargateService(
         task_image_options: typing.Optional[typing.Union[NetworkLoadBalancedTaskImageOptions, typing.Dict[builtins.str, typing.Any]]] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -10853,6 +10947,7 @@ class NetworkLoadBalancedFargateService(
         :param task_image_options: The properties required to create a new task definition. One of taskImageOptions or taskDefinition must be specified. Default: - none
         :param vpc: The VPC where the container instances will be launched or the elastic network interfaces (ENIs) will be deployed. If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster. Default: - uses the VPC defined in the cluster or creates a new VPC.
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -10887,6 +10982,7 @@ class NetworkLoadBalancedFargateService(
             task_image_options=task_image_options,
             vpc=vpc,
             cpu=cpu,
+            ephemeral_storage_gib=ephemeral_storage_gib,
             memory_limit_mib=memory_limit_mib,
             platform_version=platform_version,
             runtime_platform=runtime_platform,
@@ -10939,6 +11035,7 @@ class NetworkLoadBalancedFargateService(
         "task_image_options": "taskImageOptions",
         "vpc": "vpc",
         "cpu": "cpu",
+        "ephemeral_storage_gib": "ephemeralStorageGiB",
         "memory_limit_mib": "memoryLimitMiB",
         "platform_version": "platformVersion",
         "runtime_platform": "runtimePlatform",
@@ -10976,6 +11073,7 @@ class NetworkLoadBalancedFargateServiceProps(
         task_image_options: typing.Optional[typing.Union[NetworkLoadBalancedTaskImageOptions, typing.Dict[builtins.str, typing.Any]]] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -11007,6 +11105,7 @@ class NetworkLoadBalancedFargateServiceProps(
         :param task_image_options: The properties required to create a new task definition. One of taskImageOptions or taskDefinition must be specified. Default: - none
         :param vpc: The VPC where the container instances will be launched or the elastic network interfaces (ENIs) will be deployed. If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster. Default: - uses the VPC defined in the cluster or creates a new VPC.
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -11065,6 +11164,7 @@ class NetworkLoadBalancedFargateServiceProps(
             check_type(argname="argument task_image_options", value=task_image_options, expected_type=type_hints["task_image_options"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
             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 platform_version", value=platform_version, expected_type=type_hints["platform_version"])
             check_type(argname="argument runtime_platform", value=runtime_platform, expected_type=type_hints["runtime_platform"])
@@ -11116,6 +11216,8 @@ class NetworkLoadBalancedFargateServiceProps(
             self._values["vpc"] = vpc
         if cpu is not None:
             self._values["cpu"] = cpu
+        if ephemeral_storage_gib is not None:
+            self._values["ephemeral_storage_gib"] = ephemeral_storage_gib
         if memory_limit_mib is not None:
             self._values["memory_limit_mib"] = memory_limit_mib
         if platform_version is not None:
@@ -11379,6 +11481,19 @@ class NetworkLoadBalancedFargateServiceProps(
         result = self._values.get("cpu")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def ephemeral_storage_gib(self) -> typing.Optional[jsii.Number]:
+        '''The amount (in GiB) of ephemeral storage to be allocated to the task.
+
+        The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB.
+
+        Only supported in Fargate platform version 1.4.0 or later.
+
+        :default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
+        '''
+        result = self._values.get("ephemeral_storage_gib")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def memory_limit_mib(self) -> typing.Optional[jsii.Number]:
         '''The amount (in MiB) of memory used by the task.
@@ -12066,6 +12181,7 @@ class NetworkMultipleTargetGroupsFargateService(
         task_image_options: typing.Optional[typing.Union[NetworkLoadBalancedTaskImageProps, typing.Dict[builtins.str, typing.Any]]] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -12089,6 +12205,7 @@ class NetworkMultipleTargetGroupsFargateService(
         :param task_image_options: The properties required to create a new task definition. Only one of TaskDefinition or TaskImageOptions must be specified. Default: - none
         :param vpc: The VPC where the container instances will be launched or the elastic network interfaces (ENIs) will be deployed. If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster. Default: - uses the VPC defined in the cluster or creates a new VPC.
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -12113,6 +12230,7 @@ class NetworkMultipleTargetGroupsFargateService(
             task_image_options=task_image_options,
             vpc=vpc,
             cpu=cpu,
+            ephemeral_storage_gib=ephemeral_storage_gib,
             memory_limit_mib=memory_limit_mib,
             platform_version=platform_version,
             runtime_platform=runtime_platform,
@@ -12170,6 +12288,7 @@ class NetworkMultipleTargetGroupsFargateService(
         "task_image_options": "taskImageOptions",
         "vpc": "vpc",
         "cpu": "cpu",
+        "ephemeral_storage_gib": "ephemeralStorageGiB",
         "memory_limit_mib": "memoryLimitMiB",
         "platform_version": "platformVersion",
         "runtime_platform": "runtimePlatform",
@@ -12197,6 +12316,7 @@ class NetworkMultipleTargetGroupsFargateServiceProps(
         task_image_options: typing.Optional[typing.Union[NetworkLoadBalancedTaskImageProps, typing.Dict[builtins.str, typing.Any]]] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -12218,6 +12338,7 @@ class NetworkMultipleTargetGroupsFargateServiceProps(
         :param task_image_options: The properties required to create a new task definition. Only one of TaskDefinition or TaskImageOptions must be specified. Default: - none
         :param vpc: The VPC where the container instances will be launched or the elastic network interfaces (ENIs) will be deployed. If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster. Default: - uses the VPC defined in the cluster or creates a new VPC.
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -12282,6 +12403,7 @@ class NetworkMultipleTargetGroupsFargateServiceProps(
             check_type(argname="argument task_image_options", value=task_image_options, expected_type=type_hints["task_image_options"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
             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 platform_version", value=platform_version, expected_type=type_hints["platform_version"])
             check_type(argname="argument runtime_platform", value=runtime_platform, expected_type=type_hints["runtime_platform"])
@@ -12314,6 +12436,8 @@ class NetworkMultipleTargetGroupsFargateServiceProps(
             self._values["vpc"] = vpc
         if cpu is not None:
             self._values["cpu"] = cpu
+        if ephemeral_storage_gib is not None:
+            self._values["ephemeral_storage_gib"] = ephemeral_storage_gib
         if memory_limit_mib is not None:
             self._values["memory_limit_mib"] = memory_limit_mib
         if platform_version is not None:
@@ -12477,6 +12601,19 @@ class NetworkMultipleTargetGroupsFargateServiceProps(
         result = self._values.get("cpu")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def ephemeral_storage_gib(self) -> typing.Optional[jsii.Number]:
+        '''The amount (in GiB) of ephemeral storage to be allocated to the task.
+
+        The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB.
+
+        Only supported in Fargate platform version 1.4.0 or later.
+
+        :default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
+        '''
+        result = self._values.get("ephemeral_storage_gib")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def memory_limit_mib(self) -> typing.Optional[jsii.Number]:
         '''The amount (in MiB) of memory used by the task.
@@ -13468,6 +13605,7 @@ class QueueProcessingFargateService(
         visibility_timeout: typing.Optional[_Duration_4839e8c3] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -13511,6 +13649,7 @@ class QueueProcessingFargateService(
         :param visibility_timeout: Timeout of processing a single message. After dequeuing, the processor has this much time to handle the message and delete it from the queue before it becomes visible again for dequeueing by another processor. Values must be between 0 and (12 hours). If the queue construct is specified, visibilityTimeout should be omitted. Default: Duration.seconds(30)
         :param vpc: The VPC where the container instances will be launched or the elastic network interfaces (ENIs) will be deployed. If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster. Default: - uses the VPC defined in the cluster or creates a new VPC.
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -13555,6 +13694,7 @@ class QueueProcessingFargateService(
             visibility_timeout=visibility_timeout,
             vpc=vpc,
             cpu=cpu,
+            ephemeral_storage_gib=ephemeral_storage_gib,
             memory_limit_mib=memory_limit_mib,
             platform_version=platform_version,
             runtime_platform=runtime_platform,
@@ -13609,6 +13749,7 @@ class QueueProcessingFargateService(
         "visibility_timeout": "visibilityTimeout",
         "vpc": "vpc",
         "cpu": "cpu",
+        "ephemeral_storage_gib": "ephemeralStorageGiB",
         "memory_limit_mib": "memoryLimitMiB",
         "platform_version": "platformVersion",
         "runtime_platform": "runtimePlatform",
@@ -13656,6 +13797,7 @@ class QueueProcessingFargateServiceProps(
         visibility_timeout: typing.Optional[_Duration_4839e8c3] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -13697,6 +13839,7 @@ class QueueProcessingFargateServiceProps(
         :param visibility_timeout: Timeout of processing a single message. After dequeuing, the processor has this much time to handle the message and delete it from the queue before it becomes visible again for dequeueing by another processor. Values must be between 0 and (12 hours). If the queue construct is specified, visibilityTimeout should be omitted. Default: Duration.seconds(30)
         :param vpc: The VPC where the container instances will be launched or the elastic network interfaces (ENIs) will be deployed. If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster. Default: - uses the VPC defined in the cluster or creates a new VPC.
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -13770,6 +13913,7 @@ class QueueProcessingFargateServiceProps(
             check_type(argname="argument visibility_timeout", value=visibility_timeout, expected_type=type_hints["visibility_timeout"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
             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 platform_version", value=platform_version, expected_type=type_hints["platform_version"])
             check_type(argname="argument runtime_platform", value=runtime_platform, expected_type=type_hints["runtime_platform"])
@@ -13838,6 +13982,8 @@ class QueueProcessingFargateServiceProps(
             self._values["vpc"] = vpc
         if cpu is not None:
             self._values["cpu"] = cpu
+        if ephemeral_storage_gib is not None:
+            self._values["ephemeral_storage_gib"] = ephemeral_storage_gib
         if memory_limit_mib is not None:
             self._values["memory_limit_mib"] = memory_limit_mib
         if platform_version is not None:
@@ -14191,6 +14337,19 @@ class QueueProcessingFargateServiceProps(
         result = self._values.get("cpu")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def ephemeral_storage_gib(self) -> typing.Optional[jsii.Number]:
+        '''The amount (in GiB) of ephemeral storage to be allocated to the task.
+
+        The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB.
+
+        Only supported in Fargate platform version 1.4.0 or later.
+
+        :default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
+        '''
+        result = self._values.get("ephemeral_storage_gib")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def memory_limit_mib(self) -> typing.Optional[jsii.Number]:
         '''The amount (in MiB) of memory used by the task.
@@ -14906,6 +15065,7 @@ class ScheduledFargateTask(
         tags: typing.Optional[typing.Sequence[typing.Union[_Tag_dc8ac6d2, typing.Dict[builtins.str, typing.Any]]]] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -14928,6 +15088,7 @@ class ScheduledFargateTask(
         :param tags: The metadata that you apply to the task to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. Default: - No tags are applied to the task
         :param vpc: The VPC where the container instances will be launched or the elastic network interfaces (ENIs) will be deployed. If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster. Default: - uses the VPC defined in the cluster or creates a new VPC.
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -14951,6 +15112,7 @@ class ScheduledFargateTask(
             tags=tags,
             vpc=vpc,
             cpu=cpu,
+            ephemeral_storage_gib=ephemeral_storage_gib,
             memory_limit_mib=memory_limit_mib,
             platform_version=platform_version,
             runtime_platform=runtime_platform,
@@ -14982,6 +15144,7 @@ class ScheduledFargateTask(
         "log_driver": "logDriver",
         "secrets": "secrets",
         "cpu": "cpu",
+        "ephemeral_storage_gib": "ephemeralStorageGiB",
         "memory_limit_mib": "memoryLimitMiB",
         "platform_version": "platformVersion",
         "runtime_platform": "runtimePlatform",
@@ -15001,6 +15164,7 @@ class ScheduledFargateTaskImageOptions(
         log_driver: typing.Optional[_LogDriver_393a21bb] = None,
         secrets: typing.Optional[typing.Mapping[builtins.str, _Secret_6be2f64f]] = None,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -15014,6 +15178,7 @@ class ScheduledFargateTaskImageOptions(
         :param log_driver: The log driver to use. Default: - AwsLogDriver if enableLogging is true
         :param secrets: The secret to expose to the container as an environment variable. Default: - No secret environment variables.
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -15049,6 +15214,7 @@ class ScheduledFargateTaskImageOptions(
             check_type(argname="argument log_driver", value=log_driver, expected_type=type_hints["log_driver"])
             check_type(argname="argument secrets", value=secrets, expected_type=type_hints["secrets"])
             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 platform_version", value=platform_version, expected_type=type_hints["platform_version"])
             check_type(argname="argument runtime_platform", value=runtime_platform, expected_type=type_hints["runtime_platform"])
@@ -15066,6 +15232,8 @@ class ScheduledFargateTaskImageOptions(
             self._values["secrets"] = secrets
         if cpu is not None:
             self._values["cpu"] = cpu
+        if ephemeral_storage_gib is not None:
+            self._values["ephemeral_storage_gib"] = ephemeral_storage_gib
         if memory_limit_mib is not None:
             self._values["memory_limit_mib"] = memory_limit_mib
         if platform_version is not None:
@@ -15156,6 +15324,19 @@ class ScheduledFargateTaskImageOptions(
         result = self._values.get("cpu")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def ephemeral_storage_gib(self) -> typing.Optional[jsii.Number]:
+        '''The amount (in GiB) of ephemeral storage to be allocated to the task.
+
+        The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB.
+
+        Only supported in Fargate platform version 1.4.0 or later.
+
+        :default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
+        '''
+        result = self._values.get("ephemeral_storage_gib")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def memory_limit_mib(self) -> typing.Optional[jsii.Number]:
         '''The amount (in MiB) of memory used by the task.
@@ -15244,6 +15425,7 @@ class ScheduledFargateTaskImageOptions(
         "tags": "tags",
         "vpc": "vpc",
         "cpu": "cpu",
+        "ephemeral_storage_gib": "ephemeralStorageGiB",
         "memory_limit_mib": "memoryLimitMiB",
         "platform_version": "platformVersion",
         "runtime_platform": "runtimePlatform",
@@ -15267,6 +15449,7 @@ class ScheduledFargateTaskProps(ScheduledTaskBaseProps, FargateServiceBaseProps)
         tags: typing.Optional[typing.Sequence[typing.Union[_Tag_dc8ac6d2, typing.Dict[builtins.str, typing.Any]]]] = None,
         vpc: typing.Optional[_IVpc_f30d5663] = None,
         cpu: typing.Optional[jsii.Number] = None,
+        ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
         memory_limit_mib: typing.Optional[jsii.Number] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -15287,6 +15470,7 @@ class ScheduledFargateTaskProps(ScheduledTaskBaseProps, FargateServiceBaseProps)
         :param tags: The metadata that you apply to the task to help you categorize and organize them. Each tag consists of a key and an optional value, both of which you define. Default: - No tags are applied to the task
         :param vpc: The VPC where the container instances will be launched or the elastic network interfaces (ENIs) will be deployed. If a vpc is specified, the cluster construct should be omitted. Alternatively, you can omit both vpc and cluster. Default: - uses the VPC defined in the cluster or creates a new VPC.
         :param cpu: The number of cpu units used by the task. Valid values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 0.5GB, 1GB, 2GB 512 (.5 vCPU) - Available memory values: 1GB, 2GB, 3GB, 4GB 1024 (1 vCPU) - Available memory values: 2GB, 3GB, 4GB, 5GB, 6GB, 7GB, 8GB 2048 (2 vCPU) - Available memory values: Between 4GB and 16GB in 1GB increments 4096 (4 vCPU) - Available memory values: Between 8GB and 30GB in 1GB increments 8192 (8 vCPU) - Available memory values: Between 16GB and 60GB in 4GB increments 16384 (16 vCPU) - Available memory values: Between 32GB and 120GB in 8GB increments This default is set in the underlying FargateTaskDefinition construct. Default: 256
+        :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB. Only supported in Fargate platform version 1.4.0 or later. Default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. 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) This default is set in the underlying FargateTaskDefinition construct. Default: 512
         :param platform_version: The platform version on which to run your service. If one is not specified, the LATEST platform version is used by default. For more information, see `AWS Fargate Platform Versions <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/platform_versions.html>`_ in the Amazon Elastic Container Service Developer Guide. Default: Latest
         :param runtime_platform: The runtime platform of the task definition. Default: - If the property is undefined, ``operatingSystemFamily`` is LINUX and ``cpuArchitecture`` is X86_64
@@ -15335,6 +15519,7 @@ class ScheduledFargateTaskProps(ScheduledTaskBaseProps, FargateServiceBaseProps)
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
             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 platform_version", value=platform_version, expected_type=type_hints["platform_version"])
             check_type(argname="argument runtime_platform", value=runtime_platform, expected_type=type_hints["runtime_platform"])
@@ -15364,6 +15549,8 @@ class ScheduledFargateTaskProps(ScheduledTaskBaseProps, FargateServiceBaseProps)
             self._values["vpc"] = vpc
         if cpu is not None:
             self._values["cpu"] = cpu
+        if ephemeral_storage_gib is not None:
+            self._values["ephemeral_storage_gib"] = ephemeral_storage_gib
         if memory_limit_mib is not None:
             self._values["memory_limit_mib"] = memory_limit_mib
         if platform_version is not None:
@@ -15510,6 +15697,19 @@ class ScheduledFargateTaskProps(ScheduledTaskBaseProps, FargateServiceBaseProps)
         result = self._values.get("cpu")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def ephemeral_storage_gib(self) -> typing.Optional[jsii.Number]:
+        '''The amount (in GiB) of ephemeral storage to be allocated to the task.
+
+        The minimum supported value is ``21`` GiB and the maximum supported value is ``200`` GiB.
+
+        Only supported in Fargate platform version 1.4.0 or later.
+
+        :default: Undefined, in which case, the task will receive 20GiB ephemeral storage.
+        '''
+        result = self._values.get("ephemeral_storage_gib")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
     @builtins.property
     def memory_limit_mib(self) -> typing.Optional[jsii.Number]:
         '''The amount (in MiB) of memory used by the task.
@@ -15913,6 +16113,7 @@ def _typecheckingstub__71d73c2659fa1f33af684ebf8ddbca1ec7e44bab1dd25721962f3dd2e
 def _typecheckingstub__be57306e3f86de996d7bf3938a60ebd3f8fd4e38da3fbde2b8a23f728f3a7ef7(
     *,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -16433,6 +16634,7 @@ def _typecheckingstub__52e4707f036e6b5ab8a12a1dd88ad78656d9ef102eb7d04caef957d69
     task_image_options: typing.Optional[typing.Union[ApplicationLoadBalancedTaskImageOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -16474,6 +16676,7 @@ def _typecheckingstub__cdcb8bd483faaddad588ad37d4527fa1a0028fc2307a21fc3690044a0
     task_image_options: typing.Optional[typing.Union[ApplicationLoadBalancedTaskImageOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -16554,6 +16757,7 @@ def _typecheckingstub__21d949e97492f7aeebbdedfda795498da7248be2cc48f01eb45a80ef9
     task_image_options: typing.Optional[typing.Union[ApplicationLoadBalancedTaskImageProps, typing.Dict[builtins.str, typing.Any]]] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -16577,6 +16781,7 @@ def _typecheckingstub__73b52f632d3e26b256f0a917de129f36c8484b906c75d27af3ae333c6
     task_image_options: typing.Optional[typing.Union[ApplicationLoadBalancedTaskImageProps, typing.Dict[builtins.str, typing.Any]]] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -16682,6 +16887,7 @@ def _typecheckingstub__633773eb8c5e71fd9d413b4600a4460d67ddbbf4f0d1ad414b05ab210
     task_image_options: typing.Optional[typing.Union[NetworkLoadBalancedTaskImageOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -16714,6 +16920,7 @@ def _typecheckingstub__883e3ba9ce3759b7fedc824d271d29edacc0ccdd564e943054039dc84
     task_image_options: typing.Optional[typing.Union[NetworkLoadBalancedTaskImageOptions, typing.Dict[builtins.str, typing.Any]]] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -16792,6 +16999,7 @@ def _typecheckingstub__d0896ef010a141982cad4e6363ddf5474e1d63a5c38dc712f84a1d13e
     task_image_options: typing.Optional[typing.Union[NetworkLoadBalancedTaskImageProps, typing.Dict[builtins.str, typing.Any]]] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -16815,6 +17023,7 @@ def _typecheckingstub__052b2be34bb887cde358099c21efe7f3e968827a5a4e4c975e35f96da
     task_image_options: typing.Optional[typing.Union[NetworkLoadBalancedTaskImageProps, typing.Dict[builtins.str, typing.Any]]] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -16946,6 +17155,7 @@ def _typecheckingstub__f7f1cc7ffec4414918cb71e7371c364ad046987205ab7eb0cbe7ad6fc
     visibility_timeout: typing.Optional[_Duration_4839e8c3] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -16985,6 +17195,7 @@ def _typecheckingstub__9959b47db027250927e99f3cbc475109465e4e426a52383adb8d29f22
     visibility_timeout: typing.Optional[_Duration_4839e8c3] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -17067,6 +17278,7 @@ def _typecheckingstub__15eedf0b4c0341f211d295e779c0f7ee21fa9c4c54661f567547054da
     tags: typing.Optional[typing.Sequence[typing.Union[_Tag_dc8ac6d2, typing.Dict[builtins.str, typing.Any]]]] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -17083,6 +17295,7 @@ def _typecheckingstub__4a749e8e91135e4a7ff734b7c08ac37ec5bc550062036c75493dec950
     log_driver: typing.Optional[_LogDriver_393a21bb] = None,
     secrets: typing.Optional[typing.Mapping[builtins.str, _Secret_6be2f64f]] = None,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,
@@ -17104,6 +17317,7 @@ def _typecheckingstub__f90096eb899a3c06d73ca9750fbecb38041c3e8d6b078cc4e3353aafd
     tags: typing.Optional[typing.Sequence[typing.Union[_Tag_dc8ac6d2, typing.Dict[builtins.str, typing.Any]]]] = None,
     vpc: typing.Optional[_IVpc_f30d5663] = None,
     cpu: typing.Optional[jsii.Number] = None,
+    ephemeral_storage_gib: typing.Optional[jsii.Number] = None,
     memory_limit_mib: typing.Optional[jsii.Number] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     runtime_platform: typing.Optional[typing.Union[_RuntimePlatform_5ed98a9c, typing.Dict[builtins.str, typing.Any]]] = None,