aws-cdk-lib 2.178.1__py3-none-any.whl → 2.179.0__py3-none-any.whl

aws_cdk/aws_events_targets/__init__.py

@@ -558,6 +558,34 @@ rule.add_target(targets.EcsTask(
 ))
 ```
 
+### Overriding Values in the Task Definition
+
+You can override values in the task definition by setting the corresponding properties in the `EcsTaskProps`. All
+values in the [`TaskOverrides` API](https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_TaskOverride.html) are
+supported.
+
+```python
+import aws_cdk.aws_ecs as ecs
+
+# cluster: ecs.ICluster
+# task_definition: ecs.TaskDefinition
+
+
+rule = events.Rule(self, "Rule",
+    schedule=events.Schedule.rate(cdk.Duration.hours(1))
+)
+
+rule.add_target(targets.EcsTask(
+    cluster=cluster,
+    task_definition=task_definition,
+    task_count=1,
+
+    # Overrides the cpu and memory values in the task definition
+    cpu="512",
+    memory="512"
+))
+```
+
 ## Schedule a Redshift query (serverless or cluster)
 
 Use the `RedshiftQuery` target to schedule an Amazon Redshift Query.
@@ -1826,7 +1854,6 @@ class EcsTask(
     Example::
 
         import aws_cdk.aws_ecs as ecs
-        import aws_cdk.aws_ec2 as ec2
         
         # cluster: ecs.ICluster
         # task_definition: ecs.TaskDefinition
@@ -1836,13 +1863,15 @@ class EcsTask(
             schedule=events.Schedule.rate(cdk.Duration.hours(1))
         )
         
-        rule.add_target(
-            targets.EcsTask(
-                cluster=cluster,
-                task_definition=task_definition,
-                assign_public_ip=True,
-                subnet_selection=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC)
-            ))
+        rule.add_target(targets.EcsTask(
+            cluster=cluster,
+            task_definition=task_definition,
+            task_count=1,
+        
+            # Overrides the cpu and memory values in the task definition
+            cpu="512",
+            memory="512"
+        ))
     '''
 
     def __init__(
@@ -1852,8 +1881,13 @@ class EcsTask(
         task_definition: _ITaskDefinition_889ba4d8,
         assign_public_ip: typing.Optional[builtins.bool] = None,
         container_overrides: typing.Optional[typing.Sequence[typing.Union[ContainerOverride, typing.Dict[builtins.str, typing.Any]]]] = None,
+        cpu: typing.Optional[builtins.str] = None,
         enable_execute_command: typing.Optional[builtins.bool] = None,
+        ephemeral_storage: typing.Optional[typing.Union["EphemeralStorageOverride", typing.Dict[builtins.str, typing.Any]]] = None,
+        execution_role: typing.Optional[_IRole_235f5d8e] = None,
+        inference_accelerator_overrides: typing.Optional[typing.Sequence[typing.Union["InferenceAcceleratorOverride", typing.Dict[builtins.str, typing.Any]]]] = None,
         launch_type: typing.Optional[_LaunchType_6894135d] = None,
+        memory: typing.Optional[builtins.str] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         propagate_tags: typing.Optional[_PropagatedTagSource_ad4e874a] = None,
         role: typing.Optional[_IRole_235f5d8e] = None,
@@ -1861,6 +1895,7 @@ class EcsTask(
         subnet_selection: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
         tags: typing.Optional[typing.Sequence[typing.Union["Tag", typing.Dict[builtins.str, typing.Any]]]] = None,
         task_count: typing.Optional[jsii.Number] = None,
+        task_role: typing.Optional[_IRole_235f5d8e] = None,
         dead_letter_queue: typing.Optional[_IQueue_7ed6f679] = None,
         max_event_age: typing.Optional[_Duration_4839e8c3] = None,
         retry_attempts: typing.Optional[jsii.Number] = None,
@@ -1870,8 +1905,13 @@ class EcsTask(
         :param task_definition: Task Definition of the task that should be started.
         :param assign_public_ip: Specifies whether the task's elastic network interface receives a public IP address. You can specify true only when LaunchType is set to FARGATE. Default: - true if the subnet type is PUBLIC, otherwise false
         :param container_overrides: Container setting overrides. Key is the name of the container to override, value is the values you want to override.
+        :param cpu: The CPU override for the task. Default: - The task definition's CPU value
         :param enable_execute_command: Whether or not to enable the execute command functionality for the containers in this task. If true, this enables execute command functionality on all containers in the task. Default: - false
+        :param ephemeral_storage: The ephemeral storage setting override for the task. NOTE: This parameter is only supported for tasks hosted on Fargate that use the following platform versions: - Linux platform version 1.4.0 or later. - Windows platform version 1.0.0 or later. Default: - The task definition's ephemeral storage value
+        :param execution_role: The execution role for the task. The Amazon Resource Name (ARN) of the task execution role override for the task. Default: - The task definition's execution role
+        :param inference_accelerator_overrides: The Elastic Inference accelerator override for the task. Default: - The task definition's inference accelerator overrides
         :param launch_type: Specifies the launch type on which your task is running. The launch type that you specify here must match one of the launch type (compatibilities) of the target task. Default: - 'EC2' if ``isEc2Compatible`` for the ``taskDefinition`` is true, otherwise 'FARGATE'
+        :param memory: The memory override for the task. Default: - The task definition's memory value
         :param platform_version: The platform version on which to run your task. Unless you have specific compatibility requirements, you don't need to specify this. Default: - ECS will set the Fargate platform version to 'LATEST'
         :param propagate_tags: Specifies whether to propagate the tags from the task definition to the task. If no value is specified, the tags are not propagated. Default: - Tags will not be propagated
         :param role: Existing IAM role to run the ECS task. Default: A new IAM role is created
@@ -1879,6 +1919,7 @@ class EcsTask(
         :param subnet_selection: In what subnets to place the task's ENIs. (Only applicable in case the TaskDefinition is configured for AwsVpc networking) Default: Private subnets
         :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 additional tags are applied to the task
         :param task_count: How many tasks should be started when this event is triggered. Default: 1
+        :param task_role: The IAM role for the task. Default: - The task definition's task role
         :param dead_letter_queue: The SQS queue to be used as deadLetterQueue. Check out the `considerations for using a dead-letter queue <https://docs.aws.amazon.com/eventbridge/latest/userguide/rule-dlq.html#dlq-considerations>`_. The events not successfully delivered are automatically retried for a specified period of time, depending on the retry policy of the target. If an event is not delivered before all retry attempts are exhausted, it will be sent to the dead letter queue. Default: - no dead-letter queue
         :param max_event_age: The maximum age of a request that Lambda sends to a function for processing. Minimum value of 60. Maximum value of 86400. Default: Duration.hours(24)
         :param retry_attempts: The maximum number of times to retry when the function returns an error. Minimum value of 0. Maximum value of 185. Default: 185
