def test_instanceid(self): group = AutoScalingGroup( 'mygroup', InstanceId="i-1234", MaxSize="1", MinSize="1", ) self.assertTrue(group.validate())
def test_none(self): group = AutoScalingGroup( "mygroup", MaxSize="1", MinSize="1", ) with self.assertRaises(ValueError): self.assertTrue(group.validate())
def test_launchconfigurationname(self): group = AutoScalingGroup( 'mygroup', LaunchConfigurationName="I'm a test", MaxSize="1", MinSize="1", ) self.assertTrue(group.validate())
def test_none(self): group = AutoScalingGroup( 'mygroup', MaxSize="1", MinSize="1", ) with self.assertRaises(ValueError): self.assertTrue(group.validate())
def test_instanceid(self): group = AutoScalingGroup( 'mygroup', AvailabilityZones=['eu-west-1a', 'eu-west-1b'], InstanceId="i-1234", MaxSize="1", MinSize="1", ) self.assertTrue(group.validate())
def test_launchconfigurationname(self): group = AutoScalingGroup( "mygroup", AvailabilityZones=["eu-west-1a", "eu-west-1b"], LaunchConfigurationName="I'm a test", MaxSize="1", MinSize="1", ) self.assertTrue(group.validate())
def test_instanceid(self): group = AutoScalingGroup( "mygroup", AvailabilityZones=["eu-west-1a", "eu-west-1b"], InstanceId="i-1234", MaxSize="1", MinSize="1", ) self.assertTrue(group.validate())
def getTemplate(self): #asgConfigJson = simplejson.loads(simplejson.dumps(self.asgConfig)) asgConfigJson = self.asgConfig if self.elb is not None: self.template.add_resource( AutoScalingGroup( "ELBASG", DesiredCapacity=asgConfigJson['DesiredCapactiy'], MinSize=asgConfigJson['MinSize'], MaxSize=asgConfigJson['MaxSize'], LaunchConfigurationName=self.launchConfigName, HealthCheckType="ELB", HealthCheckGracePeriod=asgConfigJson[ 'HealthCheckGracePeriod'], LoadBalancerNames=[self.elb], AvailabilityZones=[self.availZone], VPCZoneIdentifier=[self.subnet], Tags=[ Tag("Name", Join("-", [self.friendlyName, self.branch]), True) ], UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( MaxBatchSize=asgConfigJson['MaxBatchSize'], MinInstancesInService=asgConfigJson[ 'MinInstancesInService'], PauseTime=asgConfigJson['PauseTime'], WaitOnResourceSignals=asgConfigJson[ 'WaitOnResourceSignals'])))) else: self.template.add_resource( AutoScalingGroup( "NoELBASG", DesiredCapacity=asgConfigJson['DesiredCapactiy'], MinSize=asgConfigJson['MinSize'], MaxSize=asgConfigJson['MaxSize'], LaunchConfigurationName=self.launchConfigName, HealthCheckType="EC2", HealthCheckGracePeriod=asgConfigJson[ 'HealthCheckGracePeriod'], AvailabilityZones=[self.availZone], VPCZoneIdentifier=[self.subnet], Tags=[ Tag("Name", Join("-", [self.friendlyName, self.branch]), True) ], UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( MaxBatchSize=asgConfigJson['MaxBatchSize'], MinInstancesInService=asgConfigJson[ 'MinInstancesInService'], PauseTime=asgConfigJson['PauseTime'], WaitOnResourceSignals=asgConfigJson[ 'WaitOnResourceSignals'])))) return self.template
def test_exclusive(self): group = AutoScalingGroup( 'mygroup', InstanceId="i-1234", LaunchConfigurationName="I'm a test", MaxSize="1", MinSize="1", ) with self.assertRaises(ValueError): self.assertTrue(group.validate())
def test_exclusive(self): group = AutoScalingGroup( "mygroup", InstanceId="i-1234", LaunchConfigurationName="I'm a test", MaxSize="1", MinSize="1", ) with self.assertRaises(ValueError): self.assertTrue(group.validate())
def test_AutoScalingRollingUpdate_all_defaults(self): group = AutoScalingGroup( 'mygroup', AvailabilityZones=['eu-west-1a', 'eu-west-1b'], LaunchConfigurationName="I'm a test", MaxSize="1", MinSize="1", UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate())) self.assertTrue(group.validate())
def test_AutoScalingRollingUpdate_all_defaults(self): group = AutoScalingGroup( "mygroup", AvailabilityZones=["eu-west-1a", "eu-west-1b"], LaunchConfigurationName="I'm a test", MaxSize="1", MinSize="1", UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate()), ) self.assertIsNone(group.validate())
def test_AutoScalingRollingUpdate_all_defaults(self): group = AutoScalingGroup( 'mygroup', AvailabilityZones=['eu-west-1a', 'eu-west-1b'], LaunchConfigurationName="I'm a test", MaxSize="1", MinSize="1", UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate()) ) self.assertTrue(group.validate())
def test_working(self): group = AutoScalingGroup('mygroup', LaunchConfigurationName="I'm a test", MaxSize="4", MinSize="2", UpdatePolicy=UpdatePolicy('AutoScalingRollingUpdate', PauseTime='PT1M5S', MinInstancesInService='2', MaxBatchSize='1', ) ) self.assertTrue(group.validate())
def test_working(self): group = AutoScalingGroup('mygroup', LaunchConfigurationName="I'm a test", MaxSize="4", MinSize="2", UpdatePolicy=UpdatePolicy( 'AutoScalingRollingUpdate', PauseTime='PT1M5S', MinInstancesInService='2', MaxBatchSize='1', )) self.assertTrue(group.validate())
def test_mininstances(self): group = AutoScalingGroup('mygroup', LaunchConfigurationName="I'm a test", MaxSize="1", MinSize="1", UpdatePolicy=UpdatePolicy( 'AutoScalingRollingUpdate', PauseTime='PT1M5S', MinInstancesInService='1', MaxBatchSize='1', )) with self.assertRaises(ValueError): self.assertTrue(group.validate())
def test_mininstances_maxsize_is_ref(self): paramMaxSize = Parameter("ParamMaxSize", Type="String") group = AutoScalingGroup('mygroup', LaunchConfigurationName="I'm a test", MaxSize=Ref(paramMaxSize), MinSize="2", UpdatePolicy=UpdatePolicy( 'AutoScalingRollingUpdate', PauseTime='PT1M5S', MinInstancesInService='2', MaxBatchSize="1", )) self.assertTrue(group.validate())
def test_mininstances(self): group = AutoScalingGroup('mygroup', LaunchConfigurationName="I'm a test", MaxSize="1", MinSize="1", UpdatePolicy=UpdatePolicy('AutoScalingRollingUpdate', PauseTime='PT1M5S', MinInstancesInService='1', MaxBatchSize='1', ) ) with self.assertRaises(ValueError): self.assertTrue(group.validate())
def test_AutoScalingRollingUpdate_validation(self): update_policy = UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( MinInstancesInService="2", MaxBatchSize='1')) group = AutoScalingGroup( 'mygroup', AvailabilityZones=['eu-west-1a', 'eu-west-1b'], LaunchConfigurationName="I'm a test", MaxSize="2", MinSize="1", UpdatePolicy=update_policy) with self.assertRaises(ValueError): self.assertTrue(group.validate())
def test_size_if(self): group = AutoScalingGroup( "mygroup", AvailabilityZones=["eu-west-1a", "eu-west-1b"], LaunchConfigurationName="I'm a test", MaxSize=If("isstage", "1", "5"), MinSize="1", UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( PauseTime="PT5M", MinInstancesInService="1", MaxBatchSize="1", WaitOnResourceSignals=True ) ), ) self.assertTrue(group.validate())
def test_size_if(self): group = AutoScalingGroup( 'mygroup', AvailabilityZones=['eu-west-1a', 'eu-west-1b'], LaunchConfigurationName="I'm a test", MaxSize=If("isstage", "1", "5"), MinSize="1", UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( PauseTime='PT5M', MinInstancesInService="1", MaxBatchSize='1', WaitOnResourceSignals=True))) self.assertTrue(group.validate())
def test_mininstances(self): group = AutoScalingGroup( "mygroup", LaunchConfigurationName="I'm a test", MaxSize=1, MinSize=1, UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( PauseTime="PT1M5S", MinInstancesInService="1", MaxBatchSize="1")), ) with self.assertRaises(ValueError): group.validate()
def test_mininstances_maxsize_is_ref(self): paramMaxSize = Parameter("ParamMaxSize", Type="String") group = AutoScalingGroup( "mygroup", AvailabilityZones=["eu-west-1a", "eu-west-1b"], LaunchConfigurationName="I'm a test", MaxSize=Ref(paramMaxSize), MinSize="2", UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( PauseTime="PT1M5S", MinInstancesInService="2", MaxBatchSize="1")), ) self.assertIsNone(group.validate())
def test_helperfn_as_updatepolicy(self): update_policy = UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( PauseTime="PT5M", MinInstancesInService="1", MaxBatchSize="1", WaitOnResourceSignals=True ) ) group = AutoScalingGroup( "mygroup", AvailabilityZones=["eu-west-1a", "eu-west-1b"], LaunchConfigurationName="I'm a test", MaxSize=If("isstage", "1", "5"), MinSize="1", UpdatePolicy=If("UseUpdatePolicy", update_policy, Ref("AWS::NoValue")), ) self.assertTrue(group.validate())
def test_AutoScalingRollingUpdate_validation(self): update_policy = UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( MinInstancesInService="2", MaxBatchSize="1")) group = AutoScalingGroup( "mygroup", AvailabilityZones=["eu-west-1a", "eu-west-1b"], LaunchConfigurationName="I'm a test", MaxSize="2", MinSize="1", UpdatePolicy=update_policy, ) with self.assertRaises(ValueError): group.validate()
def create_autoscaling_resource(name, launchConfig): """[ create simple autoscaling resource ] Arguments: name {[String]} -- [ name ] launchConfig {[LaunchConfiguration]} -- [description] Returns: [ troposphere.resource ] -- [ AutoScalingGroup ] """ return AutoScalingGroup( name + "AutoScalingGroup", DesiredCapacity=10, AutoScalingGroupName=name, LaunchConfigurationName=Ref(launchConfig), MinSize=9, MaxSize=10, AvailabilityZones=[Ref(zone1), Ref(zone2)], HealthCheckType="EC2", UpdatePolicy=UpdatePolicy( AutoScalingReplacingUpdate=AutoScalingReplacingUpdate( WillReplace=True, ), AutoScalingRollingUpdate=AutoScalingRollingUpdate( PauseTime='PT5M', MinInstancesInService="1", MaxBatchSize='1', WaitOnResourceSignals=True)), Tags=Tags(Application=Ref('AWS::StackId')))
def test_mininstances_mininstancesinservice_is_ref(self): paramMinInstancesInService = Parameter("ParamMinInstancesInService", Type="String") group = AutoScalingGroup( 'mygroup', AvailabilityZones=['eu-west-1a', 'eu-west-1b'], LaunchConfigurationName="I'm a test", MaxSize="4", MinSize="2", UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( PauseTime='PT1M5S', MinInstancesInService=Ref(paramMinInstancesInService), MaxBatchSize="2", ))) self.assertTrue(group.validate())
def add_nat_asg(self): user_data = [resources.get_resource('nat_takeover.sh')] if self.enable_ntp: user_data.append(resources.get_resource('ntp_takeover.sh')) if self.extra_user_data: user_data.append(open(self.extra_user_data).read()) nat_asg_name = "Nat%sASG" % str(self.subnet_index) user_data.extend([ "\n", "cfn-signal -s true", " --resource ", nat_asg_name, " --stack ", { "Ref": "AWS::StackName" }, " --region ", { "Ref": "AWS::Region" } ]) nat_launch_config = self.add_resource( LaunchConfiguration("Nat%sLaunchConfig" % str(self.subnet_index), UserData=Base64(Join('', user_data)), ImageId=FindInMap('RegionMap', Ref('AWS::Region'), 'natAmiId'), KeyName=Ref('ec2Key'), SecurityGroups=[Ref(self.sg)], EbsOptimized=False, IamInstanceProfile=Ref(self.instance_profile), InstanceType=self.instance_type, AssociatePublicIpAddress=True)) # Create the NAT in a public subnet subnet_layer = self._subnets['public'].keys()[0] nat_asg = self.add_resource( AutoScalingGroup( nat_asg_name, DesiredCapacity=1, Tags=[ Tag("Name", Join("-", [ "NAT", self.subnet_index, ]), True), Tag("isNat", "true", True) ], MinSize=1, MaxSize=1, Cooldown="30", LaunchConfigurationName=Ref(nat_launch_config), HealthCheckGracePeriod=30, HealthCheckType="EC2", VPCZoneIdentifier=[ self._subnets['public'][subnet_layer][self.subnet_index] ], CreationPolicy=CreationPolicy( ResourceSignal=ResourceSignal(Count=1, Timeout='PT15M')))) return nat_asg
def test_size_if(self): group = AutoScalingGroup( "mygroup", AvailabilityZones=["eu-west-1a", "eu-west-1b"], LaunchConfigurationName="I'm a test", MaxSize=If("isstage", "1", "5"), MinSize="1", UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( PauseTime="PT5M", MinInstancesInService="1", MaxBatchSize="1", WaitOnResourceSignals=True, )), ) self.assertIsNone(group.validate())
def test_helperfn_as_AutoScalingRollingUpdate(self): update_policy = UpdatePolicy(AutoScalingRollingUpdate=If( 'RollingUpdate', AutoScalingRollingUpdate(PauseTime='PT5M', MinInstancesInService="1", MaxBatchSize='1', WaitOnResourceSignals=True), Ref("AWS::NoValue"), ), ) group = AutoScalingGroup( 'mygroup', AvailabilityZones=['eu-west-1a', 'eu-west-1b'], LaunchConfigurationName="I'm a test", MaxSize=If("isstage", "1", "5"), MinSize="1", UpdatePolicy=If("UseUpdatePolicy", update_policy, Ref("AWS::NoValue"))) self.assertTrue(group.validate())
def test_helperfn_as_updatepolicy(self): update_policy = UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( PauseTime="PT5M", MinInstancesInService="1", MaxBatchSize="1", WaitOnResourceSignals=True, )) group = AutoScalingGroup( "mygroup", AvailabilityZones=["eu-west-1a", "eu-west-1b"], LaunchConfigurationName="I'm a test", MaxSize=If("isstage", "1", "5"), MinSize="1", UpdatePolicy=If("UseUpdatePolicy", update_policy, Ref("AWS::NoValue")), ) self.assertTrue(group.validate())
def test_mininstances_mininstancesinservice_is_ref(self): paramMinInstancesInService = Parameter( "ParamMinInstancesInService", Type="String" ) group = AutoScalingGroup( 'mygroup', LaunchConfigurationName="I'm a test", MaxSize="4", MinSize="2", UpdatePolicy=UpdatePolicy( 'AutoScalingRollingUpdate', PauseTime='PT1M5S', MinInstancesInService=Ref(paramMinInstancesInService), MaxBatchSize="2", ) ) self.assertTrue(group.validate())
def test_AutoScalingRollingUpdate_validation(self): update_policy = UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( MinInstancesInService="2", MaxBatchSize='1' ) ) group = AutoScalingGroup( 'mygroup', AvailabilityZones=['eu-west-1a', 'eu-west-1b'], LaunchConfigurationName="I'm a test", MaxSize="2", MinSize="1", UpdatePolicy=update_policy ) with self.assertRaises(ValueError): self.assertTrue(group.validate())
def test_mininstances_maxsize_is_ref(self): paramMaxSize = Parameter( "ParamMaxSize", Type="String" ) group = AutoScalingGroup( 'mygroup', AvailabilityZones=['eu-west-1a', 'eu-west-1b'], LaunchConfigurationName="I'm a test", MaxSize=Ref(paramMaxSize), MinSize="2", UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( PauseTime='PT1M5S', MinInstancesInService='2', MaxBatchSize="1" ) ) ) self.assertTrue(group.validate())
def define_web_auto_scaling(template, alb_target_group_80, alb_target_group_9090, sg): web_launch_config = LaunchConfiguration( stack_name_strict + "WebLC", UserData=Base64( Join('', [ '#!/bin/bash\n', 'set -x\n', 'exec > >(tee /tmp/user-data.log|logger -t user-data ) 2>&1\n', 'sudo su - deploy -c "echo \\"export RAILS_ENV=' + env + '\\" >> ~/.bashrc"\n', 'sudo su - deploy -c "cd ~/app/current; wget http://taxweb-deploy.s3.amazonaws.com/' + app_name + '/app_update.sh -O app_update.sh >/dev/null 2>&1"\n', 'sudo su - deploy -c "cd ~/app/current && chmod 755 app_update.sh && ./app_update.sh ' + env + ' web ' + app_name + '"\n' ])), ImageId=Ref(base_ami), InstanceType=Ref(instance_type), KeyName="taxweb-AWS-US-West", SecurityGroups=[Ref(sg)]) template.add_resource(web_launch_config) web_autoscaling_group = AutoScalingGroup( stack_name_strict + "WebASG", Tags=[ Tag("Name", stack_name + "-web", True), Tag("Custo", app_name, True), Tag("Env", env, True), Tag("Role", "web", True), ], LaunchConfigurationName=Ref(web_launch_config), MinSize=1, MaxSize=1, DesiredCapacity=1, VPCZoneIdentifier=[Ref(subnet_id1), Ref(subnet_id2)], TargetGroupARNs=[Ref(alb_target_group_80), Ref(alb_target_group_9090)], HealthCheckType="ELB", HealthCheckGracePeriod="300", ) template.add_resource(web_autoscaling_group) return { "launch_config": web_launch_config, "autoscaling_group": web_autoscaling_group }
def create_autoscale_group(stack, name, launch_con, vpc_zones, elbs=[], target_groups=[]): """Add EC2 AutoScalingGroup Resource.""" return stack.stack.add_resource( AutoScalingGroup( '{0}{1}ASG'.format(stack.env, name.replace('_', '')), LaunchConfigurationName=Ref(launch_con), MinSize="0", MaxSize="5", HealthCheckType="EC2", VPCZoneIdentifier=vpc_zones, TerminationPolicies=['OldestInstance'], LoadBalancerNames=elbs, TargetGroupARNs=target_groups, ))
def add_autoscaling_group(self, name, launch_configuration_name, subnets, desired_size=2, min_size=1, max_size=2, health_check_type='EC2', target_group_arns=[]): """ Create Autoscaling Group :param name: Name of the ASG :param launch_configuration_name: Which launch configuration to use to create instances :param subnets: Subnet to spin up instances in :param desired_size: Desired number of instances :param min_size: Minimum number of instances :param max_size: Maximum number of instances :param health_check_type: Health check type :param target_group_arns: ARN of the target group(s), if any """ auto_scaling_group = AutoScalingGroup( name, DesiredCapacity=desired_size, Tags=[{ 'Key': 'Name', 'Value': name, 'PropagateAtLaunch': True }], LaunchConfigurationName=Ref(launch_configuration_name), MinSize=min_size, MaxSize=max_size, VPCZoneIdentifier=subnets, HealthCheckType=health_check_type, HealthCheckGracePeriod=60, TargetGroupARNs=target_group_arns, UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( PauseTime='PT1H', MinInstancesInService=min_size, MaxBatchSize='1', WaitOnResourceSignals=True))) self.template.add_resource(auto_scaling_group)
def add_nat_asg(self): user_data = [resources.get_resource('nat_takeover.sh')] if self.enable_ntp: user_data.append(resources.get_resource('ntp_takeover.sh')) if self.extra_user_data: user_data.append(open(self.extra_user_data).read()) nat_launch_config = self.add_resource( LaunchConfiguration("Nat%sLaunchConfig" % str(self.subnet_index), UserData=Base64(Join('\n', user_data)), ImageId=FindInMap('RegionMap', Ref('AWS::Region'), 'natAmiId'), KeyName=Ref('ec2Key'), SecurityGroups=[Ref(self.sg)], EbsOptimized=False, IamInstanceProfile=Ref(self.instance_profile), InstanceType=self.instance_type, AssociatePublicIpAddress=True)) nat_asg = self.add_resource( AutoScalingGroup("Nat%sASG" % str(self.subnet_index), DesiredCapacity=1, Tags=[ Tag("Name", Join("-", [Ref(self.vpc_id), "NAT"]), True), Tag("isNat", "true", True) ], MinSize=1, MaxSize=1, Cooldown="30", LaunchConfigurationName=Ref(nat_launch_config), HealthCheckGracePeriod=30, HealthCheckType="EC2", VPCZoneIdentifier=[ Ref(self.subnets['public'][self.subnet_index]) ])) return nat_asg
def _auto_scaling_group(self): return AutoScalingGroup( "duy%sAutoscalingGroup" % self.config['env'], DesiredCapacity=self.config['scale_desire'], Tags=[ Tag("Name", "duy-%s" % self.config['env'], True), Tag("Environment", self.config['env'], True), Tag("PropagateAtLaunch", "true", True) ], LaunchConfigurationName=Ref(self.launchConfiguration), MinSize=self.config['scale_min'], MaxSize=self.config['scale_max'], VPCZoneIdentifier=self.config['private_subnet'], LoadBalancerNames=[Ref(self.loadBalancer)], HealthCheckType="EC2", HealthCheckGracePeriod="300", TerminationPolicies=["OldestInstance", "Default"], UpdatePolicy=UpdatePolicy( AutoScalingRollingUpdate=AutoScalingRollingUpdate( PauseTime='PT5M', MinInstancesInService="1", MaxBatchSize='1', WaitOnResourceSignals=True)))
def build_hook(self): if len(self.subnet_cidrs) != len(self.azs): raise ValueError('VPNJumpbox: Wrong number of CIDRs, should be %s' % len(self.azs)) eip = self.add_resource(EIP( "%sEIP" % self.name, Domain="vpc", )) asg_name = '%sAutoscalingGroup' % self.name launch_config = self._get_launch_config(asg_name, eip) subnets = self._add_subnets() asg = self.add_resource(AutoScalingGroup( asg_name, AvailabilityZones=self.azs, LaunchConfigurationName=Ref(launch_config), MaxSize=1, MinSize=1, DesiredCapacity=1, VPCZoneIdentifier=subnets, CreationPolicy=CreationPolicy( ResourceSignal=ResourceSignal( Count=1, Timeout='PT10M' ) ), DependsOn=[])) asg.Tags = [ASGTag('Name', self.name, True)] self.add_output(Output( 'JumpboxEIP', Value=Ref(eip) ))
def add_auto_scaling_group(self, asg): """ Add auto scaling group to stack """ default_security_groups = [ SecurityGroups(GroupId=Ref('IncomingSg')), SecurityGroups(GroupId=ImportValue('{}-cluster:DBBadgeSg'.format(self.cluster.get('name')))), ] for group in self.cluster.get('security_groups', []): default_security_groups.append( SecurityGroups(GroupId=group) ) launch_config = LaunchConfiguration( "ASGLaunchConfig{}".format(sanitize_cfn_resource_name(asg.get('name'))), IamInstanceProfile=self.instance_role, ImageId=self.ami, InstanceType=asg.get('instance_type'), KeyName=self.keypair, SecurityGroups=default_security_groups, BlockDeviceMappings=self.block_devices, UserData=Base64(Sub(self.open_userdata())) ) # launch config self.template.add_resource(launch_config) self.template.add_condition('IsActive', Equals(Ref('Status'), 'active')) auto_scaling_group = AutoScalingGroup( "ASG{}".format(sanitize_cfn_resource_name(asg.get('name'))), VPCZoneIdentifier=self.cluster.get('subnets'), Cooldown=300, DesiredCapacity=asg.get('desired_instances', 1), HealthCheckType='EC2', HealthCheckGracePeriod=60, LaunchConfigurationName=Ref(launch_config), MinSize=If('IsActive', asg.get('min_size', 1), 0), MaxSize=asg.get('max_size', 1) ) self.template.add_resource(auto_scaling_group)
def test_instanceid(self): group = AutoScalingGroup( "mygroup", AvailabilityZones=["eu-west-1a", "eu-west-1b"], InstanceId="i-1234", MaxSize="1", MinSize="1" ) self.assertTrue(group.validate())
consul_block_device_mapping = BlockDeviceMapping(config['name'] + 'ConsulBlockDeviceMapping') consul_block_device_mapping.DeviceName = '/dev/sda1' consul_block_device_mapping.Ebs = consul_block_device consul_launch_config = LaunchConfiguration(config['name'] + 'ConsulLaunchConfig') consul_launch_config.AssociatePublicIpAddress = True consul_launch_config.EbsOptimized = config['consul_launch_config']['ebs_optimized'] consul_launch_config.ImageId = config['consul_launch_config']['image_id'] consul_launch_config.KeyName = config['consul_launch_config']['key_name'] consul_launch_config.InstanceType = config['consul_launch_config']['instance_type'] consul_launch_config.BlockDeviceMappings = [consul_block_device_mapping] consul_launch_config.SecurityGroups = [Ref(config['name'] + 'homeSsh'), Ref(consul_sg)] t.add_resource(consul_launch_config) # auto scale group for consul server consul_asg = AutoScalingGroup(config['name'] + 'ConsulAsg') consul_asg.AvailabilityZones = config['consul_asg']['availability_zones'] consul_asg.LaunchConfigurationName = Ref(consul_launch_config) consul_asg.MaxSize = config['consul_asg']['max_size'] consul_asg.MinSize = config['consul_asg']['min_size'] consul_asg.VPCZoneIdentifier = [Ref(subnet.title) for subnet in app_subnets] name_tag = {'Key': 'Name', 'Value': config['consul_asg']['instance_name'], 'PropagateAtLaunch': True} consul_asg.Tags = [name_tag] t.add_resource(consul_asg) # launch configuration for application block_device = EBSBlockDevice(config['name'] + 'Ebs') block_device.DeleteOnTermination = config['app_launch_config']['block_device']['delete_on_termination'] block_device_mapping = BlockDeviceMapping(config['name'] + 'BlockDeviceMapping') block_device_mapping.DeviceName = '/dev/sda1'
def create_microservice_asg(template, name, ami, key_name, instance_profile, instance_type, vpc_id, instance_port=8080, subnets=None, security_groups=[], availability_zones=None, region='us-east-1', load_balancer=None, load_balancer_security_group=None, min_size=1, max_size=1, desired_capacity=None, creation_policy=None, update_policy=None, depends_on=None, metadata=None, tags=[]): template.mappings[name] = { region: {'instanceType': instance_type, 'ami': ami, 'profile': instance_profile} } if not availability_zones: availability_zones = _all_az(region) if load_balancer: security_groups.append(template.add_resource(ec2.SecurityGroup( "InstanceSecurityGroup" + name, GroupDescription="Enable access from ELB", SecurityGroupIngress=[ ec2.SecurityGroupRule( IpProtocol='tcp', FromPort=load_balancer['elb'].Listeners[0].InstancePort, ToPort=load_balancer['elb'].Listeners[0].InstancePort, SourceSecurityGroupId=Ref(load_balancer_security_group) ), ], VpcId=vpc_id ))) if not creation_policy: creation_policy = _default_creation_policy(name) if not update_policy: update_policy = _default_update_policy() security_group_refs = [Ref(sg) for sg in security_groups] asg_name = "AutoscalingGroup" + name lc_name = "LaunchConfiguration" + name lc = LaunchConfiguration( lc_name, UserData=Base64(Join('', [ "#!/bin/bash -ex\n", "# redirect output to syslog\n", "exec 1> >(logger -s -t user-data) 2>&1\n", "# running cfn-init\n", "/usr/local/bin/cfn-init --stack ", Ref("AWS::StackName"), " --resource {}".format(lc_name), " --region ", Ref("AWS::Region"), "\n", "echo \"cfn-init finished\"\n", "printf '%b\n' \"$(cat /home/ubuntu/application.properties)\"\n", "# restart services\n", "service supervisor restart\n", "echo \"restarting services\"\n", "# wait until microservice is ready\n", "until $(curl --output /dev/null --silent --head --fail http://localhost:{}/health); do\n".format( instance_port), " printf '.'\n", " sleep 5\n", "done\n" "echo \"springboot is up\"\n", "# signal asg\n" "cfn-signal -e 0", " --resource {}".format(asg_name), " --stack ", Ref("AWS::StackName"), " --region ", Ref("AWS::Region"), "\n" ])), ImageId=FindInMap(name, Ref("AWS::Region"), 'ami'), KeyName=key_name, SecurityGroups=security_group_refs, InstanceType=FindInMap(name, Ref("AWS::Region"), 'instanceType'), IamInstanceProfile=Ref(instance_profile) ) if metadata: lc.Metadata = metadata lc = template.add_resource(lc) if not desired_capacity: desired_capacity = max_size if not subnets: subnets = _get_vpc_subnets(vpc_id, region) asg = AutoScalingGroup( asg_name, DesiredCapacity=desired_capacity, Tags=tags, LaunchConfigurationName=Ref(lc), MinSize=min_size, MaxSize=max_size, LoadBalancerNames=[Ref(load_balancer['elb'])] if load_balancer else None, HealthCheckGracePeriod=60, AvailabilityZones=availability_zones, HealthCheckType="EC2" if not load_balancer else "ELB", VPCZoneIdentifier=subnets, CreationPolicy=creation_policy, UpdatePolicy=update_policy ) if depends_on: asg.DependsOn = depends_on asg = template.add_resource(asg) return { 'asg': asg, 'lc': lc, 'security_groups': security_groups }