aws-cdk-lib 2.200.2__py3-none-any.whl → 2.224.0__py3-none-any.whl

aws_cdk/aws_batch/__init__.py

@@ -66,7 +66,18 @@ For stateful or otherwise non-interruption-tolerant workflows, omit `spot` or se
 
 #### Choosing Your Instance Types
 
-Batch allows you to choose the instance types or classes that will run your workload.
+Batch allows you to choose most up-to-date instance classes based on your region.
+This example configures your `ComputeEnvironment` to use only ARM64 instance:
+
+```python
+vpc = ec2.Vpc(self, "VPC")
+
+batch.ManagedEc2EcsComputeEnvironment(self, "myEc2ComputeEnv",
+    vpc=vpc,
+    default_instance_classes=[batch.DefaultInstanceClass.ARM64]
+)
+```
+
 This example configures your `ComputeEnvironment` to use only the `M5AD.large` instance:
 
 ```python
@@ -91,6 +102,9 @@ batch.ManagedEc2EcsComputeEnvironment(self, "myEc2ComputeEnv",
 )
 ```
 
+> [!WARNING]
+> `useOptimalInstanceClasses` is deprecated! Use `defaultInstanceClasses` instead.
+
 Unless you explicitly specify `useOptimalInstanceClasses: false`, this compute environment will use `'optimal'` instances,
 which tells Batch to pick an instance from the C4, M4, and R4 instance families.
 *Note*: Batch does not allow specifying instance types or classes with different architectures.
@@ -533,6 +547,40 @@ job_defn = batch.EcsJobDefinition(self, "JobDefn",
 )
 ```
 
+### Enable Execute Command (ECS Exec)
+
+You can enable [ECS Exec](https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html) for interactive debugging and troubleshooting by setting `enableExecuteCommand` to `true`.
+When enabled, you'll be able to execute commands interactively in running containers.
+
+```python
+job_defn = batch.EcsJobDefinition(self, "JobDefn",
+    container=batch.EcsEc2ContainerDefinition(self, "Ec2Container",
+        image=ecs.ContainerImage.from_registry("public.ecr.aws/amazonlinux/amazonlinux:latest"),
+        memory=cdk.Size.mebibytes(2048),
+        cpu=256,
+        enable_execute_command=True
+    )
+)
+```
+
+The same functionality is available for Fargate containers:
+
+```python
+job_defn = batch.EcsJobDefinition(self, "JobDefn",
+    container=batch.EcsFargateContainerDefinition(self, "FargateContainer",
+        image=ecs.ContainerImage.from_registry("public.ecr.aws/amazonlinux/amazonlinux:latest"),
+        memory=cdk.Size.mebibytes(2048),
+        cpu=256,
+        enable_execute_command=True
+    )
+)
+```
+
+When `enableExecuteCommand` is set to `true`:
+
+* If no `jobRole` is provided, a new IAM role will be automatically created with the required SSM permissions
+* If a `jobRole` is already provided, the necessary SSM permissions will be added to the existing role
+
 ### Secrets
 
 You can expose SecretsManager Secret ARNs or SSM Parameters to your container as environment variables.
@@ -792,6 +840,21 @@ from ..aws_iam import (
 )
 from ..aws_secretsmanager import ISecret as _ISecret_6e020e6a
 from ..aws_ssm import IParameter as _IParameter_509a0f80
+from ..interfaces.aws_batch import (
+    ComputeEnvironmentReference as _ComputeEnvironmentReference_74ec9988,
+    ConsumableResourceReference as _ConsumableResourceReference_eb60ef1d,
+    IComputeEnvironmentRef as _IComputeEnvironmentRef_eab02155,
+    IConsumableResourceRef as _IConsumableResourceRef_114da7c5,
+    IJobDefinitionRef as _IJobDefinitionRef_ae0cae56,
+    IJobQueueRef as _IJobQueueRef_2f1c7bda,
+    ISchedulingPolicyRef as _ISchedulingPolicyRef_a7864c7c,
+    IServiceEnvironmentRef as _IServiceEnvironmentRef_5865fef4,
+    JobDefinitionReference as _JobDefinitionReference_e67f0e8f,
+    JobQueueReference as _JobQueueReference_1a1e9db8,
+    SchedulingPolicyReference as _SchedulingPolicyReference_a55795c6,
+    ServiceEnvironmentReference as _ServiceEnvironmentReference_9a7dc7ee,
+)
+from ..interfaces.aws_ec2 import IPlacementGroupRef as _IPlacementGroupRef_5d6e601f
 
 
 @jsii.enum(jsii_type="aws-cdk-lib.aws_batch.Action")
@@ -886,7 +949,7 @@ class AllocationStrategy(enum.Enum):
     '''
 
 
-@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
+@jsii.implements(_IInspectable_c2943556, _IComputeEnvironmentRef_eab02155, _ITaggable_36806126)
 class CfnComputeEnvironment(
     _CfnResource_9df397a6,
     metaclass=jsii.JSIIMeta,
@@ -970,8 +1033,10 @@ class CfnComputeEnvironment(
                         launch_template_id="launchTemplateId",
                         launch_template_name="launchTemplateName",
                         target_instance_types=["targetInstanceTypes"],
+                        userdata_type="userdataType",
                         version="version"
                     )],
+                    userdata_type="userdataType",
                     version="version"
                 ),
                 minv_cpus=123,
@@ -1019,14 +1084,15 @@ class CfnComputeEnvironment(
         unmanagedv_cpus: typing.Optional[jsii.Number] = None,
         update_policy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnComputeEnvironment.UpdatePolicyProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
-        '''
+        '''Create a new ``AWS::Batch::ComputeEnvironment``.
+
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
         :param type: The type of the compute environment: ``MANAGED`` or ``UNMANAGED`` . For more information, see `Compute Environments <https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html>`_ in the *AWS Batch User Guide* .
         :param compute_environment_name: The name for your compute environment. It can be up to 128 characters long. It can contain uppercase and lowercase letters, numbers, hyphens (-), and underscores (_).
         :param compute_resources: The ComputeResources property type specifies details of the compute resources managed by the compute environment. This parameter is required for managed compute environments. For more information, see `Compute Environments <https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html>`_ in the ** .
         :param context: Reserved.
-        :param eks_configuration: The details for the Amazon EKS cluster that supports the compute environment.
+        :param eks_configuration: The details for the Amazon EKS cluster that supports the compute environment. .. epigraph:: To create a compute environment that uses EKS resources, the caller must have permissions to call ``eks:DescribeCluster`` .
         :param replace_compute_environment: Specifies whether the compute environment is replaced if an update is made that requires replacing the instances in the compute environment. The default value is ``true`` . To enable more properties to be updated, set this property to ``false`` . When changing the value of this property to ``false`` , do not change any other properties at the same time. If other properties are changed at the same time, and the change needs to be rolled back but it can't, it's possible for the stack to go into the ``UPDATE_ROLLBACK_FAILED`` state. You can't update a stack that is in the ``UPDATE_ROLLBACK_FAILED`` state. However, if you can continue to roll it back, you can return the stack to its original settings and then try to update it again. For more information, see `Continue rolling back an update <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-continueupdaterollback.html>`_ in the *AWS CloudFormation User Guide* . ``ReplaceComputeEnvironment`` is not applicable for Fargate compute environments. Fargate compute environments are always updated without interruption. The properties that can't be changed without replacing the compute environment are in the ```ComputeResources`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html>`_ property type: ```AllocationStrategy`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-allocationstrategy>`_ , ```BidPercentage`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-bidpercentage>`_ , ```Ec2Configuration`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-ec2configuration>`_ , ```Ec2KeyPair`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-ec2keypair>`_ , ```Ec2KeyPair`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-ec2keypair>`_ , ```ImageId`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-imageid>`_ , ```InstanceRole`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-instancerole>`_ , ```InstanceTypes`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-instancetypes>`_ , ```LaunchTemplate`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-launchtemplate>`_ , ```MaxvCpus`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-maxvcpus>`_ , ```MinvCpus`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-minvcpus>`_ , ```PlacementGroup`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-placementgroup>`_ , ```SecurityGroupIds`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-securitygroupids>`_ , ```Subnets`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-subnets>`_ , `Tags <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-tags>`_ , ```Type`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-type>`_ , and ```UpdateToLatestImageVersion`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-updatetolatestimageversion>`_ . Default: - true
         :param service_role: The full Amazon Resource Name (ARN) of the IAM role that allows AWS Batch to make calls to other AWS services on your behalf. For more information, see `AWS Batch service IAM role <https://docs.aws.amazon.com/batch/latest/userguide/service_IAM_role.html>`_ in the *AWS Batch User Guide* . .. epigraph:: If your account already created the AWS Batch service-linked role, that role is used by default for your compute environment unless you specify a different role here. If the AWS Batch service-linked role doesn't exist in your account, and no role is specified here, the service attempts to create the AWS Batch service-linked role in your account. If your specified role has a path other than ``/`` , then you must specify either the full role ARN (recommended) or prefix the role name with the path. For example, if a role with the name ``bar`` has a path of ``/foo/`` , specify ``/foo/bar`` as the role name. For more information, see `Friendly names and paths <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-friendly-names>`_ in the *IAM User Guide* . .. epigraph:: Depending on how you created your AWS Batch service role, its ARN might contain the ``service-role`` path prefix. When you only specify the name of the service role, AWS Batch assumes that your ARN doesn't use the ``service-role`` path prefix. Because of this, we recommend that you specify the full ARN of your service role when you create compute environments.
         :param state: The state of the compute environment. If the state is ``ENABLED`` , then the compute environment accepts jobs from a queue and can scale out automatically based on queues. If the state is ``ENABLED`` , then the AWS Batch scheduler can attempt to place jobs from an associated job queue on the compute resources within the environment. If the compute environment is managed, then it can scale its instances out or in automatically, based on the job queue demand. If the state is ``DISABLED`` , then the AWS Batch scheduler doesn't attempt to place jobs within the environment. Jobs in a ``STARTING`` or ``RUNNING`` state continue to progress normally. Managed compute environments in the ``DISABLED`` state don't scale out. .. epigraph:: Compute environments in a ``DISABLED`` state may continue to incur billing charges. To prevent additional charges, turn off and then delete the compute environment. For more information, see `State <https://docs.aws.amazon.com/batch/latest/userguide/compute_environment_parameters.html#compute_environment_state>`_ in the *AWS Batch User Guide* . When an instance is idle, the instance scales down to the ``minvCpus`` value. However, the instance size doesn't change. For example, consider a ``c5.8xlarge`` instance with a ``minvCpus`` value of ``4`` and a ``desiredvCpus`` value of ``36`` . This instance doesn't scale down to a ``c5.large`` instance.
@@ -1098,6 +1164,12 @@ class CfnComputeEnvironment(
     def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
         return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))
 
+    @builtins.property
+    @jsii.member(jsii_name="computeEnvironmentRef")
+    def compute_environment_ref(self) -> _ComputeEnvironmentReference_74ec9988:
+        '''A reference to a ComputeEnvironment resource.'''
+        return typing.cast(_ComputeEnvironmentReference_74ec9988, jsii.get(self, "computeEnvironmentRef"))
+
     @builtins.property
     @jsii.member(jsii_name="tags")
     def tags(self) -> _TagManager_0a598cb3:
@@ -1331,7 +1403,7 @@ class CfnComputeEnvironment(
             :param ec2_key_pair: The Amazon EC2 key pair that's used for instances launched in the compute environment. You can use this key pair to log in to your instances with SSH. To remove the Amazon EC2 key pair, set this value to an empty string. When updating a compute environment, changing the Amazon EC2 key pair 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 image_id: The Amazon Machine Image (AMI) ID used for instances launched in the compute environment. This parameter is overridden by the ``imageIdOverride`` member of the ``Ec2Configuration`` structure. To remove the custom AMI ID and use the default AMI ID, set this value to an empty string. When updating a compute environment, changing the AMI ID 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. > The AMI that you choose for a compute environment must match the architecture of the instance types that you intend to use for that compute environment. For example, if your compute environment uses A1 instance types, the compute resource AMI that you choose must support ARM instances. Amazon ECS vends both x86 and ARM versions of the Amazon ECS-optimized Amazon Linux 2 AMI. For more information, see `Amazon ECS-optimized Amazon Linux 2 AMI <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#ecs-optimized-ami-linux-variants.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
             :param instance_role: The Amazon ECS instance profile applied to Amazon EC2 instances in a compute environment. Required for Amazon EC2 instances. You can specify the short name or full Amazon Resource Name (ARN) of an instance profile. For example, ``*ecsInstanceRole*`` or ``arn:aws:iam:: *<aws_account_id>* :instance-profile/ *ecsInstanceRole*`` . For more information, see `Amazon ECS instance role <https://docs.aws.amazon.com/batch/latest/userguide/instance_IAM_role.html>`_ 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* . .. epigraph:: This parameter isn't applicable to jobs that are running on Fargate resources. Don't specify it.
-            :param instance_types: The instances types that can be launched. You can specify instance families to launch any instance type within those families (for example, ``c5`` or ``p3`` ), or you can specify specific sizes within a family (such as ``c5.8xlarge`` ). You can also choose ``optimal`` to select instance types (from the C4, M4, and R4 instance families) that match the demand of your job queues. 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. > When you create a compute environment, the instance types that you select for the compute environment must share the same architecture. For example, you can't mix x86 and ARM instances in the same compute environment. > Currently, ``optimal`` uses instance types from the C4, M4, and R4 instance families. In Regions that don't have instance types from those instance families, instance types from the C5, M5, and R5 instance families are used.
+            :param instance_types: The instances types that can be launched. You can specify instance families to launch any instance type within those families (for example, ``c5`` or ``p3`` ), or you can specify specific sizes within a family (such as ``c5.8xlarge`` ). AWS Batch can select the instance type for you if you choose one of the following: - ``optimal`` to select instance types (from the ``c4`` , ``m4`` , ``r4`` , ``c5`` , ``m5`` , and ``r5`` instance families) that match the demand of your job queues. - ``default_x86_64`` to choose x86 based instance types (from the ``m6i`` , ``c6i`` , ``r6i`` , and ``c7i`` instance families) that matches the resource demands of the job queue. - ``default_arm64`` to choose x86 based instance types (from the ``m6g`` , ``c6g`` , ``r6g`` , and ``c7g`` instance families) that matches the resource demands of the job queue. .. epigraph:: Starting on 11/01/2025 the behavior of ``optimal`` is going to be changed to match ``default_x86_64`` . During the change your instance families could be updated to a newer generation. You do not need to perform any actions for the upgrade to happen. For more information about change, see `Optimal instance type configuration to receive automatic instance family updates <https://docs.aws.amazon.com/batch/latest/userguide/optimal-default-instance-troubleshooting.html>`_ . > Instance family availability varies by AWS Region . For example, some AWS Region s may not have any fourth generation instance families but have fifth and sixth generation instance families. When using ``default_x86_64`` or ``default_arm64`` instance bundles, AWS Batch selects instance families based on a balance of cost-effectiveness and performance. While newer generation instances often provide better price-performance, AWS Batch may choose an earlier generation instance family if it provides the optimal combination of availability, cost, and performance for your workload. For example, in an AWS Region where both c6i and c7i instances are available, AWS Batch might select c6i instances if they offer better cost-effectiveness for your specific job requirements. For more information on AWS Batch instance types and AWS Region availability, see `Instance type compute table <https://docs.aws.amazon.com/batch/latest/userguide/instance-type-compute-table.html>`_ in the *AWS Batch User Guide* . AWS Batch periodically updates your instances in default bundles to newer, more cost-effective options. Updates happen automatically without requiring any action from you. Your workloads continue running during updates with no interruption > This parameter isn't applicable to jobs that are running on Fargate resources. Don't specify it. > When you create a compute environment, the instance types that you select for the compute environment must share the same architecture. For example, you can't mix x86 and ARM instances in the same compute environment.
             :param launch_template: The launch template to use for your compute resources. Any other compute resource parameters that you specify in a `CreateComputeEnvironment <https://docs.aws.amazon.com/batch/latest/APIReference/API_CreateComputeEnvironment.html>`_ API operation override the same parameters in the launch template. You must specify either the launch template ID or launch template name in the request, but not both. For more information, see `Launch Template Support <https://docs.aws.amazon.com/batch/latest/userguide/launch-templates.html>`_ in the ** . Removing the launch template from a compute environment will not remove the AMI specified in the launch template. In order to update the AMI specified in a launch template, the ``updateToLatestImageVersion`` parameter must be set to ``true`` . When updating a compute environment, changing the launch template 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 ** . .. epigraph:: This parameter isn't applicable to jobs running on Fargate resources, and shouldn't be specified.
             :param minv_cpus: The minimum number of vCPUs that an environment should maintain (even if the compute environment is ``DISABLED`` ). .. epigraph:: This parameter isn't applicable to jobs that are running on Fargate resources. Don't specify it.
             :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.
@@ -1376,8 +1448,10 @@ class CfnComputeEnvironment(
                             launch_template_id="launchTemplateId",
                             launch_template_name="launchTemplateName",
                             target_instance_types=["targetInstanceTypes"],
+                            userdata_type="userdataType",
                             version="version"
                         )],
+                        userdata_type="userdataType",
                         version="version"
                     ),
                     minv_cpus=123,