@@ -1888,8 +1929,13 @@ class EcsTask(
             task_definition=task_definition,
             assign_public_ip=assign_public_ip,
             container_overrides=container_overrides,
+            cpu=cpu,
             enable_execute_command=enable_execute_command,
+            ephemeral_storage=ephemeral_storage,
+            execution_role=execution_role,
+            inference_accelerator_overrides=inference_accelerator_overrides,
             launch_type=launch_type,
+            memory=memory,
             platform_version=platform_version,
             propagate_tags=propagate_tags,
             role=role,
@@ -1897,6 +1943,7 @@ class EcsTask(
             subnet_selection=subnet_selection,
             tags=tags,
             task_count=task_count,
+            task_role=task_role,
             dead_letter_queue=dead_letter_queue,
             max_event_age=max_event_age,
             retry_attempts=retry_attempts,
@@ -1933,6 +1980,58 @@ class EcsTask(
         return typing.cast(typing.Optional[typing.List[_ISecurityGroup_acf8a799]], jsii.get(self, "securityGroups"))
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_events_targets.EphemeralStorageOverride",
+    jsii_struct_bases=[],
+    name_mapping={"size_in_gib": "sizeInGiB"},
+)
+class EphemeralStorageOverride:
+    def __init__(self, *, size_in_gib: jsii.Number) -> None:
+        '''Override ephemeral storage for the task.
+
+        :param size_in_gib: The total amount, in GiB, of ephemeral storage to set for the task. The minimum supported value is 20 GiB and the maximum supported value is 200 GiB.
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            from aws_cdk import aws_events_targets as events_targets
+            
+            ephemeral_storage_override = events_targets.EphemeralStorageOverride(
+                size_in_gi_b=123
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__5eb4fe2cce860dd139eb826c1adfe14b0a1394ea467d09e880ac9c27d43ec835)
+            check_type(argname="argument size_in_gib", value=size_in_gib, expected_type=type_hints["size_in_gib"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "size_in_gib": size_in_gib,
+        }
+
+    @builtins.property
+    def size_in_gib(self) -> jsii.Number:
+        '''The total amount, in GiB, of ephemeral storage to set for the task.
+
+        The minimum supported value is 20 GiB and the maximum supported value is 200 GiB.
+        '''
+        result = self._values.get("size_in_gib")
+        assert result is not None, "Required property 'size_in_gib' is missing"
+        return typing.cast(jsii.Number, result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "EphemeralStorageOverride(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.implements(_IRuleTarget_7a91f454)
 class EventBus(
     metaclass=jsii.JSIIMeta,
@@ -2124,6 +2223,69 @@ class _IDeliveryStreamProxy(
 typing.cast(typing.Any, IDeliveryStream).__jsii_proxy_class__ = lambda : _IDeliveryStreamProxy
 
 
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_events_targets.InferenceAcceleratorOverride",
+    jsii_struct_bases=[],
+    name_mapping={"device_name": "deviceName", "device_type": "deviceType"},
+)
+class InferenceAcceleratorOverride:
+    def __init__(self, *, device_name: builtins.str, device_type: builtins.str) -> None:
+        '''Override inference accelerators for the task.
+
+        :param device_name: The Elastic Inference accelerator device name to override for the task. This parameter must match a ``deviceName`` specified in the task definition.
+        :param device_type: The Elastic Inference accelerator type to use.
+
+        :exampleMetadata: fixture=_generated
+
+        Example::
+
+            # The code below shows an example of how to instantiate this type.
+            # The values are placeholders you should change.
+            from aws_cdk import aws_events_targets as events_targets
+            
+            inference_accelerator_override = events_targets.InferenceAcceleratorOverride(
+                device_name="deviceName",
+                device_type="deviceType"
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__04d9348fef54fca78833e3224fa6f62badc3a0e6c0bfa6af7838fe531de0ebf6)
+            check_type(argname="argument device_name", value=device_name, expected_type=type_hints["device_name"])
+            check_type(argname="argument device_type", value=device_type, expected_type=type_hints["device_type"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "device_name": device_name,
+            "device_type": device_type,
+        }
+
+    @builtins.property
+    def device_name(self) -> builtins.str:
+        '''The Elastic Inference accelerator device name to override for the task.
+
+        This parameter must match a ``deviceName`` specified in the task definition.
+        '''
+        result = self._values.get("device_name")
+        assert result is not None, "Required property 'device_name' is missing"
+        return typing.cast(builtins.str, result)
+
+    @builtins.property
+    def device_type(self) -> builtins.str:
+        '''The Elastic Inference accelerator type to use.'''
+        result = self._values.get("device_type")
+        assert result is not None, "Required property 'device_type' is missing"
+        return typing.cast(builtins.str, result)
+
+    def __eq__(self, rhs: typing.Any) -> builtins.bool:
+        return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+    def __ne__(self, rhs: typing.Any) -> builtins.bool:
+        return not (rhs == self)
+
+    def __repr__(self) -> str:
+        return "InferenceAcceleratorOverride(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
 @jsii.implements(_IRuleTarget_7a91f454)
 class KinesisFirehoseStream(
     metaclass=jsii.JSIIMeta,
@@ -4443,8 +4605,13 @@ class CodePipelineTargetOptions(TargetBaseProps):
         "task_definition": "taskDefinition",
         "assign_public_ip": "assignPublicIp",
         "container_overrides": "containerOverrides",
+        "cpu": "cpu",
         "enable_execute_command": "enableExecuteCommand",
+        "ephemeral_storage": "ephemeralStorage",
+        "execution_role": "executionRole",
+        "inference_accelerator_overrides": "inferenceAcceleratorOverrides",
         "launch_type": "launchType",
+        "memory": "memory",
         "platform_version": "platformVersion",
         "propagate_tags": "propagateTags",
         "role": "role",
@@ -4452,6 +4619,7 @@ class CodePipelineTargetOptions(TargetBaseProps):
         "subnet_selection": "subnetSelection",
         "tags": "tags",
         "task_count": "taskCount",
+        "task_role": "taskRole",
     },
 )
 class EcsTaskProps(TargetBaseProps):
@@ -4465,8 +4633,13 @@ class EcsTaskProps(TargetBaseProps):
         task_definition: _ITaskDefinition_889ba4d8,
         assign_public_ip: typing.Optional[builtins.bool] = None,
         container_overrides: typing.Optional[typing.Sequence[typing.Union[ContainerOverride, typing.Dict[builtins.str, typing.Any]]]] = None,
+        cpu: typing.Optional[builtins.str] = None,
         enable_execute_command: typing.Optional[builtins.bool] = None,
+        ephemeral_storage: typing.Optional[typing.Union[EphemeralStorageOverride, typing.Dict[builtins.str, typing.Any]]] = None,
+        execution_role: typing.Optional[_IRole_235f5d8e] = None,
+        inference_accelerator_overrides: typing.Optional[typing.Sequence[typing.Union[InferenceAcceleratorOverride, typing.Dict[builtins.str, typing.Any]]]] = None,
         launch_type: typing.Optional[_LaunchType_6894135d] = None,
+        memory: typing.Optional[builtins.str] = None,
         platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
         propagate_tags: typing.Optional[_PropagatedTagSource_ad4e874a] = None,
         role: typing.Optional[_IRole_235f5d8e] = None,
@@ -4474,6 +4647,7 @@ class EcsTaskProps(TargetBaseProps):
         subnet_selection: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[Tag, typing.Dict[builtins.str, typing.Any]]]] = None,
         task_count: typing.Optional[jsii.Number] = None,
