aws-cdk-constructs 2.40.1__tar.gz → 2.41.0__tar.gz

{aws_cdk_constructs-2.40.1/aws_cdk_constructs.egg-info → aws_cdk_constructs-2.41.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws_cdk_constructs
-Version: 2.40.1
+Version: 2.41.0
 Summary: AWS CDK constructs
 Home-page: https://bitbucket.org/cioapps/aws-cdk-constructs
 Author: author

{aws_cdk_constructs-2.40.1 → aws_cdk_constructs-2.41.0}/aws_cdk_constructs/__init__.py

@@ -15,4 +15,4 @@ from .load_balancer import Alb, Nlb
 from .security_group import SecurityGroup
 from .windows_server import WindowsServer
 
-__version__ = '2.40.1'
+__version__ = '2.41.0'

{aws_cdk_constructs-2.40.1 → aws_cdk_constructs-2.41.0}/aws_cdk_constructs/ecs/cluster.py

@@ -1,16 +1,20 @@
 from __future__ import annotations
 
-from typing import List, Optional, TYPE_CHECKING, Dict
-
 from aws_cdk import (
     aws_ecs as _ecs,
     aws_ec2 as _ec2,
+    aws_iam as _iam,
     aws_route53 as _route53,
     aws_cloudwatch as _cloudwatch,
     aws_elasticloadbalancingv2 as _elb,
+    aws_autoscaling as _autoscaling,
+    aws_secretsmanager as _secretsmanager,
     Duration,
+    Tags,
 )
 from constructs import Construct
+from typing import List, Optional, TYPE_CHECKING, Dict
+
 from aws_cdk_constructs.load_balancer import Alb
 
 if TYPE_CHECKING:
@@ -61,6 +65,20 @@ class ECSCluster(Construct):
             use_cdn (Optional - bool): Add cloudflare IPs to the ALB security group
 
             load_balancer_idle_timeout (Optional int): Sets the default timeout for the ALB in seconds. Defaults to 50s in ALB construct
+
+            ec2_enable (Optional - bool): Enables a EC2 capacity provider in the cluster.
+
+            ec2_instance_type (Optional - str): The instance type to be used by the EC2 capacity provider.
+
+            ec2_desired_capacity (Optional - int): The desired capacity of the EC2 capacity provider.
+
+            ec2_max_capacity (Optional - int): The max capacity of the EC2 capacity provider.
+
+            ec2_tag_scheduler_uptime (Optional - str): The tag to be used to filter the EC2 instances to be used by the scheduler.
+
+            ec2_tag_scheduler_uptime_days (Optional - str): The tag to be used to filter the EC2 instances to be used by the scheduler.
+
+            ec2_tag_scheduler_skip (Optional - str): The tag to be used to filter the EC2 instances to be used by the scheduler.
     """
 
     def __init__(
@@ -80,6 +98,13 @@ class ECSCluster(Construct):
         use_cdn: Optional[bool] = False,
         ssl_certificate_arn: Optional[str] = None,
         load_balancer_idle_timeout: Optional[int] = None,
+        ec2_enable: Optional[bool] = False,
+        ec2_instance_type: Optional[str] = None,
+        ec2_desired_capacity: Optional[int] = None,
+        ec2_max_capacity: Optional[int] = None,
+        ec2_tag_scheduler_uptime: Optional[str] = '08:00-18:00',
+        ec2_tag_scheduler_uptime_days: Optional[str] = '1-2-3-4-5',
+        ec2_tag_scheduler_skip: Optional[str] = 'False',
     ) -> None:
         self.id = id
         self.scope = scope
@@ -99,6 +124,18 @@ class ECSCluster(Construct):
         )
         self.create_alb = create_alb
 
+        self.ec2_enabled = all(
+            [
+                ec2_enable,
+                ec2_max_capacity,
+                ec2_desired_capacity,
+                ec2_instance_type,
+            ]
+        )
+        self.ec2_instance_type = (ec2_instance_type,)
+        self.ec2_max_capacity = (ec2_max_capacity,)
+        self.ec2_desired_capacity = ec2_desired_capacity
+
         super().__init__(scope, id)
 
         create_alb_dns = 'True' if create_alb_dns else 'False'
@@ -129,6 +166,129 @@ class ECSCluster(Construct):
         else:
             self.alb = None
 
+        if self.ec2_enabled:
+            self.ecs_sg = _ec2.SecurityGroup(
+                self, f'{app_name}-sg', vpc=self.vpc
+            )
+            self.ecs_sg.add_ingress_rule(
+                peer=self.alb.security_group,
+                connection=_ec2.Port.tcp_range(
+                    start_port=32768, end_port=65535
+                ),
+            )
+            self._ec2_role = _iam.Role(
+                self,
+                'asg_role',
+                description=app_name + '_' + '_ec2_role',
+                assumed_by=_iam.ServicePrincipal('ec2.amazonaws.com'),
+                managed_policies=[
+                    # AWS managed policy to allow sending logs and custom metrics to CloudWatch
+                    _iam.ManagedPolicy.from_aws_managed_policy_name(
+                        'CloudWatchAgentServerPolicy'
+                    ),
+                    # AWS managed policy to allow Session Manager console connections to the EC2 instance
+                    _iam.ManagedPolicy.from_aws_managed_policy_name(
+                        'AmazonSSMManagedInstanceCore'
+                    ),
+                ],
+                role_name=app_name + '_' + '_ec2_role',
+            )
+
+            user_data = _ec2.UserData.for_linux()
+            user_data.add_commands(
+                'yum -y install docker',
+                'service docker start',
+                'curl -O https://s3.eu-west-1.amazonaws.com/amazon-ecs-agent-eu-west-1/amazon-ecs-init-latest.x86_64.rpm',
+                'sudo yum localinstall -y amazon-ecs-init-latest.x86_64.rpm',
+                f"echo 'ECS_CLUSTER={self.cluster.cluster_name}' >> /etc/ecs/ecs.config",
+                "echo 'ECS_ENABLE_TASK_IAM_ROLE=true' >> /etc/ecs/ecs.config",
+                'echo \'ECS_AVAILABLE_LOGGING_DRIVERS=["awslogs"]\' >> /etc/ecs/ecs.config',
+                'cat /etc/ecs/ecs.config',
+                'service ecs start',
+                'yum install -y https://s3.amazonaws.com/ec2-downloads-windows/SSMAgent/latest/linux_amd64/amazon-ssm-agent.rpm',
+                'sudo systemctl status amazon-ssm-agent',
+                'ssm-cli get-diagnostics --output table',
+            )
+            machine_image = _ec2.GenericLinuxImage(
+                {'eu-west-1': self._get_ami_id(f'{self.id}-ami-id')}
+            )
+
+            if not machine_image:
+                raise TypeError(
+                    f'Impossible to determine the AMI ID for environment: {self.environment}'
+                )
+            launch_template = _ec2.LaunchTemplate(
+                self,
+                f'{app_name}-lt',
+                detailed_monitoring=True,
+                machine_image=machine_image,
+                role=self._ec2_role,
+                user_data=user_data,
+                security_group=self.ecs_sg,
+                instance_type=_ec2.InstanceType(ec2_instance_type),
+            )
+            auto_scaling_group = _autoscaling.AutoScalingGroup(
+                self,
+                f'{app_name}-asg',
+                vpc=self.vpc,
+                allow_all_outbound=True,
+                desired_capacity=ec2_desired_capacity,
+                max_capacity=ec2_max_capacity,
+                launch_template=launch_template,
+            )
+
+            capacity_provider = _ecs.AsgCapacityProvider(
+                self,
+                f'{app_name}-AsgCapacityProvider',
+                auto_scaling_group=auto_scaling_group,
+            )
+            self.cluster.add_asg_capacity_provider(capacity_provider)
+            Tags.of(auto_scaling_group).add(
+                'SchedulerSkip',
+                ec2_tag_scheduler_skip,
+                apply_to_launched_instances=True,
+            )
+            Tags.of(auto_scaling_group).add(
+                'SchedulerUptime',
+                ec2_tag_scheduler_uptime,
+                apply_to_launched_instances=True,
+            )
+            Tags.of(auto_scaling_group).add(
+                'SchedulerUptimeDays',
+                ec2_tag_scheduler_uptime_days,
+                apply_to_launched_instances=True,
+            )
+
+    def _get_ami_id(self, id):
+        ami_secret_arn = self.environments_parameters.get('common').get(
+            'al2023_x86_64_ami_secret_arn'
+        )
+        # Determine the Image Architecture to retrieve the correspondent secret ID
+        # Get the AMI secret as json
+        secret_obj = _secretsmanager.Secret.from_secret_complete_arn(
+            scope=self,
+            id=self.id + '_ami_secret' + id,
+            secret_complete_arn=ami_secret_arn,
+        )
+        # Normalize the environment name
+        # We only has three development stages (development, qa, production)
+        # Any other environment will use the production version of the AMI (like Shared Services, which is a production environment)
+        development_stages = ['development', 'qa', 'production']
+        ami_secret_environment = ('production', self.environment)[
+            self.environment.lower in development_stages
+        ]
+
+        ami_secret_environment_lower = ami_secret_environment.lower()
+        # Get the AMI id correspondent to the selected environment, as CDK token
+        ec2_ami_id = secret_obj.secret_value_from_json(
+            f'{ami_secret_environment_lower}/ami_id'
+        ).unsafe_unwrap()  # Unsafe unwrap as we accept that the value is part of the cloudformation template
+        if not ec2_ami_id:
+            raise TypeError(
+                f'Impossible to retrieve the AMI ID from secrets manager for environment: {self.environment}'
+            )
+        return ec2_ami_id
+
     def _get_vpc(self) -> _ec2.IVpc:
         return _ec2.Vpc.from_lookup(
             self.scope, self.id + 'VPC', vpc_id=self.aws_account.get('vpc')

{aws_cdk_constructs-2.40.1 → aws_cdk_constructs-2.41.0}/aws_cdk_constructs/ecs/microservice.py

@@ -18,8 +18,8 @@ from aws_cdk import (
 )
 from constructs import Construct
 
-from aws_cdk_constructs.efs.volume import EFSVolume
 from aws_cdk_constructs.ecs.fargate_validator import FargateValidator
+from aws_cdk_constructs.efs.volume import EFSVolume
 
 if TYPE_CHECKING:
     from .cluster import ECSCluster
@@ -105,6 +105,8 @@ class ECSMicroservice(Construct):
 
         max_buffer_size_mib (int): The size (mebibytes) of the buffer when log_driver_blocking_mode is set to false. Default: 4
 
+        deploy_to_ec2 (bool): When set to true the service will be deployed to EC2 instead of Fargate. Default: false
+
     """
 
     def __init__(
@@ -136,9 +138,11 @@ class ECSMicroservice(Construct):
         health_check_timeout: int = 5,
         internal: bool = False,
         alternative_fqdns: list[str] = [],
+        ephemeral_storage_gib: int = 21,
         omit_cloudformation_template_outputs: bool = False,
         log_driver_blocking_mode: bool = False,
         max_buffer_size_mib: int = 4,
+        deploy_to_ec2: [bool] = False,
     ) -> None:
         self.scope = scope
         self.id = name
@@ -165,6 +169,8 @@ class ECSMicroservice(Construct):
         self.environment = self.cluster.environment
         self.log_driver_blocking_mode = log_driver_blocking_mode
         self.max_buffer_size_mib = max_buffer_size_mib
+        self.ephemeral_storage_gib = ephemeral_storage_gib
+        self.deploy_to_ec2 = deploy_to_ec2
 
         if not log_driver_blocking_mode:
             # Configure ECS logging in non-blocking mode and the buffer size when the log_driver_blocking_mode is set to False (default value)
@@ -209,28 +215,51 @@ class ECSMicroservice(Construct):
         if self.cluster.alb is not None and internal is False:
             lb_target_priority = self.cluster.alb.get_safe_rule_priority()
             self.cluster.target_priority = lb_target_priority
-            self.target_group = self.cluster.alb.listener.add_targets(
-                self.id,
-                port=self.port,
-                targets=[self.service],
-                priority=lb_target_priority,
-                protocol=_elb.ApplicationProtocol.HTTP,
-                health_check=_elb.HealthCheck(
-                    port=str(self.port),
-                    path=self.health_check_path,
-                    healthy_threshold_count=healthy_threshold_count,
-                    unhealthy_threshold_count=unhealthy_threshold_count,
-                    interval=Duration.seconds(health_check_interval),
-                    timeout=Duration.seconds(health_check_timeout),
-                ),
-                conditions=[
-                    _elb.ListenerCondition.host_headers(
-                        [
-                            f'{self.id}-{self.cluster.app_name}.{self.cluster.domain_name}'
-                        ]
-                    )
-                ],
-            )
+
+            if self.deploy_to_ec2:
+                self.target_group = self.cluster.alb.listener.add_targets(
+                    self.id,
+                    targets=[self.service],
+                    priority=lb_target_priority,
+                    protocol=_elb.ApplicationProtocol.HTTP,
+                    health_check=_elb.HealthCheck(
+                        path=self.health_check_path,
+                        healthy_threshold_count=healthy_threshold_count,
+                        unhealthy_threshold_count=unhealthy_threshold_count,
+                        interval=Duration.seconds(health_check_interval),
+                        timeout=Duration.seconds(health_check_timeout),
+                    ),
+                    conditions=[
+                        _elb.ListenerCondition.host_headers(
+                            [
+                                f'{self.id}-{self.cluster.app_name}.{self.cluster.domain_name}'
+                            ]
+                        )
+                    ],
+                )
+            else:
+                self.target_group = self.cluster.alb.listener.add_targets(
+                    self.id,
+                    port=self.port,
+                    targets=[self.service],
+                    priority=lb_target_priority,
+                    protocol=_elb.ApplicationProtocol.HTTP,
+                    health_check=_elb.HealthCheck(
+                        port=str(self.port),
+                        path=self.health_check_path,
+                        healthy_threshold_count=healthy_threshold_count,
+                        unhealthy_threshold_count=unhealthy_threshold_count,
+                        interval=Duration.seconds(health_check_interval),
+                        timeout=Duration.seconds(health_check_timeout),
+                    ),
+                    conditions=[
+                        _elb.ListenerCondition.host_headers(
+                            [
+                                f'{self.id}-{self.cluster.app_name}.{self.cluster.domain_name}'
+                            ]
+                        )
+                    ],
+                )
             if alternative_fqdns:
                 for fqdn in alternative_fqdns:
                     lb_target_priority = (
@@ -248,11 +277,19 @@ class ECSMicroservice(Construct):
                         ],
                     )
 
