must-cdk 0.0.7__py3-none-any.whl → 0.0.9__py3-none-any.whl

must_cdk/__init__.py

@@ -275,9 +275,8 @@ class ApiGatewayToLambdaProps:
     name_mapping={
         "max_capacity": "maxCapacity",
         "min_capacity": "minCapacity",
-        "target_cpu_utilization_percent": "targetCpuUtilizationPercent",
-        "scale_in_cooldown_sec": "scaleInCooldownSec",
-        "scale_out_cooldown_sec": "scaleOutCooldownSec",
+        "cpu_scale": "cpuScale",
+        "memory_scale": "memoryScale",
     },
 )
 class AutoScalingProps:
@@ -286,66 +285,168 @@ class AutoScalingProps:
         *,
         max_capacity: jsii.Number,
         min_capacity: jsii.Number,
-        target_cpu_utilization_percent: jsii.Number,
-        scale_in_cooldown_sec: typing.Optional[jsii.Number] = None,
-        scale_out_cooldown_sec: typing.Optional[jsii.Number] = None,
+        cpu_scale: typing.Optional[typing.Union[_aws_cdk_aws_ecs_ceddda9d.CpuUtilizationScalingProps, typing.Dict[builtins.str, typing.Any]]] = None,
+        memory_scale: typing.Optional[typing.Union[_aws_cdk_aws_ecs_ceddda9d.MemoryUtilizationScalingProps, typing.Dict[builtins.str, typing.Any]]] = None,
     ) -> None:
-        '''Configuration for ECS service autoscaling.
+        '''Configuration for ECS service auto-scaling.
 
