CDK Stack

my_stack.py

from aws_cdk.core import Stack, Construct, RemovalPolicy, Duration
import aws_cdk.aws_iam as iam
import aws_cdk.aws_sqs as sqs
import aws_cdk.aws_cloudwatch as cw
import aws_cdk.aws_ec2 as ec2
import aws_cdk.aws_autoscaling as autoscaling
from aws_cdk.aws_cloudwatch_actions import AutoScalingAction


vpc_id = "vpc-0123456789abc"
key_name = "my_ssh_key-dev"


class MyCdkStack(Stack):

    def __init__(self, scope: Construct, id: str, **kwargs) -> None:
        super().__init__(scope, id, **kwargs)

        # IAM role for EC2 to access to SQS
        role = iam.Role(self, "Ec2SqsRole",
                        description="Allow EC2 instances to interact with SQS queues",
                        assumed_by=iam.ServicePrincipal("ec2.amazonaws.com"),
                        managed_policies=[iam.ManagedPolicy.from_aws_managed_policy_name("AmazonSQSFullAccess")],
                        role_name="EC2_SQS_Role")

        # SQS queue
        queue = sqs.Queue(self, "ToBeProcessedQueue",
                          queue_name="To_Be_Processed_Queue")

        # CloudWatch Alarms
        metric = queue.metric_approximate_number_of_messages_visible(period=Duration.minutes(1),
                                                                     statistic="Average")
        scale_out_init = metric.create_alarm(self, "ScaleOutInit",
                                             alarm_name="ScaleOutInit",
                                             alarm_description="First scale out when a message is available",
                                             threshold=0,
                                             evaluation_periods=1,
                                             comparison_operator=cw.ComparisonOperator.GREATER_THAN_THRESHOLD,
                                             statistic="Average",
                                             treat_missing_data=cw.TreatMissingData.NOT_BREACHING)

        # VPC
        vpc = ec2.Vpc.from_lookup(self, "VPC", vpc_id=vpc_id)

        # Subnet
        vpc_subnets = ec2.SubnetSelection(subnet_type=ec2.SubnetType.PRIVATE)

        # Security Group
        sg = ec2.SecurityGroup.from_security_group_id(self, "MYSG",
                                                      security_group_id="sg-0123456789abc")

        # AMI
        ami = ec2.MachineImage.generic_linux({
                                                 "ca-central-1": "ami-0123456789abc"
                                             })

        # Auto-scaling group
        asg = autoscaling.AutoScalingGroup(self, "ASG",
                                           role=role,
                                           vpc=vpc,
                                           instance_type=ec2.InstanceType(instance_type_identifier="t2.micro"),
                                           machine_image=ami,
                                           key_name=key_name,
                                           vpc_subnets=vpc_subnets,
                                           desired_capacity=0,
                                           max_capacity=2,
                                           min_capacity=0)
        asg.add_security_group(sg)

        scaling_action = autoscaling.StepScalingAction(self,
                                                       "scaleout",
                                                       auto_scaling_group=asg,
                                                       adjustment_type=autoscaling.AdjustmentType.EXACT_CAPACITY)
        scaling_action.add_adjustment(adjustment=1, lower_bound=1)
        scale_out_init.add_alarm_action(AutoScalingAction(scaling_action))