-            self.cluster.alb.security_group.add_ingress_rule(
-                peer=self.security_group,
-                connection=_ec2.Port.all_traffic(),
-                description='Allow ALB to access the service',
-            )
+            if deploy_to_ec2:
+                self.cluster.alb.security_group.add_ingress_rule(
+                    peer=self.cluster.ecs_sg,
+                    connection=_ec2.Port.all_traffic(),
+                    description='Allow ALB to access the service',
+                )
+            else:
+
+                self.cluster.alb.security_group.add_ingress_rule(
+                    peer=self.security_group,
+                    connection=_ec2.Port.all_traffic(),
+                    description='Allow ALB to access the service',
+                )
 
         if self.cluster.hosted_zone:
             self.create_cname(self.cluster.hosted_zone)
@@ -289,12 +326,22 @@ class ECSMicroservice(Construct):
 
         :returns: aws_ecs.FargateTaskDefinition object
         """
-        return _ecs.FargateTaskDefinition(
-            scope=self.scope,
-            id=self.id + '-task',
-            cpu=self.cpu,
-            memory_limit_mib=self.memory_limit_mib,
-        )
+        if self.deploy_to_ec2:
+            task = _ecs.TaskDefinition(
+                compatibility=_ecs.Compatibility.EC2,
+                scope=self.scope,
+                id=self.id + '-task',
+            )
+            return task
+        else:
+
+            return _ecs.FargateTaskDefinition(
+                scope=self.scope,
+                id=self.id + '-task',
+                cpu=self.cpu,
+                memory_limit_mib=self.memory_limit_mib,
+                ephemeral_storage_gib=self.ephemeral_storage_gib,
+            )
 
     def _create_main_container(self) -> _ecs.ContainerDefinition:
         """Create the main container for the service,  based on the ECR image and attaches it to the task definition