-        :param max_capacity: Maximum number of tasks.
-        :param min_capacity: Minimum number of tasks.
-        :param target_cpu_utilization_percent: Target CPU utilization percentage.
-        :param scale_in_cooldown_sec: Cooldown time in seconds after scale-in.
-        :param scale_out_cooldown_sec: Cooldown time in seconds after scale-out.
+        :param max_capacity: Maximum number of tasks to run.
+        :param min_capacity: Minimum number of tasks to run.
+        :param cpu_scale: Scale task based on CPU utilization.
+        :param memory_scale: Scale task based on memory utilization.
         '''
+        if isinstance(cpu_scale, dict):
+            cpu_scale = _aws_cdk_aws_ecs_ceddda9d.CpuUtilizationScalingProps(**cpu_scale)
+        if isinstance(memory_scale, dict):
+            memory_scale = _aws_cdk_aws_ecs_ceddda9d.MemoryUtilizationScalingProps(**memory_scale)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__d0ea30b15daf73de785b4991457443ee0ca220224fbd08155a17d86c67413930)
             check_type(argname="argument max_capacity", value=max_capacity, expected_type=type_hints["max_capacity"])
             check_type(argname="argument min_capacity", value=min_capacity, expected_type=type_hints["min_capacity"])
-            check_type(argname="argument target_cpu_utilization_percent", value=target_cpu_utilization_percent, expected_type=type_hints["target_cpu_utilization_percent"])
-            check_type(argname="argument scale_in_cooldown_sec", value=scale_in_cooldown_sec, expected_type=type_hints["scale_in_cooldown_sec"])
-            check_type(argname="argument scale_out_cooldown_sec", value=scale_out_cooldown_sec, expected_type=type_hints["scale_out_cooldown_sec"])
+            check_type(argname="argument cpu_scale", value=cpu_scale, expected_type=type_hints["cpu_scale"])
+            check_type(argname="argument memory_scale", value=memory_scale, expected_type=type_hints["memory_scale"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
             "max_capacity": max_capacity,
             "min_capacity": min_capacity,
-            "target_cpu_utilization_percent": target_cpu_utilization_percent,
         }
-        if scale_in_cooldown_sec is not None:
-            self._values["scale_in_cooldown_sec"] = scale_in_cooldown_sec
-        if scale_out_cooldown_sec is not None:
-            self._values["scale_out_cooldown_sec"] = scale_out_cooldown_sec
+        if cpu_scale is not None:
+            self._values["cpu_scale"] = cpu_scale
+        if memory_scale is not None:
+            self._values["memory_scale"] = memory_scale
 
     @builtins.property
     def max_capacity(self) -> jsii.Number:
-        '''Maximum number of tasks.'''
+        '''Maximum number of tasks to run.'''
         result = self._values.get("max_capacity")
         assert result is not None, "Required property 'max_capacity' is missing"
         return typing.cast(jsii.Number, result)
 
     @builtins.property
     def min_capacity(self) -> jsii.Number:
-        '''Minimum number of tasks.'''
+        '''Minimum number of tasks to run.'''
         result = self._values.get("min_capacity")
         assert result is not None, "Required property 'min_capacity' is missing"
         return typing.cast(jsii.Number, result)
 
     @builtins.property
-    def target_cpu_utilization_percent(self) -> jsii.Number:
-        '''Target CPU utilization percentage.'''
-        result = self._values.get("target_cpu_utilization_percent")
-        assert result is not None, "Required property 'target_cpu_utilization_percent' is missing"
+    def cpu_scale(
+        self,
+    ) -> typing.Optional[_aws_cdk_aws_ecs_ceddda9d.CpuUtilizationScalingProps]:
+        '''Scale task based on CPU utilization.'''
+        result = self._values.get("cpu_scale")
+        return typing.cast(typing.Optional[_aws_cdk_aws_ecs_ceddda9d.CpuUtilizationScalingProps], result)
+
+    @builtins.property
+    def memory_scale(
+        self,
+    ) -> typing.Optional[_aws_cdk_aws_ecs_ceddda9d.MemoryUtilizationScalingProps]:
+        '''Scale task based on memory utilization.'''
+        result = self._values.get("memory_scale")
+        return typing.cast(typing.Optional[_aws_cdk_aws_ecs_ceddda9d.MemoryUtilizationScalingProps], 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 "AutoScalingProps(%s)" % ", ".join(
+            k + "=" + repr(v) for k, v in self._values.items()
+        )
+
+
+@jsii.data_type(
+    jsii_type="must-cdk.ContainerProps",
+    jsii_struct_bases=[],
+    name_mapping={
+        "alb_listener_container_port": "albListenerContainerPort",
+        "container_port": "containerPort",
+        "image": "image",
+        "health_check": "healthCheck",
+        "memory_limit": "memoryLimit",
+        "memory_reservation": "memoryReservation",
+    },
+)
+class ContainerProps:
+    def __init__(
+        self,
+        *,
+        alb_listener_container_port: jsii.Number,
+        container_port: jsii.Number,
+        image: _aws_cdk_aws_ecs_ceddda9d.ContainerImage,
+        health_check: typing.Optional[typing.Union[_aws_cdk_aws_ecs_ceddda9d.HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+        memory_limit: typing.Optional[jsii.Number] = None,
+        memory_reservation: typing.Optional[jsii.Number] = None,
+    ) -> None:
+        '''Configuration for the ECS Fargate task definition and container.
+
+        :param alb_listener_container_port: The port number the container listens on.
+        :param container_port: The port number the container listens on.
+        :param image: Container image to deploy.
+        :param health_check: Optional container health check configuration.
+        :param memory_limit: Hard memory limit in MiB for the task (default: 2048).
+        :param memory_reservation: Soft memory reservation in MiB for the container (default: 1024).
+        '''
+        if isinstance(health_check, dict):
+            health_check = _aws_cdk_aws_ecs_ceddda9d.HealthCheck(**health_check)
+        if __debug__:
+            type_hints = typing.get_type_hints(_typecheckingstub__54ea2679bab87dfe8eb538ebc455f8d93200c1beb37ad6e093fa52678f8ac1fc)
+            check_type(argname="argument alb_listener_container_port", value=alb_listener_container_port, expected_type=type_hints["alb_listener_container_port"])
+            check_type(argname="argument container_port", value=container_port, expected_type=type_hints["container_port"])
+            check_type(argname="argument image", value=image, expected_type=type_hints["image"])
+            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
+            check_type(argname="argument memory_limit", value=memory_limit, expected_type=type_hints["memory_limit"])
+            check_type(argname="argument memory_reservation", value=memory_reservation, expected_type=type_hints["memory_reservation"])
+        self._values: typing.Dict[builtins.str, typing.Any] = {
+            "alb_listener_container_port": alb_listener_container_port,
+            "container_port": container_port,
+            "image": image,
+        }
+        if health_check is not None:
+            self._values["health_check"] = health_check
+        if memory_limit is not None:
+            self._values["memory_limit"] = memory_limit
+        if memory_reservation is not None:
+            self._values["memory_reservation"] = memory_reservation
+
+    @builtins.property
+    def alb_listener_container_port(self) -> jsii.Number:
+        '''The port number the container listens on.'''
+        result = self._values.get("alb_listener_container_port")
+        assert result is not None, "Required property 'alb_listener_container_port' is missing"
+        return typing.cast(jsii.Number, result)
+
+    @builtins.property
+    def container_port(self) -> jsii.Number:
+        '''The port number the container listens on.'''
+        result = self._values.get("container_port")
+        assert result is not None, "Required property 'container_port' is missing"
         return typing.cast(jsii.Number, result)
 
     @builtins.property
-    def scale_in_cooldown_sec(self) -> typing.Optional[jsii.Number]:
-        '''Cooldown time in seconds after scale-in.'''
-        result = self._values.get("scale_in_cooldown_sec")
+    def image(self) -> _aws_cdk_aws_ecs_ceddda9d.ContainerImage:
+        '''Container image to deploy.'''
+        result = self._values.get("image")
+        assert result is not None, "Required property 'image' is missing"
+        return typing.cast(_aws_cdk_aws_ecs_ceddda9d.ContainerImage, result)
+
+    @builtins.property
+    def health_check(self) -> typing.Optional[_aws_cdk_aws_ecs_ceddda9d.HealthCheck]:
+        '''Optional container health check configuration.'''
+        result = self._values.get("health_check")
+        return typing.cast(typing.Optional[_aws_cdk_aws_ecs_ceddda9d.HealthCheck], result)
+
+    @builtins.property
+    def memory_limit(self) -> typing.Optional[jsii.Number]:
+        '''Hard memory limit in MiB for the task (default: 2048).'''
+        result = self._values.get("memory_limit")
         return typing.cast(typing.Optional[jsii.Number], result)
 
     @builtins.property
-    def scale_out_cooldown_sec(self) -> typing.Optional[jsii.Number]:
-        '''Cooldown time in seconds after scale-out.'''
-        result = self._values.get("scale_out_cooldown_sec")
+    def memory_reservation(self) -> typing.Optional[jsii.Number]:
+        '''Soft memory reservation in MiB for the container (default: 1024).'''
+        result = self._values.get("memory_reservation")
         return typing.cast(typing.Optional[jsii.Number], result)
 
     def __eq__(self, rhs: typing.Any) -> builtins.bool:
@@ -355,7 +456,7 @@ class AutoScalingProps:
         return not (rhs == self)
 
     def __repr__(self) -> str:
-        return "AutoScalingProps(%s)" % ", ".join(
+        return "ContainerProps(%s)" % ", ".join(
             k + "=" + repr(v) for k, v in self._values.items()
         )
 
@@ -370,46 +471,52 @@ class EcsCodeDeploy(
         scope: _constructs_77d1e7e8.Construct,
         id: builtins.str,
         *,
-        certificate_arn: builtins.str,
         cluster: _aws_cdk_aws_ecs_ceddda9d.ICluster,
-        container_port: jsii.Number,
+        containers: typing.Sequence[typing.Union[ContainerProps, typing.Dict[builtins.str, typing.Any]]],
         environment: builtins.str,
-        image_uri: builtins.str,
         service_name: builtins.str,
+        task_exec_role: _aws_cdk_aws_iam_ceddda9d.IRole,
+        task_role: _aws_cdk_aws_iam_ceddda9d.IRole,
         vpc: _aws_cdk_aws_ec2_ceddda9d.IVpc,
         auto_scaling: typing.Optional[typing.Union[AutoScalingProps, typing.Dict[builtins.str, typing.Any]]] = None,
+        certificates: typing.Optional[typing.Sequence[_aws_cdk_aws_certificatemanager_ceddda9d.ICertificate]] = None,
         enable_public_load_balancer: typing.Optional[builtins.bool] = None,
-        health_check: typing.Optional[typing.Union[_aws_cdk_aws_ecs_ceddda9d.HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+        memory_limit: typing.Optional[jsii.Number] = None,
+        task_cpu: typing.Optional[jsii.Number] = None,
     ) -> None:
         '''
         :param scope: -
         :param id: -
