def downbakupfile(AccessKeyId, AccessKeySecret, args):
client = AcsClient(AccessKeyId, AccessKeySecret, 'cn-shanghai', timeout=600)
start_time = args.st
end_time = args.et
request = DescribeBackupsRequest()
request.set_accept_format('json')
request.set_DBInstanceId(args.i)
# 新建目录并下载备份文件
if os.path.exists(args.d):
pass
else:
os.mkdir(args.d)
# 获取备份总数及每页显示数，计算页数
request.set_StartTime(start_time)
request.set_EndTime(end_time)
response = client.do_action_with_exception(request)
pages = math.ceil(eval(str(response, encoding='utf-8'))['TotalRecordCount'] / eval(str(response, encoding='utf-8'))['PageRecordCount'])
for page in range(1, pages + 1):
request.set_PageNumber(page)
response = client.do_action_with_exception(request)
backupdetail = eval(str(response, encoding='utf-8'))['Items']['Backup']
for i in range(len(backupdetail)):
bakfile_url = backupdetail[i]['BackupDownloadURL'] # 外网下载地址
# bakfile_url = backupdetail[i]['BackupIntranetDownloadURL'] # 内网下载地址
re_result = wget.filename_from_url(bakfile_url)
bakfile = os.path.join(os.path.join(os.path.dirname(os.path.abspath(__file__)), args.d),re_result)
if os.path.exists(bakfile):
pass
else:
wget.download(bakfile_url, out=bakfile)
print('下载文件 %s 成功' % bakfile)
deletefile(args.d)
def getAliCloundCertificateLocationList(self):
client=AcsClient(self.secreyKey,self.accesssecret)
req = DescribeLocationListRequest()
req.set_accept_format('json')
try:
data=client.do_action_with_exception(req)
if data:
return data
else:
return False
except Exception as e:
logger.error(e)
return False
def get_region_redis(self, page_number=1, page_size=50):
try:
clt = AcsClient(self.access_id, self.access_key, self.region)
request = DescribeInstancesRequest()
request.set_accept_format('json')
request.set_PageNumber(page_number)
request.set_PageSize(page_size)
response = clt.do_action_with_exception(request)
return json.loads(str(response, encoding="utf8"))
except Exception as err:
print(err)
return {}
def __get_ecs(client: AcsClient, kwargs) -> list:
instances_request = CommonRequest(domain=settings.DEPLOY_CONF.get(
'aliyun_api_address', 'ecs'),
version='2014-05-26',
action_name='DescribeInstances')
instances_request.add_query_param('PageSize', 100)
return_instances = []
response = client.do_action_with_exception(instances_request)
res_instance_list = json.loads(response.decode())['Instances']['Instance']
return_instances.extend(res_instance_list)
page_number = 1
while True:
page_number += 1
instances_request.add_query_param('PageNumber', page_number)
response = client.do_action_with_exception(instances_request)
res_instance_list = json.loads(
response.decode())['Instances']['Instance']
if not res_instance_list:
break
return_instances.extend(res_instance_list)
return return_instances
def test_set_max_retry_times(self):
client = AcsClient(self.access_key_id,
self.access_key_secret,
self.region_id,
max_retry_time=8)
request = DescribeInstancesRequest()
request.set_endpoint("somewhere.you.will.never.get")
def no_sleep(delay):
pass
with patch.object(client,
"_handle_single_request",
wraps=client._handle_single_request) as monkey:
with patch.object(time, "sleep", no_sleep):
try:
client.do_action_with_exception(request)
assert False
except ClientException as e:
self.assertEqual(error_code.SDK_HTTP_ERROR,
e.get_error_code())
self.assertEqual(9, monkey.call_count)
def test_throttled_backoff(self):
client = AcsClient(self.access_key_id,
self.access_key_secret,
self.region_id,
max_retry_time=10)
request = DescribeInstancesRequest()
globals()["_test_compute_delay"] = []
def record_sleep(delay):
global _test_compute_delay
_test_compute_delay.append(delay)
def _handle_single_request(endpoint,
request,
request_timeout,
request_connect_timeout,
signer=None):
return 400, {}, None, ServerException("Throttling", "some error")
client._handle_single_request = _handle_single_request
with patch.object(time, "sleep", wraps=record_sleep) as monkey:
try:
client.do_action_with_exception(request)
assert False
except ServerException as e:
self.assertEqual("Throttling", e.get_error_code())
self.assertEqual(10, monkey.call_count)
self.assertEqual(10, len(_test_compute_delay))
base = 0.5
for i in range(10):
min_delay = base / 2.0
max_delay = base
self.assertTrue(min_delay < _test_compute_delay[i] < max_delay)
base *= 2
if base >= 20:
base = 20
def free():
instance_list = acdb.db.load_or("instance_list", [])
region_instance_id_list = [[e["RegionId"], e["InstanceId"]]
for e in instance_list]
# Stop ECS instance
for (region_id, instance_id) in region_instance_id_list:
client = AcsClient(
conf.secret["aliyun"]["access_key"],
conf.secret["aliyun"]["access_secret"],
region_id,
)
req = StopInstanceRequest()
req.set_accept_format("json")
req.set_InstanceId(instance_id)
client.do_action_with_exception(req)
print("Stop", region_id, instance_id)
print("Wait")
for _ in range(1 << 32):
if sum([
e["Status"] == "Stopped" for e in info(region_instance_id_list)
]) == len(region_instance_id_list):
break
time.sleep(30)
# Delete ECS instance
for (region_id, instance_id) in region_instance_id_list:
client = AcsClient(
conf.secret["aliyun"]["access_key"],
conf.secret["aliyun"]["access_secret"],
region_id,
)
req = DeleteInstanceRequest()
req.set_accept_format("json")
req.set_InstanceId(instance_id)
client.do_action_with_exception(req)
print("Delete", instance_id)
acdb.db.save("instance_list", [])
def update_record(accessKeyId, accessSecret, recordid, RR, Type, target):
client = AcsClient(accessKeyId, accessSecret, 'cn-hangzhou')
request = UpdateDomainRecordRequest()
request.set_accept_format('json')
request.set_RecordId(recordid)
request.set_RR(RR)
request.set_Type(Type)
request.set_Value(target)
response = client.do_action_with_exception(request)
def createTCPListener(self, SLBid, lintenPort, backPort):
client = AcsClient(self.ak, self.sk, self.domain)
request = CreateLoadBalancerTCPListenerRequest()
request.set_LoadBalancerId(SLBid)
request.set_accept_format('json')
request.set_ListenerPort(lintenPort)
request.set_BackendServerPort(backPort)
request.set_healthCheckInterval(10) # 检查间隔10秒
request.set_Scheduler("wlc") # 默认加权最小连接数
request.set_HealthCheckType("tcp") # tcp方式检查
request.set_Bandwidth(-1) # 带宽不做限制
response = client.do_action_with_exception(request)
print(str(response, encoding='utf-8'))
def create(self, name, nettype):
client = AcsClient(self.ak, self.sk, self.domain)
request = CreateLoadBalancerRequest()
request.set_accept_format('json')
request.set_LoadBalancerSpec("slb.s1.small")
request.set_LoadBalancerName(name)
request.set_AddressType(nettype)
response = client.do_action_with_exception(request)
result = str(response, encoding='utf-8')
data = json.loads(result)
SLBid = data["LoadBalancerId"] # 获取到SLBid
# print(str(response, encoding='utf-8'))
return SLBid
def get_all_regions(self):
'''get all available reigins for current region
:return: a list, which is mapping for regions
'''
client = AcsClient(self.secret_key, self.secret_id, "default")
request = self.__common_request_settings
request.set_action_name('DescribeRegions')
request.set_domain('ecs.aliyuncs.com')
response = client.do_action_with_exception(request)
str_response = (str(response, encoding='utf-8'))
regions = json.loads(str_response).get('Regions').get('Region')
return regions
def InstanceStatus(regionId, instanceId, type):
typedict = {
0: StopInstanceRequest,
1: StartInstanceRequest,
2: RebootInstanceRequest
}
client = AcsClient(accesskeyId, accessSecret, regionId)
request = typedict[int(type)]()
request.set_accept_format('json')
request.set_InstanceId(instanceId)
response = client.do_action_with_exception(request)
print(str(response, encoding='utf-8'))
#获取实例状态
import time
time.sleep(60)
getInstanceInfo = DescribeInstanceAttributeRequest()
getInstanceInfo.set_accept_format('json')
getInstanceInfo.set_InstanceId(instanceId)
ecsstatus = json.loads(client.do_action_with_exception(getInstanceInfo))
print("ecsstatus %s" % ecsstatus)
return ecsstatusdict[ecsstatus["Status"]]
def DescribeSecurityGroupAttribute(ui, AccessKeyID, AccessKeySecret, ZoneId,
SecurityGroupId):
# print(AccessKeyID, AccessKeySecret, ZoneId, SecurityGroupId)
client = AcsClient(AccessKeyID, AccessKeySecret, ZoneId)
request = DescribeSecurityGroupAttributeRequest()
request.set_accept_format('json')
request.set_SecurityGroupId(SecurityGroupId)
response = client.do_action_with_exception(request)
# python2: print(response)
print(str(response, encoding='utf-8'))
def __delete_image(img_id, region):
client = AcsClient(__SK, __KEY, region)
d_request = DeleteImageRequest()
d_request.set_accept_format('json')
d_request.set_ImageId(img_id)
result = json.loads(client.do_action_with_exception(d_request))
if 'Code' in result:
logging.warn('remove image failed')
logging.error('remove failed . message: ' % result['Message'])
return False
else:
logging.info('Ok,image has been removed')
return True
def do_action(self, queryset):
for obj in queryset:
alikey = AliKey.objects.get(id=3)
client = AcsClient(alikey.ak_id, alikey.ak_secret, 'us-west-1')
request = CommonRequest()
request.set_accept_format('json')
request.set_domain('ecs.aliyuncs.com')
request.set_method('POST')
request.set_version('2014-05-26')
request.set_action_name('RebootInstance')
request.add_query_param('InstanceId', obj.shiliid)
request.add_query_param('ForceStop', 'true')
response = client.do_action_with_exception(request)
try:
print("a")
response = client.do_action_with_exception(request)
except:
print("false")
return
def get_redis_backups(cls, access_key_id, access_key_secret, region_id,
instance_id, last_backup_days):
client = AcsClient(access_key_id, access_key_secret, region_id)
request = DescribeBackupsRequest()
request.set_accept_format('json')
start_time = datetime.datetime.now() - datetime.timedelta(
days=last_backup_days)
end_time = datetime.datetime.now()
request.set_StartTime(cls.convert_to_ali_time(start_time))
request.set_EndTime(cls.convert_to_ali_time(end_time))
request.set_InstanceId(instance_id)
response = client.do_action_with_exception(request)
return json.loads(response)["Backups"]["Backup"]
def get_expire_domain(domain,
AccessKeyId=AccessKeyId,
AccessKeySecret=AccessKeySecret):
clt = AcsClient(AccessKeyId, AccessKeySecret)
request = QueryDomainListRequest()
request.set_PageSize(10)
request.set_PageNum(1)
request.set_DomainName(domain)
result = clt.do_action_with_exception(request)
res_dict = json.loads(result)
return res_dict.get("Data").get("Domain")[0].get("ExpirationCurrDateDiff")
class TextMessage:
def __init__(self):
# 注意：不要更改
REGION = "cn-hangzhou"
PRODUCT_NAME = "Dysmsapi"
DOMAIN = "dysmsapi.aliyuncs.com"
self.acs_client = AcsClient(const.AccessKeyID, const.AccessKeySecret, REGION)
region_provider.add_endpoint(PRODUCT_NAME, REGION, DOMAIN)
def sendSMS(self, businessID, phoneNumber, templatePara = None, signName = SIGNNAME, messageType = VERIFICATION):
'''
templatePara: dict
used to send text message to phoneNumber
if messageType == VERIFICATION, templatePara must contain key 'code'
'''
smsRequest = SendSmsRequest.SendSmsRequest()
# 申请的短信模板编码,必填
if (messageType == VERIFICATION):
smsRequest.set_TemplateCode(const.Verification)
# 短信模板变量参数
if templatePara is not None:
smsRequest.set_TemplateParam(templatePara)
else:
raise ValueError("you must give a paramter to send message")
# 设置业务请求流水号，必填。
smsRequest.set_OutId(businessID)
# 短信签名
smsRequest.set_SignName(signName)
# 数据提交方式
# smsRequest.set_method(MT.POST)
# 数据提交格式
# smsRequest.set_accept_format(FT.JSON)
# 短信发送的号码列表，必填。
smsRequest.set_PhoneNumbers(phoneNumber)
# 调用短信发送接口，返回json
smsResponse = self.acs_client.do_action_with_exception(smsRequest)
# TODO 业务处理
return smsResponse
def create_ali_ecs_PostPaid(ImageId, InstanceType,
SecurityGroupIds, VSwitchId,
InstanceName, Description,
HostName, ZoneId,
regionId, service_name, *args, **kwargs):
# print(args)
# print(kwargs)
client = AcsClient(accessKeyId, accessSecret, regionId)
request = RunInstancesRequest()
request.set_accept_format('json')
password = '******'
request.set_ImageId(ImageId)
request.set_InstanceType(InstanceType)
request.set_SecurityGroupIdss(SecurityGroupIds)
request.set_VSwitchId(VSwitchId)
request.set_InstanceName(InstanceName)
request.set_Description(Description)
request.set_HostName(HostName)
request.set_Password(password)
request.set_ZoneId(ZoneId)
request.set_Amount(1)
request.set_SecurityEnhancementStrategy("Active")
request.set_Tags([
{
"Key": "group",
"Value": service_name
}
])
for kwarg in kwargs:
# 判断数据盘指定与否
if 'datadisk' in kwarg:
DataDisk = kwargs['datadisk']['datadisk']
request.set_DataDisks([
{
"Size": DataDisk,
"Category": "cloud_ssd"
}
])
request.set_InstanceChargeType("PostPaid")
response = client.do_action_with_exception(request)
res = json.loads(str(response, encoding='utf-8'))
return res
def get_ecs_ids(keys):
'''
获取所有ECS的实例id
:return:
'''
key_id = keys['key_id']
key_secret = keys['key_secret']
region_id = keys['region_id']
client = AcsClient(key_id, key_secret, region_id)
try:
request = DescribeInstanceStatusRequest.DescribeInstanceStatusRequest()
response = client.do_action_with_exception(request)
response_json = json.loads(response)
TotalCount = response_json['TotalCount']
PageSize = response_json['PageSize']
PageNum = response_json['PageNumber']
TotalNum = math.ceil(int(TotalCount) / int(PageSize))
result = [{
'TotalCount': TotalCount,
'TotalNum': TotalNum,
'PageNum': PageNum
}]
for pagenums in range(1, int(result[0]['TotalNum']) + 1):
request = DescribeInstanceStatusRequest.DescribeInstanceStatusRequest(
)
request.set_PageNumber(pagenums)
response = client.do_action_with_exception(request)
response_json = json.loads(response)
Items = response_json['InstanceStatuses']['InstanceStatus']
for item in Items:
result.append(item['InstanceId'])
except Exception as e:
print(e)
result = []
return result
def test_retry_with_client_token(self):
client = AcsClient(self.access_key_id, self.access_key_secret, self.region_id)
orginal_func = client._handle_single_request
request = CreateInstanceRequest()
request.set_ImageId("coreos_1745_7_0_64_30G_alibase_20180705.vhd")
request.set_InstanceType("ecs.n2.small")
globals()['_test_client_token'] = None
globals()['_test_retry_times'] = 0
def _handle_single_request(endpoint, request, request_timeout, signer=None):
global _test_client_token
global _test_retry_times
if _test_retry_times > 0:
assert _test_client_token == request.get_ClientToken()
_test_retry_times += 0
_test_client_token = request.get_ClientToken()
return (
None,
None,
None,
ClientException(error_code.SDK_HTTP_ERROR, "some error"),
)
def no_sleep(delay):
pass
with patch.object(time, "sleep", no_sleep):
with patch.object(client, "_handle_single_request",
wraps=_handle_single_request) as monkey:
try:
client.do_action_with_exception(request)
assert False
except ClientException as e:
self.assertEqual(error_code.SDK_HTTP_ERROR, e.get_error_code())
self.assertEqual(4, monkey.call_count)
def get_cloud_ip(DomainName, target_RR):
client = AcsClient(accessKeyId, accessSecret, 'cn-hangzhou')
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(DomainName)
response = client.do_action_with_exception(request)
cloud_data = json.loads(response)['DomainRecords']['Record']
new_cloud_date = []
for Record in cloud_data:
if Record['RR'] in target_RR:
cloud_ip = Record['Value']
new_cloud_date.append(Record)
return cloud_ip, new_cloud_date
def get_record(rr=None):
client = AcsClient(accessKeyId, accessSecret, 'cn-hangzhou')
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName("henqy.club")
if not rr:
pass
else:
request.set_RRKeyWord(rr)
response = client.do_action_with_exception(request)
record = loads(response)['DomainRecords']['Record']
return record
def get_aliecs_info(instance_id):
client = AcsClient(accessKeyId, accessSecret, regionId)
request = DescribeInstancesRequest()
request.set_accept_format('json')
instnce_id_data = []
instnce_id_data.append(instance_id)
# print(instnce_id_data)
request.set_InstanceIds(instnce_id_data)
response = client.do_action_with_exception(request)
res = json.loads(str(response, encoding='utf-8'))
disks_info = get_instance_disk_info(instance_id)
# print(disks_info)
res['disk_infos'] = disks_info
return res
def update_namespace_request(self, namespace, request_body):
"""
This method will update namespace present in alibaba
:param namespace:
:param request_body:
:return:
"""
error = False
response = None
try:
client = AcsClient(self.access_key, self.secret_key,
self.region_id)
request_update_namespace = UpdateNamespaceRequest.UpdateNamespaceRequest(
)
request_update_namespace.set_endpoint(self.region_id)
request_update_namespace.set_Namespace(namespace)
request_update_namespace.set_content(json.dumps(request_body))
response_update_namespace = client.do_action_with_exception(
request_update_namespace)
response = json.loads(response_update_namespace)
except ServerException as e:
error = True
if 'key is not found.' in str(e.message):
response = e.message
else:
if 'ServerResponseBody' in e.message:
response = json.loads(
str(e.message).split('ServerResponseBody: ')[1]).get(
'message')
elif response == '':
response = 'Invalid request %s' % json.loads(
str(e.message).split('ServerResponseBody: ')[1]).get(
'code')
elif response is None:
response = e.error_code
else:
response = e.message
except ClientException as e:
error = True
if 'Max retries exceeded' in str(e.message):
response = 'Max retries exceeded, Failed to establish a new connection'
else:
response = e.message
except Exception as e:
error = True
response = e.message
print(e.message)
finally:
return error, response
def send_msg(request):
if not request.form.get('receiver') or not re.match(
r"^1[35678]\d{9}$", request.form.get('receiver')):
return jsonify({
'status': 'fail',
'info': 'send msg fail, please check receiver.'
}), 400
else:
receiver = request.form.get('receiver')
if not request.form.get('text') or not re.match(r"^\d{6}$",
request.form.get('text')):
return jsonify({
'status': 'fail',
'info': 'send msg fail, please check text.'
}), 400
else:
text = request.form.get('text')
if 'username' not in session and request.form.get(
'token') != config.Config.TOKEN:
return jsonify({
'status': 'fail',
'info': 'no certified operate.'
}), 400
try:
client = AcsClient(config.Config.ALI_ASSESS_KEY_ID,
config.Config.ALI_ASSESS_KEY_SECRET,
config.Config.ALI_REGION_ID)
request = CommonRequest()
request.set_accept_format('json')
request.set_domain('dysmsapi.aliyuncs.com')
request.set_method('POST')
request.set_protocol_type('https')
request.set_version('2017-05-25')
request.set_action_name('SendSms')
request.add_query_param('RegionId', config.Config.ALI_REGION_ID)
request.add_query_param('PhoneNumbers', receiver)
request.add_query_param('SignName', "KisPig网")
request.add_query_param('TemplateCode', "SMS_184215625")
request.add_query_param('TemplateParam',
"{\"message\": \"" + text + "\"}")
response = client.do_action_with_exception(request)
return jsonify({'status': 'ok', 'info': 'send msg success.'}), 200
except Exception as e:
return jsonify({
'status': 'fail',
'info': 'send msg fail.',
'reason': str(e)
}), 400
def test_normal_backoff(self):
client = AcsClient(self.access_key_id,
self.access_key_secret,
self.region_id,
max_retry_time=10)
request = DescribeInstancesRequest()
request.set_endpoint("somewhere.you.will.never.get")
globals()["_test_compute_delay"] = []
def record_sleep(delay):
global _test_compute_delay
_test_compute_delay.append(delay)
with patch.object(time, "sleep", wraps=record_sleep) as monkey:
try:
client.do_action_with_exception(request)
assert False
except ClientException as e:
self.assertEqual(error_code.SDK_HTTP_ERROR, e.get_error_code())
self.assertEqual(10, monkey.call_count)
self.assertEqual([0.1, 0.2, 0.4, 0.8, 1.6, 3.2, 6.4, 12.8, 20.0, 20.0],
_test_compute_delay)
def ALICDNConfig(domain, ak, sk):
try:
CLI = AcsClient(ak, sk, 'cn-hangzhou')
request = DescribeCdnDomainDetailRequest()
request.set_accept_format('json')
request.set_DomainName(domain)
response = json.loads(CLI.do_action_with_exception(request))
return {
"msg":
response['GetDomainDetailModel']['SourceModels']['SourceModel'],
"code": 200
}
except aliexceptions.ServerException as err:
return {"msg": str(err), "code": 5001}
def listByDomain(_client: AcsClient, _Domain_str: str):
"""
获取指定域名下所有解析列表
:param _client:
:param _Domain_str: 域名（例如：qq.com,必须是顶级域名）
:return:
"""
request = DescribeDomainRecordsRequest()
request.set_accept_format('json')
request.set_DomainName(_Domain_str)
response = _client.do_action_with_exception(request)
return json.loads(str(response, encoding='utf-8'))
def add_mxrecord(accessKeyId, accessSecret, DomainName, RR, Type, target,
Priority):
client = AcsClient(accessKeyId, accessSecret, 'cn-hangzhou')
request = AddDomainRecordRequest()
request.set_accept_format('json')
request.set_DomainName(DomainName)
request.set_RR(RR)
request.set_Type(Type)
request.set_Value(target)
request.set_Priority(Priority)
response = client.do_action_with_exception(request)
class Aliyun(object):
"""
:param access_key: access_key.
:param access_secret: access_secret.
:param region: region.
"""
def __init__(self, access_key, access_secret, region="cn-beijing"):
self.region = region
self.client = AcsClient(access_key, access_secret, self.region)
self.zones = None
def request_page_query(self, req):
page_size = 50
index = 1
req.set_query_params({'PageSize': page_size})
req.set_query_params({'PageNumber', index})
body = self.client.do_action_with_exception(req)
res = json.loads(body.decode("utf-8"))
total_count = res['TotalCount']
if total_count <= page_size:
yield res
else:
current_count = total_count
while current_count < total_count:
index += 1
req.set_query_params({'PageNumber', index})
body = self.client.do_action_with_exception(req)
current_count += page_size
yield json.loads(body.decode("utf-8"))
def get_zone(self, zone_id):
if not self.zones:
self.zones = self.__request_zones()
for zone in self.zones:
if zone['ZoneId'] == zone_id:
return zone
raise ValueError("Invalid ZoneId.")
def __request_zones(self):
req = DescribeZonesRequest.DescribeZonesRequest()
result = self.__do_request(req)["Zones"]["Zone"]
return result
def __do_request(self, req):
body = self.client.do_action_with_exception(req)
return json.loads(body.decode("utf-8"))
def create_instance(self, instance):
"""
:param Instance instance: class Instance
:param callback: callback function run after instance creation successfully.
"""
c = instance.config
zone = self.get_zone(c.ZoneId)
check_resource_types(zone)
check_instance_type(zone, instance.is_io_optimized, c.InstanceType)
req = self.prepare_instance_create_request(zone, instance)
res = self.__do_request(req)
return res
def prepare_instance_create_request(self, zone, instance):
c = instance.config
request = CreateInstanceRequest.CreateInstanceRequest()
request.set_accept_format('json')
request.add_query_param('RegionId', self.region)
for k, v in c.items():
request.add_query_param(k, v)
check_system_disk_categories(zone, instance.is_io_optimized, instance.system_disk.category)
request.add_query_param('SystemDisk.Category', instance.system_disk.category)
request.add_query_param('SystemDisk.Size', instance.system_disk.size)
index = 1
for disk in instance.data_disks:
check_data_disk_categories(zone, instance.is_io_optimized, disk.category)
request.add_query_param('DataDisk.%d.Category' % index, disk.category)
request.add_query_param('DataDisk.%d.Size' % index, disk.size)
index += 1
index = 1
for tag in instance.tags:
request.add_query_param('Tag.%d.Key' % index, tag.key)
request.add_query_param('Tag.%d.Value' % index, tag.value)
index += 1
return request
from aliyunsdkecs.request.v20140526 import \
DescribeZonesRequest, \
DescribeImagesRequest, \
DescribeInstanceTypesRequest, \
DescribeSecurityGroupsRequest, \
DescribeSecurityGroupAttributeRequest
pp = pprint.PrettyPrinter(indent=2)
access_key = ''
access_key_secret = ''
client = AcsClient(access_key, access_key_secret, 'cn-beijing')
# print Regions
req = DescribeRegionsRequest.DescribeRegionsRequest()
body = client.do_action_with_exception(req)
pp.pprint(json.loads(body.decode("utf-8")))
# VSwitch
req = DescribeVSwitchesRequest.DescribeVSwitchesRequest()
req.set_query_params({'PageSize': 50})
body = client.do_action_with_exception(req)
pp.pprint(json.loads(body.decode("utf-8")))
# zone
req = DescribeZonesRequest.DescribeZonesRequest()
body = client.do_action_with_exception(req)
pp.pprint(json.loads(body.decode("utf-8")))
# SecurityGroup
req = DescribeSecurityGroupsRequest.DescribeSecurityGroupsRequest()
except:
print('\nError when retrieving the URL:', _save_path)
logging.info("Downloading file.")
down(file_path, url)
else:
logging.info("File exists.")
# 获取RDS所有的实例列表
#
request_rds_list = DescribeDBInstancesRequest.DescribeDBInstancesRequest()
response_rds_list = client.do_action_with_exception(request_rds_list)
response_rds_list_json = json.loads(response_rds_list)
# 获取所有RDS节点备份并调用备份函数备份
#
for i in range(0,response_rds_list_json['TotalRecordCount']):
# print(i)
print(response_rds_list_json['Items']['DBInstance'][i]["DBInstanceId"])
rds_instance_id = response_rds_list_json['Items']['DBInstance'][i]["DBInstanceId"]
rds_instance_name = response_rds_list_json['Items']['DBInstance'][i]["DBInstanceDescription"]
# 调用函数进行备份每一个实例的备份文件
jsm_get_rds_backup(client=client,rds_instance_id=rds_instance_id,rds_instance_name=rds_instance_name)