+        task_role: typing.Optional[_IRole_235f5d8e] = None,
     ) -> None:
         '''Properties to define an ECS Event Task.
 
@@ -4484,8 +4658,13 @@ class EcsTaskProps(TargetBaseProps):
         :param task_definition: Task Definition of the task that should be started.
         :param assign_public_ip: Specifies whether the task's elastic network interface receives a public IP address. You can specify true only when LaunchType is set to FARGATE. Default: - true if the subnet type is PUBLIC, otherwise false
         :param container_overrides: Container setting overrides. Key is the name of the container to override, value is the values you want to override.
+        :param cpu: The CPU override for the task. Default: - The task definition's CPU value
         :param enable_execute_command: Whether or not to enable the execute command functionality for the containers in this task. If true, this enables execute command functionality on all containers in the task. Default: - false
+        :param ephemeral_storage: The ephemeral storage setting override for the task. NOTE: This parameter is only supported for tasks hosted on Fargate that use the following platform versions: - Linux platform version 1.4.0 or later. - Windows platform version 1.0.0 or later. Default: - The task definition's ephemeral storage value
+        :param execution_role: The execution role for the task. The Amazon Resource Name (ARN) of the task execution role override for the task. Default: - The task definition's execution role
+        :param inference_accelerator_overrides: The Elastic Inference accelerator override for the task. Default: - The task definition's inference accelerator overrides
         :param launch_type: Specifies the launch type on which your task is running. The launch type that you specify here must match one of the launch type (compatibilities) of the target task. Default: - 'EC2' if ``isEc2Compatible`` for the ``taskDefinition`` is true, otherwise 'FARGATE'
+        :param memory: The memory override for the task. Default: - The task definition's memory value
         :param platform_version: The platform version on which to run your task. Unless you have specific compatibility requirements, you don't need to specify this. Default: - ECS will set the Fargate platform version to 'LATEST'
         :param propagate_tags: Specifies whether to propagate the tags from the task definition to the task. If no value is specified, the tags are not propagated. Default: - Tags will not be propagated
         :param role: Existing IAM role to run the ECS task. Default: A new IAM role is created
@@ -4493,13 +4672,13 @@ class EcsTaskProps(TargetBaseProps):
         :param subnet_selection: In what subnets to place the task's ENIs. (Only applicable in case the TaskDefinition is configured for AwsVpc networking) Default: Private subnets
         :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 additional tags are applied to the task
         :param task_count: How many tasks should be started when this event is triggered. Default: 1
+        :param task_role: The IAM role for the task. Default: - The task definition's task role
 
         :exampleMetadata: infused
 
         Example::
 
             import aws_cdk.aws_ecs as ecs
-            import aws_cdk.aws_ec2 as ec2
             
             # cluster: ecs.ICluster
             # task_definition: ecs.TaskDefinition
@@ -4509,14 +4688,18 @@ class EcsTaskProps(TargetBaseProps):
                 schedule=events.Schedule.rate(cdk.Duration.hours(1))
             )
             
-            rule.add_target(
-                targets.EcsTask(
-                    cluster=cluster,
-                    task_definition=task_definition,
-                    assign_public_ip=True,
-                    subnet_selection=ec2.SubnetSelection(subnet_type=ec2.SubnetType.PUBLIC)
-                ))
+            rule.add_target(targets.EcsTask(
+                cluster=cluster,
+                task_definition=task_definition,
+                task_count=1,
+            
+                # Overrides the cpu and memory values in the task definition
+                cpu="512",
+                memory="512"
+            ))
         '''
