def build_vpc(self, cidrblock): """Build VPC""" self.log.emit('creating vpc ({}, {})'.format(self.vpc_name, cidrblock)) vpc = self.boto.ec2.create_vpc(CidrBlock = cidrblock) self.log.emit('tagging vpc (Name:{})'.format(self.vpc_name), 'debug') update_tags(vpc, Name = self.vpc_name) self.log.emit('modifying vpc for dns support', 'debug') vpc.modify_attribute(EnableDnsSupport={'Value': True}) self.log.emit('modifying vpc for dns hostnames', 'debug') vpc.modify_attribute(EnableDnsHostnames={'Value': True}) igw_name = 'igw-' + self.vpc_name self.log.emit('creating internet_gateway ({})'.format(igw_name)) gw = self.boto.ec2.create_internet_gateway() self.log.emit('tagging gateway (Name:{})'.format(igw_name), 'debug') update_tags(gw, Name = igw_name) self.log.emit('attaching igw to vpc ({})'.format(igw_name)) vpc.attach_internet_gateway( DryRun=False, InternetGatewayId=gw.id, VpcId=vpc.id, )
def tag_instance_name(self, instance): """Accept a EnrichedInstance, objects create tags.""" msg = 'tagging instance {} (Name:{})' h = '{}-{}-{}' hostname = h.format(self.evpc.name, instance.role, instance.id_human) self.log.emit(msg.format(instance.identity, hostname)) update_tags(instance, Name=hostname)
def route_tables(self, route_cfg): """Build route_tables defined in config""" for rt_name, data in route_cfg.items(): longname = '{}-{}'.format(self.evpc.name, rt_name) route_table = self.evpc.get_route_table(longname) if route_table is None: self.log.emit('creating route_table ({})'.format(longname)) if data.get('main', False) == True: route_table = self.evpc.get_main_route_table() else: route_table = self.evpc.create_route_table() self.log.emit('tagging route_table (Name:{})'.format(longname), 'debug') update_tags(route_table, Name = longname) # TODO: move to separate method ... # gatewayId, natGatewayId, networkInterfaceId, vpcPeeringConnectionId or instanceId # add routes to route_table defined in configuration. for route in data.get('routes', []): destination, target = route self.log.emit('adding route {} to route_table ({})'.format(route, longname)) if target.lower() == 'internet_gateway': # this is ugly but we assume only one internet gateway. route_table.create_route( DestinationCidrBlock = destination, GatewayId = list(self.evpc.internet_gateways.all())[0].id, )
def subnets(self, subnet_cfg): """Build subnets defined in config.""" sizes = sorted([x['size'] for x in subnet_cfg.values()]) cidrs = allocate(self.evpc.cidr_block, sizes) azones = self.evpc.azones subnets = {} for size, cidr in zip(sizes, cidrs): subnets.setdefault(size, []).append(cidr) for name, sn in subnet_cfg.items(): longname = '{}-{}'.format(self.evpc.name, name) az_letter = sn.get('availability_zone', None) if az_letter is not None: az_name = self.evpc.region_name + az_letter else: az_index = int(name.split('-')[-1]) - 1 az_name = azones[az_index] cidr = subnets[sn['size']].pop() self.log.emit('creating subnet {} in {}'.format(cidr, az_name)) subnet = self.evpc.create_subnet( CidrBlock = str(cidr), AvailabilityZone = az_name ) self.log.emit('tagging subnet (Name:{})'.format(longname), 'debug') update_tags( subnet, Name = longname, description = sn.get('description', ''), ) # Modifying the subnet's public IP addressing behavior. if sn.get('public', False) == True: subnet.map_public_ip_on_launch = True
def tag_instance_name(self, instance): """Accept a EnrichedInstance, objects create tags.""" msg = 'tagging instance {} (Name:{})' h = '{}-{}-{}' hostname = h.format(self.evpc.name, instance.role, instance.id_human) self.log.emit(msg.format(instance.identity, hostname)) update_tags(instance, Name = hostname)
def subnets(self, subnet_cfg): """Build subnets defined in config.""" sizes = sorted([x['size'] for x in subnet_cfg.values()]) cidrs = allocate(self.evpc.cidr_block, sizes) azones = self.evpc.azones subnets = {} for size, cidr in zip(sizes, cidrs): subnets.setdefault(size, []).append(cidr) for name, sn in subnet_cfg.items(): longname = '{}-{}'.format(self.evpc.name, name) az_letter = sn.get('availability_zone', None) if az_letter is not None: az_name = self.evpc.region_name + az_letter else: az_index = int(name.split('-')[-1]) - 1 az_name = azones[az_index] cidr = subnets[sn['size']].pop() self.log.emit('creating subnet {} in {}'.format(cidr, az_name)) subnet = self.evpc.create_subnet(CidrBlock=str(cidr), AvailabilityZone=az_name) self.log.emit('tagging subnet (Name:{})'.format(longname), 'debug') update_tags( subnet, Name=longname, description=sn.get('description', ''), ) # Modifying the subnet's public IP addressing behavior. if sn.get('public', False) == True: subnet.map_public_ip_on_launch = True
def tag_instances(self, role_name, instances): """Accept a list of EnrichedInstance, objects create tags.""" msg = 'tagging instance {} (Name:{}, role:{})' for instance in instances: h = '{}-{}-{}' hostname = h.format(self.evpc.name, role_name, instance.id_human) self.log.emit(msg.format(instance.identity, hostname, role_name)) update_tags(instance, Name = hostname, role = role_name)
def build_vpc(self, cidrblock): """Build VPC""" self.log.emit('creating vpc ({}, {})'.format(self.vpc_name, cidrblock)) vpc = self.boto.ec2.create_vpc(CidrBlock = cidrblock) self.log.emit('tagging vpc (Name:{})'.format(self.vpc_name), 'debug') update_tags(vpc, Name = self.vpc_name) self.log.emit('modifying vpc for dns support', 'debug') vpc.modify_attribute(EnableDnsSupport={'Value': True}) self.log.emit('modifying vpc for dns hostnames', 'debug') vpc.modify_attribute(EnableDnsHostnames={'Value': True})
def build_vpc(self, cidrblock): """Build VPC""" self.log.emit('creating vpc ({}, {})'.format(self.vpc_name, cidrblock)) vpc = self.boto.ec2.create_vpc(CidrBlock=cidrblock) self.log.emit('tagging vpc (Name:{})'.format(self.vpc_name), 'debug') update_tags(vpc, Name=self.vpc_name) self.log.emit('modifying vpc for dns support', 'debug') vpc.modify_attribute(EnableDnsSupport={'Value': True}) self.log.emit('modifying vpc for dns hostnames', 'debug') vpc.modify_attribute(EnableDnsHostnames={'Value': True})
def build_internet_gateway(self): """Build and attach Internet Gateway to VPC.""" igw_name = "igw-" + self.evpc.name self.log.emit("creating internet_gateway ({})".format(igw_name)) gw = self.boto.ec2.create_internet_gateway() self.log.emit("tagging gateway (Name:{})".format(igw_name), "debug") update_tags(gw, Name=igw_name) self.log.emit("attaching igw to vpc ({})".format(igw_name)) self.evpc.attach_internet_gateway( DryRun=False, InternetGatewayId=gw.id, VpcId=self.evpc.id )
def dhcp_options(self, dhcp_options_cfg): """Creates DHCP Options Set and associates with VPC""" for dhcp_name, data in dhcp_options_cfg.items(): longname = '{}-{}'.format(self.evpc.name, dhcp_name) self.log.emit('creating DHCP Options Set {}'.format(longname)) dhcp_options_id = self.evpc.create_dhcp_options(data) # associate DHCP Options with VPC self.log.emit('associating DHCP Options {} ({}) with VPC {}'.format(longname, dhcp_options_id, self.vpc_name)) self.evpc.associate_dhcp_options( DhcpOptionsId=dhcp_options_id ) self.evpc.reload() update_tags(self.evpc.dhcp_options, Name=longname)
def route_tables(self, route_cfg): """Build route_tables defined in config""" for rt_name, data in route_cfg.items(): longname = "{}-{}".format(self.evpc.name, rt_name) route_table = self.evpc.get_route_table(longname) if route_table is None: self.log.emit("creating route_table ({})".format(longname)) if data.get("main", False) == True: route_table = self.evpc.get_main_route_table() else: route_table = self.evpc.create_route_table() self.log.emit("tagging route_table (Name:{})".format(longname), "debug") update_tags(route_table, Name=longname)
def route_tables(self, route_cfg): """Build route_tables defined in config""" for rt_name, data in route_cfg.items(): longname = '{}-{}'.format(self.evpc.name, rt_name) route_table = self.evpc.get_route_table(longname) if route_table is None: self.log.emit('creating route_table ({})'.format(longname)) if data.get('main', False) == True: route_table = self.evpc.get_main_route_table() else: route_table = self.evpc.create_route_table() self.log.emit('tagging route_table (Name:{})'.format(longname), 'debug') update_tags(route_table, Name = longname)
def build_vpc(self, cidrblock="172.31.0.0/16", tenancy="default"): """Build VPC""" msg_vpc = "creating vpc ({}, {}) with {} tenancy" self.log.emit(msg_vpc.format(self.vpc_name, cidrblock, tenancy)) vpc = self.boto.ec2.create_vpc(CidrBlock=cidrblock, InstanceTenancy=tenancy) self.log.emit("tagging vpc (Name:{})".format(self.vpc_name), "debug") update_tags(vpc, Name=self.vpc_name) self.log.emit("modifying vpc for dns support", "debug") vpc.modify_attribute(EnableDnsSupport={"Value": True}) self.log.emit("modifying vpc for dns hostnames", "debug") vpc.modify_attribute(EnableDnsHostnames={"Value": True})
def create_dhcp_options(self, dhcp_configurations): """Creates and return a new dhcp_options set.""" response = self.boto.ec2_client.create_dhcp_options( DhcpConfigurations = dhcp_configurations ) dhcp_options_id = nested_lookup('DhcpOptionsId', response)[0] dhcp_options = self._get_dhcp_options_from_id(dhcp_options_id) self.log.emit('tagging dhcp_options (Name:{})'.format(self.evpc.name), 'debug') update_tags(dhcp_options, Name = self.evpc.name) self.log.emit('associating dhcp_options to {}'.format(self.evpc.name)) dhcp_options.associate_with_vpc(VpcId = self.evpc.id)
def security_groups(self, security_group_cfg): """Build Security Groups defined in config.""" for sg_name, rules in security_group_cfg.items(): sg = self.evpc.get_security_group(sg_name) if sg is not None: continue longname = "{}-{}".format(self.evpc.name, sg_name) self.log.emit("creating security_group {}".format(longname)) security_group = self.evpc.create_security_group( GroupName=longname, Description=longname ) self.log.emit("tagging security_group (Name:{})".format(longname), "debug") update_tags(security_group, Name=longname)
def route_tables(self, route_cfg): """Build route_tables defined in config""" for name, data in route_cfg.items(): longname = '{}-{}'.format(self.evpc.name, name) route_table = self.evpc.get_route_table(longname) if route_table is None: self.log.emit('creating route_table ({})'.format(longname)) if data.get('main', False) == True: route_table = self.evpc.get_main_route_table() else: route_table = self.evpc.create_route_table() self.log.emit('tagging route_table (Name:{})'.format(longname), 'debug') update_tags(route_table, Name=longname)
def build_internet_gateway(self): """Build and attach Internet Gateway to VPC.""" igw_name = 'igw-' + self.evpc.name self.log.emit('creating internet_gateway ({})'.format(igw_name)) gw = self.boto.ec2.create_internet_gateway() self.log.emit('tagging gateway (Name:{})'.format(igw_name), 'debug') update_tags(gw, Name = igw_name) self.log.emit('attaching igw to vpc ({})'.format(igw_name)) self.evpc.attach_internet_gateway( DryRun=False, InternetGatewayId=gw.id, VpcId=self.evpc.id, )
def create_dhcp_options(self, dhcp_configurations): """Creates and return a new dhcp_options set.""" response = self.boto.ec2_client.create_dhcp_options( DhcpConfigurations=dhcp_configurations) dhcp_options_id = nested_lookup('DhcpOptionsId', response)[0] dhcp_options = self._get_dhcp_options_from_id(dhcp_options_id) self.log.emit('tagging dhcp_options (Name:{})'.format(self.evpc.name), 'debug') update_tags(dhcp_options, Name=self.evpc.name) self.log.emit('associating dhcp_options to {}'.format(self.evpc.name)) dhcp_options.associate_with_vpc(VpcId=self.evpc.id)
def tags(self, tag_cfg): reserved_tags = [ 'Name', 'role', 'aws:autoscaling:groupName', 'key_pairs', 'private_hosted_zone_id', 'vpc_name' ] safe_tags = {} for key, value in tag_cfg.items(): if key not in reserved_tags: safe_tags[key] = str(value) taggable_resources = self.evpc.taggable_resources for resource in taggable_resources: if safe_tags: self.log.emit('tagging {} with {} ...'.format( resource, safe_tags)) update_tags(resource, **safe_tags)
def security_groups(self, security_group_cfg): """Build Security Groups defined in config.""" for sg_name, rules in security_group_cfg.items(): sg = self.evpc.get_security_group(sg_name) if sg is not None: continue longname = '{}-{}'.format(self.evpc.name, sg_name) self.log.emit('creating security_group {}'.format(longname)) security_group = self.evpc.create_security_group( GroupName = longname, Description = longname, ) self.log.emit( 'tagging security_group (Name:{})'.format(longname), 'debug' ) update_tags(security_group, Name = longname)
def build_vpc(self, cidrblock='172.31.0.0/16', tenancy='default'): """Build VPC""" msg_vpc = 'creating vpc ({}, {}) with {} tenancy' self.log.emit(msg_vpc.format(self.vpc_name, cidrblock, tenancy)) vpc = self.boto.ec2.create_vpc( CidrBlock=cidrblock, InstanceTenancy=tenancy, ) self.log.emit('tagging vpc (Name:{})'.format(self.vpc_name), 'debug') update_tags(vpc, Name=self.vpc_name) self.log.emit('modifying vpc for dns support', 'debug') vpc.modify_attribute(EnableDnsSupport={'Value': True}) self.log.emit('modifying vpc for dns hostnames', 'debug') vpc.modify_attribute(EnableDnsHostnames={'Value': True})
def tags(self, tag_cfg): reserved_tags = [ "Name", "role", "aws:autoscaling:groupName", "key_pairs", "private_hosted_zone_id", "vpc_name", ] safe_tags = {} for key, value in tag_cfg.items(): if key not in reserved_tags: safe_tags[key] = str(value) taggable_resources = self.evpc.taggable_resources for resource in taggable_resources: if safe_tags: self.log.emit("tagging {} with {} ...".format(resource, safe_tags)) update_tags(resource, **safe_tags)
def subnets(self, subnet_cfg): """Build subnets defined in config.""" sizes = sorted([x['size'] for x in subnet_cfg.values()]) cidrs = allocate(self.evpc.cidr_block, sizes) azones = self.evpc.azones subnets = {} for size, cidr in zip(sizes, cidrs): subnets.setdefault(size, []).append(cidr) for sn_name in sorted(subnet_cfg): sn = subnet_cfg[sn_name] longname = '{}-{}'.format(self.evpc.name, sn_name) az_letter = sn.get('availability_zone', None) if az_letter is not None: az_name = self.evpc.region_name + az_letter else: az_index = int(sn_name.split('-')[-1]) - 1 az_name = azones[az_index] cidr = subnets[sn['size']].pop(0) self.log.emit('creating subnet {} in {}'.format(cidr, az_name)) subnet = self.evpc.create_subnet(CidrBlock=str(cidr), AvailabilityZone=az_name) self.log.emit('tagging subnet (Name:{})'.format(longname), 'debug') update_tags( subnet, Name=longname, description=sn.get('description', ''), ) if sn.get('public', False) == True: # Modify the subnet's public IP addressing behavior. msg_mod = 'modifying subnet to map public IPs on instance launch ({})' self.log.emit(msg_mod.format(longname)) self.boto.ec2_client.modify_subnet_attribute( SubnetId=subnet.id, MapPublicIpOnLaunch={'Value': True}, )
def _update_key_pairs_tag(self, key_names): update_tags(self.evpc, key_pairs=",".join(key_names))
def tag_instance_volumes(self, instance): """Accept an EnrichedInstance, tag all attached volumes.""" msg = 'tagging volumes for instance {} (Name:{})' for volume in instance.volumes.all(): self.log.emit(msg.format(instance.identity, instance.identity)) update_tags(volume, Name = instance.identity)
def instance_role(self, role_name, role_data, desired_count): if role_data.get('autoscaling', False) == True: # exit early if this instance_role is autoscaling. return [] self.log.emit('creating role: {}'.format(role_name)) ami = self.amis[role_data['ami']][self.evpc.region_name] key_pair = self.evpc.key_pair.get_key_pair( role_data.get('key_pair', 'default') ) security_groups = map( self.evpc.get_security_group, role_data.get('security_groups', []) ) subnets = map( self.evpc.get_subnet, role_data.get('subnets', []) ) if len(subnets) == 0: self.log.emit( 'no subnets found for role: {}'.format(role_name), 'warning' ) # exit early. return None # sort by subnets by amount of instances, smallest first. subnets = sorted( subnets, key = lambda sn : collection_len(sn.instances), ) # determine the count of this role's existing instances. # Note: we look for role in all subnets, not just the listed subnets. existing_count = len(self.evpc.get_role(role_name)) if existing_count >= desired_count: # for now we exit early, maybe terminate extras... self.log.emit('{} {}'.format(existing_count, desired_count), 'debug') return None # determine count of additional instances needed to reach desired_count. needed_count = desired_count - existing_count needed_per_subnet = desired_count / len(subnets) needed_remainder = desired_count % len(subnets) block_device_map = get_block_device_map_from_role_config(role_data) role_instances = [] kwargs = { 'ImageId' : ami, 'InstanceType' : role_data.get('instance_type'), 'KeyName' : key_pair.name, 'SecurityGroupIds' : get_ids(security_groups), 'BlockDeviceMappings' : block_device_map, 'UserData' : role_data.get('userdata', ''), 'IamInstanceProfile' : {}, } profile_name = role_data.get('instance_profile_name', None) if profile_name: kwargs['IamInstanceProfile'] = { 'Name' : profile_name } for subnet in subnets: # ensure Run_Instance_Idempotency.html#client-tokens kwargs['ClientToken'] = str(uuid4()) # figure out how many instances this subnet needs to create ... existing_in_subnet = len(self.evpc.get_role(role_name, subnet.instances.all())) count = needed_per_subnet - existing_in_subnet if needed_remainder != 0: needed_remainder -= 1 count += 1 if count == 0: # skip this subnet, it doesn't need to launch any instances. continue subnet_name = make_tag_dict(subnet)['Name'] msg = '{} instances of role {} launching into {} subnet' self.log.emit(msg.format(count, role_name, subnet_name)) # create a batch of instances in subnet! kwargs['MinCount'] = kwargs['MaxCount'] = count instances = self._create_instances(subnet, **kwargs) # accumulate all new instances into a single list. role_instances += instances # add role tag to each instance. for instance in role_instances: update_tags(instance, role = role_name)
def instance_role(self, role_name, role_data, desired_count): if role_data.get("autoscaling", False) == True: # exit early if this instance_role is autoscaling. return None self.log.emit("creating role: {}".format(role_name)) ami = self.amis[role_data["ami"]][self.evpc.region_name] key_pair = self.evpc.key_pair.get_key_pair(role_data.get("key_pair", "default")) security_groups = map_filter_false( self.evpc.get_security_group, role_data.get("security_groups", []) ) subnets = map_filter_false(self.evpc.get_subnet, role_data.get("subnets", [])) if len(subnets) == 0: self.log.emit("no subnets found for role: {}".format(role_name), "warning") # exit early. return None # sort by subnets by amount of instances, smallest first. subnets = sorted(subnets, key=lambda sn: collection_len(sn.instances)) # determine the count of this role's existing instances. # Note: we look for role in all subnets, not just the listed subnets. existing_count = len(self.evpc.get_role(role_name)) if existing_count >= desired_count: # for now we exit early, maybe terminate extras... msg = "skipping role: {} (existing_count {} is greater than or equal to {})" self.log.emit(msg.format(role_name, existing_count, desired_count), "debug") return None # determine count of additional instances needed to reach desired_count. needed_count = desired_count - existing_count needed_per_subnet = desired_count / len(subnets) needed_remainder = desired_count % len(subnets) block_device_map = get_block_device_map_from_role_config(role_data) role_instances = [] kwargs = { "ImageId": ami, "InstanceType": role_data.get("instance_type"), "KeyName": key_pair.name, "SecurityGroupIds": get_ids(security_groups), "BlockDeviceMappings": block_device_map, "UserData": role_data.get("userdata", ""), "IamInstanceProfile": {}, } profile_name = role_data.get("instance_profile_name", None) if profile_name: kwargs["IamInstanceProfile"] = {"Name": profile_name} private_ip_address = role_data.get("private_ip_address", None) if private_ip_address: kwargs["PrivateIpAddress"] = private_ip_address for subnet in subnets: # ensure Run_Instance_Idempotency.html#client-tokens kwargs["ClientToken"] = str(uuid4()) # figure out how many instances this subnet needs to create ... existing_in_subnet = len( self.evpc.get_role(role_name, subnet.instances.all()) ) count = needed_per_subnet - existing_in_subnet if needed_remainder != 0: needed_remainder -= 1 count += 1 if count == 0: # skip this subnet, it doesn't need to launch any instances. continue subnet_name = make_tag_dict(subnet)["Name"] msg = "{} instances of role {} launching into {} subnet" self.log.emit(msg.format(count, role_name, subnet_name)) # create a batch of instances in subnet! kwargs["MinCount"] = kwargs["MaxCount"] = count instances = self._create_instances(subnet, **kwargs) # accumulate all new instances into a single list. role_instances += instances # add role tag to each instance. for instance in role_instances: update_tags(instance, role=role_name)
def tag_instance_volumes(self, instance): """Accept an EnrichedInstance, tag all attached volumes.""" msg = 'tagging volumes for instance {} (Name:{})' for volume in instance.volumes.all(): self.log.emit(msg.format(instance.identity, instance.identity)) update_tags(volume, Name=instance.identity)
def instance_role(self, role_name, role_data, desired_count): if role_data.get('autoscaling', False) == True: # exit early if this instance_role is autoscaling. return None self.log.emit('creating role: {}'.format(role_name)) ami = self.amis[role_data['ami']][self.evpc.region_name] key_pair = self.evpc.key_pair.get_key_pair( role_data.get('key_pair', 'default')) security_groups = map_filter_false( self.evpc.get_security_group, role_data.get('security_groups', [])) subnets = map_filter_false(self.evpc.get_subnet, role_data.get('subnets', [])) if len(subnets) == 0: self.log.emit('no subnets found for role: {}'.format(role_name), 'warning') # exit early. return None # sort by subnets by amount of instances, smallest first. subnets = sorted( subnets, key=lambda sn: collection_len(sn.instances), ) # determine the count of this role's existing instances. # Note: we look for role in all subnets, not just the listed subnets. existing_count = len(self.evpc.get_role(role_name)) if existing_count >= desired_count: # for now we exit early, maybe terminate extras... msg = 'skipping role: {} (existing_count {} is greater than or equal to {})' self.log.emit(msg.format(role_name, existing_count, desired_count), 'debug') return None # determine count of additional instances needed to reach desired_count. needed_count = desired_count - existing_count needed_per_subnet = desired_count / len(subnets) needed_remainder = desired_count % len(subnets) block_device_map = get_block_device_map_from_role_config(role_data) role_instances = [] kwargs = { 'ImageId': ami, 'InstanceType': role_data.get('instance_type'), 'KeyName': key_pair.name, 'SecurityGroupIds': get_ids(security_groups), 'BlockDeviceMappings': block_device_map, 'UserData': role_data.get('userdata', ''), 'IamInstanceProfile': {}, } profile_name = role_data.get('instance_profile_name', None) if profile_name: kwargs['IamInstanceProfile'] = {'Name': profile_name} for subnet in subnets: # ensure Run_Instance_Idempotency.html#client-tokens kwargs['ClientToken'] = str(uuid4()) # figure out how many instances this subnet needs to create ... existing_in_subnet = len( self.evpc.get_role(role_name, subnet.instances.all())) count = needed_per_subnet - existing_in_subnet if needed_remainder != 0: needed_remainder -= 1 count += 1 if count == 0: # skip this subnet, it doesn't need to launch any instances. continue subnet_name = make_tag_dict(subnet)['Name'] msg = '{} instances of role {} launching into {} subnet' self.log.emit(msg.format(count, role_name, subnet_name)) # create a batch of instances in subnet! kwargs['MinCount'] = kwargs['MaxCount'] = count instances = self._create_instances(subnet, **kwargs) # accumulate all new instances into a single list. role_instances += instances # add role tag to each instance. for instance in role_instances: update_tags(instance, role=role_name)
def _update_key_pairs_tag(self, key_names): update_tags(self.evpc, key_pairs = ','.join(key_names))