@@ -1628,12 +1702,21 @@ class CfnComputeEnvironment(
         def instance_types(self) -> typing.Optional[typing.List[builtins.str]]:
             '''The instances types that can be launched.
 
-            You can specify instance families to launch any instance type within those families (for example, ``c5`` or ``p3`` ), or you can specify specific sizes within a family (such as ``c5.8xlarge`` ). You can also choose ``optimal`` to select instance types (from the C4, M4, and R4 instance families) that match the demand of your job queues.
+            You can specify instance families to launch any instance type within those families (for example, ``c5`` or ``p3`` ), or you can specify specific sizes within a family (such as ``c5.8xlarge`` ).
+
+            AWS Batch can select the instance type for you if you choose one of the following:
+
+            - ``optimal`` to select instance types (from the ``c4`` , ``m4`` , ``r4`` , ``c5`` , ``m5`` , and ``r5`` instance families) that match the demand of your job queues.
+            - ``default_x86_64`` to choose x86 based instance types (from the ``m6i`` , ``c6i`` , ``r6i`` , and ``c7i`` instance families) that matches the resource demands of the job queue.
+            - ``default_arm64`` to choose x86 based instance types (from the ``m6g`` , ``c6g`` , ``r6g`` , and ``c7g`` instance families) that matches the resource demands of the job queue.
 
-            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. > When you create a compute environment, the instance types that you select for the compute environment must share the same architecture. For example, you can't mix x86 and ARM instances in the same compute environment. > Currently, ``optimal`` uses instance types from the C4, M4, and R4 instance families. In Regions that don't have instance types from those instance families, instance types from the C5, M5, and R5 instance families are used.
+               Starting on 11/01/2025 the behavior of ``optimal`` is going to be changed to match ``default_x86_64`` . During the change your instance families could be updated to a newer generation. You do not need to perform any actions for the upgrade to happen. For more information about change, see `Optimal instance type configuration to receive automatic instance family updates <https://docs.aws.amazon.com/batch/latest/userguide/optimal-default-instance-troubleshooting.html>`_ . > Instance family availability varies by AWS Region . For example, some AWS Region s may not have any fourth generation instance families but have fifth and sixth generation instance families.
+
+               When using ``default_x86_64`` or ``default_arm64`` instance bundles, AWS Batch selects instance families based on a balance of cost-effectiveness and performance. While newer generation instances often provide better price-performance, AWS Batch may choose an earlier generation instance family if it provides the optimal combination of availability, cost, and performance for your workload. For example, in an AWS Region where both c6i and c7i instances are available, AWS Batch might select c6i instances if they offer better cost-effectiveness for your specific job requirements. For more information on AWS Batch instance types and AWS Region availability, see `Instance type compute table <https://docs.aws.amazon.com/batch/latest/userguide/instance-type-compute-table.html>`_ in the *AWS Batch User Guide* .
+
+               AWS Batch periodically updates your instances in default bundles to newer, more cost-effective options. Updates happen automatically without requiring any action from you. Your workloads continue running during updates with no interruption > This parameter isn't applicable to jobs that are running on Fargate resources. Don't specify it. > When you create a compute environment, the instance types that you select for the compute environment must share the same architecture. For example, you can't mix x86 and ARM instances in the same compute environment.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-instancetypes
             '''
@@ -1785,7 +1868,7 @@ class CfnComputeEnvironment(
 
                This object isn't applicable to jobs that are running on Fargate resources.
 
-            :param image_type: The image type to match with the instance type to select an AMI. The supported values are different for ``ECS`` and ``EKS`` resources. - **ECS** - If the ``imageIdOverride`` parameter isn't specified, then a recent `Amazon ECS-optimized Amazon Linux 2 AMI <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#al2ami>`_ ( ``ECS_AL2`` ) is used. If a new image type is specified in an update, but neither an ``imageId`` nor a ``imageIdOverride`` parameter is specified, then the latest Amazon ECS optimized AMI for that image type that's supported by AWS Batch is used. - **ECS_AL2** - `Amazon Linux 2 <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#al2ami>`_ : Default for all non-GPU instance families. - **ECS_AL2_NVIDIA** - `Amazon Linux 2 (GPU) <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#gpuami>`_ : Default for all GPU instance families (for example ``P4`` and ``G4`` ) and can be used for all non AWS Graviton-based instance types. - **ECS_AL2023** - `Amazon Linux 2023 <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html>`_ : AWS Batch supports Amazon Linux 2023. .. epigraph:: Amazon Linux 2023 does not support ``A1`` instances. - **ECS_AL1** - `Amazon Linux <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#alami>`_ . Amazon Linux has reached the end-of-life of standard support. For more information, see `Amazon Linux AMI <https://docs.aws.amazon.com/amazon-linux-ami/>`_ . - **EKS** - If the ``imageIdOverride`` parameter isn't specified, then a recent `Amazon EKS-optimized Amazon Linux AMI <https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html>`_ ( ``EKS_AL2`` ) is used. If a new image type is specified in an update, but neither an ``imageId`` nor a ``imageIdOverride`` parameter is specified, then the latest Amazon EKS optimized AMI for that image type that AWS Batch supports is used. - **EKS_AL2** - `Amazon Linux 2 <https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html>`_ : Default for all non-GPU instance families. - **EKS_AL2_NVIDIA** - `Amazon Linux 2 (accelerated) <https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html>`_ : Default for all GPU instance families (for example, ``P4`` and ``G4`` ) and can be used for all non AWS Graviton-based instance types.
+            :param image_type: The image type to match with the instance type to select an AMI. The supported values are different for ``ECS`` and ``EKS`` resources. - **ECS** - If the ``imageIdOverride`` parameter isn't specified, then a recent `Amazon ECS-optimized Amazon Linux 2 AMI <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#al2ami>`_ ( ``ECS_AL2`` ) is used. If a new image type is specified in an update, but neither an ``imageId`` nor a ``imageIdOverride`` parameter is specified, then the latest Amazon ECS optimized AMI for that image type that's supported by AWS Batch is used. .. epigraph:: AWS will end support for Amazon ECS optimized AL2-optimized and AL2-accelerated AMIs. Starting in January 2026, AWS Batch will change the default AMI for new Amazon ECS compute environments from Amazon Linux 2 to Amazon Linux 2023. We recommend migrating AWS Batch Amazon ECS compute environments to Amazon Linux 2023 to maintain optimal performance and security. For more information on upgrading from AL2 to AL2023, see `How to migrate from ECS AL2 to ECS AL2023 <https://docs.aws.amazon.com/batch/latest/userguide/ecs-migration-2023.html>`_ in the *AWS Batch User Guide* . - **ECS_AL2** - `Amazon Linux 2 <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#al2ami>`_ : Default for all non-GPU instance families. - **ECS_AL2_NVIDIA** - `Amazon Linux 2 (GPU) <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#gpuami>`_ : Default for all GPU instance families (for example ``P4`` and ``G4`` ) and can be used for all non AWS Graviton-based instance types. - **ECS_AL2023** - `Amazon Linux 2023 <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html>`_ : AWS Batch supports Amazon Linux 2023. .. epigraph:: Amazon Linux 2023 does not support ``A1`` instances. - **ECS_AL2023_NVIDIA** - `Amazon Linux 2023 (GPU) <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#gpuami>`_ : For all GPU instance families and can be used for all non AWS Graviton-based instance types. .. epigraph:: ECS_AL2023_NVIDIA doesn't support ``p3`` and ``g3`` instance types. - **EKS** - If the ``imageIdOverride`` parameter isn't specified, then a recent `Amazon EKS-optimized Amazon Linux AMI <https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html>`_ ( ``EKS_AL2`` ) is used. If a new image type is specified in an update, but neither an ``imageId`` nor a ``imageIdOverride`` parameter is specified, then the latest Amazon EKS optimized AMI for that image type that AWS Batch supports is used. .. epigraph:: Starting end of October 2025 Amazon EKS optimized Amazon Linux 2023 AMIs will be the default on AWS Batch for EKS versions prior to 1.33. Starting from Kubernetes version 1.33, EKS optimized Amazon Linux 2023 AMIs will be the default when it becomes supported on AWS Batch . AWS will end support for Amazon EKS AL2-optimized and AL2-accelerated AMIs, starting 11/26/25. You can continue using AWS Batch -provided Amazon EKS optimized Amazon Linux 2 AMIs on your Amazon EKS compute environments beyond the 11/26/25 end-of-support date, these compute environments will no longer receive any new software updates, security patches, or bug fixes from AWS . For more information on upgrading from AL2 to AL2023, see `How to upgrade from EKS AL2 to EKS AL2023 <https://docs.aws.amazon.com/batch/latest/userguide/eks-migration-2023.html>`_ in the *AWS Batch User Guide* . - **EKS_AL2** - `Amazon Linux 2 <https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html>`_ : Default for all non-GPU instance families. - **EKS_AL2_NVIDIA** - `Amazon Linux 2 (accelerated) <https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html>`_ : Default for all GPU instance families (for example, ``P4`` and ``G4`` ) and can be used for all non AWS Graviton-based instance types. - **EKS_AL2023** - `Amazon Linux 2023 <https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html>`_ : AWS Batch supports Amazon Linux 2023. .. epigraph:: Amazon Linux 2023 does not support ``A1`` instances. - **EKS_AL2023_NVIDIA** - `Amazon Linux 2023 (accelerated) <https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html>`_ : GPU instance families and can be used for all non AWS Graviton-based instance types.
             :param image_id_override: The AMI ID used for instances launched in the compute environment that match the image type. This setting overrides the ``imageId`` set in the ``computeResource`` object. .. epigraph:: The AMI that you choose for a compute environment must match the architecture of the instance types that you intend to use for that compute environment. For example, if your compute environment uses A1 instance types, the compute resource AMI that you choose must support ARM instances. Amazon ECS vends both x86 and ARM versions of the Amazon ECS-optimized Amazon Linux 2 AMI. For more information, see `Amazon ECS-optimized Amazon Linux 2 AMI <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#ecs-optimized-ami-linux-variants.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
             :param image_kubernetes_version: The Kubernetes version for the compute environment. If you don't specify a value, the latest version that AWS Batch supports is used.
 
@@ -1826,6 +1909,11 @@ class CfnComputeEnvironment(
             The supported values are different for ``ECS`` and ``EKS`` resources.
 
             - **ECS** - If the ``imageIdOverride`` parameter isn't specified, then a recent `Amazon ECS-optimized Amazon Linux 2 AMI <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#al2ami>`_ ( ``ECS_AL2`` ) is used. If a new image type is specified in an update, but neither an ``imageId`` nor a ``imageIdOverride`` parameter is specified, then the latest Amazon ECS optimized AMI for that image type that's supported by AWS Batch is used.
+
+            .. epigraph::
+
+               AWS will end support for Amazon ECS optimized AL2-optimized and AL2-accelerated AMIs. Starting in January 2026, AWS Batch will change the default AMI for new Amazon ECS compute environments from Amazon Linux 2 to Amazon Linux 2023. We recommend migrating AWS Batch Amazon ECS compute environments to Amazon Linux 2023 to maintain optimal performance and security. For more information on upgrading from AL2 to AL2023, see `How to migrate from ECS AL2 to ECS AL2023 <https://docs.aws.amazon.com/batch/latest/userguide/ecs-migration-2023.html>`_ in the *AWS Batch User Guide* .
+
             - **ECS_AL2** - `Amazon Linux 2 <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#al2ami>`_ : Default for all non-GPU instance families.
             - **ECS_AL2_NVIDIA** - `Amazon Linux 2 (GPU) <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#gpuami>`_ : Default for all GPU instance families (for example ``P4`` and ``G4`` ) and can be used for all non AWS Graviton-based instance types.
             - **ECS_AL2023** - `Amazon Linux 2023 <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html>`_ : AWS Batch supports Amazon Linux 2023.
@@ -1834,10 +1922,29 @@ class CfnComputeEnvironment(
 
                Amazon Linux 2023 does not support ``A1`` instances.
 
-            - **ECS_AL1** - `Amazon Linux <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#alami>`_ . Amazon Linux has reached the end-of-life of standard support. For more information, see `Amazon Linux AMI <https://docs.aws.amazon.com/amazon-linux-ami/>`_ .
+            - **ECS_AL2023_NVIDIA** - `Amazon Linux 2023 (GPU) <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-optimized_AMI.html#gpuami>`_ : For all GPU instance families and can be used for all non AWS Graviton-based instance types.
+
+            .. epigraph::
+
+               ECS_AL2023_NVIDIA doesn't support ``p3`` and ``g3`` instance types.
+
             - **EKS** - If the ``imageIdOverride`` parameter isn't specified, then a recent `Amazon EKS-optimized Amazon Linux AMI <https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html>`_ ( ``EKS_AL2`` ) is used. If a new image type is specified in an update, but neither an ``imageId`` nor a ``imageIdOverride`` parameter is specified, then the latest Amazon EKS optimized AMI for that image type that AWS Batch supports is used.
+
+            .. epigraph::
+
+               Starting end of October 2025 Amazon EKS optimized Amazon Linux 2023 AMIs will be the default on AWS Batch for EKS versions prior to 1.33. Starting from Kubernetes version 1.33, EKS optimized Amazon Linux 2023 AMIs will be the default when it becomes supported on AWS Batch .
+
+               AWS will end support for Amazon EKS AL2-optimized and AL2-accelerated AMIs, starting 11/26/25. You can continue using AWS Batch -provided Amazon EKS optimized Amazon Linux 2 AMIs on your Amazon EKS compute environments beyond the 11/26/25 end-of-support date, these compute environments will no longer receive any new software updates, security patches, or bug fixes from AWS . For more information on upgrading from AL2 to AL2023, see `How to upgrade from EKS AL2 to EKS AL2023 <https://docs.aws.amazon.com/batch/latest/userguide/eks-migration-2023.html>`_ in the *AWS Batch User Guide* .
+
             - **EKS_AL2** - `Amazon Linux 2 <https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html>`_ : Default for all non-GPU instance families.
             - **EKS_AL2_NVIDIA** - `Amazon Linux 2 (accelerated) <https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html>`_ : Default for all GPU instance families (for example, ``P4`` and ``G4`` ) and can be used for all non AWS Graviton-based instance types.
+            - **EKS_AL2023** - `Amazon Linux 2023 <https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html>`_ : AWS Batch supports Amazon Linux 2023.
+
+            .. epigraph::
+
+               Amazon Linux 2023 does not support ``A1`` instances.
+
+            - **EKS_AL2023_NVIDIA** - `Amazon Linux 2023 (accelerated) <https://docs.aws.amazon.com/eks/latest/userguide/eks-optimized-ami.html>`_ : GPU instance families and can be used for all non AWS Graviton-based instance types.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-ec2configurationobject.html#cfn-batch-computeenvironment-ec2configurationobject-imagetype
             '''
@@ -1968,6 +2075,7 @@ class CfnComputeEnvironment(
             "launch_template_id": "launchTemplateId",
             "launch_template_name": "launchTemplateName",
             "target_instance_types": "targetInstanceTypes",
+            "userdata_type": "userdataType",
             "version": "version",
         },
     )
@@ -1978,6 +2086,7 @@ class CfnComputeEnvironment(
             launch_template_id: typing.Optional[builtins.str] = None,
             launch_template_name: typing.Optional[builtins.str] = None,
             target_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
+            userdata_type: typing.Optional[builtins.str] = None,
             version: typing.Optional[builtins.str] = None,
         ) -> None:
             '''An object that represents a launch template to use in place of the default launch template.
@@ -1993,7 +2102,8 @@ class CfnComputeEnvironment(
 
             :param launch_template_id: The ID of the launch template. *Note:* If you specify the ``launchTemplateId`` you can't specify the ``launchTemplateName`` as well.
             :param launch_template_name: The name of the launch template. *Note:* If you specify the ``launchTemplateName`` you can't specify the ``launchTemplateId`` as well.
-            :param target_instance_types: The instance type or family that this override launch template should be applied to. This parameter is required when defining a launch template override. Information included in this parameter must meet the following requirements: - Must be a valid Amazon EC2 instance type or family. - ``optimal`` isn't allowed. - ``targetInstanceTypes`` can target only instance types and families that are included within the ```ComputeResource.instanceTypes`` <https://docs.aws.amazon.com/batch/latest/APIReference/API_ComputeResource.html#Batch-Type-ComputeResource-instanceTypes>`_ set. ``targetInstanceTypes`` doesn't need to include all of the instances from the ``instanceType`` set, but at least a subset. For example, if ``ComputeResource.instanceTypes`` includes ``[m5, g5]`` , ``targetInstanceTypes`` can include ``[m5.2xlarge]`` and ``[m5.large]`` but not ``[c5.large]`` . - ``targetInstanceTypes`` included within the same launch template override or across launch template overrides can't overlap for the same compute environment. For example, you can't define one launch template override to target an instance family and another define an instance type within this same family.
+            :param target_instance_types: The instance type or family that this override launch template should be applied to. This parameter is required when defining a launch template override. Information included in this parameter must meet the following requirements: - Must be a valid Amazon EC2 instance type or family. - The following AWS Batch ``InstanceTypes`` are not allowed: ``optimal`` , ``default_x86_64`` , and ``default_arm64`` . - ``targetInstanceTypes`` can target only instance types and families that are included within the ```ComputeResource.instanceTypes`` <https://docs.aws.amazon.com/batch/latest/APIReference/API_ComputeResource.html#Batch-Type-ComputeResource-instanceTypes>`_ set. ``targetInstanceTypes`` doesn't need to include all of the instances from the ``instanceType`` set, but at least a subset. For example, if ``ComputeResource.instanceTypes`` includes ``[m5, g5]`` , ``targetInstanceTypes`` can include ``[m5.2xlarge]`` and ``[m5.large]`` but not ``[c5.large]`` . - ``targetInstanceTypes`` included within the same launch template override or across launch template overrides can't overlap for the same compute environment. For example, you can't define one launch template override to target an instance family and another define an instance type within this same family.
+            :param userdata_type: The EKS node initialization process to use. You only need to specify this value if you are using a custom AMI. The default value is ``EKS_BOOTSTRAP_SH`` . If *imageType* is a custom AMI based on EKS_AL2023 or EKS_AL2023_NVIDIA then you must choose ``EKS_NODEADM`` .
             :param version: The version number of the launch template, ``$Default`` , or ``$Latest`` . If the value is ``$Default`` , the default version of the launch template is used. If the value is ``$Latest`` , the latest version of the launch template is used. .. epigraph:: If the AMI ID that's used in a compute environment is from the launch template, the AMI isn't changed when the compute environment is updated. It's only changed if the ``updateToLatestImageVersion`` parameter for the compute environment is set to ``true`` . During an infrastructure update, if either ``$Default`` or ``$Latest`` is specified, AWS Batch re-evaluates the launch template version, and it might use a different version of the launch template. This is the case even if the launch template isn't specified in the update. When updating a compute environment, changing the launch template 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: ``$Default`` Latest: ``$Latest``
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-launchtemplatespecificationoverride.html
@@ -2009,6 +2119,7 @@ class CfnComputeEnvironment(
                     launch_template_id="launchTemplateId",
                     launch_template_name="launchTemplateName",
                     target_instance_types=["targetInstanceTypes"],
+                    userdata_type="userdataType",
                     version="version"
                 )
             '''
@@ -2017,6 +2128,7 @@ class CfnComputeEnvironment(
                 check_type(argname="argument launch_template_id", value=launch_template_id, expected_type=type_hints["launch_template_id"])
                 check_type(argname="argument launch_template_name", value=launch_template_name, expected_type=type_hints["launch_template_name"])
                 check_type(argname="argument target_instance_types", value=target_instance_types, expected_type=type_hints["target_instance_types"])
+                check_type(argname="argument userdata_type", value=userdata_type, expected_type=type_hints["userdata_type"])
                 check_type(argname="argument version", value=version, expected_type=type_hints["version"])
             self._values: typing.Dict[builtins.str, typing.Any] = {}
             if launch_template_id is not None:
@@ -2025,6 +2137,8 @@ class CfnComputeEnvironment(
                 self._values["launch_template_name"] = launch_template_name
             if target_instance_types is not None:
                 self._values["target_instance_types"] = target_instance_types
+            if userdata_type is not None:
+                self._values["userdata_type"] = userdata_type
             if version is not None:
                 self._values["version"] = version
 
@@ -2059,7 +2173,7 @@ class CfnComputeEnvironment(
             Information included in this parameter must meet the following requirements:
 
             - Must be a valid Amazon EC2 instance type or family.
-            - ``optimal`` isn't allowed.
+            - The following AWS Batch ``InstanceTypes`` are not allowed: ``optimal`` , ``default_x86_64`` , and ``default_arm64`` .
             - ``targetInstanceTypes`` can target only instance types and families that are included within the ```ComputeResource.instanceTypes`` <https://docs.aws.amazon.com/batch/latest/APIReference/API_ComputeResource.html#Batch-Type-ComputeResource-instanceTypes>`_ set. ``targetInstanceTypes`` doesn't need to include all of the instances from the ``instanceType`` set, but at least a subset. For example, if ``ComputeResource.instanceTypes`` includes ``[m5, g5]`` , ``targetInstanceTypes`` can include ``[m5.2xlarge]`` and ``[m5.large]`` but not ``[c5.large]`` .
             - ``targetInstanceTypes`` included within the same launch template override or across launch template overrides can't overlap for the same compute environment. For example, you can't define one launch template override to target an instance family and another define an instance type within this same family.
 
@@ -2068,6 +2182,17 @@ class CfnComputeEnvironment(
             result = self._values.get("target_instance_types")
             return typing.cast(typing.Optional[typing.List[builtins.str]], result)
 
+        @builtins.property
+        def userdata_type(self) -> typing.Optional[builtins.str]:
+            '''The EKS node initialization process to use.
+
+            You only need to specify this value if you are using a custom AMI. The default value is ``EKS_BOOTSTRAP_SH`` . If *imageType* is a custom AMI based on EKS_AL2023 or EKS_AL2023_NVIDIA then you must choose ``EKS_NODEADM`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-launchtemplatespecificationoverride.html#cfn-batch-computeenvironment-launchtemplatespecificationoverride-userdatatype
+            '''
+            result = self._values.get("userdata_type")
+            return typing.cast(typing.Optional[builtins.str], result)
+
         @builtins.property
         def version(self) -> typing.Optional[builtins.str]:
             '''The version number of the launch template, ``$Default`` , or ``$Latest`` .
@@ -2104,6 +2229,7 @@ class CfnComputeEnvironment(
             "launch_template_id": "launchTemplateId",
             "launch_template_name": "launchTemplateName",
             "overrides": "overrides",
+            "userdata_type": "userdataType",
             "version": "version",
         },
     )
@@ -2114,6 +2240,7 @@ class CfnComputeEnvironment(
             launch_template_id: typing.Optional[builtins.str] = None,
             launch_template_name: typing.Optional[builtins.str] = None,
             overrides: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnComputeEnvironment.LaunchTemplateSpecificationOverrideProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
+            userdata_type: typing.Optional[builtins.str] = None,
             version: typing.Optional[builtins.str] = None,
         ) -> None:
             '''An object that represents a launch template that's associated with a compute resource.
@@ -2128,6 +2255,7 @@ class CfnComputeEnvironment(
             :param launch_template_id: The ID of the launch template.
             :param launch_template_name: The name of the launch template.
             :param overrides: A launch template to use in place of the default launch template. You must specify either the launch template ID or launch template name in the request, but not both. You can specify up to ten (10) launch template overrides that are associated to unique instance types or families for each compute environment. .. epigraph:: To unset all override templates for a compute environment, you can pass an empty array to the `UpdateComputeEnvironment.overrides <https://docs.aws.amazon.com/batch/latest/APIReference/API_UpdateComputeEnvironment.html>`_ parameter, or not include the ``overrides`` parameter when submitting the ``UpdateComputeEnvironment`` API operation.
+            :param userdata_type: The EKS node initialization process to use. You only need to specify this value if you are using a custom AMI. The default value is ``EKS_BOOTSTRAP_SH`` . If *imageType* is a custom AMI based on EKS_AL2023 or EKS_AL2023_NVIDIA then you must choose ``EKS_NODEADM`` .
             :param version: The version number of the launch template, ``$Default`` , or ``$Latest`` . If the value is ``$Default`` , the default version of the launch template is used. If the value is ``$Latest`` , the latest version of the launch template is used. .. epigraph:: If the AMI ID that's used in a compute environment is from the launch template, the AMI isn't changed when the compute environment is updated. It's only changed if the ``updateToLatestImageVersion`` parameter for the compute environment is set to ``true`` . During an infrastructure update, if either ``$Default`` or ``$Latest`` is specified, AWS Batch re-evaluates the launch template version, and it might use a different version of the launch template. This is the case even if the launch template isn't specified in the update. When updating a compute environment, changing the launch template 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: ``$Default`` Latest: ``$Latest``
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-launchtemplatespecification.html
@@ -2146,8 +2274,10 @@ class CfnComputeEnvironment(
                         launch_template_id="launchTemplateId",
                         launch_template_name="launchTemplateName",
                         target_instance_types=["targetInstanceTypes"],
+                        userdata_type="userdataType",
                         version="version"
                     )],
+                    userdata_type="userdataType",
                     version="version"
                 )
             '''
@@ -2156,6 +2286,7 @@ class CfnComputeEnvironment(
                 check_type(argname="argument launch_template_id", value=launch_template_id, expected_type=type_hints["launch_template_id"])
                 check_type(argname="argument launch_template_name", value=launch_template_name, expected_type=type_hints["launch_template_name"])
                 check_type(argname="argument overrides", value=overrides, expected_type=type_hints["overrides"])
+                check_type(argname="argument userdata_type", value=userdata_type, expected_type=type_hints["userdata_type"])
                 check_type(argname="argument version", value=version, expected_type=type_hints["version"])
             self._values: typing.Dict[builtins.str, typing.Any] = {}
             if launch_template_id is not None:
@@ -2164,6 +2295,8 @@ class CfnComputeEnvironment(
                 self._values["launch_template_name"] = launch_template_name
             if overrides is not None:
                 self._values["overrides"] = overrides
+            if userdata_type is not None:
+                self._values["userdata_type"] = userdata_type
             if version is not None:
                 self._values["version"] = version
 
@@ -2203,6 +2336,17 @@ class CfnComputeEnvironment(
             result = self._values.get("overrides")
             return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnComputeEnvironment.LaunchTemplateSpecificationOverrideProperty"]]]], result)
 
+        @builtins.property
+        def userdata_type(self) -> typing.Optional[builtins.str]:
+            '''The EKS node initialization process to use.
+
+            You only need to specify this value if you are using a custom AMI. The default value is ``EKS_BOOTSTRAP_SH`` . If *imageType* is a custom AMI based on EKS_AL2023 or EKS_AL2023_NVIDIA then you must choose ``EKS_NODEADM`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-launchtemplatespecification.html#cfn-batch-computeenvironment-launchtemplatespecification-userdatatype
+            '''
+            result = self._values.get("userdata_type")
+            return typing.cast(typing.Optional[builtins.str], result)
+
         @builtins.property
         def version(self) -> typing.Optional[builtins.str]:
             '''The version number of the launch template, ``$Default`` , or ``$Latest`` .
@@ -2357,7 +2501,7 @@ class CfnComputeEnvironmentProps:
         :param compute_environment_name: The name for your compute environment. It can be up to 128 characters long. It can contain uppercase and lowercase letters, numbers, hyphens (-), and underscores (_).
         :param compute_resources: The ComputeResources property type specifies details of the compute resources managed by the compute environment. This parameter is required for managed compute environments. For more information, see `Compute Environments <https://docs.aws.amazon.com/batch/latest/userguide/compute_environments.html>`_ in the ** .
         :param context: Reserved.
-        :param eks_configuration: The details for the Amazon EKS cluster that supports the compute environment.
+        :param eks_configuration: The details for the Amazon EKS cluster that supports the compute environment. .. epigraph:: To create a compute environment that uses EKS resources, the caller must have permissions to call ``eks:DescribeCluster`` .
         :param replace_compute_environment: Specifies whether the compute environment is replaced if an update is made that requires replacing the instances in the compute environment. The default value is ``true`` . To enable more properties to be updated, set this property to ``false`` . When changing the value of this property to ``false`` , do not change any other properties at the same time. If other properties are changed at the same time, and the change needs to be rolled back but it can't, it's possible for the stack to go into the ``UPDATE_ROLLBACK_FAILED`` state. You can't update a stack that is in the ``UPDATE_ROLLBACK_FAILED`` state. However, if you can continue to roll it back, you can return the stack to its original settings and then try to update it again. For more information, see `Continue rolling back an update <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-updating-stacks-continueupdaterollback.html>`_ in the *AWS CloudFormation User Guide* . ``ReplaceComputeEnvironment`` is not applicable for Fargate compute environments. Fargate compute environments are always updated without interruption. The properties that can't be changed without replacing the compute environment are in the ```ComputeResources`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html>`_ property type: ```AllocationStrategy`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-allocationstrategy>`_ , ```BidPercentage`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-bidpercentage>`_ , ```Ec2Configuration`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-ec2configuration>`_ , ```Ec2KeyPair`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-ec2keypair>`_ , ```Ec2KeyPair`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-ec2keypair>`_ , ```ImageId`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-imageid>`_ , ```InstanceRole`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-instancerole>`_ , ```InstanceTypes`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-instancetypes>`_ , ```LaunchTemplate`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-launchtemplate>`_ , ```MaxvCpus`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-maxvcpus>`_ , ```MinvCpus`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-minvcpus>`_ , ```PlacementGroup`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-placementgroup>`_ , ```SecurityGroupIds`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-securitygroupids>`_ , ```Subnets`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-subnets>`_ , `Tags <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-tags>`_ , ```Type`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-type>`_ , and ```UpdateToLatestImageVersion`` <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-computeenvironment-computeresources.html#cfn-batch-computeenvironment-computeresources-updatetolatestimageversion>`_ . Default: - true
         :param service_role: The full Amazon Resource Name (ARN) of the IAM role that allows AWS Batch to make calls to other AWS services on your behalf. For more information, see `AWS Batch service IAM role <https://docs.aws.amazon.com/batch/latest/userguide/service_IAM_role.html>`_ in the *AWS Batch User Guide* . .. epigraph:: If your account already created the AWS Batch service-linked role, that role is used by default for your compute environment unless you specify a different role here. If the AWS Batch service-linked role doesn't exist in your account, and no role is specified here, the service attempts to create the AWS Batch service-linked role in your account. If your specified role has a path other than ``/`` , then you must specify either the full role ARN (recommended) or prefix the role name with the path. For example, if a role with the name ``bar`` has a path of ``/foo/`` , specify ``/foo/bar`` as the role name. For more information, see `Friendly names and paths <https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_identifiers.html#identifiers-friendly-names>`_ in the *IAM User Guide* . .. epigraph:: Depending on how you created your AWS Batch service role, its ARN might contain the ``service-role`` path prefix. When you only specify the name of the service role, AWS Batch assumes that your ARN doesn't use the ``service-role`` path prefix. Because of this, we recommend that you specify the full ARN of your service role when you create compute environments.
         :param state: The state of the compute environment. If the state is ``ENABLED`` , then the compute environment accepts jobs from a queue and can scale out automatically based on queues. If the state is ``ENABLED`` , then the AWS Batch scheduler can attempt to place jobs from an associated job queue on the compute resources within the environment. If the compute environment is managed, then it can scale its instances out or in automatically, based on the job queue demand. If the state is ``DISABLED`` , then the AWS Batch scheduler doesn't attempt to place jobs within the environment. Jobs in a ``STARTING`` or ``RUNNING`` state continue to progress normally. Managed compute environments in the ``DISABLED`` state don't scale out. .. epigraph:: Compute environments in a ``DISABLED`` state may continue to incur billing charges. To prevent additional charges, turn off and then delete the compute environment. For more information, see `State <https://docs.aws.amazon.com/batch/latest/userguide/compute_environment_parameters.html#compute_environment_state>`_ in the *AWS Batch User Guide* . When an instance is idle, the instance scales down to the ``minvCpus`` value. However, the instance size doesn't change. For example, consider a ``c5.8xlarge`` instance with a ``minvCpus`` value of ``4`` and a ``desiredvCpus`` value of ``36`` . This instance doesn't scale down to a ``c5.large`` instance.
@@ -2406,8 +2550,10 @@ class CfnComputeEnvironmentProps:
                             launch_template_id="launchTemplateId",
                             launch_template_name="launchTemplateName",
                             target_instance_types=["targetInstanceTypes"],
+                            userdata_type="userdataType",
                             version="version"
                         )],
