aws-cdk-lib 2.140.0__py3-none-any.whl → 2.142.0__py3-none-any.whl

aws_cdk/aws_ec2/__init__.py

@@ -9389,7 +9389,6 @@ class CfnCustomerGateway(
         
             # the properties below are optional
             bgp_asn=123,
-            bgp_asn_extended=123,
             certificate_arn="certificateArn",
             device_name="deviceName",
             tags=[CfnTag(
@@ -9407,7 +9406,6 @@ class CfnCustomerGateway(
         ip_address: builtins.str,
         type: builtins.str,
         bgp_asn: typing.Optional[jsii.Number] = None,
-        bgp_asn_extended: typing.Optional[jsii.Number] = None,
         certificate_arn: typing.Optional[builtins.str] = None,
         device_name: typing.Optional[builtins.str] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -9418,7 +9416,6 @@ class CfnCustomerGateway(
         :param ip_address: IPv4 address for the customer gateway device's outside interface. The address must be static.
         :param type: The type of VPN connection that this customer gateway supports ( ``ipsec.1`` ).
         :param bgp_asn: For devices that support BGP, the customer gateway's BGP ASN. Default: 65000 Default: - 65000
-        :param bgp_asn_extended: 
         :param certificate_arn: The Amazon Resource Name (ARN) for the customer gateway certificate.
         :param device_name: The name of customer gateway device.
         :param tags: One or more tags for the customer gateway.
@@ -9431,7 +9428,6 @@ class CfnCustomerGateway(
             ip_address=ip_address,
             type=type,
             bgp_asn=bgp_asn,
-            bgp_asn_extended=bgp_asn_extended,
             certificate_arn=certificate_arn,
             device_name=device_name,
             tags=tags,
@@ -9528,18 +9524,6 @@ class CfnCustomerGateway(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "bgpAsn", value)
 
-    @builtins.property
-    @jsii.member(jsii_name="bgpAsnExtended")
-    def bgp_asn_extended(self) -> typing.Optional[jsii.Number]:
-        return typing.cast(typing.Optional[jsii.Number], jsii.get(self, "bgpAsnExtended"))
-
-    @bgp_asn_extended.setter
-    def bgp_asn_extended(self, value: typing.Optional[jsii.Number]) -> None:
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__f41644d25c48e5c3c87a361ba478bdb4a18bf473fe1582fa35c6311f6d5284d8)
-            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "bgpAsnExtended", value)
-
     @builtins.property
     @jsii.member(jsii_name="certificateArn")
     def certificate_arn(self) -> typing.Optional[builtins.str]:
@@ -9587,7 +9571,6 @@ class CfnCustomerGateway(
         "ip_address": "ipAddress",
         "type": "type",
         "bgp_asn": "bgpAsn",
-        "bgp_asn_extended": "bgpAsnExtended",
         "certificate_arn": "certificateArn",
         "device_name": "deviceName",
         "tags": "tags",
@@ -9600,7 +9583,6 @@ class CfnCustomerGatewayProps:
         ip_address: builtins.str,
         type: builtins.str,
         bgp_asn: typing.Optional[jsii.Number] = None,
-        bgp_asn_extended: typing.Optional[jsii.Number] = None,
         certificate_arn: typing.Optional[builtins.str] = None,
         device_name: typing.Optional[builtins.str] = None,
         tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -9610,7 +9592,6 @@ class CfnCustomerGatewayProps:
         :param ip_address: IPv4 address for the customer gateway device's outside interface. The address must be static.
         :param type: The type of VPN connection that this customer gateway supports ( ``ipsec.1`` ).
         :param bgp_asn: For devices that support BGP, the customer gateway's BGP ASN. Default: 65000 Default: - 65000
-        :param bgp_asn_extended: 
         :param certificate_arn: The Amazon Resource Name (ARN) for the customer gateway certificate.
         :param device_name: The name of customer gateway device.
         :param tags: One or more tags for the customer gateway.
@@ -9630,7 +9611,6 @@ class CfnCustomerGatewayProps:
             
                 # the properties below are optional
                 bgp_asn=123,
-                bgp_asn_extended=123,
                 certificate_arn="certificateArn",
                 device_name="deviceName",
                 tags=[CfnTag(
@@ -9644,7 +9624,6 @@ class CfnCustomerGatewayProps:
             check_type(argname="argument ip_address", value=ip_address, expected_type=type_hints["ip_address"])
             check_type(argname="argument type", value=type, expected_type=type_hints["type"])
             check_type(argname="argument bgp_asn", value=bgp_asn, expected_type=type_hints["bgp_asn"])
-            check_type(argname="argument bgp_asn_extended", value=bgp_asn_extended, expected_type=type_hints["bgp_asn_extended"])
             check_type(argname="argument certificate_arn", value=certificate_arn, expected_type=type_hints["certificate_arn"])
             check_type(argname="argument device_name", value=device_name, expected_type=type_hints["device_name"])
             check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
@@ -9654,8 +9633,6 @@ class CfnCustomerGatewayProps:
         }
         if bgp_asn is not None:
             self._values["bgp_asn"] = bgp_asn
-        if bgp_asn_extended is not None:
-            self._values["bgp_asn_extended"] = bgp_asn_extended
         if certificate_arn is not None:
             self._values["certificate_arn"] = certificate_arn
         if device_name is not None:
@@ -9698,14 +9675,6 @@ class CfnCustomerGatewayProps:
         result = self._values.get("bgp_asn")
         return typing.cast(typing.Optional[jsii.Number], result)
 
-    @builtins.property
-    def bgp_asn_extended(self) -> typing.Optional[jsii.Number]:
-        '''
-        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-customergateway.html#cfn-ec2-customergateway-bgpasnextended
-        '''
-        result = self._values.get("bgp_asn_extended")
-        return typing.cast(typing.Optional[jsii.Number], result)
-
     @builtins.property
     def certificate_arn(self) -> typing.Optional[builtins.str]:
         '''The Amazon Resource Name (ARN) for the customer gateway certificate.
@@ -19455,6 +19424,15 @@ class CfnInstance(
         '''
         return typing.cast(builtins.str, jsii.get(self, "attrPublicIp"))
 
+    @builtins.property
+    @jsii.member(jsii_name="attrState")
+    def attr_state(self) -> _IResolvable_da3f097b:
+        '''The current state of the instance.
+
+        :cloudformationAttribute: State
+        '''
+        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrState"))
+
     @builtins.property
     @jsii.member(jsii_name="attrVpcId")
     def attr_vpc_id(self) -> builtins.str:
@@ -21758,6 +21736,76 @@ class CfnInstance(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.StateProperty",
+        jsii_struct_bases=[],
+        name_mapping={"code": "code", "name": "name"},
+    )
+    class StateProperty:
+        def __init__(
+            self,
+            *,
+            code: typing.Optional[builtins.str] = None,
+            name: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''The current state of the instance.
+
+            :param code: The state of the instance as a 16-bit unsigned integer.
+            :param name: The current state of the instance.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-state.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_ec2 as ec2
+                
+                state_property = ec2.CfnInstance.StateProperty(
+                    code="code",
+                    name="name"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__9846fa72cbaae139f4b014952902793cafe1392ee629b0862fc35909f9ec8da2)
+                check_type(argname="argument code", value=code, expected_type=type_hints["code"])
+                check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if code is not None:
+                self._values["code"] = code
+            if name is not None:
+                self._values["name"] = name
+
+        @builtins.property
+        def code(self) -> typing.Optional[builtins.str]:
+            '''The state of the instance as a 16-bit unsigned integer.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-state.html#cfn-ec2-instance-state-code
+            '''
+            result = self._values.get("code")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def name(self) -> typing.Optional[builtins.str]:
+            '''The current state of the instance.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-instance-state.html#cfn-ec2-instance-state-name
+            '''
+            result = self._values.get("name")
+            return typing.cast(typing.Optional[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 "StateProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_ec2.CfnInstance.VolumeProperty",
         jsii_struct_bases=[],
@@ -27765,7 +27813,7 @@ class CfnLaunchTemplate(
             :param connection_tracking_specification: A connection tracking specification for the network interface.
             :param delete_on_termination: Indicates whether the network interface is deleted when the instance is terminated.
             :param description: A description for the network interface.
-            :param device_index: The device index for the network interface attachment.
+            :param device_index: The device index for the network interface attachment. Each network interface requires a device index. If you create a launch template that includes secondary network interfaces but not a primary network interface, then you must add a primary network interface as a launch parameter when you launch an instance from the template.
             :param ena_srd_specification: The ENA Express configuration for the network interface.
             :param groups: The IDs of one or more security groups.
             :param interface_type: The type of network interface. To create an Elastic Fabric Adapter (EFA), specify ``efa`` . For more information, see `Elastic Fabric Adapter <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/efa.html>`_ in the *Amazon Elastic Compute Cloud User Guide* . If you are not creating an EFA, specify ``interface`` or omit this parameter. Valid values: ``interface`` | ``efa``
@@ -27966,6 +28014,8 @@ class CfnLaunchTemplate(
         def device_index(self) -> typing.Optional[jsii.Number]:
             '''The device index for the network interface attachment.
 
+            Each network interface requires a device index. If you create a launch template that includes secondary network interfaces but not a primary network interface, then you must add a primary network interface as a launch parameter when you launch an instance from the template.
+
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-launchtemplate-networkinterface.html#cfn-ec2-launchtemplate-networkinterface-deviceindex
             '''
             result = self._values.get("device_index")
@@ -73537,8 +73587,7 @@ class InstanceType(
                 subnet_type=ec2.SubnetType.PUBLIC
             ),
             vpc=vpc,
-            removal_policy=RemovalPolicy.SNAPSHOT,
-            instance_removal_policy=RemovalPolicy.RETAIN
+            ca_certificate=docdb.CaCertificate.RDS_CA_RSA4096_G1
         )
     '''
 
@@ -95028,7 +95077,6 @@ def _typecheckingstub__16b41182e007e05b84fd0c97afc1e26001e78a56de2eb5b10c9f809de
     ip_address: builtins.str,
     type: builtins.str,
     bgp_asn: typing.Optional[jsii.Number] = None,
-    bgp_asn_extended: typing.Optional[jsii.Number] = None,
     certificate_arn: typing.Optional[builtins.str] = None,
     device_name: typing.Optional[builtins.str] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -95066,12 +95114,6 @@ def _typecheckingstub__84dfb7d1775bd2bb124f990570c9a2ef23fafd01744cfe248fcb36056
     """Type checking stubs"""
     pass
 
-def _typecheckingstub__f41644d25c48e5c3c87a361ba478bdb4a18bf473fe1582fa35c6311f6d5284d8(
-    value: typing.Optional[jsii.Number],
-) -> None:
-    """Type checking stubs"""
-    pass
-
 def _typecheckingstub__4a4b900e840c5be3a2b16a5177f91335cf813daeca359e549a639cb05a03ac63(
     value: typing.Optional[builtins.str],
 ) -> None:
@@ -95095,7 +95137,6 @@ def _typecheckingstub__b0ef9a2e3e2b6937b21db500a1cd795126e924d9b920931a413ecdb66
     ip_address: builtins.str,
     type: builtins.str,
     bgp_asn: typing.Optional[jsii.Number] = None,
-    bgp_asn_extended: typing.Optional[jsii.Number] = None,
     certificate_arn: typing.Optional[builtins.str] = None,
     device_name: typing.Optional[builtins.str] = None,
     tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -96943,6 +96984,14 @@ def _typecheckingstub__3246e3302ff8df6b195439adc5ead244f95f45eca29b97351de498153
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__9846fa72cbaae139f4b014952902793cafe1392ee629b0862fc35909f9ec8da2(
+    *,
+    code: typing.Optional[builtins.str] = None,
+    name: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__b979ff4b2e7bc79429f0409f1fb60a5125a9cda71770a0324082ebc0a6c50756(
     *,
     device: builtins.str,

aws_cdk/aws_ecr/__init__.py

@@ -219,6 +219,27 @@ repository.add_to_resource_policy(iam.PolicyStatement(
     principals=[iam.AnyPrincipal()]
 ))
 ```
+
+## CloudWatch event rules
+
+You can publish repository events to a CloudWatch event rule with `onEvent`:
+
+```python
+import aws_cdk.aws_lambda as lambda_
+from aws_cdk.aws_events_targets import LambdaFunction
+
+
+repo = ecr.Repository(self, "Repo")
+lambda_handler = lambda_.Function(self, "LambdaFunction",
+    runtime=lambda_.Runtime.PYTHON_3_12,
+    code=lambda_.Code.from_inline("# dummy func"),
+    handler="index.handler"
+)
+
+repo.on_event("OnEventTargetLambda",
+    target=LambdaFunction(lambda_handler)
+)
+```
 '''
 from pkgutil import extend_path
 __path__ = extend_path(__path__, __name__)
@@ -4664,15 +4685,19 @@ class Repository(
 
     Example::
 
-        import aws_cdk.aws_ecr as ecr
+        import aws_cdk.aws_lambda as lambda_
+        from aws_cdk.aws_events_targets import LambdaFunction
         
         
-        apprunner.Service(self, "Service",
-            source=apprunner.Source.from_ecr(
-                image_configuration=apprunner.ImageConfiguration(port=80),
-                repository=ecr.Repository.from_repository_name(self, "NginxRepository", "nginx"),
-                tag_or_digest="latest"
-            )
+        repo = ecr.Repository(self, "Repo")
+        lambda_handler = lambda_.Function(self, "LambdaFunction",
+            runtime=lambda_.Runtime.PYTHON_3_12,
+            code=lambda_.Code.from_inline("# dummy func"),
+            handler="index.handler"
+        )
+        
+        repo.on_event("OnEventTargetLambda",
+            target=LambdaFunction(lambda_handler)
         )
     '''
 

aws_cdk/aws_ecs/__init__.py

@@ -384,12 +384,13 @@ fargate_task_definition = ecs.FargateTaskDefinition(self, "TaskDef",
     ),
     memory_limit_mi_b=512,
     cpu=256,
-    pid_mode=ecs.PidMode.HOST
+    pid_mode=ecs.PidMode.TASK
 )
 ```
 
 **Note:** `pidMode` is only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version 1.4.0
-or later (Linux). This isn't supported for Windows containers on Fargate.
+or later (Linux). Only the `task` option is supported for Linux containers. `pidMode` isn't supported for Windows containers on Fargate.
+If `pidMode` is specified for a Fargate task, then `runtimePlatform.operatingSystemFamily` must also be specified.
 
 To add containers to a task definition, call `addContainer()`:
 
@@ -1971,6 +1972,7 @@ from ..aws_cloudwatch import (
 from ..aws_ec2 import (
     Connections as _Connections_0f31fce8,
     EbsDeviceVolumeType as _EbsDeviceVolumeType_6792555b,
+    IKeyPair as _IKeyPair_bc344eda,
     IMachineImage as _IMachineImage_0e8bd50b,
     ISecurityGroup as _ISecurityGroup_acf8a799,
     IVpc as _IVpc_f30d5663,
@@ -2174,6 +2176,7 @@ class AddAutoScalingGroupCapacityOptions:
         "ignore_unmodified_size_properties": "ignoreUnmodifiedSizeProperties",
         "instance_monitoring": "instanceMonitoring",
         "key_name": "keyName",
+        "key_pair": "keyPair",
         "max_capacity": "maxCapacity",
         "max_instance_lifetime": "maxInstanceLifetime",
         "min_capacity": "minCapacity",
@@ -2214,6 +2217,7 @@ class AddCapacityOptions(
         ignore_unmodified_size_properties: typing.Optional[builtins.bool] = None,
         instance_monitoring: typing.Optional[_Monitoring_50020f91] = None,
         key_name: typing.Optional[builtins.str] = None,
+        key_pair: typing.Optional[_IKeyPair_bc344eda] = None,
         max_capacity: typing.Optional[jsii.Number] = None,
         max_instance_lifetime: typing.Optional[_Duration_4839e8c3] = None,
         min_capacity: typing.Optional[jsii.Number] = None,
@@ -2247,7 +2251,8 @@ class AddCapacityOptions(
         :param health_check: Configuration for health checks. Default: - HealthCheck.ec2 with no grace period
         :param ignore_unmodified_size_properties: If the ASG has scheduled actions, don't reset unchanged group sizes. Only used if the ASG has scheduled actions (which may scale your ASG up or down regardless of cdk deployments). If true, the size of the group will only be reset if it has been changed in the CDK app. If false, the sizes will always be changed back to what they were in the CDK app on deployment. Default: true
         :param instance_monitoring: Controls whether instances in this group are launched with detailed or basic monitoring. When detailed monitoring is enabled, Amazon CloudWatch generates metrics every minute and your account is charged a fee. When you disable detailed monitoring, CloudWatch generates metrics every 5 minutes. ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified Default: - Monitoring.DETAILED
-        :param key_name: Name of SSH keypair to grant access to instances. ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified Default: - No SSH access will be possible.
+        :param key_name: (deprecated) Name of SSH keypair to grant access to instances. ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified You can either specify ``keyPair`` or ``keyName``, not both. Default: - No SSH access will be possible.
+        :param key_pair: The SSH keypair to grant access to the instance. Feature flag ``AUTOSCALING_GENERATE_LAUNCH_TEMPLATE`` must be enabled to use this property. ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified. You can either specify ``keyPair`` or ``keyName``, not both. Default: - No SSH access will be possible.
         :param max_capacity: Maximum number of instances in the fleet. Default: desiredCapacity
         :param max_instance_lifetime: The maximum amount of time that an instance can be in service. The maximum duration applies to all current and future instances in the group. As an instance approaches its maximum duration, it is terminated and replaced, and cannot be used again. You must specify a value of at least 604,800 seconds (7 days). To clear a previously set value, leave this property undefined. Default: none
         :param min_capacity: Minimum number of instances in the fleet. Default: 1
@@ -2297,6 +2302,7 @@ class AddCapacityOptions(
             check_type(argname="argument ignore_unmodified_size_properties", value=ignore_unmodified_size_properties, expected_type=type_hints["ignore_unmodified_size_properties"])
             check_type(argname="argument instance_monitoring", value=instance_monitoring, expected_type=type_hints["instance_monitoring"])
             check_type(argname="argument key_name", value=key_name, expected_type=type_hints["key_name"])
+            check_type(argname="argument key_pair", value=key_pair, expected_type=type_hints["key_pair"])
             check_type(argname="argument max_capacity", value=max_capacity, expected_type=type_hints["max_capacity"])
             check_type(argname="argument max_instance_lifetime", value=max_instance_lifetime, expected_type=type_hints["max_instance_lifetime"])
             check_type(argname="argument min_capacity", value=min_capacity, expected_type=type_hints["min_capacity"])
@@ -2348,6 +2354,8 @@ class AddCapacityOptions(
             self._values["instance_monitoring"] = instance_monitoring
         if key_name is not None:
             self._values["key_name"] = key_name
+        if key_pair is not None:
+            self._values["key_pair"] = key_pair
         if max_capacity is not None:
             self._values["max_capacity"] = max_capacity
         if max_instance_lifetime is not None:
@@ -2582,15 +2590,36 @@ class AddCapacityOptions(
 
     @builtins.property
     def key_name(self) -> typing.Optional[builtins.str]:
-        '''Name of SSH keypair to grant access to instances.
+        '''(deprecated) Name of SSH keypair to grant access to instances.
 
         ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified
 
+        You can either specify ``keyPair`` or ``keyName``, not both.
+
         :default: - No SSH access will be possible.
+
+        :deprecated: - Use ``keyPair`` instead - https://docs.aws.amazon.com/cdk/api/v2/docs/aws-cdk-lib.aws_ec2-readme.html#using-an-existing-ec2-key-pair
+
+        :stability: deprecated
         '''
         result = self._values.get("key_name")
         return typing.cast(typing.Optional[builtins.str], result)
 
+    @builtins.property
+    def key_pair(self) -> typing.Optional[_IKeyPair_bc344eda]:
+        '''The SSH keypair to grant access to the instance.
+
+        Feature flag ``AUTOSCALING_GENERATE_LAUNCH_TEMPLATE`` must be enabled to use this property.
+
+        ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified.
+
+        You can either specify ``keyPair`` or ``keyName``, not both.
+
+        :default: - No SSH access will be possible.
+        '''
+        result = self._values.get("key_pair")
+        return typing.cast(typing.Optional[_IKeyPair_bc344eda], result)
+
     @builtins.property
     def max_capacity(self) -> typing.Optional[jsii.Number]:
         '''Maximum number of instances in the fleet.
@@ -26056,7 +26085,7 @@ class FargateTaskDefinitionProps(CommonTaskDefinitionProps):
         :param cpu: The number of cpu units used by the task. For tasks using the Fargate launch type, this field is required and you must use one of the following values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) 512 (.5 vCPU) - Available memory values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) 1024 (1 vCPU) - Available memory values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) 2048 (2 vCPU) - Available memory values: Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) 4096 (4 vCPU) - Available memory values: Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) 8192 (8 vCPU) - Available memory values: Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) 16384 (16 vCPU) - Available memory values: Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) Default: 256
         :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The maximum supported value is 200 GiB. NOTE: This parameter is only supported for tasks hosted on AWS Fargate using platform version 1.4.0 or later. Default: 20
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. For tasks using the Fargate launch type, this field is required and you must use one of the following values, which determines your range of valid values for the cpu parameter: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25 vCPU) 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values: 512 (.5 vCPU) 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU) Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available cpu values: 2048 (2 vCPU) Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU) Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) - Available cpu values: 8192 (8 vCPU) Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) - Available cpu values: 16384 (16 vCPU) Default: 512
-        :param pid_mode: The process namespace to use for the containers in the task. Only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version 1.4.0 or later (Linux). Not supported in Windows containers. Default: - PidMode used by the task is not specified
+        :param pid_mode: The process namespace to use for the containers in the task. Only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version 1.4.0 or later (Linux). Only the TASK option is supported for Linux-based Fargate containers. Not supported in Windows containers. If pidMode is specified for a Fargate task, then runtimePlatform.operatingSystemFamily must also be specified. For more information, see `Task Definition Parameters <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_pidmode>`_. Default: - PidMode used by the task is not specified
         :param runtime_platform: The operating system that your task definitions are running on. A runtimePlatform is supported only for tasks using the Fargate launch type. Default: - Undefined.
 
         :exampleMetadata: infused
@@ -26070,7 +26099,7 @@ class FargateTaskDefinitionProps(CommonTaskDefinitionProps):
                 ),
                 memory_limit_mi_b=512,
                 cpu=256,
-                pid_mode=ecs.PidMode.HOST
+                pid_mode=ecs.PidMode.TASK
             )
         '''
         if isinstance(runtime_platform, dict):
@@ -26232,8 +26261,11 @@ class FargateTaskDefinitionProps(CommonTaskDefinitionProps):
         '''The process namespace to use for the containers in the task.
 
         Only supported for tasks that are hosted on AWS Fargate if the tasks
-        are using platform version 1.4.0 or later (Linux).
-        Not supported in Windows containers.
+        are using platform version 1.4.0 or later (Linux).  Only the TASK option
+        is supported for Linux-based Fargate containers. Not supported in
+        Windows containers. If pidMode is specified for a Fargate task, then
+        runtimePlatform.operatingSystemFamily must also be specified.  For more
+        information, see `Task Definition Parameters <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_pidmode>`_.
 
         :default: - PidMode used by the task is not specified
         '''
@@ -31351,9 +31383,14 @@ class OperatingSystemFamily(
             check_type(argname="argument family", value=family, expected_type=type_hints["family"])
         return typing.cast("OperatingSystemFamily", jsii.sinvoke(cls, "of", [family]))
 
+    @jsii.member(jsii_name="isLinux")
+    def is_linux(self) -> builtins.bool:
+        '''Indicates whether the operating system family is Linux.'''
+        return typing.cast(builtins.bool, jsii.invoke(self, "isLinux", []))
+
     @jsii.member(jsii_name="isWindows")
     def is_windows(self) -> builtins.bool:
-        '''Returns true if the operating system family is Windows.'''
+        '''Indicates whether the operating system family is Windows.'''
         return typing.cast(builtins.bool, jsii.invoke(self, "isWindows", []))
 
     @jsii.python.classproperty
@@ -31420,7 +31457,7 @@ class PidMode(enum.Enum):
             ),
             memory_limit_mi_b=512,
             cpu=256,
-            pid_mode=ecs.PidMode.HOST
+            pid_mode=ecs.PidMode.TASK
         )
     '''
 
@@ -35190,7 +35227,7 @@ class TaskDefinition(
         :param ipc_mode: The IPC resource namespace to use for the containers in the task. Not supported in Fargate and Windows containers. Default: - IpcMode used by the task is not specified
         :param memory_mib: The amount (in MiB) of memory used by the task. If using the EC2 launch type, this field is optional and any value can be used. If using the Fargate launch type, this field is required and you must use one of the following values, which determines your range of valid values for the cpu parameter: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25 vCPU) 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values: 512 (.5 vCPU) 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU) Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available cpu values: 2048 (2 vCPU) Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU) Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) - Available cpu values: 8192 (8 vCPU) Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) - Available cpu values: 16384 (16 vCPU) Default: - Memory used by task is not specified.
         :param network_mode: The networking mode to use for the containers in the task. On Fargate, the only supported networking mode is AwsVpc. Default: - NetworkMode.Bridge for EC2 & External tasks, AwsVpc for Fargate tasks.
-        :param pid_mode: The process namespace to use for the containers in the task. Only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version 1.4.0 or later (Linux). Not supported in Windows containers. Default: - PidMode used by the task is not specified
+        :param pid_mode: The process namespace to use for the containers in the task. Only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version 1.4.0 or later (Linux). Only the TASK option is supported for Linux-based Fargate containers. Not supported in Windows containers. If pidMode is specified for a Fargate task, then runtimePlatform.operatingSystemFamily must also be specified. For more information, see `Task Definition Parameters <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_pidmode>`_. Default: - PidMode used by the task is not specified
         :param placement_constraints: The placement constraints to use for tasks in the service. You can specify a maximum of 10 constraints per task (this limit includes constraints in the task definition and those specified at run time). Not supported in Fargate. Default: - No placement constraints.
         :param runtime_platform: The operating system that your task definitions are running on. A runtimePlatform is supported only for tasks using the Fargate launch type. Default: - Undefined.
         :param execution_role: The name of the IAM task execution role that grants the ECS agent permission to call AWS APIs on your behalf. The role will be used to retrieve container images from ECR and create CloudWatch log groups. Default: - An execution role will be automatically created if you use ECR images in your task definition.
@@ -35766,8 +35803,10 @@ class TaskDefinition(
         '''The process namespace to use for the containers in the task.
 
         Only supported for tasks that are hosted on AWS Fargate if the tasks
-        are using platform version 1.4.0 or later (Linux).
-        Not supported in Windows containers.
+        are using platform version 1.4.0 or later (Linux). Not supported in
+        Windows containers. If pidMode is specified for a Fargate task,
+        then runtimePlatform.operatingSystemFamily must also be specified.  For more
+        information, see `Task Definition Parameters <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_pidmode>`_.
         '''
         return typing.cast(typing.Optional[PidMode], jsii.get(self, "pidMode"))
 
@@ -35977,7 +36016,7 @@ class TaskDefinitionProps(CommonTaskDefinitionProps):
         :param ipc_mode: The IPC resource namespace to use for the containers in the task. Not supported in Fargate and Windows containers. Default: - IpcMode used by the task is not specified
         :param memory_mib: The amount (in MiB) of memory used by the task. If using the EC2 launch type, this field is optional and any value can be used. If using the Fargate launch type, this field is required and you must use one of the following values, which determines your range of valid values for the cpu parameter: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25 vCPU) 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values: 512 (.5 vCPU) 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU) Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available cpu values: 2048 (2 vCPU) Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU) Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) - Available cpu values: 8192 (8 vCPU) Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) - Available cpu values: 16384 (16 vCPU) Default: - Memory used by task is not specified.
         :param network_mode: The networking mode to use for the containers in the task. On Fargate, the only supported networking mode is AwsVpc. Default: - NetworkMode.Bridge for EC2 & External tasks, AwsVpc for Fargate tasks.
-        :param pid_mode: The process namespace to use for the containers in the task. Only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version 1.4.0 or later (Linux). Not supported in Windows containers. Default: - PidMode used by the task is not specified
+        :param pid_mode: The process namespace to use for the containers in the task. Only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version 1.4.0 or later (Linux). Only the TASK option is supported for Linux-based Fargate containers. Not supported in Windows containers. If pidMode is specified for a Fargate task, then runtimePlatform.operatingSystemFamily must also be specified. For more information, see `Task Definition Parameters <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_pidmode>`_. Default: - PidMode used by the task is not specified
         :param placement_constraints: The placement constraints to use for tasks in the service. You can specify a maximum of 10 constraints per task (this limit includes constraints in the task definition and those specified at run time). Not supported in Fargate. Default: - No placement constraints.
         :param runtime_platform: The operating system that your task definitions are running on. A runtimePlatform is supported only for tasks using the Fargate launch type. Default: - Undefined.
 
@@ -36230,8 +36269,11 @@ class TaskDefinitionProps(CommonTaskDefinitionProps):
         '''The process namespace to use for the containers in the task.
 
         Only supported for tasks that are hosted on AWS Fargate if the tasks
-        are using platform version 1.4.0 or later (Linux).
-        Not supported in Windows containers.
+        are using platform version 1.4.0 or later (Linux). Only the TASK option
+        is supported for Linux-based Fargate containers. Not supported in Windows
+        containers. If pidMode is specified for a Fargate task, then
+        runtimePlatform.operatingSystemFamily must also be specified.  For more
+        information, see `Task Definition Parameters <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_pidmode>`_.
 
         :default: - PidMode used by the task is not specified
         '''
@@ -37649,6 +37691,7 @@ class Cluster(
         ignore_unmodified_size_properties: typing.Optional[builtins.bool] = None,
         instance_monitoring: typing.Optional[_Monitoring_50020f91] = None,
         key_name: typing.Optional[builtins.str] = None,
+        key_pair: typing.Optional[_IKeyPair_bc344eda] = None,
         max_capacity: typing.Optional[jsii.Number] = None,
         max_instance_lifetime: typing.Optional[_Duration_4839e8c3] = None,
         min_capacity: typing.Optional[jsii.Number] = None,
@@ -37687,7 +37730,8 @@ class Cluster(
         :param health_check: Configuration for health checks. Default: - HealthCheck.ec2 with no grace period
         :param ignore_unmodified_size_properties: If the ASG has scheduled actions, don't reset unchanged group sizes. Only used if the ASG has scheduled actions (which may scale your ASG up or down regardless of cdk deployments). If true, the size of the group will only be reset if it has been changed in the CDK app. If false, the sizes will always be changed back to what they were in the CDK app on deployment. Default: true
         :param instance_monitoring: Controls whether instances in this group are launched with detailed or basic monitoring. When detailed monitoring is enabled, Amazon CloudWatch generates metrics every minute and your account is charged a fee. When you disable detailed monitoring, CloudWatch generates metrics every 5 minutes. ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified Default: - Monitoring.DETAILED
-        :param key_name: Name of SSH keypair to grant access to instances. ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified Default: - No SSH access will be possible.
+        :param key_name: (deprecated) Name of SSH keypair to grant access to instances. ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified You can either specify ``keyPair`` or ``keyName``, not both. Default: - No SSH access will be possible.
+        :param key_pair: The SSH keypair to grant access to the instance. Feature flag ``AUTOSCALING_GENERATE_LAUNCH_TEMPLATE`` must be enabled to use this property. ``launchTemplate`` and ``mixedInstancesPolicy`` must not be specified when this property is specified. You can either specify ``keyPair`` or ``keyName``, not both. Default: - No SSH access will be possible.
         :param max_capacity: Maximum number of instances in the fleet. Default: desiredCapacity
         :param max_instance_lifetime: The maximum amount of time that an instance can be in service. The maximum duration applies to all current and future instances in the group. As an instance approaches its maximum duration, it is terminated and replaced, and cannot be used again. You must specify a value of at least 604,800 seconds (7 days). To clear a previously set value, leave this property undefined. Default: none
         :param min_capacity: Minimum number of instances in the fleet. Default: 1
@@ -37724,6 +37768,7 @@ class Cluster(
             ignore_unmodified_size_properties=ignore_unmodified_size_properties,
             instance_monitoring=instance_monitoring,
             key_name=key_name,
+            key_pair=key_pair,
             max_capacity=max_capacity,
             max_instance_lifetime=max_instance_lifetime,
             min_capacity=min_capacity,
@@ -40506,7 +40551,7 @@ class FargateTaskDefinition(
         :param cpu: The number of cpu units used by the task. For tasks using the Fargate launch type, this field is required and you must use one of the following values, which determines your range of valid values for the memory parameter: 256 (.25 vCPU) - Available memory values: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) 512 (.5 vCPU) - Available memory values: 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) 1024 (1 vCPU) - Available memory values: 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) 2048 (2 vCPU) - Available memory values: Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) 4096 (4 vCPU) - Available memory values: Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) 8192 (8 vCPU) - Available memory values: Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) 16384 (16 vCPU) - Available memory values: Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) Default: 256
         :param ephemeral_storage_gib: The amount (in GiB) of ephemeral storage to be allocated to the task. The maximum supported value is 200 GiB. NOTE: This parameter is only supported for tasks hosted on AWS Fargate using platform version 1.4.0 or later. Default: 20
         :param memory_limit_mib: The amount (in MiB) of memory used by the task. For tasks using the Fargate launch type, this field is required and you must use one of the following values, which determines your range of valid values for the cpu parameter: 512 (0.5 GB), 1024 (1 GB), 2048 (2 GB) - Available cpu values: 256 (.25 vCPU) 1024 (1 GB), 2048 (2 GB), 3072 (3 GB), 4096 (4 GB) - Available cpu values: 512 (.5 vCPU) 2048 (2 GB), 3072 (3 GB), 4096 (4 GB), 5120 (5 GB), 6144 (6 GB), 7168 (7 GB), 8192 (8 GB) - Available cpu values: 1024 (1 vCPU) Between 4096 (4 GB) and 16384 (16 GB) in increments of 1024 (1 GB) - Available cpu values: 2048 (2 vCPU) Between 8192 (8 GB) and 30720 (30 GB) in increments of 1024 (1 GB) - Available cpu values: 4096 (4 vCPU) Between 16384 (16 GB) and 61440 (60 GB) in increments of 4096 (4 GB) - Available cpu values: 8192 (8 vCPU) Between 32768 (32 GB) and 122880 (120 GB) in increments of 8192 (8 GB) - Available cpu values: 16384 (16 vCPU) Default: 512
-        :param pid_mode: The process namespace to use for the containers in the task. Only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version 1.4.0 or later (Linux). Not supported in Windows containers. Default: - PidMode used by the task is not specified
+        :param pid_mode: The process namespace to use for the containers in the task. Only supported for tasks that are hosted on AWS Fargate if the tasks are using platform version 1.4.0 or later (Linux). Only the TASK option is supported for Linux-based Fargate containers. Not supported in Windows containers. If pidMode is specified for a Fargate task, then runtimePlatform.operatingSystemFamily must also be specified. For more information, see `Task Definition Parameters <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/task_definition_parameters.html#task_definition_pidmode>`_. Default: - PidMode used by the task is not specified
         :param runtime_platform: The operating system that your task definitions are running on. A runtimePlatform is supported only for tasks using the Fargate launch type. Default: - Undefined.
         :param execution_role: The name of the IAM task execution role that grants the ECS agent permission to call AWS APIs on your behalf. The role will be used to retrieve container images from ECR and create CloudWatch log groups. Default: - An execution role will be automatically created if you use ECR images in your task definition.
         :param family: The name of a family that this task definition is registered to. A family groups multiple versions of a task definition. Default: - Automatically generated name.
@@ -40839,6 +40884,7 @@ def _typecheckingstub__64f2d9b3495e3be78346f77d5ad90928968c8ce230e670b6279dc67ad
     ignore_unmodified_size_properties: typing.Optional[builtins.bool] = None,
     instance_monitoring: typing.Optional[_Monitoring_50020f91] = None,
     key_name: typing.Optional[builtins.str] = None,
+    key_pair: typing.Optional[_IKeyPair_bc344eda] = None,
     max_capacity: typing.Optional[jsii.Number] = None,
     max_instance_lifetime: typing.Optional[_Duration_4839e8c3] = None,
     min_capacity: typing.Optional[jsii.Number] = None,
@@ -44488,6 +44534,7 @@ def _typecheckingstub__63e98e008463515927d4aee3c938d64639e34ce8a2c09fa766883be6a
     ignore_unmodified_size_properties: typing.Optional[builtins.bool] = None,
     instance_monitoring: typing.Optional[_Monitoring_50020f91] = None,
     key_name: typing.Optional[builtins.str] = None,
+    key_pair: typing.Optional[_IKeyPair_bc344eda] = None,
     max_capacity: typing.Optional[jsii.Number] = None,
     max_instance_lifetime: typing.Optional[_Duration_4839e8c3] = None,
     min_capacity: typing.Optional[jsii.Number] = None,