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

aws_cdk/aws_ec2/__init__.py

@@ -929,7 +929,10 @@ If the security group ID is known and configuration details are unknown, use met
 sg = ec2.SecurityGroup.from_lookup_by_id(self, "SecurityGroupLookup", "sg-1234")
 ```
 
-The result of `SecurityGroup.fromLookupByName` and `SecurityGroup.fromLookupById` operations will be written to a file called `cdk.context.json`. You must commit this file to source control so that the lookup values are available in non-privileged environments such as CI build steps, and to ensure your template builds are repeatable.
+The result of `SecurityGroup.fromLookupByName` and `SecurityGroup.fromLookupById` operations will be
+written to a file called `cdk.context.json`.
+You must commit this file to source control so that the lookup values are available in non-privileged
+environments such as CI build steps, and to ensure your template builds are repeatable.
 
 ### Cross Stack Connections
 
@@ -1054,6 +1057,13 @@ generic_windows = ec2.MachineImage.generic_windows({
 > [Runtime Context](https://docs.aws.amazon.com/cdk/latest/guide/context.html) in the CDK
 > developer guide.
 >
+> To customize the cache key, use the `additionalCacheKey` parameter.
+> This allows you to have multiple lookups with the same parameters
+> cache their values separately. This can be useful if you want to
+> scope the context variable to a construct (ie, using `additionalCacheKey: this.node.path`),
+> so that if the value in the cache needs to be updated, it does not need to be updated
+> for all constructs at the same time.
+>
 > `MachineImage.genericLinux()`, `MachineImage.genericWindows()` will use `CfnMapping` in
 > an agnostic stack.
 
@@ -1479,6 +1489,30 @@ ec2.Instance(self, "LatestAl2023",
     # context cache is turned on by default
     machine_image=ec2.AmazonLinux2023ImageSsmParameter()
 )
+
+# or
+ec2.Instance(self, "LatestAl2023",
+    vpc=vpc,
+    instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
+    machine_image=ec2.MachineImage.latest_amazon_linux2023(
+        cached_in_context=True,
+        # creates a distinct context variable for this image, instead of resolving to the same
+        # value anywhere this lookup is done in your app
+        additional_cache_key=self.node.path
+    )
+)
+
+# or
+ec2.Instance(self, "LatestAl2023",
+    vpc=vpc,
+    instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
+    # context cache is turned on by default
+    machine_image=ec2.AmazonLinux2023ImageSsmParameter(
+        # creates a distinct context variable for this image, instead of resolving to the same
+        # value anywhere this lookup is done in your app
+        additional_cache_key=self.node.path
+    )
+)
 ```
 
 #### Kernel Versions