+                        userdata_type="userdataType",
                         version="version"
                     ),
                     minv_cpus=123,
@@ -2525,6 +2671,10 @@ class CfnComputeEnvironmentProps:
     ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnComputeEnvironment.EksConfigurationProperty]]:
         '''The details for the Amazon EKS cluster that supports the compute environment.
 
+        .. epigraph::
+
+           To create a compute environment that uses EKS resources, the caller must have permissions to call ``eks:DescribeCluster`` .
+
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-computeenvironment.html#cfn-batch-computeenvironment-eksconfiguration
         '''
         result = self._values.get("eks_configuration")
@@ -2636,7 +2786,7 @@ class CfnComputeEnvironmentProps:
         )
 
 
-@jsii.implements(_IInspectable_c2943556, _ITaggableV2_4e6798f8)
+@jsii.implements(_IInspectable_c2943556, _IConsumableResourceRef_114da7c5, _ITaggableV2_4e6798f8)
 class CfnConsumableResource(
     _CfnResource_9df397a6,
     metaclass=jsii.JSIIMeta,
@@ -2678,7 +2828,8 @@ class CfnConsumableResource(
         consumable_resource_name: typing.Optional[builtins.str] = None,
         tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     ) -> None:
-        '''
+        '''Create a new ``AWS::Batch::ConsumableResource``.
+
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
         :param resource_type: Indicates whether the resource is available to be re-used after a job completes. Can be one of:. - ``REPLENISHABLE`` - ``NON_REPLENISHABLE``
@@ -2776,6 +2927,12 @@ class CfnConsumableResource(
     def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
         return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))
 
+    @builtins.property
+    @jsii.member(jsii_name="consumableResourceRef")
+    def consumable_resource_ref(self) -> _ConsumableResourceReference_eb60ef1d:
+        '''A reference to a ConsumableResource resource.'''
+        return typing.cast(_ConsumableResourceReference_eb60ef1d, jsii.get(self, "consumableResourceRef"))
+
     @builtins.property
     @jsii.member(jsii_name="resourceType")
     def resource_type(self) -> builtins.str:
@@ -2951,7 +3108,7 @@ class CfnConsumableResourceProps:
         )
 
 
