aws-cdk-lib 2.137.0__py3-none-any.whl → 2.138.0__py3-none-any.whl

aws_cdk/aws_ecs/__init__.py

@@ -8997,7 +8997,7 @@ class CfnService(
             :param alarms: Information about the CloudWatch alarms.
             :param deployment_circuit_breaker: .. epigraph:: The deployment circuit breaker can only be used for services using the rolling update ( ``ECS`` ) deployment type. The *deployment circuit breaker* determines whether a service deployment will fail if the service can't reach a steady state. If you use the deployment circuit breaker, a service deployment will transition to a failed state and stop launching new tasks. If you use the rollback option, when a service deployment fails, the service is rolled back to the last deployment that completed successfully. For more information, see `Rolling update <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/deployment-type-ecs.html>`_ in the *Amazon Elastic Container Service Developer Guide*
             :param maximum_percent: If a service is using the rolling update ( ``ECS`` ) deployment type, the ``maximumPercent`` parameter represents an upper limit on the number of your service's tasks that are allowed in the ``RUNNING`` or ``PENDING`` state during a deployment, as a percentage of the ``desiredCount`` (rounded down to the nearest integer). This parameter enables you to define the deployment batch size. For example, if your service is using the ``REPLICA`` service scheduler and has a ``desiredCount`` of four tasks and a ``maximumPercent`` value of 200%, the scheduler may start four new tasks before stopping the four older tasks (provided that the cluster resources required to do this are available). The default ``maximumPercent`` value for a service using the ``REPLICA`` service scheduler is 200%. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and tasks that use the EC2 launch type, the *maximum percent* value is set to the default value and is used to define the upper limit on the number of the tasks in the service that remain in the ``RUNNING`` state while the container instances are in the ``DRAINING`` state. If the tasks in the service use the Fargate launch type, the maximum percent value is not used, although it is returned when describing your service.
-            :param minimum_healthy_percent: If a service is using the rolling update ( ``ECS`` ) deployment type, the ``minimumHealthyPercent`` represents a lower limit on the number of your service's tasks that must remain in the ``RUNNING`` state during a deployment, as a percentage of the ``desiredCount`` (rounded up to the nearest integer). This parameter enables you to deploy without using additional cluster capacity. For example, if your service has a ``desiredCount`` of four tasks and a ``minimumHealthyPercent`` of 50%, the service scheduler may stop two existing tasks to free up cluster capacity before starting two new tasks. For services that *do not* use a load balancer, the following should be noted: - A service is considered healthy if all essential containers within the tasks in the service pass their health checks. - If a task has no essential containers with a health check defined, the service scheduler will wait for 40 seconds after a task reaches a ``RUNNING`` state before the task is counted towards the minimum healthy percent total. - If a task has one or more essential containers with a health check defined, the service scheduler will wait for the task to reach a healthy status before counting it towards the minimum healthy percent total. A task is considered healthy when all essential containers within the task have passed their health checks. The amount of time the service scheduler can wait for is determined by the container health check settings. For services that *do* use a load balancer, the following should be noted: - If a task has no essential containers with a health check defined, the service scheduler will wait for the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total. - If a task has an essential container with a health check defined, the service scheduler will wait for both the task to reach a healthy status and the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the EC2 launch type, the *minimum healthy percent* value is set to the default value and is used to define the lower limit on the number of the tasks in the service that remain in the ``RUNNING`` state while the container instances are in the ``DRAINING`` state. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the Fargate launch type, the minimum healthy percent value is not used, although it is returned when describing your service.
+            :param minimum_healthy_percent: If a service is using the rolling update ( ``ECS`` ) deployment type, the ``minimumHealthyPercent`` represents a lower limit on the number of your service's tasks that must remain in the ``RUNNING`` state during a deployment, as a percentage of the ``desiredCount`` (rounded up to the nearest integer). This parameter enables you to deploy without using additional cluster capacity. For example, if your service has a ``desiredCount`` of four tasks and a ``minimumHealthyPercent`` of 50%, the service scheduler may stop two existing tasks to free up cluster capacity before starting two new tasks. For services that *do not* use a load balancer, the following should be noted: - A service is considered healthy if all essential containers within the tasks in the service pass their health checks. - If a task has no essential containers with a health check defined, the service scheduler will wait for 40 seconds after a task reaches a ``RUNNING`` state before the task is counted towards the minimum healthy percent total. - If a task has one or more essential containers with a health check defined, the service scheduler will wait for the task to reach a healthy status before counting it towards the minimum healthy percent total. A task is considered healthy when all essential containers within the task have passed their health checks. The amount of time the service scheduler can wait for is determined by the container health check settings. For services that *do* use a load balancer, the following should be noted: - If a task has no essential containers with a health check defined, the service scheduler will wait for the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total. - If a task has an essential container with a health check defined, the service scheduler will wait for both the task to reach a healthy status and the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total. The default value for a replica service for ``minimumHealthyPercent`` is 100%. The default ``minimumHealthyPercent`` value for a service using the ``DAEMON`` service schedule is 0% for the AWS CLI , the AWS SDKs, and the APIs and 50% for the AWS Management Console. The minimum number of healthy tasks during a deployment is the ``desiredCount`` multiplied by the ``minimumHealthyPercent`` /100, rounded up to the nearest integer value. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the EC2 launch type, the *minimum healthy percent* value is set to the default value and is used to define the lower limit on the number of the tasks in the service that remain in the ``RUNNING`` state while the container instances are in the ``DRAINING`` state. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the Fargate launch type, the minimum healthy percent value is not used, although it is returned when describing your service.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-deploymentconfiguration.html
             :exampleMetadata: fixture=_generated
@@ -9094,6 +9094,10 @@ class CfnService(
             - If a task has no essential containers with a health check defined, the service scheduler will wait for the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total.
             - If a task has an essential container with a health check defined, the service scheduler will wait for both the task to reach a healthy status and the load balancer target group health check to return a healthy status before counting the task towards the minimum healthy percent total.
 
+            The default value for a replica service for ``minimumHealthyPercent`` is 100%. The default ``minimumHealthyPercent`` value for a service using the ``DAEMON`` service schedule is 0% for the AWS CLI , the AWS SDKs, and the APIs and 50% for the AWS Management Console.
+
+            The minimum number of healthy tasks during a deployment is the ``desiredCount`` multiplied by the ``minimumHealthyPercent`` /100, rounded up to the nearest integer value.
+
             If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the EC2 launch type, the *minimum healthy percent* value is set to the default value and is used to define the lower limit on the number of the tasks in the service that remain in the ``RUNNING`` state while the container instances are in the ``DRAINING`` state. If a service is using either the blue/green ( ``CODE_DEPLOY`` ) or ``EXTERNAL`` deployment types and is running tasks that use the Fargate launch type, the minimum healthy percent value is not used, although it is returned when describing your service.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-service-deploymentconfiguration.html#cfn-ecs-service-deploymentconfiguration-minimumhealthypercent
@@ -11867,6 +11871,16 @@ class CfnTaskDefinition(
                     transit_encryption="transitEncryption",
                     transit_encryption_port=123
                 ),
+                f_sx_windows_file_server_volume_configuration=ecs.CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty(
+                    file_system_id="fileSystemId",
+                    root_directory="rootDirectory",
+        
+                    # the properties below are optional
+                    authorization_config=ecs.CfnTaskDefinition.FSxAuthorizationConfigProperty(
+                        credentials_parameter="credentialsParameter",
+                        domain="domain"
+                    )
+                ),
                 host=ecs.CfnTaskDefinition.HostVolumePropertiesProperty(
                     source_path="sourcePath"
                 ),
@@ -14004,6 +14018,176 @@ class CfnTaskDefinition(
                 k + "=" + repr(v) for k, v in self._values.items()
             )
 
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnTaskDefinition.FSxAuthorizationConfigProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "credentials_parameter": "credentialsParameter",
+            "domain": "domain",
+        },
+    )
+    class FSxAuthorizationConfigProperty:
+        def __init__(
+            self,
+            *,
+            credentials_parameter: builtins.str,
+            domain: builtins.str,
+        ) -> None:
+            '''
+            :param credentials_parameter: 
+            :param domain: 
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxauthorizationconfig.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_ecs as ecs
+                
+                f_sx_authorization_config_property = ecs.CfnTaskDefinition.FSxAuthorizationConfigProperty(
+                    credentials_parameter="credentialsParameter",
+                    domain="domain"
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__f5e3b577af4628d7fb3319bd51694790c1cd0a62eae308c830c9dccee5d8ca1d)
+                check_type(argname="argument credentials_parameter", value=credentials_parameter, expected_type=type_hints["credentials_parameter"])
+                check_type(argname="argument domain", value=domain, expected_type=type_hints["domain"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "credentials_parameter": credentials_parameter,
+                "domain": domain,
+            }
+
+        @builtins.property
+        def credentials_parameter(self) -> builtins.str:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxauthorizationconfig.html#cfn-ecs-taskdefinition-fsxauthorizationconfig-credentialsparameter
+            '''
+            result = self._values.get("credentials_parameter")
+            assert result is not None, "Required property 'credentials_parameter' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def domain(self) -> builtins.str:
+            '''
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxauthorizationconfig.html#cfn-ecs-taskdefinition-fsxauthorizationconfig-domain
+            '''
+            result = self._values.get("domain")
+            assert result is not None, "Required property 'domain' is missing"
+            return typing.cast(builtins.str, result)
+
+        def __eq__(self, rhs: typing.Any) -> builtins.bool:
+            return isinstance(rhs, self.__class__) and rhs._values == self._values
+
+        def __ne__(self, rhs: typing.Any) -> builtins.bool:
+            return not (rhs == self)
+
+        def __repr__(self) -> str:
+            return "FSxAuthorizationConfigProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
+    @jsii.data_type(
+        jsii_type="aws-cdk-lib.aws_ecs.CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty",
+        jsii_struct_bases=[],
+        name_mapping={
+            "file_system_id": "fileSystemId",
+            "root_directory": "rootDirectory",
+            "authorization_config": "authorizationConfig",
+        },
+    )
+    class FSxWindowsFileServerVolumeConfigurationProperty:
+        def __init__(
+            self,
+            *,
+            file_system_id: builtins.str,
+            root_directory: builtins.str,
+            authorization_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskDefinition.FSxAuthorizationConfigProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+        ) -> None:
+            '''This parameter is specified when you're using `Amazon FSx for Windows File Server <https://docs.aws.amazon.com/fsx/latest/WindowsGuide/what-is.html>`_ file system for task storage.
+
+            For more information and the input format, see `Amazon FSx for Windows File Server volumes <https://docs.aws.amazon.com/AmazonECS/latest/developerguide/wfsx-volumes.html>`_ in the *Amazon Elastic Container Service Developer Guide* .
+
+            :param file_system_id: The Amazon FSx for Windows File Server file system ID to use.
+            :param root_directory: The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.
+            :param authorization_config: The authorization configuration details for the Amazon FSx for Windows File Server file system.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration.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_ecs as ecs
+                
+                f_sx_windows_file_server_volume_configuration_property = ecs.CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty(
+                    file_system_id="fileSystemId",
+                    root_directory="rootDirectory",
+                
+                    # the properties below are optional
+                    authorization_config=ecs.CfnTaskDefinition.FSxAuthorizationConfigProperty(
+                        credentials_parameter="credentialsParameter",
+                        domain="domain"
+                    )
+                )
+            '''
+            if __debug__:
+                type_hints = typing.get_type_hints(_typecheckingstub__ef74e299375c10c97a6bb4455d35f14ea7c21e10b612cd0fb3958fd12601168f)
+                check_type(argname="argument file_system_id", value=file_system_id, expected_type=type_hints["file_system_id"])
+                check_type(argname="argument root_directory", value=root_directory, expected_type=type_hints["root_directory"])
+                check_type(argname="argument authorization_config", value=authorization_config, expected_type=type_hints["authorization_config"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {
+                "file_system_id": file_system_id,
+                "root_directory": root_directory,
+            }
+            if authorization_config is not None:
+                self._values["authorization_config"] = authorization_config
+
+        @builtins.property
+        def file_system_id(self) -> builtins.str:
+            '''The Amazon FSx for Windows File Server file system ID to use.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration.html#cfn-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration-filesystemid
+            '''
+            result = self._values.get("file_system_id")
+            assert result is not None, "Required property 'file_system_id' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def root_directory(self) -> builtins.str:
+            '''The directory within the Amazon FSx for Windows File Server file system to mount as the root directory inside the host.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration.html#cfn-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration-rootdirectory
+            '''
+            result = self._values.get("root_directory")
+            assert result is not None, "Required property 'root_directory' is missing"
+            return typing.cast(builtins.str, result)
+
+        @builtins.property
+        def authorization_config(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTaskDefinition.FSxAuthorizationConfigProperty"]]:
+            '''The authorization configuration details for the Amazon FSx for Windows File Server file system.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration.html#cfn-ecs-taskdefinition-fsxwindowsfileservervolumeconfiguration-authorizationconfig
+            '''
+            result = self._values.get("authorization_config")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTaskDefinition.FSxAuthorizationConfigProperty"]], 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 "FSxWindowsFileServerVolumeConfigurationProperty(%s)" % ", ".join(
+                k + "=" + repr(v) for k, v in self._values.items()
+            )
+
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_ecs.CfnTaskDefinition.FirelensConfigurationProperty",
         jsii_struct_bases=[],
@@ -16067,6 +16251,7 @@ class CfnTaskDefinition(
             "configured_at_launch": "configuredAtLaunch",
             "docker_volume_configuration": "dockerVolumeConfiguration",
             "efs_volume_configuration": "efsVolumeConfiguration",
+            "f_sx_windows_file_server_volume_configuration": "fSxWindowsFileServerVolumeConfiguration",
             "host": "host",
             "name": "name",
         },
@@ -16078,6 +16263,7 @@ class CfnTaskDefinition(
             configured_at_launch: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
             docker_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskDefinition.DockerVolumeConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             efs_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskDefinition.EFSVolumeConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
+            f_sx_windows_file_server_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             host: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union["CfnTaskDefinition.HostVolumePropertiesProperty", typing.Dict[builtins.str, typing.Any]]]] = None,
             name: typing.Optional[builtins.str] = None,
         ) -> None:
@@ -16088,6 +16274,7 @@ class CfnTaskDefinition(
             :param configured_at_launch: Indicates whether the volume should be configured at launch time. This is used to create Amazon EBS volumes for standalone tasks or tasks created as part of a service. Each task definition revision may only have one volume configured at launch in the volume configuration. To configure a volume at launch time, use this task definition revision and specify a ``volumeConfigurations`` object when calling the ``CreateService`` , ``UpdateService`` , ``RunTask`` or ``StartTask`` APIs.
             :param docker_volume_configuration: This parameter is specified when you use Docker volumes. Windows containers only support the use of the ``local`` driver. To use bind mounts, specify the ``host`` parameter instead. .. epigraph:: Docker volumes aren't supported by tasks run on AWS Fargate .
             :param efs_volume_configuration: This parameter is specified when you use an Amazon Elastic File System file system for task storage.
+            :param f_sx_windows_file_server_volume_configuration: This parameter is specified when you use Amazon FSx for Windows File Server file system for task storage.
             :param host: This parameter is specified when you use bind mount host volumes. The contents of the ``host`` parameter determine whether your bind mount host volume persists on the host container instance and where it's stored. If the ``host`` parameter is empty, then the Docker daemon assigns a host path for your data volume. However, the data isn't guaranteed to persist after the containers that are associated with it stop running. Windows containers can mount whole directories on the same drive as ``$env:ProgramData`` . Windows containers can't mount directories on a different drive, and mount point can't be across drives. For example, you can mount ``C:\\my\\path:C:\\my\\path`` and ``D:\\:D:\\`` , but not ``D:\\my\\path:C:\\my\\path`` or ``D:\\:C:\\my\\path`` .
             :param name: The name of the volume. Up to 255 letters (uppercase and lowercase), numbers, underscores, and hyphens are allowed. When using a volume configured at launch, the ``name`` is required and must also be specified as the volume name in the ``ServiceVolumeConfiguration`` or ``TaskVolumeConfiguration`` parameter when creating your service or standalone task. For all other types of volumes, this name is referenced in the ``sourceVolume`` parameter of the ``mountPoints`` object in the container definition. When a volume is using the ``efsVolumeConfiguration`` , the name is required.
 
@@ -16125,6 +16312,16 @@ class CfnTaskDefinition(
                         transit_encryption="transitEncryption",
                         transit_encryption_port=123
                     ),
+                    f_sx_windows_file_server_volume_configuration=ecs.CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty(
+                        file_system_id="fileSystemId",
+                        root_directory="rootDirectory",
+                
+                        # the properties below are optional
+                        authorization_config=ecs.CfnTaskDefinition.FSxAuthorizationConfigProperty(
+                            credentials_parameter="credentialsParameter",
+                            domain="domain"
+                        )
+                    ),
                     host=ecs.CfnTaskDefinition.HostVolumePropertiesProperty(
                         source_path="sourcePath"
                     ),
@@ -16136,6 +16333,7 @@ class CfnTaskDefinition(
                 check_type(argname="argument configured_at_launch", value=configured_at_launch, expected_type=type_hints["configured_at_launch"])
                 check_type(argname="argument docker_volume_configuration", value=docker_volume_configuration, expected_type=type_hints["docker_volume_configuration"])
                 check_type(argname="argument efs_volume_configuration", value=efs_volume_configuration, expected_type=type_hints["efs_volume_configuration"])
+                check_type(argname="argument f_sx_windows_file_server_volume_configuration", value=f_sx_windows_file_server_volume_configuration, expected_type=type_hints["f_sx_windows_file_server_volume_configuration"])
                 check_type(argname="argument host", value=host, expected_type=type_hints["host"])
                 check_type(argname="argument name", value=name, expected_type=type_hints["name"])
             self._values: typing.Dict[builtins.str, typing.Any] = {}
@@ -16145,6 +16343,8 @@ class CfnTaskDefinition(
                 self._values["docker_volume_configuration"] = docker_volume_configuration
             if efs_volume_configuration is not None:
                 self._values["efs_volume_configuration"] = efs_volume_configuration
+            if f_sx_windows_file_server_volume_configuration is not None:
+                self._values["f_sx_windows_file_server_volume_configuration"] = f_sx_windows_file_server_volume_configuration
             if host is not None:
                 self._values["host"] = host
             if name is not None:
@@ -16192,6 +16392,17 @@ class CfnTaskDefinition(
             result = self._values.get("efs_volume_configuration")
             return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTaskDefinition.EFSVolumeConfigurationProperty"]], result)
 
+        @builtins.property
+        def f_sx_windows_file_server_volume_configuration(
+            self,
+        ) -> typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty"]]:
+            '''This parameter is specified when you use Amazon FSx for Windows File Server file system for task storage.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-ecs-taskdefinition-volume.html#cfn-ecs-taskdefinition-volume-fsxwindowsfileservervolumeconfiguration
+            '''
+            result = self._values.get("f_sx_windows_file_server_volume_configuration")
+            return typing.cast(typing.Optional[typing.Union[_IResolvable_da3f097b, "CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty"]], result)
+
         @builtins.property
         def host(
             self,
@@ -16504,6 +16715,16 @@ class CfnTaskDefinitionProps:
                         transit_encryption="transitEncryption",
                         transit_encryption_port=123
                     ),
+                    f_sx_windows_file_server_volume_configuration=ecs.CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty(
+                        file_system_id="fileSystemId",
+                        root_directory="rootDirectory",
+            
+                        # the properties below are optional
+                        authorization_config=ecs.CfnTaskDefinition.FSxAuthorizationConfigProperty(
+                            credentials_parameter="credentialsParameter",
+                            domain="domain"
+                        )
+                    ),
                     host=ecs.CfnTaskDefinition.HostVolumePropertiesProperty(
                         source_path="sourcePath"
                     ),
@@ -41747,6 +41968,23 @@ def _typecheckingstub__fdddb0d48923d3583475a8b34d0a6079606e57e6de57c6ca22978691d
     """Type checking stubs"""
     pass
 
+def _typecheckingstub__f5e3b577af4628d7fb3319bd51694790c1cd0a62eae308c830c9dccee5d8ca1d(
+    *,
+    credentials_parameter: builtins.str,
+    domain: builtins.str,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__ef74e299375c10c97a6bb4455d35f14ea7c21e10b612cd0fb3958fd12601168f(
+    *,
+    file_system_id: builtins.str,
+    root_directory: builtins.str,
+    authorization_config: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskDefinition.FSxAuthorizationConfigProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
 def _typecheckingstub__6a1cd84d62e34083a37bc4c25d849ac547dacc5fe8a4db04170cf83e3cd1e9d3(
     *,
     options: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Mapping[builtins.str, builtins.str]]] = None,
@@ -41935,6 +42173,7 @@ def _typecheckingstub__0b8eeaf561ff6334fbacca7f706104a9a5e10a366526af78d2a6b7173
     configured_at_launch: typing.Optional[typing.Union[builtins.bool, _IResolvable_da3f097b]] = None,
     docker_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskDefinition.DockerVolumeConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     efs_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskDefinition.EFSVolumeConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
+    f_sx_windows_file_server_volume_configuration: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskDefinition.FSxWindowsFileServerVolumeConfigurationProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     host: typing.Optional[typing.Union[_IResolvable_da3f097b, typing.Union[CfnTaskDefinition.HostVolumePropertiesProperty, typing.Dict[builtins.str, typing.Any]]]] = None,
     name: typing.Optional[builtins.str] = None,
 ) -> None:

aws_cdk/aws_efs/__init__.py

@@ -2229,7 +2229,7 @@ class CfnFileSystem(
         ) -> None:
             '''Describes the destination file system in the replication configuration.
 
-            :param availability_zone_name: The AWS For One Zone file systems, the replication configuration must specify the Availability Zone in which the destination file system is located. Use the format ``us-east-1a`` to specify the Availability Zone. For more information about One Zone file systems, see `EFS file system types <https://docs.aws.amazon.com/efs/latest/ug/storage-classes.html>`_ in the *Amazon EFS User Guide* . .. epigraph:: One Zone file system type is not available in all Availability Zones in AWS Regions where Amazon EFS is available.
+            :param availability_zone_name: For One Zone file systems, the replication configuration must specify the Availability Zone in which the destination file system is located. Use the format ``us-east-1a`` to specify the Availability Zone. For more information about One Zone file systems, see `EFS file system types <https://docs.aws.amazon.com/efs/latest/ug/storage-classes.html>`_ in the *Amazon EFS User Guide* . .. epigraph:: One Zone file system type is not available in all Availability Zones in AWS Regions where Amazon EFS is available.
             :param file_system_id: The ID of the destination Amazon EFS file system.
             :param kms_key_id: The ID of an AWS KMS key used to protect the encrypted file system.
             :param region: The AWS Region in which the destination file system is located. .. epigraph:: For One Zone file systems, the replication configuration must specify the AWS Region in which the destination file system is located.
@@ -2268,7 +2268,7 @@ class CfnFileSystem(
 
         @builtins.property
         def availability_zone_name(self) -> typing.Optional[builtins.str]:
-            '''The AWS For One Zone file systems, the replication configuration must specify the Availability Zone in which the destination file system is located.
+            '''For One Zone file systems, the replication configuration must specify the Availability Zone in which the destination file system is located.
 
             Use the format ``us-east-1a`` to specify the Availability Zone. For more information about One Zone file systems, see `EFS file system types <https://docs.aws.amazon.com/efs/latest/ug/storage-classes.html>`_ in the *Amazon EFS User Guide* .
             .. epigraph::

aws_cdk/aws_elasticache/__init__.py

@@ -5397,11 +5397,15 @@ class CfnServerlessCache(
             # the properties below are optional
             cache_usage_limits=elasticache.CfnServerlessCache.CacheUsageLimitsProperty(
                 data_storage=elasticache.CfnServerlessCache.DataStorageProperty(
+                    unit="unit",
+        
+                    # the properties below are optional
                     maximum=123,
-                    unit="unit"
+                    minimum=123
                 ),
                 ecpu_per_second=elasticache.CfnServerlessCache.ECPUPerSecondProperty(
-                    maximum=123
+                    maximum=123,
+                    minimum=123
                 )
             ),
             daily_snapshot_time="dailySnapshotTime",
@@ -5871,11 +5875,15 @@ class CfnServerlessCache(
                 
                 cache_usage_limits_property = elasticache.CfnServerlessCache.CacheUsageLimitsProperty(
                     data_storage=elasticache.CfnServerlessCache.DataStorageProperty(
+                        unit="unit",
+                
+                        # the properties below are optional
                         maximum=123,
-                        unit="unit"
+                        minimum=123
                     ),
                     ecpu_per_second=elasticache.CfnServerlessCache.ECPUPerSecondProperty(
-                        maximum=123
+                        maximum=123,
+                        minimum=123
                     )
                 )
             '''
@@ -5925,14 +5933,21 @@ class CfnServerlessCache(
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_elasticache.CfnServerlessCache.DataStorageProperty",
         jsii_struct_bases=[],
-        name_mapping={"maximum": "maximum", "unit": "unit"},
+        name_mapping={"unit": "unit", "maximum": "maximum", "minimum": "minimum"},
     )
     class DataStorageProperty:
-        def __init__(self, *, maximum: jsii.Number, unit: builtins.str) -> None:
+        def __init__(
+            self,
+            *,
+            unit: builtins.str,
+            maximum: typing.Optional[jsii.Number] = None,
+            minimum: typing.Optional[jsii.Number] = None,
+        ) -> None:
             '''The data storage limit.
 
-            :param maximum: The upper limit for data storage the cache is set to use.
             :param unit: The unit that the storage is measured in, in GB.
+            :param maximum: The upper limit for data storage the cache is set to use.
+            :param minimum: The lower limit for data storage the cache is set to use.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-serverlesscache-datastorage.html
             :exampleMetadata: fixture=_generated
@@ -5944,38 +5959,53 @@ class CfnServerlessCache(
                 from aws_cdk import aws_elasticache as elasticache
                 
                 data_storage_property = elasticache.CfnServerlessCache.DataStorageProperty(
+                    unit="unit",
+                
+                    # the properties below are optional
                     maximum=123,
-                    unit="unit"
+                    minimum=123
                 )
             '''
             if __debug__:
                 type_hints = typing.get_type_hints(_typecheckingstub__14470b22401430bce81195b8e644412f38b76011c8cab7fa8399081bd44b546d)
-                check_type(argname="argument maximum", value=maximum, expected_type=type_hints["maximum"])
                 check_type(argname="argument unit", value=unit, expected_type=type_hints["unit"])
+                check_type(argname="argument maximum", value=maximum, expected_type=type_hints["maximum"])
+                check_type(argname="argument minimum", value=minimum, expected_type=type_hints["minimum"])
             self._values: typing.Dict[builtins.str, typing.Any] = {
-                "maximum": maximum,
                 "unit": unit,
             }
+            if maximum is not None:
+                self._values["maximum"] = maximum
+            if minimum is not None:
+                self._values["minimum"] = minimum
+
+        @builtins.property
+        def unit(self) -> builtins.str:
+            '''The unit that the storage is measured in, in GB.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-serverlesscache-datastorage.html#cfn-elasticache-serverlesscache-datastorage-unit
+            '''
+            result = self._values.get("unit")
+            assert result is not None, "Required property 'unit' is missing"
+            return typing.cast(builtins.str, result)
 
         @builtins.property
-        def maximum(self) -> jsii.Number:
+        def maximum(self) -> typing.Optional[jsii.Number]:
             '''The upper limit for data storage the cache is set to use.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-serverlesscache-datastorage.html#cfn-elasticache-serverlesscache-datastorage-maximum
             '''
             result = self._values.get("maximum")
-            assert result is not None, "Required property 'maximum' is missing"
-            return typing.cast(jsii.Number, result)
+            return typing.cast(typing.Optional[jsii.Number], result)
 
         @builtins.property
-        def unit(self) -> builtins.str:
-            '''The unit that the storage is measured in, in GB.
+        def minimum(self) -> typing.Optional[jsii.Number]:
+            '''The lower limit for data storage the cache is set to use.
 
-            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-serverlesscache-datastorage.html#cfn-elasticache-serverlesscache-datastorage-unit
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-serverlesscache-datastorage.html#cfn-elasticache-serverlesscache-datastorage-minimum
             '''
-            result = self._values.get("unit")
-            assert result is not None, "Required property 'unit' is missing"
-            return typing.cast(builtins.str, result)
+            result = self._values.get("minimum")
+            return typing.cast(typing.Optional[jsii.Number], result)
 
         def __eq__(self, rhs: typing.Any) -> builtins.bool:
             return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -5991,13 +6021,19 @@ class CfnServerlessCache(
     @jsii.data_type(
         jsii_type="aws-cdk-lib.aws_elasticache.CfnServerlessCache.ECPUPerSecondProperty",
         jsii_struct_bases=[],
-        name_mapping={"maximum": "maximum"},
+        name_mapping={"maximum": "maximum", "minimum": "minimum"},
     )
     class ECPUPerSecondProperty:
-        def __init__(self, *, maximum: jsii.Number) -> None:
+        def __init__(
+            self,
+            *,
+            maximum: typing.Optional[jsii.Number] = None,
+            minimum: typing.Optional[jsii.Number] = None,
+        ) -> None:
             '''The configuration for the number of ElastiCache Processing Units (ECPU) the cache can consume per second.
 
             :param maximum: The configuration for the maximum number of ECPUs the cache can consume per second.
+            :param minimum: The configuration for the minimum number of ECPUs the cache should be able consume per second.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-serverlesscache-ecpupersecond.html
             :exampleMetadata: fixture=_generated
@@ -6009,25 +6045,37 @@ class CfnServerlessCache(
                 from aws_cdk import aws_elasticache as elasticache
                 
                 e_cPUPer_second_property = elasticache.CfnServerlessCache.ECPUPerSecondProperty(
-                    maximum=123
+                    maximum=123,
+                    minimum=123
                 )
             '''
             if __debug__:
                 type_hints = typing.get_type_hints(_typecheckingstub__a4a85c1f856007000025702b1b01488e1f0726e767adf52fbf709f88ed3720f1)
                 check_type(argname="argument maximum", value=maximum, expected_type=type_hints["maximum"])
-            self._values: typing.Dict[builtins.str, typing.Any] = {
-                "maximum": maximum,
-            }
+                check_type(argname="argument minimum", value=minimum, expected_type=type_hints["minimum"])
+            self._values: typing.Dict[builtins.str, typing.Any] = {}
+            if maximum is not None:
+                self._values["maximum"] = maximum
+            if minimum is not None:
+                self._values["minimum"] = minimum
 
         @builtins.property
-        def maximum(self) -> jsii.Number:
+        def maximum(self) -> typing.Optional[jsii.Number]:
             '''The configuration for the maximum number of ECPUs the cache can consume per second.
 
             :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-serverlesscache-ecpupersecond.html#cfn-elasticache-serverlesscache-ecpupersecond-maximum
             '''
             result = self._values.get("maximum")
-            assert result is not None, "Required property 'maximum' is missing"
-            return typing.cast(jsii.Number, result)
+            return typing.cast(typing.Optional[jsii.Number], result)
+
+        @builtins.property
+        def minimum(self) -> typing.Optional[jsii.Number]:
+            '''The configuration for the minimum number of ECPUs the cache should be able consume per second.
+
+            :see: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/aws-properties-elasticache-serverlesscache-ecpupersecond.html#cfn-elasticache-serverlesscache-ecpupersecond-minimum
+            '''
+            result = self._values.get("minimum")
+            return typing.cast(typing.Optional[jsii.Number], result)
 
         def __eq__(self, rhs: typing.Any) -> builtins.bool:
             return isinstance(rhs, self.__class__) and rhs._values == self._values
@@ -6191,11 +6239,15 @@ class CfnServerlessCacheProps:
                 # the properties below are optional
                 cache_usage_limits=elasticache.CfnServerlessCache.CacheUsageLimitsProperty(
                     data_storage=elasticache.CfnServerlessCache.DataStorageProperty(
+                        unit="unit",
+            
+                        # the properties below are optional
                         maximum=123,
-                        unit="unit"
+                        minimum=123
                     ),
                     ecpu_per_second=elasticache.CfnServerlessCache.ECPUPerSecondProperty(
-                        maximum=123
+                        maximum=123,
+                        minimum=123
                     )
                 ),
                 daily_snapshot_time="dailySnapshotTime",
@@ -8611,15 +8663,17 @@ def _typecheckingstub__77ebaaf0b703f3ff0164d4845d37449699aec6cbe500ff6d63278a3a6
 
 def _typecheckingstub__14470b22401430bce81195b8e644412f38b76011c8cab7fa8399081bd44b546d(
     *,
-    maximum: jsii.Number,
     unit: builtins.str,
+    maximum: typing.Optional[jsii.Number] = None,
+    minimum: typing.Optional[jsii.Number] = None,
 ) -> None:
     """Type checking stubs"""
     pass
 
 def _typecheckingstub__a4a85c1f856007000025702b1b01488e1f0726e767adf52fbf709f88ed3720f1(
     *,
-    maximum: jsii.Number,
+    maximum: typing.Optional[jsii.Number] = None,
+    minimum: typing.Optional[jsii.Number] = None,
 ) -> None:
     """Type checking stubs"""
     pass