@@ -1958,6 +1992,25 @@ ec2.Volume(self, "Volume",
 )
 ```
 
+#### Volume initialization rate
+
+When creating an EBS volume from a snapshot, you can specify the [volume initialization rate](https://docs.aws.amazon.com/ebs/latest/userguide/initalize-volume.html#volume-initialization-rate) at which the snapshot blocks are downloaded from Amazon S3 to the volume.
+Specifying a volume initialization rate ensures that the volume is initialized at a predictable and consistent rate after creation.
+
+```python
+ec2.Volume(self, "Volume",
+    availability_zone="us-east-1a",
+    size=Size.gibibytes(500),
+    snapshot_id="snap-1234567890abcdef0",
+    volume_initialization_rate=Size.mebibytes(250)
+)
+```
+
+The `volumeInitializationRate` must be:
+
+* Between 100 and 300 MiB/s
+* Only specified when creating a volume from a snapshot
+
 ### Configuring Instance Metadata Service (IMDS)
 
 #### Toggling IMDSv1
@@ -4108,6 +4161,7 @@ class AmazonLinuxGeneration(enum.Enum):
     jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxImageProps",
     jsii_struct_bases=[],
     name_mapping={
+        "additional_cache_key": "additionalCacheKey",
         "cached_in_context": "cachedInContext",
         "cpu_type": "cpuType",
         "edition": "edition",
@@ -4122,6 +4176,7 @@ class AmazonLinuxImageProps:
     def __init__(
         self,
         *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
         edition: typing.Optional[AmazonLinuxEdition] = None,
@@ -4133,6 +4188,7 @@ class AmazonLinuxImageProps:
     ) -> None:
         '''Amazon Linux image properties.
 
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param cpu_type: CPU Type. Default: X86_64
         :param edition: What edition of Amazon Linux to use. Default: Standard
@@ -4163,6 +4219,7 @@ class AmazonLinuxImageProps:
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__dd95a518c06563a07debc9bf1ca51713b747cf64bded6f7cc81a28680d7ea9fc)
+            check_type(argname="argument additional_cache_key", value=additional_cache_key, expected_type=type_hints["additional_cache_key"])
             check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
             check_type(argname="argument cpu_type", value=cpu_type, expected_type=type_hints["cpu_type"])
             check_type(argname="argument edition", value=edition, expected_type=type_hints["edition"])
@@ -4172,6 +4229,8 @@ class AmazonLinuxImageProps:
             check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
             check_type(argname="argument virtualization", value=virtualization, expected_type=type_hints["virtualization"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if additional_cache_key is not None:
+            self._values["additional_cache_key"] = additional_cache_key
         if cached_in_context is not None:
             self._values["cached_in_context"] = cached_in_context
         if cpu_type is not None:
@@ -4190,242 +4249,286 @@ class AmazonLinuxImageProps:
             self._values["virtualization"] = virtualization
 
     @builtins.property
-    def cached_in_context(self) -> typing.Optional[builtins.bool]:
-        '''Whether the AMI ID is cached to be stable between deployments.
-
-        By default, the newest image is used on each deployment. This will cause
-        instances to be replaced whenever a new version is released, and may cause
-        downtime if there aren't enough running instances in the AutoScalingGroup
-        to reschedule the tasks on.
-
-        If set to true, the AMI ID will be cached in ``cdk.context.json`` and the
-        same value will be used on future runs. Your instances will not be replaced
-        but your AMI version will grow old over time. To refresh the AMI lookup,
-        you will have to evict the value from the cache using the ``cdk context``
-        command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for
-        more information.
-
-        Can not be set to ``true`` in environment-agnostic stacks.
-
-        :default: false
-        '''
-        result = self._values.get("cached_in_context")
-        return typing.cast(typing.Optional[builtins.bool], result)
-
-    @builtins.property
-    def cpu_type(self) -> typing.Optional[AmazonLinuxCpuType]:
-        '''CPU Type.
-
-        :default: X86_64
-        '''
-        result = self._values.get("cpu_type")
-        return typing.cast(typing.Optional[AmazonLinuxCpuType], result)
-
-    @builtins.property
-    def edition(self) -> typing.Optional[AmazonLinuxEdition]:
-        '''What edition of Amazon Linux to use.
-
-        :default: Standard
-        '''
-        result = self._values.get("edition")
-        return typing.cast(typing.Optional[AmazonLinuxEdition], result)
-
-    @builtins.property
-    def generation(self) -> typing.Optional[AmazonLinuxGeneration]:
-        '''What generation of Amazon Linux to use.
-
-        :default: AmazonLinux
-        '''
-        result = self._values.get("generation")
-        return typing.cast(typing.Optional[AmazonLinuxGeneration], result)
-
-    @builtins.property
-    def kernel(self) -> typing.Optional["AmazonLinuxKernel"]:
-        '''What kernel version of Amazon Linux to use.
-
-        :default: -
-        '''
-        result = self._values.get("kernel")
-        return typing.cast(typing.Optional["AmazonLinuxKernel"], result)
-
-    @builtins.property
-    def storage(self) -> typing.Optional["AmazonLinuxStorage"]:
-        '''What storage backed image to use.
-
-        :default: GeneralPurpose
-        '''
-        result = self._values.get("storage")
-        return typing.cast(typing.Optional["AmazonLinuxStorage"], result)
-
-    @builtins.property
-    def user_data(self) -> typing.Optional["UserData"]:
-        '''Initial user data.
-
-        :default: - Empty UserData for Linux machines
-        '''
-        result = self._values.get("user_data")
-        return typing.cast(typing.Optional["UserData"], result)
-
-    @builtins.property
-    def virtualization(self) -> typing.Optional["AmazonLinuxVirt"]:
-        '''Virtualization type.
+    def additional_cache_key(self) -> typing.Optional[builtins.str]:
+        '''Adds an additional discriminator to the ``cdk.context.json`` cache key.
 
-        :default: HVM
+        :default: - no additional cache key
         '''
-        result = self._values.get("virtualization")
-        return typing.cast(typing.Optional["AmazonLinuxVirt"], 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 "AmazonLinuxImageProps(%s)" % ", ".join(
-            k + "=" + repr(v) for k, v in self._values.items()
-        )
-
-
-@jsii.data_type(
-    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxImageSsmParameterBaseOptions",
-    jsii_struct_bases=[],
-    name_mapping={"cached_in_context": "cachedInContext", "user_data": "userData"},
-)
-class AmazonLinuxImageSsmParameterBaseOptions:
-    def __init__(
-        self,
-        *,
-        cached_in_context: typing.Optional[builtins.bool] = None,
-        user_data: typing.Optional["UserData"] = None,
-    ) -> None:
-        '''Base options for amazon linux ssm parameters.
-
-        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
-        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
-
-        :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
-            
-            # user_data: ec2.UserData
-            
-            amazon_linux_image_ssm_parameter_base_options = ec2.AmazonLinuxImageSsmParameterBaseOptions(
-                cached_in_context=False,
-                user_data=user_data
-            )
-        '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__08eb71b09afb1d361b3f043a5c2d7d4be91f84b114302afefc8a69963ee6333f)
-            check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
-            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
-        self._values: typing.Dict[builtins.str, typing.Any] = {}
-        if cached_in_context is not None:
-            self._values["cached_in_context"] = cached_in_context
-        if user_data is not None:
-            self._values["user_data"] = user_data
-
-    @builtins.property
-    def cached_in_context(self) -> typing.Optional[builtins.bool]:
-        '''Whether the AMI ID is cached to be stable between deployments.
-
-        By default, the newest image is used on each deployment. This will cause
-        instances to be replaced whenever a new version is released, and may cause
-        downtime if there aren't enough running instances in the AutoScalingGroup
-        to reschedule the tasks on.
-
-        If set to true, the AMI ID will be cached in ``cdk.context.json`` and the
-        same value will be used on future runs. Your instances will not be replaced
-        but your AMI version will grow old over time. To refresh the AMI lookup,
-        you will have to evict the value from the cache using the ``cdk context``
-        command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for
-        more information.
-
-        Can not be set to ``true`` in environment-agnostic stacks.
-
-        :default: false
-        '''
-        result = self._values.get("cached_in_context")
-        return typing.cast(typing.Optional[builtins.bool], result)
-
-    @builtins.property
-    def user_data(self) -> typing.Optional["UserData"]:
-        '''Initial user data.
-
-        :default: - Empty UserData for Linux machines
-        '''
-        result = self._values.get("user_data")
-        return typing.cast(typing.Optional["UserData"], 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 "AmazonLinuxImageSsmParameterBaseOptions(%s)" % ", ".join(
-            k + "=" + repr(v) for k, v in self._values.items()
-        )
-
-
-@jsii.data_type(
-    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxImageSsmParameterBaseProps",
-    jsii_struct_bases=[AmazonLinuxImageSsmParameterBaseOptions],
-    name_mapping={
-        "cached_in_context": "cachedInContext",
-        "user_data": "userData",
-        "parameter_name": "parameterName",
-    },
-)
-class AmazonLinuxImageSsmParameterBaseProps(AmazonLinuxImageSsmParameterBaseOptions):
-    def __init__(
-        self,
-        *,
-        cached_in_context: typing.Optional[builtins.bool] = None,
-        user_data: typing.Optional["UserData"] = None,
-        parameter_name: builtins.str,
-    ) -> None:
-        '''Base properties for an Amazon Linux SSM Parameter.
-
-        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
-        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
-        :param parameter_name: The name of the SSM parameter that contains the AMI value.
-
-        :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
-            
-            # user_data: ec2.UserData
-            
-            amazon_linux_image_ssm_parameter_base_props = ec2.AmazonLinuxImageSsmParameterBaseProps(
-                parameter_name="parameterName",
-            
-                # the properties below are optional
-                cached_in_context=False,
-                user_data=user_data
-            )
-        '''
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__78a32cfc14171e780d6e44d3e6a99faa6da50655ac09560f7b229b0c0c7383f1)
-            check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
-            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
-            check_type(argname="argument parameter_name", value=parameter_name, expected_type=type_hints["parameter_name"])
-        self._values: typing.Dict[builtins.str, typing.Any] = {
-            "parameter_name": parameter_name,
-        }
-        if cached_in_context is not None:
-            self._values["cached_in_context"] = cached_in_context
-        if user_data is not None:
-            self._values["user_data"] = user_data
+        result = self._values.get("additional_cache_key")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def cached_in_context(self) -> typing.Optional[builtins.bool]:
+        '''Whether the AMI ID is cached to be stable between deployments.
+
+        By default, the newest image is used on each deployment. This will cause
+        instances to be replaced whenever a new version is released, and may cause
+        downtime if there aren't enough running instances in the AutoScalingGroup
+        to reschedule the tasks on.
+
+        If set to true, the AMI ID will be cached in ``cdk.context.json`` and the
+        same value will be used on future runs. Your instances will not be replaced
+        but your AMI version will grow old over time. To refresh the AMI lookup,
+        you will have to evict the value from the cache using the ``cdk context``
+        command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for
+        more information.
+
+        Can not be set to ``true`` in environment-agnostic stacks.
+
+        :default: false
+        '''
+        result = self._values.get("cached_in_context")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def cpu_type(self) -> typing.Optional[AmazonLinuxCpuType]:
+        '''CPU Type.
+
+        :default: X86_64
+        '''
+        result = self._values.get("cpu_type")
+        return typing.cast(typing.Optional[AmazonLinuxCpuType], result)
+
+    @builtins.property
+    def edition(self) -> typing.Optional[AmazonLinuxEdition]:
+        '''What edition of Amazon Linux to use.
+
+        :default: Standard
+        '''
+        result = self._values.get("edition")
+        return typing.cast(typing.Optional[AmazonLinuxEdition], result)
+
+    @builtins.property
+    def generation(self) -> typing.Optional[AmazonLinuxGeneration]:
+        '''What generation of Amazon Linux to use.
+
+        :default: AmazonLinux
+        '''
+        result = self._values.get("generation")
+        return typing.cast(typing.Optional[AmazonLinuxGeneration], result)
+
+    @builtins.property
+    def kernel(self) -> typing.Optional["AmazonLinuxKernel"]:
+        '''What kernel version of Amazon Linux to use.
+
+        :default: -
+        '''
+        result = self._values.get("kernel")
+        return typing.cast(typing.Optional["AmazonLinuxKernel"], result)
+
+    @builtins.property
+    def storage(self) -> typing.Optional["AmazonLinuxStorage"]:
+        '''What storage backed image to use.
+
+        :default: GeneralPurpose
+        '''
+        result = self._values.get("storage")
+        return typing.cast(typing.Optional["AmazonLinuxStorage"], result)
+
+    @builtins.property
+    def user_data(self) -> typing.Optional["UserData"]:
+        '''Initial user data.
+
+        :default: - Empty UserData for Linux machines
+        '''
+        result = self._values.get("user_data")
+        return typing.cast(typing.Optional["UserData"], result)
+
+    @builtins.property
+    def virtualization(self) -> typing.Optional["AmazonLinuxVirt"]:
+        '''Virtualization type.
+
+        :default: HVM
+        '''
+        result = self._values.get("virtualization")
+        return typing.cast(typing.Optional["AmazonLinuxVirt"], 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 "AmazonLinuxImageProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxImageSsmParameterBaseOptions",
+    jsii_struct_bases=[],
+    name_mapping={
+        "additional_cache_key": "additionalCacheKey",
+        "cached_in_context": "cachedInContext",
+        "user_data": "userData",
+    },
+)
+class AmazonLinuxImageSsmParameterBaseOptions:
+    def __init__(
+        self,
+        *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
+        cached_in_context: typing.Optional[builtins.bool] = None,
+        user_data: typing.Optional["UserData"] = None,
+    ) -> None:
+        '''Base options for amazon linux ssm parameters.
+
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
+        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
+        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
+
+        :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
+            
+            # user_data: ec2.UserData
+            
+            amazon_linux_image_ssm_parameter_base_options = ec2.AmazonLinuxImageSsmParameterBaseOptions(
+                additional_cache_key="additionalCacheKey",
+                cached_in_context=False,
+                user_data=user_data
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__08eb71b09afb1d361b3f043a5c2d7d4be91f84b114302afefc8a69963ee6333f)
+            check_type(argname="argument additional_cache_key", value=additional_cache_key, expected_type=type_hints["additional_cache_key"])
+            check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
+            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if additional_cache_key is not None:
+            self._values["additional_cache_key"] = additional_cache_key
+        if cached_in_context is not None:
+            self._values["cached_in_context"] = cached_in_context
+        if user_data is not None:
+            self._values["user_data"] = user_data
+
+    @builtins.property
+    def additional_cache_key(self) -> typing.Optional[builtins.str]:
+        '''Adds an additional discriminator to the ``cdk.context.json`` cache key.
+
+        :default: - no additional cache key
+        '''
+        result = self._values.get("additional_cache_key")
+        return typing.cast(typing.Optional[builtins.str], result)
+
+    @builtins.property
+    def cached_in_context(self) -> typing.Optional[builtins.bool]:
+        '''Whether the AMI ID is cached to be stable between deployments.
+
+        By default, the newest image is used on each deployment. This will cause
+        instances to be replaced whenever a new version is released, and may cause
+        downtime if there aren't enough running instances in the AutoScalingGroup
+        to reschedule the tasks on.
+
+        If set to true, the AMI ID will be cached in ``cdk.context.json`` and the
+        same value will be used on future runs. Your instances will not be replaced
+        but your AMI version will grow old over time. To refresh the AMI lookup,
+        you will have to evict the value from the cache using the ``cdk context``
+        command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for
+        more information.
+
+        Can not be set to ``true`` in environment-agnostic stacks.
+
+        :default: false
+        '''
+        result = self._values.get("cached_in_context")
+        return typing.cast(typing.Optional[builtins.bool], result)
+
+    @builtins.property
+    def user_data(self) -> typing.Optional["UserData"]:
+        '''Initial user data.
+
+        :default: - Empty UserData for Linux machines
+        '''
+        result = self._values.get("user_data")
+        return typing.cast(typing.Optional["UserData"], 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 "AmazonLinuxImageSsmParameterBaseOptions(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxImageSsmParameterBaseProps",
+    jsii_struct_bases=[AmazonLinuxImageSsmParameterBaseOptions],
+    name_mapping={
+        "additional_cache_key": "additionalCacheKey",
+        "cached_in_context": "cachedInContext",
+        "user_data": "userData",
+        "parameter_name": "parameterName",
+    },
+)
+class AmazonLinuxImageSsmParameterBaseProps(AmazonLinuxImageSsmParameterBaseOptions):
+    def __init__(
+        self,
+        *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
+        cached_in_context: typing.Optional[builtins.bool] = None,
+        user_data: typing.Optional["UserData"] = None,
+        parameter_name: builtins.str,
+    ) -> None:
+        '''Base properties for an Amazon Linux SSM Parameter.
+
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
+        :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
+        :param user_data: Initial user data. Default: - Empty UserData for Linux machines
+        :param parameter_name: The name of the SSM parameter that contains the AMI value.
+
+        :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
+            
+            # user_data: ec2.UserData
+            
+            amazon_linux_image_ssm_parameter_base_props = ec2.AmazonLinuxImageSsmParameterBaseProps(
+                parameter_name="parameterName",
+            
+                # the properties below are optional
+                additional_cache_key="additionalCacheKey",
+                cached_in_context=False,
+                user_data=user_data
+            )
+        '''
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__78a32cfc14171e780d6e44d3e6a99faa6da50655ac09560f7b229b0c0c7383f1)
+            check_type(argname="argument additional_cache_key", value=additional_cache_key, expected_type=type_hints["additional_cache_key"])
+            check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
+            check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
+            check_type(argname="argument parameter_name", value=parameter_name, expected_type=type_hints["parameter_name"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "parameter_name": parameter_name,
+        }
+        if additional_cache_key is not None:
+            self._values["additional_cache_key"] = additional_cache_key
+        if cached_in_context is not None:
+            self._values["cached_in_context"] = cached_in_context
+        if user_data is not None:
+            self._values["user_data"] = user_data
+
+    @builtins.property
+    def additional_cache_key(self) -> typing.Optional[builtins.str]:
+        '''Adds an additional discriminator to the ``cdk.context.json`` cache key.
+
+        :default: - no additional cache key
+        '''
+        result = self._values.get("additional_cache_key")
+        return typing.cast(typing.Optional[builtins.str], result)
 
     @builtins.property
     def cached_in_context(self) -> typing.Optional[builtins.bool]:
@@ -4482,6 +4585,7 @@ class AmazonLinuxImageSsmParameterBaseProps(AmazonLinuxImageSsmParameterBaseOpti
     jsii_type="aws-cdk-lib.aws_ec2.AmazonLinuxImageSsmParameterCommonOptions",
     jsii_struct_bases=[AmazonLinuxImageSsmParameterBaseOptions],
     name_mapping={
+        "additional_cache_key": "additionalCacheKey",
         "cached_in_context": "cachedInContext",
         "user_data": "userData",
         "cpu_type": "cpuType",
@@ -4494,6 +4598,7 @@ class AmazonLinuxImageSsmParameterCommonOptions(
     def __init__(
         self,
         *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional["UserData"] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
@@ -4501,6 +4606,7 @@ class AmazonLinuxImageSsmParameterCommonOptions(
     ) -> None:
         '''Common options across all generations.
 
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
         :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
@@ -4517,6 +4623,7 @@ class AmazonLinuxImageSsmParameterCommonOptions(
             # user_data: ec2.UserData
             
             amazon_linux_image_ssm_parameter_common_options = ec2.AmazonLinuxImageSsmParameterCommonOptions(
+                additional_cache_key="additionalCacheKey",
                 cached_in_context=False,
                 cpu_type=ec2.AmazonLinuxCpuType.ARM_64,
                 edition=ec2.AmazonLinuxEdition.STANDARD,
@@ -4525,11 +4632,14 @@ class AmazonLinuxImageSsmParameterCommonOptions(
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__8fcdd01a6ab45c77447fba339b5a9358c3ab40c4833c1f86c68009a6a3bb1422)
+            check_type(argname="argument additional_cache_key", value=additional_cache_key, expected_type=type_hints["additional_cache_key"])
             check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
             check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
             check_type(argname="argument cpu_type", value=cpu_type, expected_type=type_hints["cpu_type"])
             check_type(argname="argument edition", value=edition, expected_type=type_hints["edition"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if additional_cache_key is not None:
+            self._values["additional_cache_key"] = additional_cache_key
         if cached_in_context is not None:
             self._values["cached_in_context"] = cached_in_context
         if user_data is not None:
@@ -4539,6 +4649,15 @@ class AmazonLinuxImageSsmParameterCommonOptions(
         if edition is not None:
             self._values["edition"] = edition
 
+    @builtins.property
+    def additional_cache_key(self) -> typing.Optional[builtins.str]:
+        '''Adds an additional discriminator to the ``cdk.context.json`` cache key.
+
+        :default: - no additional cache key
+        '''
+        result = self._values.get("additional_cache_key")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def cached_in_context(self) -> typing.Optional[builtins.bool]:
         '''Whether the AMI ID is cached to be stable between deployments.
@@ -11030,6 +11149,20 @@ class CfnEC2Fleet(
                 ),
                 overrides=[ec2.CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty(
                     availability_zone="availabilityZone",
+                    block_device_mappings=[ec2.CfnEC2Fleet.BlockDeviceMappingProperty(
+                        device_name="deviceName",
+                        ebs=ec2.CfnEC2Fleet.EbsBlockDeviceProperty(
+                            delete_on_termination=False,
+                            encrypted=False,
+                            iops=123,
+                            kms_key_id="kmsKeyId",
+                            snapshot_id="snapshotId",
+                            volume_size=123,
+                            volume_type="volumeType"
+                        ),
+                        no_device="noDevice",
+                        virtual_name="virtualName"
+                    )],
                     instance_requirements=ec2.CfnEC2Fleet.InstanceRequirementsRequestProperty(
                         accelerator_count=ec2.CfnEC2Fleet.AcceleratorCountRequestProperty(
                             max=123,
@@ -11750,6 +11883,129 @@ class CfnEC2Fleet(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.BlockDeviceMappingProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "device_name": "deviceName",
+            "ebs": "ebs",
+            "no_device": "noDevice",
+            "virtual_name": "virtualName",
+        },
+    )
+    class BlockDeviceMappingProperty:
+        def __init__(
+            self,
+            *,
+            device_name: typing.Optional[builtins.str] = None,
+            ebs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.EbsBlockDeviceProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            no_device: typing.Optional[builtins.str] = None,
+            virtual_name: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''Describes a block device mapping, which defines the EBS volumes and instance store volumes to attach to an instance at launch.
+
+            :param device_name: The device name (for example, ``/dev/sdh`` or ``xvdh`` ).
+            :param ebs: Parameters used to automatically set up EBS volumes when the instance is launched.
+            :param no_device: To omit the device from the block device mapping, specify an empty string. When this property is specified, the device is removed from the block device mapping regardless of the assigned value.
+            :param virtual_name: The virtual device name ( ``ephemeral`` N). Instance store volumes are numbered starting from 0. An instance type with 2 available instance store volumes can specify mappings for ``ephemeral0`` and ``ephemeral1`` . The number of available instance store volumes depends on the instance type. After you connect to the instance, you must mount the volume. NVMe instance store volumes are automatically enumerated and assigned a device name. Including them in your block device mapping has no effect. Constraints: For M3 instances, you must specify instance store volumes in the block device mapping for the instance. When you launch an M3 instance, we ignore any instance store volumes specified in the block device mapping for the AMI.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-blockdevicemapping.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
+                
+                block_device_mapping_property = ec2.CfnEC2Fleet.BlockDeviceMappingProperty(
+                    device_name="deviceName",
+                    ebs=ec2.CfnEC2Fleet.EbsBlockDeviceProperty(
+                        delete_on_termination=False,
+                        encrypted=False,
+                        iops=123,
+                        kms_key_id="kmsKeyId",
+                        snapshot_id="snapshotId",
+                        volume_size=123,
+                        volume_type="volumeType"
+                    ),
+                    no_device="noDevice",
+                    virtual_name="virtualName"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__2ac1bca7bdb78c6a00383adcdf8e49157dfa7db32559bd0d8033ff9f9ea819c7)
+                check_type(argname="argument device_name", value=device_name, expected_type=type_hints["device_name"])
+                check_type(argname="argument ebs", value=ebs, expected_type=type_hints["ebs"])
+                check_type(argname="argument no_device", value=no_device, expected_type=type_hints["no_device"])
+                check_type(argname="argument virtual_name", value=virtual_name, expected_type=type_hints["virtual_name"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if device_name is not None:
+                self._values["device_name"] = device_name
+            if ebs is not None:
+                self._values["ebs"] = ebs
+            if no_device is not None:
+                self._values["no_device"] = no_device
+            if virtual_name is not None:
+                self._values["virtual_name"] = virtual_name
+
+        @builtins.property
+        def device_name(self) -> typing.Optional[builtins.str]:
+            '''The device name (for example, ``/dev/sdh`` or ``xvdh`` ).
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-blockdevicemapping.html#cfn-ec2-ec2fleet-blockdevicemapping-devicename
+            '''
+            result = self._values.get("device_name")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def ebs(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.EbsBlockDeviceProperty"]]:
+            '''Parameters used to automatically set up EBS volumes when the instance is launched.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-blockdevicemapping.html#cfn-ec2-ec2fleet-blockdevicemapping-ebs
+            '''
+            result = self._values.get("ebs")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.EbsBlockDeviceProperty"]], result)
+
+        @builtins.property
+        def no_device(self) -> typing.Optional[builtins.str]:
+            '''To omit the device from the block device mapping, specify an empty string.
+
+            When this property is specified, the device is removed from the block device mapping regardless of the assigned value.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-blockdevicemapping.html#cfn-ec2-ec2fleet-blockdevicemapping-nodevice
+            '''
+            result = self._values.get("no_device")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def virtual_name(self) -> typing.Optional[builtins.str]:
+            '''The virtual device name ( ``ephemeral`` N).
+
+            Instance store volumes are numbered starting from 0. An instance type with 2 available instance store volumes can specify mappings for ``ephemeral0`` and ``ephemeral1`` . The number of available instance store volumes depends on the instance type. After you connect to the instance, you must mount the volume.
+
+            NVMe instance store volumes are automatically enumerated and assigned a device name. Including them in your block device mapping has no effect.
+
+            Constraints: For M3 instances, you must specify instance store volumes in the block device mapping for the instance. When you launch an M3 instance, we ignore any instance store volumes specified in the block device mapping for the AMI.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-blockdevicemapping.html#cfn-ec2-ec2fleet-blockdevicemapping-virtualname
+            '''
+            result = self._values.get("virtual_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 "BlockDeviceMappingProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.CapacityRebalanceProperty",
         jsii_struct_bases=[],
@@ -11964,6 +12220,206 @@ class CfnEC2Fleet(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.EbsBlockDeviceProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "delete_on_termination": "deleteOnTermination",
+            "encrypted": "encrypted",
+            "iops": "iops",
+            "kms_key_id": "kmsKeyId",
+            "snapshot_id": "snapshotId",
+            "volume_size": "volumeSize",
+            "volume_type": "volumeType",
+        },
+    )
+    class EbsBlockDeviceProperty:
+        def __init__(
+            self,
+            *,
+            delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+            encrypted: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+            iops: typing.Optional[jsii.Number] = None,
+            kms_key_id: typing.Optional[builtins.str] = None,
+            snapshot_id: typing.Optional[builtins.str] = None,
+            volume_size: typing.Optional[jsii.Number] = None,
+            volume_type: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''Describes a block device for an EBS volume.
+
+            :param delete_on_termination: Indicates whether the EBS volume is deleted on instance termination. For more information, see `Preserving Amazon EBS volumes on instance termination <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#preserving-volumes-on-termination>`_ in the *Amazon EC2 User Guide* .
+            :param encrypted: Indicates whether the encryption state of an EBS volume is changed while being restored from a backing snapshot. The effect of setting the encryption state to ``true`` depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Amazon EBS encryption <https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption.html#encryption-parameters>`_ in the *Amazon EBS User Guide* . In no case can you remove encryption from an encrypted volume. Encrypted volumes can only be attached to instances that support Amazon EBS encryption. For more information, see `Supported instance types <https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption-requirements.html#ebs-encryption_supported_instances>`_ . This parameter is not returned by ``DescribeImageAttribute`` . For ``CreateImage`` and ``RegisterImage`` , whether you can include this parameter, and the allowed values differ depending on the type of block device mapping you are creating. - If you are creating a block device mapping for a *new (empty) volume* , you can include this parameter, and specify either ``true`` for an encrypted volume, or ``false`` for an unencrypted volume. If you omit this parameter, it defaults to ``false`` (unencrypted). - If you are creating a block device mapping from an *existing encrypted or unencrypted snapshot* , you must omit this parameter. If you include this parameter, the request will fail, regardless of the value that you specify. - If you are creating a block device mapping from an *existing unencrypted volume* , you can include this parameter, but you must specify ``false`` . If you specify ``true`` , the request will fail. In this case, we recommend that you omit the parameter. - If you are creating a block device mapping from an *existing encrypted volume* , you can include this parameter, and specify either ``true`` or ``false`` . However, if you specify ``false`` , the parameter is ignored and the block device mapping is always encrypted. In this case, we recommend that you omit the parameter.
+            :param iops: The number of I/O operations per second (IOPS). For ``gp3`` , ``io1`` , and ``io2`` volumes, this represents the number of IOPS that are provisioned for the volume. For ``gp2`` volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting. The following are the supported values for each volume type: - ``gp3`` : 3,000 - 16,000 IOPS - ``io1`` : 100 - 64,000 IOPS - ``io2`` : 100 - 256,000 IOPS For ``io2`` volumes, you can achieve up to 256,000 IOPS on `instances built on the Nitro System <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ . On other instances, you can achieve performance up to 32,000 IOPS. This parameter is required for ``io1`` and ``io2`` volumes. The default for ``gp3`` volumes is 3,000 IOPS.
+            :param kms_key_id: Identifier (key ID, key alias, key ARN, or alias ARN) of the customer managed KMS key to use for EBS encryption. This parameter is only supported on ``BlockDeviceMapping`` objects called by `RunInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html>`_ , `RequestSpotFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RequestSpotFleet.html>`_ , and `RequestSpotInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RequestSpotInstances.html>`_ .
+            :param snapshot_id: The ID of the snapshot.
+            :param volume_size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. If you specify a snapshot, the default is the snapshot size. You can specify a volume size that is equal to or larger than the snapshot size. The following are the supported sizes for each volume type: - ``gp2`` and ``gp3`` : 1 - 16,384 GiB - ``io1`` : 4 - 16,384 GiB - ``io2`` : 4 - 65,536 GiB - ``st1`` and ``sc1`` : 125 - 16,384 GiB - ``standard`` : 1 - 1024 GiB
+            :param volume_type: The volume type. For more information, see `Amazon EBS volume types <https://docs.aws.amazon.com/ebs/latest/userguide/ebs-volume-types.html>`_ in the *Amazon EBS User Guide* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ebsblockdevice.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
+                
+                ebs_block_device_property = ec2.CfnEC2Fleet.EbsBlockDeviceProperty(
+                    delete_on_termination=False,
+                    encrypted=False,
+                    iops=123,
+                    kms_key_id="kmsKeyId",
+                    snapshot_id="snapshotId",
+                    volume_size=123,
+                    volume_type="volumeType"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__98937edeb55103aa31b4f310bc1c5cdf31ffd54c5c2d451314118a9d43196bbd)
+                check_type(argname="argument delete_on_termination", value=delete_on_termination, expected_type=type_hints["delete_on_termination"])
+                check_type(argname="argument encrypted", value=encrypted, expected_type=type_hints["encrypted"])
+                check_type(argname="argument iops", value=iops, expected_type=type_hints["iops"])
+                check_type(argname="argument kms_key_id", value=kms_key_id, expected_type=type_hints["kms_key_id"])
+                check_type(argname="argument snapshot_id", value=snapshot_id, expected_type=type_hints["snapshot_id"])
+                check_type(argname="argument volume_size", value=volume_size, expected_type=type_hints["volume_size"])
+                check_type(argname="argument volume_type", value=volume_type, expected_type=type_hints["volume_type"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if delete_on_termination is not None:
+                self._values["delete_on_termination"] = delete_on_termination
+            if encrypted is not None:
+                self._values["encrypted"] = encrypted
+            if iops is not None:
+                self._values["iops"] = iops
+            if kms_key_id is not None:
+                self._values["kms_key_id"] = kms_key_id
+            if snapshot_id is not None:
+                self._values["snapshot_id"] = snapshot_id
+            if volume_size is not None:
+                self._values["volume_size"] = volume_size
+            if volume_type is not None:
+                self._values["volume_type"] = volume_type
+
+        @builtins.property
+        def delete_on_termination(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''Indicates whether the EBS volume is deleted on instance termination.
+
+            For more information, see `Preserving Amazon EBS volumes on instance termination <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/terminating-instances.html#preserving-volumes-on-termination>`_ in the *Amazon EC2 User Guide* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ebsblockdevice.html#cfn-ec2-ec2fleet-ebsblockdevice-deleteontermination
+            '''
+            result = self._values.get("delete_on_termination")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
+        @builtins.property
+        def encrypted(
+            self,
+        ) -> typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]]:
+            '''Indicates whether the encryption state of an EBS volume is changed while being restored from a backing snapshot.
+
+            The effect of setting the encryption state to ``true`` depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Amazon EBS encryption <https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption.html#encryption-parameters>`_ in the *Amazon EBS User Guide* .
+
+            In no case can you remove encryption from an encrypted volume.
+
+            Encrypted volumes can only be attached to instances that support Amazon EBS encryption. For more information, see `Supported instance types <https://docs.aws.amazon.com/ebs/latest/userguide/ebs-encryption-requirements.html#ebs-encryption_supported_instances>`_ .
+
+            This parameter is not returned by ``DescribeImageAttribute`` .
+
+            For ``CreateImage`` and ``RegisterImage`` , whether you can include this parameter, and the allowed values differ depending on the type of block device mapping you are creating.
+
+            - If you are creating a block device mapping for a *new (empty) volume* , you can include this parameter, and specify either ``true`` for an encrypted volume, or ``false`` for an unencrypted volume. If you omit this parameter, it defaults to ``false`` (unencrypted).
+            - If you are creating a block device mapping from an *existing encrypted or unencrypted snapshot* , you must omit this parameter. If you include this parameter, the request will fail, regardless of the value that you specify.
+            - If you are creating a block device mapping from an *existing unencrypted volume* , you can include this parameter, but you must specify ``false`` . If you specify ``true`` , the request will fail. In this case, we recommend that you omit the parameter.
+            - If you are creating a block device mapping from an *existing encrypted volume* , you can include this parameter, and specify either ``true`` or ``false`` . However, if you specify ``false`` , the parameter is ignored and the block device mapping is always encrypted. In this case, we recommend that you omit the parameter.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ebsblockdevice.html#cfn-ec2-ec2fleet-ebsblockdevice-encrypted
+            '''
+            result = self._values.get("encrypted")
+            return typing.cast(typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]], result)
+
+        @builtins.property
+        def iops(self) -> typing.Optional[jsii.Number]:
+            '''The number of I/O operations per second (IOPS).
+
+            For ``gp3`` , ``io1`` , and ``io2`` volumes, this represents the number of IOPS that are provisioned for the volume. For ``gp2`` volumes, this represents the baseline performance of the volume and the rate at which the volume accumulates I/O credits for bursting.
+
+            The following are the supported values for each volume type:
+
+            - ``gp3`` : 3,000 - 16,000 IOPS
+            - ``io1`` : 100 - 64,000 IOPS
+            - ``io2`` : 100 - 256,000 IOPS
+
+            For ``io2`` volumes, you can achieve up to 256,000 IOPS on `instances built on the Nitro System <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html#ec2-nitro-instances>`_ . On other instances, you can achieve performance up to 32,000 IOPS.
+
+            This parameter is required for ``io1`` and ``io2`` volumes. The default for ``gp3`` volumes is 3,000 IOPS.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ebsblockdevice.html#cfn-ec2-ec2fleet-ebsblockdevice-iops
+            '''
+            result = self._values.get("iops")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def kms_key_id(self) -> typing.Optional[builtins.str]:
+            '''Identifier (key ID, key alias, key ARN, or alias ARN) of the customer managed KMS key to use for EBS encryption.
+
+            This parameter is only supported on ``BlockDeviceMapping`` objects called by `RunInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RunInstances.html>`_ , `RequestSpotFleet <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RequestSpotFleet.html>`_ , and `RequestSpotInstances <https://docs.aws.amazon.com/AWSEC2/latest/APIReference/API_RequestSpotInstances.html>`_ .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ebsblockdevice.html#cfn-ec2-ec2fleet-ebsblockdevice-kmskeyid
+            '''
+            result = self._values.get("kms_key_id")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def snapshot_id(self) -> typing.Optional[builtins.str]:
+            '''The ID of the snapshot.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ebsblockdevice.html#cfn-ec2-ec2fleet-ebsblockdevice-snapshotid
+            '''
+            result = self._values.get("snapshot_id")
+            return typing.cast(typing.Optional[builtins.str], result)
+
+        @builtins.property
+        def volume_size(self) -> typing.Optional[jsii.Number]:
+            '''The size of the volume, in GiBs.
+
+            You must specify either a snapshot ID or a volume size. If you specify a snapshot, the default is the snapshot size. You can specify a volume size that is equal to or larger than the snapshot size.
+
+            The following are the supported sizes for each volume type:
+
+            - ``gp2`` and ``gp3`` : 1 - 16,384 GiB
+            - ``io1`` : 4 - 16,384 GiB
+            - ``io2`` : 4 - 65,536 GiB
+            - ``st1`` and ``sc1`` : 125 - 16,384 GiB
+            - ``standard`` : 1 - 1024 GiB
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ebsblockdevice.html#cfn-ec2-ec2fleet-ebsblockdevice-volumesize
+            '''
+            result = self._values.get("volume_size")
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def volume_type(self) -> typing.Optional[builtins.str]:
+            '''The volume type.
+
+            For more information, see `Amazon EBS volume types <https://docs.aws.amazon.com/ebs/latest/userguide/ebs-volume-types.html>`_ in the *Amazon EBS User Guide* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-ebsblockdevice.html#cfn-ec2-ec2fleet-ebsblockdevice-volumetype
+            '''
+            result = self._values.get("volume_type")
+            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 "EbsBlockDeviceProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_ec2.CfnEC2Fleet.FleetLaunchTemplateConfigRequestProperty",
         jsii_struct_bases=[],
@@ -12005,6 +12461,20 @@ class CfnEC2Fleet(
                     ),
                     overrides=[ec2.CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty(
                         availability_zone="availabilityZone",
+                        block_device_mappings=[ec2.CfnEC2Fleet.BlockDeviceMappingProperty(
+                            device_name="deviceName",
+                            ebs=ec2.CfnEC2Fleet.EbsBlockDeviceProperty(
+                                delete_on_termination=False,
+                                encrypted=False,
+                                iops=123,
+                                kms_key_id="kmsKeyId",
+                                snapshot_id="snapshotId",
+                                volume_size=123,
+                                volume_type="volumeType"
+                            ),
+                            no_device="noDevice",
+                            virtual_name="virtualName"
+                        )],
                         instance_requirements=ec2.CfnEC2Fleet.InstanceRequirementsRequestProperty(
                             accelerator_count=ec2.CfnEC2Fleet.AcceleratorCountRequestProperty(
                                 max=123,
@@ -12135,6 +12605,7 @@ class CfnEC2Fleet(
         jsii_struct_bases=[],
         name_mapping={
             "availability_zone": "availabilityZone",
+            "block_device_mappings": "blockDeviceMappings",
             "instance_requirements": "instanceRequirements",
             "instance_type": "instanceType",
             "max_price": "maxPrice",
@@ -12149,6 +12620,7 @@ class CfnEC2Fleet(
             self,
             *,
             availability_zone: typing.Optional[builtins.str] = None,
+            block_device_mappings: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.BlockDeviceMappingProperty", typing.Dict[builtins.str, typing.Any]]]]]] = None,
             instance_requirements: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnEC2Fleet.InstanceRequirementsRequestProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             instance_type: typing.Optional[builtins.str] = None,
             max_price: typing.Optional[builtins.str] = None,
@@ -12162,6 +12634,7 @@ class CfnEC2Fleet(
             ``FleetLaunchTemplateOverridesRequest`` is a property of the `FleetLaunchTemplateConfigRequest <https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateconfigrequest.html>`_ property type.
 
             :param availability_zone: The Availability Zone in which to launch the instances.
+            :param block_device_mappings: The block device mappings, which define the EBS volumes and instance store volumes to attach to the instance at launch. Supported only for fleets of type ``instant`` . For more information, see `Block device mappings for volumes on Amazon EC2 instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html>`_ in the *Amazon EC2 User Guide* .
             :param instance_requirements: The attributes for the instance types. When you specify instance attributes, Amazon EC2 will identify instance types with those attributes. .. epigraph:: If you specify ``InstanceRequirements`` , you can't specify ``InstanceType`` .
             :param instance_type: The instance type. ``mac1.metal`` is not supported as a launch template override. .. epigraph:: If you specify ``InstanceType`` , you can't specify ``InstanceRequirements`` .
             :param max_price: The maximum price per unit hour that you are willing to pay for a Spot Instance. We do not recommend using this parameter because it can lead to increased interruptions. If you do not specify this parameter, you will pay the current Spot price. .. epigraph:: If you specify a maximum price, your instances will be interrupted more frequently than if you do not specify this parameter. If you specify a maximum price, it must be more than USD $0.001. Specifying a value below USD $0.001 will result in an ``InvalidParameterValue`` error message.
@@ -12181,6 +12654,20 @@ class CfnEC2Fleet(
                 
                 fleet_launch_template_overrides_request_property = ec2.CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty(
                     availability_zone="availabilityZone",
+                    block_device_mappings=[ec2.CfnEC2Fleet.BlockDeviceMappingProperty(
+                        device_name="deviceName",
+                        ebs=ec2.CfnEC2Fleet.EbsBlockDeviceProperty(
+                            delete_on_termination=False,
+                            encrypted=False,
+                            iops=123,
+                            kms_key_id="kmsKeyId",
+                            snapshot_id="snapshotId",
+                            volume_size=123,
+                            volume_type="volumeType"
+                        ),
+                        no_device="noDevice",
+                        virtual_name="virtualName"
+                    )],
                     instance_requirements=ec2.CfnEC2Fleet.InstanceRequirementsRequestProperty(
                         accelerator_count=ec2.CfnEC2Fleet.AcceleratorCountRequestProperty(
                             max=123,
@@ -12261,6 +12748,7 @@ class CfnEC2Fleet(
             if __debug__:
                 type_hints = typing.get_type_hints(_typecheckingstub__d758750d188cce1b749f19591d20310ad5bc697f0e6f94f495c9619297998763)
                 check_type(argname="argument availability_zone", value=availability_zone, expected_type=type_hints["availability_zone"])
+                check_type(argname="argument block_device_mappings", value=block_device_mappings, expected_type=type_hints["block_device_mappings"])
                 check_type(argname="argument instance_requirements", value=instance_requirements, expected_type=type_hints["instance_requirements"])
                 check_type(argname="argument instance_type", value=instance_type, expected_type=type_hints["instance_type"])
                 check_type(argname="argument max_price", value=max_price, expected_type=type_hints["max_price"])
@@ -12271,6 +12759,8 @@ class CfnEC2Fleet(
             self._values: typing.Dict[builtins.str, typing.Any] = {}
             if availability_zone is not None:
                 self._values["availability_zone"] = availability_zone
+            if block_device_mappings is not None:
+                self._values["block_device_mappings"] = block_device_mappings
             if instance_requirements is not None:
                 self._values["instance_requirements"] = instance_requirements
             if instance_type is not None:
@@ -12295,6 +12785,21 @@ class CfnEC2Fleet(
             result = self._values.get("availability_zone")
             return typing.cast(typing.Optional[builtins.str], result)
 
+        @builtins.property
+        def block_device_mappings(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.BlockDeviceMappingProperty"]]]]:
+            '''The block device mappings, which define the EBS volumes and instance store volumes to attach to the instance at launch.
+
+            Supported only for fleets of type ``instant`` .
+
+            For more information, see `Block device mappings for volumes on Amazon EC2 instances <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/block-device-mapping-concepts.html>`_ in the *Amazon EC2 User Guide* .
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest.html#cfn-ec2-ec2fleet-fleetlaunchtemplateoverridesrequest-blockdevicemappings
+            '''
+            result = self._values.get("block_device_mappings")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, typing.List[typing.Union[_IResolvable_da3f097b, "CfnEC2Fleet.BlockDeviceMappingProperty"]]]], result)
+
         @builtins.property
         def instance_requirements(
             self,
@@ -14627,6 +15132,20 @@ class CfnEC2FleetProps:
                     ),
                     overrides=[ec2.CfnEC2Fleet.FleetLaunchTemplateOverridesRequestProperty(
                         availability_zone="availabilityZone",
+                        block_device_mappings=[ec2.CfnEC2Fleet.BlockDeviceMappingProperty(
+                            device_name="deviceName",
+                            ebs=ec2.CfnEC2Fleet.EbsBlockDeviceProperty(
+                                delete_on_termination=False,
+                                encrypted=False,
+                                iops=123,
+                                kms_key_id="kmsKeyId",
+                                snapshot_id="snapshotId",
+                                volume_size=123,
+                                volume_type="volumeType"
+                            ),
+                            no_device="noDevice",
+                            virtual_name="virtualName"
+                        )],
                         instance_requirements=ec2.CfnEC2Fleet.InstanceRequirementsRequestProperty(
                             accelerator_count=ec2.CfnEC2Fleet.AcceleratorCountRequestProperty(
                                 max=123,
@@ -15694,7 +16213,7 @@ class CfnEIPProps:
         )
 
 
-@jsii.implements(_IInspectable_c2943556)
+@jsii.implements(_IInspectable_c2943556, _ITaggableV2_4e6798f8)
 class CfnEgressOnlyInternetGateway(
     _CfnResource_9df397a6,
     metaclass=jsii.JSIIMeta,
@@ -15717,7 +16236,13 @@ class CfnEgressOnlyInternetGateway(
         from aws_cdk import aws_ec2 as ec2
         
         cfn_egress_only_internet_gateway = ec2.CfnEgressOnlyInternetGateway(self, "MyCfnEgressOnlyInternetGateway",
-            vpc_id="vpcId"
+            vpc_id="vpcId",
+        
+            # the properties below are optional
+            tags=[CfnTag(
+                key="key",
+                value="value"
+            )]
         )
     '''
 
@@ -15727,17 +16252,19 @@ class CfnEgressOnlyInternetGateway(
         id: builtins.str,
         *,
         vpc_id: builtins.str,
+        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
     ) -> None:
         '''
         :param scope: Scope in which this resource is defined.
         :param id: Construct identifier for this resource (unique in its scope).
         :param vpc_id: The ID of the VPC for which to create the egress-only internet gateway.
+        :param tags: The tags assigned to the egress-only internet gateway.
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__84a7ddca98bd1c24713f12588ec54b51cdc19c99c2209e07c964172011c4d7ab)
             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 = CfnEgressOnlyInternetGatewayProps(vpc_id=vpc_id)
+        props = CfnEgressOnlyInternetGatewayProps(vpc_id=vpc_id, tags=tags)
 
         jsii.create(self.__class__, self, [scope, id, props])
 
@@ -15780,6 +16307,12 @@ class CfnEgressOnlyInternetGateway(
         '''
         return typing.cast(builtins.str, jsii.get(self, "attrId"))
 
+    @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]:
@@ -15798,17 +16331,36 @@ class CfnEgressOnlyInternetGateway(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "vpcId", value) # pyright: ignore[reportArgumentType]
 
+    @builtins.property
+    @jsii.member(jsii_name="tags")
+    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
+        '''The tags assigned to the egress-only internet gateway.'''
+        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], jsii.get(self, "tags"))
+
+    @tags.setter
+    def tags(self, value: typing.Optional[typing.List[_CfnTag_f6864754]]) -> None:
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__923846a8ba3d02f36c9267e2c903018ed279860265ad8a488da0a81153c5ff44)
+            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_ec2.CfnEgressOnlyInternetGatewayProps",
     jsii_struct_bases=[],