-@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
+@jsii.implements(_IInspectable_c2943556, _IJobDefinitionRef_ae0cae56, _ITaggable_36806126)
 class CfnJobDefinition(
     _CfnResource_9df397a6,
     metaclass=jsii.JSIIMeta,
@@ -2985,12 +3142,14 @@ class CfnJobDefinition(
         parameters: typing.Any = None,
         platform_capabilities: typing.Optional[typing.Sequence[builtins.str]] = None,
         propagate_tags: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+        resource_retention_policy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.ResourceRetentionPolicyProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         retry_strategy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.RetryStrategyProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
         scheduling_priority: typing.Optional[jsii.Number] = None,
         tags: typing.Any = None,
         timeout: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobDefinition.TimeoutProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
-        '''
+        '''Create a new ``AWS::Batch::JobDefinition``.
+
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
         :param type: The type of job definition. For more information about multi-node parallel jobs, see `Creating a multi-node parallel job definition <https://docs.aws.amazon.com/batch/latest/userguide/multi-node-job-def.html>`_ in the *AWS Batch User Guide* . - If the value is ``container`` , then one of the following is required: ``containerProperties`` , ``ecsProperties`` , or ``eksProperties`` . - If the value is ``multinode`` , then ``nodeProperties`` is required. .. epigraph:: If the job is run on Fargate resources, then ``multinode`` isn't supported.
@@ -3003,6 +3162,7 @@ class CfnJobDefinition(
         :param parameters: Default parameters or parameter substitution placeholders that are set in the job definition. Parameters are specified as a key-value pair mapping. Parameters in a ``SubmitJob`` request override any corresponding parameter defaults from the job definition. For more information about specifying parameters, see `Job definition parameters <https://docs.aws.amazon.com/batch/latest/userguide/job_definition_parameters.html>`_ in the *AWS Batch User Guide* .
         :param platform_capabilities: The platform capabilities required by the job definition. If no value is specified, it defaults to ``EC2`` . Jobs run on Fargate resources specify ``FARGATE`` .
         :param propagate_tags: Specifies whether to propagate the tags from the job or job definition to the corresponding Amazon ECS task. If no value is specified, the tags aren't propagated. Tags can only be propagated to the tasks when the tasks are created. For tags with the same name, job tags are given priority over job definitions tags. If the total number of combined tags from the job and job definition is over 50, the job is moved to the ``FAILED`` state.
+        :param resource_retention_policy: Specifies the resource retention policy settings for the job definition.
         :param retry_strategy: The retry strategy to use for failed jobs that are submitted with this job definition.
         :param scheduling_priority: The scheduling priority of the job definition. This only affects jobs in job queues with a fair-share policy. Jobs with a higher scheduling priority are scheduled before jobs with a lower scheduling priority.
         :param tags: The tags that are applied to the job definition.
@@ -3023,6 +3183,7 @@ class CfnJobDefinition(
             parameters=parameters,
             platform_capabilities=platform_capabilities,
             propagate_tags=propagate_tags,
+            resource_retention_policy=resource_retention_policy,
             retry_strategy=retry_strategy,
             scheduling_priority=scheduling_priority,
             tags=tags,
@@ -3031,6 +3192,48 @@ class CfnJobDefinition(
 
         jsii.create(self.__class__, self, [scope, id, props])
 
+    @jsii.member(jsii_name="fromJobDefinitionArn")
+    @builtins.classmethod
+    def from_job_definition_arn(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        arn: builtins.str,
+    ) -> _IJobDefinitionRef_ae0cae56:
+        '''Creates a new IJobDefinitionRef from an ARN.
+
+        :param scope: -
+        :param id: -
+        :param arn: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__9eb64c713801d4b9b5ffb80a279b71c78cb6317fd0c771df22f2646f9d957f0d)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+            check_type(argname="argument arn", value=arn, expected_type=type_hints["arn"])
+        return typing.cast(_IJobDefinitionRef_ae0cae56, jsii.sinvoke(cls, "fromJobDefinitionArn", [scope, id, arn]))
+
+    @jsii.member(jsii_name="fromJobDefinitionName")
+    @builtins.classmethod
+    def from_job_definition_name(
+        cls,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        job_definition_name: builtins.str,
+    ) -> _IJobDefinitionRef_ae0cae56:
+        '''Creates a new IJobDefinitionRef from a jobDefinitionName.
+
+        :param scope: -
+        :param id: -
+        :param job_definition_name: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__825692ecdcf61885a93251433de856e5a5f6a3a7d68b8673883d418e98bd1956)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+            check_type(argname="argument job_definition_name", value=job_definition_name, expected_type=type_hints["job_definition_name"])
+        return typing.cast(_IJobDefinitionRef_ae0cae56, jsii.sinvoke(cls, "fromJobDefinitionName", [scope, id, job_definition_name]))
+
     @jsii.member(jsii_name="inspect")
     def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
         '''Examines the CloudFormation resource and discloses attributes.
@@ -3075,6 +3278,12 @@ class CfnJobDefinition(
     def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
         return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))
 
+    @builtins.property
+    @jsii.member(jsii_name="jobDefinitionRef")
+    def job_definition_ref(self) -> _JobDefinitionReference_e67f0e8f:
+        '''A reference to a JobDefinition resource.'''
+        return typing.cast(_JobDefinitionReference_e67f0e8f, jsii.get(self, "jobDefinitionRef"))
+
     @builtins.property
     @jsii.member(jsii_name="tags")
     def tags(self) -> _TagManager_0a598cb3:
@@ -3244,6 +3453,24 @@ class CfnJobDefinition(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "propagateTags", value) # pyright: ignore[reportArgumentType]
 
+    @builtins.property
+    @jsii.member(jsii_name="resourceRetentionPolicy")
+    def resource_retention_policy(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnJobDefinition.ResourceRetentionPolicyProperty"]]:
+        '''Specifies the resource retention policy settings for the job definition.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnJobDefinition.ResourceRetentionPolicyProperty"]], jsii.get(self, "resourceRetentionPolicy"))
+
+    @resource_retention_policy.setter
+    def resource_retention_policy(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnJobDefinition.ResourceRetentionPolicyProperty"]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__24d6c12e4e40e86cb18eef4cad19675ced395908001d3f74f425b06ab99bb085)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "resourceRetentionPolicy", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="retryStrategy")
     def retry_strategy(
@@ -6606,7 +6833,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. - **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 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 ``awsfirelens`` , ``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* .
 
@@ -6651,7 +6878,7 @@ class CfnJobDefinition(
 
             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`` .
+            The supported log drivers are ``awsfirelens`` , ``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.
@@ -8790,6 +9017,67 @@ class CfnJobDefinition(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_batch.CfnJobDefinition.ResourceRetentionPolicyProperty",
+        jsii_struct_bases=[],
+        name_mapping={"skip_deregister_on_update": "skipDeregisterOnUpdate"},
+    )
+    class ResourceRetentionPolicyProperty:
+        def __init__(
+            self,
+            *,
+            skip_deregister_on_update: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+        ) -> None:
+            '''Specifies the resource retention policy settings for a job definition.
+
+            :param skip_deregister_on_update: Specifies whether the previous revision of the job definition is retained in an active status after UPDATE events for the resource. The default value is ``false`` . When the property is set to ``false`` , the previous revision of the job definition is de-registered after a new revision is created. When the property is set to ``true`` , the previous revision of the job definition is not de-registered. Default: - false
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-resourceretentionpolicy.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
+                
+                resource_retention_policy_property = batch.CfnJobDefinition.ResourceRetentionPolicyProperty(
+                    skip_deregister_on_update=False
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__96a556bd9c16087d87c49ecc18104d825d1cd7dc2f678a8e272fcb8ad46b87ff)
+                check_type(argname="argument skip_deregister_on_update", value=skip_deregister_on_update, expected_type=type_hints["skip_deregister_on_update"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if skip_deregister_on_update is not None:
+                self._values["skip_deregister_on_update"] = skip_deregister_on_update
+
+        @builtins.property
+        def skip_deregister_on_update(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''Specifies whether the previous revision of the job definition is retained in an active status after UPDATE events for the resource.
+
+            The default value is ``false`` . When the property is set to ``false`` , the previous revision of the job definition is de-registered after a new revision is created. When the property is set to ``true`` , the previous revision of the job definition is not de-registered.
+
+            :default: - false
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-resourceretentionpolicy.html#cfn-batch-jobdefinition-resourceretentionpolicy-skipderegisteronupdate
+            '''
+            result = self._values.get("skip_deregister_on_update")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _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 "ResourceRetentionPolicyProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_batch.CfnJobDefinition.ResourcesProperty",
         jsii_struct_bases=[],
@@ -8962,8 +9250,8 @@ class CfnJobDefinition(
         ) -> None:
             '''An object that represents the compute environment architecture for AWS Batch jobs on Fargate.
 
-            :param cpu_architecture: The vCPU architecture. The default value is ``X86_64`` . Valid values are ``X86_64`` and ``ARM64`` . .. epigraph:: This parameter must be set to ``X86_64`` for Windows containers. > Fargate Spot is not supported for ``ARM64`` and Windows-based containers on Fargate. A job queue will be blocked if a Fargate ``ARM64`` or Windows job is submitted to a job queue with only Fargate Spot compute environments. However, you can attach both ``FARGATE`` and ``FARGATE_SPOT`` compute environments to the same job queue.
-            :param operating_system_family: The operating system for the compute environment. Valid values are: ``LINUX`` (default), ``WINDOWS_SERVER_2019_CORE`` , ``WINDOWS_SERVER_2019_FULL`` , ``WINDOWS_SERVER_2022_CORE`` , and ``WINDOWS_SERVER_2022_FULL`` . .. epigraph:: The following parameters can’t be set for Windows containers: ``linuxParameters`` , ``privileged`` , ``user`` , ``ulimits`` , ``readonlyRootFilesystem`` , and ``efsVolumeConfiguration`` . > The AWS Batch Scheduler checks the compute environments that are attached to the job queue before registering a task definition with Fargate. In this scenario, the job queue is where the job is submitted. If the job requires a Windows container and the first compute environment is ``LINUX`` , the compute environment is skipped and the next compute environment is checked until a Windows-based compute environment is found. > Fargate Spot is not supported for ``ARM64`` and Windows-based containers on Fargate. A job queue will be blocked if a Fargate ``ARM64`` or Windows job is submitted to a job queue with only Fargate Spot compute environments. However, you can attach both ``FARGATE`` and ``FARGATE_SPOT`` compute environments to the same job queue.
+            :param cpu_architecture: The vCPU architecture. The default value is ``X86_64`` . Valid values are ``X86_64`` and ``ARM64`` . .. epigraph:: This parameter must be set to ``X86_64`` for Windows containers. > Fargate Spot is not supported on Windows-based containers on Fargate. A job queue will be blocked if a Windows job is submitted to a job queue with only Fargate Spot compute environments. However, you can attach both ``FARGATE`` and ``FARGATE_SPOT`` compute environments to the same job queue.
+            :param operating_system_family: The operating system for the compute environment. Valid values are: ``LINUX`` (default), ``WINDOWS_SERVER_2019_CORE`` , ``WINDOWS_SERVER_2019_FULL`` , ``WINDOWS_SERVER_2022_CORE`` , and ``WINDOWS_SERVER_2022_FULL`` . .. epigraph:: The following parameters can’t be set for Windows containers: ``linuxParameters`` , ``privileged`` , ``user`` , ``ulimits`` , ``readonlyRootFilesystem`` , and ``efsVolumeConfiguration`` . > The AWS Batch Scheduler checks the compute environments that are attached to the job queue before registering a task definition with Fargate. In this scenario, the job queue is where the job is submitted. If the job requires a Windows container and the first compute environment is ``LINUX`` , the compute environment is skipped and the next compute environment is checked until a Windows-based compute environment is found. > Fargate Spot is not supported on Windows-based containers on Fargate. A job queue will be blocked if a Windows job is submitted to a job queue with only Fargate Spot compute environments. However, you can attach both ``FARGATE`` and ``FARGATE_SPOT`` compute environments to the same job queue.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-runtimeplatform.html
             :exampleMetadata: fixture=_generated
@@ -8995,7 +9283,7 @@ class CfnJobDefinition(
 
             .. epigraph::
 
-               This parameter must be set to ``X86_64`` for Windows containers. > Fargate Spot is not supported for ``ARM64`` and Windows-based containers on Fargate. A job queue will be blocked if a Fargate ``ARM64`` or Windows job is submitted to a job queue with only Fargate Spot compute environments. However, you can attach both ``FARGATE`` and ``FARGATE_SPOT`` compute environments to the same job queue.
+               This parameter must be set to ``X86_64`` for Windows containers. > Fargate Spot is not supported on Windows-based containers on Fargate. A job queue will be blocked if a Windows job is submitted to a job queue with only Fargate Spot compute environments. However, you can attach both ``FARGATE`` and ``FARGATE_SPOT`` compute environments to the same job queue.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-runtimeplatform.html#cfn-batch-jobdefinition-runtimeplatform-cpuarchitecture
             '''
@@ -9009,7 +9297,7 @@ class CfnJobDefinition(
             Valid values are: ``LINUX`` (default), ``WINDOWS_SERVER_2019_CORE`` , ``WINDOWS_SERVER_2019_FULL`` , ``WINDOWS_SERVER_2022_CORE`` , and ``WINDOWS_SERVER_2022_FULL`` .
             .. epigraph::
 
-               The following parameters can’t be set for Windows containers: ``linuxParameters`` , ``privileged`` , ``user`` , ``ulimits`` , ``readonlyRootFilesystem`` , and ``efsVolumeConfiguration`` . > The AWS Batch Scheduler checks the compute environments that are attached to the job queue before registering a task definition with Fargate. In this scenario, the job queue is where the job is submitted. If the job requires a Windows container and the first compute environment is ``LINUX`` , the compute environment is skipped and the next compute environment is checked until a Windows-based compute environment is found. > Fargate Spot is not supported for ``ARM64`` and Windows-based containers on Fargate. A job queue will be blocked if a Fargate ``ARM64`` or Windows job is submitted to a job queue with only Fargate Spot compute environments. However, you can attach both ``FARGATE`` and ``FARGATE_SPOT`` compute environments to the same job queue.
+               The following parameters can’t be set for Windows containers: ``linuxParameters`` , ``privileged`` , ``user`` , ``ulimits`` , ``readonlyRootFilesystem`` , and ``efsVolumeConfiguration`` . > The AWS Batch Scheduler checks the compute environments that are attached to the job queue before registering a task definition with Fargate. In this scenario, the job queue is where the job is submitted. If the job requires a Windows container and the first compute environment is ``LINUX`` , the compute environment is skipped and the next compute environment is checked until a Windows-based compute environment is found. > Fargate Spot is not supported on Windows-based containers on Fargate. A job queue will be blocked if a Windows job is submitted to a job queue with only Fargate Spot compute environments. However, you can attach both ``FARGATE`` and ``FARGATE_SPOT`` compute environments to the same job queue.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobdefinition-runtimeplatform.html#cfn-batch-jobdefinition-runtimeplatform-operatingsystemfamily
             '''
@@ -10212,6 +10500,7 @@ class CfnJobDefinition(
         "parameters": "parameters",
         "platform_capabilities": "platformCapabilities",
         "propagate_tags": "propagateTags",
+        "resource_retention_policy": "resourceRetentionPolicy",
         "retry_strategy": "retryStrategy",
         "scheduling_priority": "schedulingPriority",
         "tags": "tags",
@@ -10232,6 +10521,7 @@ class CfnJobDefinitionProps:
         parameters: typing.Any = None,
         platform_capabilities: typing.Optional[typing.Sequence[builtins.str]] = None,
         propagate_tags: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+        resource_retention_policy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.ResourceRetentionPolicyProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         retry_strategy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.RetryStrategyProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
         scheduling_priority: typing.Optional[jsii.Number] = None,
         tags: typing.Any = None,
@@ -10249,6 +10539,7 @@ class CfnJobDefinitionProps:
         :param parameters: Default parameters or parameter substitution placeholders that are set in the job definition. Parameters are specified as a key-value pair mapping. Parameters in a ``SubmitJob`` request override any corresponding parameter defaults from the job definition. For more information about specifying parameters, see `Job definition parameters <https://docs.aws.amazon.com/batch/latest/userguide/job_definition_parameters.html>`_ in the *AWS Batch User Guide* .
         :param platform_capabilities: The platform capabilities required by the job definition. If no value is specified, it defaults to ``EC2`` . Jobs run on Fargate resources specify ``FARGATE`` .
         :param propagate_tags: Specifies whether to propagate the tags from the job or job definition to the corresponding Amazon ECS task. If no value is specified, the tags aren't propagated. Tags can only be propagated to the tasks when the tasks are created. For tags with the same name, job tags are given priority over job definitions tags. If the total number of combined tags from the job and job definition is over 50, the job is moved to the ``FAILED`` state.
+        :param resource_retention_policy: Specifies the resource retention policy settings for the job definition.
         :param retry_strategy: The retry strategy to use for failed jobs that are submitted with this job definition.
         :param scheduling_priority: The scheduling priority of the job definition. This only affects jobs in job queues with a fair-share policy. Jobs with a higher scheduling priority are scheduled before jobs with a lower scheduling priority.
         :param tags: The tags that are applied to the job definition.
@@ -10273,6 +10564,7 @@ class CfnJobDefinitionProps:
             check_type(argname="argument parameters", value=parameters, expected_type=type_hints["parameters"])
             check_type(argname="argument platform_capabilities", value=platform_capabilities, expected_type=type_hints["platform_capabilities"])
             check_type(argname="argument propagate_tags", value=propagate_tags, expected_type=type_hints["propagate_tags"])
+            check_type(argname="argument resource_retention_policy", value=resource_retention_policy, expected_type=type_hints["resource_retention_policy"])
             check_type(argname="argument retry_strategy", value=retry_strategy, expected_type=type_hints["retry_strategy"])
             check_type(argname="argument scheduling_priority", value=scheduling_priority, expected_type=type_hints["scheduling_priority"])
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
@@ -10298,6 +10590,8 @@ class CfnJobDefinitionProps:
             self._values["platform_capabilities"] = platform_capabilities
         if propagate_tags is not None:
             self._values["propagate_tags"] = propagate_tags
+        if resource_retention_policy is not None:
+            self._values["resource_retention_policy"] = resource_retention_policy
         if retry_strategy is not None:
             self._values["retry_strategy"] = retry_strategy
         if scheduling_priority is not None:
@@ -10434,6 +10728,17 @@ class CfnJobDefinitionProps:
         result = self._values.get("propagate_tags")
         return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
 
+    @builtins.property
+    def resource_retention_policy(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnJobDefinition.ResourceRetentionPolicyProperty]]:
+        '''Specifies the resource retention policy settings for the job definition.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-jobdefinition.html#cfn-batch-jobdefinition-resourceretentionpolicy
+        '''
+        result = self._values.get("resource_retention_policy")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnJobDefinition.ResourceRetentionPolicyProperty]], result)
+
     @builtins.property
     def retry_strategy(
         self,
@@ -10490,7 +10795,7 @@ class CfnJobDefinitionProps:
         )
 
 
-@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
+@jsii.implements(_IInspectable_c2943556, _IJobQueueRef_2f1c7bda, _ITaggable_36806126)
 class CfnJobQueue(
     _CfnResource_9df397a6,
     metaclass=jsii.JSIIMeta,
@@ -10511,14 +10816,15 @@ class CfnJobQueue(
         from aws_cdk import aws_batch as batch
         
         cfn_job_queue = batch.CfnJobQueue(self, "MyCfnJobQueue",
+            priority=123,
+        
+            # the properties below are optional
             compute_environment_order=[batch.CfnJobQueue.ComputeEnvironmentOrderProperty(
                 compute_environment="computeEnvironment",
                 order=123
             )],
-            priority=123,
-        
-            # the properties below are optional
             job_queue_name="jobQueueName",
+            job_queue_type="jobQueueType",
             job_state_time_limit_actions=[batch.CfnJobQueue.JobStateTimeLimitActionProperty(
                 action="action",
                 max_time_seconds=123,
@@ -10526,6 +10832,10 @@ class CfnJobQueue(
                 state="state"
             )],
             scheduling_policy_arn="schedulingPolicyArn",
+            service_environment_order=[batch.CfnJobQueue.ServiceEnvironmentOrderProperty(
+                order=123,
+                service_environment="serviceEnvironment"
+            )],
             state="state",
             tags={
                 "tags_key": "tags"
@@ -10538,22 +10848,27 @@ class CfnJobQueue(
         scope: _constructs_77d1e7e8.Construct,
         id: builtins.str,
         *,
-        compute_environment_order: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobQueue.ComputeEnvironmentOrderProperty", typing.Dict[builtins.str, typing.Any]]]]],
         priority: jsii.Number,
+        compute_environment_order: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobQueue.ComputeEnvironmentOrderProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
         job_queue_name: typing.Optional[builtins.str] = None,
+        job_queue_type: typing.Optional[builtins.str] = None,
         job_state_time_limit_actions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobQueue.JobStateTimeLimitActionProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
         scheduling_policy_arn: typing.Optional[builtins.str] = None,
+        service_environment_order: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnJobQueue.ServiceEnvironmentOrderProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
         state: typing.Optional[builtins.str] = None,
         tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     ) -> None:
-        '''
+        '''Create a new ``AWS::Batch::JobQueue``.
+
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
-        :param compute_environment_order: The set of compute environments mapped to a job queue and their order relative to each other. The job scheduler uses this parameter to determine which compute environment runs a specific job. Compute environments must be in the ``VALID`` state before you can associate them with a job queue. You can associate up to three compute environments with a job queue. All of the compute environments must be either EC2 ( ``EC2`` or ``SPOT`` ) or Fargate ( ``FARGATE`` or ``FARGATE_SPOT`` ); EC2 and Fargate compute environments can't be mixed. .. epigraph:: All compute environments that are associated with a job queue must share the same architecture. AWS Batch doesn't support mixing compute environment architecture types in a single job queue.
         :param priority: The priority of the job queue. Job queues with a higher priority (or a higher integer value for the ``priority`` parameter) are evaluated first when associated with the same compute environment. Priority is determined in descending order. For example, a job queue with a priority value of ``10`` is given scheduling preference over a job queue with a priority value of ``1`` . All of the compute environments must be either EC2 ( ``EC2`` or ``SPOT`` ) or Fargate ( ``FARGATE`` or ``FARGATE_SPOT`` ); EC2 and Fargate compute environments can't be mixed.
+        :param compute_environment_order: The set of compute environments mapped to a job queue and their order relative to each other. The job scheduler uses this parameter to determine which compute environment runs a specific job. Compute environments must be in the ``VALID`` state before you can associate them with a job queue. You can associate up to three compute environments with a job queue. All of the compute environments must be either EC2 ( ``EC2`` or ``SPOT`` ) or Fargate ( ``FARGATE`` or ``FARGATE_SPOT`` ); EC2 and Fargate compute environments can't be mixed. .. epigraph:: All compute environments that are associated with a job queue must share the same architecture. AWS Batch doesn't support mixing compute environment architecture types in a single job queue.
         :param job_queue_name: The name of the job queue. It can be up to 128 letters long. It can contain uppercase and lowercase letters, numbers, hyphens (-), and underscores (_).
+        :param job_queue_type: The type of job queue. For service jobs that run on SageMaker AI , this value is ``SAGEMAKER_TRAINING`` . For regular container jobs, this value is ``EKS`` , ``ECS`` , or ``ECS_FARGATE`` depending on the compute environment.
         :param job_state_time_limit_actions: The set of actions that AWS Batch perform on jobs that remain at the head of the job queue in the specified state longer than specified times. AWS Batch will perform each action after ``maxTimeSeconds`` has passed.
         :param scheduling_policy_arn: The Amazon Resource Name (ARN) of the scheduling policy. The format is ``aws: *Partition* :batch: *Region* : *Account* :scheduling-policy/ *Name*`` . For example, ``aws:aws:batch:us-west-2:123456789012:scheduling-policy/MySchedulingPolicy`` .
+        :param service_environment_order: The order of the service environment associated with the job queue. Job queues with a higher priority are evaluated first when associated with the same service environment.
         :param state: The state of the job queue. If the job queue state is ``ENABLED`` , it is able to accept jobs. If the job queue state is ``DISABLED`` , new jobs can't be added to the queue, but jobs already in the queue can finish.
         :param tags: The tags that are applied to the job queue. For more information, see `Tagging your AWS Batch resources <https://docs.aws.amazon.com/batch/latest/userguide/using-tags.html>`_ in *AWS Batch User Guide* .
         '''
@@ -10562,11 +10877,13 @@ class CfnJobQueue(
             check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         props = CfnJobQueueProps(
-            compute_environment_order=compute_environment_order,
             priority=priority,
+            compute_environment_order=compute_environment_order,
             job_queue_name=job_queue_name,
+            job_queue_type=job_queue_type,
             job_state_time_limit_actions=job_state_time_limit_actions,
             scheduling_policy_arn=scheduling_policy_arn,
+            service_environment_order=service_environment_order,
             state=state,
             tags=tags,
         )
@@ -10617,43 +10934,49 @@ class CfnJobQueue(
     def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
         return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))
 
+    @builtins.property
+    @jsii.member(jsii_name="jobQueueRef")
+    def job_queue_ref(self) -> _JobQueueReference_1a1e9db8:
+        '''A reference to a JobQueue resource.'''
+        return typing.cast(_JobQueueReference_1a1e9db8, jsii.get(self, "jobQueueRef"))
+
     @builtins.property
     @jsii.member(jsii_name="tags")
     def tags(self) -> _TagManager_0a598cb3:
         '''Tag Manager which manages the tags for this resource.'''
         return typing.cast(_TagManager_0a598cb3, jsii.get(self, "tags"))
 
+    @builtins.property
+    @jsii.member(jsii_name="priority")
+    def priority(self) -> jsii.Number:
+        '''The priority of the job queue.'''
+        return typing.cast(jsii.Number, jsii.get(self, "priority"))
+
+    @priority.setter
+    def priority(self, value: jsii.Number) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__620331f74c116d31a6d43627e1a45e7041bc3c110194265f30dc193863c8ed94)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "priority", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="computeEnvironmentOrder")
     def compute_environment_order(
         self,
-    ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnJobQueue.ComputeEnvironmentOrderProperty"]]]:
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnJobQueue.ComputeEnvironmentOrderProperty"]]]]:
         '''The set of compute environments mapped to a job queue and their order relative to each other.'''
-        return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnJobQueue.ComputeEnvironmentOrderProperty"]]], jsii.get(self, "computeEnvironmentOrder"))
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnJobQueue.ComputeEnvironmentOrderProperty"]]]], jsii.get(self, "computeEnvironmentOrder"))
 
     @compute_environment_order.setter
     def compute_environment_order(
         self,
-        value: typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnJobQueue.ComputeEnvironmentOrderProperty"]]],
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnJobQueue.ComputeEnvironmentOrderProperty"]]]],
     ) -> None:
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__aa1c2f3f42165309672c3fdf8c286ff9dc5e99756ec1a5b3ffca9e719d4c7036)
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "computeEnvironmentOrder", value) # pyright: ignore[reportArgumentType]
 
-    @builtins.property
-    @jsii.member(jsii_name="priority")
-    def priority(self) -> jsii.Number:
-        '''The priority of the job queue.'''
-        return typing.cast(jsii.Number, jsii.get(self, "priority"))
-
-    @priority.setter
-    def priority(self, value: jsii.Number) -> None:
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__620331f74c116d31a6d43627e1a45e7041bc3c110194265f30dc193863c8ed94)
-            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "priority", value) # pyright: ignore[reportArgumentType]
-
     @builtins.property
     @jsii.member(jsii_name="jobQueueName")
     def job_queue_name(self) -> typing.Optional[builtins.str]:
@@ -10667,6 +10990,19 @@ class CfnJobQueue(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "jobQueueName", value) # pyright: ignore[reportArgumentType]
 
+    @builtins.property
+    @jsii.member(jsii_name="jobQueueType")
+    def job_queue_type(self) -> typing.Optional[builtins.str]:
+        '''The type of job queue.'''
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "jobQueueType"))
+
+    @job_queue_type.setter
+    def job_queue_type(self, value: typing.Optional[builtins.str]) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__cf7ba788adc96e65e278a0278721e322a7b2c5ad42c7d2cafd707c74e58d6e65)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "jobQueueType", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="jobStateTimeLimitActions")
     def job_state_time_limit_actions(
@@ -10698,6 +11034,24 @@ class CfnJobQueue(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "schedulingPolicyArn", value) # pyright: ignore[reportArgumentType]
 
+    @builtins.property
+    @jsii.member(jsii_name="serviceEnvironmentOrder")
+    def service_environment_order(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnJobQueue.ServiceEnvironmentOrderProperty"]]]]:
+        '''The order of the service environment associated with the job queue.'''
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnJobQueue.ServiceEnvironmentOrderProperty"]]]], jsii.get(self, "serviceEnvironmentOrder"))
+
+    @service_environment_order.setter
+    def service_environment_order(
+        self,
+        value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnJobQueue.ServiceEnvironmentOrderProperty"]]]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__59b5173dac1cdbe1bbc03df51cc226f4cddcdbdc7dd27fbfc1081cce50fc2d50)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "serviceEnvironmentOrder", value) # pyright: ignore[reportArgumentType]
+
     @builtins.property
     @jsii.member(jsii_name="state")
     def state(self) -> typing.Optional[builtins.str]:
@@ -10917,39 +11271,120 @@ class CfnJobQueue(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_batch.CfnJobQueue.ServiceEnvironmentOrderProperty",
+        jsii_struct_bases=[],
+        name_mapping={"order": "order", "service_environment": "serviceEnvironment"},
+    )
+    class ServiceEnvironmentOrderProperty:
+        def __init__(
+            self,
+            *,
+            order: jsii.Number,
+            service_environment: builtins.str,
+        ) -> None:
+            '''Specifies the order of a service environment for a job queue.
 
-@jsii.data_type(
-    jsii_type="aws-cdk-lib.aws_batch.CfnJobQueueProps",
-    jsii_struct_bases=[],
-    name_mapping={
-        "compute_environment_order": "computeEnvironmentOrder",
-        "priority": "priority",
-        "job_queue_name": "jobQueueName",
-        "job_state_time_limit_actions": "jobStateTimeLimitActions",
-        "scheduling_policy_arn": "schedulingPolicyArn",
-        "state": "state",
-        "tags": "tags",
-    },
-)
-class CfnJobQueueProps:
-    def __init__(
-        self,
-        *,
-        compute_environment_order: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobQueue.ComputeEnvironmentOrderProperty, typing.Dict[builtins.str, typing.Any]]]]],
-        priority: jsii.Number,
-        job_queue_name: typing.Optional[builtins.str] = None,
-        job_state_time_limit_actions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobQueue.JobStateTimeLimitActionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
-        scheduling_policy_arn: typing.Optional[builtins.str] = None,
-        state: typing.Optional[builtins.str] = None,
-        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
-    ) -> None:
-        '''Properties for defining a ``CfnJobQueue``.
+            This determines the priority order when multiple service environments are associated with the same job queue.
 
-        :param compute_environment_order: The set of compute environments mapped to a job queue and their order relative to each other. The job scheduler uses this parameter to determine which compute environment runs a specific job. Compute environments must be in the ``VALID`` state before you can associate them with a job queue. You can associate up to three compute environments with a job queue. All of the compute environments must be either EC2 ( ``EC2`` or ``SPOT`` ) or Fargate ( ``FARGATE`` or ``FARGATE_SPOT`` ); EC2 and Fargate compute environments can't be mixed. .. epigraph:: All compute environments that are associated with a job queue must share the same architecture. AWS Batch doesn't support mixing compute environment architecture types in a single job queue.
-        :param priority: The priority of the job queue. Job queues with a higher priority (or a higher integer value for the ``priority`` parameter) are evaluated first when associated with the same compute environment. Priority is determined in descending order. For example, a job queue with a priority value of ``10`` is given scheduling preference over a job queue with a priority value of ``1`` . All of the compute environments must be either EC2 ( ``EC2`` or ``SPOT`` ) or Fargate ( ``FARGATE`` or ``FARGATE_SPOT`` ); EC2 and Fargate compute environments can't be mixed.
-        :param job_queue_name: The name of the job queue. It can be up to 128 letters long. It can contain uppercase and lowercase letters, numbers, hyphens (-), and underscores (_).
+            :param order: The order of the service environment. Job queues with a higher priority are evaluated first when associated with the same service environment.
+            :param service_environment: The name or ARN of the service environment.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobqueue-serviceenvironmentorder.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
+                
+                service_environment_order_property = batch.CfnJobQueue.ServiceEnvironmentOrderProperty(
+                    order=123,
+                    service_environment="serviceEnvironment"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__04c4b071542df93d5d7f1e7493b1bd821aaeae2008c337f58b1d399f309446bf)
+                check_type(argname="argument order", value=order, expected_type=type_hints["order"])
+                check_type(argname="argument service_environment", value=service_environment, expected_type=type_hints["service_environment"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "order": order,
+                "service_environment": service_environment,
+            }
+
+        @builtins.property
+        def order(self) -> jsii.Number:
+            '''The order of the service environment.
+
+            Job queues with a higher priority are evaluated first when associated with the same service environment.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobqueue-serviceenvironmentorder.html#cfn-batch-jobqueue-serviceenvironmentorder-order
+            '''
+            result = self._values.get("order")
+            assert result is not None, "Required property 'order' is missing"
+            return typing.cast(jsii.Number, result)
+
+        @builtins.property
+        def service_environment(self) -> builtins.str:
+            '''The name or ARN of the service environment.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-jobqueue-serviceenvironmentorder.html#cfn-batch-jobqueue-serviceenvironmentorder-serviceenvironment
+            '''
+            result = self._values.get("service_environment")
+            assert result is not None, "Required property 'service_environment' 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 "ServiceEnvironmentOrderProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_batch.CfnJobQueueProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "priority": "priority",
+        "compute_environment_order": "computeEnvironmentOrder",
+        "job_queue_name": "jobQueueName",
+        "job_queue_type": "jobQueueType",
+        "job_state_time_limit_actions": "jobStateTimeLimitActions",
+        "scheduling_policy_arn": "schedulingPolicyArn",
+        "service_environment_order": "serviceEnvironmentOrder",
+        "state": "state",
+        "tags": "tags",
+    },
+)
+class CfnJobQueueProps:
+    def __init__(
+        self,
+        *,
+        priority: jsii.Number,
+        compute_environment_order: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobQueue.ComputeEnvironmentOrderProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        job_queue_name: typing.Optional[builtins.str] = None,
+        job_queue_type: typing.Optional[builtins.str] = None,
+        job_state_time_limit_actions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobQueue.JobStateTimeLimitActionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        scheduling_policy_arn: typing.Optional[builtins.str] = None,
+        service_environment_order: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobQueue.ServiceEnvironmentOrderProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+        state: typing.Optional[builtins.str] = None,
+        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    ) -> None:
+        '''Properties for defining a ``CfnJobQueue``.
+
+        :param priority: The priority of the job queue. Job queues with a higher priority (or a higher integer value for the ``priority`` parameter) are evaluated first when associated with the same compute environment. Priority is determined in descending order. For example, a job queue with a priority value of ``10`` is given scheduling preference over a job queue with a priority value of ``1`` . All of the compute environments must be either EC2 ( ``EC2`` or ``SPOT`` ) or Fargate ( ``FARGATE`` or ``FARGATE_SPOT`` ); EC2 and Fargate compute environments can't be mixed.
+        :param compute_environment_order: The set of compute environments mapped to a job queue and their order relative to each other. The job scheduler uses this parameter to determine which compute environment runs a specific job. Compute environments must be in the ``VALID`` state before you can associate them with a job queue. You can associate up to three compute environments with a job queue. All of the compute environments must be either EC2 ( ``EC2`` or ``SPOT`` ) or Fargate ( ``FARGATE`` or ``FARGATE_SPOT`` ); EC2 and Fargate compute environments can't be mixed. .. epigraph:: All compute environments that are associated with a job queue must share the same architecture. AWS Batch doesn't support mixing compute environment architecture types in a single job queue.
+        :param job_queue_name: The name of the job queue. It can be up to 128 letters long. It can contain uppercase and lowercase letters, numbers, hyphens (-), and underscores (_).
+        :param job_queue_type: The type of job queue. For service jobs that run on SageMaker AI , this value is ``SAGEMAKER_TRAINING`` . For regular container jobs, this value is ``EKS`` , ``ECS`` , or ``ECS_FARGATE`` depending on the compute environment.
         :param job_state_time_limit_actions: The set of actions that AWS Batch perform on jobs that remain at the head of the job queue in the specified state longer than specified times. AWS Batch will perform each action after ``maxTimeSeconds`` has passed.
         :param scheduling_policy_arn: The Amazon Resource Name (ARN) of the scheduling policy. The format is ``aws: *Partition* :batch: *Region* : *Account* :scheduling-policy/ *Name*`` . For example, ``aws:aws:batch:us-west-2:123456789012:scheduling-policy/MySchedulingPolicy`` .
+        :param service_environment_order: The order of the service environment associated with the job queue. Job queues with a higher priority are evaluated first when associated with the same service environment.
         :param state: The state of the job queue. If the job queue state is ``ENABLED`` , it is able to accept jobs. If the job queue state is ``DISABLED`` , new jobs can't be added to the queue, but jobs already in the queue can finish.
         :param tags: The tags that are applied to the job queue. For more information, see `Tagging your AWS Batch resources <https://docs.aws.amazon.com/batch/latest/userguide/using-tags.html>`_ in *AWS Batch User Guide* .
 
@@ -10963,14 +11398,15 @@ class CfnJobQueueProps:
             from aws_cdk import aws_batch as batch
             
             cfn_job_queue_props = batch.CfnJobQueueProps(
+                priority=123,
+            
+                # the properties below are optional
                 compute_environment_order=[batch.CfnJobQueue.ComputeEnvironmentOrderProperty(
                     compute_environment="computeEnvironment",
                     order=123
                 )],
-                priority=123,
-            
-                # the properties below are optional
                 job_queue_name="jobQueueName",
+                job_queue_type="jobQueueType",
                 job_state_time_limit_actions=[batch.CfnJobQueue.JobStateTimeLimitActionProperty(
                     action="action",
                     max_time_seconds=123,
@@ -10978,6 +11414,10 @@ class CfnJobQueueProps:
                     state="state"
                 )],
                 scheduling_policy_arn="schedulingPolicyArn",
+                service_environment_order=[batch.CfnJobQueue.ServiceEnvironmentOrderProperty(
+                    order=123,
+                    service_environment="serviceEnvironment"
+                )],
                 state="state",
                 tags={
                     "tags_key": "tags"
@@ -10986,32 +11426,51 @@ class CfnJobQueueProps:
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__009d6d384b1b723169e64875095e05fe852ae3931adf5ba2004d22475a76caa9)
-            check_type(argname="argument compute_environment_order", value=compute_environment_order, expected_type=type_hints["compute_environment_order"])
             check_type(argname="argument priority", value=priority, expected_type=type_hints["priority"])
+            check_type(argname="argument compute_environment_order", value=compute_environment_order, expected_type=type_hints["compute_environment_order"])
             check_type(argname="argument job_queue_name", value=job_queue_name, expected_type=type_hints["job_queue_name"])
+            check_type(argname="argument job_queue_type", value=job_queue_type, expected_type=type_hints["job_queue_type"])
             check_type(argname="argument job_state_time_limit_actions", value=job_state_time_limit_actions, expected_type=type_hints["job_state_time_limit_actions"])
             check_type(argname="argument scheduling_policy_arn", value=scheduling_policy_arn, expected_type=type_hints["scheduling_policy_arn"])
+            check_type(argname="argument service_environment_order", value=service_environment_order, expected_type=type_hints["service_environment_order"])
             check_type(argname="argument state", value=state, expected_type=type_hints["state"])
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
-            "compute_environment_order": compute_environment_order,
             "priority": priority,
         }
+        if compute_environment_order is not None:
+            self._values["compute_environment_order"] = compute_environment_order
         if job_queue_name is not None:
             self._values["job_queue_name"] = job_queue_name
+        if job_queue_type is not None:
+            self._values["job_queue_type"] = job_queue_type
         if job_state_time_limit_actions is not None:
             self._values["job_state_time_limit_actions"] = job_state_time_limit_actions
         if scheduling_policy_arn is not None:
             self._values["scheduling_policy_arn"] = scheduling_policy_arn
+        if service_environment_order is not None:
+            self._values["service_environment_order"] = service_environment_order
         if state is not None:
             self._values["state"] = state
         if tags is not None:
             self._values["tags"] = tags
 
+    @builtins.property
+    def priority(self) -> jsii.Number:
+        '''The priority of the job queue.
+
+        Job queues with a higher priority (or a higher integer value for the ``priority`` parameter) are evaluated first when associated with the same compute environment. Priority is determined in descending order. For example, a job queue with a priority value of ``10`` is given scheduling preference over a job queue with a priority value of ``1`` . All of the compute environments must be either EC2 ( ``EC2`` or ``SPOT`` ) or Fargate ( ``FARGATE`` or ``FARGATE_SPOT`` ); EC2 and Fargate compute environments can't be mixed.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-jobqueue.html#cfn-batch-jobqueue-priority
+        '''
+        result = self._values.get("priority")
+        assert result is not None, "Required property 'priority' is missing"
+        return typing.cast(jsii.Number, result)
+
     @builtins.property
     def compute_environment_order(
         self,
-    ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnJobQueue.ComputeEnvironmentOrderProperty]]]:
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnJobQueue.ComputeEnvironmentOrderProperty]]]]:
         '''The set of compute environments mapped to a job queue and their order relative to each other.
 
         The job scheduler uses this parameter to determine which compute environment runs a specific job. Compute environments must be in the ``VALID`` state before you can associate them with a job queue. You can associate up to three compute environments with a job queue. All of the compute environments must be either EC2 ( ``EC2`` or ``SPOT`` ) or Fargate ( ``FARGATE`` or ``FARGATE_SPOT`` ); EC2 and Fargate compute environments can't be mixed.
@@ -11022,20 +11481,7 @@ class CfnJobQueueProps:
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-jobqueue.html#cfn-batch-jobqueue-computeenvironmentorder
         '''
         result = self._values.get("compute_environment_order")
-        assert result is not None, "Required property 'compute_environment_order' is missing"
-        return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnJobQueue.ComputeEnvironmentOrderProperty]]], result)
-
-    @builtins.property
-    def priority(self) -> jsii.Number:
-        '''The priority of the job queue.
-
-        Job queues with a higher priority (or a higher integer value for the ``priority`` parameter) are evaluated first when associated with the same compute environment. Priority is determined in descending order. For example, a job queue with a priority value of ``10`` is given scheduling preference over a job queue with a priority value of ``1`` . All of the compute environments must be either EC2 ( ``EC2`` or ``SPOT`` ) or Fargate ( ``FARGATE`` or ``FARGATE_SPOT`` ); EC2 and Fargate compute environments can't be mixed.
-
-        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-jobqueue.html#cfn-batch-jobqueue-priority
-        '''
-        result = self._values.get("priority")
-        assert result is not None, "Required property 'priority' is missing"
-        return typing.cast(jsii.Number, result)
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnJobQueue.ComputeEnvironmentOrderProperty]]]], result)
 
     @builtins.property
     def job_queue_name(self) -> typing.Optional[builtins.str]:
@@ -11048,6 +11494,17 @@ class CfnJobQueueProps:
         result = self._values.get("job_queue_name")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def job_queue_type(self) -> typing.Optional[builtins.str]:
+        '''The type of job queue.
+
+        For service jobs that run on SageMaker AI , this value is ``SAGEMAKER_TRAINING`` . For regular container jobs, this value is ``EKS`` , ``ECS`` , or ``ECS_FARGATE`` depending on the compute environment.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-jobqueue.html#cfn-batch-jobqueue-jobqueuetype
+        '''
+        result = self._values.get("job_queue_type")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def job_state_time_limit_actions(
         self,
@@ -11072,6 +11529,19 @@ class CfnJobQueueProps:
         result = self._values.get("scheduling_policy_arn")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def service_environment_order(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnJobQueue.ServiceEnvironmentOrderProperty]]]]:
+        '''The order of the service environment associated with the job queue.
+
+        Job queues with a higher priority are evaluated first when associated with the same service environment.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-jobqueue.html#cfn-batch-jobqueue-serviceenvironmentorder
+        '''
+        result = self._values.get("service_environment_order")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnJobQueue.ServiceEnvironmentOrderProperty]]]], result)
+
     @builtins.property
     def state(self) -> typing.Optional[builtins.str]:
         '''The state of the job queue.
@@ -11106,7 +11576,7 @@ class CfnJobQueueProps:
         )
 
 
-@jsii.implements(_IInspectable_c2943556, _ITaggable_36806126)
+@jsii.implements(_IInspectable_c2943556, _ISchedulingPolicyRef_a7864c7c, _ITaggable_36806126)
 class CfnSchedulingPolicy(
     _CfnResource_9df397a6,
     metaclass=jsii.JSIIMeta,
@@ -11151,7 +11621,8 @@ class CfnSchedulingPolicy(
         name: typing.Optional[builtins.str] = None,
         tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     ) -> None:
-        '''
+        '''Create a new ``AWS::Batch::SchedulingPolicy``.
+
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
         :param fairshare_policy: The fair-share scheduling policy details.
@@ -11212,6 +11683,12 @@ class CfnSchedulingPolicy(
     def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
         return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))
 
+    @builtins.property
+    @jsii.member(jsii_name="schedulingPolicyRef")
+    def scheduling_policy_ref(self) -> _SchedulingPolicyReference_a55795c6:
+        '''A reference to a SchedulingPolicy resource.'''
+        return typing.cast(_SchedulingPolicyReference_a55795c6, jsii.get(self, "schedulingPolicyRef"))
+
     @builtins.property
     @jsii.member(jsii_name="tags")
     def tags(self) -> _TagManager_0a598cb3:
@@ -11390,7 +11867,7 @@ class CfnSchedulingPolicy(
 
             Share identifiers that aren't included have a default weight of ``1.0`` .
 
-            :param share_identifier: A share identifier or share identifier prefix. If the string ends with an asterisk (*), this entry specifies the weight factor to use for share identifiers that start with that prefix. The list of share identifiers in a fair-share policy can't overlap. For example, you can't have one that specifies a ``shareIdentifier`` of ``UserA*`` and another that specifies a ``shareIdentifier`` of ``UserA-1`` . There can be no more than 500 share identifiers active in a job queue. The string is limited to 255 alphanumeric characters, and can be followed by an asterisk (*).
+            :param share_identifier: A share identifier or share identifier prefix. If the string ends with an asterisk (*), this entry specifies the weight factor to use for share identifiers that start with that prefix. The list of share identifiers in a fair-share policy can't overlap. For example, you can't have one that specifies a ``shareIdentifier`` of ``UserA*`` and another that specifies a ``shareIdentifier`` of ``UserA1`` . There can be no more than 500 share identifiers active in a job queue. The string is limited to 255 alphanumeric characters, and can be followed by an asterisk (*).
             :param weight_factor: The weight factor for the share identifier. The default value is 1.0. A lower value has a higher priority for compute resources. For example, jobs that use a share identifier with a weight factor of 0.125 (1/8) get 8 times the compute resources of jobs that use a share identifier with a weight factor of 1. The smallest supported value is 0.0001, and the largest supported value is 999.9999.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-schedulingpolicy-shareattributes.html
@@ -11421,7 +11898,7 @@ class CfnSchedulingPolicy(
         def share_identifier(self) -> typing.Optional[builtins.str]:
             '''A share identifier or share identifier prefix.
 
-            If the string ends with an asterisk (*), this entry specifies the weight factor to use for share identifiers that start with that prefix. The list of share identifiers in a fair-share policy can't overlap. For example, you can't have one that specifies a ``shareIdentifier`` of ``UserA*`` and another that specifies a ``shareIdentifier`` of ``UserA-1`` .
+            If the string ends with an asterisk (*), this entry specifies the weight factor to use for share identifiers that start with that prefix. The list of share identifiers in a fair-share policy can't overlap. For example, you can't have one that specifies a ``shareIdentifier`` of ``UserA*`` and another that specifies a ``shareIdentifier`` of ``UserA1`` .
 
             There can be no more than 500 share identifiers active in a job queue.
 
@@ -11518,36 +11995,455 @@ class CfnSchedulingPolicyProps:
             self._values["tags"] = tags
 
     @builtins.property
-    def fairshare_policy(
-        self,
-    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnSchedulingPolicy.FairsharePolicyProperty]]:
-        '''The fair-share scheduling policy details.
+    def fairshare_policy(
+        self,
+    ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, CfnSchedulingPolicy.FairsharePolicyProperty]]:
+        '''The fair-share scheduling policy details.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-schedulingpolicy.html#cfn-batch-schedulingpolicy-fairsharepolicy
+        '''
+        result = self._values.get("fairshare_policy")
+        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnSchedulingPolicy.FairsharePolicyProperty]], result)
+
+    @builtins.property
+    def name(self) -> typing.Optional[builtins.str]:
+        '''The name of the fair-share scheduling policy.
+
+        It can be up to 128 letters long. It can contain uppercase and lowercase letters, numbers, hyphens (-), and underscores (_).
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-schedulingpolicy.html#cfn-batch-schedulingpolicy-name
+        '''
+        result = self._values.get("name")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
+        '''The tags that you apply to the scheduling policy to help you categorize and organize your resources.
+
+        Each tag consists of a key and an optional value. For more information, see `Tagging AWS Resources <https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html>`_ in *AWS General Reference* .
+
+        These tags can be updated or removed using the `TagResource <https://docs.aws.amazon.com/batch/latest/APIReference/API_TagResource.html>`_ and `UntagResource <https://docs.aws.amazon.com/batch/latest/APIReference/API_UntagResource.html>`_ API operations.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-schedulingpolicy.html#cfn-batch-schedulingpolicy-tags
+        '''
+        result = self._values.get("tags")
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, 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 "CfnSchedulingPolicyProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.implements(_IInspectable_c2943556, _IServiceEnvironmentRef_5865fef4, _ITaggableV2_4e6798f8)
+class CfnServiceEnvironment(
+    _CfnResource_9df397a6,
+    metaclass=jsii.JSIIMeta,
+    jsii_type="aws-cdk-lib.aws_batch.CfnServiceEnvironment",
+):
+    '''Creates a service environment for running service jobs.
+
+    Service environments define capacity limits for specific service types such as SageMaker Training jobs.
+
+    :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-serviceenvironment.html
+    :cloudformationResource: AWS::Batch::ServiceEnvironment
+    :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
+        
+        cfn_service_environment = batch.CfnServiceEnvironment(self, "MyCfnServiceEnvironment",
+            capacity_limits=[batch.CfnServiceEnvironment.CapacityLimitProperty(
+                capacity_unit="capacityUnit",
+                max_capacity=123
+            )],
+            service_environment_type="serviceEnvironmentType",
+        
+            # the properties below are optional
+            service_environment_name="serviceEnvironmentName",
+            state="state",
+            tags={
+                "tags_key": "tags"
+            }
+        )
+    '''
+
+    def __init__(
+        self,
+        scope: _constructs_77d1e7e8.Construct,
+        id: builtins.str,
+        *,
+        capacity_limits: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnServiceEnvironment.CapacityLimitProperty", typing.Dict[builtins.str, typing.Any]]]]],
+        service_environment_type: builtins.str,
+        service_environment_name: typing.Optional[builtins.str] = None,
+        state: typing.Optional[builtins.str] = None,
+        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    ) -> None:
+        '''Create a new ``AWS::Batch::ServiceEnvironment``.
+
+        :param scope: Scope in which this resource is defined.
+        :param id: Construct identifier for this resource (unique in its scope).
+        :param capacity_limits: The capacity limits for the service environment. This defines the maximum resources that can be used by service jobs in this environment.
+        :param service_environment_type: The type of service environment. For SageMaker Training jobs, this value is ``SAGEMAKER_TRAINING`` .
+        :param service_environment_name: The name of the service environment.
+        :param state: The state of the service environment. Valid values are ``ENABLED`` and ``DISABLED`` .
+        :param tags: The tags associated with the service environment. Each tag consists of a key and an optional value. For more information, see `Tagging your AWS Batch resources <https://docs.aws.amazon.com/batch/latest/userguide/using-tags.html>`_ .
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__a6f9de8dd6d91e1ef3541444262c3bd9eba874d47c3dbe2b368127e55802962d)
+            check_type(argname="argument scope", value=scope, expected_type=type_hints["scope"])
+            check_type(argname="argument id", value=id, expected_type=type_hints["id"])
+        props = CfnServiceEnvironmentProps(
+            capacity_limits=capacity_limits,
+            service_environment_type=service_environment_type,
+            service_environment_name=service_environment_name,
+            state=state,
+            tags=tags,
+        )
+
+        jsii.create(self.__class__, self, [scope, id, props])
+
+    @jsii.member(jsii_name="inspect")
+    def inspect(self, inspector: _TreeInspector_488e0dd5) -> None:
+        '''Examines the CloudFormation resource and discloses attributes.
+
+        :param inspector: tree inspector to collect and process attributes.
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__96e0974d2660553889a9af3a927bfad81828948853f01018235f809576a4c6b9)
+            check_type(argname="argument inspector", value=inspector, expected_type=type_hints["inspector"])
+        return typing.cast(None, jsii.invoke(self, "inspect", [inspector]))
+
+    @jsii.member(jsii_name="renderProperties")
+    def _render_properties(
+        self,
+        props: typing.Mapping[builtins.str, typing.Any],
+    ) -> typing.Mapping[builtins.str, typing.Any]:
+        '''
+        :param props: -
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__e6991ed0f2dc20fa74e5cde5971e4b3997019046ee7c1e1fc7eca96b677bc91b)
+            check_type(argname="argument props", value=props, expected_type=type_hints["props"])
+        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.invoke(self, "renderProperties", [props]))
+
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="CFN_RESOURCE_TYPE_NAME")
+    def CFN_RESOURCE_TYPE_NAME(cls) -> builtins.str:
+        '''The CloudFormation resource type name for this resource class.'''
+        return typing.cast(builtins.str, jsii.sget(cls, "CFN_RESOURCE_TYPE_NAME"))
+
+    @builtins.property
+    @jsii.member(jsii_name="attrServiceEnvironmentArn")
+    def attr_service_environment_arn(self) -> builtins.str:
+        '''The Amazon Resource Name (ARN) of the service environment.
+
+        :cloudformationAttribute: ServiceEnvironmentArn
+        '''
+        return typing.cast(builtins.str, jsii.get(self, "attrServiceEnvironmentArn"))
+
+    @builtins.property
+    @jsii.member(jsii_name="cdkTagManager")
+    def cdk_tag_manager(self) -> _TagManager_0a598cb3:
+        '''Tag Manager which manages the tags for this resource.'''
+        return typing.cast(_TagManager_0a598cb3, jsii.get(self, "cdkTagManager"))
+
+    @builtins.property
+    @jsii.member(jsii_name="cfnProperties")
+    def _cfn_properties(self) -> typing.Mapping[builtins.str, typing.Any]:
+        return typing.cast(typing.Mapping[builtins.str, typing.Any], jsii.get(self, "cfnProperties"))
+
+    @builtins.property
+    @jsii.member(jsii_name="serviceEnvironmentRef")
+    def service_environment_ref(self) -> _ServiceEnvironmentReference_9a7dc7ee:
+        '''A reference to a ServiceEnvironment resource.'''
+        return typing.cast(_ServiceEnvironmentReference_9a7dc7ee, jsii.get(self, "serviceEnvironmentRef"))
+
+    @builtins.property
+    @jsii.member(jsii_name="capacityLimits")
+    def capacity_limits(
+        self,
+    ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnServiceEnvironment.CapacityLimitProperty"]]]:
+        '''The capacity limits for the service environment.'''
+        return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnServiceEnvironment.CapacityLimitProperty"]]], jsii.get(self, "capacityLimits"))
+
+    @capacity_limits.setter
+    def capacity_limits(
+        self,
+        value: typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnServiceEnvironment.CapacityLimitProperty"]]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__d996fbedbaec7f1ef9fada43375af4381f0a867d50517c77d6662e6e7d7d26ae)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "capacityLimits", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="serviceEnvironmentType")
+    def service_environment_type(self) -> builtins.str:
+        '''The type of service environment.'''
+        return typing.cast(builtins.str, jsii.get(self, "serviceEnvironmentType"))
+
+    @service_environment_type.setter
+    def service_environment_type(self, value: builtins.str) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__555f27a186fb86df6655903dee02e46968e9230d8927d6c74bb13420e35fb703)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "serviceEnvironmentType", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="serviceEnvironmentName")
+    def service_environment_name(self) -> typing.Optional[builtins.str]:
+        '''The name of the service environment.'''
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "serviceEnvironmentName"))
+
+    @service_environment_name.setter
+    def service_environment_name(self, value: typing.Optional[builtins.str]) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__2f9d1cde60619bebd040c4ca1b04e45af9a3d96ad1c7d934c1fe4f4c102b0fde)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "serviceEnvironmentName", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="state")
+    def state(self) -> typing.Optional[builtins.str]:
+        '''The state of the service environment.'''
+        return typing.cast(typing.Optional[builtins.str], jsii.get(self, "state"))
+
+    @state.setter
+    def state(self, value: typing.Optional[builtins.str]) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__eb9c6d092d73d302c59d162da7ef41f680de210ef8b625b0d6804765c19c16cf)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "state", value) # pyright: ignore[reportArgumentType]
+
+    @builtins.property
+    @jsii.member(jsii_name="tags")
+    def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
+        '''The tags associated with the service environment.'''
+        return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], jsii.get(self, "tags"))
+
+    @tags.setter
+    def tags(
+        self,
+        value: typing.Optional[typing.Mapping[builtins.str, builtins.str]],
+    ) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__07a3aaaa5bb4d6dbce1c225211ed2ba7848e8258ea1ae35767262fbfb6c68d93)
+            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
+        jsii.set(self, "tags", value) # pyright: ignore[reportArgumentType]
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_batch.CfnServiceEnvironment.CapacityLimitProperty",
+        jsii_struct_bases=[],
+        name_mapping={"capacity_unit": "capacityUnit", "max_capacity": "maxCapacity"},
+    )
+    class CapacityLimitProperty:
+        def __init__(
+            self,
+            *,
+            capacity_unit: typing.Optional[builtins.str] = None,
+            max_capacity: typing.Optional[jsii.Number] = None,
+        ) -> None:
+            '''Defines the capacity limit for a service environment.
+
+            This structure specifies the maximum amount of resources that can be used by service jobs in the environment.
+
+            :param capacity_unit: The unit of measure for the capacity limit. This defines how the maxCapacity value should be interpreted. For ``SAGEMAKER_TRAINING`` jobs, use ``NUM_INSTANCES`` .
+            :param max_capacity: The maximum capacity available for the service environment. This value represents the maximum amount resources that can be allocated to service jobs. For example, ``maxCapacity=50`` , ``capacityUnit=NUM_INSTANCES`` . This indicates that the maximum number of instances that can be run on this service environment is 50. You could then run 5 SageMaker Training jobs that each use 10 instances. However, if you submit another job that requires 10 instances, it will wait in the queue.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-serviceenvironment-capacitylimit.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
+                
+                capacity_limit_property = batch.CfnServiceEnvironment.CapacityLimitProperty(
+                    capacity_unit="capacityUnit",
+                    max_capacity=123
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__8d4366eeddf34eff3fc133ef72e4bd900563fba6b925f9d9524d8c92ac2f3e4a)
+                check_type(argname="argument capacity_unit", value=capacity_unit, expected_type=type_hints["capacity_unit"])
+                check_type(argname="argument max_capacity", value=max_capacity, expected_type=type_hints["max_capacity"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if capacity_unit is not None:
+                self._values["capacity_unit"] = capacity_unit
+            if max_capacity is not None:
+                self._values["max_capacity"] = max_capacity
+
+        @builtins.property
+        def capacity_unit(self) -> typing.Optional[builtins.str]:
+            '''The unit of measure for the capacity limit.
+
+            This defines how the maxCapacity value should be interpreted. For ``SAGEMAKER_TRAINING`` jobs, use ``NUM_INSTANCES`` .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-serviceenvironment-capacitylimit.html#cfn-batch-serviceenvironment-capacitylimit-capacityunit
+            '''
+            result = self._values.get("capacity_unit")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def max_capacity(self) -> typing.Optional[jsii.Number]:
+            '''The maximum capacity available for the service environment.
+
+            This value represents the maximum amount resources that can be allocated to service jobs.
+
+            For example, ``maxCapacity=50`` , ``capacityUnit=NUM_INSTANCES`` . This indicates that the maximum number of instances that can be run on this service environment is 50. You could then run 5 SageMaker Training jobs that each use 10 instances. However, if you submit another job that requires 10 instances, it will wait in the queue.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-batch-serviceenvironment-capacitylimit.html#cfn-batch-serviceenvironment-capacitylimit-maxcapacity
+            '''
+            result = self._values.get("max_capacity")
+            return typing.cast(typing.Optional[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 "CapacityLimitProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_batch.CfnServiceEnvironmentProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "capacity_limits": "capacityLimits",
+        "service_environment_type": "serviceEnvironmentType",
+        "service_environment_name": "serviceEnvironmentName",
+        "state": "state",
+        "tags": "tags",
+    },
+)
+class CfnServiceEnvironmentProps:
+    def __init__(
+        self,
+        *,
+        capacity_limits: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnServiceEnvironment.CapacityLimitProperty, typing.Dict[builtins.str, typing.Any]]]]],
+        service_environment_type: builtins.str,
+        service_environment_name: typing.Optional[builtins.str] = None,
+        state: typing.Optional[builtins.str] = None,
+        tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+    ) -> None:
+        '''Properties for defining a ``CfnServiceEnvironment``.
+
+        :param capacity_limits: The capacity limits for the service environment. This defines the maximum resources that can be used by service jobs in this environment.
+        :param service_environment_type: The type of service environment. For SageMaker Training jobs, this value is ``SAGEMAKER_TRAINING`` .
+        :param service_environment_name: The name of the service environment.
+        :param state: The state of the service environment. Valid values are ``ENABLED`` and ``DISABLED`` .
+        :param tags: The tags associated with the service environment. Each tag consists of a key and an optional value. For more information, see `Tagging your AWS Batch resources <https://docs.aws.amazon.com/batch/latest/userguide/using-tags.html>`_ .
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-serviceenvironment.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
+            
+            cfn_service_environment_props = batch.CfnServiceEnvironmentProps(
+                capacity_limits=[batch.CfnServiceEnvironment.CapacityLimitProperty(
+                    capacity_unit="capacityUnit",
+                    max_capacity=123
+                )],
+                service_environment_type="serviceEnvironmentType",
+            
+                # the properties below are optional
+                service_environment_name="serviceEnvironmentName",
+                state="state",
+                tags={
+                    "tags_key": "tags"
+                }
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__dfdb5cc25e8550eb4e42278bd3377213122f3560aa9c8e788955ad66e1ecad9a)
+            check_type(argname="argument capacity_limits", value=capacity_limits, expected_type=type_hints["capacity_limits"])
+            check_type(argname="argument service_environment_type", value=service_environment_type, expected_type=type_hints["service_environment_type"])
+            check_type(argname="argument service_environment_name", value=service_environment_name, expected_type=type_hints["service_environment_name"])
+            check_type(argname="argument state", value=state, expected_type=type_hints["state"])
+            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "capacity_limits": capacity_limits,
+            "service_environment_type": service_environment_type,
+        }
+        if service_environment_name is not None:
+            self._values["service_environment_name"] = service_environment_name
+        if state is not None:
+            self._values["state"] = state
+        if tags is not None:
+            self._values["tags"] = tags
+
+    @builtins.property
+    def capacity_limits(
+        self,
+    ) -> typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnServiceEnvironment.CapacityLimitProperty]]]:
+        '''The capacity limits for the service environment.
+
+        This defines the maximum resources that can be used by service jobs in this environment.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-serviceenvironment.html#cfn-batch-serviceenvironment-capacitylimits
+        '''
+        result = self._values.get("capacity_limits")
+        assert result is not None, "Required property 'capacity_limits' is missing"
+        return typing.cast(typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnServiceEnvironment.CapacityLimitProperty]]], result)
+
+    @builtins.property
+    def service_environment_type(self) -> builtins.str:
+        '''The type of service environment.
 
