def _create_cvm(nums):
client = _get_cvm_client()
if nums <= 0:
raise Exception("Fail to create cvm[%d]" % nums)
if not IMAGE_ID:
raise Exception("Empty Image ID")
iter = nums / ITEM_UNIT
left = nums % ITEM_UNIT
count = 0
while (count <= iter):
req = models.RunInstancesRequest()
req.ImageId = IMAGE_ID
req.InstanceChargeType = "POSTPAID_BY_HOUR"
req.InstanceType = INSTANCE_TYPE
req.SystemDisk = {"DiskType": SYS_DISK_TYPE, "DiskSize": 50}
req.VirtualPrivateCloud = {"VpcId": "DEFAULT", "SubnetId": "DEFAULT"}
req.InstanceCount = ITEM_UNIT if count < iter else left
resp = client.RunInstances(req)
if not _succeed(resp):
logging.warning(resp.to_json_string())
count = count + 1
time.sleep(0.1)
def createInstance(params):
req = models.RunInstancesRequest()
req.InstanceType = params["InstanceType"]
req.InstanceName = params["InstanceName"]
req.Placement = params["Placement"]
req.ImageId = params["ImageId"]
req.InstanceChargeType = params["InstanceChargeType"]
if "VirtualPrivateCloud" in params:
req.VirtualPrivateCloud = params["VirtualPrivateCloud"]
if "SecurityGroupIds" in params:
req.SecurityGroupIds = params["SecurityGroupIds"]
if "InternetAccessible" in params:
req.InternetAccessible = params["InternetAccessible"]
if "LoginSettings" in params:
req.LoginSettings = params["LoginSettings"]
resp = client.RunInstances(req)
return resp
def create_cvm(vpc_id,subnet_id,sg_id,key_id):
'''
:param vpc_id:
:param subnet_id:
:param sg_id:
:param key_id:
:return:
'''
try:
InstanceChargeType = params["cvm_info"]["InstanceChargeType"]
Placement = params["cvm_info"]["Placement"]
InstanceType = params["cvm_info"]["InstanceType"]
ImageId = params["cvm_info"]["ImageId"]
SystemDisk = params["cvm_info"]["SystemDisk"]
DataDisks = params["cvm_info"]["DataDisks.N"]
InternetAccessible = params["cvm_info"]["InternetAccessible"]
InstanceCount = params["cvm_info"]["InstanceCount"]
InstanceName = params["cvm_info"]["InstanceName"]
HostName = params["cvm_info"]["HostName"]
VirtualPrivateCloud = {"VpcId": vpc_id,"SubnetId": subnet_id}
SecurityGroupId = [sg_id]
LoginId = [key_id]
temp = {"InstanceChargeType": InstanceChargeType, "Placement": Placement, "InstanceType": InstanceType,
"ImageId": ImageId, "SystemDisk": SystemDisk, "DataDisks": DataDisks, "VirtualPrivateCloud":VirtualPrivateCloud,
"InternetAccessible": InternetAccessible, "InstanceCount": InstanceCount, "InstanceName": InstanceName,
"SecurityGroupIds":SecurityGroupId, "LoginSettings": {"KeyIds": LoginId}, "HostName": HostName}
cvm_params = json.dumps(temp)
req = cvm_models.RunInstancesRequest()
req.from_json_string(cvm_params)
resp = cvm_client.RunInstances(req)
cvm_id = json.loads(resp.to_json_string())["InstanceIdSet"]
#cvm_ip = json.loads(resp.to_json_string())["InstanceSet"][0]["PublicIpAddresses"][0]
return cvm_id
except TencentCloudSDKException as err:
print (err)
exit(1)
def buy(secu_id, secu_key, region, pay_type, zone, instype, imageid, disksize,
width):
try:
cred = credential.Credential(secu_id, secu_key)
httpProfile = HttpProfile()
httpProfile.endpoint = "cvm.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = cvm_client.CvmClient(cred, region, clientProfile)
req = models.RunInstancesRequest()
params = '{"InstanceChargeType":"%s","Placement":{"Zone":"%s"},' \
'"InstanceType":"%s","ImageId":"%s","SystemDisk":{"DiskSize":%d},' \
'"InternetAccessible":{"InternetMaxBandwidthOut":%d,"PublicIpAssigned":true}}' \
% (pay_type, zone, instype, imageid, int(disksize), int(width))
req.from_json_string(params)
resp = client.RunInstances(req)
# print(resp.to_json_string())
return "购买成功，等待实例创建开启"
except TencentCloudSDKException as err:
print(err)
def run_instances_request(self, args):
client = cvm_client.CvmClient(self.credential, args['region'], self.profile(self.SERVICE_NAME))
req = models.RunInstancesRequest()
params ={"InstanceChargeType": "PREPAID",
"InstanceChargePrepaid": {
"Period": int(args['Period']),
"RenewFlag": "NOTIFY_AND_MANUAL_RENEW"
},
"Placement": {
"Zone": args['zone']
},
"InstanceType": args['InstanceType'],
"ImageId": args['ImageId'],
"InstanceCount": 1,
"SystemDisk": {
"DiskType": args['DiskType'],
"DiskSize": int(args['DiskSize'])
},
"HostName": args['HostName'],
"VirtualPrivateCloud": {
"VpcId": args['vpc'],
"SubnetId": args['subnet']
},
"InternetAccessible": {
"InternetChargeType": args['InternetChargeType'],
"InternetMaxBandwidthOut": int(args['InternetMaxBandwidthOut']),
"PublicIpAssigned": args['PublicIpAssigned']
},
"LoginSettings": {
"Password": args['Password']
},
"SecurityGroupIds": [args['SecurityGroupIds']]
}
req.from_json_string(json.dumps(params))
resp = client.RunInstances(req)
return json.loads(resp.to_json_string())
def cret_cvm(self, cvm_info_dict, **kwargs):
"""
创建INSTANCE_FOR_GOTOTECENT
{
Zone:'',
InstanceType:'',
ImageId:'',
DataDisksSize:'',
VpcId:'',
SubnetId:'',
SecurityGroupId:'',
InstanceName
InstanceName:'',
}
"""
# 创建request
cret_req = cvm_models.RunInstancesRequest()
# 通过列表数组获取实例类型
cret_req.InstanceType = cvm_info_dict.get('InstanceType')
# 定义创建的cvm创建的地域
cret_req.Placement = {
'Zone': cvm_info_dict.get('Zone'),
}
# 定义cvm付费类型，按量后付费：POSTPAID_BY_HOUR 预付费：PREPAID
cret_req.InstanceChargeType = 'POSTPAID_BY_HOUR'
# 如果外部传入imageid，则使用传入的imageid
cret_req.ImageId = kwargs.get('ImageId') if kwargs.get(
'ImageId') else cvm_info_dict.get('ImageId')
# 定义系统盘类型及大小
if kwargs.get('DiskSize'):
cret_req.SystemDisk = {
"DiskType": 'CLOUD_PREMIUM',
"DiskSize": kwargs.get('DiskSize'),
}
else:
cret_req.SystemDisk = {
"DiskType": 'CLOUD_PREMIUM',
"DiskSize": '50',
}
# 定义数据盘的类型和，数据盘的大小
cret_req.DataDisks = [{
'DiskType': 'CLOUD_PREMIUM',
'DiskSize': cvm_info_dict.get('DataDisksSize')
}]
# 定义指定vpc属性
cret_req.VirtualPrivateCloud = {
"VpcId": cvm_info_dict.get('VpcId'),
"SubnetId": cvm_info_dict.get('SubnetId'),
"AsVpcGateway": 'FALSE',
}
# 读取cvm_info.md文件，定义安全组
cret_req.SecurityGroupIds = [cvm_info_dict.get('SecurityGroupId')]
cret_req.InstanceName = kwargs.get('InstanceName') if kwargs.get(
'InstanceName') else 'go2tencent_tran_' + self.random_char
# 读取cvm_info.md文件，定义主机名称
cret_req.HostName = kwargs.get('HostName') if kwargs.get(
'HostName') else 'go2tencent-tran' + self.random_char
# 公网带宽相关选项
cret_req.InternetAccessible = {
# 网络计费类型
# BANDWIDTH_PREPAID：预付费按带宽结算
# TRAFFIC_POSTPAID_BY_HOUR：流量按小时后付费
# BANDWIDTH_POSTPAID_BY_HOUR：带宽按小时后付费
# BANDWIDTH_PACKAGE：带宽包用户
'InternetChargeType': 'TRAFFIC_POSTPAID_BY_HOUR',
# 公网出带宽上限，单位：Mbps,默认为0
'InternetMaxBandwidthOut': '5',
# 'InternetMaxBandwidthOut': instance_list[14],
# 是否分配公网IP
# 当公网带宽大于0Mbps时，可自由选择开通与否，默认开通公网IP；当公网带宽为0，则不允许分配公网IP。
'PublicIpAssigned': 'TRUE'
}
# 登陆设置
if kwargs.get('Password'):
cret_req.LoginSettings = {
'Password': kwargs.get('Password'),
}
else:
cret_req.LoginSettings = {
# 'Password': '******',
'KeyIds': [cvm_info_dict.get('KeyId')]
# 表示保持镜像的登录设置，不支持公有镜像
# 'KeepImageLogin':'******'
}
# 启用安全加固急监控
cret_req.EnhancedService = {
'SecurityService': {
"Enabled": "TRUE"
},
'MonitorService': {
"Enabled": "TRUE"
},
}
# 标签
cret_req.TagSpecification = [{
"ResourceType":
"instance",
"Tags": [{
"Key": "go2tencent_key",
"Value": 'go2tencent_values'
}]
}]
# 指定开机后执行DNS修改172.18.80.13/14，Base64编码格式，如需要修改，参照Readme中说明
# create_req.UserData = "IyEvYmluL2Jhc2gKCiMgMjAxOC0xMC0xNgoKY2F0IDw8IEVPRiA+IC9ldGMvcmVzb2x2LmNvbmYKbmFtZXNlcnZlciAxNzIuMTguODAuMTMgCm5hbWVzZXJ2ZXIgMTcyLjE4LjgwLjE0CkVPRgo="
# 创建的cvm数量
cret_req.InstanceCount = 1
# 置放群组id
# create_req.DisasterRecoverGroupIds = [CvmOper.DisasterRecoverGroupIds_Dict[instance_list[9]]]
try:
response = self.cvm_helper.RunInstances(cret_req)
result_content = response.to_json_string()
return json.loads(result_content)
except TencentCloudSDKException as err:
print(err)
def create(vm_):
"""
Create a single Tencent Cloud instance from a data dict.
Tencent Cloud profiles require a ``provider``, ``availability_zone``, ``image`` and ``size``.
Set up profile at ``/etc/salt/cloud.profiles`` or ``/etc/salt/cloud.profiles.d/*.conf``:
.. code-block:: yaml
tencentcloud-guangzhou-s1sm1:
provider: my-tencentcloud-config
availability_zone: ap-guangzhou-3
image: img-31tjrtph
size: S1.SMALL1
allocate_public_ip: True
internet_max_bandwidth_out: 1
password: '******'
securitygroups:
- sg-5e90804b
CLI Examples:
.. code-block:: bash
salt-cloud -p tencentcloud-guangzhou-s1 myinstance
"""
try:
# Check for required profile parameters before sending any API calls.
if (
vm_["profile"]
and config.is_profile_configured(
__opts__,
__active_provider_name__ or "tencentcloud",
vm_["profile"],
vm_=vm_,
)
is False
):
return False
except AttributeError:
pass
__utils__["cloud.fire_event"](
"event",
"starting create",
"salt/cloud/{}/creating".format(vm_["name"]),
args=__utils__["cloud.filter_event"](
"creating", vm_, ["name", "profile", "provider", "driver"]
),
sock_dir=__opts__["sock_dir"],
transport=__opts__["transport"],
)
log.debug("Try creating instance: %s", pprint.pformat(vm_))
# Init cvm client
client = get_provider_client("cvm_client")
req = cvm_models.RunInstancesRequest()
req.InstanceName = vm_["name"]
# Required parameters
req.InstanceType = __get_size(vm_)
req.ImageId = __get_image(vm_)
zone = __get_availability_zone(vm_)
projectId = vm_.get("project_id", 0)
req.Placement = {"Zone": zone, "ProjectId": projectId}
# Optional parameters
req.SecurityGroupIds = __get_securitygroups(vm_)
req.HostName = vm_.get("hostname", vm_["name"])
req.InstanceChargeType = vm_.get("instance_charge_type", "POSTPAID_BY_HOUR")
if req.InstanceChargeType == "PREPAID":
period = vm_.get("instance_charge_type_prepaid_period", 1)
renewFlag = vm_.get(
"instance_charge_type_prepaid_renew_flag", "NOTIFY_AND_MANUAL_RENEW"
)
req.InstanceChargePrepaid = {"Period": period, "RenewFlag": renewFlag}
allocate_public_ip = vm_.get("allocate_public_ip", False)
internet_max_bandwidth_out = vm_.get("internet_max_bandwidth_out", 0)
if allocate_public_ip and internet_max_bandwidth_out > 0:
req.InternetAccessible = {
"PublicIpAssigned": allocate_public_ip,
"InternetMaxBandwidthOut": internet_max_bandwidth_out,
}
internet_charge_type = vm_.get("internet_charge_type", "")
if internet_charge_type != "":
req.InternetAccessible["InternetChargeType"] = internet_charge_type
req.LoginSettings = {}
req.VirtualPrivateCloud = {}
req.SystemDisk = {}
keyId = vm_.get("key_name", "")
if keyId:
req.LoginSettings["KeyIds"] = [keyId]
password = vm_.get("password", "")
if password:
req.LoginSettings["Password"] = password
private_ip = vm_.get("private_ip", "")
if private_ip:
req.VirtualPrivateCloud["PrivateIpAddresses"] = private_ip
vpc_id = vm_.get("vpc_id", "")
if vpc_id:
req.VirtualPrivateCloud["VpcId"] = vpc_id
subnetId = vm_.get("subnet_id", "")
if subnetId:
req.VirtualPrivateCloud["SubnetId"] = subnetId
system_disk_size = vm_.get("system_disk_size", 0)
if system_disk_size:
req.SystemDisk["DiskSize"] = system_disk_size
system_disk_type = vm_.get("system_disk_type", "")
if system_disk_type:
req.SystemDisk["DiskType"] = system_disk_type
__utils__["cloud.fire_event"](
"event",
"requesting instance",
"salt/cloud/{}/requesting".format(vm_["name"]),
args=__utils__["cloud.filter_event"]("requesting", vm_, list(vm_)),
sock_dir=__opts__["sock_dir"],
transport=__opts__["transport"],
)
try:
resp = client.RunInstances(req)
if not resp.InstanceIdSet:
raise SaltCloudSystemExit("Unexpected error, no instance created")
except Exception as exc: # pylint: disable=broad-except
log.error(
"Error creating %s on tencentcloud\n\n"
"The following exception was thrown when trying to "
"run the initial deployment: %s",
vm_["name"],
str(exc),
# Show the traceback if the debug logging level is enabled
exc_info_on_loglevel=logging.DEBUG,
)
return False
time.sleep(5)
def __query_node_data(vm_name):
data = show_instance(vm_name, call="action")
if not data:
return False
if data["InstanceState"] != "RUNNING":
return False
if data["PrivateIpAddresses"]:
return data
try:
data = salt.utils.cloud.wait_for_ip(
__query_node_data,
update_args=(vm_["name"],),
timeout=config.get_cloud_config_value(
"wait_for_ip_timeout", vm_, __opts__, default=10 * 60
),
interval=config.get_cloud_config_value(
"wait_for_ip_interval", vm_, __opts__, default=10
),
)
except (SaltCloudExecutionTimeout, SaltCloudExecutionFailure) as exc:
try:
destroy(vm_["name"])
except SaltCloudSystemExit:
pass
finally:
raise SaltCloudSystemExit(str(exc))
if data["PublicIpAddresses"]:
ssh_ip = data["PublicIpAddresses"][0]
elif data["PrivateIpAddresses"]:
ssh_ip = data["PrivateIpAddresses"][0]
else:
log.error("No available ip: cant connect to salt")
return False
log.debug("Instance %s: %s is now running", vm_["name"], ssh_ip)
vm_["ssh_host"] = ssh_ip
# The instance is booted and accessible, let's Salt it!
ret = __utils__["cloud.bootstrap"](vm_, __opts__)
ret.update(data)
log.debug("'%s' instance creation details:\n%s", vm_["name"], pprint.pformat(data))
__utils__["cloud.fire_event"](
"event",
"created instance",
"salt/cloud/{}/created".format(vm_["name"]),
args=__utils__["cloud.filter_event"](
"created", vm_, ["name", "profile", "provider", "driver"]
),
sock_dir=__opts__["sock_dir"],
transport=__opts__["transport"],
)
return ret
try:
# 实例化一个认证对象，入参需要传入腾讯云账户secretId，secretKey
cred = credential.Credential("AKIDylMjqkOq7Azay9Nq8D5kCSVM1Sfft4Sd",
"K8lBONAk7IEzXt30kGXcS5UfbJm0zkG4")
httpProfile = HttpProfile()
httpProfile.endpoint = "cvm.api3.test.403a.tcecqpoc.fsphere.cn"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
# 实例化要请求产品(以cvm为例)的client对象，clientProfile是可选的。
client = cvm_client.CvmClient(cred, "shanghai", clientProfile)
# 实例化一个cvm实例信息查询请求对象,每个接口都会对应一个request对象。
req = models.RunInstancesRequest()
# 这里还支持以标准json格式的string来赋值请求参数的方式。下面的代码跟上面的参数赋值是等效的。
params = '{"Placement.Zone":["ap-guangzhou-2"],"ImageId":["img-pmqg1cw7"]}'
#
req.from_json_string(params)
# 通过client对象调用DescribeInstances方法发起请求。注意请求方法名与请求对象是对应的。
# 返回的resp是一个DescribeInstancesResponse类的实例，与请求对象对应。
resp = client.RunInstances(req)
# 输出json格式的字符串回包
print(resp.to_json_string())
# 也可以取出单个值。
# 你可以通过官网接口文档或跳转到response对象的定义处查看返回字段的定义。