@@ -319,19 +366,36 @@ class ECSMicroservice(Construct):
                 )
             )
 
-        return self.task.add_container(
-            id=self.id + '-main-container',
-            image=image,
-            port_mappings=[_ecs.PortMapping(container_port=self.port)],
-            logging=_ecs.LogDriver.aws_logs(
-                stream_prefix=self.id + '-main-container',
-                log_retention=_logs.RetentionDays.ONE_WEEK,
-                mode=self.log_driver_mode,
-                max_buffer_size=self.max_buffer_size,
-            ),
-            environment=self.container_env,
-            entry_point=self.entry_point,
-        )
+        if self.deploy_to_ec2:
+            return self.task.add_container(
+                id=self.id + '-main-container',
+                image=image,
+                cpu=self.cpu,
+                memory_reservation_mib=self.memory_limit_mib,
+                port_mappings=[_ecs.PortMapping(container_port=self.port)],
+                logging=_ecs.LogDriver.aws_logs(
+                    stream_prefix=self.id + '-main-container',
+                    log_retention=_logs.RetentionDays.ONE_WEEK,
+                    mode=self.log_driver_mode,
+                    max_buffer_size=self.max_buffer_size,
+                ),
+                environment=self.container_env,
+                entry_point=self.entry_point,
+            )
+        else:
+            return self.task.add_container(
+                id=self.id + '-main-container',
+                image=image,
+                port_mappings=[_ecs.PortMapping(container_port=self.port)],
+                logging=_ecs.LogDriver.aws_logs(
+                    stream_prefix=self.id + '-main-container',
+                    log_retention=_logs.RetentionDays.ONE_WEEK,
+                    mode=self.log_driver_mode,
+                    max_buffer_size=self.max_buffer_size,
+                ),
+                environment=self.container_env,
+                entry_point=self.entry_point,
+            )
 
     def _create_autoscaling(self) -> Optional[_ecs.ScalableTaskCount]:
         """Create the autoscaling settings for the service, if there's a max_number of replicas"""
