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 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 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
}