-        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-schedulingpolicy.html#cfn-batch-schedulingpolicy-fairsharepolicy
+        For SageMaker Training jobs, this value is ``SAGEMAKER_TRAINING`` .
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-serviceenvironment.html#cfn-batch-serviceenvironment-serviceenvironmenttype
         '''
-        result = self._values.get("fairshare_policy")
-        return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, CfnSchedulingPolicy.FairsharePolicyProperty]], result)
+        result = self._values.get("service_environment_type")
+        assert result is not None, "Required property 'service_environment_type' is missing"
+        return typing.cast(builtins.str, result)
 
     @builtins.property
-    def name(self) -> typing.Optional[builtins.str]:
-        '''The name of the fair-share scheduling policy.
+    def service_environment_name(self) -> typing.Optional[builtins.str]:
+        '''The name of the service environment.
 
-        It can be up to 128 letters long. It can contain uppercase and lowercase letters, numbers, hyphens (-), and underscores (_).
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-serviceenvironment.html#cfn-batch-serviceenvironment-serviceenvironmentname
+        '''
+        result = self._values.get("service_environment_name")
+        return typing.cast(typing.Optional[builtins.str], result)
 
-        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-schedulingpolicy.html#cfn-batch-schedulingpolicy-name
+    @builtins.property
+    def state(self) -> typing.Optional[builtins.str]:
+        '''The state of the service environment.
+
+        Valid values are ``ENABLED`` and ``DISABLED`` .
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-serviceenvironment.html#cfn-batch-serviceenvironment-state
         '''
-        result = self._values.get("name")
+        result = self._values.get("state")
         return typing.cast(typing.Optional[builtins.str], result)
 
     @builtins.property
     def tags(self) -> typing.Optional[typing.Mapping[builtins.str, builtins.str]]:
-        '''The tags that you apply to the scheduling policy to help you categorize and organize your resources.
-
-        Each tag consists of a key and an optional value. For more information, see `Tagging AWS Resources <https://docs.aws.amazon.com/general/latest/gr/aws_tagging.html>`_ in *AWS General Reference* .
+        '''The tags associated with the service environment.
 
-        These tags can be updated or removed using the `TagResource <https://docs.aws.amazon.com/batch/latest/APIReference/API_TagResource.html>`_ and `UntagResource <https://docs.aws.amazon.com/batch/latest/APIReference/API_UntagResource.html>`_ API operations.
+        Each tag consists of a key and an optional value. For more information, see `Tagging your AWS Batch resources <https://docs.aws.amazon.com/batch/latest/userguide/using-tags.html>`_ .
 
