from __future__ import print_function
import volcenginesdkecs
import volcenginesdkstorageebs
import volcenginesdkvpc
import sys
import volcenginesdkcore
from pprint import pprint
from volcenginesdkcore.rest import ApiException
import time
import json
from .yuanshi import *
# if __name__ == '__main__':
# configuration = volcenginesdkcore.Configuration()
# configuration.ak = "********************"
# configuration.sk = "******************"
# configuration.region = "cn-guilin-boe"
# try:
# # api_instance = volcenginesdkecs.ECSApi(volcenginesdkcore.ApiClient(configuration))
# api_instance=volcenginesdkstorageebs.STORAGEEBSApi(volcenginesdkcore.ApiClient(configuration))
# # resp=api_instance.create_volume(volcenginesdkstorageebs.CreateVolumeRequest(volume_name='test_yunhui',zone_id='cn-guilin-c',volume_type='ESSD_PL0',kind='data',size=20,)) #创建云盘api
# resp=api_instance.describe_volumes(volcenginesdkstorageebs.DescribeVolumesRequest(volume_name='test_yunhui',zone_id='cn-guilin-c',volume_status='attached')) #查询云盘api 可以模糊查询
# print(resp)
# resp=eval（str(resp))
# print(resp)
# # reap=api_instance.attach_volume(volcenginesdkstorageebs.AttachVolumeRequest(instance_id='i-yc7ysqcpxakdvamhn6lb',volume_id='vol-ldw6rdivpsgaptetcfc2'))
# # resp = api_instance.attach_volume(volcenginesdkstorageebs.AttachVolumeRequest())
# # resp=api_instance.describe_available_resource(volcenginesdkecs.DescribeAvailableResourceRequest(destination_resource='InstanceType',zone_id='cn-guilin-c',instance_type_id='ecs.g3i.xlarge')) #检查可用区剩余规格资源是否可用api
# # resp=eval（str(resp))['available_zones'][0]['available_resources'][0]['supported_resources'][0]['status'] #取出可用资源状态字典中的值
# # resp = api_instance.stop_instance(volcenginesdkecs.StopInstanceRequest(instance_id='i-yc7m08i48rkdvaaww49f',force_stop=False)) #StopInstanceRequest 关闭实例的api
# # time.sleep(10)
# # print(resp)
# # resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=['i-yc68wxpjwmexzl4trabg'])) #获取DescribeInstancesRequest 获取实例详细信息的api
# # resp=api_instance.replace_system_volume(volcenginesdkecs.ReplaceSystemVolumeRequest(instance_id='i-yc7m08i48rkdvaaww49f',image_id='image-ybzlq4f7lnia4oz5f8v9',password='root@123')) #ReplaceSystemVolumeRequest 给示例重装系统api
# # resp=api_instance.delete_instance(volcenginesdkecs.DeleteInstanceRequest(instance_id=instance_id)) #删除示例api
# # resp=api_instance.run_instances(
# # volcenginesdkecs.RunInstancesRequest(
# # count=1,
# # zone_id='cn-guilin-c',
# # image_id='image-ybzlq4f7lnia4oz5f8v9',
# # instance_type='ecs.g3i.large',
# # instance_name='yunhui_api_create',
# # password='root@123',
# # volumes1=[volcenginesdkecs.VolumeForRunInstancesInput(volume_type="ESSD_PL0",size=40,)],
# # network_interfaces=[volcenginesdkecs.NetworkInterfaceForRunInstancesInput(
# # subnet_id='subnet-2bz38x74sr0u82dx0eg039z49',
# # security_group_ids=['sg-2bzq6oxrg6kg02dx0eedwmc3m'],
# # )],
# # instance_charge_type='PostPaid',
# # ))
# # print(resp)
# # fasong(resp,'创建虚机')
# except ApiException as e:
# print("Exception when calling AUTOSCALINGApi->describe_scaling_groups: %s\n" % e)
class Volume_API_all():
#封装了操作云盘的api
def __init__(self,region='cn-guilin-boe',ak="***********************",sk="*************",host='volcengineapi-boe-stable.byted.org'):
self.region=region
self.ak=ak
self.sk=sk
self.host=host
if self.region=='cn-guilin-boe':
self.subnet_id='subnet-3rerjngm1c45c5zsk2hgcjb3v'
self.security_group_ids=['sg-2bzq6oxrg6kg02dx0eedwmc3m']
self.vpc_id='vpc-2bzq6orucueio2dx0ef84oc85'
self.zone_id='cn-guilin-c'
print(f'使用{self.region} 环境的虚机镜像和规格')
elif self.region=='cn-beijing':
self.subnet_id='subnet-mj6lr6onpgxs5smt1a6be1v7'
self.security_group_ids=['sg-rrokfkt1nq4gv0x57hpixo8']
self.zone_id='cn-beijing-b'
print(f'使用{self.region} 环境的虚机镜像和规格')
def start(self):
'''
返回实例化volum_api对象
'''
configuration = volcenginesdkcore.Configuration() #实例化配置文件对象
configuration.ak = self.ak
configuration.sk = self.sk
configuration.region = self.region
configuration.host=self.host
api_instance=volcenginesdkstorageebs.STORAGEEBSApi(volcenginesdkcore.ApiClient(configuration)) #实例化api对象供后续调用
return api_instance
def create_volume(self,count=1,volume_name='test_yunhui',volume_type='ESSD_PL0',size=20):
'''
创建数据盘的函数(封装了创建数据盘的api)
'''
zone_id=self.zone_id
try:
if count==1:
api_instance=self.start()
resp=api_instance.create_volume(volcenginesdkstorageebs.CreateVolumeRequest(volume_name=volume_name,zone_id=zone_id,volume_type=volume_type,kind='data',size=size))
resp=eval（str(resp))['volume_id']
return resp
else:
volume_list=[]
api_instance=self.start()
for i in range(count):
resp=api_instance.create_volume(volcenginesdkstorageebs.CreateVolumeRequest(volume_name=volume_name,zone_id=zone_id,volume_type=volume_type,kind='data',size=size))
resp=eval（str(resp))['volume_id']
volume_list.append(resp)
return volume_list
except:
return 0
def volume_chaxun(self,volume_name='test_yunhui',instance_id=None,volume_status='available',page_size=100,kind=None):
'''
return 0 ==查询失败
查询数据盘的函数(封装了查询数据盘的api) 如果volume_status='attached'已挂载,返回包含volume_id 和instance_id 的列表
volume_status(云盘状态) 取值说明如下：
available 可用
attaching 挂载中
attached 已挂载
detaching 卸载中
creating 创建中
deleting 删除中
error 错误
extending 扩容中
'''
zone_id=self.zone_id
try:
api_instance=self.start()
if instance_id!=None:
resp=api_instance.describe_volumes(volcenginesdkstorageebs.DescribeVolumesRequest(instance_id=instance_id,zone_id=zone_id,page_size=page_size,volume_status=volume_status,kind=kind)) #查询云盘的api
resp=eval（str(resp))['volumes']
volume_list=[]
for i in resp:
volume_list.append([i['volume_id'],i['instance_id']])
return volume_list #返回嵌套列表 [['volume_id'],['instance_id']] #返回一个实例上所有非系统盘的嵌套列表
elif volume_status !='attached':
resp=api_instance.describe_volumes(volcenginesdkstorageebs.DescribeVolumesRequest(volume_name=volume_name,instance_id=instance_id,zone_id=zone_id,page_size=page_size,volume_status=volume_status)) #查询云盘的api
resp=eval（str(resp))['volumes']
volume_list=[]
for i in resp:
volume_list.append(i['volume_id'])
print(f'共查询到{len(volume_list)}个状态为{volume_status}的云盘')
print(volume_list)
return volume_list
else:
resp=api_instance.describe_volumes(volcenginesdkstorageebs.DescribeVolumesRequest(volume_name=volume_name,instance_id=instance_id,zone_id=zone_id,page_size=page_size,volume_status=volume_status)) #查询云盘的api
print(resp)
resp=eval（str(resp))['volumes']
volume_list=[]
for i in resp:
volume_list.append([i['volume_id'],i['instance_id']]) #
return volume_list #返回嵌套列表 [['volume_id'],['instance_id']]
except Exception as err:
# return 0
return err
def attach_volume(self,instance_id='',volume_id=''):
'''
return 0 ==插入云盘失败
给实例插入数据盘的函数(封装了插入数据盘的api)
'''
try:
api_instance=self.start()
reap=api_instance.attach_volume(volcenginesdkstorageebs.AttachVolumeRequest(instance_id=instance_id,volume_id=volume_id))
print(f'{instance_id} 插入 {volume_id} 成功')
except Exception as err:
print(err)
print(f'{instance_id} 插入 {volume_id} 失败')
return 0
def detach_volume(self,volume_id,instance_id):
'''
return 0 ==删除失败
从实例上卸载数据盘的函数(封装了卸载实例数据盘的api)
'''
try:
api_instance=self.start()
resp=api_instance.detach_volume(volcenginesdkstorageebs.DetachVolumeRequest(instance_id=instance_id,volume_id=volume_id))
print(f'{instance_id} {volume_id} 云盘卸载成功')
except Exception as err:
print(err)
return 0
def delete_volume(self,volume_id):
'''
return 0 ==删除云盘失败
删除数据盘的函数(封装了删除数据盘的api)
'''
try:
api_instance=self.start()
if type(volume_id)==list:
for i in volume_id:
resp=api_instance.delete_volume(volcenginesdkstorageebs.DeleteVolumeRequest(volume_id=i))
print(f'{i} 云盘删除成功')
else:
resp=api_instance.delete_volume(volcenginesdkstorageebs.DeleteVolumeRequest(volume_id=volume_id))
print(f'{volume_id} 云盘删除成功')
except:
return 0
class Vpc_API_all():
def __init__(self,region='cn-guilin-boe',ak="**********************",sk="**********************",host='volcengineapi-boe-stable.byted.org'):
self.region=region
self.ak=ak
self.sk=sk
self.host=host
if self.region=='cn-guilin-boe':
self.subnet_id='subnet-3rerjngm1c45c5zsk2hgcjb3v'
self.security_group_ids=['sg-2bzq6oxrg6kg02dx0eedwmc3m']
self.vpc_id='vpc-2bzq6orucueio2dx0ef84oc85'
self.zone_id='cn-guilin-c'
print(f'使用{self.region} 环境的虚机镜像和规格')
elif self.region=='cn-beijing':
self.subnet_id='subnet-mj8cl5u7gqgw5smt1a949cvc'
self.security_group_ids=['sg-rrokfkt1nq4gv0x57hpixo8']
self.vpc_id='vpc-rrokfevybk74v0x58w4ax5q'
self.zone_id='cn-beijing-b'
print(f'使用{self.region} 环境的虚机镜像和规格')
def start(self):
'''
返回实例化vpc_api对象
'''
configuration = volcenginesdkcore.Configuration() #实例化配置文件对象
configuration.ak = self.ak
configuration.sk = self.sk
configuration.region = self.region
configuration.host=self.host
api_instance = volcenginesdkvpc.VPCApi(volcenginesdkcore.ApiClient(configuration)) #实例化api对象供后续调用
return api_instance
def create_subnet(self,wangduan=None,subnet_name='DPU20_VM_TEST_yunhui_create'):
'''
创建vpc 下子网的函数(封装了指定vpc 子网的API)
'''
try:
vpc_id=self.vpc_id
zone_id=self.zone_id
api_instance=self.start()
resp=api_instance.create_subnet(volcenginesdkvpc.CreateSubnetRequest(cidr_block=wangduan,vpc_id=vpc_id,zone_id=zone_id,subnet_name=subnet_name)) #创建子网api
resp=eval（str(resp))
resp=resp['subnet_id']
return resp
except:
return 0
def create_network_interface(self,count=1,network_interface_name='yunhui_apt_createinterface'):
'''
创建子网下面创建网卡的函数(封装了指定创建网卡的API)
'''
subnet_id=self.subnet_id
security_group_ids=self.security_group_ids
if count==1:
try:
api_instance=self.start()
resp=api_instance.create_network_interface(volcenginesdkvpc.CreateNetworkInterfaceRequest(subnet_id=subnet_id,security_group_ids=security_group_ids,network_interface_name=network_interface_name))
resp=eval（str(resp))
resp=resp['network_interface_id']
return resp
except Exception as err:
print(err)
return
else:
interface_list=[]
for i in range(count):
try:
api_instance=self.start()
resp=api_instance.create_network_interface(volcenginesdkvpc.CreateNetworkInterfaceRequest(subnet_id=subnet_id,security_group_ids=security_group_ids,network_interface_name=network_interface_name))
print(resp)
resp=eval（str(resp))
resp=resp['network_interface_id']
print(resp)
interface_list.append(resp)
except Exception as err:
print(err)
return
def chaxun_wangka(self,status='Available',type='secondary',instance_id=None,network_interface_ids=None,page_size=100,page_number=1):
'''
查询子网下面创建网卡的函数(封装了查询网卡的API) network_interface_id 网卡id device_id 绑定实例id
网卡状态。
Creating 创建中
Available 未挂载
Attaching 挂载中
InUse 已挂载
Detaching 卸载中
Deleting 删除中
不传入默认查询所有状态的网卡
'''
vpc_id=self.vpc_id
subnet_id=self.subnet_id
try:
api_instance=self.start()
if network_interface_ids!=None:
print('对传入的网卡id进行查询')
resp=api_instance.describe_network_interfaces(volcenginesdkvpc.DescribeNetworkInterfacesRequest(type=type,network_interface_ids=network_interface_ids,page_size=page_size,vpc_id=vpc_id,subnet_id=subnet_id,page_number=page_number)) #查询网卡api
resp=eval（str(resp))['network_interface_sets'][0]['status']
return resp
elif status !='InUse':
resp=api_instance.describe_network_interfaces(volcenginesdkvpc.DescribeNetworkInterfacesRequest(status=status,type=type,instance_id=instance_id,network_interface_ids=network_interface_ids,page_size=page_size,vpc_id=vpc_id,subnet_id=subnet_id,page_number=page_number)) #查询网卡api
total_count=eval（str(resp))['total_count']
print(f'所有分页共有{total_count}个可用网卡')
resp=eval（str(resp))['network_interface_sets']
wangka_list=[]
for i in resp:
wangka_list.append(i['network_interface_id'])
# print(wangka_list)
print(f'第{page_number}个分页 查询到有 {len(wangka_list)}个可用网卡')
return wangka_list
else:
resp=api_instance.describe_network_interfaces(volcenginesdkvpc.DescribeNetworkInterfacesRequest(status=status,type=type,instance_id=instance_id,network_interface_ids=network_interface_ids,page_size=page_size,page_number=page_number)) #查询网卡api
#判断如果是查询单个实例上已经挂载的盘 返回列表
resp=eval（str(resp))['network_interface_sets']
wangka_list=[]
for i in resp:
wangka_list.append(i['network_interface_id'])
print(wangka_list)
return wangka_list
except:
return 0
def attach_wangka(self,instance_id=None,network_interface_id=None):
'''
调用AttachNetworkInterface 挂载单个辅助网卡到实例上
请确保待挂载的辅助网卡状态为Available
请确保待挂载的辅助网卡与被挂载的实例在同一可用区
'''
try:
api_instance=self.start()
resp=api_instance.attach_network_interface(volcenginesdkvpc.AttachNetworkInterfaceRequest(instance_id=instance_id,network_interface_id=network_interface_id))
print(f'{instance_id} 插入 {network_interface_id}网卡 成功')
return 1
except Exception as err:
print(f'{instance_id} 插入 {network_interface_id}网卡 失败')
print(err)
return 0
def detach_wangka(self,instance_id=None,network_interface_id=None):
'''
调用DetachNetworkInterface,从指定的实例上卸载辅助网卡
'''
try:
api_instance=self.start()
resp=api_instance.detach_network_interface(volcenginesdkvpc.DetachNetworkInterfaceRequest(instance_id=instance_id,network_interface_id=network_interface_id))
print(f'{instance_id} 卸载 {network_interface_id}网卡 成功')
return 1
except:
print(f'{instance_id} 卸载 {network_interface_id}网卡 失败')
return 0
class ECS_API_all():
def __init__(self,region='cn-guilin-boe',ak="**********************",sk="**********************",host='volcengineapi-boe-stable.byted.org'):
self.region=region #使用环境
self.ak=ak
self.sk=sk
self.host=host
if self.region=='cn-guilin-boe':
self.images={
#spr icx genoa 虚机 使用相同的镜像
'Debian10':'image-ybzlq4f7lnia4oz5f8v9',
'Debian9':'image-yccq4364w1cqkwd3kwpu',
'Ubuntu22.04':'image-yc6gg8pdc9cqkwkw1voq',
'Ubuntu20.04':'image-yc6gg6pq02cqkwi64eah',
'Ubuntu18.04':'image-yc6gg3mqiocqkxf8lmbx',
'CentOS7.9':'image-ybvz29lxzcia4ox5h0m9',
'CentOS8.3':'image-ybn89k3tsqkdvbipetx3',
'CentOS7.6':'image-ybn80jjtu2kdvbwflw7r',
'windows':'image-ycb3dcv1n3cqkvxm3lwt',
'CentOS_Stream9':'image-ycbq21bie6cqkweowrfr',
'CentOS_Stream8':'image-ycbq23fdfbcqkx7dq5l0'
}
self.guige={
'2c':'ecs.g3i.large',
'4c':'ecs.g3i.xlarge',
'8c':'ecs.g3i.2xlarge',
'16c':'ecs.g3i.4xlarge',
'32c':'ecs.g3i.8xlarge',
'48c':'ecs.g3i.12xlarge',
'64c':'ecs.g3i.16xlarge',
'96c':'ecs.g3i.24xlarge',
'192c':'ecs.g3i.48xlarge'
}
self.subnet_id='subnet-13fhfg7g8k7403n6nu5n7zdzw'
self.security_group_ids=['sg-2bzq6oxrg6kg02dx0eedwmc3m']
self.zone_id='cn-guilin-c'
print(f'使用{self.region} 环境的虚机镜像和规格')
elif self.region=='cn-beijing':
# 线上虚机规格和镜像
self.images={
#spr icx genoa 虚机 和 ecs.r3i.48xlarge 使用相同的镜像
'Debian10':'image-ybohkhduatebgzcjbtgd',
'Debian9':'image-ycaijqfbm03xaxgv6do1',
'Ubuntu22.04':'image-yc0efhx6jv4qwlql1jmt',
'Ubuntu20.04':'image-aagd56zrx2jtdryj5p63',
'Ubuntu18.04':'image-aagd56zrwqjtdrn56wlu',
'CentOS7.9':'image-aagd56zrw2jtdro3bnrl',
'CentOS8.3':'image-aagd56zrwejtdrj77qz8',
'CentOS7.6':'image-aagd56zrv2jtdr8yavg3',
'CentOS_Stream8':'image-yc0ef6v8ahc8mklivea3',
'CentOS_Stream9':'image-yc0efeiy0p4qwm0h6uhp',
#Genoa ecs.ebmpoc2.test 规格裸机 和spr 裸机 ecs.ebmpoc1.test 规格 和 icx 裸机 ecs.ebmg2i.cw.32xlarge ecs.ebmr3id.48xlarge 使用相同镜像
'Debian10_Genoa':'image-ybohjvdkdxebgze9la41',
'Debian9_Genoa':'image-ycakpv2w3ic8mkxiiqir',
'CentOS_Stream9_Genoa':'image-yc0gb491cwfu0590gvtn',
'CentOS_Stream8_Genoa':'image-yc0gb29du0fu051jwpax',
'CentOS8.3_Genoa':'image-ebgyrvn6ucf7qmhzg8bo',
'CentOS7.9_Genoa':'image-ybohjqgkelebgzc7m1xx',
'CentOS7.6_Genoa':'image-ybqi9l4zoz8rx7kgelt7',
'Ubuntu22.04_Genoa':'image-yc0gb8b5o9fu04zzjwrx',
'Ubuntu20.04_Genoa':'image-ybohjbqz63ebgzgtfwx7',
'Ubuntu18.04_Genoa':'image-ybohjkua5vebgzbw03aj',
}
# self.guige 字典定义了虚机的规格
self.guige={
#g3i 或者g2i
'2c':'ecs.g3i.cw.large',
'4c':'ecs.g3i.cw.xlarge',
'8c':'ecs.g3i.cw.2xlarge',
'16c':'ecs.g3i.cw.4xlarge',
'32c':'ecs.g3i.cw.8xlarge',
'48c':'ecs.g3i.cw.12xlarge',
'64c':'ecs.g3i.cw.16xlarge',
'96c':'ecs.g3i.cw.24xlarge',
'128c':'ecs.g2i.cw.32xlarge',
'192c':'ecs.g3i.cw.48xlarge',
'spr_luoji':'ecs.ebmpoc1.test',
'icx_luoji':'ecs.ebmg2i.cw.32xlarge',
#genoa 裸机
'genoa':'ecs.ebmpoc2.test',
#genoa 虚机
'2c_genoa':'ecs.g3a.cw.large',
'4c_genoa':'ecs.g3a.cw.xlarge',
'8c_genoa':'ecs.g3a.cw.2xlarge',
'16c_genoa':'ecs.g3a.cw.4xlarge',
'32c_genoa':'ecs.g3a.cw.8xlarge',
'48c_genoa':'ecs.g3a.cw.12xlarge',
'64c_genoa':'ecs.g3a.cw.16xlarge',
'96c_genoa':'ecs.g3a.cw.24xlarge',
'128c_genoa':'ecs.g3a.cw.32xlarge',
'192c_genoa':'ecs.g3a.cw.48xlarge',
'384c_genoa':'ecs.g3a.cw.96xlarge'
}
self.subnet_id='subnet-mj8cl5u7gqgw5smt1a949cvc'
self.security_group_ids=['sg-rrokfkt1nq4gv0x57hpixo8']
self.zone_id='cn-beijing-b'
print(f'使用{self.region} 环境的虚机镜像和规格')
def start(self):
'''
返回实例化api对象
'''
configuration = volcenginesdkcore.Configuration() #实例化配置文件对象
configuration.ak = self.ak
configuration.sk = self.sk
configuration.region = self.region
configuration.host=self.host
api_instance = volcenginesdkecs.ECSApi(volcenginesdkcore.ApiClient(configuration)) #实例化api对象供后续调用
return api_instance
def create_vm(self,count=1,image_id='',guige='',host_name='yunhui',password='root@123',volume_type="ESSD_FlexPL",volumes_num=0,host_id=None):
'''
创建虚机的函数(封装了创建虚机的api) 创建虚机之前会查询指定规格的虚资源是否可用，不可用直接退出并返回创建失败
'''
#count 创建数量
#image_id 镜像id
#guige 虚机规格
subnet_id=self.subnet_id
zone_id=self.zone_id
security_group_ids=self.security_group_ids
api_instance=self.start()
resp=api_instance.describe_available_resource(volcenginesdkecs.DescribeAvailableResourceRequest(destination_resource='InstanceType',zone_id=zone_id,instance_type_id=self.guige[guige])) #检查可用区剩余规格资源是否可用api
print(resp)
# resp=eval（str(resp))['available_zones'][0]['available_resources'][0]['supported_resources'][0]['status'] #取出可用资源状态字典中的值
# if resp in ['SoldOut']:
# print(f'{self.region} 没有创建{guige}虚机的资源')
# return 0
Volume_count=[volcenginesdkecs.VolumeForRunInstancesInput(volume_type="ESSD_PL0",size=40,)]
#数据盘默认20G
if volumes_num !=0:
for i in range(1,volumes_num):
Volume_count.append(volcenginesdkecs.VolumeForRunInstancesInput(volume_type="ESSD_PL0",size=20,))
resp=api_instance.run_instances(
volcenginesdkecs.RunInstancesRequest(
count=count,
zone_id=zone_id, #集群名称
image_id=self.images[image_id], #虚机镜像
instance_type=self.guige[guige], #虚机规格
instance_name=host_name, #虚机名称
password=password,
volumes=Volume_count,
network_interfaces=[volcenginesdkecs.NetworkInterfaceForRunInstancesInput(
subnet_id=subnet_id,
security_group_ids=security_group_ids,
)],
instance_charge_type='PostPaid',
host_id=host_id
))
print(resp)
resp=eval（str(resp)) #字符串转化为字典
fasong(resp['instance_ids'],'创建虚机')
return resp['instance_ids'] #返回创建的虚机id
def close_vm(self,instance_ids='',force_stop=False):
'''
return 0 ==失败
return 1 == 成功
关闭虚机的函数(封装了关闭一个或多个虚机的api) 通过该函数的返回值是否为0来判断是否执行了关机动作
'''
#如果传入的是字符串
api_instance=self.start()
if type(instance_ids)==str:
instance_ids=[instance_ids]
#判断那些机器可以关机，哪些不可以关机
resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=instance_ids)) #获取DescribeInstancesRequest 获取实例详细信息的api
resp=eval（str(resp))
if resp['instances'][0]['status'] not in ['RUNNING']:
print(f'{instance_ids[0]} 该虚机已经关机或者处于其他状态，不能关机')
return 0
else:
errer_list=[]
success_list=[]
for i in instance_ids:
try:
resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=[i])) #获取DescribeInstancesRequest 获取实例详细信息的api
resp=eval（str(resp))
if resp['instances'][0]['status'] not in ['RUNNING']:
print(f'{i} 该虚机已经关机或者处于其他状态，不能关机')
errer_list.append(i)
else:
success_list.append(i) #可以关机的id 列表
except:
print(f'实例{i} 无法查询信息')
return
instance_ids=success_list
if errer_list !=[]:
return 0 #如果有机器不能关机直接报错退出
resp=api_instance.stop_instances(volcenginesdkecs.StopInstancesRequest(force_stop=force_stop,instance_ids=instance_ids)) #stop_instances 关闭一个或者多个实例api
print(resp)
return 1
# while True:
# a=0
# resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=[instance_id])) #获取DescribeInstancesRequest 获取实例详细信息的api
# print(resp)
# resp=eval（str(resp)) #字符串转化为字典
# if resp['instances'][0]['status']=='STOPPED':
# prerint('调用关机成功')
# break
# elif a==12:
# print('2分钟没有关机成功,程序退出,请后续重点关注')
# break
# else:
# print('继续关机')
# a=a+1
# time.sleep(10)
def chongzhuang_vm(self,instance_ids,image_id=''):
'''
return 0 == 失败
重装一台或者多台虚机的函数(封装了重装系统的api)
实例的状态，取值：
MIGRATING 迁移中
CREATING 创建中
RUNNING 运行中
STOPPING 停止中
STOPPED 已停止
REBOOTING 重启中
STARTING 启动中
REBUILDING 重装中
RESIZING 更配中
ERROR 错误
'''
#如果传入的是字符串
api_instance=self.start()
if type(instance_ids)==str:
instance_ids=[instance_ids]
# print(instance_ids,type(instance_ids))
#判断那些机器重装，哪些不可以重装
resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=instance_ids)) #获取DescribeInstancesRequest 获取实例详细信息的api
# print(resp)
resp=eval（str(resp))
if resp['instances'][0]['status'] not in ['STOPPED']:
print(f'{instance_ids[0]} 该虚机没有关机 不能重装系统')
return 0
else:
resp=api_instance.replace_system_volume(volcenginesdkecs.ReplaceSystemVolumeRequest(instance_id=instance_ids[0],image_id=self.images[image_id],password='root@123')) #ReplaceSystemVolumeRequest 给示例重装系统api
print(resp)
return 1
else:
errer_list=[]
success_list=[]
for i in instance_ids:
resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=[i])) #获取DescribeInstancesRequest 获取实例详细信息的api
resp=eval（str(resp))
if resp['instances'][0]['status'] not in ['STOPPED']:
print(f'{i} 该虚机没有关机 不能重装系统')
errer_list.append(i)
else:
success_list.append(i)
instance_ids=success_list
if errer_list !=[]:
return 0 #如果有机器处于不能关机状态直接报错退出
for i in instance_ids:
resp=api_instance.replace_system_volume(volcenginesdkecs.ReplaceSystemVolumeRequest(instance_id=i,image_id=self.images[image_id],password='root@123')) #ReplaceSystemVolumeRequest 给示例重装系统api
print(resp)
return 1
def delete_vm(self,instance_ids=''):
'''
return 0 ==失败
删除一台或者多台虚机的函数(封装了删除虚机的api)
'''
api_instance=self.start()
if type(instance_ids)==str:
instance_ids=[instance_ids]
resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=instance_ids)) #获取DescribeInstancesRequest 获取实例详细信息的api
resp=eval（str(resp))
if resp['instances'][0]['status'] not in ['STOPPED','RUNNING']:
print(f'{instance_ids[0]} 该虚机不在可以删除的状态')
return 0
else:
resp=api_instance.delete_instances(volcenginesdkecs.DeleteInstancesRequest(instance_ids=instance_ids)) #DeleteInstancesRequest 删除一台或者多台虚机API
return 1
else:
errer_list=[]
success_list=[]
for i in instance_ids:
resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=[i])) #获取DescribeInstancesRequest 获取实例详细信息的api
resp=eval（str(resp))
if resp['instances'][0]['status'] not in ['STOPPED','RUNNING']:
print(f'{i} 该虚机不在可以删除的状态')
errer_list.append(i)
else:
success_list.append(i)
instance_ids=success_list
if errer_list !=[]:
return 0 #如果有机器处于不能删除状态直接报错退出
resp=api_instance.delete_instances(volcenginesdkecs.DeleteInstancesRequest(instance_ids=instance_ids))
return 1
def restart_vm(self,instance_ids,force_stop=False):
'''
return 0 ==失败
重启一台或者多台虚机的函数(封装了重启虚机的api)
注意虚机关机之后不能重启
'''
api_instance=self.start()
if type(instance_ids)==str:
instance_ids=[instance_ids]
resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=instance_ids)) #获取DescribeInstancesRequest 获取实例详细信息的api
resp=eval（str(resp))
if resp['instances'][0]['status'] not in ['RUNNING']:
print(f'{instance_ids[0]} 该虚机不在可以重启的状态')
return 0
else:
resp=api_instance.reboot_instances(volcenginesdkecs.RebootInstancesRequest(instance_ids=instance_ids,force_stop=force_stop)) #RebootInstancesRequest 重启实例api
return 1
else:
errer_list=[]
success_list=[]
for i in instance_ids:
resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=[i])) #获取DescribeInstancesRequest 获取实例详细信息的api
resp=eval（str(resp))
if resp['instances'][0]['status'] not in ['RUNNING']:
print(f'{i} 该虚机不在可以重启的状态')
errer_list.append(i)
else:
success_list.append(i)
instance_ids=success_list
print(instance_ids)
if errer_list !=[]:
return 0 #如果有机器不能关机直接报错退出
resp=api_instance.reboot_instances(volcenginesdkecs.RebootInstancesRequest(instance_ids=instance_ids,force_stop=force_stop)) #RebootInstancesRequest 重启实例api
print('全部重启')
return 1
def start_vm(self,instance_ids):
'''
return 0 ==失败
重启一台或者多台虚机的函数(封装了重启虚机的api)
'''
api_instance=self.start()
if type(instance_ids)==str:
instance_ids=[instance_ids]
resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=instance_ids)) #获取DescribeInstancesRequest 获取实例详细信息的api
resp=eval（str(resp))
if resp['instances'][0]['status'] not in ['STOPPED']:
print(f'{instance_ids[0]} 该虚机不在可以重启的状态')
return 0
else:
resp=api_instance.start_instances(volcenginesdkecs.StartInstancesRequest(instance_ids=instance_ids)) #StartInstancesRequest 启动实例api
return 1
else:
errer_list=[]
success_list=[]
for i in instance_ids:
resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=[i])) #获取DescribeInstancesRequest 获取实例详细信息的api
resp=eval（str(resp))
if resp['instances'][0]['status'] not in ['STOPPED']:
print(f'{i} 该虚机不在可以启动的状态')
errer_list.append(i)
else:
success_list.append(i)
instance_ids=success_list
print(instance_ids)
if errer_list !=[]:
return 0 #如果有机器不能关机直接报错退出
resp=api_instance.start_instances(volcenginesdkecs.StartInstancesRequest(instance_ids=instance_ids)) #StartInstancesRequest 启动实例api #RebootInstancesRequest 重启实例api
print('全部启动')
return 1
def chaxun_vm(self,instance_ids,canshu='status'):
'''
return 0 ==失败
查询一台或者多台虚机的函数(封装了查询虚机的api) 该函数目前主要返回虚机的运行状态
'''
api_instance=self.start()
resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=[instance_ids])) #获取DescribeInstancesRequest 获取实例详细信息的api
# print(resp)
resp=eval（str(resp))
resp=resp['instances'][0][canshu]
return resp
def chaxun_vm_sql(self,instance_ids):
'''
sql 查询专用
return 0 ==失败
查询一台或者多台虚机的函数(封装了查询虚机的api) 该函数目前主要返回虚机的运行状态
'''
api_instance=self.start()
resp =api_instance.describe_instances(volcenginesdkecs.DescribeInstancesRequest(instance_ids=[instance_ids])) #获取DescribeInstancesRequest 获取实例详细信息的api
# print(resp)
resp=eval（str(resp))
# resp=resp['instances'][0][canshu]
return resp本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。
