def add_ec2_launch_configuration(self,
name,
security_groups,
keypair,
image_id='ami-14913f63',
instance_type='t2.micro',
metadata=None,
userdata=None):
"""
Create a Launch Configuration
:param name: Name of the Launch Config
:param security_groups: SG to assign to the ASG
:param keypair: Key pair to use to launch the instances in the ASG
:param image_id: AMI ID to spin up the instances from
:param instance_type: Instance type
:param metadata: Any metadata, eg. files, packages etc.
:param userdata: Any userdata
"""
launch_config = LaunchConfiguration(name,
ImageId=image_id,
SecurityGroups=security_groups,
InstanceType=instance_type,
KeyName=keypair)
launch_config.BlockDeviceMappings = self.block_device_default
if metadata:
launch_config.Metadata = metadata
if userdata:
launch_config.UserData = userdata
self.template.add_resource(launch_config)
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
}