-        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-schedulingpolicy.html#cfn-batch-schedulingpolicy-tags
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-batch-serviceenvironment.html#cfn-batch-serviceenvironment-tags
         '''
         result = self._values.get("tags")
         return typing.cast(typing.Optional[typing.Mapping[builtins.str, builtins.str]], result)
@@ -11559,7 +12455,7 @@ class CfnSchedulingPolicyProps:
         return not (rhs == self)
 
     def __repr__(self) -> str:
-        return "CfnSchedulingPolicyProps(%s)" % ", ".join(
+        return "CfnServiceEnvironmentProps(%s)" % ", ".join(
             k + "=" + repr(v) for k, v in self._values.items()
         )
 
@@ -11771,6 +12667,29 @@ class CustomReason:
         )
 
 
+@jsii.enum(jsii_type="aws-cdk-lib.aws_batch.DefaultInstanceClass")
+class DefaultInstanceClass(enum.Enum):
+    '''Batch default instances types.
+
+    :see: https://docs.aws.amazon.com/batch/latest/userguide/instance-type-compute-table.html
+    :exampleMetadata: infused
+
+    Example::
+
+        vpc = ec2.Vpc(self, "VPC")
+        
+        batch.ManagedEc2EcsComputeEnvironment(self, "myEc2ComputeEnv",
+            vpc=vpc,
+            default_instance_classes=[batch.DefaultInstanceClass.ARM64]
+        )
+    '''
+
+    X86_64 = "X86_64"
+    '''x86 based instance types (from the m6i, c6i, r6i, and c7i instance families).'''
+    ARM64 = "ARM64"
+    '''ARM64 based instance types (from the m6g, c6g, r6g, and c7g instance families).'''
+
+
 @jsii.data_type(
     jsii_type="aws-cdk-lib.aws_batch.Device",
     jsii_struct_bases=[],
@@ -11900,6 +12819,7 @@ class DnsPolicy(enum.Enum):
         "image": "image",
         "memory": "memory",
         "command": "command",
+        "enable_execute_command": "enableExecuteCommand",
         "environment": "environment",
         "execution_role": "executionRole",
         "job_role": "jobRole",
@@ -11919,6 +12839,7 @@ class EcsContainerDefinitionProps:
         image: _ContainerImage_94af1b43,
         memory: _Size_7b441c34,
         command: typing.Optional[typing.Sequence[builtins.str]] = None,
+        enable_execute_command: typing.Optional[builtins.bool] = None,
         environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         execution_role: typing.Optional[_IRole_235f5d8e] = None,
         job_role: typing.Optional[_IRole_235f5d8e] = None,
@@ -11935,6 +12856,7 @@ class EcsContainerDefinitionProps:
         :param image: The image that this container will run.
         :param memory: The memory hard limit present to the container. If your container attempts to exceed the memory specified, the container is terminated. You must specify at least 4 MiB of memory for a job.
         :param command: The command that's passed to the container. Default: - no command
+        :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. This allows you to use ECS Exec to access containers interactively. When enabled, a job role with required SSM permissions will be created automatically if no job role is provided. If a job role is alreadyprovided, the required permissions will be added to it. Default: undefined - AWS Batch default is false
         :param environment: The environment variables to pass to a container. Cannot start with ``AWS_BATCH``. We don't recommend using plaintext environment variables for sensitive information, such as credential data. Default: - no environment variables
         :param execution_role: The role used by Amazon ECS container and AWS Fargate agents to make AWS API calls on your behalf. Default: - a Role will be created
         :param job_role: The role that the container can assume. Default: - no job role
@@ -11971,6 +12893,7 @@ class EcsContainerDefinitionProps:
             
                 # the properties below are optional
                 command=["command"],
+                enable_execute_command=False,
                 environment={
                     "environment_key": "environment"
                 },
@@ -11992,6 +12915,7 @@ class EcsContainerDefinitionProps:
             check_type(argname="argument image", value=image, expected_type=type_hints["image"])
             check_type(argname="argument memory", value=memory, expected_type=type_hints["memory"])
             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 execution_role", value=execution_role, expected_type=type_hints["execution_role"])
             check_type(argname="argument job_role", value=job_role, expected_type=type_hints["job_role"])
@@ -12008,6 +12932,8 @@ class EcsContainerDefinitionProps:
         }
         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 execution_role is not None:
@@ -12067,6 +12993,23 @@ class EcsContainerDefinitionProps:
         result = self._values.get("command")
         return typing.cast(typing.Optional[typing.List[builtins.str]], result)
 
+    @builtins.property
+    def enable_execute_command(self) -> typing.Optional[builtins.bool]:
+        '''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.
+
+        This allows you to use ECS Exec to access containers interactively.
+        When enabled, a job role with required SSM permissions will be created automatically if no job role is provided.
+        If a job role is alreadyprovided, the required permissions will be added to it.
+
+        :default: undefined - AWS Batch default is false
+
+        :see: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html
+        '''
+        result = self._values.get("enable_execute_command")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     @builtins.property
     def environment(
         self,
@@ -12184,6 +13127,7 @@ class EcsContainerDefinitionProps:
         "image": "image",
         "memory": "memory",
         "command": "command",
+        "enable_execute_command": "enableExecuteCommand",
         "environment": "environment",
         "execution_role": "executionRole",
         "job_role": "jobRole",
@@ -12206,6 +13150,7 @@ class EcsEc2ContainerDefinitionProps(EcsContainerDefinitionProps):
         image: _ContainerImage_94af1b43,
         memory: _Size_7b441c34,
         command: typing.Optional[typing.Sequence[builtins.str]] = None,
+        enable_execute_command: typing.Optional[builtins.bool] = None,
         environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         execution_role: typing.Optional[_IRole_235f5d8e] = None,
         job_role: typing.Optional[_IRole_235f5d8e] = None,
@@ -12225,6 +13170,7 @@ class EcsEc2ContainerDefinitionProps(EcsContainerDefinitionProps):
         :param image: The image that this container will run.
         :param memory: The memory hard limit present to the container. If your container attempts to exceed the memory specified, the container is terminated. You must specify at least 4 MiB of memory for a job.
         :param command: The command that's passed to the container. Default: - no command
+        :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. This allows you to use ECS Exec to access containers interactively. When enabled, a job role with required SSM permissions will be created automatically if no job role is provided. If a job role is alreadyprovided, the required permissions will be added to it. Default: undefined - AWS Batch default is false
         :param environment: The environment variables to pass to a container. Cannot start with ``AWS_BATCH``. We don't recommend using plaintext environment variables for sensitive information, such as credential data. Default: - no environment variables
         :param execution_role: The role used by Amazon ECS container and AWS Fargate agents to make AWS API calls on your behalf. Default: - a Role will be created
         :param job_role: The role that the container can assume. Default: - no job role
@@ -12272,6 +13218,7 @@ class EcsEc2ContainerDefinitionProps(EcsContainerDefinitionProps):
             check_type(argname="argument image", value=image, expected_type=type_hints["image"])
             check_type(argname="argument memory", value=memory, expected_type=type_hints["memory"])
             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 execution_role", value=execution_role, expected_type=type_hints["execution_role"])
             check_type(argname="argument job_role", value=job_role, expected_type=type_hints["job_role"])
@@ -12291,6 +13238,8 @@ class EcsEc2ContainerDefinitionProps(EcsContainerDefinitionProps):
         }
         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 execution_role is not None:
@@ -12356,6 +13305,23 @@ class EcsEc2ContainerDefinitionProps(EcsContainerDefinitionProps):
         result = self._values.get("command")
         return typing.cast(typing.Optional[typing.List[builtins.str]], result)
 
+    @builtins.property
+    def enable_execute_command(self) -> typing.Optional[builtins.bool]:
+        '''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.
+
+        This allows you to use ECS Exec to access containers interactively.
+        When enabled, a job role with required SSM permissions will be created automatically if no job role is provided.
+        If a job role is alreadyprovided, the required permissions will be added to it.
+
+        :default: undefined - AWS Batch default is false
+
+        :see: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html
+        '''
+        result = self._values.get("enable_execute_command")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     @builtins.property
     def environment(
         self,
@@ -12503,6 +13469,7 @@ class EcsEc2ContainerDefinitionProps(EcsContainerDefinitionProps):
         "image": "image",
         "memory": "memory",
         "command": "command",
+        "enable_execute_command": "enableExecuteCommand",
         "environment": "environment",
         "execution_role": "executionRole",
         "job_role": "jobRole",
@@ -12527,6 +13494,7 @@ class EcsFargateContainerDefinitionProps(EcsContainerDefinitionProps):
         image: _ContainerImage_94af1b43,
         memory: _Size_7b441c34,
         command: typing.Optional[typing.Sequence[builtins.str]] = None,
+        enable_execute_command: typing.Optional[builtins.bool] = None,
         environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         execution_role: typing.Optional[_IRole_235f5d8e] = None,
         job_role: typing.Optional[_IRole_235f5d8e] = None,
@@ -12548,6 +13516,7 @@ class EcsFargateContainerDefinitionProps(EcsContainerDefinitionProps):
         :param image: The image that this container will run.
         :param memory: The memory hard limit present to the container. If your container attempts to exceed the memory specified, the container is terminated. You must specify at least 4 MiB of memory for a job.
         :param command: The command that's passed to the container. Default: - no command
+        :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. This allows you to use ECS Exec to access containers interactively. When enabled, a job role with required SSM permissions will be created automatically if no job role is provided. If a job role is alreadyprovided, the required permissions will be added to it. Default: undefined - AWS Batch default is false
         :param environment: The environment variables to pass to a container. Cannot start with ``AWS_BATCH``. We don't recommend using plaintext environment variables for sensitive information, such as credential data. Default: - no environment variables
         :param execution_role: The role used by Amazon ECS container and AWS Fargate agents to make AWS API calls on your behalf. Default: - a Role will be created
         :param job_role: The role that the container can assume. Default: - no job role
@@ -12584,6 +13553,7 @@ class EcsFargateContainerDefinitionProps(EcsContainerDefinitionProps):
             check_type(argname="argument image", value=image, expected_type=type_hints["image"])
             check_type(argname="argument memory", value=memory, expected_type=type_hints["memory"])
             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 execution_role", value=execution_role, expected_type=type_hints["execution_role"])
             check_type(argname="argument job_role", value=job_role, expected_type=type_hints["job_role"])
@@ -12605,6 +13575,8 @@ class EcsFargateContainerDefinitionProps(EcsContainerDefinitionProps):
         }
         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 execution_role is not None:
@@ -12674,6 +13646,23 @@ class EcsFargateContainerDefinitionProps(EcsContainerDefinitionProps):
         result = self._values.get("command")
         return typing.cast(typing.Optional[typing.List[builtins.str]], result)
 
+    @builtins.property
+    def enable_execute_command(self) -> typing.Optional[builtins.bool]:
+        '''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.
+
+        This allows you to use ECS Exec to access containers interactively.
+        When enabled, a job role with required SSM permissions will be created automatically if no job role is provided.
+        If a job role is alreadyprovided, the required permissions will be added to it.
+
+        :default: undefined - AWS Batch default is false
+
+        :see: https://docs.aws.amazon.com/AmazonECS/latest/developerguide/ecs-exec.html
+        '''
+        result = self._values.get("enable_execute_command")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
     @builtins.property
     def environment(
         self,
@@ -15217,6 +16206,15 @@ class IEcsContainerDefinition(
         '''
         ...
 