-        :param certificate_arn: 
-        :param cluster: 
-        :param container_port: 
-        :param environment: 
-        :param image_uri: 
-        :param service_name: 
-        :param vpc: 
-        :param auto_scaling: 
-        :param enable_public_load_balancer: 
-        :param health_check: 
+        :param cluster: ECS Cluster where the service will run.
+        :param containers: Configuration related to the task definition and container.
+        :param environment: Environment name (e.g., dev, prod) for tagging and naming.
+        :param service_name: Base name used for resources like log groups, roles, services, etc.
+        :param task_exec_role: Task execution role for the ECS task.
+        :param task_role: Task role for the ECS task.
+        :param vpc: VPC in which to deploy ECS and ALB resources.
+        :param auto_scaling: Optional auto-scaling configuration.
+        :param certificates: Optional ACM certificates for HTTPS termination.
+        :param enable_public_load_balancer: Whether the load balancer should be internet-facing (default: false).
+        :param memory_limit: 
+        :param task_cpu: CPU units for the task (default: 1024).
         '''
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__19ac4f77d3bba1391929b87d2d23b70fe61e21aa6809f43ed4283d6ecf350909)
             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 = EcsCodeDeployProps(
-            certificate_arn=certificate_arn,
             cluster=cluster,
-            container_port=container_port,
+            containers=containers,
             environment=environment,
-            image_uri=image_uri,
             service_name=service_name,
+            task_exec_role=task_exec_role,
+            task_role=task_role,
             vpc=vpc,
             auto_scaling=auto_scaling,
+            certificates=certificates,
             enable_public_load_balancer=enable_public_load_balancer,
-            health_check=health_check,
+            memory_limit=memory_limit,
+            task_cpu=task_cpu,
         )
 
         jsii.create(self.__class__, self, [scope, id, props])
@@ -427,149 +534,176 @@ class EcsCodeDeploy(
         return typing.cast(_aws_cdk_aws_ecs_ceddda9d.FargateService, jsii.get(self, "service"))
 
     @builtins.property
-    @jsii.member(jsii_name="taskRole")
-    def task_role(self) -> _aws_cdk_aws_iam_ceddda9d.Role:
-        return typing.cast(_aws_cdk_aws_iam_ceddda9d.Role, jsii.get(self, "taskRole"))
-
-    @task_role.setter
-    def task_role(self, value: _aws_cdk_aws_iam_ceddda9d.Role) -> None:
-        if __debug__:
-            type_hints = typing.get_type_hints(_typecheckingstub__60923688f982908f977f559dbd1295485a3b0547df3c45291a862130dede0c3e)
-            check_type(argname="argument value", value=value, expected_type=type_hints["value"])
-        jsii.set(self, "taskRole", value) # pyright: ignore[reportArgumentType]
+    @jsii.member(jsii_name="taskDef")
+    def task_def(self) -> _aws_cdk_aws_ecs_ceddda9d.TaskDefinition:
+        return typing.cast(_aws_cdk_aws_ecs_ceddda9d.TaskDefinition, jsii.get(self, "taskDef"))
 
 
 @jsii.data_type(
     jsii_type="must-cdk.EcsCodeDeployProps",
     jsii_struct_bases=[],
     name_mapping={
-        "certificate_arn": "certificateArn",
         "cluster": "cluster",
-        "container_port": "containerPort",
+        "containers": "containers",
         "environment": "environment",
-        "image_uri": "imageUri",
         "service_name": "serviceName",
+        "task_exec_role": "taskExecRole",
+        "task_role": "taskRole",
         "vpc": "vpc",
         "auto_scaling": "autoScaling",
+        "certificates": "certificates",
         "enable_public_load_balancer": "enablePublicLoadBalancer",
-        "health_check": "healthCheck",
+        "memory_limit": "memoryLimit",
+        "task_cpu": "taskCPU",
     },
 )
 class EcsCodeDeployProps:
     def __init__(
         self,
         *,
-        certificate_arn: builtins.str,
         cluster: _aws_cdk_aws_ecs_ceddda9d.ICluster,
-        container_port: jsii.Number,
+        containers: typing.Sequence[typing.Union[ContainerProps, typing.Dict[builtins.str, typing.Any]]],
         environment: builtins.str,
-        image_uri: builtins.str,
         service_name: builtins.str,
+        task_exec_role: _aws_cdk_aws_iam_ceddda9d.IRole,
+        task_role: _aws_cdk_aws_iam_ceddda9d.IRole,
         vpc: _aws_cdk_aws_ec2_ceddda9d.IVpc,
         auto_scaling: typing.Optional[typing.Union[AutoScalingProps, typing.Dict[builtins.str, typing.Any]]] = None,
+        certificates: typing.Optional[typing.Sequence[_aws_cdk_aws_certificatemanager_ceddda9d.ICertificate]] = None,
         enable_public_load_balancer: typing.Optional[builtins.bool] = None,
-        health_check: typing.Optional[typing.Union[_aws_cdk_aws_ecs_ceddda9d.HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+        memory_limit: typing.Optional[jsii.Number] = None,
+        task_cpu: typing.Optional[jsii.Number] = None,
     ) -> None:
-        '''
-        :param certificate_arn: 
-        :param cluster: 
-        :param container_port: 
-        :param environment: 
-        :param image_uri: 
-        :param service_name: 
-        :param vpc: 
-        :param auto_scaling: 
-        :param enable_public_load_balancer: 
-        :param health_check: 
+        '''Properties for the EcsCodeDeploy construct.
+
+        :param cluster: ECS Cluster where the service will run.
+        :param containers: Configuration related to the task definition and container.
+        :param environment: Environment name (e.g., dev, prod) for tagging and naming.
+        :param service_name: Base name used for resources like log groups, roles, services, etc.
+        :param task_exec_role: Task execution role for the ECS task.
+        :param task_role: Task role for the ECS task.
+        :param vpc: VPC in which to deploy ECS and ALB resources.
+        :param auto_scaling: Optional auto-scaling configuration.
+        :param certificates: Optional ACM certificates for HTTPS termination.
+        :param enable_public_load_balancer: Whether the load balancer should be internet-facing (default: false).
+        :param memory_limit: 
+        :param task_cpu: CPU units for the task (default: 1024).
         '''
         if isinstance(auto_scaling, dict):
             auto_scaling = AutoScalingProps(**auto_scaling)