+        if isinstance(ephemeral_storage, dict):
+            ephemeral_storage = EphemeralStorageOverride(**ephemeral_storage)
         if isinstance(subnet_selection, dict):
             subnet_selection = _SubnetSelection_e57d76df(**subnet_selection)
         if __debug__:
@@ -4528,8 +4711,13 @@ class EcsTaskProps(TargetBaseProps):
             check_type(argname="argument task_definition", value=task_definition, expected_type=type_hints["task_definition"])
             check_type(argname="argument assign_public_ip", value=assign_public_ip, expected_type=type_hints["assign_public_ip"])
             check_type(argname="argument container_overrides", value=container_overrides, expected_type=type_hints["container_overrides"])
+            check_type(argname="argument cpu", value=cpu, expected_type=type_hints["cpu"])
             check_type(argname="argument enable_execute_command", value=enable_execute_command, expected_type=type_hints["enable_execute_command"])
+            check_type(argname="argument ephemeral_storage", value=ephemeral_storage, expected_type=type_hints["ephemeral_storage"])
+            check_type(argname="argument execution_role", value=execution_role, expected_type=type_hints["execution_role"])
+            check_type(argname="argument inference_accelerator_overrides", value=inference_accelerator_overrides, expected_type=type_hints["inference_accelerator_overrides"])
             check_type(argname="argument launch_type", value=launch_type, expected_type=type_hints["launch_type"])