+    @builtins.property
+    @jsii.member(jsii_name="enableExecuteCommand")
+    def enable_execute_command(self) -> typing.Optional[builtins.bool]:
+        '''Whether to enable ecs exec for this container.
+
+        :default: undefined - AWS Batch default is false
+        '''
+        ...
+
     @builtins.property
     @jsii.member(jsii_name="environment")
     def environment(
@@ -15360,6 +16358,15 @@ class _IEcsContainerDefinitionProxy(
         '''
         return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "command"))
 
+    @builtins.property
+    @jsii.member(jsii_name="enableExecuteCommand")
+    def enable_execute_command(self) -> typing.Optional[builtins.bool]:
+        '''Whether to enable ecs exec for this container.
+
+        :default: undefined - AWS Batch default is false
+        '''
+        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "enableExecuteCommand"))
+
     @builtins.property
     @jsii.member(jsii_name="environment")
     def environment(
@@ -17955,6 +18962,8 @@ class JobStateTimeLimitActionsAction(enum.Enum):
 
     CANCEL = "CANCEL"
     '''Cancel the job.'''
+    TERMINATE = "TERMINATE"
+    '''Terminate the job.'''
 
 
 @jsii.enum(jsii_type="aws-cdk-lib.aws_batch.JobStateTimeLimitActionsReason")
@@ -18591,13 +19600,14 @@ class ManagedEc2EcsComputeEnvironment(
         id: builtins.str,
         *,
         allocation_strategy: typing.Optional[AllocationStrategy] = None,
+        default_instance_classes: typing.Optional[typing.Sequence[DefaultInstanceClass]] = None,
         images: typing.Optional[typing.Sequence[typing.Union[EcsMachineImage, typing.Dict[builtins.str, typing.Any]]]] = None,
         instance_classes: typing.Optional[typing.Sequence[_InstanceClass_85a592e7]] = None,
         instance_role: typing.Optional[_IRole_235f5d8e] = None,
         instance_types: typing.Optional[typing.Sequence[_InstanceType_f64915b9]] = None,
         launch_template: typing.Optional[_ILaunchTemplate_f32c0fd7] = None,
         minv_cpus: typing.Optional[jsii.Number] = None,
-        placement_group: typing.Optional[_IPlacementGroup_583ddf23] = None,
+        placement_group: typing.Optional[_IPlacementGroupRef_5d6e601f] = None,
         spot_bid_percentage: typing.Optional[jsii.Number] = None,
         spot_fleet_role: typing.Optional[_IRole_235f5d8e] = None,
         use_optimal_instance_classes: typing.Optional[builtins.bool] = None,
@@ -18618,6 +19628,7 @@ class ManagedEc2EcsComputeEnvironment(
         :param scope: -
         :param id: -
         :param allocation_strategy: The allocation strategy to use if not enough instances of the best fitting instance type can be allocated. Default: - ``BEST_FIT_PROGRESSIVE`` if not using Spot instances, ``SPOT_CAPACITY_OPTIMIZED`` if using Spot instances.
+        :param default_instance_classes: Use batch's default instance types. A simpler way to choose up-to-date instance classes based on region instead of specifying exact instance classes. Default: - choose from instanceTypes and instanceClasses
         :param images: Configure which AMIs this Compute Environment can launch. If you specify this property with only ``image`` specified, then the ``imageType`` will default to ``ECS_AL2``. *If your image needs GPU resources, specify ``ECS_AL2_NVIDIA``; otherwise, the instances will not be able to properly join the ComputeEnvironment*. Default: - ECS_AL2 for non-GPU instances, ECS_AL2_NVIDIA for GPU instances
         :param instance_classes: The instance classes that this Compute Environment can launch. Which one is chosen depends on the ``AllocationStrategy`` used. Batch will automatically choose the instance size. Default: - the instances Batch considers will be used (currently C4, M4, and R4)
         :param instance_role: The execution Role that instances launched by this Compute Environment will use. Default: - a role will be created
@@ -18627,7 +19638,7 @@ class ManagedEc2EcsComputeEnvironment(
         :param placement_group: The EC2 placement group to associate with your compute resources. If you intend to submit multi-node parallel jobs to this 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. Default: - no placement group
         :param spot_bid_percentage: The maximum percentage that a Spot Instance price can be when compared with the On-Demand price for that instance type before instances are launched. For example, if your maximum percentage is 20%, the Spot price must be less than 20% of the current On-Demand price for that Instance. You always pay the lowest market price and never more than your maximum percentage. For most use cases, Batch recommends leaving this field empty. Implies ``spot == true`` if set Default: 100%
         :param spot_fleet_role: The service-linked role that Spot Fleet needs to launch instances on your behalf. Default: - a new role will be created
-        :param use_optimal_instance_classes: Whether or not to use batch's optimal instance type. The optimal instance type is equivalent to adding the C4, M4, and R4 instance classes. You can specify other instance classes (of the same architecture) in addition to the optimal instance classes. Default: true
+        :param use_optimal_instance_classes: (deprecated) Whether or not to use batch's optimal instance type. The optimal instance type is equivalent to adding the C4, M4, and R4 instance classes. You can specify other instance classes (of the same architecture) in addition to the optimal instance classes. Default: true
         :param vpc: VPC in which this Compute Environment will launch Instances.
         :param maxv_cpus: The maximum vCpus this ``ManagedComputeEnvironment`` can scale up to. Each vCPU is equivalent to 1024 CPU shares. *Note*: if this Compute Environment uses EC2 resources (not Fargate) with either ``AllocationStrategy.BEST_FIT_PROGRESSIVE`` or ``AllocationStrategy.SPOT_CAPACITY_OPTIMIZED``, or ``AllocationStrategy.BEST_FIT`` with Spot instances, The scheduler may exceed this number by at most one of the instances specified in ``instanceTypes`` or ``instanceClasses``. Default: 256
         :param replace_compute_environment: Specifies whether this Compute Environment is replaced if an update is made that requires replacing its instances. To enable more properties to be updated, set this property to ``false``. When changing the value of this property to false, do not change any other properties at the same time. If other properties are changed at the same time, and the change needs to be rolled back but it can't, it's possible for the stack to go into the UPDATE_ROLLBACK_FAILED state. You can't update a stack that is in the UPDATE_ROLLBACK_FAILED state. However, if you can continue to roll it back, you can return the stack to its original settings and then try to update it again. The properties which require a replacement of the Compute Environment are: Default: false
@@ -18647,6 +19658,7 @@ class ManagedEc2EcsComputeEnvironment(
             check_type(argname="argument id", value=id, expected_type=type_hints["id"])
         props = ManagedEc2EcsComputeEnvironmentProps(
             allocation_strategy=allocation_strategy,
+            default_instance_classes=default_instance_classes,
             images=images,
             instance_classes=instance_classes,
             instance_role=instance_role,
@@ -18957,6 +19969,7 @@ class ManagedEc2EcsComputeEnvironment(
         "update_to_latest_image_version": "updateToLatestImageVersion",
         "vpc_subnets": "vpcSubnets",
         "allocation_strategy": "allocationStrategy",
+        "default_instance_classes": "defaultInstanceClasses",
         "images": "images",
         "instance_classes": "instanceClasses",
         "instance_role": "instanceRole",
@@ -18986,13 +19999,14 @@ class ManagedEc2EcsComputeEnvironmentProps(ManagedComputeEnvironmentProps):
         update_to_latest_image_version: typing.Optional[builtins.bool] = None,
         vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
         allocation_strategy: typing.Optional[AllocationStrategy] = None,
+        default_instance_classes: typing.Optional[typing.Sequence[DefaultInstanceClass]] = None,
         images: typing.Optional[typing.Sequence[typing.Union[EcsMachineImage, typing.Dict[builtins.str, typing.Any]]]] = None,
         instance_classes: typing.Optional[typing.Sequence[_InstanceClass_85a592e7]] = None,
         instance_role: typing.Optional[_IRole_235f5d8e] = None,
         instance_types: typing.Optional[typing.Sequence[_InstanceType_f64915b9]] = None,
         launch_template: typing.Optional[_ILaunchTemplate_f32c0fd7] = None,
         minv_cpus: typing.Optional[jsii.Number] = None,
-        placement_group: typing.Optional[_IPlacementGroup_583ddf23] = None,
+        placement_group: typing.Optional[_IPlacementGroupRef_5d6e601f] = None,
         spot_bid_percentage: typing.Optional[jsii.Number] = None,
         spot_fleet_role: typing.Optional[_IRole_235f5d8e] = None,
         use_optimal_instance_classes: typing.Optional[builtins.bool] = None,
@@ -19012,6 +20026,7 @@ class ManagedEc2EcsComputeEnvironmentProps(ManagedComputeEnvironmentProps):
         :param update_to_latest_image_version: Whether or not the AMI is updated to the latest one supported by Batch when an infrastructure update occurs. If you specify a specific AMI, this property will be ignored. Note: the CDK will never set this value by default, ``false`` will set by CFN. This is to avoid a deployment failure that occurs when this value is set. Default: false
         :param vpc_subnets: The VPC Subnets this Compute Environment will launch instances in. Default: new subnets will be created
         :param allocation_strategy: The allocation strategy to use if not enough instances of the best fitting instance type can be allocated. Default: - ``BEST_FIT_PROGRESSIVE`` if not using Spot instances, ``SPOT_CAPACITY_OPTIMIZED`` if using Spot instances.
+        :param default_instance_classes: Use batch's default instance types. A simpler way to choose up-to-date instance classes based on region instead of specifying exact instance classes. Default: - choose from instanceTypes and instanceClasses
         :param images: Configure which AMIs this Compute Environment can launch. If you specify this property with only ``image`` specified, then the ``imageType`` will default to ``ECS_AL2``. *If your image needs GPU resources, specify ``ECS_AL2_NVIDIA``; otherwise, the instances will not be able to properly join the ComputeEnvironment*. Default: - ECS_AL2 for non-GPU instances, ECS_AL2_NVIDIA for GPU instances
         :param instance_classes: The instance classes that this Compute Environment can launch. Which one is chosen depends on the ``AllocationStrategy`` used. Batch will automatically choose the instance size. Default: - the instances Batch considers will be used (currently C4, M4, and R4)
         :param instance_role: The execution Role that instances launched by this Compute Environment will use. Default: - a role will be created
@@ -19021,7 +20036,7 @@ class ManagedEc2EcsComputeEnvironmentProps(ManagedComputeEnvironmentProps):
         :param placement_group: The EC2 placement group to associate with your compute resources. If you intend to submit multi-node parallel jobs to this 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. Default: - no placement group
         :param spot_bid_percentage: The maximum percentage that a Spot Instance price can be when compared with the On-Demand price for that instance type before instances are launched. For example, if your maximum percentage is 20%, the Spot price must be less than 20% of the current On-Demand price for that Instance. You always pay the lowest market price and never more than your maximum percentage. For most use cases, Batch recommends leaving this field empty. Implies ``spot == true`` if set Default: 100%
         :param spot_fleet_role: The service-linked role that Spot Fleet needs to launch instances on your behalf. Default: - a new role will be created
-        :param use_optimal_instance_classes: Whether or not to use batch's optimal instance type. The optimal instance type is equivalent to adding the C4, M4, and R4 instance classes. You can specify other instance classes (of the same architecture) in addition to the optimal instance classes. Default: true
+        :param use_optimal_instance_classes: (deprecated) Whether or not to use batch's optimal instance type. The optimal instance type is equivalent to adding the C4, M4, and R4 instance classes. You can specify other instance classes (of the same architecture) in addition to the optimal instance classes. Default: true
 
         :exampleMetadata: infused
 
@@ -19053,6 +20068,7 @@ class ManagedEc2EcsComputeEnvironmentProps(ManagedComputeEnvironmentProps):
             check_type(argname="argument update_to_latest_image_version", value=update_to_latest_image_version, expected_type=type_hints["update_to_latest_image_version"])
             check_type(argname="argument vpc_subnets", value=vpc_subnets, expected_type=type_hints["vpc_subnets"])
             check_type(argname="argument allocation_strategy", value=allocation_strategy, expected_type=type_hints["allocation_strategy"])
+            check_type(argname="argument default_instance_classes", value=default_instance_classes, expected_type=type_hints["default_instance_classes"])
             check_type(argname="argument images", value=images, expected_type=type_hints["images"])
             check_type(argname="argument instance_classes", value=instance_classes, expected_type=type_hints["instance_classes"])
             check_type(argname="argument instance_role", value=instance_role, expected_type=type_hints["instance_role"])
@@ -19090,6 +20106,8 @@ class ManagedEc2EcsComputeEnvironmentProps(ManagedComputeEnvironmentProps):
             self._values["vpc_subnets"] = vpc_subnets
         if allocation_strategy is not None:
             self._values["allocation_strategy"] = allocation_strategy
+        if default_instance_classes is not None:
+            self._values["default_instance_classes"] = default_instance_classes
         if images is not None:
             self._values["images"] = images
         if instance_classes is not None:
@@ -19281,6 +20299,22 @@ class ManagedEc2EcsComputeEnvironmentProps(ManagedComputeEnvironmentProps):
         result = self._values.get("allocation_strategy")
         return typing.cast(typing.Optional[AllocationStrategy], result)
 
+    @builtins.property
+    def default_instance_classes(
+        self,
+    ) -> typing.Optional[typing.List[DefaultInstanceClass]]:
+        '''Use batch's default instance types.
+
+        A simpler way to choose up-to-date instance classes based on region
+        instead of specifying exact instance classes.
+
+        :default: - choose from instanceTypes and instanceClasses
+
+        :see: https://docs.aws.amazon.com/batch/latest/userguide/instance-type-compute-table.html
+        '''
+        result = self._values.get("default_instance_classes")
+        return typing.cast(typing.Optional[typing.List[DefaultInstanceClass]], result)
+
     @builtins.property
     def images(self) -> typing.Optional[typing.List[EcsMachineImage]]:
         '''Configure which AMIs this Compute Environment can launch.
@@ -19351,7 +20385,7 @@ class ManagedEc2EcsComputeEnvironmentProps(ManagedComputeEnvironmentProps):
         return typing.cast(typing.Optional[jsii.Number], result)
 
     @builtins.property
-    def placement_group(self) -> typing.Optional[_IPlacementGroup_583ddf23]:
+    def placement_group(self) -> typing.Optional[_IPlacementGroupRef_5d6e601f]:
         '''The EC2 placement group to associate with your compute resources.
 
         If you intend to submit multi-node parallel jobs to this Compute Environment,
@@ -19364,7 +20398,7 @@ class ManagedEc2EcsComputeEnvironmentProps(ManagedComputeEnvironmentProps):
         :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html
         '''
         result = self._values.get("placement_group")
-        return typing.cast(typing.Optional[_IPlacementGroup_583ddf23], result)
+        return typing.cast(typing.Optional[_IPlacementGroupRef_5d6e601f], result)
 
     @builtins.property
     def spot_bid_percentage(self) -> typing.Optional[jsii.Number]:
@@ -19395,13 +20429,17 @@ class ManagedEc2EcsComputeEnvironmentProps(ManagedComputeEnvironmentProps):
 
     @builtins.property
     def use_optimal_instance_classes(self) -> typing.Optional[builtins.bool]:
-        '''Whether or not to use batch's optimal instance type.
+        '''(deprecated) Whether or not to use batch's optimal instance type.
 
         The optimal instance type is equivalent to adding the
         C4, M4, and R4 instance classes. You can specify other instance classes
         (of the same architecture) in addition to the optimal instance classes.
 
         :default: true
+
+        :deprecated: use defaultInstanceClasses instead
+
+        :stability: deprecated
         '''
         result = self._values.get("use_optimal_instance_classes")
         return typing.cast(typing.Optional[builtins.bool], result)
@@ -19438,12 +20476,13 @@ class ManagedEc2EksComputeEnvironment(
         from aws_cdk import aws_ec2 as ec2
         from aws_cdk import aws_eks as eks
         from aws_cdk import aws_iam as iam
+        from aws_cdk.interfaces import aws_ec2 as interfaces_aws_ec2
         
         # cluster: eks.Cluster
         # instance_type: ec2.InstanceType
         # launch_template: ec2.LaunchTemplate
         # machine_image: ec2.IMachineImage
-        # placement_group: ec2.PlacementGroup
+        # placement_group_ref: interfaces_aws_ec2.IPlacementGroupRef
         # role: iam.Role
         # security_group: ec2.SecurityGroup
         # subnet: ec2.Subnet
@@ -19458,6 +20497,7 @@ class ManagedEc2EksComputeEnvironment(
             # the properties below are optional
             allocation_strategy=batch.AllocationStrategy.BEST_FIT,
             compute_environment_name="computeEnvironmentName",
+            default_instance_classes=[batch.DefaultInstanceClass.X86_64],
             enabled=False,
             images=[batch.EksMachineImage(
                 image=machine_image,
@@ -19469,7 +20509,7 @@ class ManagedEc2EksComputeEnvironment(
             launch_template=launch_template,
             maxv_cpus=123,
             minv_cpus=123,
-            placement_group=placement_group,
+            placement_group=placement_group_ref,
             replace_compute_environment=False,
             security_groups=[security_group],
             service_role=role,
@@ -19498,13 +20538,14 @@ class ManagedEc2EksComputeEnvironment(
         eks_cluster: _ICluster_6b2b80df,
         kubernetes_namespace: builtins.str,
         allocation_strategy: typing.Optional[AllocationStrategy] = None,
+        default_instance_classes: typing.Optional[typing.Sequence[DefaultInstanceClass]] = None,
         images: typing.Optional[typing.Sequence[typing.Union[EksMachineImage, typing.Dict[builtins.str, typing.Any]]]] = None,
         instance_classes: typing.Optional[typing.Sequence[_InstanceClass_85a592e7]] = None,
         instance_role: typing.Optional[_IRole_235f5d8e] = None,
         instance_types: typing.Optional[typing.Sequence[_InstanceType_f64915b9]] = None,
         launch_template: typing.Optional[_ILaunchTemplate_f32c0fd7] = None,
         minv_cpus: typing.Optional[jsii.Number] = None,
-        placement_group: typing.Optional[_IPlacementGroup_583ddf23] = None,
+        placement_group: typing.Optional[_IPlacementGroupRef_5d6e601f] = None,
         spot_bid_percentage: typing.Optional[jsii.Number] = None,
         use_optimal_instance_classes: typing.Optional[builtins.bool] = None,
         vpc: _IVpc_f30d5663,
@@ -19526,6 +20567,7 @@ class ManagedEc2EksComputeEnvironment(
         :param eks_cluster: The cluster that backs this Compute Environment. Required for Compute Environments running Kubernetes jobs. Please ensure that you have followed the steps at https://docs.aws.amazon.com/batch/latest/userguide/getting-started-eks.html before attempting to deploy a ``ManagedEc2EksComputeEnvironment`` that uses this cluster. If you do not follow the steps in the link, the deployment fail with a message that the compute environment did not stabilize.
         :param kubernetes_namespace: The namespace of the Cluster.
         :param allocation_strategy: The allocation strategy to use if not enough instances of the best fitting instance type can be allocated. Default: - ``BEST_FIT_PROGRESSIVE`` if not using Spot instances, ``SPOT_CAPACITY_OPTIMIZED`` if using Spot instances.
+        :param default_instance_classes: Use batch's default instance types. A simpler way to choose up-to-date instance classes based on region instead of specifying exact instance classes. Default: - choose from instanceTypes and instanceClasses
         :param images: Configure which AMIs this Compute Environment can launch. Default: If ``imageKubernetesVersion`` is specified, - EKS_AL2 for non-GPU instances, EKS_AL2_NVIDIA for GPU instances, Otherwise, - ECS_AL2 for non-GPU instances, ECS_AL2_NVIDIA for GPU instances,
         :param instance_classes: The instance types that this Compute Environment can launch. Which one is chosen depends on the ``AllocationStrategy`` used. Batch will automatically choose the instance size. Default: - the instances Batch considers will be used (currently C4, M4, and R4)
         :param instance_role: The execution Role that instances launched by this Compute Environment will use. Default: - a role will be created
@@ -19534,7 +20576,7 @@ class ManagedEc2EksComputeEnvironment(
         :param minv_cpus: The minimum vCPUs that an environment should maintain, even if the compute environment is DISABLED. Default: 0
         :param placement_group: The EC2 placement group to associate with your compute resources. If you intend to submit multi-node parallel jobs to this 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. Default: - no placement group
         :param spot_bid_percentage: The maximum percentage that a Spot Instance price can be when compared with the On-Demand price for that instance type before instances are launched. For example, if your maximum percentage is 20%, the Spot price must be less than 20% of the current On-Demand price for that Instance. You always pay the lowest market price and never more than your maximum percentage. For most use cases, Batch recommends leaving this field empty. Implies ``spot == true`` if set Default: - 100%
-        :param use_optimal_instance_classes: Whether or not to use batch's optimal instance type. The optimal instance type is equivalent to adding the C4, M4, and R4 instance classes. You can specify other instance classes (of the same architecture) in addition to the optimal instance classes. Default: true
+        :param use_optimal_instance_classes: (deprecated) Whether or not to use batch's optimal instance type. The optimal instance type is equivalent to adding the C4, M4, and R4 instance classes. You can specify other instance classes (of the same architecture) in addition to the optimal instance classes. Default: true
         :param vpc: VPC in which this Compute Environment will launch Instances.
         :param maxv_cpus: The maximum vCpus this ``ManagedComputeEnvironment`` can scale up to. Each vCPU is equivalent to 1024 CPU shares. *Note*: if this Compute Environment uses EC2 resources (not Fargate) with either ``AllocationStrategy.BEST_FIT_PROGRESSIVE`` or ``AllocationStrategy.SPOT_CAPACITY_OPTIMIZED``, or ``AllocationStrategy.BEST_FIT`` with Spot instances, The scheduler may exceed this number by at most one of the instances specified in ``instanceTypes`` or ``instanceClasses``. Default: 256
         :param replace_compute_environment: Specifies whether this Compute Environment is replaced if an update is made that requires replacing its instances. To enable more properties to be updated, set this property to ``false``. When changing the value of this property to false, do not change any other properties at the same time. If other properties are changed at the same time, and the change needs to be rolled back but it can't, it's possible for the stack to go into the UPDATE_ROLLBACK_FAILED state. You can't update a stack that is in the UPDATE_ROLLBACK_FAILED state. However, if you can continue to roll it back, you can return the stack to its original settings and then try to update it again. The properties which require a replacement of the Compute Environment are: Default: false
@@ -19556,6 +20598,7 @@ class ManagedEc2EksComputeEnvironment(
             eks_cluster=eks_cluster,
             kubernetes_namespace=kubernetes_namespace,
             allocation_strategy=allocation_strategy,
+            default_instance_classes=default_instance_classes,
             images=images,
             instance_classes=instance_classes,
             instance_role=instance_role,
@@ -19862,6 +20905,7 @@ class ManagedEc2EksComputeEnvironment(
         "eks_cluster": "eksCluster",
         "kubernetes_namespace": "kubernetesNamespace",
         "allocation_strategy": "allocationStrategy",
+        "default_instance_classes": "defaultInstanceClasses",
         "images": "images",
         "instance_classes": "instanceClasses",
         "instance_role": "instanceRole",
@@ -19892,13 +20936,14 @@ class ManagedEc2EksComputeEnvironmentProps(ManagedComputeEnvironmentProps):
         eks_cluster: _ICluster_6b2b80df,
         kubernetes_namespace: builtins.str,
         allocation_strategy: typing.Optional[AllocationStrategy] = None,
+        default_instance_classes: typing.Optional[typing.Sequence[DefaultInstanceClass]] = None,
         images: typing.Optional[typing.Sequence[typing.Union[EksMachineImage, typing.Dict[builtins.str, typing.Any]]]] = None,
         instance_classes: typing.Optional[typing.Sequence[_InstanceClass_85a592e7]] = None,
         instance_role: typing.Optional[_IRole_235f5d8e] = None,
         instance_types: typing.Optional[typing.Sequence[_InstanceType_f64915b9]] = None,
         launch_template: typing.Optional[_ILaunchTemplate_f32c0fd7] = None,
         minv_cpus: typing.Optional[jsii.Number] = None,
-        placement_group: typing.Optional[_IPlacementGroup_583ddf23] = None,
+        placement_group: typing.Optional[_IPlacementGroupRef_5d6e601f] = None,
         spot_bid_percentage: typing.Optional[jsii.Number] = None,
         use_optimal_instance_classes: typing.Optional[builtins.bool] = None,
     ) -> None:
@@ -19919,6 +20964,7 @@ class ManagedEc2EksComputeEnvironmentProps(ManagedComputeEnvironmentProps):
         :param eks_cluster: The cluster that backs this Compute Environment. Required for Compute Environments running Kubernetes jobs. Please ensure that you have followed the steps at https://docs.aws.amazon.com/batch/latest/userguide/getting-started-eks.html before attempting to deploy a ``ManagedEc2EksComputeEnvironment`` that uses this cluster. If you do not follow the steps in the link, the deployment fail with a message that the compute environment did not stabilize.
         :param kubernetes_namespace: The namespace of the Cluster.
         :param allocation_strategy: The allocation strategy to use if not enough instances of the best fitting instance type can be allocated. Default: - ``BEST_FIT_PROGRESSIVE`` if not using Spot instances, ``SPOT_CAPACITY_OPTIMIZED`` if using Spot instances.
+        :param default_instance_classes: Use batch's default instance types. A simpler way to choose up-to-date instance classes based on region instead of specifying exact instance classes. Default: - choose from instanceTypes and instanceClasses
         :param images: Configure which AMIs this Compute Environment can launch. Default: If ``imageKubernetesVersion`` is specified, - EKS_AL2 for non-GPU instances, EKS_AL2_NVIDIA for GPU instances, Otherwise, - ECS_AL2 for non-GPU instances, ECS_AL2_NVIDIA for GPU instances,
         :param instance_classes: The instance types that this Compute Environment can launch. Which one is chosen depends on the ``AllocationStrategy`` used. Batch will automatically choose the instance size. Default: - the instances Batch considers will be used (currently C4, M4, and R4)
         :param instance_role: The execution Role that instances launched by this Compute Environment will use. Default: - a role will be created
@@ -19927,7 +20973,7 @@ class ManagedEc2EksComputeEnvironmentProps(ManagedComputeEnvironmentProps):
         :param minv_cpus: The minimum vCPUs that an environment should maintain, even if the compute environment is DISABLED. Default: 0
         :param placement_group: The EC2 placement group to associate with your compute resources. If you intend to submit multi-node parallel jobs to this 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. Default: - no placement group
         :param spot_bid_percentage: The maximum percentage that a Spot Instance price can be when compared with the On-Demand price for that instance type before instances are launched. For example, if your maximum percentage is 20%, the Spot price must be less than 20% of the current On-Demand price for that Instance. You always pay the lowest market price and never more than your maximum percentage. For most use cases, Batch recommends leaving this field empty. Implies ``spot == true`` if set Default: - 100%
-        :param use_optimal_instance_classes: Whether or not to use batch's optimal instance type. The optimal instance type is equivalent to adding the C4, M4, and R4 instance classes. You can specify other instance classes (of the same architecture) in addition to the optimal instance classes. Default: true
+        :param use_optimal_instance_classes: (deprecated) Whether or not to use batch's optimal instance type. The optimal instance type is equivalent to adding the C4, M4, and R4 instance classes. You can specify other instance classes (of the same architecture) in addition to the optimal instance classes. Default: true
 
         :exampleMetadata: fixture=_generated
 
@@ -19940,12 +20986,13 @@ class ManagedEc2EksComputeEnvironmentProps(ManagedComputeEnvironmentProps):
             from aws_cdk import aws_ec2 as ec2
             from aws_cdk import aws_eks as eks
             from aws_cdk import aws_iam as iam
+            from aws_cdk.interfaces import aws_ec2 as interfaces_aws_ec2
             
             # cluster: eks.Cluster
             # instance_type: ec2.InstanceType
             # launch_template: ec2.LaunchTemplate
             # machine_image: ec2.IMachineImage
-            # placement_group: ec2.PlacementGroup
+            # placement_group_ref: interfaces_aws_ec2.IPlacementGroupRef
             # role: iam.Role
             # security_group: ec2.SecurityGroup
             # subnet: ec2.Subnet
@@ -19960,6 +21007,7 @@ class ManagedEc2EksComputeEnvironmentProps(ManagedComputeEnvironmentProps):
                 # the properties below are optional
                 allocation_strategy=batch.AllocationStrategy.BEST_FIT,
                 compute_environment_name="computeEnvironmentName",
+                default_instance_classes=[batch.DefaultInstanceClass.X86_64],
                 enabled=False,
                 images=[batch.EksMachineImage(
                     image=machine_image,
@@ -19971,7 +21019,7 @@ class ManagedEc2EksComputeEnvironmentProps(ManagedComputeEnvironmentProps):
                 launch_template=launch_template,
                 maxv_cpus=123,
                 minv_cpus=123,
-                placement_group=placement_group,
+                placement_group=placement_group_ref,
                 replace_compute_environment=False,
                 security_groups=[security_group],
                 service_role=role,
@@ -20010,6 +21058,7 @@ class ManagedEc2EksComputeEnvironmentProps(ManagedComputeEnvironmentProps):
             check_type(argname="argument eks_cluster", value=eks_cluster, expected_type=type_hints["eks_cluster"])
             check_type(argname="argument kubernetes_namespace", value=kubernetes_namespace, expected_type=type_hints["kubernetes_namespace"])
             check_type(argname="argument allocation_strategy", value=allocation_strategy, expected_type=type_hints["allocation_strategy"])
+            check_type(argname="argument default_instance_classes", value=default_instance_classes, expected_type=type_hints["default_instance_classes"])
             check_type(argname="argument images", value=images, expected_type=type_hints["images"])
             check_type(argname="argument instance_classes", value=instance_classes, expected_type=type_hints["instance_classes"])
             check_type(argname="argument instance_role", value=instance_role, expected_type=type_hints["instance_role"])
@@ -20048,6 +21097,8 @@ class ManagedEc2EksComputeEnvironmentProps(ManagedComputeEnvironmentProps):
             self._values["vpc_subnets"] = vpc_subnets
         if allocation_strategy is not None:
             self._values["allocation_strategy"] = allocation_strategy
+        if default_instance_classes is not None:
+            self._values["default_instance_classes"] = default_instance_classes
         if images is not None:
             self._values["images"] = images
         if instance_classes is not None:
@@ -20260,6 +21311,22 @@ class ManagedEc2EksComputeEnvironmentProps(ManagedComputeEnvironmentProps):
         result = self._values.get("allocation_strategy")
         return typing.cast(typing.Optional[AllocationStrategy], result)
 
+    @builtins.property
+    def default_instance_classes(
+        self,
+    ) -> typing.Optional[typing.List[DefaultInstanceClass]]:
+        '''Use batch's default instance types.
+
+        A simpler way to choose up-to-date instance classes based on region
+        instead of specifying exact instance classes.
+
+        :default: - choose from instanceTypes and instanceClasses
+
+        :see: https://docs.aws.amazon.com/batch/latest/userguide/instance-type-compute-table.html
+        '''
+        result = self._values.get("default_instance_classes")
+        return typing.cast(typing.Optional[typing.List[DefaultInstanceClass]], result)
+
     @builtins.property
     def images(self) -> typing.Optional[typing.List[EksMachineImage]]:
         '''Configure which AMIs this Compute Environment can launch.
@@ -20331,7 +21398,7 @@ class ManagedEc2EksComputeEnvironmentProps(ManagedComputeEnvironmentProps):
         return typing.cast(typing.Optional[jsii.Number], result)
 
     @builtins.property
-    def placement_group(self) -> typing.Optional[_IPlacementGroup_583ddf23]:
+    def placement_group(self) -> typing.Optional[_IPlacementGroupRef_5d6e601f]:
         '''The EC2 placement group to associate with your compute resources.
 
         If you intend to submit multi-node parallel jobs to this Compute Environment,
@@ -20344,7 +21411,7 @@ class ManagedEc2EksComputeEnvironmentProps(ManagedComputeEnvironmentProps):
         :see: https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/placement-groups.html
         '''
         result = self._values.get("placement_group")
-        return typing.cast(typing.Optional[_IPlacementGroup_583ddf23], result)
+        return typing.cast(typing.Optional[_IPlacementGroupRef_5d6e601f], result)
 
     @builtins.property
     def spot_bid_percentage(self) -> typing.Optional[jsii.Number]:
@@ -20364,13 +21431,17 @@ class ManagedEc2EksComputeEnvironmentProps(ManagedComputeEnvironmentProps):
 
     @builtins.property
     def use_optimal_instance_classes(self) -> typing.Optional[builtins.bool]:
-        '''Whether or not to use batch's optimal instance type.
+        '''(deprecated) Whether or not to use batch's optimal instance type.
 
         The optimal instance type is equivalent to adding the
         C4, M4, and R4 instance classes. You can specify other instance classes
         (of the same architecture) in addition to the optimal instance classes.
 
         :default: true
+
+        :deprecated: use defaultInstanceClasses instead
+
+        :stability: deprecated
         '''
         result = self._values.get("use_optimal_instance_classes")
         return typing.cast(typing.Optional[builtins.bool], result)
@@ -22265,6 +23336,7 @@ class EcsEc2ContainerDefinition(
         image: _ContainerImage_94af1b43,
         memory: _Size_7b441c34,
         command: typing.Optional[typing.Sequence[builtins.str]] = None,
+        enable_execute_command: typing.Optional[builtins.bool] = None,
         environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         execution_role: typing.Optional[_IRole_235f5d8e] = None,
         job_role: typing.Optional[_IRole_235f5d8e] = None,
@@ -22285,6 +23357,7 @@ class EcsEc2ContainerDefinition(
         :param image: The image that this container will run.
         :param memory: The memory hard limit present to the container. If your container attempts to exceed the memory specified, the container is terminated. You must specify at least 4 MiB of memory for a job.
         :param command: The command that's passed to the container. Default: - no command
+        :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. This allows you to use ECS Exec to access containers interactively. When enabled, a job role with required SSM permissions will be created automatically if no job role is provided. If a job role is alreadyprovided, the required permissions will be added to it. Default: undefined - AWS Batch default is false
         :param environment: The environment variables to pass to a container. Cannot start with ``AWS_BATCH``. We don't recommend using plaintext environment variables for sensitive information, such as credential data. Default: - no environment variables
         :param execution_role: The role used by Amazon ECS container and AWS Fargate agents to make AWS API calls on your behalf. Default: - a Role will be created
         :param job_role: The role that the container can assume. Default: - no job role
@@ -22307,6 +23380,7 @@ class EcsEc2ContainerDefinition(
             image=image,
             memory=memory,
             command=command,
+            enable_execute_command=enable_execute_command,
             environment=environment,
             execution_role=execution_role,
             job_role=job_role,
@@ -22408,6 +23482,12 @@ class EcsEc2ContainerDefinition(
         '''The command that's passed to the container.'''
         return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "command"))
 