-        if isinstance(health_check, dict):
-            health_check = _aws_cdk_aws_ecs_ceddda9d.HealthCheck(**health_check)
         if __debug__:
             type_hints = typing.get_type_hints(_typecheckingstub__0e1edfc306738ea99e0bd03a55876d7f75a063970dd3103fc1bbb766dff014b1)
-            check_type(argname="argument certificate_arn", value=certificate_arn, expected_type=type_hints["certificate_arn"])
             check_type(argname="argument cluster", value=cluster, expected_type=type_hints["cluster"])
-            check_type(argname="argument container_port", value=container_port, expected_type=type_hints["container_port"])
+            check_type(argname="argument containers", value=containers, expected_type=type_hints["containers"])
             check_type(argname="argument environment", value=environment, expected_type=type_hints["environment"])
-            check_type(argname="argument image_uri", value=image_uri, expected_type=type_hints["image_uri"])
             check_type(argname="argument service_name", value=service_name, expected_type=type_hints["service_name"])
+            check_type(argname="argument task_exec_role", value=task_exec_role, expected_type=type_hints["task_exec_role"])
+            check_type(argname="argument task_role", value=task_role, expected_type=type_hints["task_role"])
             check_type(argname="argument vpc", value=vpc, expected_type=type_hints["vpc"])
             check_type(argname="argument auto_scaling", value=auto_scaling, expected_type=type_hints["auto_scaling"])