-    name_mapping={"vpc_id": "vpcId"},
+    name_mapping={"vpc_id": "vpcId", "tags": "tags"},
 )
 class CfnEgressOnlyInternetGatewayProps:
-    def __init__(self, *, vpc_id: builtins.str) -> None:
+    def __init__(
+        self,
+        *,
+        vpc_id: builtins.str,
+        tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
+    ) -> None:
         '''Properties for defining a ``CfnEgressOnlyInternetGateway``.
 
         :param vpc_id: The ID of the VPC for which to create the egress-only internet gateway.
+        :param tags: The tags assigned to the egress-only internet gateway.
 
         :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-egressonlyinternetgateway.html
         :exampleMetadata: fixture=_generated
@@ -15820,15 +16372,24 @@ class CfnEgressOnlyInternetGatewayProps:
             from aws_cdk import aws_ec2 as ec2
             
             cfn_egress_only_internet_gateway_props = ec2.CfnEgressOnlyInternetGatewayProps(
-                vpc_id="vpcId"
+                vpc_id="vpcId",
+            
+                # the properties below are optional
+                tags=[CfnTag(
+                    key="key",
+                    value="value"
+                )]
             )
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__b693b2d49003d73758f4c0003564a93353b18fc97434556a2e988e47f367fb84)
             check_type(argname="argument vpc_id", value=vpc_id, expected_type=type_hints["vpc_id"])
+            check_type(argname="argument tags", value=tags, expected_type=type_hints["tags"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "vpc_id": vpc_id,
         }
+        if tags is not None:
+            self._values["tags"] = tags
 
     @builtins.property
     def vpc_id(self) -> builtins.str:
@@ -15840,6 +16401,15 @@ class CfnEgressOnlyInternetGatewayProps:
         assert result is not None, "Required property 'vpc_id' is missing"
         return typing.cast(builtins.str, result)
 
+    @builtins.property
+    def tags(self) -> typing.Optional[typing.List[_CfnTag_f6864754]]:
+        '''The tags assigned to the egress-only internet gateway.
+
+        :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-egressonlyinternetgateway.html#cfn-ec2-egressonlyinternetgateway-tags
+        '''
+        result = self._values.get("tags")
+        return typing.cast(typing.Optional[typing.List[_CfnTag_f6864754]], result)
+
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
         return isinstance(rhs, self.__class__) and rhs._values == self._values
 
@@ -52031,7 +52601,7 @@ class CfnSubnet(
 
     Example::
 
-        from aws_cdk.lambda_layer_kubectl_v32 import KubectlV32Layer
+        from aws_cdk.lambda_layer_kubectl_v33 import KubectlV33Layer
         # vpc: ec2.Vpc
         
         
@@ -52056,11 +52626,11 @@ class CfnSubnet(
             subnetcount = subnetcount + 1
         
         cluster = eks.Cluster(self, "hello-eks",
-            version=eks.KubernetesVersion.V1_32,
+            version=eks.KubernetesVersion.V1_33,
             vpc=vpc,
             ip_family=eks.IpFamily.IP_V6,
             vpc_subnets=[ec2.SubnetSelection(subnets=vpc.public_subnets)],
-            kubectl_layer=KubectlV32Layer(self, "kubectl")
+            kubectl_layer=KubectlV33Layer(self, "kubectl")
         )
     '''
 