@@ -344,16 +408,27 @@ class ECSMicroservice(Construct):
 
     def _create_service(self) -> _ecs.FargateService:
         """Creates the Fargate Service"""
-        return _ecs.FargateService(
-            scope=self.scope,
-            id=self.id + '-srv',
-            task_definition=self.task,
-            security_groups=self.security_groups,
-            cluster=self.cluster.cluster,
-            enable_execute_command=True,
-            desired_count=self.desired_count,
-            propagate_tags=_ecs.PropagatedTagSource.SERVICE,
-        )
+        if self.deploy_to_ec2:
+            return _ecs.Ec2Service(
+                scope=self.scope,
+                id=self.id + '-srv',
+                task_definition=self.task,
+                cluster=self.cluster.cluster,
+                enable_execute_command=False,
+                desired_count=self.desired_count,
+                propagate_tags=_ecs.PropagatedTagSource.SERVICE,
+            )
+        else:
+            return _ecs.FargateService(
+                scope=self.scope,
+                id=self.id + '-srv',
+                task_definition=self.task,
+                security_groups=self.security_groups,
+                cluster=self.cluster.cluster,
+                enable_execute_command=True,
+                desired_count=self.desired_count,
+                propagate_tags=_ecs.PropagatedTagSource.SERVICE,
+            )
 
     def attach_volume(self, name: str, mount_point: str) -> EFSVolume:
         """Public method to create and attach an EFS volume to the containers
@@ -371,7 +446,11 @@ class ECSMicroservice(Construct):
             environments_parameters=self.environments_parameters,
             app_name=self.cluster.app_name,
         )
-        volume.grant_access(self.security_group)
+        if self.deploy_to_ec2:
+            volume.grant_access(self.cluster.ecs_sg)
+        else:
+            volume.grant_access(self.security_group)
+
         self.task.node.add_dependency(volume)
         self.task.add_volume(
             name=volume.id,
@@ -398,19 +477,37 @@ class ECSMicroservice(Construct):
             directory=os.getcwd() + dockerfile_path,
         )
 
-        init_container = self.task.add_container(
-            id=f'{self.id}-{name}-init-container',
-            image=_ecs.ContainerImage.from_docker_image_asset(
-                init_container_image
-            ),
-            essential=False,
-            logging=_ecs.LogDriver.aws_logs(
-                stream_prefix=f'{self.id}-{name}-init-container',
-                log_retention=_logs.RetentionDays.ONE_WEEK,
-                mode=self.log_driver_mode,
-                max_buffer_size=self.max_buffer_size,
-            ),
-        )
+        if self.deploy_to_ec2:
+            init_container = self.task.add_container(
+                id=f'{self.id}-{name}-init-container',
+                image=_ecs.ContainerImage.from_docker_image_asset(
+                    init_container_image
+                ),
+                cpu=self.cpu,
+                memory_reservation_mib=self.memory_limit_mib,
+                essential=False,
+                logging=_ecs.LogDriver.aws_logs(
+                    stream_prefix=f'{self.id}-{name}-init-container',
+                    log_retention=_logs.RetentionDays.ONE_WEEK,
+                    mode=self.log_driver_mode,
+                    max_buffer_size=self.max_buffer_size,
+                ),
+            )
+        else:
+
+            init_container = self.task.add_container(
+                id=f'{self.id}-{name}-init-container',
+                image=_ecs.ContainerImage.from_docker_image_asset(
+                    init_container_image
+                ),
+                essential=False,
+                logging=_ecs.LogDriver.aws_logs(
+                    stream_prefix=f'{self.id}-{name}-init-container',
+                    log_retention=_logs.RetentionDays.ONE_WEEK,
+                    mode=self.log_driver_mode,
+                    max_buffer_size=self.max_buffer_size,
+                ),
+            )
 
         init_container.node.add_dependency(volume)
         self.main_container.add_container_dependencies(

{aws_cdk_constructs-2.40.1 → aws_cdk_constructs-2.41.0/aws_cdk_constructs.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: aws_cdk_constructs
-Version: 2.40.1
+Version: 2.41.0
 Summary: AWS CDK constructs
 Home-page: https://bitbucket.org/cioapps/aws-cdk-constructs
 Author: author

{aws_cdk_constructs-2.40.1 → aws_cdk_constructs-2.41.0}/tests/test_ecs_cluster.py

@@ -472,3 +472,168 @@ def test_cluster_render_widgets_from_microservices_internal_are_ignored(
         .get('Fn::Join')[1]
     )
     assert len(widgets) == 97
+
+
+def test_ecs_requires_all_ec2_params_to_be_enables(
+    stack, vpc, hosted_zone, environment_parameters, mocker
+):
+    mocker.patch('aws_cdk.aws_ec2.Vpc.from_lookup', return_value=vpc)
+    cluster = ECSCluster(
+        scope=stack,
+        id='x',
+        environment='development',
+        environments_parameters=environment_parameters,
+        app_name='testapp',
+        hosted_zone=hosted_zone,
+        target_priority=100,
+        ec2_enable=True,
+        ec2_instance_type='t2.micro',
+        ec2_max_capacity=1,
+    )
+
+    assert cluster.ec2_enabled == False
+
+
+def test_ecs_with_ec2_creates_sg_with_port_range(
+    stack, vpc, hosted_zone, environment_parameters, mocker
+):
+    mocker.patch('aws_cdk.aws_ec2.Vpc.from_lookup', return_value=vpc)
+    cluster = ECSCluster(
+        scope=stack,
+        id='x',
+        environment='development',
+        environments_parameters=environment_parameters,
+        app_name='testapp',
+        hosted_zone=hosted_zone,
+        target_priority=100,
+        ec2_enable=True,
+        ec2_instance_type='t2.micro',
+        ec2_max_capacity=1,
+        ec2_desired_capacity=1,
+    )
+    template = Template.from_stack(stack)
+    alb_sg = template.find_resources(
+        'AWS::EC2::SecurityGroup',
+        {
+            'Properties': {
+                'GroupName': f'testapp_{stack.stack_name}_alb_sg',
+            }
+        },
+    )
+    alb_sg_id = list(alb_sg.keys())[0]
+    template.has_resource_properties(
+        'AWS::EC2::SecurityGroupIngress',
+        {
+            'FromPort': 32768,
+            'IpProtocol': 'tcp',
+            'SourceSecurityGroupId': {'Fn::GetAtt': [alb_sg_id, 'GroupId']},
+            'ToPort': 65535,
+        },
+    )
+
+
+def test_ecs_with_ec2_creates_right_launch_template(
+    stack, vpc, hosted_zone, environment_parameters, mocker
+):
+    mocker.patch('aws_cdk.aws_ec2.Vpc.from_lookup', return_value=vpc)
+    secret = cdk.aws_secretsmanager.Secret(
+        stack,
+        'Secret',
+        secret_object_value={
+            'production/ami_id': cdk.SecretValue.unsafe_plain_text(
+                'ami_id_response'
+            )
+        },
+    )
+    mocker.patch(
+        'aws_cdk.aws_secretsmanager.Secret.from_secret_complete_arn',
+        return_value=secret,
+    )
+    cluster = ECSCluster(
+        scope=stack,
+        id='x',
+        environment='development',
+        environments_parameters=environment_parameters,
+        app_name='testapp',
+        hosted_zone=hosted_zone,
+        target_priority=100,
+        ec2_enable=True,
+        ec2_instance_type='t2.micro',
+        ec2_max_capacity=1,
+        ec2_desired_capacity=1,
+    )
+
+    template = Template.from_stack(stack)
+    secret = template.find_resources(
+        'AWS::SecretsManager::Secret',
+        {
+            'Properties': {
+                'SecretString': '{"production/ami_id":"ami_id_response"}'
+            }
+        },
+    )
+    secret_id = list(secret.keys())[0]
+    template.has_resource_properties(
+        'AWS::EC2::LaunchTemplate',
+        {
+            'LaunchTemplateData': {
+                'ImageId': {
+                    'Fn::Join': [
+                        '',
+                        [
+                            '{{resolve:secretsmanager:',
+                            {'Ref': secret_id},
+                            ':SecretString:production/ami_id::}}',
+                        ],
+                    ]
+                },
+                'InstanceType': 't2.micro',
+            }
+        },
+    )
+
+
+def test_ecs_with_ec2_creates_asg(
+    stack, vpc, hosted_zone, environment_parameters, mocker
+):
+    mocker.patch('aws_cdk.aws_ec2.Vpc.from_lookup', return_value=vpc)
+
+    cluster = ECSCluster(
+        scope=stack,
+        id='x',
+        environment='development',
+        environments_parameters=environment_parameters,
+        app_name='testapp',
+        hosted_zone=hosted_zone,
+        target_priority=100,
+        ec2_enable=True,
+        ec2_instance_type='t2.micro',
+        ec2_max_capacity=1,
+        ec2_desired_capacity=1,
+    )
+    template = Template.from_stack(stack)
+    template.has_resource_properties(
+        'AWS::AutoScaling::AutoScalingGroup',
+        {
+            'DesiredCapacity': '1',
+            'MaxSize': '1',
+            'MinSize': '1',
+            'Tags': [
+                {
+                    'Key': 'SchedulerSkip',
+                    'PropagateAtLaunch': True,
+                    'Value': 'False',
+                },
+                {
+                    'Key': 'SchedulerUptime',
+                    'PropagateAtLaunch': True,
+                    'Value': '08:00-18:00',
+                },
+                {
+                    'Key': 'SchedulerUptimeDays',
+                    'PropagateAtLaunch': True,
+                    'Value': '1-2-3-4-5',
+                },
+            ],
+        },
+    )

{aws_cdk_constructs-2.40.1 → aws_cdk_constructs-2.41.0}/tests/test_ecs_microservice.py

@@ -36,6 +36,23 @@ def cluster(stack, vpc, mocker, environment_parameters):
     )
 
 
+@pytest.fixture
+def cluster_ec2(stack, vpc, mocker, environment_parameters):
+    mocker.patch('aws_cdk.aws_ec2.Vpc.from_lookup', return_value=vpc)
+
+    return ECSCluster(
+        scope=stack,
+        id='x',
+        environments_parameters=environment_parameters,
+        environment='development',
+        app_name='test-app',
+        ec2_enable=True,
+        ec2_instance_type='t2.micro',
+        ec2_max_capacity=1,
+        ec2_desired_capacity=1,
+    )
+
+
 @pytest.fixture
 def template(stack, ms):
     return Template.from_stack(stack)
@@ -48,6 +65,17 @@ def ms(stack, cluster):
     )
 
 
+@pytest.fixture
+def ms_ec2(stack, cluster_ec2):
+    return ECSMicroservice(
+        scope=stack,
+        name='test-ms',
+        image='repository/image',
+        cluster=cluster_ec2,
+        deploy_to_ec2=True,
+    )
+
+
 def test_construct_default_values(stack, cluster, ms):
     assert ms.id == 'test-ms'
     assert ms.image == 'repository/image'
@@ -650,3 +678,34 @@ def test_ms_log_blocking_mode(stack, cluster):
             ],
         },
     )
+
+
+def test_ms_on_ec2_has_autoassigend_port_on_targetgroup(
+    stack, cluster_ec2, ms_ec2
+):
+    template = Template.from_stack(stack)
+    template.has_resource_properties(
+        'AWS::ElasticLoadBalancingV2::TargetGroup',
+        {'Port': 80, 'TargetType': 'instance'},
+    )
+
+
+def test_ms_on_ec2_adds_sg_from_ec2_to_alb(stack, cluster_ec2, ms_ec2):
+    template = Template.from_stack(stack)
+    srv_sg = template.find_resources(
+        'AWS::EC2::SecurityGroup',
+        {'Properties': {'GroupDescription': 'test-stack/x/test-app-sg'}},
+    )
+
+    srv_sg_id = list(srv_sg.keys())[0]
+    template.has_resource_properties(
+        'AWS::EC2::SecurityGroupIngress',
+        {'SourceSecurityGroupId': {'Fn::GetAtt': [srv_sg_id, 'GroupId']}},
+    )
+
+
+def test_ms_has_launch_type_ec2(stack, cluster_ec2, ms_ec2):
+    template = Template.from_stack(stack)
+    template.has_resource_properties(
+        'AWS::ECS::Service', {'LaunchType': 'EC2'}
+    )