def create_vm(self, create_params):
try:
for params in create_params:
computer_name = params["computer_name"]
admin_username = params["admin_username"]
password = params["password"]
vm_size = params["vm_size"]
publisher = params["publisher"]
offer = params["offer"]
sku = params["sku"]
version = params["version"]
group_name = params["group_name"]
region = params["region"]
result = self.create_network_interface(group_name, region,
computer_name)
vm_params = {
'location': region,
'os_profile': {
'computer_name': computer_name,
'admin_username': admin_username,
'admin_password': password
},
'hardware_profile': {
'vm_size': vm_size
},
'storage_profile': {
'image_reference': {
'publisher': publisher,
'offer': offer,
'sku': sku,
'version': version
},
},
'network_profile': {
'network_interfaces': [{
'id': result.id,
}]
},
}
response = self.client.virtual_machines.create_or_update(
group_name, computer_name, vm_params)
return response
except Exception as e:
msg1 = "Error while creating VM in azure "
exit_message(msg1 + str(e), 1, self.isJson)
return 0
def create_db(self, create_params):
try:
for params in create_params:
server_name = params["instance"]
administrator_login = params["master_user"]
administrator_login_password = params["password"]
storage_mb = params.get("allocated_storage")
version = params["engine_version"]
group_name = params["group_name"]
region = params["region"]
ssl_mode = params.get("ssl_mode", 'Disabled')
start_ip = params.get("start_ip", None)
end_ip = params.get("end_ip", None)
publicly_accessible = params.get("publicly_accessible", None)
db_params = {
'location': region,
'properties': {
'version': version,
'create_mode': 'Default',
'administrator_login': administrator_login,
'administrator_login_password':
administrator_login_password,
'ssl_enforcement': ssl_mode
}
}
if storage_mb:
db_params["properties"]["storage_mb"] = storage_mb
response = self.client.servers.create_or_update(
group_name, server_name, db_params)
response.wait()
# Creating and adding firewall to server
if publicly_accessible == "Yes":
firewall_response = self.client.firewall_rules.create_or_update(
group_name, server_name,
server_name + "-default-firewall-rule", '0.0.0.0',
'255.255.255.255')
elif start_ip and end_ip:
firewall_response = self.client.firewall_rules.create_or_update(
group_name, server_name,
server_name + "-default-firewall-rule", start_ip,
end_ip)
firewall_response.wait()
return response
except Exception as e:
msg1 = "Error while creating postgres instance in azure "
exit_message(msg1 + str(e), 1, self.isJson)
return 0
def get_vm_list(self, filter_params={}):
self.header_keys = [
'region', 'name', 'type', 'public_ips', 'private_ips', 'state'
]
self.header_titles = [
'Region', 'Name', 'Instance Type', 'Public Ips', 'Private Ips',
'state'
]
p_region = filter_params.get("region", "")
p_instance = filter_params.get("instance", "")
info = False
if p_instance:
info = True
ec2_regions = []
available_ec2_regions = boto3.session.Session().get_available_regions(
self.instance_type)
if p_region > "":
if p_region in available_ec2_regions:
ec2_regions = [p_region]
else:
msg = str(p_region) + " is not a valid region for ec2."
exit_message(msg, 1, self.isJson)
else:
ec2_regions = available_ec2_regions
ec2_hosts = []
for region in ec2_regions:
try:
msg = "Searching " + region + "..."
message(msg, "info", self.isJson)
ec2 = get_client('ec2', region=region)
hosts = ec2.describe_instances()
for host in hosts['Reservations']:
for h in host['Instances']:
if p_instance > "":
if p_instance != h['InstanceId']:
continue
vm = AwsVM(h)
vm.region = region
if p_instance:
vm.set_extra_info(h)
if self.verbose:
print_verbose(vm.__dict__)
ec2_hosts.append(vm.__dict__)
except Exception as e:
pass
return ec2_hosts
def get_rds_list(self, filter_params={}):
self.header_keys = [
'region', 'instance', 'status', 'db_class', 'engine_version'
]
self.header_titles = [
'Region', 'Instance', 'Status', 'Class', 'Version'
]
p_region = filter_params.get("region", "")
p_instance = filter_params.get("instance", "")
rds_regions = []
available_rds_regions = boto3.session.Session().get_available_regions(
"rds")
if p_region > "":
if p_region in available_rds_regions:
rds_regions = [p_region]
else:
msg = str(p_region) + " is not a valid region for rds."
exit_message(msg, 1, self.isJson)
else:
rds_regions = available_rds_regions
# get all of the postgres db instances
pg_list = []
for region in rds_regions:
msg = "Searching " + region + "..."
message(msg, "info", self.isJson)
rds = get_client('rds', region=region)
dbs = rds.describe_db_instances()
for db in dbs['DBInstances']:
if db['Engine'] in ["postgres"]:
if p_instance > "":
if p_instance != db['DBInstanceIdentifier']:
continue
rds = AwsRDS(db)
rds.region = region
if p_instance:
extras_args = {}
extras_args['ec2'] = get_client('ec2', region=region)
rds.set_extra_info(db, extras_args)
if self.verbose:
print_verbose(rds.__dict__, p_type="pg")
pg_list.append(rds.__dict__)
return pg_list
def create_vm(self, p_dict):
response = {
'state': 'complete',
'msg': 'Instance created successfully.'
}
for d in p_dict:
p_region = d['region']
ec2_params = {}
ec2_params['MinCount'] = 1
ec2_params['MaxCount'] = 1
try:
ec2_params['ImageId'] = d['image_id']
ec2_params['InstanceType'] = d['instance_type']
except Exception as e:
exit_message("missing required field " + str(e), 1,
self.isJson)
if d.get("kernel_id"):
ec2_params['KernelId'] = d.get("kernel_id")
if d.get("keyname"):
ec2_params['KeyName'] = d.get("key_name")
if d.get("monitoring"):
ec2_params['Monitoring'] = d.get("monitoring")
if d.get("ramdisk_id"):
ec2_params['RamdiskId'] = d.get("ram_disk_id")
if d.get("subnet_id"):
ec2_params['SubnetId'] = d.get("subnet_id")
if d.get("user_data"):
ec2_params['UserData'] = d.get("user_data")
if d.get("additional_info"):
ec2_params['AdditionalInfo'] = d.get("additional_info")
if d.get("client_token"):
ec2_params['ClientToken'] = d.get("client_token")
if d.get("disable_api_termination"):
ec2_params['DisableApiTermination'] = d.get(
"disable_api_termination")
if d.get("dryrun"):
ec2_params['DryRun'] = d.get("dry_run")
if d.get("ebs_optimized"):
ec2_params['EbsOptimized'] = d.get("ebs_optimized")
if d.get("shutdown_behaviour"):
ec2_params['InstanceInitiatedShutdownBehavior'] = d.get(
"shutdown_behaviour")
if d.get("private_ip_address"):
ec2_params['PrivateIpAddress'] = d.get("private_ip_address")
if d.get("tags"):
tags = []
for tag in d.get("tags").keys():
tags.append({'Key': tag, "Value": d.get("tags").get(tag)})
ec2_params['TagSpecifications'] = [{
"ResourceType": "instance",
"Tags": tags
}]
try:
cred_json = get_credentials_by_type(cloud_type="aws")
if len(cred_json) > 0:
credentials = cred_json[0]['credentials']
ec2 = boto3.resource(
"ec2",
aws_access_key_id=credentials['access_key_id'],
aws_secret_access_key=credentials["secret_access_key"],
region_name=p_region)
else:
ec2 = boto3.resource("ec2", region_name=p_region)
instance = ec2.create_instances(**ec2_params)
except Exception as e:
response['state'] = 'failed'
response['msg'] = "ec2.create_instances(): " + str(e)
return response
return response
def create_db(self, p_dict):
### optional parms #############
engine = "postgres"
multi_az = False
public_access = False
storage_encrypted = False
monitoring_interval = 0 # Valid Values: 0, 1, 5, 10, 15, 30, 60
### mandatory parms ############
for d in p_dict:
try:
p_region = d['region']
db_params = {}
db_params['DBName'] = d['db_name']
db_params['DBInstanceClass'] = d['db_class']
db_params['DBInstanceIdentifier'] = d['instance']
db_params['MasterUsername'] = d['master_user']
db_params['MasterUserPassword'] = d['password']
#db_params['DBSubnetGroupName'] = d['subnet_group']
db_params['Engine'] = d.get("engine", engine)
db_params['MultiAZ'] = d.get("multi_az", multi_az)
db_params['PubliclyAccessible'] = d.get(
"public_accessible", public_access)
db_params['StorageEncrypted'] = d.get("storage_encrypted",
storage_encrypted)
db_params['MonitoringInterval'] = d.get(
"monitoring_interval", monitoring_interval)
s_port = str(d['port'])
try:
db_params['Port'] = int(s_port)
except Exception as e:
exit_message("port must be an integer", 1, self.isJson)
db_params['StorageType'] = d['storage_type']
s_allocated_storage = str(d['allocated_storage'])
try:
db_params['AllocatedStorage'] = int(s_allocated_storage)
except Exception as e:
exit_message("allocated storage GB must be an integer", 1,
self.isJson)
# All optional Params
if d.get("availability_zone"):
db_params['AvailabilityZone'] = d.get("availability_zone")
if d.get("security_groups"):
# List of security groups
db_params['DBSecurityGroups'] = d.get("security_groups")
if d.get("vpc_security_group_ids"):
# List of VPC security groups
db_params['VpcSecurityGroupIds'] = d.get(
"vpc_security_group_ids")
if d.get("maintenance_window"):
db_params['PreferredMaintenanceWindow'] = d.get(
"maintenance_window")
if d.get("db_parameter_group"):
db_params['DBParameterGroupName'] = d.get(
"db_parameter_group")
if d.get("backup_retention_period"):
# between 0 to 35
db_params['BackupRetentionPeriod'] = d.get(
"backup_retention_period")
if d.get("backup_window"):
db_params['PreferredBackupWindow'] = d.get("backup_window")
if d.get("engine_version"):
db_params['EngineVersion'] = d.get("engine_version")
if d.get("version_upgrade"):
db_params['AutoMinorVersionUpgrade'] = d.get(
"version_upgrade")
if d.get("licence_model"):
db_params['LicenseModel'] = d.get("licence_model")
if d.get("iops"):
db_params['Iops'] = d.get("iops")
if d.get("option_group_name"):
db_params['OptionGroupName'] = d.get("option_group_name")
if d.get("charset"):
db_params['CharacterSetName'] = d.get("charset")
if d.get("tags"):
# List of dict Eg : [ {"Key":'tag name',"Value":value}, ....]
db_params['Tags'] = d.get("tags")
if d.get("cluster_identifier"):
db_params['DBClusterIdentifier'] = d.get(
"cluster_identifier")
if d.get("tde_arn"):
db_params['TdeCredentialArn'] = d.get("tde_arn")
if d.get("tde_arn_pwd"):
db_params['TdeCredentialPassword'] = d.get("tde_arn_pwd")
if d.get("kms_key_id"):
db_params['KmsKeyId'] = d.get("kms_key_id")
if d.get("domain"):
db_params['Domain'] = d.get("domain")
if d.get("copy_tags"):
db_params['CopyTagsToSnapshot'] = d.get("copy_tags")
if d.get("monitor_arn"):
db_params['MonitoringRoleArn'] = d.get("monitor_arn")
if d.get("iam_role"):
db_params['DomainIAMRoleName'] = d.get("iam_role")
break
except Exception as e:
exit_message("missing required field " + str(e), 1,
self.isJson)
try:
response = get_client("rds",
p_region).create_db_instance(**db_params)
return response
except Exception as e:
msg1 = "rds.create_db_instance(): "
exit_message(msg1 + str(e), 1, self.isJson)
return (0)