def build_block_device_map(ephemeral,
number_ephemeral_disks=1,
ebs_size=None,
iops=None,
number_ebs_volumes=1):
bdm = blockdevicemapping.BlockDeviceMapping()
if ephemeral:
# The ephemeral disk
xvdb = BlockDeviceType()
xvdb.ephemeral_name = 'ephemeral0'
bdm['/dev/xvdb'] = xvdb
if number_ephemeral_disks == 2:
xvdc = BlockDeviceType()
xvdc.ephemeral_name = 'ephemeral1'
bdm['/dev/xvdc'] = xvdc
if ebs_size:
for disks in range(0, number_ebs_volumes):
xvd_n = blockdevicemapping.EBSBlockDeviceType(
delete_on_termination=True)
xvd_n.size = int(ebs_size) # size in Gigabytes
if iops:
xvd_n.iops = 500
xvd_n.volume_type = 'io1'
else:
xvd_n.volume_type = 'gp2'
last_char = chr(ord('f') + disks)
bdm['/dev/xvd' + last_char] = xvd_n
return bdm
def create_launch_configuration(name, image_id, key_name=None,
security_groups=None, user_data=None,
instance_type='m1.small', kernel_id=None,
ramdisk_id=None, block_device_mappings=None,
instance_monitoring=False, spot_price=None,
instance_profile_name=None,
ebs_optimized=False,
associate_public_ip_address=None,
volume_type=None, delete_on_termination=True,
iops=None, use_block_device_types=False,
region=None, key=None, keyid=None,
profile=None):
'''
Create a launch configuration.
CLI example::
salt myminion boto_asg.create_launch_configuration mylc image_id=ami-0b9c9f62 key_name='mykey' security_groups='["mygroup"]' instance_type='c3.2xlarge'
'''
conn = _get_conn(region, key, keyid, profile)
if not conn:
return False
if isinstance(security_groups, six.string_types):
security_groups = json.loads(security_groups)
if isinstance(block_device_mappings, six.string_types):
block_device_mappings = json.loads(block_device_mappings)
_bdms = []
if block_device_mappings:
# Boto requires objects for the mappings and the devices.
_block_device_map = blockdevicemapping.BlockDeviceMapping()
for block_device_dict in block_device_mappings:
for block_device, attributes in six.iteritems(block_device_dict):
_block_device = blockdevicemapping.EBSBlockDeviceType()
for attribute, value in six.iteritems(attributes):
setattr(_block_device, attribute, value)
_block_device_map[block_device] = _block_device
_bdms = [_block_device_map]
lc = autoscale.LaunchConfiguration(
name=name, image_id=image_id, key_name=key_name,
security_groups=security_groups, user_data=user_data,
instance_type=instance_type, kernel_id=kernel_id,
ramdisk_id=ramdisk_id, block_device_mappings=_bdms,
instance_monitoring=instance_monitoring, spot_price=spot_price,
instance_profile_name=instance_profile_name,
ebs_optimized=ebs_optimized,
associate_public_ip_address=associate_public_ip_address,
volume_type=volume_type, delete_on_termination=delete_on_termination,
iops=iops, use_block_device_types=use_block_device_types)
try:
conn.create_launch_configuration(lc)
log.info('Created LC {0}'.format(name))
return True
except boto.exception.BotoServerError as e:
log.debug(e)
msg = 'Failed to create LC {0}'.format(name)
log.error(msg)
return False
def create_instance(ebs_size, ami_name):
"""
Create the AWS instance
:param ebs_size:
"""
puts('Creating the instance {1} with disk size {0} GB'.format(
ebs_size, ami_name))
# This relies on a ~/.boto file holding the '<aws access key>', '<aws secret key>'
ec2_connection = boto.connect_ec2()
dev_sda1 = blockdevicemapping.EBSBlockDeviceType(
delete_on_termination=True)
dev_sda1.size = int(ebs_size) # size in Gigabytes
bdm = blockdevicemapping.BlockDeviceMapping()
bdm['/dev/sda1'] = dev_sda1
reservations = ec2_connection.run_instances(
AMI_ID,
instance_type=INSTANCE_TYPE,
key_name=KEY_NAME,
security_groups=SECURITY_GROUPS,
block_device_map=bdm)
instance = reservations.instances[0]
# Sleep so Amazon recognizes the new instance
for i in range(4):
fastprint('.')
time.sleep(5)
# Are we running yet?
while not instance.update() == 'running':
fastprint('.')
time.sleep(5)
# Sleep a bit more Amazon recognizes the new instance
for i in range(4):
fastprint('.')
time.sleep(5)
puts('.')
ec2_connection.create_tags([instance.id], {'Name': '{0}'.format(ami_name)})
# The instance is started, but not useable (yet)
puts('Started the instance now waiting for the SSH daemon to start.')
for i in range(12):
fastprint('.')
time.sleep(5)
puts('.')
# Return the instance
return instance, ec2_connection
def create_launch_configuration(name,
image_id,
key_name=None,
vpc_id=None,
vpc_name=None,
security_groups=None,
user_data=None,
instance_type='m1.small',
kernel_id=None,
ramdisk_id=None,
block_device_mappings=None,
instance_monitoring=False,
spot_price=None,
instance_profile_name=None,
ebs_optimized=False,
associate_public_ip_address=None,
volume_type=None,
delete_on_termination=True,
iops=None,
use_block_device_types=False,
region=None,
key=None,
keyid=None,
profile=None):
'''
Create a launch configuration.
CLI example::
salt myminion boto_asg.create_launch_configuration mylc image_id=ami-0b9c9f62 key_name='mykey' security_groups='["mygroup"]' instance_type='c3.2xlarge'
'''
conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)
if isinstance(security_groups, six.string_types):
security_groups = json.loads(security_groups)
if isinstance(block_device_mappings, six.string_types):
block_device_mappings = json.loads(block_device_mappings)
_bdms = []
if block_device_mappings:
# Boto requires objects for the mappings and the devices.
_block_device_map = blockdevicemapping.BlockDeviceMapping()
for block_device_dict in block_device_mappings:
for block_device, attributes in six.iteritems(block_device_dict):
_block_device = blockdevicemapping.EBSBlockDeviceType()
for attribute, value in six.iteritems(attributes):
setattr(_block_device, attribute, value)
_block_device_map[block_device] = _block_device
_bdms = [_block_device_map]
# If a VPC is specified, then determine the secgroup id's within that VPC, not
# within the default VPC. If a security group id is already part of the list,
# convert_to_group_ids leaves that entry without attempting a lookup on it.
if security_groups and (vpc_id or vpc_name):
security_groups = __salt__['boto_secgroup.convert_to_group_ids'](
security_groups,
vpc_id=vpc_id,
vpc_name=vpc_name,
region=region,
key=key,
keyid=keyid,
profile=profile)
lc = autoscale.LaunchConfiguration(
name=name,
image_id=image_id,
key_name=key_name,
security_groups=security_groups,
user_data=user_data,
instance_type=instance_type,
kernel_id=kernel_id,
ramdisk_id=ramdisk_id,
block_device_mappings=_bdms,
instance_monitoring=instance_monitoring,
spot_price=spot_price,
instance_profile_name=instance_profile_name,
ebs_optimized=ebs_optimized,
associate_public_ip_address=associate_public_ip_address,
volume_type=volume_type,
delete_on_termination=delete_on_termination,
iops=iops,
use_block_device_types=use_block_device_types)
retries = 30
while True:
try:
conn.create_launch_configuration(lc)
log.info('Created LC {0}'.format(name))
return True
except boto.exception.BotoServerError as e:
if retries and e.code == 'Throttling':
log.debug('Throttled by AWS API, retrying in 5 seconds...')
time.sleep(5)
retries -= 1
continue
log.error(e)
msg = 'Failed to create LC {0}'.format(name)
log.error(msg)
return False
def create_instance(ebs_size, ami_name, sydney=False):
"""
Create the AWS instance
:param ebs_size:
"""
puts('Creating the instance {1} with disk size {0} GB'.format(ebs_size, ami_name))
if exists(join(expanduser('~'), '.aws/credentials')):
# This relies on a ~/.aws/credentials file holding the '<aws access key>', '<aws secret key>'
puts("Using ~/.aws/credentials")
if sydney:
ec2_connection = boto.ec2.connect_to_region(SYDNEY_REGION, profile_name='theSkyNet')
else:
ec2_connection = boto.connect_ec2(profile_name='theSkyNet')
else:
# This relies on a ~/.boto or /etc/boto.cfg file holding the '<aws access key>', '<aws secret key>'
puts("Using ~/.boto or /etc/boto.cfg")
ec2_connection = boto.connect_ec2()
dev_xvda = blockdevicemapping.EBSBlockDeviceType(delete_on_termination=True)
dev_xvda.size = int(ebs_size) # size in Gigabytes
bdm = blockdevicemapping.BlockDeviceMapping()
bdm['/dev/xvda'] = dev_xvda
if sydney:
reservations = ec2_connection.run_instances(
SYDNEY_AMI_ID,
subnet_id=SYDNEY_SUBNET,
instance_type=INSTANCE_TYPE,
key_name=SYDNEY_KEY_NAME,
security_group_ids=SYDNEY_SECURITY_GROUPS,
block_device_map=bdm)
else:
reservations = ec2_connection.run_instances(AMI_ID, instance_type=INSTANCE_TYPE, key_name=KEY_NAME, security_groups=SECURITY_GROUPS, block_device_map=bdm)
instance = reservations.instances[0]
# Sleep so Amazon recognizes the new instance
for i in range(4):
fastprint('.')
time.sleep(5)
# Are we running yet?
while not instance.update() == 'running':
fastprint('.')
time.sleep(5)
# Sleep a bit more Amazon recognizes the new instance
for i in range(4):
fastprint('.')
time.sleep(5)
puts('.')
ec2_connection.create_tags([instance.id], {'Name': '{0}'.format(ami_name)})
# The instance is started, but not useable (yet)
puts('Started the instance now waiting for the SSH daemon to start.')
for i in range(12):
fastprint('.')
time.sleep(5)
puts('.')
# Return the instance
return instance, ec2_connection
