aws-cdk-lib 2.189.1__py3-none-any.whl → 2.191.0__py3-none-any.whl

aws_cdk/aws_batch/__init__.py

@@ -1337,7 +1337,7 @@ class CfnComputeEnvironment(
             :param placement_group: The Amazon EC2 placement group to associate with your compute resources. If you intend to submit multi-node parallel jobs to your compute environment, you should consider creating a cluster placement group and associate it with your compute resources. This keeps your multi-node parallel job on a logical grouping of instances within a single Availability Zone with high network flow potential. For more information, see `Placement groups <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html>`_ in the *Amazon EC2 User Guide for Linux Instances* . When updating a compute environment, changing the placement group requires an infrastructure update of the compute environment. For more information, see `Updating compute environments <https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html>`_ in the *AWS Batch User Guide* . .. epigraph:: This parameter isn't applicable to jobs that are running on Fargate resources. Don't specify it.
             :param security_group_ids: The Amazon EC2 security groups that are associated with instances launched in the compute environment. This parameter is required for Fargate compute resources, where it can contain up to 5 security groups. For Fargate compute resources, providing an empty list is handled as if this parameter wasn't specified and no change is made. For Amazon EC2 compute resources, providing an empty list removes the security groups from the compute resource. When updating a compute environment, changing the Amazon EC2 security groups requires an infrastructure update of the compute environment. For more information, see `Updating compute environments <https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html>`_ in the *AWS Batch User Guide* .
             :param spot_iam_fleet_role: The Amazon Resource Name (ARN) of the Amazon EC2 Spot Fleet IAM role applied to a ``SPOT`` compute environment. This role is required if the allocation strategy set to ``BEST_FIT`` or if the allocation strategy isn't specified. For more information, see `Amazon EC2 spot fleet role <https://docs.aws.amazon.com/batch/latest/userguide/spot_fleet_IAM_role.html>`_ in the *AWS Batch User Guide* . .. epigraph:: This parameter isn't applicable to jobs that are running on Fargate resources. Don't specify it. > To tag your Spot Instances on creation, the Spot Fleet IAM role specified here must use the newer *AmazonEC2SpotFleetTaggingRole* managed policy. The previously recommended *AmazonEC2SpotFleetRole* managed policy doesn't have the required permissions to tag Spot Instances. For more information, see `Spot instances not tagged on creation <https://docs.aws.amazon.com/batch/latest/userguide/troubleshooting.html#spot-instance-no-tag>`_ in the *AWS Batch User Guide* .
-            :param tags: Key-value pair tags to be applied to Amazon EC2 resources that are launched in the compute environment. For AWS Batch , these take the form of ``"String1": "String2"`` , where ``String1`` is the tag key and ``String2`` is the tag value-for example, ``{ "Name": "Batch Instance - C4OnDemand" }`` . This is helpful for recognizing your Batch instances in the Amazon EC2 console. These tags aren't seen when using the AWS Batch ``ListTagsForResource`` API operation. When updating a compute environment, changing this setting requires an infrastructure update of the compute environment. For more information, see `Updating compute environments <https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html>`_ in the *AWS Batch User Guide* . .. epigraph:: This parameter isn't applicable to jobs that are running on Fargate resources. Don't specify it.
+            :param tags: Key-value pair tags to be applied to Amazon EC2 resources that are launched in the compute environment. For AWS Batch , these take the form of ``"String1": "String2"`` , where ``String1`` is the tag key and ``String2`` is the tag value (for example, ``{ "Name": "Batch Instance - C4OnDemand" }`` ). This is helpful for recognizing your Batch instances in the Amazon EC2 console. These tags aren't seen when using the AWS Batch ``ListTagsForResource`` API operation. When updating a compute environment, changing this setting requires an infrastructure update of the compute environment. For more information, see `Updating compute environments <https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html>`_ in the *AWS Batch User Guide* . .. epigraph:: This parameter isn't applicable to jobs that are running on Fargate resources. Don't specify it.
             :param update_to_latest_image_version: Specifies whether the AMI ID is updated to the latest one that's supported by AWS Batch when the compute environment has an infrastructure update. The default value is ``false`` . .. epigraph:: An AMI ID can either be specified in the ``imageId`` or ``imageIdOverride`` parameters or be determined by the launch template that's specified in the ``launchTemplate`` parameter. If an AMI ID is specified any of these ways, this parameter is ignored. For more information about to update AMI IDs during an infrastructure update, see `Updating the AMI ID <https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html#updating-compute-environments-ami>`_ in the *AWS Batch User Guide* . When updating a compute environment, changing this setting requires an infrastructure update of the compute environment. For more information, see `Updating compute environments <https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html>`_ in the *AWS Batch User Guide* . Default: - false
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html
@@ -1718,7 +1718,7 @@ class CfnComputeEnvironment(
         def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
             '''Key-value pair tags to be applied to Amazon EC2 resources that are launched in the compute environment.
 
-            For AWS Batch , these take the form of ``"String1": "String2"`` , where ``String1`` is the tag key and ``String2`` is the tag value-for example, ``{ "Name": "Batch Instance - C4OnDemand" }`` . This is helpful for recognizing your Batch instances in the Amazon EC2 console. These tags aren't seen when using the AWS Batch ``ListTagsForResource`` API operation.
+            For AWS Batch , these take the form of ``"String1": "String2"`` , where ``String1`` is the tag key and ``String2`` is the tag value (for example, ``{ "Name": "Batch Instance - C4OnDemand" }`` ). This is helpful for recognizing your Batch instances in the Amazon EC2 console. These tags aren't seen when using the AWS Batch ``ListTagsForResource`` API operation.
 
             When updating a compute environment, changing this setting requires an infrastructure update of the compute environment. For more information, see `Updating compute environments <https://docs.aws.amazon.com/batch/latest/userguide/updating-compute-environments.html>`_ in the *AWS Batch User Guide* .
             .. epigraph::
@@ -3514,6 +3514,7 @@ class CfnJobDefinition(
         name_mapping={
             "image": "image",
             "command": "command",
+            "enable_execute_command": "enableExecuteCommand",
             "environment": "environment",
             "ephemeral_storage": "ephemeralStorage",
             "execution_role_arn": "executionRoleArn",
@@ -3543,6 +3544,7 @@ class CfnJobDefinition(
             *,
             image: builtins.str,
             command: typing.Optional[typing.Sequence[builtins.str]] = None,
+            enable_execute_command: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
             environment: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.EnvironmentProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             ephemeral_storage: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.EphemeralStorageProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             execution_role_arn: typing.Optional[builtins.str] = None,
@@ -3571,6 +3573,7 @@ class CfnJobDefinition(
 
             :param image: Required. The image used to start a container. This string is passed directly to the Docker daemon. Images in the Docker Hub registry are available by default. Other repositories are specified with ``*repository-url* / *image* : *tag*`` . It can be 255 characters long. It can contain uppercase and lowercase letters, numbers, hyphens (-), underscores (_), colons (:), periods (.), forward slashes (/), and number signs (#). This parameter maps to ``Image`` in the `Create a container <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.23/#create-a-container>`_ section of the `Docker Remote API <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.23/>`_ and the ``IMAGE`` parameter of `docker run <https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/>`_ . .. epigraph:: Docker image architecture must match the processor architecture of the compute resources that they're scheduled on. For example, ARM-based Docker images can only run on ARM-based compute resources. - Images in Amazon ECR Public repositories use the full ``registry/repository[:tag]`` or ``registry/repository[@digest]`` naming conventions. For example, ``public.ecr.aws/ *registry_alias* / *my-web-app* : *latest*`` . - Images in Amazon ECR repositories use the full registry and repository URI (for example, ``123456789012.dkr.ecr.<region-name>.amazonaws.com/<repository-name>`` ). - Images in official repositories on Docker Hub use a single name (for example, ``ubuntu`` or ``mongo`` ). - Images in other repositories on Docker Hub are qualified with an organization name (for example, ``amazon/amazon-ecs-agent`` ). - Images in other online repositories are qualified further by a domain name (for example, ``quay.io/assemblyline/ubuntu`` ).
             :param command: The command that's passed to the container. This parameter maps to ``Cmd`` in the `Create a container <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.23/#create-a-container>`_ section of the `Docker Remote API <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.23/>`_ and the ``COMMAND`` parameter to `docker run <https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/>`_ . For more information, see `https://docs.docker.com/engine/reference/builder/#cmd <https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/builder/#cmd>`_ .
+            :param enable_execute_command: Determines whether execute command functionality is turned on for this task. If ``true`` , execute command functionality is turned on all the containers in the task.
             :param environment: The environment variables to pass to a container. This parameter maps to ``Env`` in the `Create a container <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.23/#create-a-container>`_ section of the `Docker Remote API <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.23/>`_ and the ``--env`` option to `docker run <https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/>`_ . .. epigraph:: We don't recommend using plaintext environment variables for sensitive information, such as credential data. > Environment variables cannot start with " ``AWS_BATCH`` ". This naming convention is reserved for variables that AWS Batch sets.
             :param ephemeral_storage: The amount of ephemeral storage to allocate for the task. This parameter is used to expand the total amount of ephemeral storage available, beyond the default amount, for tasks hosted on AWS Fargate .
             :param execution_role_arn: The Amazon Resource Name (ARN) of the execution role that AWS Batch can assume. For jobs that run on Fargate resources, you must provide an execution role. For more information, see `AWS Batch execution IAM role <https://docs.aws.amazon.com/batch/latest/userguide/execution-IAM-role.html>`_ in the *AWS Batch User Guide* .
@@ -3609,6 +3612,7 @@ class CfnJobDefinition(
                 
                     # the properties below are optional
                     command=["command"],
+                    enable_execute_command=False,
                     environment=[batch.CfnJobDefinition.EnvironmentProperty(
                         name="name",
                         value="value"
@@ -3707,6 +3711,7 @@ class CfnJobDefinition(
                 type_hints = typing.get_type_hints(_typecheckingstub__09b3c38642739790560033cae597f009c106d353ddc5faf85f6a7bf4891ac4d1)
                 check_type(argname="argument image", value=image, expected_type=type_hints["image"])
                 check_type(argname="argument command", value=command, expected_type=type_hints["command"])
+                check_type(argname="argument enable_execute_command", value=enable_execute_command, expected_type=type_hints["enable_execute_command"])
                 check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
                 check_type(argname="argument ephemeral_storage", value=ephemeral_storage, expected_type=type_hints["ephemeral_storage"])
                 check_type(argname="argument execution_role_arn", value=execution_role_arn, expected_type=type_hints["execution_role_arn"])
@@ -3733,6 +3738,8 @@ class CfnJobDefinition(
             }
             if command is not None:
                 self._values["command"] = command
+            if enable_execute_command is not None:
+                self._values["enable_execute_command"] = enable_execute_command
             if environment is not None:
                 self._values["environment"] = environment
             if ephemeral_storage is not None:
@@ -3808,6 +3815,19 @@ class CfnJobDefinition(
             result = self._values.get("command")
             return typing.cast(typing.Optional[typing.List[builtins.str]], result)
 
+        @builtins.property
+        def enable_execute_command(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''Determines whether execute command functionality is turned on for this task.
+
+            If ``true`` , execute command functionality is turned on all the containers in the task.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-containerproperties.html#cfn-batch-jobdefinition-containerproperties-enableexecutecommand
+            '''
+            result = self._values.get("enable_execute_command")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
         @builtins.property
         def environment(
             self,
@@ -4227,6 +4247,14 @@ class CfnJobDefinition(
                                 value="value"
                             )],
                             essential=False,
+                            firelens_configuration=batch.CfnJobDefinition.FirelensConfigurationProperty(
+                                type="type",
+                
+                                # the properties below are optional
+                                options={
+                                    "options_key": "options"
+                                }
+                            ),
                             linux_parameters=batch.CfnJobDefinition.LinuxParametersProperty(
                                 devices=[batch.CfnJobDefinition.DeviceProperty(
                                     container_path="containerPath",
@@ -4281,6 +4309,7 @@ class CfnJobDefinition(
                             )],
                             user="user"
                         )],
+                        enable_execute_command=False,
                         ephemeral_storage=batch.CfnJobDefinition.EphemeralStorageProperty(
                             size_in_gi_b=123
                         ),
@@ -4356,6 +4385,7 @@ class CfnJobDefinition(
         jsii_struct_bases=[],
         name_mapping={
             "containers": "containers",
+            "enable_execute_command": "enableExecuteCommand",
             "ephemeral_storage": "ephemeralStorage",
             "execution_role_arn": "executionRoleArn",
             "ipc_mode": "ipcMode",
@@ -4372,6 +4402,7 @@ class CfnJobDefinition(
             self,
             *,
             containers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.TaskContainerPropertiesProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+            enable_execute_command: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
             ephemeral_storage: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.EphemeralStorageProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             execution_role_arn: typing.Optional[builtins.str] = None,
             ipc_mode: typing.Optional[builtins.str] = None,
@@ -4387,6 +4418,7 @@ class CfnJobDefinition(
             You can specify which Docker images to use, the required resources, and other configurations related to launching the task definition through an Amazon ECS service or task.
 
             :param containers: This object is a list of containers.
+            :param enable_execute_command: Determines whether execute command functionality is turned on for this task. If ``true`` , execute command functionality is turned on all the containers in the task.
             :param ephemeral_storage: The amount of ephemeral storage to allocate for the task. This parameter is used to expand the total amount of ephemeral storage available, beyond the default amount, for tasks hosted on AWS Fargate .
             :param execution_role_arn: The Amazon Resource Name (ARN) of the execution role that AWS Batch can assume. For jobs that run on Fargate resources, you must provide an execution role. For more information, see `AWS Batch execution IAM role <https://docs.aws.amazon.com/batch/latest/userguide/execution-IAM-role.html>`_ in the *AWS Batch User Guide* .
             :param ipc_mode: The IPC resource namespace to use for the containers in the task. The valid values are ``host`` , ``task`` , or ``none`` . If ``host`` is specified, all containers within the tasks that specified the ``host`` IPC mode on the same container instance share the same IPC resources with the host Amazon EC2 instance. If ``task`` is specified, all containers within the specified ``task`` share the same IPC resources. If ``none`` is specified, the IPC resources within the containers of a task are private, and are not shared with other containers in a task or on the container instance. If no value is specified, then the IPC resource namespace sharing depends on the Docker daemon setting on the container instance. For more information, see `IPC settings <https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#ipc-settings---ipc>`_ in the Docker run reference.
@@ -4423,6 +4455,14 @@ class CfnJobDefinition(
                             value="value"
                         )],
                         essential=False,
+                        firelens_configuration=batch.CfnJobDefinition.FirelensConfigurationProperty(
+                            type="type",
+                
+                            # the properties below are optional
+                            options={
+                                "options_key": "options"
+                            }
+                        ),
                         linux_parameters=batch.CfnJobDefinition.LinuxParametersProperty(
                             devices=[batch.CfnJobDefinition.DeviceProperty(
                                 container_path="containerPath",
@@ -4477,6 +4517,7 @@ class CfnJobDefinition(
                         )],
                         user="user"
                     )],
+                    enable_execute_command=False,
                     ephemeral_storage=batch.CfnJobDefinition.EphemeralStorageProperty(
                         size_in_gi_b=123
                     ),
@@ -4515,6 +4556,7 @@ class CfnJobDefinition(
             if __debug__:
                 type_hints = typing.get_type_hints(_typecheckingstub__8e8c39be2b840a158045732ea20d964bf03d380304bbcd66936cb862e6cc2a8e)
                 check_type(argname="argument containers", value=containers, expected_type=type_hints["containers"])
+                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_arn", value=execution_role_arn, expected_type=type_hints["execution_role_arn"])
                 check_type(argname="argument ipc_mode", value=ipc_mode, expected_type=type_hints["ipc_mode"])
@@ -4527,6 +4569,8 @@ class CfnJobDefinition(
             self._values: typing.Dict[builtins.str, typing.Any] = {}
             if containers is not None:
                 self._values["containers"] = containers
+            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_arn is not None:
@@ -4557,6 +4601,19 @@ class CfnJobDefinition(
             result = self._values.get("containers")
             return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnJobDefinition.TaskContainerPropertiesProperty"]]]], result)
 
+        @builtins.property
+        def enable_execute_command(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''Determines whether execute command functionality is turned on for this task.
+
+            If ``true`` , execute command functionality is turned on all the containers in the task.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-ecstaskproperties.html#cfn-batch-jobdefinition-ecstaskproperties-enableexecutecommand
+            '''
+            result = self._values.get("enable_execute_command")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
         @builtins.property
         def ephemeral_storage(
             self,
@@ -6088,6 +6145,89 @@ class CfnJobDefinition(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_batch.CfnJobDefinition.FirelensConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={"type": "type", "options": "options"},
+    )
+    class FirelensConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            type: builtins.str,
+            options: typing.Optional[typing.Union[typing.Mapping[builtins.str, builtins.str], _IResolvable_da3f097b]] = None,
+        ) -> None:
+            '''The FireLens configuration for the container.
+
+            This is used to specify and configure a log router for container logs. For more information, see `Custom log <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html>`_ routing in the *Amazon Elastic Container Service Developer Guide* .
+
+            :param type: The log router to use. The valid values are ``fluentd`` or ``fluentbit`` .
+            :param options: The options to use when configuring the log router. This field is optional and can be used to specify a custom configuration file or to add additional metadata, such as the task, task definition, cluster, and container instance details to the log event. If specified, the syntax to use is ``"options":{"enable-ecs-log-metadata":"true|false","config-file-type:"s3|file","config-file-value":"arn:aws:s3:::mybucket/fluent.conf|filepath"}`` . For more information, see `Creating a task definition that uses a FireLens configuration <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html#firelens-taskdef>`_ in the *Amazon Elastic Container Service Developer Guide* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-firelensconfiguration.html
+            :exampleMetadata: fixture=_generated
+
+            Example::
+
+                # The code below shows an example of how to instantiate this type.
+                # The values are placeholders you should change.
+                from aws_cdk import aws_batch as batch
+                
+                firelens_configuration_property = batch.CfnJobDefinition.FirelensConfigurationProperty(
+                    type="type",
+                
+                    # the properties below are optional
+                    options={
+                        "options_key": "options"
+                    }
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__012b674cbcf1ea538c209d328bedd805776a59df4892337af673d8b565f4f57d)
+                check_type(argname="argument type", value=type, expected_type=type_hints["type"])
+                check_type(argname="argument options", value=options, expected_type=type_hints["options"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "type": type,
+            }
+            if options is not None:
+                self._values["options"] = options
+
+        @builtins.property
+        def type(self) -> builtins.str:
+            '''The log router to use.
+
+            The valid values are ``fluentd`` or ``fluentbit`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-firelensconfiguration.html#cfn-batch-jobdefinition-firelensconfiguration-type
+            '''
+            result = self._values.get("type")
+            assert result is not None, "Required property 'type' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def options(
+            self,
+        ) -> typing.Optional[typing.Union[typing.Mapping[builtins.str, builtins.str], _IResolvable_da3f097b]]:
+            '''The options to use when configuring the log router.
+
+            This field is optional and can be used to specify a custom configuration file or to add additional metadata, such as the task, task definition, cluster, and container instance details to the log event. If specified, the syntax to use is ``"options":{"enable-ecs-log-metadata":"true|false","config-file-type:"s3|file","config-file-value":"arn:aws:s3:::mybucket/fluent.conf|filepath"}`` . For more information, see `Creating a task definition that uses a FireLens configuration <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html#firelens-taskdef>`_ in the *Amazon Elastic Container Service Developer Guide* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-firelensconfiguration.html#cfn-batch-jobdefinition-firelensconfiguration-options
+            '''
+            result = self._values.get("options")
+            return typing.cast(typing.Optional[typing.Union[typing.Mapping[builtins.str, builtins.str], _IResolvable_da3f097b]], 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 "FirelensConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_batch.CfnJobDefinition.HostPathProperty",
         jsii_struct_bases=[],
@@ -6466,7 +6606,7 @@ class CfnJobDefinition(
         ) -> None:
             '''Log configuration options to send to a custom log driver for the container.
 
-            :param log_driver: The log driver to use for the container. The valid values that are listed for this parameter are log drivers that the Amazon ECS container agent can communicate with by default. The supported log drivers are ``awslogs`` , ``fluentd`` , ``gelf`` , ``json-file`` , ``journald`` , ``logentries`` , ``syslog`` , and ``splunk`` . .. epigraph:: Jobs that are running on Fargate resources are restricted to the ``awslogs`` and ``splunk`` log drivers. - **awslogs** - Specifies the Amazon CloudWatch Logs logging driver. For more information, see `Using the awslogs log driver <https://docs.aws.amazon.com/batch/latest/userguide/using_awslogs.html>`_ in the *AWS Batch User Guide* and `Amazon CloudWatch Logs logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/awslogs/>`_ in the Docker documentation. - **fluentd** - Specifies the Fluentd logging driver. For more information including usage and options, see `Fluentd logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/fluentd/>`_ in the *Docker documentation* . - **gelf** - Specifies the Graylog Extended Format (GELF) logging driver. For more information including usage and options, see `Graylog Extended Format logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/gelf/>`_ in the *Docker documentation* . - **journald** - Specifies the journald logging driver. For more information including usage and options, see `Journald logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/journald/>`_ in the *Docker documentation* . - **json-file** - Specifies the JSON file logging driver. For more information including usage and options, see `JSON File logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/json-file/>`_ in the *Docker documentation* . - **splunk** - Specifies the Splunk logging driver. For more information including usage and options, see `Splunk logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/splunk/>`_ in the *Docker documentation* . - **syslog** - Specifies the syslog logging driver. For more information including usage and options, see `Syslog logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/syslog/>`_ in the *Docker documentation* . .. epigraph:: If you have a custom driver that's not listed earlier that you want to work with the Amazon ECS container agent, you can fork the Amazon ECS container agent project that's `available on GitHub <https://docs.aws.amazon.com/https://github.com/aws/amazon-ecs-agent>`_ and customize it to work with that driver. We encourage you to submit pull requests for changes that you want to have included. However, Amazon Web Services doesn't currently support running modified copies of this software. This parameter requires version 1.18 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: ``sudo docker version | grep "Server API version"``
+            :param log_driver: The log driver to use for the container. The valid values that are listed for this parameter are log drivers that the Amazon ECS container agent can communicate with by default. The supported log drivers are ``awslogs`` , ``fluentd`` , ``gelf`` , ``json-file`` , ``journald`` , ``logentries`` , ``syslog`` , and ``splunk`` . .. epigraph:: Jobs that are running on Fargate resources are restricted to the ``awslogs`` and ``splunk`` log drivers. - **awsfirelens** - Specifies the firelens logging driver. For more information on configuring Firelens, see `Send Amazon ECS logs to an AWS service or AWS Partner <https://docs.aws.amazon.com//AmazonECS/latest/developerguide/using_firelens.html>`_ in the *Amazon Elastic Container Service Developer Guide* . - **awslogs** - Specifies the Amazon CloudWatch Logs logging driver. For more information, see `Using the awslogs log driver <https://docs.aws.amazon.com/batch/latest/userguide/using_awslogs.html>`_ in the *AWS Batch User Guide* and `Amazon CloudWatch Logs logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/awslogs/>`_ in the Docker documentation. - **fluentd** - Specifies the Fluentd logging driver. For more information including usage and options, see `Fluentd logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/fluentd/>`_ in the *Docker documentation* . - **gelf** - Specifies the Graylog Extended Format (GELF) logging driver. For more information including usage and options, see `Graylog Extended Format logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/gelf/>`_ in the *Docker documentation* . - **journald** - Specifies the journald logging driver. For more information including usage and options, see `Journald logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/journald/>`_ in the *Docker documentation* . - **json-file** - Specifies the JSON file logging driver. For more information including usage and options, see `JSON File logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/json-file/>`_ in the *Docker documentation* . - **splunk** - Specifies the Splunk logging driver. For more information including usage and options, see `Splunk logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/splunk/>`_ in the *Docker documentation* . - **syslog** - Specifies the syslog logging driver. For more information including usage and options, see `Syslog logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/syslog/>`_ in the *Docker documentation* . .. epigraph:: If you have a custom driver that's not listed earlier that you want to work with the Amazon ECS container agent, you can fork the Amazon ECS container agent project that's `available on GitHub <https://docs.aws.amazon.com/https://github.com/aws/amazon-ecs-agent>`_ and customize it to work with that driver. We encourage you to submit pull requests for changes that you want to have included. However, Amazon Web Services doesn't currently support running modified copies of this software. This parameter requires version 1.18 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: ``sudo docker version | grep "Server API version"``
             :param options: The configuration options to send to the log driver. This parameter requires version 1.19 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: ``sudo docker version | grep "Server API version"``
             :param secret_options: The secrets to pass to the log configuration. For more information, see `Specifying sensitive data <https://docs.aws.amazon.com/batch/latest/userguide/specifying-sensitive-data.html>`_ in the *AWS Batch User Guide* .
 
@@ -6516,6 +6656,7 @@ class CfnJobDefinition(
 
                Jobs that are running on Fargate resources are restricted to the ``awslogs`` and ``splunk`` log drivers.
 
+            - **awsfirelens** - Specifies the firelens logging driver. For more information on configuring Firelens, see `Send Amazon ECS logs to an AWS service or AWS Partner <https://docs.aws.amazon.com//AmazonECS/latest/developerguide/using_firelens.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
             - **awslogs** - Specifies the Amazon CloudWatch Logs logging driver. For more information, see `Using the awslogs log driver <https://docs.aws.amazon.com/batch/latest/userguide/using_awslogs.html>`_ in the *AWS Batch User Guide* and `Amazon CloudWatch Logs logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/awslogs/>`_ in the Docker documentation.
             - **fluentd** - Specifies the Fluentd logging driver. For more information including usage and options, see `Fluentd logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/fluentd/>`_ in the *Docker documentation* .
             - **gelf** - Specifies the Graylog Extended Format (GELF) logging driver. For more information including usage and options, see `Graylog Extended Format logging driver <https://docs.aws.amazon.com/https://docs.docker.com/config/containers/logging/gelf/>`_ in the *Docker documentation* .
@@ -6846,6 +6987,14 @@ class CfnJobDefinition(
                                 value="value"
                             )],
                             essential=False,
+                            firelens_configuration=batch.CfnJobDefinition.FirelensConfigurationProperty(
+                                type="type",
+                
+                                # the properties below are optional
+                                options={
+                                    "options_key": "options"
+                                }
+                            ),
                             linux_parameters=batch.CfnJobDefinition.LinuxParametersProperty(
                                 devices=[batch.CfnJobDefinition.DeviceProperty(
                                     container_path="containerPath",
@@ -6900,6 +7049,7 @@ class CfnJobDefinition(
                             )],
                             user="user"
                         )],
+                        enable_execute_command=False,
                         execution_role_arn="executionRoleArn",
                         ipc_mode="ipcMode",
                         pid_mode="pidMode",
@@ -6964,6 +7114,7 @@ class CfnJobDefinition(
         jsii_struct_bases=[],
         name_mapping={
             "containers": "containers",
+            "enable_execute_command": "enableExecuteCommand",
             "execution_role_arn": "executionRoleArn",
             "ipc_mode": "ipcMode",
             "pid_mode": "pidMode",
@@ -6976,6 +7127,7 @@ class CfnJobDefinition(
             self,
             *,
             containers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.TaskContainerPropertiesProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+            enable_execute_command: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
             execution_role_arn: typing.Optional[builtins.str] = None,
             ipc_mode: typing.Optional[builtins.str] = None,
             pid_mode: typing.Optional[builtins.str] = None,
@@ -6987,6 +7139,7 @@ class CfnJobDefinition(
             You can specify which Docker images to use, the required resources, and other configurations related to launching the task definition through an Amazon ECS service or task.
 
             :param containers: This object is a list of containers.
+            :param enable_execute_command: Determines whether execute command functionality is turned on for this task. If ``true`` , execute command functionality is turned on all the containers in the task.
             :param execution_role_arn: The Amazon Resource Name (ARN) of the execution role that AWS Batch can assume. For jobs that run on Fargate resources, you must provide an execution role. For more information, see `AWS Batch execution IAM role <https://docs.aws.amazon.com/batch/latest/userguide/execution-IAM-role.html>`_ in the *AWS Batch User Guide* .
             :param ipc_mode: The IPC resource namespace to use for the containers in the task. The valid values are ``host`` , ``task`` , or ``none`` . If ``host`` is specified, all containers within the tasks that specified the ``host`` IPC mode on the same container instance share the same IPC resources with the host Amazon EC2 instance. If ``task`` is specified, all containers within the specified ``task`` share the same IPC resources. If ``none`` is specified, the IPC resources within the containers of a task are private, and are not shared with other containers in a task or on the container instance. If no value is specified, then the IPC resource namespace sharing depends on the Docker daemon setting on the container instance. For more information, see `IPC settings <https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#ipc-settings---ipc>`_ in the Docker run reference.
             :param pid_mode: The process namespace to use for the containers in the task. The valid values are ``host`` or ``task`` . For example, monitoring sidecars might need ``pidMode`` to access information about other containers running in the same task. If ``host`` is specified, all containers within the tasks that specified the ``host`` PID mode on the same container instance share the process namespace with the host Amazon EC2 instance. If ``task`` is specified, all containers within the specified task share the same process namespace. If no value is specified, the default is a private namespace for each container. For more information, see `PID settings <https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#pid-settings---pid>`_ in the Docker run reference.
@@ -7019,6 +7172,14 @@ class CfnJobDefinition(
                             value="value"
                         )],
                         essential=False,
+                        firelens_configuration=batch.CfnJobDefinition.FirelensConfigurationProperty(
+                            type="type",
+                
+                            # the properties below are optional
+                            options={
+                                "options_key": "options"
+                            }
+                        ),
                         linux_parameters=batch.CfnJobDefinition.LinuxParametersProperty(
                             devices=[batch.CfnJobDefinition.DeviceProperty(
                                 container_path="containerPath",
@@ -7073,6 +7234,7 @@ class CfnJobDefinition(
                         )],
                         user="user"
                     )],
+                    enable_execute_command=False,
                     execution_role_arn="executionRoleArn",
                     ipc_mode="ipcMode",
                     pid_mode="pidMode",
@@ -7100,6 +7262,7 @@ class CfnJobDefinition(
             if __debug__:
                 type_hints = typing.get_type_hints(_typecheckingstub__cb3ca5619c68fc8ff93d966eb183ea114ed6764e99467d7b283af54300b4b5ca)
                 check_type(argname="argument containers", value=containers, expected_type=type_hints["containers"])
+                check_type(argname="argument enable_execute_command", value=enable_execute_command, expected_type=type_hints["enable_execute_command"])
                 check_type(argname="argument execution_role_arn", value=execution_role_arn, expected_type=type_hints["execution_role_arn"])
                 check_type(argname="argument ipc_mode", value=ipc_mode, expected_type=type_hints["ipc_mode"])
                 check_type(argname="argument pid_mode", value=pid_mode, expected_type=type_hints["pid_mode"])
@@ -7108,6 +7271,8 @@ class CfnJobDefinition(
             self._values: typing.Dict[builtins.str, typing.Any] = {}
             if containers is not None:
                 self._values["containers"] = containers
+            if enable_execute_command is not None:
+                self._values["enable_execute_command"] = enable_execute_command
             if execution_role_arn is not None:
                 self._values["execution_role_arn"] = execution_role_arn
             if ipc_mode is not None:
@@ -7130,6 +7295,19 @@ class CfnJobDefinition(
             result = self._values.get("containers")
             return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnJobDefinition.TaskContainerPropertiesProperty"]]]], result)
 
+        @builtins.property
+        def enable_execute_command(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''Determines whether execute command functionality is turned on for this task.
+
+            If ``true`` , execute command functionality is turned on all the containers in the task.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-multinodeecstaskproperties.html#cfn-batch-jobdefinition-multinodeecstaskproperties-enableexecutecommand
+            '''
+            result = self._values.get("enable_execute_command")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
         @builtins.property
         def execution_role_arn(self) -> typing.Optional[builtins.str]:
             '''The Amazon Resource Name (ARN) of the execution role that AWS Batch can assume.
@@ -7329,6 +7507,7 @@ class CfnJobDefinition(
                 
                             # the properties below are optional
                             command=["command"],
+                            enable_execute_command=False,
                             environment=[batch.CfnJobDefinition.EnvironmentProperty(
                                 name="name",
                                 value="value"
@@ -7438,6 +7617,14 @@ class CfnJobDefinition(
                                         value="value"
                                     )],
                                     essential=False,
+                                    firelens_configuration=batch.CfnJobDefinition.FirelensConfigurationProperty(
+                                        type="type",
+                
+                                        # the properties below are optional
+                                        options={
+                                            "options_key": "options"
+                                        }
+                                    ),
                                     linux_parameters=batch.CfnJobDefinition.LinuxParametersProperty(
                                         devices=[batch.CfnJobDefinition.DeviceProperty(
                                             container_path="containerPath",
@@ -7492,6 +7679,7 @@ class CfnJobDefinition(
                                     )],
                                     user="user"
                                 )],
+                                enable_execute_command=False,
                                 execution_role_arn="executionRoleArn",
                                 ipc_mode="ipcMode",
                                 pid_mode="pidMode",
@@ -7742,6 +7930,7 @@ class CfnJobDefinition(
                 
                         # the properties below are optional
                         command=["command"],
+                        enable_execute_command=False,
                         environment=[batch.CfnJobDefinition.EnvironmentProperty(
                             name="name",
                             value="value"
@@ -7851,6 +8040,14 @@ class CfnJobDefinition(
                                     value="value"
                                 )],
                                 essential=False,
+                                firelens_configuration=batch.CfnJobDefinition.FirelensConfigurationProperty(
+                                    type="type",
+                
+                                    # the properties below are optional
+                                    options={
+                                        "options_key": "options"
+                                    }
+                                ),
                                 linux_parameters=batch.CfnJobDefinition.LinuxParametersProperty(
                                     devices=[batch.CfnJobDefinition.DeviceProperty(
                                         container_path="containerPath",
@@ -7905,6 +8102,7 @@ class CfnJobDefinition(
                                 )],
                                 user="user"
                             )],
+                            enable_execute_command=False,
                             execution_role_arn="executionRoleArn",
                             ipc_mode="ipcMode",
                             pid_mode="pidMode",
@@ -9129,6 +9327,7 @@ class CfnJobDefinition(
             "depends_on": "dependsOn",
             "environment": "environment",
             "essential": "essential",
+            "firelens_configuration": "firelensConfiguration",
             "linux_parameters": "linuxParameters",
             "log_configuration": "logConfiguration",
             "mount_points": "mountPoints",
@@ -9151,6 +9350,7 @@ class CfnJobDefinition(
             depends_on: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.TaskContainerDependencyProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             environment: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.EnvironmentProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             essential: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+            firelens_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.FirelensConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             linux_parameters: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.LinuxParametersProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             log_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.LogConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             mount_points: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.MountPointProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
@@ -9172,6 +9372,7 @@ class CfnJobDefinition(
             :param depends_on: A list of containers that this container depends on.
             :param environment: The environment variables to pass to a container. This parameter maps to Env in the `Create a container <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.23/#create-a-container>`_ section of the `Docker Remote API <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.23/>`_ and the ``--env`` parameter to `docker run <https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/>`_ . .. epigraph:: We don't recommend using plaintext environment variables for sensitive information, such as credential data. > Environment variables cannot start with ``AWS_BATCH`` . This naming convention is reserved for variables that AWS Batch sets.
             :param essential: If the essential parameter of a container is marked as ``true`` , and that container fails or stops for any reason, all other containers that are part of the task are stopped. If the ``essential`` parameter of a container is marked as false, its failure doesn't affect the rest of the containers in a task. If this parameter is omitted, a container is assumed to be essential. All jobs must have at least one essential container. If you have an application that's composed of multiple containers, group containers that are used for a common purpose into components, and separate the different components into multiple task definitions. For more information, see `Application Architecture <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/application_architecture.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
+            :param firelens_configuration: The FireLens configuration for the container. This is used to specify and configure a log router for container logs. For more information, see `Custom log <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html>`_ routing in the *Amazon Elastic Container Service Developer Guide* .
             :param linux_parameters: Linux-specific modifications that are applied to the container, such as Linux kernel capabilities. For more information, see `KernelCapabilities <https://docs.aws.amazon.com/AmazonECS/latest/APIReference/API_KernelCapabilities.html>`_ .
             :param log_configuration: The log configuration specification for the container. This parameter maps to ``LogConfig`` in the `Create a container <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate>`_ section of the `Docker Remote API <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/>`_ and the ``--log-driver`` option to `docker run <https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration>`_ . By default, containers use the same logging driver that the Docker daemon uses. However the container can use a different logging driver than the Docker daemon by specifying a log driver with this parameter in the container definition. To use a different logging driver for a container, the log system must be configured properly on the container instance (or on a different log server for remote logging options). For more information about the options for different supported log drivers, see `Configure logging drivers <https://docs.aws.amazon.com/https://docs.docker.com/engine/admin/logging/overview/>`_ in the *Docker documentation* . .. epigraph:: Amazon ECS currently supports a subset of the logging drivers available to the Docker daemon (shown in the ``LogConfiguration`` data type). Additional log drivers may be available in future releases of the Amazon ECS container agent. This parameter requires version 1.18 of the Docker Remote API or greater on your container instance. To check the Docker Remote API version on your container instance, log in to your container instance and run the following command: sudo docker version ``--format '{{.Server.APIVersion}}'`` .. epigraph:: The Amazon ECS container agent running on a container instance must register the logging drivers available on that instance with the ``ECS_AVAILABLE_LOGGING_DRIVERS`` environment variable before containers placed on that instance can use these log configuration options. For more information, see `Amazon ECS container agent configuration <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-agent-config.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
             :param mount_points: The mount points for data volumes in your container. This parameter maps to ``Volumes`` in the `Create a container <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/#operation/ContainerCreate>`_ section of the `Docker Remote API <https://docs.aws.amazon.com/https://docs.docker.com/engine/api/v1.35/>`_ and the `--volume <https://docs.aws.amazon.com/>`_ option to `docker run <https://docs.aws.amazon.com/https://docs.docker.com/engine/reference/run/#security-configuration>`_ . Windows containers can mount whole directories on the same drive as ``$env:ProgramData`` . Windows containers can't mount directories on a different drive, and mount point can't be across drives.
@@ -9209,6 +9410,14 @@ class CfnJobDefinition(
                         value="value"
                     )],
                     essential=False,
+                    firelens_configuration=batch.CfnJobDefinition.FirelensConfigurationProperty(
+                        type="type",
+                
+                        # the properties below are optional
+                        options={
+                            "options_key": "options"
+                        }
+                    ),
                     linux_parameters=batch.CfnJobDefinition.LinuxParametersProperty(
                         devices=[batch.CfnJobDefinition.DeviceProperty(
                             container_path="containerPath",
@@ -9271,6 +9480,7 @@ class CfnJobDefinition(
                 check_type(argname="argument depends_on", value=depends_on, expected_type=type_hints["depends_on"])
                 check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
                 check_type(argname="argument essential", value=essential, expected_type=type_hints["essential"])
+                check_type(argname="argument firelens_configuration", value=firelens_configuration, expected_type=type_hints["firelens_configuration"])
                 check_type(argname="argument linux_parameters", value=linux_parameters, expected_type=type_hints["linux_parameters"])
                 check_type(argname="argument log_configuration", value=log_configuration, expected_type=type_hints["log_configuration"])
                 check_type(argname="argument mount_points", value=mount_points, expected_type=type_hints["mount_points"])
@@ -9293,6 +9503,8 @@ class CfnJobDefinition(
                 self._values["environment"] = environment
             if essential is not None:
                 self._values["essential"] = essential
+            if firelens_configuration is not None:
+                self._values["firelens_configuration"] = firelens_configuration
             if linux_parameters is not None:
                 self._values["linux_parameters"] = linux_parameters
             if log_configuration is not None:
@@ -9381,6 +9593,19 @@ class CfnJobDefinition(
             result = self._values.get("essential")
             return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
 
+        @builtins.property
+        def firelens_configuration(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnJobDefinition.FirelensConfigurationProperty"]]:
+            '''The FireLens configuration for the container.
+
+            This is used to specify and configure a log router for container logs. For more information, see `Custom log <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/using_firelens.html>`_ routing in the *Amazon Elastic Container Service Developer Guide* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-taskcontainerproperties.html#cfn-batch-jobdefinition-taskcontainerproperties-firelensconfiguration
+            '''
+            result = self._values.get("firelens_configuration")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnJobDefinition.FirelensConfigurationProperty"]], result)
+
         @builtins.property
         def linux_parameters(
             self,
@@ -11060,7 +11285,7 @@ class CfnSchedulingPolicy(
             '''The fair-share scheduling policy details.
 
             :param compute_reservation: A value used to reserve some of the available maximum vCPU for share identifiers that aren't already used. The reserved ratio is ``( *computeReservation* /100)^ *ActiveFairShares*`` where ``*ActiveFairShares*`` is the number of active share identifiers. For example, a ``computeReservation`` value of 50 indicates that AWS Batch reserves 50% of the maximum available vCPU if there's only one share identifier. It reserves 25% if there are two share identifiers. It reserves 12.5% if there are three share identifiers. A ``computeReservation`` value of 25 indicates that AWS Batch should reserve 25% of the maximum available vCPU if there's only one share identifier, 6.25% if there are two fair share identifiers, and 1.56% if there are three share identifiers. The minimum value is 0 and the maximum value is 99.
-            :param share_decay_seconds: The amount of time (in seconds) to use to calculate a fair-share percentage for each share identifier in use. A value of zero (0) indicates the default minimum time window (600 seconds). The maximum supported value is 604800 (1 week). The decay allows for more recently run jobs to have more weight than jobs that ran earlier. Consider adjusting this number if you have jobs that (on average) run longer than ten minutes, or a large difference in job count or job run times between share identifiers, and the allocation of resources doesn’t meet your needs.
+            :param share_decay_seconds: The amount of time (in seconds) to use to calculate a fair-share percentage for each share identifier in use. A value of zero (0) indicates the default minimum time window (600 seconds). The maximum supported value is 604800 (1 week). The decay allows for more recently run jobs to have more weight than jobs that ran earlier. Consider adjusting this number if you have jobs that (on average) run longer than ten minutes, or a large difference in job count or job run times between share identifiers, and the allocation of resources doesn't meet your needs.
             :param share_distribution: An array of ``SharedIdentifier`` objects that contain the weights for the share identifiers for the fair-share policy. Share identifiers that aren't included have a default weight of ``1.0`` .
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-schedulingpolicy-fairsharepolicy.html
@@ -11115,7 +11340,7 @@ class CfnSchedulingPolicy(
 
             A value of zero (0) indicates the default minimum time window (600 seconds). The maximum supported value is 604800 (1 week).
 
-            The decay allows for more recently run jobs to have more weight than jobs that ran earlier. Consider adjusting this number if you have jobs that (on average) run longer than ten minutes, or a large difference in job count or job run times between share identifiers, and the allocation of resources doesn’t meet your needs.
+            The decay allows for more recently run jobs to have more weight than jobs that ran earlier. Consider adjusting this number if you have jobs that (on average) run longer than ten minutes, or a large difference in job count or job run times between share identifiers, and the allocation of resources doesn't meet your needs.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-schedulingpolicy-fairsharepolicy.html#cfn-batch-schedulingpolicy-fairsharepolicy-sharedecayseconds
             '''
@@ -24998,6 +25223,7 @@ def _typecheckingstub__09b3c38642739790560033cae597f009c106d353ddc5faf85f6a7bf48
     *,
     image: builtins.str,
     command: typing.Optional[typing.Sequence[builtins.str]] = None,
+    enable_execute_command: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     environment: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.EnvironmentProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     ephemeral_storage: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.EphemeralStorageProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     execution_role_arn: typing.Optional[builtins.str] = None,
@@ -25042,6 +25268,7 @@ def _typecheckingstub__6153a950309796a66c44ef3a234e02ed7ff91444107709427ae345e4f
 def _typecheckingstub__8e8c39be2b840a158045732ea20d964bf03d380304bbcd66936cb862e6cc2a8e(
     *,
     containers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.TaskContainerPropertiesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    enable_execute_command: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     ephemeral_storage: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.EphemeralStorageProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     execution_role_arn: typing.Optional[builtins.str] = None,
     ipc_mode: typing.Optional[builtins.str] = None,
@@ -25173,6 +25400,14 @@ def _typecheckingstub__2b088f865053d4cfdc2700de70d732a768d630a892a20da6fda19303d
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__012b674cbcf1ea538c209d328bedd805776a59df4892337af673d8b565f4f57d(
+    *,
+    type: builtins.str,
+    options: typing.Optional[typing.Union[typing.Mapping[builtins.str, builtins.str], _IResolvable_da3f097b]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__2bf55e035d36507c507c0ff620eda0a3096496a2cd5226656fc5e4af46e1b9ac(
     *,
     path: typing.Optional[builtins.str] = None,
@@ -25250,6 +25485,7 @@ def _typecheckingstub__9a2309f896452e04abc96277b3c04ead84cbae39e501242083e44da7e
 def _typecheckingstub__cb3ca5619c68fc8ff93d966eb183ea114ed6764e99467d7b283af54300b4b5ca(
     *,
     containers: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.TaskContainerPropertiesProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    enable_execute_command: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     execution_role_arn: typing.Optional[builtins.str] = None,
     ipc_mode: typing.Optional[builtins.str] = None,
     pid_mode: typing.Optional[builtins.str] = None,
@@ -25376,6 +25612,7 @@ def _typecheckingstub__4946f5f042ef067bff74424b1b71c92ab13e52a7f47a4271e02811052
     depends_on: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.TaskContainerDependencyProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     environment: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.EnvironmentProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     essential: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+    firelens_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.FirelensConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     linux_parameters: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.LinuxParametersProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     log_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.LogConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     mount_points: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.MountPointProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,