+            check_type(argname="argument certificates", value=certificates, expected_type=type_hints["certificates"])
             check_type(argname="argument enable_public_load_balancer", value=enable_public_load_balancer, expected_type=type_hints["enable_public_load_balancer"])
-            check_type(argname="argument health_check", value=health_check, expected_type=type_hints["health_check"])
+            check_type(argname="argument memory_limit", value=memory_limit, expected_type=type_hints["memory_limit"])
+            check_type(argname="argument task_cpu", value=task_cpu, expected_type=type_hints["task_cpu"])
         self._values: typing.Dict[builtins.str, typing.Any] = {
-            "certificate_arn": certificate_arn,
             "cluster": cluster,
-            "container_port": container_port,
+            "containers": containers,
             "environment": environment,
-            "image_uri": image_uri,
             "service_name": service_name,
+            "task_exec_role": task_exec_role,
+            "task_role": task_role,
             "vpc": vpc,
         }
         if auto_scaling is not None:
             self._values["auto_scaling"] = auto_scaling
+        if certificates is not None:
+            self._values["certificates"] = certificates
         if enable_public_load_balancer is not None:
             self._values["enable_public_load_balancer"] = enable_public_load_balancer
-        if health_check is not None:
-            self._values["health_check"] = health_check
-
-    @builtins.property
-    def certificate_arn(self) -> builtins.str:
-        result = self._values.get("certificate_arn")
-        assert result is not None, "Required property 'certificate_arn' is missing"
-        return typing.cast(builtins.str, result)
+        if memory_limit is not None:
+            self._values["memory_limit"] = memory_limit
+        if task_cpu is not None:
+            self._values["task_cpu"] = task_cpu
 
     @builtins.property
     def cluster(self) -> _aws_cdk_aws_ecs_ceddda9d.ICluster:
+        '''ECS Cluster where the service will run.'''
         result = self._values.get("cluster")
         assert result is not None, "Required property 'cluster' is missing"
         return typing.cast(_aws_cdk_aws_ecs_ceddda9d.ICluster, result)
 
     @builtins.property
-    def container_port(self) -> jsii.Number:
-        result = self._values.get("container_port")
-        assert result is not None, "Required property 'container_port' is missing"
-        return typing.cast(jsii.Number, result)
+    def containers(self) -> typing.List[ContainerProps]:
+        '''Configuration related to the task definition and container.'''
+        result = self._values.get("containers")
+        assert result is not None, "Required property 'containers' is missing"
+        return typing.cast(typing.List[ContainerProps], result)
 
     @builtins.property
     def environment(self) -> builtins.str:
+        '''Environment name (e.g., dev, prod) for tagging and naming.'''
         result = self._values.get("environment")
         assert result is not None, "Required property 'environment' is missing"
         return typing.cast(builtins.str, result)
 
-    @builtins.property
-    def image_uri(self) -> builtins.str:
-        result = self._values.get("image_uri")
-        assert result is not None, "Required property 'image_uri' is missing"
-        return typing.cast(builtins.str, result)
-
     @builtins.property
     def service_name(self) -> builtins.str:
+        '''Base name used for resources like log groups, roles, services, etc.'''
         result = self._values.get("service_name")
         assert result is not None, "Required property 'service_name' is missing"
         return typing.cast(builtins.str, result)
 
+    @builtins.property
+    def task_exec_role(self) -> _aws_cdk_aws_iam_ceddda9d.IRole:
+        '''Task execution role for the ECS task.'''
+        result = self._values.get("task_exec_role")
+        assert result is not None, "Required property 'task_exec_role' is missing"
+        return typing.cast(_aws_cdk_aws_iam_ceddda9d.IRole, result)
+
+    @builtins.property
+    def task_role(self) -> _aws_cdk_aws_iam_ceddda9d.IRole:
+        '''Task role for the ECS task.'''
+        result = self._values.get("task_role")
+        assert result is not None, "Required property 'task_role' is missing"
+        return typing.cast(_aws_cdk_aws_iam_ceddda9d.IRole, result)
+
     @builtins.property
     def vpc(self) -> _aws_cdk_aws_ec2_ceddda9d.IVpc:
+        '''VPC in which to deploy ECS and ALB resources.'''
         result = self._values.get("vpc")
         assert result is not None, "Required property 'vpc' is missing"
         return typing.cast(_aws_cdk_aws_ec2_ceddda9d.IVpc, result)
 
     @builtins.property
     def auto_scaling(self) -> typing.Optional[AutoScalingProps]:
+        '''Optional auto-scaling configuration.'''
         result = self._values.get("auto_scaling")
         return typing.cast(typing.Optional[AutoScalingProps], result)
 
+    @builtins.property
+    def certificates(
+        self,
+    ) -> typing.Optional[typing.List[_aws_cdk_aws_certificatemanager_ceddda9d.ICertificate]]:
+        '''Optional ACM certificates for HTTPS termination.'''
+        result = self._values.get("certificates")
+        return typing.cast(typing.Optional[typing.List[_aws_cdk_aws_certificatemanager_ceddda9d.ICertificate]], result)
+
     @builtins.property
     def enable_public_load_balancer(self) -> typing.Optional[builtins.bool]:
+        '''Whether the load balancer should be internet-facing (default: false).'''
         result = self._values.get("enable_public_load_balancer")
         return typing.cast(typing.Optional[builtins.bool], result)
 
     @builtins.property