@@ -52186,6 +52756,14 @@ class CfnSubnet(
         '''
         return typing.cast(builtins.str, jsii.get(self, "attrAvailabilityZoneId"))
 
+    @builtins.property
+    @jsii.member(jsii_name="attrBlockPublicAccessStates")
+    def attr_block_public_access_states(self) -> _IResolvable_da3f097b:
+        '''
+        :cloudformationAttribute: BlockPublicAccessStates
+        '''
+        return typing.cast(_IResolvable_da3f097b, jsii.get(self, "attrBlockPublicAccessStates"))
+
     @builtins.property
     @jsii.member(jsii_name="attrCidrBlock")
     def attr_cidr_block(self) -> builtins.str:
@@ -52498,6 +53076,62 @@ class CfnSubnet(
             check_type(argname="argument value", value=value, expected_type=type_hints["value"])
         jsii.set(self, "tagsRaw", value) # pyright: ignore[reportArgumentType]
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ec2.CfnSubnet.BlockPublicAccessStatesProperty",
+        jsii_struct_bases=[],
+        name_mapping={"internet_gateway_block_mode": "internetGatewayBlockMode"},
+    )
+    class BlockPublicAccessStatesProperty:
+        def __init__(
+            self,
+            *,
+            internet_gateway_block_mode: typing.Optional[builtins.str] = None,
+        ) -> None:
+            '''
+            :param internet_gateway_block_mode: The mode of VPC BPA. Options here are off, block-bidirectional, block-ingress
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-subnet-blockpublicaccessstates.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
+                
+                block_public_access_states_property = ec2.CfnSubnet.BlockPublicAccessStatesProperty(
+                    internet_gateway_block_mode="internetGatewayBlockMode"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__39b852e2beaad9da72706596053a58f7c1190828d458e590af07c5701812220d)
+                check_type(argname="argument internet_gateway_block_mode", value=internet_gateway_block_mode, expected_type=type_hints["internet_gateway_block_mode"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if internet_gateway_block_mode is not None:
+                self._values["internet_gateway_block_mode"] = internet_gateway_block_mode
+
+        @builtins.property
+        def internet_gateway_block_mode(self) -> typing.Optional[builtins.str]:
+            '''The mode of VPC BPA.
+
+            Options here are off, block-bidirectional, block-ingress
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ec2-subnet-blockpublicaccessstates.html#cfn-ec2-subnet-blockpublicaccessstates-internetgatewayblockmode
+            '''
+            result = self._values.get("internet_gateway_block_mode")
+            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 "BlockPublicAccessStatesProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_ec2.CfnSubnet.PrivateDnsNameOptionsOnLaunchProperty",
         jsii_struct_bases=[],
@@ -53720,8 +54354,7 @@ class CfnTrafficMirrorFilter(
     @builtins.property
     @jsii.member(jsii_name="attrId")
     def attr_id(self) -> builtins.str:
-        '''The ID of a traffic mirror filter.
-
+        '''
         :cloudformationAttribute: Id
         '''
         return typing.cast(builtins.str, jsii.get(self, "attrId"))
@@ -60356,7 +60989,7 @@ class CfnVPCCidrBlock(
 
     Example::
 
-        from aws_cdk.lambda_layer_kubectl_v32 import KubectlV32Layer
+        from aws_cdk.lambda_layer_kubectl_v33 import KubectlV33Layer
         # vpc: ec2.Vpc
         
         
@@ -60381,11 +61014,11 @@ class CfnVPCCidrBlock(
             subnetcount = subnetcount + 1
         
         cluster = eks.Cluster(self, "hello-eks",
-            version=eks.KubernetesVersion.V1_32,
+            version=eks.KubernetesVersion.V1_33,
             vpc=vpc,
             ip_family=eks.IpFamily.IP_V6,
             vpc_subnets=[ec2.SubnetSelection(subnets=vpc.public_subnets)],
-            kubectl_layer=KubectlV32Layer(self, "kubectl")
+            kubectl_layer=KubectlV33Layer(self, "kubectl")
         )
     '''
 
@@ -60695,7 +61328,7 @@ class CfnVPCCidrBlockProps:
 
         Example::
 
-            from aws_cdk.lambda_layer_kubectl_v32 import KubectlV32Layer
+            from aws_cdk.lambda_layer_kubectl_v33 import KubectlV33Layer
             # vpc: ec2.Vpc
             
             
@@ -60720,11 +61353,11 @@ class CfnVPCCidrBlockProps:
                 subnetcount = subnetcount + 1
             
             cluster = eks.Cluster(self, "hello-eks",
-                version=eks.KubernetesVersion.V1_32,
+                version=eks.KubernetesVersion.V1_33,
                 vpc=vpc,
                 ip_family=eks.IpFamily.IP_V6,
                 vpc_subnets=[ec2.SubnetSelection(subnets=vpc.public_subnets)],
-                kubectl_layer=KubectlV32Layer(self, "kubectl")
+                kubectl_layer=KubectlV33Layer(self, "kubectl")
             )
         '''
         if __debug__:
@@ -82206,6 +82839,16 @@ class InterfaceVpcEndpointAwsService(
     def DIRECTORY_SERVICE_DATA(cls) -> "InterfaceVpcEndpointAwsService":
         return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "DIRECTORY_SERVICE_DATA"))
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="DSQL_MANAGEMENT")
+    def DSQL_MANAGEMENT(cls) -> "InterfaceVpcEndpointAwsService":
+        '''The management endpoint for DSQL.
+
+        For the Connection endpoint, use ``new InterfaceVpcEndpointService(cfnCluster.attrVpcEndpointServiceName)``.
+        See https://docs.aws.amazon.com/aurora-dsql/latest/userguide/privatelink-managing-clusters.html#endpoint-types-dsql for details
+        '''
+        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "DSQL_MANAGEMENT"))
+
     @jsii.python.classproperty
     @jsii.member(jsii_name="DYNAMODB")
     def DYNAMODB(cls) -> "InterfaceVpcEndpointAwsService":
@@ -83352,6 +83995,16 @@ class InterfaceVpcEndpointAwsService(
         '''
         return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SES"))
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="SHIELD")
+    def SHIELD(cls) -> "InterfaceVpcEndpointAwsService":
+        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SHIELD"))
+
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="SHIELD_FIPS")
+    def SHIELD_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
+        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SHIELD_FIPS"))
+
     @jsii.python.classproperty
     @jsii.member(jsii_name="SIMSPACE_WEAVER")
     def SIMSPACE_WEAVER(cls) -> "InterfaceVpcEndpointAwsService":
@@ -83372,6 +84025,11 @@ class InterfaceVpcEndpointAwsService(
     def SQS(cls) -> "InterfaceVpcEndpointAwsService":
         return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SQS"))
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="SQS_FIPS")
+    def SQS_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
+        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "SQS_FIPS"))
+
     @jsii.python.classproperty
     @jsii.member(jsii_name="SSM")
     def SSM(cls) -> "InterfaceVpcEndpointAwsService":
@@ -83422,6 +84080,11 @@ class InterfaceVpcEndpointAwsService(
     def STS(cls) -> "InterfaceVpcEndpointAwsService":
         return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "STS"))
 
+    @jsii.python.classproperty
+    @jsii.member(jsii_name="STS_FIPS")
+    def STS_FIPS(cls) -> "InterfaceVpcEndpointAwsService":
+        return typing.cast("InterfaceVpcEndpointAwsService", jsii.sget(cls, "STS_FIPS"))
+
     @jsii.python.classproperty
     @jsii.member(jsii_name="SUPPLY_CHAIN")
     def SUPPLY_CHAIN(cls) -> "InterfaceVpcEndpointAwsService":