+    @builtins.property
+    @jsii.member(jsii_name="enableExecuteCommand")
+    def enable_execute_command(self) -> typing.Optional[builtins.bool]:
+        '''Whether to enable ecs exec for this container.'''
+        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "enableExecuteCommand"))
+
     @builtins.property
     @jsii.member(jsii_name="environment")
     def environment(
@@ -22515,6 +23595,7 @@ class EcsFargateContainerDefinition(
         image: _ContainerImage_94af1b43,
         memory: _Size_7b441c34,
         command: typing.Optional[typing.Sequence[builtins.str]] = None,
+        enable_execute_command: typing.Optional[builtins.bool] = None,
         environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
         execution_role: typing.Optional[_IRole_235f5d8e] = None,
         job_role: typing.Optional[_IRole_235f5d8e] = None,
@@ -22537,6 +23618,7 @@ class EcsFargateContainerDefinition(
         :param image: The image that this container will run.
         :param memory: The memory hard limit present to the container. If your container attempts to exceed the memory specified, the container is terminated. You must specify at least 4 MiB of memory for a job.
         :param command: The command that's passed to the container. Default: - no command
+        :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. This allows you to use ECS Exec to access containers interactively. When enabled, a job role with required SSM permissions will be created automatically if no job role is provided. If a job role is alreadyprovided, the required permissions will be added to it. Default: undefined - AWS Batch default is false
         :param environment: The environment variables to pass to a container. Cannot start with ``AWS_BATCH``. We don't recommend using plaintext environment variables for sensitive information, such as credential data. Default: - no environment variables
         :param execution_role: The role used by Amazon ECS container and AWS Fargate agents to make AWS API calls on your behalf. Default: - a Role will be created
         :param job_role: The role that the container can assume. Default: - no job role
@@ -22561,6 +23643,7 @@ class EcsFargateContainerDefinition(
             image=image,
             memory=memory,
             command=command,
+            enable_execute_command=enable_execute_command,
             environment=environment,
             execution_role=execution_role,
             job_role=job_role,
@@ -22648,6 +23731,12 @@ class EcsFargateContainerDefinition(
         '''The command that's passed to the container.'''
         return typing.cast(typing.Optional[typing.List[builtins.str]], jsii.get(self, "command"))
 
+    @builtins.property
+    @jsii.member(jsii_name="enableExecuteCommand")
+    def enable_execute_command(self) -> typing.Optional[builtins.bool]:
+        '''Whether to enable ecs exec for this container.'''
+        return typing.cast(typing.Optional[builtins.bool], jsii.get(self, "enableExecuteCommand"))
+
     @builtins.property
     @jsii.member(jsii_name="environment")
     def environment(
@@ -22742,29 +23831,25 @@ class EcsJobDefinition(
 
     Example::
 
-        # vpc: ec2.IVpc
+        # my_file_system: efs.IFileSystem
+        # my_job_role: iam.Role
         
+        my_file_system.grant_read(my_job_role)
         
-        ecs_job = batch.EcsJobDefinition(self, "JobDefn",
+        job_defn = batch.EcsJobDefinition(self, "JobDefn",
             container=batch.EcsEc2ContainerDefinition(self, "containerDefn",
                 image=ecs.ContainerImage.from_registry("public.ecr.aws/amazonlinux/amazonlinux:latest"),
                 memory=cdk.Size.mebibytes(2048),
-                cpu=256
+                cpu=256,
+                volumes=[batch.EcsVolume.efs(
+                    name="myVolume",
+                    file_system=my_file_system,
+                    container_path="/Volumes/myVolume",
+                    use_job_role=True
+                )],
+                job_role=my_job_role
             )
         )
-        
-        queue = batch.JobQueue(self, "JobQueue",
-            compute_environments=[batch.OrderedComputeEnvironment(
-                compute_environment=batch.ManagedEc2EcsComputeEnvironment(self, "managedEc2CE",
-                    vpc=vpc
-                ),
-                order=1
-            )],
-            priority=10
-        )
-        
-        user = iam.User(self, "MyUser")
-        ecs_job.grant_submit_job(user, queue)
     '''
 
     def __init__(
@@ -22974,29 +24059,25 @@ class EcsJobDefinitionProps(JobDefinitionProps):
 
         Example::
 
-            # vpc: ec2.IVpc
+            # my_file_system: efs.IFileSystem
+            # my_job_role: iam.Role
             
+            my_file_system.grant_read(my_job_role)
             
-            ecs_job = batch.EcsJobDefinition(self, "JobDefn",
+            job_defn = batch.EcsJobDefinition(self, "JobDefn",
                 container=batch.EcsEc2ContainerDefinition(self, "containerDefn",
                     image=ecs.ContainerImage.from_registry("public.ecr.aws/amazonlinux/amazonlinux:latest"),
                     memory=cdk.Size.mebibytes(2048),
-                    cpu=256
+                    cpu=256,
+                    volumes=[batch.EcsVolume.efs(
+                        name="myVolume",
+                        file_system=my_file_system,
+                        container_path="/Volumes/myVolume",
+                        use_job_role=True
+                    )],
+                    job_role=my_job_role
                 )
             )
-            
-            queue = batch.JobQueue(self, "JobQueue",
-                compute_environments=[batch.OrderedComputeEnvironment(
-                    compute_environment=batch.ManagedEc2EcsComputeEnvironment(self, "managedEc2CE",
-                        vpc=vpc
-                    ),
-                    order=1
-                )],
-                priority=10
-            )
-            
-            user = iam.User(self, "MyUser")
-            ecs_job.grant_submit_job(user, queue)
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__b8c494afeabc17e9b4e022255720a4708371545e981a1d166b385628fe681d4b)
@@ -24821,8 +25902,11 @@ __all__ = [
     "CfnJobQueueProps",
     "CfnSchedulingPolicy",
     "CfnSchedulingPolicyProps",
+    "CfnServiceEnvironment",
+    "CfnServiceEnvironmentProps",
     "ComputeEnvironmentProps",
     "CustomReason",
+    "DefaultInstanceClass",
     "Device",
     "DevicePermission",
     "DnsPolicy",
@@ -25052,6 +26136,7 @@ def _typecheckingstub__4b5bc20e5d24e0d359d6430d6ef9cdce99590872d896d3e0d65372a69
     launch_template_id: typing.Optional[builtins.str] = None,
     launch_template_name: typing.Optional[builtins.str] = None,
     target_instance_types: typing.Optional[typing.Sequence[builtins.str]] = None,
+    userdata_type: typing.Optional[builtins.str] = None,
     version: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
@@ -25062,6 +26147,7 @@ def _typecheckingstub__e2a48b24f0297afff0df36a352af2f9856ad8fac713d1ecbc2161d0b9
     launch_template_id: typing.Optional[builtins.str] = None,
     launch_template_name: typing.Optional[builtins.str] = None,
     overrides: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnComputeEnvironment.LaunchTemplateSpecificationOverrideProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
+    userdata_type: typing.Optional[builtins.str] = None,
     version: typing.Optional[builtins.str] = None,
 ) -> None:
     """Type checking stubs"""
@@ -25164,6 +26250,7 @@ def _typecheckingstub__37959c68856ab28ea1a57515db976bc2215806d52c75f6166834df6ae
     parameters: typing.Any = None,
     platform_capabilities: typing.Optional[typing.Sequence[builtins.str]] = None,
     propagate_tags: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+    resource_retention_policy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.ResourceRetentionPolicyProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     retry_strategy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.RetryStrategyProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     scheduling_priority: typing.Optional[jsii.Number] = None,
     tags: typing.Any = None,
@@ -25172,6 +26259,22 @@ def _typecheckingstub__37959c68856ab28ea1a57515db976bc2215806d52c75f6166834df6ae
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__9eb64c713801d4b9b5ffb80a279b71c78cb6317fd0c771df22f2646f9d957f0d(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    arn: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__825692ecdcf61885a93251433de856e5a5f6a3a7d68b8673883d418e98bd1956(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    job_definition_name: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__84b6af858f7642dbc10029a34c2ed90c61a840b3c9d8a639fbe0690b4aa593d9(
     inspector: _TreeInspector_488e0dd5,
 ) -> None:
@@ -25244,6 +26347,12 @@ def _typecheckingstub__269e7fe24ddc93928c4ed8726528871fc789de7275942860c547acd76
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__24d6c12e4e40e86cb18eef4cad19675ced395908001d3f74f425b06ab99bb085(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnJobDefinition.ResourceRetentionPolicyProperty]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__2ac615dba37cd2b5a6e9d6f8cdd4b6beef51ff826d65fe0b5cdc31685de03def(
     value: typing.Optional[typing.Union[_IResolvable_da3f097b, CfnJobDefinition.RetryStrategyProperty]],
 ) -> None:
@@ -25625,6 +26734,13 @@ def _typecheckingstub__7384d4b3b97f8aebbaa3dfe7ec74991276f6b53d6e1885662f675369f
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__96a556bd9c16087d87c49ecc18104d825d1cd7dc2f678a8e272fcb8ad46b87ff(
+    *,
+    skip_deregister_on_update: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__634ef7ff057388be2736fb45bfab10d038183951137f893e49e433ed83008f6a(
     *,
     limits: typing.Any = None,
@@ -25753,6 +26869,7 @@ def _typecheckingstub__ed150d027b29486332c3fd2205a51f3c6f64c25946114fb86a6eba384
     parameters: typing.Any = None,
     platform_capabilities: typing.Optional[typing.Sequence[builtins.str]] = None,
     propagate_tags: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+    resource_retention_policy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.ResourceRetentionPolicyProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     retry_strategy: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobDefinition.RetryStrategyProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     scheduling_priority: typing.Optional[jsii.Number] = None,
     tags: typing.Any = None,
@@ -25765,11 +26882,13 @@ def _typecheckingstub__6480ab252bc515b2cdb6dc0c833877438fd473fd39eadf6b8a064969a
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
     *,
-    compute_environment_order: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobQueue.ComputeEnvironmentOrderProperty, typing.Dict[builtins.str, typing.Any]]]]],
     priority: jsii.Number,
+    compute_environment_order: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobQueue.ComputeEnvironmentOrderProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     job_queue_name: typing.Optional[builtins.str] = None,
+    job_queue_type: typing.Optional[builtins.str] = None,
     job_state_time_limit_actions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobQueue.JobStateTimeLimitActionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     scheduling_policy_arn: typing.Optional[builtins.str] = None,
+    service_environment_order: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobQueue.ServiceEnvironmentOrderProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     state: typing.Optional[builtins.str] = None,
     tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
 ) -> None:
@@ -25788,14 +26907,14 @@ def _typecheckingstub__ce1fe922d9589f26998c2113a8a19530d98bfc01fe2462a8639a35935
     """Type checking stubs"""
     pass
 
-def _typecheckingstub__aa1c2f3f42165309672c3fdf8c286ff9dc5e99756ec1a5b3ffca9e719d4c7036(
-    value: typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnJobQueue.ComputeEnvironmentOrderProperty]]],
+def _typecheckingstub__620331f74c116d31a6d43627e1a45e7041bc3c110194265f30dc193863c8ed94(
+    value: jsii.Number,
 ) -> None:
     """Type checking stubs"""
     pass
 
-def _typecheckingstub__620331f74c116d31a6d43627e1a45e7041bc3c110194265f30dc193863c8ed94(
-    value: jsii.Number,
+def _typecheckingstub__aa1c2f3f42165309672c3fdf8c286ff9dc5e99756ec1a5b3ffca9e719d4c7036(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnJobQueue.ComputeEnvironmentOrderProperty]]]],
 ) -> None:
     """Type checking stubs"""
     pass
@@ -25806,6 +26925,12 @@ def _typecheckingstub__3b88e27e62b46f1049263a61bb14f62674a8121083de64c2db32d5856
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__cf7ba788adc96e65e278a0278721e322a7b2c5ad42c7d2cafd707c74e58d6e65(
+    value: typing.Optional[builtins.str],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__6e248d0029fc3043fabb974edf0f06b8f9f721a8f13ce794fd6c39b5ae3bb91e(
     value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnJobQueue.JobStateTimeLimitActionProperty]]]],
 ) -> None:
@@ -25818,6 +26943,12 @@ def _typecheckingstub__48a6952b4a8d4426554895a52085bf8c88701735f3f94a3426e81e56a
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__59b5173dac1cdbe1bbc03df51cc226f4cddcdbdc7dd27fbfc1081cce50fc2d50(
+    value: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnJobQueue.ServiceEnvironmentOrderProperty]]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__e97106b05367d04f8f618f0b8edf4f7fdc4b88436890062ac6e344ede4e180b0(
     value: typing.Optional[builtins.str],
 ) -> None:
@@ -25848,13 +26979,23 @@ def _typecheckingstub__78ff35092216cfb2ffd2106f7da574c86c17494e3404a6f2ccdc020cc
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__04c4b071542df93d5d7f1e7493b1bd821aaeae2008c337f58b1d399f309446bf(
+    *,
+    order: jsii.Number,
+    service_environment: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__009d6d384b1b723169e64875095e05fe852ae3931adf5ba2004d22475a76caa9(
     *,
-    compute_environment_order: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobQueue.ComputeEnvironmentOrderProperty, typing.Dict[builtins.str, typing.Any]]]]],
     priority: jsii.Number,
+    compute_environment_order: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobQueue.ComputeEnvironmentOrderProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     job_queue_name: typing.Optional[builtins.str] = None,
+    job_queue_type: typing.Optional[builtins.str] = None,
     job_state_time_limit_actions: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobQueue.JobStateTimeLimitActionProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     scheduling_policy_arn: typing.Optional[builtins.str] = None,
+    service_environment_order: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnJobQueue.ServiceEnvironmentOrderProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     state: typing.Optional[builtins.str] = None,
     tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
 ) -> None:
@@ -25928,6 +27069,80 @@ def _typecheckingstub__baa72ee437297b58169f0020ba3178c321d8f72981fcd34857611be31
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__a6f9de8dd6d91e1ef3541444262c3bd9eba874d47c3dbe2b368127e55802962d(
+    scope: _constructs_77d1e7e8.Construct,
+    id: builtins.str,
+    *,
+    capacity_limits: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnServiceEnvironment.CapacityLimitProperty, typing.Dict[builtins.str, typing.Any]]]]],
+    service_environment_type: builtins.str,
+    service_environment_name: typing.Optional[builtins.str] = None,
+    state: typing.Optional[builtins.str] = None,
+    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__96e0974d2660553889a9af3a927bfad81828948853f01018235f809576a4c6b9(
+    inspector: _TreeInspector_488e0dd5,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__e6991ed0f2dc20fa74e5cde5971e4b3997019046ee7c1e1fc7eca96b677bc91b(
+    props: typing.Mapping[builtins.str, typing.Any],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__d996fbedbaec7f1ef9fada43375af4381f0a867d50517c77d6662e6e7d7d26ae(
+    value: typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, CfnServiceEnvironment.CapacityLimitProperty]]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__555f27a186fb86df6655903dee02e46968e9230d8927d6c74bb13420e35fb703(
+    value: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__2f9d1cde60619bebd040c4ca1b04e45af9a3d96ad1c7d934c1fe4f4c102b0fde(
+    value: typing.Optional[builtins.str],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__eb9c6d092d73d302c59d162da7ef41f680de210ef8b625b0d6804765c19c16cf(
+    value: typing.Optional[builtins.str],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__07a3aaaa5bb4d6dbce1c225211ed2ba7848e8258ea1ae35767262fbfb6c68d93(
+    value: typing.Optional[typing.Mapping[builtins.str, builtins.str]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__8d4366eeddf34eff3fc133ef72e4bd900563fba6b925f9d9524d8c92ac2f3e4a(
+    *,
+    capacity_unit: typing.Optional[builtins.str] = None,
+    max_capacity: typing.Optional[jsii.Number] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__dfdb5cc25e8550eb4e42278bd3377213122f3560aa9c8e788955ad66e1ecad9a(
+    *,
+    capacity_limits: typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnServiceEnvironment.CapacityLimitProperty, typing.Dict[builtins.str, typing.Any]]]]],
+    service_environment_type: builtins.str,
+    service_environment_name: typing.Optional[builtins.str] = None,
+    state: typing.Optional[builtins.str] = None,
+    tags: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__ed356ed6d550d61b3cd35694bb99d63fcbc2d06693243747eaf82004f05f9958(
     *,
     compute_environment_name: typing.Optional[builtins.str] = None,
@@ -25961,6 +27176,7 @@ def _typecheckingstub__be0d7a8daca28c8e38e4e8dc8b20bc2ac1814af7b5292ed57768ad6bb
     image: _ContainerImage_94af1b43,
     memory: _Size_7b441c34,
     command: typing.Optional[typing.Sequence[builtins.str]] = None,
+    enable_execute_command: typing.Optional[builtins.bool] = None,
     environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     execution_role: typing.Optional[_IRole_235f5d8e] = None,
     job_role: typing.Optional[_IRole_235f5d8e] = None,
@@ -25980,6 +27196,7 @@ def _typecheckingstub__397c7ba6003633e0c17fd25493d817d40262ed9fcf2688d3147876a33
     image: _ContainerImage_94af1b43,
     memory: _Size_7b441c34,
     command: typing.Optional[typing.Sequence[builtins.str]] = None,
+    enable_execute_command: typing.Optional[builtins.bool] = None,
     environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     execution_role: typing.Optional[_IRole_235f5d8e] = None,
     job_role: typing.Optional[_IRole_235f5d8e] = None,
@@ -26002,6 +27219,7 @@ def _typecheckingstub__e5c078c2a3d8816b92a00e4027344466064444955323dc2ff127e9c01
     image: _ContainerImage_94af1b43,
     memory: _Size_7b441c34,
     command: typing.Optional[typing.Sequence[builtins.str]] = None,
+    enable_execute_command: typing.Optional[builtins.bool] = None,
     environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     execution_role: typing.Optional[_IRole_235f5d8e] = None,
     job_role: typing.Optional[_IRole_235f5d8e] = None,
@@ -26315,13 +27533,14 @@ def _typecheckingstub__f512f54787789f74db02e15bede1080e7c35d142bce05240edb789cee
     id: builtins.str,
     *,
     allocation_strategy: typing.Optional[AllocationStrategy] = None,
+    default_instance_classes: typing.Optional[typing.Sequence[DefaultInstanceClass]] = None,
     images: typing.Optional[typing.Sequence[typing.Union[EcsMachineImage, typing.Dict[builtins.str, typing.Any]]]] = None,
     instance_classes: typing.Optional[typing.Sequence[_InstanceClass_85a592e7]] = None,
     instance_role: typing.Optional[_IRole_235f5d8e] = None,
     instance_types: typing.Optional[typing.Sequence[_InstanceType_f64915b9]] = None,
     launch_template: typing.Optional[_ILaunchTemplate_f32c0fd7] = None,
     minv_cpus: typing.Optional[jsii.Number] = None,
-    placement_group: typing.Optional[_IPlacementGroup_583ddf23] = None,
+    placement_group: typing.Optional[_IPlacementGroupRef_5d6e601f] = None,
     spot_bid_percentage: typing.Optional[jsii.Number] = None,
     spot_fleet_role: typing.Optional[_IRole_235f5d8e] = None,
     use_optimal_instance_classes: typing.Optional[builtins.bool] = None,
@@ -26376,13 +27595,14 @@ def _typecheckingstub__8eb858d67ed25e3f273cc247ebf45f3c3f60ddc697df4791d3298b29a
     update_to_latest_image_version: typing.Optional[builtins.bool] = None,
     vpc_subnets: typing.Optional[typing.Union[_SubnetSelection_e57d76df, typing.Dict[builtins.str, typing.Any]]] = None,
     allocation_strategy: typing.Optional[AllocationStrategy] = None,
+    default_instance_classes: typing.Optional[typing.Sequence[DefaultInstanceClass]] = None,
     images: typing.Optional[typing.Sequence[typing.Union[EcsMachineImage, typing.Dict[builtins.str, typing.Any]]]] = None,
     instance_classes: typing.Optional[typing.Sequence[_InstanceClass_85a592e7]] = None,
     instance_role: typing.Optional[_IRole_235f5d8e] = None,
     instance_types: typing.Optional[typing.Sequence[_InstanceType_f64915b9]] = None,
     launch_template: typing.Optional[_ILaunchTemplate_f32c0fd7] = None,
     minv_cpus: typing.Optional[jsii.Number] = None,
-    placement_group: typing.Optional[_IPlacementGroup_583ddf23] = None,
+    placement_group: typing.Optional[_IPlacementGroupRef_5d6e601f] = None,
     spot_bid_percentage: typing.Optional[jsii.Number] = None,
     spot_fleet_role: typing.Optional[_IRole_235f5d8e] = None,
     use_optimal_instance_classes: typing.Optional[builtins.bool] = None,
@@ -26397,13 +27617,14 @@ def _typecheckingstub__9d1d04f77f1ffdbbe37085b164b175a3e5f0615a7fcde154dcc7f2b64
     eks_cluster: _ICluster_6b2b80df,
     kubernetes_namespace: builtins.str,
     allocation_strategy: typing.Optional[AllocationStrategy] = None,
+    default_instance_classes: typing.Optional[typing.Sequence[DefaultInstanceClass]] = None,
     images: typing.Optional[typing.Sequence[typing.Union[EksMachineImage, typing.Dict[builtins.str, typing.Any]]]] = None,
     instance_classes: typing.Optional[typing.Sequence[_InstanceClass_85a592e7]] = None,
     instance_role: typing.Optional[_IRole_235f5d8e] = None,
     instance_types: typing.Optional[typing.Sequence[_InstanceType_f64915b9]] = None,
     launch_template: typing.Optional[_ILaunchTemplate_f32c0fd7] = None,
     minv_cpus: typing.Optional[jsii.Number] = None,
-    placement_group: typing.Optional[_IPlacementGroup_583ddf23] = None,
+    placement_group: typing.Optional[_IPlacementGroupRef_5d6e601f] = None,
     spot_bid_percentage: typing.Optional[jsii.Number] = None,
     use_optimal_instance_classes: typing.Optional[builtins.bool] = None,
     vpc: _IVpc_f30d5663,
@@ -26451,13 +27672,14 @@ def _typecheckingstub__0a94139ce5fac0f77a3f41888dd3906c6a6876b7e2df289a2bb742a8c
     eks_cluster: _ICluster_6b2b80df,
     kubernetes_namespace: builtins.str,
     allocation_strategy: typing.Optional[AllocationStrategy] = None,
+    default_instance_classes: typing.Optional[typing.Sequence[DefaultInstanceClass]] = None,
     images: typing.Optional[typing.Sequence[typing.Union[EksMachineImage, typing.Dict[builtins.str, typing.Any]]]] = None,
     instance_classes: typing.Optional[typing.Sequence[_InstanceClass_85a592e7]] = None,
     instance_role: typing.Optional[_IRole_235f5d8e] = None,
     instance_types: typing.Optional[typing.Sequence[_InstanceType_f64915b9]] = None,
     launch_template: typing.Optional[_ILaunchTemplate_f32c0fd7] = None,
     minv_cpus: typing.Optional[jsii.Number] = None,
-    placement_group: typing.Optional[_IPlacementGroup_583ddf23] = None,
+    placement_group: typing.Optional[_IPlacementGroupRef_5d6e601f] = None,
     spot_bid_percentage: typing.Optional[jsii.Number] = None,
     use_optimal_instance_classes: typing.Optional[builtins.bool] = None,
 ) -> None:
@@ -26662,6 +27884,7 @@ def _typecheckingstub__e10b04cbfabc7b4f22d3019c7492dc27b542667400ab4e258b28839c7
     image: _ContainerImage_94af1b43,
     memory: _Size_7b441c34,
     command: typing.Optional[typing.Sequence[builtins.str]] = None,
+    enable_execute_command: typing.Optional[builtins.bool] = None,
     environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     execution_role: typing.Optional[_IRole_235f5d8e] = None,
     job_role: typing.Optional[_IRole_235f5d8e] = None,
@@ -26694,6 +27917,7 @@ def _typecheckingstub__b55710648e6c85d4781b971c282911ebf6e5f4b765f9f77bb61c7cb35
     image: _ContainerImage_94af1b43,
     memory: _Size_7b441c34,
     command: typing.Optional[typing.Sequence[builtins.str]] = None,
+    enable_execute_command: typing.Optional[builtins.bool] = None,
     environment: typing.Optional[typing.Mapping[builtins.str, builtins.str]] = None,
     execution_role: typing.Optional[_IRole_235f5d8e] = None,
     job_role: typing.Optional[_IRole_235f5d8e] = None,
@@ -26909,3 +28133,6 @@ def _typecheckingstub__336ca5bcbe380ed2e934b92392f8548b45a77fa6056f7dbbf4741722d
 ) -> None:
     """Type checking stubs"""
     pass
+
+for cls in [IComputeEnvironment, IEcsContainerDefinition, IEcsEc2ContainerDefinition, IEcsFargateContainerDefinition, IEksContainerDefinition, IEksJobDefinition, IFairshareSchedulingPolicy, IFargateComputeEnvironment, IJobDefinition, IJobQueue, IManagedComputeEnvironment, IManagedEc2EcsComputeEnvironment, ISchedulingPolicy, IUnmanagedComputeEnvironment]:
+    typing.cast(typing.Any, cls).__protocol_attrs__ = typing.cast(typing.Any, cls).__protocol_attrs__ - set(['__jsii_proxy_class__', '__jsii_type__'])