-    def health_check(self) -> typing.Optional[_aws_cdk_aws_ecs_ceddda9d.HealthCheck]:
-        result = self._values.get("health_check")
-        return typing.cast(typing.Optional[_aws_cdk_aws_ecs_ceddda9d.HealthCheck], result)
+    def memory_limit(self) -> typing.Optional[jsii.Number]:
+        result = self._values.get("memory_limit")
+        return typing.cast(typing.Optional[jsii.Number], result)
+
+    @builtins.property
+    def task_cpu(self) -> typing.Optional[jsii.Number]:
+        '''CPU units for the task (default: 1024).'''
+        result = self._values.get("task_cpu")
+        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
@@ -811,6 +945,7 @@ __all__ = [
     "ApiGatewayToLambdaCustomDomain",
     "ApiGatewayToLambdaProps",
     "AutoScalingProps",
+    "ContainerProps",
     "EcsCodeDeploy",
     "EcsCodeDeployProps",
     "WebsocketApiGatewayToLambdaCustomDomain",
@@ -851,9 +986,20 @@ def _typecheckingstub__d0ea30b15daf73de785b4991457443ee0ca220224fbd08155a17d86c6
     *,
     max_capacity: jsii.Number,
     min_capacity: jsii.Number,
-    target_cpu_utilization_percent: jsii.Number,
-    scale_in_cooldown_sec: typing.Optional[jsii.Number] = None,
-    scale_out_cooldown_sec: typing.Optional[jsii.Number] = None,
+    cpu_scale: typing.Optional[typing.Union[_aws_cdk_aws_ecs_ceddda9d.CpuUtilizationScalingProps, typing.Dict[builtins.str, typing.Any]]] = None,
+    memory_scale: typing.Optional[typing.Union[_aws_cdk_aws_ecs_ceddda9d.MemoryUtilizationScalingProps, typing.Dict[builtins.str, typing.Any]]] = None,
+) -> None:
+    """Type checking stubs"""
+    pass
+
+def _typecheckingstub__54ea2679bab87dfe8eb538ebc455f8d93200c1beb37ad6e093fa52678f8ac1fc(
+    *,
+    alb_listener_container_port: jsii.Number,
+    container_port: jsii.Number,
+    image: _aws_cdk_aws_ecs_ceddda9d.ContainerImage,
+    health_check: typing.Optional[typing.Union[_aws_cdk_aws_ecs_ceddda9d.HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+    memory_limit: typing.Optional[jsii.Number] = None,
+    memory_reservation: typing.Optional[jsii.Number] = None,
 ) -> None:
     """Type checking stubs"""
     pass
@@ -862,38 +1008,36 @@ def _typecheckingstub__19ac4f77d3bba1391929b87d2d23b70fe61e21aa6809f43ed4283d6ec
     scope: _constructs_77d1e7e8.Construct,
     id: builtins.str,
     *,
-    certificate_arn: builtins.str,
     cluster: _aws_cdk_aws_ecs_ceddda9d.ICluster,
-    container_port: jsii.Number,
+    containers: typing.Sequence[typing.Union[ContainerProps, typing.Dict[builtins.str, typing.Any]]],
     environment: builtins.str,
-    image_uri: builtins.str,
     service_name: builtins.str,
+    task_exec_role: _aws_cdk_aws_iam_ceddda9d.IRole,
+    task_role: _aws_cdk_aws_iam_ceddda9d.IRole,
     vpc: _aws_cdk_aws_ec2_ceddda9d.IVpc,
     auto_scaling: typing.Optional[typing.Union[AutoScalingProps, typing.Dict[builtins.str, typing.Any]]] = None,
+    certificates: typing.Optional[typing.Sequence[_aws_cdk_aws_certificatemanager_ceddda9d.ICertificate]] = None,
     enable_public_load_balancer: typing.Optional[builtins.bool] = None,
-    health_check: typing.Optional[typing.Union[_aws_cdk_aws_ecs_ceddda9d.HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
-) -> None:
-    """Type checking stubs"""
-    pass
-
-def _typecheckingstub__60923688f982908f977f559dbd1295485a3b0547df3c45291a862130dede0c3e(
-    value: _aws_cdk_aws_iam_ceddda9d.Role,
+    memory_limit: typing.Optional[jsii.Number] = None,
+    task_cpu: typing.Optional[jsii.Number] = None,
 ) -> None:
     """Type checking stubs"""
     pass
 
 def _typecheckingstub__0e1edfc306738ea99e0bd03a55876d7f75a063970dd3103fc1bbb766dff014b1(
     *,
-    certificate_arn: builtins.str,
     cluster: _aws_cdk_aws_ecs_ceddda9d.ICluster,
-    container_port: jsii.Number,
+    containers: typing.Sequence[typing.Union[ContainerProps, typing.Dict[builtins.str, typing.Any]]],
     environment: builtins.str,
-    image_uri: builtins.str,
     service_name: builtins.str,
+    task_exec_role: _aws_cdk_aws_iam_ceddda9d.IRole,
+    task_role: _aws_cdk_aws_iam_ceddda9d.IRole,
     vpc: _aws_cdk_aws_ec2_ceddda9d.IVpc,
     auto_scaling: typing.Optional[typing.Union[AutoScalingProps, typing.Dict[builtins.str, typing.Any]]] = None,
+    certificates: typing.Optional[typing.Sequence[_aws_cdk_aws_certificatemanager_ceddda9d.ICertificate]] = None,
     enable_public_load_balancer: typing.Optional[builtins.bool] = None,
-    health_check: typing.Optional[typing.Union[_aws_cdk_aws_ecs_ceddda9d.HealthCheck, typing.Dict[builtins.str, typing.Any]]] = None,
+    memory_limit: typing.Optional[jsii.Number] = None,
+    task_cpu: typing.Optional[jsii.Number] = None,
 ) -> None:
     """Type checking stubs"""
     pass

must_cdk/_jsii/__init__.py

@@ -32,7 +32,7 @@ import aws_cdk._jsii
 import constructs._jsii
 
 __jsii_assembly__ = jsii.JSIIAssembly.load(
-    "must-cdk", "0.0.7", __name__[0:-6], "must-cdk@0.0.7.jsii.tgz"
+    "must-cdk", "0.0.9", __name__[0:-6], "must-cdk@0.0.9.jsii.tgz"
 )
 
 __all__ = [

{must_cdk-0.0.7.dist-info → must_cdk-0.0.9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: must-cdk
-Version: 0.0.7
+Version: 0.0.9
 Summary: must-cdk
 Home-page: https://github.com/globalmsq/must-cdk.git
 Author: Must Admin<admin-mufin@users.noreply.github.com>

must_cdk-0.0.9.dist-info/RECORD

@@ -0,0 +1,9 @@
+must_cdk/__init__.py,sha256=TAUyyyvgdJTiUBeoFcBz2eaKSIbVLCHBbfZnOrR80fA,53859
+must_cdk/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+must_cdk/_jsii/__init__.py,sha256=IHz_nKI_sBm69hGz72z70pKB6WoPfg7GhcNc9lQbsbg,1427
+must_cdk/_jsii/must-cdk@0.0.9.jsii.tgz,sha256=RQC5RbqiOfUAEJWPCN-jOd-4EI0_iklSZNu6ZjmKIaQ,270774
+must_cdk-0.0.9.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
+must_cdk-0.0.9.dist-info/METADATA,sha256=F-dH03rumvr4EwgJ7Zclh7RsCWWPXDSGCVNRJt-y1OY,1040
+must_cdk-0.0.9.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
+must_cdk-0.0.9.dist-info/top_level.txt,sha256=xm4unKYFXnjqQyemg16SUHfrXIb5XMbfUC_3xNsFyjc,9
+must_cdk-0.0.9.dist-info/RECORD,,

must_cdk-0.0.7.dist-info/RECORD

@@ -1,9 +0,0 @@
-must_cdk/__init__.py,sha256=Vr5-hlH0pStuugnHfcmPGswsAsPR7Qq0-5ly1gU_Zw8,45370
-must_cdk/py.typed,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
-must_cdk/_jsii/__init__.py,sha256=rmBzY32LMUfTu6epCg7MZsj7WSydE35KmBZdCihEjTk,1427
-must_cdk/_jsii/must-cdk@0.0.7.jsii.tgz,sha256=CPtkLSsfw1HM-ztd07Yz5l_qI4cV_UVBnv557mIGNv4,480139
-must_cdk-0.0.7.dist-info/LICENSE,sha256=z8d0m5b2O9McPEK1xHG_dWgUBT6EfBDz6wA0F7xSPTA,11358
-must_cdk-0.0.7.dist-info/METADATA,sha256=stt7CpOE0VcIxUVDsToPny-gyZ39adH-FgfbMhyiK9o,1040
-must_cdk-0.0.7.dist-info/WHEEL,sha256=iAkIy5fosb7FzIOwONchHf19Qu7_1wCWyFNR5gu9nU0,91
-must_cdk-0.0.7.dist-info/top_level.txt,sha256=xm4unKYFXnjqQyemg16SUHfrXIb5XMbfUC_3xNsFyjc,9
-must_cdk-0.0.7.dist-info/RECORD,,