@@ -84889,7 +85552,7 @@ class LaunchTemplate(
         :param role: An IAM role to associate with the instance profile that is used by instances. The role must be assumable by the service principal ``ec2.amazonaws.com``. Note: You can provide an instanceProfile or a role, but not both. Default: - No new role is created.
         :param security_group: Security group to assign to instances created with the launch template. Default: No security group is assigned.
         :param spot_options: If this property is defined, then the Launch Template's InstanceMarketOptions will be set to use Spot instances, and the options for the Spot instances will be as defined. Default: - Instance launched with this template will not be spot instances.
-        :param user_data: The AMI that will be used by instances. Default: - This Launch Template creates a UserData based on the type of provided machineImage; no UserData is created if a machineImage is not provided
+        :param user_data: The user data to make available to the instance. Default: - This Launch Template creates a UserData based on the type of provided machineImage; no UserData is created if a machineImage is not provided
         :param version_description: A description for the first version of the launch template. The version description must be maximum 255 characters long. Default: - No description
         '''
         if __debug__:
@@ -85301,7 +85964,7 @@ class LaunchTemplateProps:
         :param role: An IAM role to associate with the instance profile that is used by instances. The role must be assumable by the service principal ``ec2.amazonaws.com``. Note: You can provide an instanceProfile or a role, but not both. Default: - No new role is created.
         :param security_group: Security group to assign to instances created with the launch template. Default: No security group is assigned.
         :param spot_options: If this property is defined, then the Launch Template's InstanceMarketOptions will be set to use Spot instances, and the options for the Spot instances will be as defined. Default: - Instance launched with this template will not be spot instances.
-        :param user_data: The AMI that will be used by instances. Default: - This Launch Template creates a UserData based on the type of provided machineImage; no UserData is created if a machineImage is not provided
+        :param user_data: The user data to make available to the instance. Default: - This Launch Template creates a UserData based on the type of provided machineImage; no UserData is created if a machineImage is not provided
         :param version_description: A description for the first version of the launch template. The version description must be maximum 255 characters long. Default: - No description
 
         :exampleMetadata: infused
@@ -85694,7 +86357,7 @@ class LaunchTemplateProps:
 
     @builtins.property
     def user_data(self) -> typing.Optional["UserData"]:
-        '''The AMI that will be used by instances.
+        '''The user data to make available to the instance.
 
         :default:
 
@@ -86512,6 +87175,8 @@ class LookupMachineImage(
     will be used on future runs. To refresh the AMI lookup, you will have to
     evict the value from the cache using the ``cdk context`` command. See
     https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information.
+    If ``props.additionalCacheKey`` is set, the context key uses that value as a discriminator
+    rather than the cached value being global across all lookups.
 
     :exampleMetadata: fixture=_generated
 
@@ -86527,6 +87192,7 @@ class LookupMachineImage(
             name="name",
         
             # the properties below are optional
+            additional_cache_key="additionalCacheKey",
             filters={
                 "filters_key": ["filters"]
             },
@@ -86540,6 +87206,7 @@ class LookupMachineImage(
         self,
         *,
         name: builtins.str,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         filters: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[builtins.str]]] = None,
         owners: typing.Optional[typing.Sequence[builtins.str]] = None,
         user_data: typing.Optional["UserData"] = None,
@@ -86547,6 +87214,7 @@ class LookupMachineImage(
     ) -> None:
         '''
         :param name: Name of the image (may contain wildcards).
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param filters: Additional filters on the AMI. Default: - No additional filters
         :param owners: Owner account IDs or aliases. Default: - All owners
         :param user_data: Custom userdata for this image. Default: - Empty user data appropriate for the platform type
@@ -86554,6 +87222,7 @@ class LookupMachineImage(
         '''
         props = LookupMachineImageProps(
             name=name,
+            additional_cache_key=additional_cache_key,
             filters=filters,
             owners=owners,
             user_data=user_data,
@@ -86564,7 +87233,7 @@ class LookupMachineImage(
 
     @jsii.member(jsii_name="getImage")
     def get_image(self, scope: _constructs_77d1e7e8.Construct) -> "MachineImageConfig":
-        '''Return the image to use in the given context.
+        '''Return the correct image.
 
         :param scope: -
         '''
@@ -86579,6 +87248,7 @@ class LookupMachineImage(
     jsii_struct_bases=[],
     name_mapping={
         "name": "name",
+        "additional_cache_key": "additionalCacheKey",
         "filters": "filters",
         "owners": "owners",
         "user_data": "userData",
@@ -86590,6 +87260,7 @@ class LookupMachineImageProps:
         self,
         *,
         name: builtins.str,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         filters: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[builtins.str]]] = None,
         owners: typing.Optional[typing.Sequence[builtins.str]] = None,
         user_data: typing.Optional["UserData"] = None,
@@ -86598,6 +87269,7 @@ class LookupMachineImageProps:
         '''Properties for looking up an image.
 
         :param name: Name of the image (may contain wildcards).
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param filters: Additional filters on the AMI. Default: - No additional filters
         :param owners: Owner account IDs or aliases. Default: - All owners
         :param user_data: Custom userdata for this image. Default: - Empty user data appropriate for the platform type
@@ -86648,6 +87320,7 @@ class LookupMachineImageProps:
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__9c44b2bd75c4714250889165d6fd2d06ab6a906b90c817320a7c5f526dcbfc2f)
             check_type(argname="argument name", value=name, expected_type=type_hints["name"])
+            check_type(argname="argument additional_cache_key", value=additional_cache_key, expected_type=type_hints["additional_cache_key"])
             check_type(argname="argument filters", value=filters, expected_type=type_hints["filters"])
             check_type(argname="argument owners", value=owners, expected_type=type_hints["owners"])
             check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
@@ -86655,6 +87328,8 @@ class LookupMachineImageProps:
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "name": name,
         }
+        if additional_cache_key is not None:
+            self._values["additional_cache_key"] = additional_cache_key
         if filters is not None:
             self._values["filters"] = filters
         if owners is not None:
@@ -86671,6 +87346,15 @@ class LookupMachineImageProps:
         assert result is not None, "Required property 'name' is missing"
         return typing.cast(builtins.str, result)
 
+    @builtins.property
+    def additional_cache_key(self) -> typing.Optional[builtins.str]:
+        '''Adds an additional discriminator to the ``cdk.context.json`` cache key.
+
+        :default: - no additional cache key
+        '''
+        result = self._values.get("additional_cache_key")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def filters(
         self,
@@ -86754,6 +87438,7 @@ class MachineImage(
         cls,
         parameter_name: builtins.str,
         *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         os: typing.Optional["OperatingSystemType"] = None,
         parameter_version: typing.Optional[builtins.str] = None,
@@ -86770,6 +87455,7 @@ class MachineImage(
         to the newest AMI ID.
 
         :param parameter_name: -
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param os: Operating system. Default: OperatingSystemType.LINUX
         :param parameter_version: The version of the SSM parameter. Default: no version specified.
@@ -86779,6 +87465,7 @@ class MachineImage(
             type_hints = typing.get_type_hints(_typecheckingstub__677afd5ea9b4639913a489ab67346107c0d290e015be12483e980d3a19e33a6e)
             check_type(argname="argument parameter_name", value=parameter_name, expected_type=type_hints["parameter_name"])
         options = SsmParameterImageOptions(
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             os=os,
             parameter_version=parameter_version,
@@ -86832,6 +87519,7 @@ class MachineImage(
     def latest_amazon_linux(
         cls,
         *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
         edition: typing.Optional[AmazonLinuxEdition] = None,
@@ -86860,6 +87548,7 @@ class MachineImage(
                generation=ec2.AmazonLinuxGeneration.AMAZON_LINUX_2
            )
 
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param cpu_type: CPU Type. Default: X86_64
         :param edition: What edition of Amazon Linux to use. Default: Standard
@@ -86874,6 +87563,7 @@ class MachineImage(
         :stability: deprecated
         '''
         props = AmazonLinuxImageProps(
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             cpu_type=cpu_type,
             edition=edition,
@@ -86896,6 +87586,7 @@ class MachineImage(
         virtualization: typing.Optional[AmazonLinuxVirt] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
         edition: typing.Optional[AmazonLinuxEdition] = None,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional["UserData"] = None,
     ) -> IMachineImage:
@@ -86911,6 +87602,7 @@ class MachineImage(
         :param virtualization: Virtualization type. Default: HVM
         :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
         :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
         '''
@@ -86920,6 +87612,7 @@ class MachineImage(
             virtualization=virtualization,
             cpu_type=cpu_type,
             edition=edition,
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             user_data=user_data,
         )
@@ -86934,6 +87627,7 @@ class MachineImage(
         kernel: typing.Optional[AmazonLinux2022Kernel] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
         edition: typing.Optional[AmazonLinuxEdition] = None,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional["UserData"] = None,
     ) -> IMachineImage:
@@ -86947,6 +87641,7 @@ class MachineImage(
         :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2022Kernel.DEFAULT
         :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
         :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
 
@@ -86958,6 +87653,7 @@ class MachineImage(
             kernel=kernel,
             cpu_type=cpu_type,
             edition=edition,
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             user_data=user_data,
         )
@@ -86972,6 +87668,7 @@ class MachineImage(
         kernel: typing.Optional[AmazonLinux2023Kernel] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
         edition: typing.Optional[AmazonLinuxEdition] = None,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional["UserData"] = None,
     ) -> IMachineImage:
@@ -86985,6 +87682,7 @@ class MachineImage(
         :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2023Kernel.DEFAULT
         :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
         :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
         '''
@@ -86992,6 +87690,7 @@ class MachineImage(
             kernel=kernel,
             cpu_type=cpu_type,
             edition=edition,
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             user_data=user_data,
         )
@@ -87029,6 +87728,7 @@ class MachineImage(
         cls,
         *,
         name: builtins.str,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         filters: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[builtins.str]]] = None,
         owners: typing.Optional[typing.Sequence[builtins.str]] = None,
         user_data: typing.Optional["UserData"] = None,
@@ -87048,6 +87748,7 @@ class MachineImage(
         This function can not be used in environment-agnostic stacks.
 
         :param name: Name of the image (may contain wildcards).
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param filters: Additional filters on the AMI. Default: - No additional filters
         :param owners: Owner account IDs or aliases. Default: - All owners
         :param user_data: Custom userdata for this image. Default: - Empty user data appropriate for the platform type
@@ -87055,6 +87756,7 @@ class MachineImage(
         '''
         props = LookupMachineImageProps(
             name=name,
+            additional_cache_key=additional_cache_key,
             filters=filters,
             owners=owners,
             user_data=user_data,
@@ -87069,6 +87771,7 @@ class MachineImage(
         cls,
         parameter_name: builtins.str,
         *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         os: typing.Optional["OperatingSystemType"] = None,
         parameter_version: typing.Optional[builtins.str] = None,
@@ -87079,6 +87782,7 @@ class MachineImage(
         The AMI ID will be resolved at instance launch time.
 
         :param parameter_name: The name of SSM parameter containing the AMI ID.
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param os: Operating system. Default: OperatingSystemType.LINUX
         :param parameter_version: The version of the SSM parameter. Default: no version specified.
@@ -87090,6 +87794,7 @@ class MachineImage(
             type_hints = typing.get_type_hints(_typecheckingstub__5e832dd82a3ef447ebf9a639dc9d6983793ce7321287fb2370dbed898b67d02a)
             check_type(argname="argument parameter_name", value=parameter_name, expected_type=type_hints["parameter_name"])
         options = SsmParameterImageOptions(
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             os=os,
             parameter_version=parameter_version,
@@ -90185,6 +90890,7 @@ class ResolveSsmParameterAtLaunchImage(
         # user_data: ec2.UserData
         
         resolve_ssm_parameter_at_launch_image = ec2.ResolveSsmParameterAtLaunchImage("parameterName",
+            additional_cache_key="additionalCacheKey",
             cached_in_context=False,
             os=ec2.OperatingSystemType.LINUX,
             parameter_version="parameterVersion",
@@ -90196,6 +90902,7 @@ class ResolveSsmParameterAtLaunchImage(
         self,
         parameter_name: builtins.str,
         *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         os: typing.Optional[OperatingSystemType] = None,
         parameter_version: typing.Optional[builtins.str] = None,
@@ -90203,6 +90910,7 @@ class ResolveSsmParameterAtLaunchImage(
     ) -> None:
         '''
         :param parameter_name: -
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param os: Operating system. Default: OperatingSystemType.LINUX
         :param parameter_version: The version of the SSM parameter. Default: no version specified.
@@ -90212,6 +90920,7 @@ class ResolveSsmParameterAtLaunchImage(
             type_hints = typing.get_type_hints(_typecheckingstub__ae85933c688e38a0dd9faa69a685488b55c8c19f918eabcacbd33c964c7bb468)
             check_type(argname="argument parameter_name", value=parameter_name, expected_type=type_hints["parameter_name"])
         props = SsmParameterImageOptions(
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             os=os,
             parameter_version=parameter_version,
@@ -91411,6 +92120,7 @@ class SpotRequestType(enum.Enum):
     jsii_type="aws-cdk-lib.aws_ec2.SsmParameterImageOptions",
     jsii_struct_bases=[],
     name_mapping={
+        "additional_cache_key": "additionalCacheKey",
         "cached_in_context": "cachedInContext",
         "os": "os",
         "parameter_version": "parameterVersion",
@@ -91421,6 +92131,7 @@ class SsmParameterImageOptions:
     def __init__(
         self,
         *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         os: typing.Optional[OperatingSystemType] = None,
         parameter_version: typing.Optional[builtins.str] = None,
@@ -91428,6 +92139,7 @@ class SsmParameterImageOptions:
     ) -> None:
         '''Properties for GenericSsmParameterImage.
 
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param os: Operating system. Default: OperatingSystemType.LINUX
         :param parameter_version: The version of the SSM parameter. Default: no version specified.
@@ -91477,11 +92189,14 @@ class SsmParameterImageOptions:
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__a03f16dc6f5eb3eb6f69587f84001af20bc314a1c46a530aa5fb21da814be237)
+            check_type(argname="argument additional_cache_key", value=additional_cache_key, expected_type=type_hints["additional_cache_key"])
             check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
             check_type(argname="argument os", value=os, expected_type=type_hints["os"])
             check_type(argname="argument parameter_version", value=parameter_version, expected_type=type_hints["parameter_version"])
             check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if additional_cache_key is not None:
+            self._values["additional_cache_key"] = additional_cache_key
         if cached_in_context is not None:
             self._values["cached_in_context"] = cached_in_context
         if os is not None:
@@ -91491,6 +92206,15 @@ class SsmParameterImageOptions:
         if user_data is not None:
             self._values["user_data"] = user_data
 
+    @builtins.property
+    def additional_cache_key(self) -> typing.Optional[builtins.str]:
+        '''Adds an additional discriminator to the ``cdk.context.json`` cache key.
+
+        :default: - no additional cache key
+        '''
+        result = self._values.get("additional_cache_key")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def cached_in_context(self) -> typing.Optional[builtins.bool]:
         '''Whether the AMI ID is cached to be stable between deployments.
@@ -93385,17 +94109,12 @@ class Volume(
 
     Example::
 
-        # instance: ec2.Instance
-        # role: iam.Role
-        
-        
-        volume = ec2.Volume(self, "Volume",
-            availability_zone="us-west-2a",
-            size=Size.gibibytes(500),
-            encrypted=True
+        ec2.Volume(self, "Volume",
+            availability_zone="us-east-1a",
+            size=Size.gibibytes(125),
+            volume_type=ec2.EbsDeviceVolumeType.GP3,
+            throughput=125
         )
-        
-        volume.grant_attach_volume(role, [instance])
     '''
 
     def __init__(
@@ -93413,6 +94132,7 @@ class Volume(
         size: typing.Optional[_Size_7b441c34] = None,
         snapshot_id: typing.Optional[builtins.str] = None,
         throughput: typing.Optional[jsii.Number] = None,
+        volume_initialization_rate: typing.Optional[_Size_7b441c34] = None,
         volume_name: typing.Optional[builtins.str] = None,
         volume_type: typing.Optional[EbsDeviceVolumeType] = None,
     ) -> None:
@@ -93423,13 +94143,14 @@ class Volume(
         :param auto_enable_io: Indicates whether the volume is auto-enabled for I/O operations. By default, Amazon EBS disables I/O to the volume from attached EC2 instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O. Default: false
         :param enable_multi_attach: Indicates whether Amazon EBS Multi-Attach is enabled. See `Considerations and limitations <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volumes-multi.html#considerations>`_ for the constraints of multi-attach. Default: false
         :param encrypted: Specifies whether the volume should be encrypted. The effect of setting the encryption state to true depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Encryption by Default <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default>`_ in the Amazon Elastic Compute Cloud User Guide. Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see `Supported Instance Types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_. Default: false
-        :param encryption_key: The customer-managed encryption key that is used to encrypt the Volume. The encrypted property must be true if this is provided. Note: If using an ``aws-kms.IKey`` created from a ``aws-kms.Key.fromKeyArn()`` here, then the KMS key **must** have the following in its Key policy; otherwise, the Volume will fail to create:: { "Effect": "Allow", "Principal": { "AWS": "<arn for your account-user> ex: arn:aws:iam::00000000000:root" }, "Resource": "*", "Action": [ "kms:DescribeKey", "kms:GenerateDataKeyWithoutPlainText", ], "Condition": { "StringEquals": { "kms:ViaService": "ec2.<Region>.amazonaws.com", (eg: ec2.us-east-1.amazonaws.com) "kms:CallerAccount": "0000000000" (your account ID) } } } Default: The default KMS key for the account, region, and EC2 service is used.
+        :param encryption_key: The customer-managed encryption key that is used to encrypt the Volume. The encrypted property must be true if this is provided. Note: If using an ``aws-kms.IKey`` created from a ``aws-kms.Key.fromKeyArn()`` here, then the KMS key **must** have the following in its Key policy; otherwise, the Volume will fail to create:: { "Effect": "Allow", "Principal": { "AWS": "<arn for your account-user> ex: arn:aws:iam::00000000000:root" }, "Resource": "*", "Action": [ "kms:DescribeKey", "kms:GenerateDataKeyWithoutPlainText", ], "Condition": { "StringEquals": { "kms:ViaService": "ec2.<Region>.amazonaws.com", (eg: ec2.us-east-1.amazonaws.com) "kms:CallerAccount": "0000000000" (your account ID) } } } Default: - The default KMS key for the account, region, and EC2 service is used.
         :param iops: The number of I/O operations per second (IOPS) to provision for the volume. The maximum ratio is 50 IOPS/GiB for PROVISIONED_IOPS_SSD, and 500 IOPS/GiB for both PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for more information. This parameter is valid only for PROVISIONED_IOPS_SSD, PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3 volumes. Default: None -- Required for io1 and io2 volumes. The default for gp3 volumes is 3,000 IOPS if omitted.
         :param removal_policy: Policy to apply when the volume is removed from the stack. Default: RemovalPolicy.RETAIN
-        :param size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for details on the allowable size for each type of volume. Default: If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.
-        :param snapshot_id: The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size. Default: The EBS volume is not created from a snapshot.
+        :param size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for details on the allowable size for each type of volume. Default: - If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.
+        :param snapshot_id: The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size. Default: - The EBS volume is not created from a snapshot.
         :param throughput: The throughput that the volume supports, in MiB/s Takes a minimum of 125 and maximum of 1000. Default: - 125 MiB/s. Only valid on gp3 volumes.
-        :param volume_name: The value of the physicalName property of this resource. Default: The physical name will be allocated by CloudFormation at deployment time
+        :param volume_initialization_rate: Specifies the Amazon EBS Provisioned Rate for Volume Initialization (volume initialization rate), at which to download the snapshot blocks from Amazon S3 to the volume. Valid range is between 100 and 300 MiB/s. This parameter is supported only for volumes created from snapshots. Default: undefined - The volume initialization rate is not set.
+        :param volume_name: The value of the physicalName property of this resource. Default: - The physical name will be allocated by CloudFormation at deployment time
         :param volume_type: The type of the volume; what type of storage to use to form the EBS Volume. Default: ``EbsDeviceVolumeType.GENERAL_PURPOSE_SSD``
         '''
         if __debug__:
@@ -93447,6 +94168,7 @@ class Volume(
             size=size,
             snapshot_id=snapshot_id,
             throughput=throughput,
+            volume_initialization_rate=volume_initialization_rate,
             volume_name=volume_name,
             volume_type=volume_type,
         )
@@ -93592,6 +94314,7 @@ class Volume(
         size: typing.Optional[_Size_7b441c34] = None,
         snapshot_id: typing.Optional[builtins.str] = None,
         throughput: typing.Optional[jsii.Number] = None,
+        volume_initialization_rate: typing.Optional[_Size_7b441c34] = None,
         volume_name: typing.Optional[builtins.str] = None,
         volume_type: typing.Optional[EbsDeviceVolumeType] = None,
     ) -> None:
@@ -93600,13 +94323,14 @@ class Volume(
         :param auto_enable_io: Indicates whether the volume is auto-enabled for I/O operations. By default, Amazon EBS disables I/O to the volume from attached EC2 instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O. Default: false
         :param enable_multi_attach: Indicates whether Amazon EBS Multi-Attach is enabled. See `Considerations and limitations <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volumes-multi.html#considerations>`_ for the constraints of multi-attach. Default: false
         :param encrypted: Specifies whether the volume should be encrypted. The effect of setting the encryption state to true depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Encryption by Default <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default>`_ in the Amazon Elastic Compute Cloud User Guide. Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see `Supported Instance Types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_. Default: false
-        :param encryption_key: The customer-managed encryption key that is used to encrypt the Volume. The encrypted property must be true if this is provided. Note: If using an ``aws-kms.IKey`` created from a ``aws-kms.Key.fromKeyArn()`` here, then the KMS key **must** have the following in its Key policy; otherwise, the Volume will fail to create:: { "Effect": "Allow", "Principal": { "AWS": "<arn for your account-user> ex: arn:aws:iam::00000000000:root" }, "Resource": "*", "Action": [ "kms:DescribeKey", "kms:GenerateDataKeyWithoutPlainText", ], "Condition": { "StringEquals": { "kms:ViaService": "ec2.<Region>.amazonaws.com", (eg: ec2.us-east-1.amazonaws.com) "kms:CallerAccount": "0000000000" (your account ID) } } } Default: The default KMS key for the account, region, and EC2 service is used.
+        :param encryption_key: The customer-managed encryption key that is used to encrypt the Volume. The encrypted property must be true if this is provided. Note: If using an ``aws-kms.IKey`` created from a ``aws-kms.Key.fromKeyArn()`` here, then the KMS key **must** have the following in its Key policy; otherwise, the Volume will fail to create:: { "Effect": "Allow", "Principal": { "AWS": "<arn for your account-user> ex: arn:aws:iam::00000000000:root" }, "Resource": "*", "Action": [ "kms:DescribeKey", "kms:GenerateDataKeyWithoutPlainText", ], "Condition": { "StringEquals": { "kms:ViaService": "ec2.<Region>.amazonaws.com", (eg: ec2.us-east-1.amazonaws.com) "kms:CallerAccount": "0000000000" (your account ID) } } } Default: - The default KMS key for the account, region, and EC2 service is used.
         :param iops: The number of I/O operations per second (IOPS) to provision for the volume. The maximum ratio is 50 IOPS/GiB for PROVISIONED_IOPS_SSD, and 500 IOPS/GiB for both PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for more information. This parameter is valid only for PROVISIONED_IOPS_SSD, PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3 volumes. Default: None -- Required for io1 and io2 volumes. The default for gp3 volumes is 3,000 IOPS if omitted.
         :param removal_policy: Policy to apply when the volume is removed from the stack. Default: RemovalPolicy.RETAIN
-        :param size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for details on the allowable size for each type of volume. Default: If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.
-        :param snapshot_id: The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size. Default: The EBS volume is not created from a snapshot.
+        :param size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for details on the allowable size for each type of volume. Default: - If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.
+        :param snapshot_id: The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size. Default: - The EBS volume is not created from a snapshot.
         :param throughput: The throughput that the volume supports, in MiB/s Takes a minimum of 125 and maximum of 1000. Default: - 125 MiB/s. Only valid on gp3 volumes.
-        :param volume_name: The value of the physicalName property of this resource. Default: The physical name will be allocated by CloudFormation at deployment time
+        :param volume_initialization_rate: Specifies the Amazon EBS Provisioned Rate for Volume Initialization (volume initialization rate), at which to download the snapshot blocks from Amazon S3 to the volume. Valid range is between 100 and 300 MiB/s. This parameter is supported only for volumes created from snapshots. Default: undefined - The volume initialization rate is not set.
+        :param volume_name: The value of the physicalName property of this resource. Default: - The physical name will be allocated by CloudFormation at deployment time
         :param volume_type: The type of the volume; what type of storage to use to form the EBS Volume. Default: ``EbsDeviceVolumeType.GENERAL_PURPOSE_SSD``
         '''
         props = VolumeProps(
@@ -93620,6 +94344,7 @@ class Volume(
             size=size,
             snapshot_id=snapshot_id,
             throughput=throughput,
+            volume_initialization_rate=volume_initialization_rate,
             volume_name=volume_name,
             volume_type=volume_type,
         )
@@ -93754,6 +94479,7 @@ class VolumeAttributes:
         "size": "size",
         "snapshot_id": "snapshotId",
         "throughput": "throughput",
+        "volume_initialization_rate": "volumeInitializationRate",
         "volume_name": "volumeName",
         "volume_type": "volumeType",
     },
@@ -93772,6 +94498,7 @@ class VolumeProps:
         size: typing.Optional[_Size_7b441c34] = None,
         snapshot_id: typing.Optional[builtins.str] = None,
         throughput: typing.Optional[jsii.Number] = None,
+        volume_initialization_rate: typing.Optional[_Size_7b441c34] = None,
         volume_name: typing.Optional[builtins.str] = None,
         volume_type: typing.Optional[EbsDeviceVolumeType] = None,
     ) -> None:
@@ -93781,30 +94508,26 @@ class VolumeProps:
         :param auto_enable_io: Indicates whether the volume is auto-enabled for I/O operations. By default, Amazon EBS disables I/O to the volume from attached EC2 instances when it determines that a volume's data is potentially inconsistent. If the consistency of the volume is not a concern, and you prefer that the volume be made available immediately if it's impaired, you can configure the volume to automatically enable I/O. Default: false
         :param enable_multi_attach: Indicates whether Amazon EBS Multi-Attach is enabled. See `Considerations and limitations <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/ebs-volumes-multi.html#considerations>`_ for the constraints of multi-attach. Default: false
         :param encrypted: Specifies whether the volume should be encrypted. The effect of setting the encryption state to true depends on the volume origin (new or from a snapshot), starting encryption state, ownership, and whether encryption by default is enabled. For more information, see `Encryption by Default <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#encryption-by-default>`_ in the Amazon Elastic Compute Cloud User Guide. Encrypted Amazon EBS volumes must be attached to instances that support Amazon EBS encryption. For more information, see `Supported Instance Types <https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/EBSEncryption.html#EBSEncryption_supported_instances>`_. Default: false
-        :param encryption_key: The customer-managed encryption key that is used to encrypt the Volume. The encrypted property must be true if this is provided. Note: If using an ``aws-kms.IKey`` created from a ``aws-kms.Key.fromKeyArn()`` here, then the KMS key **must** have the following in its Key policy; otherwise, the Volume will fail to create:: { "Effect": "Allow", "Principal": { "AWS": "<arn for your account-user> ex: arn:aws:iam::00000000000:root" }, "Resource": "*", "Action": [ "kms:DescribeKey", "kms:GenerateDataKeyWithoutPlainText", ], "Condition": { "StringEquals": { "kms:ViaService": "ec2.<Region>.amazonaws.com", (eg: ec2.us-east-1.amazonaws.com) "kms:CallerAccount": "0000000000" (your account ID) } } } Default: The default KMS key for the account, region, and EC2 service is used.
+        :param encryption_key: The customer-managed encryption key that is used to encrypt the Volume. The encrypted property must be true if this is provided. Note: If using an ``aws-kms.IKey`` created from a ``aws-kms.Key.fromKeyArn()`` here, then the KMS key **must** have the following in its Key policy; otherwise, the Volume will fail to create:: { "Effect": "Allow", "Principal": { "AWS": "<arn for your account-user> ex: arn:aws:iam::00000000000:root" }, "Resource": "*", "Action": [ "kms:DescribeKey", "kms:GenerateDataKeyWithoutPlainText", ], "Condition": { "StringEquals": { "kms:ViaService": "ec2.<Region>.amazonaws.com", (eg: ec2.us-east-1.amazonaws.com) "kms:CallerAccount": "0000000000" (your account ID) } } } Default: - The default KMS key for the account, region, and EC2 service is used.
         :param iops: The number of I/O operations per second (IOPS) to provision for the volume. The maximum ratio is 50 IOPS/GiB for PROVISIONED_IOPS_SSD, and 500 IOPS/GiB for both PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for more information. This parameter is valid only for PROVISIONED_IOPS_SSD, PROVISIONED_IOPS_SSD_IO2 and GENERAL_PURPOSE_SSD_GP3 volumes. Default: None -- Required for io1 and io2 volumes. The default for gp3 volumes is 3,000 IOPS if omitted.
         :param removal_policy: Policy to apply when the volume is removed from the stack. Default: RemovalPolicy.RETAIN
-        :param size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for details on the allowable size for each type of volume. Default: If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.
-        :param snapshot_id: The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size. Default: The EBS volume is not created from a snapshot.
+        :param size: The size of the volume, in GiBs. You must specify either a snapshot ID or a volume size. See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html for details on the allowable size for each type of volume. Default: - If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.
+        :param snapshot_id: The snapshot from which to create the volume. You must specify either a snapshot ID or a volume size. Default: - The EBS volume is not created from a snapshot.
         :param throughput: The throughput that the volume supports, in MiB/s Takes a minimum of 125 and maximum of 1000. Default: - 125 MiB/s. Only valid on gp3 volumes.
-        :param volume_name: The value of the physicalName property of this resource. Default: The physical name will be allocated by CloudFormation at deployment time
+        :param volume_initialization_rate: Specifies the Amazon EBS Provisioned Rate for Volume Initialization (volume initialization rate), at which to download the snapshot blocks from Amazon S3 to the volume. Valid range is between 100 and 300 MiB/s. This parameter is supported only for volumes created from snapshots. Default: undefined - The volume initialization rate is not set.
+        :param volume_name: The value of the physicalName property of this resource. Default: - The physical name will be allocated by CloudFormation at deployment time
         :param volume_type: The type of the volume; what type of storage to use to form the EBS Volume. Default: ``EbsDeviceVolumeType.GENERAL_PURPOSE_SSD``
 
         :exampleMetadata: infused
 
         Example::
 
-            # instance: ec2.Instance
-            # role: iam.Role
-            
-            
-            volume = ec2.Volume(self, "Volume",
-                availability_zone="us-west-2a",
-                size=Size.gibibytes(500),
-                encrypted=True
+            ec2.Volume(self, "Volume",
+                availability_zone="us-east-1a",
+                size=Size.gibibytes(125),
+                volume_type=ec2.EbsDeviceVolumeType.GP3,
+                throughput=125
             )
-            
-            volume.grant_attach_volume(role, [instance])
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__fd11037db838f64c74264a09154568b99584932152ae7679e47051119dcaf1ed)
@@ -93818,6 +94541,7 @@ class VolumeProps:
             check_type(argname="argument size", value=size, expected_type=type_hints["size"])
             check_type(argname="argument snapshot_id", value=snapshot_id, expected_type=type_hints["snapshot_id"])
             check_type(argname="argument throughput", value=throughput, expected_type=type_hints["throughput"])
+            check_type(argname="argument volume_initialization_rate", value=volume_initialization_rate, expected_type=type_hints["volume_initialization_rate"])
             check_type(argname="argument volume_name", value=volume_name, expected_type=type_hints["volume_name"])
             check_type(argname="argument volume_type", value=volume_type, expected_type=type_hints["volume_type"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
@@ -93841,6 +94565,8 @@ class VolumeProps:
             self._values["snapshot_id"] = snapshot_id
         if throughput is not None:
             self._values["throughput"] = throughput
+        if volume_initialization_rate is not None:
+            self._values["volume_initialization_rate"] = volume_initialization_rate
         if volume_name is not None:
             self._values["volume_name"] = volume_name
         if volume_type is not None:
@@ -93922,7 +94648,7 @@ class VolumeProps:
              }
            }
 
-        :default: The default KMS key for the account, region, and EC2 service is used.
+        :default: - The default KMS key for the account, region, and EC2 service is used.
         '''
         result = self._values.get("encryption_key")
         return typing.cast(typing.Optional[_IKey_5f11635f], result)
@@ -93960,7 +94686,7 @@ class VolumeProps:
         See https://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-resource-ec2-volume.html
         for details on the allowable size for each type of volume.
 
-        :default: If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.
+        :default: - If you're creating the volume from a snapshot and don't specify a volume size, the default is the snapshot size.
         '''
         result = self._values.get("size")
         return typing.cast(typing.Optional[_Size_7b441c34], result)
@@ -93971,7 +94697,7 @@ class VolumeProps:
 
         You must specify either a snapshot ID or a volume size.
 
-        :default: The EBS volume is not created from a snapshot.
+        :default: - The EBS volume is not created from a snapshot.
         '''
         result = self._values.get("snapshot_id")
         return typing.cast(typing.Optional[builtins.str], result)
@@ -93987,11 +94713,26 @@ class VolumeProps:
         result = self._values.get("throughput")
         return typing.cast(typing.Optional[jsii.Number], result)
 
+    @builtins.property
+    def volume_initialization_rate(self) -> typing.Optional[_Size_7b441c34]:
+        '''Specifies the Amazon EBS Provisioned Rate for Volume Initialization (volume initialization rate), at which to download the snapshot blocks from Amazon S3 to the volume.
+
+        Valid range is between 100 and 300 MiB/s.
+
+        This parameter is supported only for volumes created from snapshots.
+
+        :default: undefined - The volume initialization rate is not set.
+
+        :see: https://docs.aws.amazon.com/ebs/latest/userguide/initalize-volume.html#volume-initialization-rate
+        '''
+        result = self._values.get("volume_initialization_rate")
+        return typing.cast(typing.Optional[_Size_7b441c34], result)
+
     @builtins.property
     def volume_name(self) -> typing.Optional[builtins.str]:
         '''The value of the physicalName property of this resource.
 
-        :default: The physical name will be allocated by CloudFormation at deployment time
+        :default: - The physical name will be allocated by CloudFormation at deployment time
         '''
         result = self._values.get("volume_name")
         return typing.cast(typing.Optional[builtins.str], result)
@@ -97750,6 +98491,7 @@ class WindowsVersion(enum.Enum):
     jsii_type="aws-cdk-lib.aws_ec2.AmazonLinux2022ImageSsmParameterProps",
     jsii_struct_bases=[AmazonLinuxImageSsmParameterCommonOptions],
     name_mapping={
+        "additional_cache_key": "additionalCacheKey",
         "cached_in_context": "cachedInContext",
         "user_data": "userData",
         "cpu_type": "cpuType",
@@ -97761,6 +98503,7 @@ class AmazonLinux2022ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOp
     def __init__(
         self,
         *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional[UserData] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
@@ -97769,6 +98512,7 @@ class AmazonLinux2022ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOp
     ) -> None:
         '''Properties specific to al2022 images.
 
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
         :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
@@ -97787,6 +98531,7 @@ class AmazonLinux2022ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOp
             # user_data: ec2.UserData
             
             amazon_linux2022_image_ssm_parameter_props = ec2.AmazonLinux2022ImageSsmParameterProps(
+                additional_cache_key="additionalCacheKey",
                 cached_in_context=False,
                 cpu_type=ec2.AmazonLinuxCpuType.ARM_64,
                 edition=ec2.AmazonLinuxEdition.STANDARD,
@@ -97796,12 +98541,15 @@ class AmazonLinux2022ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOp
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__968329b6e3d88dbd1836e6234bc305a96628c570666cc423d4eeccc95dc92ab6)
+            check_type(argname="argument additional_cache_key", value=additional_cache_key, expected_type=type_hints["additional_cache_key"])
             check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
             check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
             check_type(argname="argument cpu_type", value=cpu_type, expected_type=type_hints["cpu_type"])
             check_type(argname="argument edition", value=edition, expected_type=type_hints["edition"])
             check_type(argname="argument kernel", value=kernel, expected_type=type_hints["kernel"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if additional_cache_key is not None:
+            self._values["additional_cache_key"] = additional_cache_key
         if cached_in_context is not None:
             self._values["cached_in_context"] = cached_in_context
         if user_data is not None:
@@ -97813,6 +98561,15 @@ class AmazonLinux2022ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOp
         if kernel is not None:
             self._values["kernel"] = kernel
 
+    @builtins.property
+    def additional_cache_key(self) -> typing.Optional[builtins.str]:
+        '''Adds an additional discriminator to the ``cdk.context.json`` cache key.
+
+        :default: - no additional cache key
+        '''
+        result = self._values.get("additional_cache_key")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def cached_in_context(self) -> typing.Optional[builtins.bool]:
         '''Whether the AMI ID is cached to be stable between deployments.
@@ -97888,6 +98645,7 @@ class AmazonLinux2022ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOp
     jsii_type="aws-cdk-lib.aws_ec2.AmazonLinux2023ImageSsmParameterProps",
     jsii_struct_bases=[AmazonLinuxImageSsmParameterCommonOptions],
     name_mapping={
+        "additional_cache_key": "additionalCacheKey",
         "cached_in_context": "cachedInContext",
         "user_data": "userData",
         "cpu_type": "cpuType",
@@ -97899,6 +98657,7 @@ class AmazonLinux2023ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOp
     def __init__(
         self,
         *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional[UserData] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
@@ -97907,6 +98666,7 @@ class AmazonLinux2023ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOp
     ) -> None:
         '''Properties specific to al2023 images.
 
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
         :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
@@ -97918,32 +98678,52 @@ class AmazonLinux2023ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOp
         Example::
 
             # vpc: ec2.Vpc
+            # instance_type: ec2.InstanceType
             
             
-            ec2.Instance(self, "LatestAl2023",
+            # Amazon Linux 2
+            ec2.Instance(self, "Instance2",
                 vpc=vpc,
-                instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
-                machine_image=ec2.MachineImage.latest_amazon_linux2023(
-                    cached_in_context=True
+                instance_type=instance_type,
+                machine_image=ec2.MachineImage.latest_amazon_linux2()
+            )
+            
+            # Amazon Linux 2 with kernel 5.x
+            ec2.Instance(self, "Instance3",
+                vpc=vpc,
+                instance_type=instance_type,
+                machine_image=ec2.MachineImage.latest_amazon_linux2(
+                    kernel=ec2.AmazonLinux2Kernel.KERNEL_5_10
                 )
             )
             
-            # or
-            ec2.Instance(self, "LatestAl2023",
+            # Amazon Linux 2023
+            ec2.Instance(self, "Instance4",
+                vpc=vpc,
+                instance_type=instance_type,
+                machine_image=ec2.MachineImage.latest_amazon_linux2023()
+            )
+            
+            # Graviton 3 Processor
+            ec2.Instance(self, "Instance5",
                 vpc=vpc,
                 instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
-                # context cache is turned on by default
-                machine_image=ec2.AmazonLinux2023ImageSsmParameter()
+                machine_image=ec2.MachineImage.latest_amazon_linux2023(
+                    cpu_type=ec2.AmazonLinuxCpuType.ARM_64
+                )
             )
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__d2a291560388da3a1deca6cc63773b445813e32521bbcf4ece1d3a557e2eda6b)
+            check_type(argname="argument additional_cache_key", value=additional_cache_key, expected_type=type_hints["additional_cache_key"])
             check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
             check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
             check_type(argname="argument cpu_type", value=cpu_type, expected_type=type_hints["cpu_type"])
             check_type(argname="argument edition", value=edition, expected_type=type_hints["edition"])
             check_type(argname="argument kernel", value=kernel, expected_type=type_hints["kernel"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if additional_cache_key is not None:
+            self._values["additional_cache_key"] = additional_cache_key
         if cached_in_context is not None:
             self._values["cached_in_context"] = cached_in_context
         if user_data is not None:
@@ -97955,6 +98735,15 @@ class AmazonLinux2023ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOp
         if kernel is not None:
             self._values["kernel"] = kernel
 
+    @builtins.property
+    def additional_cache_key(self) -> typing.Optional[builtins.str]:
+        '''Adds an additional discriminator to the ``cdk.context.json`` cache key.
+
+        :default: - no additional cache key
+        '''
+        result = self._values.get("additional_cache_key")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def cached_in_context(self) -> typing.Optional[builtins.bool]:
         '''Whether the AMI ID is cached to be stable between deployments.
@@ -98030,6 +98819,7 @@ class AmazonLinux2023ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOp
     jsii_type="aws-cdk-lib.aws_ec2.AmazonLinux2ImageSsmParameterProps",
     jsii_struct_bases=[AmazonLinuxImageSsmParameterCommonOptions],
     name_mapping={
+        "additional_cache_key": "additionalCacheKey",
         "cached_in_context": "cachedInContext",
         "user_data": "userData",
         "cpu_type": "cpuType",
@@ -98043,6 +98833,7 @@ class AmazonLinux2ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOptio
     def __init__(
         self,
         *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional[UserData] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
@@ -98053,6 +98844,7 @@ class AmazonLinux2ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOptio
     ) -> None:
         '''Properties specific to amzn2 images.
 
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
         :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
@@ -98103,6 +98895,7 @@ class AmazonLinux2ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOptio
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__8aa3dd8e9489482da5f68eebe827af2a2367490c7299028616bae30c26efbd55)
+            check_type(argname="argument additional_cache_key", value=additional_cache_key, expected_type=type_hints["additional_cache_key"])
             check_type(argname="argument cached_in_context", value=cached_in_context, expected_type=type_hints["cached_in_context"])
             check_type(argname="argument user_data", value=user_data, expected_type=type_hints["user_data"])
             check_type(argname="argument cpu_type", value=cpu_type, expected_type=type_hints["cpu_type"])
@@ -98111,6 +98904,8 @@ class AmazonLinux2ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOptio
             check_type(argname="argument storage", value=storage, expected_type=type_hints["storage"])
             check_type(argname="argument virtualization", value=virtualization, expected_type=type_hints["virtualization"])
         self._values: typing.Dict[builtins.str, typing.Any] = {}
+        if additional_cache_key is not None:
+            self._values["additional_cache_key"] = additional_cache_key
         if cached_in_context is not None:
             self._values["cached_in_context"] = cached_in_context
         if user_data is not None:
@@ -98126,6 +98921,15 @@ class AmazonLinux2ImageSsmParameterProps(AmazonLinuxImageSsmParameterCommonOptio
         if virtualization is not None:
             self._values["virtualization"] = virtualization
 
+    @builtins.property
+    def additional_cache_key(self) -> typing.Optional[builtins.str]:
+        '''Adds an additional discriminator to the ``cdk.context.json`` cache key.
+
+        :default: - no additional cache key
+        '''
+        result = self._values.get("additional_cache_key")
+        return typing.cast(typing.Optional[builtins.str], result)
+
     @builtins.property
     def cached_in_context(self) -> typing.Optional[builtins.bool]:
         '''Whether the AMI ID is cached to be stable between deployments.
@@ -98224,16 +99028,19 @@ class AmazonLinuxImageSsmParameterBase(
         self,
         *,
         parameter_name: builtins.str,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional[UserData] = None,
     ) -> None:
         '''
         :param parameter_name: The name of the SSM parameter that contains the AMI value.
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
         '''
         props = AmazonLinuxImageSsmParameterBaseProps(
             parameter_name=parameter_name,
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             user_data=user_data,
         )
@@ -102336,6 +103143,7 @@ class AmazonLinux2022ImageSsmParameter(
         # user_data: ec2.UserData
         
         amazon_linux2022_image_ssm_parameter = ec2.AmazonLinux2022ImageSsmParameter(
+            additional_cache_key="additionalCacheKey",
             cached_in_context=False,
             cpu_type=ec2.AmazonLinuxCpuType.ARM_64,
             edition=ec2.AmazonLinuxEdition.STANDARD,
@@ -102350,6 +103158,7 @@ class AmazonLinux2022ImageSsmParameter(
         kernel: typing.Optional[AmazonLinux2022Kernel] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
         edition: typing.Optional[AmazonLinuxEdition] = None,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional[UserData] = None,
     ) -> None:
@@ -102357,6 +103166,7 @@ class AmazonLinux2022ImageSsmParameter(
         :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2022Kernel.DEFAULT
         :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
         :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
         '''
@@ -102364,6 +103174,7 @@ class AmazonLinux2022ImageSsmParameter(
             kernel=kernel,
             cpu_type=cpu_type,
             edition=edition,
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             user_data=user_data,
         )
@@ -102378,6 +103189,7 @@ class AmazonLinux2022ImageSsmParameter(
         kernel: typing.Optional[AmazonLinux2022Kernel] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
         edition: typing.Optional[AmazonLinuxEdition] = None,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional[UserData] = None,
     ) -> builtins.str:
@@ -102397,6 +103209,7 @@ class AmazonLinux2022ImageSsmParameter(
         :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2022Kernel.DEFAULT
         :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
         :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
         '''
@@ -102404,6 +103217,7 @@ class AmazonLinux2022ImageSsmParameter(
             kernel=kernel,
             cpu_type=cpu_type,
             edition=edition,
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             user_data=user_data,
         )
@@ -102428,17 +103242,18 @@ class AmazonLinux2023ImageSsmParameter(
         ec2.Instance(self, "LatestAl2023",
             vpc=vpc,
             instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
-            machine_image=ec2.MachineImage.latest_amazon_linux2023(
-                cached_in_context=True
+            # context cache is turned on by default
+            machine_image=ec2.AmazonLinux2023ImageSsmParameter(
+                kernel=ec2.AmazonLinux2023Kernel.CDK_LATEST
             )
         )
         
         # or
+        
         ec2.Instance(self, "LatestAl2023",
             vpc=vpc,
             instance_type=ec2.InstanceType.of(ec2.InstanceClass.C7G, ec2.InstanceSize.LARGE),
-            # context cache is turned on by default
-            machine_image=ec2.AmazonLinux2023ImageSsmParameter()
+            machine_image=ec2.MachineImage.latest_amazon_linux2023()
         )
     '''
 
@@ -102448,6 +103263,7 @@ class AmazonLinux2023ImageSsmParameter(
         kernel: typing.Optional[AmazonLinux2023Kernel] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
         edition: typing.Optional[AmazonLinuxEdition] = None,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional[UserData] = None,
     ) -> None:
@@ -102455,6 +103271,7 @@ class AmazonLinux2023ImageSsmParameter(
         :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2023Kernel.DEFAULT
         :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
         :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
         '''
@@ -102462,6 +103279,7 @@ class AmazonLinux2023ImageSsmParameter(
             kernel=kernel,
             cpu_type=cpu_type,
             edition=edition,
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             user_data=user_data,
         )
@@ -102476,6 +103294,7 @@ class AmazonLinux2023ImageSsmParameter(
         kernel: typing.Optional[AmazonLinux2023Kernel] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
         edition: typing.Optional[AmazonLinuxEdition] = None,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional[UserData] = None,
     ) -> builtins.str:
@@ -102495,6 +103314,7 @@ class AmazonLinux2023ImageSsmParameter(
         :param kernel: What kernel version of Amazon Linux to use. Default: AmazonLinux2023Kernel.DEFAULT
         :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
         :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
         '''
@@ -102502,6 +103322,7 @@ class AmazonLinux2023ImageSsmParameter(
             kernel=kernel,
             cpu_type=cpu_type,
             edition=edition,
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             user_data=user_data,
         )
@@ -102528,6 +103349,7 @@ class AmazonLinux2ImageSsmParameter(
         # user_data: ec2.UserData
         
         amazon_linux2_image_ssm_parameter = ec2.AmazonLinux2ImageSsmParameter(
+            additional_cache_key="additionalCacheKey",
             cached_in_context=False,
             cpu_type=ec2.AmazonLinuxCpuType.ARM_64,
             edition=ec2.AmazonLinuxEdition.STANDARD,
@@ -102546,6 +103368,7 @@ class AmazonLinux2ImageSsmParameter(
         virtualization: typing.Optional[AmazonLinuxVirt] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
         edition: typing.Optional[AmazonLinuxEdition] = None,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional[UserData] = None,
     ) -> None:
@@ -102555,6 +103378,7 @@ class AmazonLinux2ImageSsmParameter(
         :param virtualization: Virtualization type. Default: HVM
         :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
         :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
         '''
@@ -102564,6 +103388,7 @@ class AmazonLinux2ImageSsmParameter(
             virtualization=virtualization,
             cpu_type=cpu_type,
             edition=edition,
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             user_data=user_data,
         )
@@ -102580,6 +103405,7 @@ class AmazonLinux2ImageSsmParameter(
         virtualization: typing.Optional[AmazonLinuxVirt] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
         edition: typing.Optional[AmazonLinuxEdition] = None,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         user_data: typing.Optional[UserData] = None,
     ) -> builtins.str:
@@ -102601,6 +103427,7 @@ class AmazonLinux2ImageSsmParameter(
         :param virtualization: Virtualization type. Default: HVM
         :param cpu_type: CPU Type. Default: AmazonLinuxCpuType.X86_64
         :param edition: What edition of Amazon Linux to use. Default: AmazonLinuxEdition.Standard
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param user_data: Initial user data. Default: - Empty UserData for Linux machines
         '''
@@ -102610,6 +103437,7 @@ class AmazonLinux2ImageSsmParameter(
             virtualization=virtualization,
             cpu_type=cpu_type,
             edition=edition,
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             user_data=user_data,
         )
@@ -102654,6 +103482,7 @@ class AmazonLinuxImage(
     def __init__(
         self,
         *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
         edition: typing.Optional[AmazonLinuxEdition] = None,
@@ -102664,6 +103493,7 @@ class AmazonLinuxImage(
         virtualization: typing.Optional[AmazonLinuxVirt] = None,
     ) -> None:
         '''
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param cpu_type: CPU Type. Default: X86_64
         :param edition: What edition of Amazon Linux to use. Default: Standard
@@ -102674,6 +103504,7 @@ class AmazonLinuxImage(
         :param virtualization: Virtualization type. Default: HVM
         '''
         props = AmazonLinuxImageProps(
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             cpu_type=cpu_type,
             edition=edition,
@@ -102691,6 +103522,7 @@ class AmazonLinuxImage(
     def ssm_parameter_name(
         cls,
         *,
+        additional_cache_key: typing.Optional[builtins.str] = None,
         cached_in_context: typing.Optional[builtins.bool] = None,
         cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
         edition: typing.Optional[AmazonLinuxEdition] = None,
@@ -102702,6 +103534,7 @@ class AmazonLinuxImage(
     ) -> builtins.str:
         '''Return the SSM parameter name that will contain the Amazon Linux image with the given attributes.
 
+        :param additional_cache_key: Adds an additional discriminator to the ``cdk.context.json`` cache key. Default: - no additional cache key
         :param cached_in_context: Whether the AMI ID is cached to be stable between deployments. By default, the newest image is used on each deployment. This will cause instances to be replaced whenever a new version is released, and may cause downtime if there aren't enough running instances in the AutoScalingGroup to reschedule the tasks on. If set to true, the AMI ID will be cached in ``cdk.context.json`` and the same value will be used on future runs. Your instances will not be replaced but your AMI version will grow old over time. To refresh the AMI lookup, you will have to evict the value from the cache using the ``cdk context`` command. See https://docs.aws.amazon.com/cdk/latest/guide/context.html for more information. Can not be set to ``true`` in environment-agnostic stacks. Default: false
         :param cpu_type: CPU Type. Default: X86_64
         :param edition: What edition of Amazon Linux to use. Default: Standard
@@ -102712,6 +103545,7 @@ class AmazonLinuxImage(
         :param virtualization: Virtualization type. Default: HVM
         '''
         props = AmazonLinuxImageProps(
+            additional_cache_key=additional_cache_key,
             cached_in_context=cached_in_context,
             cpu_type=cpu_type,
             edition=edition,
@@ -103680,6 +104514,7 @@ def _typecheckingstub__3d9d80aebc17990a8f3419f9444ec1fdd3e5bc1c150c3db0d42eda409
 
 def _typecheckingstub__dd95a518c06563a07debc9bf1ca51713b747cf64bded6f7cc81a28680d7ea9fc(
     *,
+    additional_cache_key: typing.Optional[builtins.str] = None,
     cached_in_context: typing.Optional[builtins.bool] = None,
     cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
     edition: typing.Optional[AmazonLinuxEdition] = None,
@@ -103694,6 +104529,7 @@ def _typecheckingstub__dd95a518c06563a07debc9bf1ca51713b747cf64bded6f7cc81a28680
 
 def _typecheckingstub__08eb71b09afb1d361b3f043a5c2d7d4be91f84b114302afefc8a69963ee6333f(
     *,
+    additional_cache_key: typing.Optional[builtins.str] = None,
     cached_in_context: typing.Optional[builtins.bool] = None,
     user_data: typing.Optional[UserData] = None,
 ) -> None:
@@ -103702,6 +104538,7 @@ def _typecheckingstub__08eb71b09afb1d361b3f043a5c2d7d4be91f84b114302afefc8a69963
 
 def _typecheckingstub__78a32cfc14171e780d6e44d3e6a99faa6da50655ac09560f7b229b0c0c7383f1(
     *,
+    additional_cache_key: typing.Optional[builtins.str] = None,
     cached_in_context: typing.Optional[builtins.bool] = None,
     user_data: typing.Optional[UserData] = None,
     parameter_name: builtins.str,
@@ -103711,6 +104548,7 @@ def _typecheckingstub__78a32cfc14171e780d6e44d3e6a99faa6da50655ac09560f7b229b0c0
 
 def _typecheckingstub__8fcdd01a6ab45c77447fba339b5a9358c3ab40c4833c1f86c68009a6a3bb1422(
     *,
+    additional_cache_key: typing.Optional[builtins.str] = None,
     cached_in_context: typing.Optional[builtins.bool] = None,
     user_data: typing.Optional[UserData] = None,
     cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
@@ -104860,6 +105698,16 @@ def _typecheckingstub__af90912c9ac24abaec82396197e6a69e4a9b7287343456143c11dce76
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__2ac1bca7bdb78c6a00383adcdf8e49157dfa7db32559bd0d8033ff9f9ea819c7(
+    *,
+    device_name: typing.Optional[builtins.str] = None,
+    ebs: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.EbsBlockDeviceProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    no_device: typing.Optional[builtins.str] = None,
+    virtual_name: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__1c9644ecfacce71230069287c64c15045d2faa220f98ae11e6e91993204231d1(
     *,
     replacement_strategy: typing.Optional[builtins.str] = None,
@@ -104882,6 +105730,19 @@ def _typecheckingstub__2e29954f7c2c9dfcf753ab53031041abbaad5b5371796092fa6a7e5ca
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__98937edeb55103aa31b4f310bc1c5cdf31ffd54c5c2d451314118a9d43196bbd(
+    *,
+    delete_on_termination: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+    encrypted: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
+    iops: typing.Optional[jsii.Number] = None,
+    kms_key_id: typing.Optional[builtins.str] = None,
+    snapshot_id: typing.Optional[builtins.str] = None,
+    volume_size: typing.Optional[jsii.Number] = None,
+    volume_type: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__a16391ac858f174f4e714e8b72b94e7e61e1b50ead8e638dff708e3d739752d5(
     *,
     launch_template_specification: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.FleetLaunchTemplateSpecificationRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
@@ -104893,6 +105754,7 @@ def _typecheckingstub__a16391ac858f174f4e714e8b72b94e7e61e1b50ead8e638dff708e3d7
 def _typecheckingstub__d758750d188cce1b749f19591d20310ad5bc697f0e6f94f495c9619297998763(
     *,
     availability_zone: typing.Optional[builtins.str] = None,
+    block_device_mappings: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Sequence[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.BlockDeviceMappingProperty, typing.Dict[builtins.str, typing.Any]]]]]] = None,
     instance_requirements: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnEC2Fleet.InstanceRequirementsRequestProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     instance_type: typing.Optional[builtins.str] = None,
     max_price: typing.Optional[builtins.str] = None,
@@ -105244,6 +106106,7 @@ def _typecheckingstub__84a7ddca98bd1c24713f12588ec54b51cdc19c99c2209e07c96417201
     id: builtins.str,
     *,
     vpc_id: builtins.str,
+    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -105266,9 +106129,16 @@ def _typecheckingstub__dd41a3676da418b0ac30e8c6707af491b5f32416672bf517e640f6132
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__923846a8ba3d02f36c9267e2c903018ed279860265ad8a488da0a81153c5ff44(
+    value: typing.Optional[typing.List[_CfnTag_f6864754]],
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__b693b2d49003d73758f4c0003564a93353b18fc97434556a2e988e47f367fb84(
     *,
     vpc_id: builtins.str,
+    tags: typing.Optional[typing.Sequence[typing.Union[_CfnTag_f6864754, typing.Dict[builtins.str, typing.Any]]]] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -110207,6 +111077,13 @@ def _typecheckingstub__b297663d31b5bbe92a3f56911eb6c57abab4c122a855b348cb1da68bc
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__39b852e2beaad9da72706596053a58f7c1190828d458e590af07c5701812220d(
+    *,
+    internet_gateway_block_mode: typing.Optional[builtins.str] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__9ead2dbf33a2462f22ec4fe1b542f6a0fc766e914575dd0c8da36b35e6a471a0(
     *,
     enable_resource_name_dns_aaaa_record: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
@@ -114862,6 +115739,7 @@ def _typecheckingstub__866a74bec8e14dd27073a82d4ff7b25ab450e0eff08b7026d08431998
 def _typecheckingstub__9c44b2bd75c4714250889165d6fd2d06ab6a906b90c817320a7c5f526dcbfc2f(
     *,
     name: builtins.str,
+    additional_cache_key: typing.Optional[builtins.str] = None,
     filters: typing.Optional[typing.Mapping[builtins.str, typing.Sequence[builtins.str]]] = None,
     owners: typing.Optional[typing.Sequence[builtins.str]] = None,
     user_data: typing.Optional[UserData] = None,
@@ -114873,6 +115751,7 @@ def _typecheckingstub__9c44b2bd75c4714250889165d6fd2d06ab6a906b90c817320a7c5f526
 def _typecheckingstub__677afd5ea9b4639913a489ab67346107c0d290e015be12483e980d3a19e33a6e(
     parameter_name: builtins.str,
     *,
+    additional_cache_key: typing.Optional[builtins.str] = None,
     cached_in_context: typing.Optional[builtins.bool] = None,
     os: typing.Optional[OperatingSystemType] = None,
     parameter_version: typing.Optional[builtins.str] = None,
@@ -114908,6 +115787,7 @@ def _typecheckingstub__0340fbf48f206279d16bd5e5e0956522ca9a19ba8d39aa2efcc7d06b4
 def _typecheckingstub__5e832dd82a3ef447ebf9a639dc9d6983793ce7321287fb2370dbed898b67d02a(
     parameter_name: builtins.str,
     *,
+    additional_cache_key: typing.Optional[builtins.str] = None,
     cached_in_context: typing.Optional[builtins.bool] = None,
     os: typing.Optional[OperatingSystemType] = None,
     parameter_version: typing.Optional[builtins.str] = None,
@@ -115239,6 +116119,7 @@ def _typecheckingstub__fb9c21f15b378acd78737933455e65f7bb8b078652a7ac4ee6c129501
 def _typecheckingstub__ae85933c688e38a0dd9faa69a685488b55c8c19f918eabcacbd33c964c7bb468(
     parameter_name: builtins.str,
     *,
+    additional_cache_key: typing.Optional[builtins.str] = None,
     cached_in_context: typing.Optional[builtins.bool] = None,
     os: typing.Optional[OperatingSystemType] = None,
     parameter_version: typing.Optional[builtins.str] = None,
@@ -115391,6 +116272,7 @@ def _typecheckingstub__238a040275c82fe5911f2f1fd16a54d47e5937007b9647e86fefb63d0
 
 def _typecheckingstub__a03f16dc6f5eb3eb6f69587f84001af20bc314a1c46a530aa5fb21da814be237(
     *,
+    additional_cache_key: typing.Optional[builtins.str] = None,
     cached_in_context: typing.Optional[builtins.bool] = None,
     os: typing.Optional[OperatingSystemType] = None,
     parameter_version: typing.Optional[builtins.str] = None,
@@ -115665,6 +116547,7 @@ def _typecheckingstub__7e030ab114373c1029fa90c55af2097b08d29de0c6045a2812c36b009
     size: typing.Optional[_Size_7b441c34] = None,
     snapshot_id: typing.Optional[builtins.str] = None,
     throughput: typing.Optional[jsii.Number] = None,
+    volume_initialization_rate: typing.Optional[_Size_7b441c34] = None,
     volume_name: typing.Optional[builtins.str] = None,
     volume_type: typing.Optional[EbsDeviceVolumeType] = None,
 ) -> None:
@@ -115733,6 +116616,7 @@ def _typecheckingstub__fd11037db838f64c74264a09154568b99584932152ae7679e47051119
     size: typing.Optional[_Size_7b441c34] = None,
     snapshot_id: typing.Optional[builtins.str] = None,
     throughput: typing.Optional[jsii.Number] = None,
+    volume_initialization_rate: typing.Optional[_Size_7b441c34] = None,
     volume_name: typing.Optional[builtins.str] = None,
     volume_type: typing.Optional[EbsDeviceVolumeType] = None,
 ) -> None:
@@ -116118,6 +117002,7 @@ def _typecheckingstub__a9243d0fea7f4d4e8b65c37925a1dbb71b6136866e6c28c37f9d5dc79
 
 def _typecheckingstub__968329b6e3d88dbd1836e6234bc305a96628c570666cc423d4eeccc95dc92ab6(
     *,
+    additional_cache_key: typing.Optional[builtins.str] = None,
     cached_in_context: typing.Optional[builtins.bool] = None,
     user_data: typing.Optional[UserData] = None,
     cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
@@ -116129,6 +117014,7 @@ def _typecheckingstub__968329b6e3d88dbd1836e6234bc305a96628c570666cc423d4eeccc95
 
 def _typecheckingstub__d2a291560388da3a1deca6cc63773b445813e32521bbcf4ece1d3a557e2eda6b(
     *,
+    additional_cache_key: typing.Optional[builtins.str] = None,
     cached_in_context: typing.Optional[builtins.bool] = None,
     user_data: typing.Optional[UserData] = None,
     cpu_type: typing.Optional[AmazonLinuxCpuType] = None,
@@ -116140,6 +117026,7 @@ def _typecheckingstub__d2a291560388da3a1deca6cc63773b445813e32521bbcf4ece1d3a557
 
 def _typecheckingstub__8aa3dd8e9489482da5f68eebe827af2a2367490c7299028616bae30c26efbd55(
     *,
+    additional_cache_key: typing.Optional[builtins.str] = None,
     cached_in_context: typing.Optional[builtins.bool] = None,
     user_data: typing.Optional[UserData] = None,
     cpu_type: typing.Optional[AmazonLinuxCpuType] = None,