+            check_type(argname="argument memory", value=memory, expected_type=type_hints["memory"])
             check_type(argname="argument platform_version", value=platform_version, expected_type=type_hints["platform_version"])
             check_type(argname="argument propagate_tags", value=propagate_tags, expected_type=type_hints["propagate_tags"])
             check_type(argname="argument role", value=role, expected_type=type_hints["role"])
@@ -4537,6 +4725,7 @@ class EcsTaskProps(TargetBaseProps):
             check_type(argname="argument subnet_selection", value=subnet_selection, expected_type=type_hints["subnet_selection"])
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
             check_type(argname="argument task_count", value=task_count, expected_type=type_hints["task_count"])
+            check_type(argname="argument task_role", value=task_role, expected_type=type_hints["task_role"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "cluster": cluster,
             "task_definition": task_definition,
@@ -4551,10 +4740,20 @@ class EcsTaskProps(TargetBaseProps):
             self._values["assign_public_ip"] = assign_public_ip
         if container_overrides is not None:
             self._values["container_overrides"] = container_overrides
+        if cpu is not None:
+            self._values["cpu"] = cpu
         if enable_execute_command is not None:
             self._values["enable_execute_command"] = enable_execute_command
+        if ephemeral_storage is not None:
+            self._values["ephemeral_storage"] = ephemeral_storage
+        if execution_role is not None:
+            self._values["execution_role"] = execution_role
+        if inference_accelerator_overrides is not None:
+            self._values["inference_accelerator_overrides"] = inference_accelerator_overrides
         if launch_type is not None:
             self._values["launch_type"] = launch_type
+        if memory is not None:
+            self._values["memory"] = memory
         if platform_version is not None:
             self._values["platform_version"] = platform_version
         if propagate_tags is not None:
@@ -4569,6 +4768,8 @@ class EcsTaskProps(TargetBaseProps):
             self._values["tags"] = tags
         if task_count is not None:
             self._values["task_count"] = task_count
+        if task_role is not None:
+            self._values["task_role"] = task_role
 
     @builtins.property
     def dead_letter_queue(self) -> typing.Optional[_IQueue_7ed6f679]:
@@ -4642,6 +4843,15 @@ class EcsTaskProps(TargetBaseProps):
         result = self._values.get("container_overrides")
         return typing.cast(typing.Optional[typing.List[ContainerOverride]], result)
 
+    @builtins.property
+    def cpu(self) -> typing.Optional[builtins.str]:
+        '''The CPU override for the task.
+
+        :default: - The task definition's CPU value
+        '''
+        result = self._values.get("cpu")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def enable_execute_command(self) -> typing.Optional[builtins.bool]:
         '''Whether or not to enable the execute command functionality for the containers in this task.
@@ -4653,6 +4863,42 @@ class EcsTaskProps(TargetBaseProps):
         result = self._values.get("enable_execute_command")
         return typing.cast(typing.Optional[builtins.bool], result)
 
+    @builtins.property
+    def ephemeral_storage(self) -> typing.Optional[EphemeralStorageOverride]:
+        '''The ephemeral storage setting override for the task.
+
+        NOTE: This parameter is only supported for tasks hosted on Fargate that use the following platform versions:
+
+        - Linux platform version 1.4.0 or later.
+        - Windows platform version 1.0.0 or later.
+
+        :default: - The task definition's ephemeral storage value
+        '''
+        result = self._values.get("ephemeral_storage")
+        return typing.cast(typing.Optional[EphemeralStorageOverride], result)
+
+    @builtins.property
+    def execution_role(self) -> typing.Optional[_IRole_235f5d8e]:
+        '''The execution role for the task.
+
+        The Amazon Resource Name (ARN) of the task execution role override for the task.
+
+        :default: - The task definition's execution role
+        '''
+        result = self._values.get("execution_role")
+        return typing.cast(typing.Optional[_IRole_235f5d8e], result)
+
+    @builtins.property
+    def inference_accelerator_overrides(
+        self,
+    ) -> typing.Optional[typing.List[InferenceAcceleratorOverride]]:
+        '''The Elastic Inference accelerator override for the task.
+
+        :default: - The task definition's inference accelerator overrides
+        '''
+        result = self._values.get("inference_accelerator_overrides")
+        return typing.cast(typing.Optional[typing.List[InferenceAcceleratorOverride]], result)
+
     @builtins.property
     def launch_type(self) -> typing.Optional[_LaunchType_6894135d]:
         '''Specifies the launch type on which your task is running.
@@ -4665,6 +4911,15 @@ class EcsTaskProps(TargetBaseProps):
         result = self._values.get("launch_type")
         return typing.cast(typing.Optional[_LaunchType_6894135d], result)
 
+    @builtins.property
+    def memory(self) -> typing.Optional[builtins.str]:
+        '''The memory override for the task.
+
+        :default: - The task definition's memory value
+        '''
+        result = self._values.get("memory")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def platform_version(self) -> typing.Optional[_FargatePlatformVersion_55d8be5c]:
         '''The platform version on which to run your task.
@@ -4740,6 +4995,15 @@ class EcsTaskProps(TargetBaseProps):
         result = self._values.get("task_count")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def task_role(self) -> typing.Optional[_IRole_235f5d8e]:
+        '''The IAM role for the task.
+
+        :default: - The task definition's task role
+        '''
+        result = self._values.get("task_role")
+        return typing.cast(typing.Optional[_IRole_235f5d8e], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -5590,9 +5854,11 @@ __all__ = [
     "ContainerOverride",
     "EcsTask",
     "EcsTaskProps",
+    "EphemeralStorageOverride",
     "EventBus",
     "EventBusProps",
     "IDeliveryStream",
+    "InferenceAcceleratorOverride",
     "KinesisFirehoseStream",
     "KinesisFirehoseStreamProps",
     "KinesisFirehoseStreamV2",
@@ -5815,6 +6081,13 @@ def _typecheckingstub__8ad199a8641f171a0447e974756bbddd91b00aaa9bcf33d231826916b
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__5eb4fe2cce860dd139eb826c1adfe14b0a1394ea467d09e880ac9c27d43ec835(
+    *,
+    size_in_gib: jsii.Number,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__e6012a31db9ac91c35876daca0265cba4fbb81bfdf8acd148b62786503371d52(
     event_bus: _IEventBus_88d13111,
     *,
@@ -5839,6 +6112,14 @@ def _typecheckingstub__5af20e134873490c1ac4788761972ccd53cd625edbd9b75c1c1f0b1a3
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__04d9348fef54fca78833e3224fa6f62badc3a0e6c0bfa6af7838fe531de0ebf6(
+    *,
+    device_name: builtins.str,
+    device_type: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__c6dba8ed5e351380147a927ce30f4c9095bc69a54a2de45039c2a1d8275dc88c(
     stream: _CfnDeliveryStream_8f3b1735,
     *,
@@ -6132,8 +6413,13 @@ def _typecheckingstub__3624031da4f9372e2ccdb3e422123cc459d01922cc36bab5b96caa98f
     task_definition: _ITaskDefinition_889ba4d8,
     assign_public_ip: typing.Optional[builtins.bool] = None,
     container_overrides: typing.Optional[typing.Sequence[typing.Union[ContainerOverride, typing.Dict[builtins.str, typing.Any]]]] = None,
+    cpu: typing.Optional[builtins.str] = None,
     enable_execute_command: typing.Optional[builtins.bool] = None,
+    ephemeral_storage: typing.Optional[typing.Union[EphemeralStorageOverride, typing.Dict[builtins.str, typing.Any]]] = None,
+    execution_role: typing.Optional[_IRole_235f5d8e] = None,
+    inference_accelerator_overrides: typing.Optional[typing.Sequence[typing.Union[InferenceAcceleratorOverride, typing.Dict[builtins.str, typing.Any]]]] = None,
     launch_type: typing.Optional[_LaunchType_6894135d] = None,
+    memory: typing.Optional[builtins.str] = None,
     platform_version: typing.Optional[_FargatePlatformVersion_55d8be5c] = None,
     propagate_tags: typing.Optional[_PropagatedTagSource_ad4e874a] = None,
     role: typing.Optional[_IRole_235f5d8e] = None,
@@ -6141,6 +6427,7 @@ def _typecheckingstub__3624031da4f9372e2ccdb3e422123cc459d01922cc36bab5b96caa98f
     subnet_selection: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[Tag, typing.Dict[builtins.str, typing.Any]]]] = None,
     task_count: typing.Optional[jsii.Number] = None,
+    task_role: typing.Optional[_IRole_235f5d8e] = None,
 ) -> None:
     """Type checking stubs"""
     pass

aws_cdk/aws_iam/__init__.py

@@ -13890,7 +13890,7 @@ class ArnPrincipal(
     Example::
 
         # Option 2: create your custom mastersRole with scoped assumeBy arn as the Cluster prop. Switch to this role from the AWS console.
-        from aws_cdk.lambda_layer_kubectl_v31 import KubectlV31Layer
+        from aws_cdk.lambda_layer_kubectl_v32 import KubectlV32Layer
         # vpc: ec2.Vpc
         
         
@@ -13900,8 +13900,8 @@ class ArnPrincipal(
         
         cluster = eks.Cluster(self, "EksCluster",
             vpc=vpc,
-            version=eks.KubernetesVersion.V1_31,
-            kubectl_layer=KubectlV31Layer(self, "KubectlLayer"),
+            version=eks.KubernetesVersion.V1_32,
+            kubectl_layer=KubectlV32Layer(self, "KubectlLayer"),
             masters_role=masters_role
         )