修改脚本功能：
1.原逻辑为人为录入ecs_price表中实例价格信息，修改为从云厂商接口获取
CREATE TABLE `ecs_price` (
`company` varchar(8) NOT NULL COMMENT '云服务商',
`instance_type` varchar(20) NOT NULL COMMENT '机型',
`instances_price` varchar(8) NOT NULL COMMENT '每月价格',
PRIMARY KEY (`instance_type`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;
2.磁盘价格计算的逻辑不变
3.最终费用仍为实例价格+磁盘价格，只不过实例价格由ecs_price_base表，换为ecs_price表
main.py
--------
#_*_coding:utf-8_*_
from cloud import alicloud
from cloud import tencent
from cloud import huawei
import json
import sys
import MySQLdb as pymysql
import datetime
import time
from decimal import Decimal
if sys.version_info.major == 3:
import urllib.request as urllib2
from functools import reduce
else:
import urllib2
reload(sys)
sys.setdefaultencoding('utf-8')
remove_dist = [-200, 11, 12, 35, 1, -100, 258, 259, 368, 20004, 440, 444, 10000]
db_config = {
"charset": "utf8",
"db": "game_server_price",
"host": "10.14.101.113",
"passwd": "NGIxMjhhOG",
"port": 30001,
"user": "grafana",
}
center_db_config = {
"charset": "utf8",
"db": "dw_game_wd",
"host": "10.14.50.2",
"passwd": "",
"port": 3306,
"user": "ops_read",
}
def mysql_conn(sql, values_list=[], **config):
try:
conn = pymysql.connect(**config)
cursor = conn.cursor()
if values_list:
cursor.executemany(sql, values_list)
else:
cursor.execute(sql)
conn.commit()
except Exception as e:
print(e)
print(sql)
sys.exit(e)
conn.close()
return cursor.fetchall()
def get_online_number():
# 查询当月每日最大人数求平均值，去除最大值小于100的项，当新服未开放时无法查询出新服，后续使用try处理
# 去除最大值小于100项目用于解决问题：新服开放当月平均值会被开服前的0平均掉
sql = "select" \
" dist,avg(cnt_max) from dw_game_wd.fact_online_day " \
"where" \
" DATE_FORMAT( log_date, '%Y%m' ) = DATE_FORMAT( CURRENT_DATE, '%Y%m' ) and cnt_max > 100 group by dist;"
result = mysql_conn(sql, **center_db_config)
online_info = {}
for dist in result:
online_info[dist[0]] = dist[1]
return online_info
def get_servers():
all_servers_list = []
all_disks_list = []
cloud_list = [huawei, alicloud, tencent]
for cloud in cloud_list:
instances = cloud()
result_cloud = instances.run_cloud()
server_list = result_cloud["instences"]
disk_list = result_cloud["disks"]
if not server_list:
continue
all_servers_list = all_servers_list + server_list
if not disk_list:
continue
all_disks_list = all_disks_list + disk_list
mysql_conn("delete from game_server_price.disk_info where date=CURRENT_DATE;", **db_config)
mysql_conn("delete from game_server_price.instances_info where date=CURRENT_DATE;", **db_config)
values_list = []
for instance in all_servers_list:
name = instance['name']
ip = instance['ip']
instance_type = instance['instance_type']
company = instance['company']
id = instance['id']
values_list.append([name, ip, instance_type, company, id])
sql = 'insert into game_server_price.instances_info value (%s,%s,%s,%s,%s,CURRENT_DATE)'
mysql_conn(sql, values_list, **db_config)
sql = 'insert into game_server_price.disk_info value (%s,%s,%s,%s,%s,0,CURRENT_DATE)'
mysql_conn(sql, all_disks_list, **db_config)
return all_servers_list
def get_ucenter_info(mainid=2):
ucurl = "http://creator-sre.gyyx.cn/app_ass_info?main_id=%s" % (mainid)
result_url = urllib2.urlopen(ucurl, timeout=30)
result_url_data = result_url.read()
alldata = json.loads(result_url_data)['data']
#alldata = json.loads(result_url_data)
dist_info_list = []
tmp_info = {}
for data in alldata:
if data['app_name'] in ['ldb_s', 'ldb', 'stat'] or int(data['dist_id']) in remove_dist:
continue
ip = data['ass_ip']
dist_id = data['dist_id']
name = data['ass_gysn']
if not name:
print(data)
app_name = data['app_name']
if app_name == "LB":continue
disk_size_setting = data['setting'].replace('G', '').replace(' ', '').split("+")[1:]
if disk_size_setting == []:
disk_size = 0
else:
disk_size = reduce(lambda x, y: x + y, map(int, disk_size_setting))
dist_info_list.append([dist_id, name, app_name, ip, disk_size])
tmp_info[data['ip']] = name
line_info_list = []
ucurl_line = 'http://creator-sre.gyyx.cn/gamelinelist?mainid=2'
result_url = urllib2.urlopen(ucurl_line, timeout=30)
result_url_data = result_url.read()
alldata = json.loads(result_url_data)['data']
#alldata = json.loads(result_url_data)
for dist in alldata:
if int(dist['dist_id']) in remove_dist or int(dist['dist_id']) > 10000:
continue
dist_id = int(dist['dist_id'])
name = tmp_info[dist['ip']]
line_num = len(dist['line_nums'].split(','))
line_info_list.append([dist_id, name, line_num])
mysql_conn("delete from game_server_price.gs_info where date=CURRENT_DATE;", **db_config)
gs_info_sql = 'insert into game_server_price.gs_info value (%s,%s,%s,current_date);'
mysql_conn(gs_info_sql, line_info_list, **db_config)
mysql_conn("delete from game_server_price.instances_center where date=CURRENT_DATE;", **db_config)
mysql_conn("truncate table game_server_price.dist_list;", **db_config)
sql = 'insert into game_server_price.instances_center value (%s,%s,%s,%s,%s,CURRENT_DATE)'
mysql_conn(sql, dist_info_list, **db_config)
sub_data_sql = 'select dist_id,sub_name from center_app.sub_category where main_id = 2 and flag in (1,0) and dist_id BETWEEN 2 and 25000 and del_info=1;'
result = mysql_conn(sub_data_sql, **center_db_config)
sub_data = list(result)
insert_sub_sql = 'insert into game_server_price.dist_list value (%s,%s)'
mysql_conn(insert_sub_sql, sub_data, **db_config)
return dist_info_list
def count_instance_price():
SQL_PRICES = '''
select
c.name
,sum(b.price_base*a.size) as disk_price
,d.instances_price
,(sum(b.price_base*a.size)+ d.instances_price) as total
,c.instance_type
,e.trade_discount
,((sum(b.price_base*a.size)+ d.instances_price)*e.trade_discount) as last_price
from
game_server_price.disk_info a
,game_server_price.disk_price_info b
,game_server_price.trade_discount_base e
,game_server_price.instances_info c
left join game_server_price.ecs_price_base d
on c.instance_type=d.instance_type
where
a.disk_type = b.disk_type
and a.company = b.company
and a.date=date_sub(CURDATE(),interval 1 day)
and c.date=date_sub(CURDATE(),interval 1 day)
and c.id=a.server_id
and a.company = e.company
group by a.server_id ;
'''
price_dict = {}
result = mysql_conn(SQL_PRICES, **db_config)
for i in result:
name = str(i[0]).strip()
price = str(i[6])
price_dict[name] = price
return price_dict
def count_all_dist_price():
sql = 'select a.name,a.app_name,b.company,b.instance_type,a.disk_size,a.dist_id ' \
'from instances_center a,instances_info b ' \
'where a.name=b.name and b.date=date_sub(CURDATE(),interval 1 day) ' \
'and a.date=date_sub(CURDATE(),interval 1 day);'
result = mysql_conn(sql, **db_config)
all_price_dict = count_instance_price()
all_instance_price = {}
instance_price_list = []
error_list = []
for instance in result:
name = str(instance[0])
price = all_price_dict[name]
if price == "None":
print("ERROR: %s price count failed!" % name)
error_list.append(name)
else:
price = Decimal(price)
if instance[1] == "adb_s":
price = price / 2
instance_price_list.append([instance[5], instance[0], price])
try:
all_instance_price[instance[5]][instance[0]] = price
except:
all_instance_price[instance[5]] = {}
all_instance_price[instance[5]][instance[0]] = price
if error_list:
print "Error list:", str(error_list)
sys.exit(1)
mysql_conn("delete from game_server_price.instances_price_history where date=date_sub(CURRENT_DATE,interval 1 day);", **db_config)
sql = 'insert into game_server_price.instances_price_history value (%s,%s,%s,date_sub(CURRENT_DATE,interval 1 day));'
print instance_price_list
mysql_conn(sql, instance_price_list, **db_config)
all_dist_price = {}
for dist in all_instance_price:
all_dist_price[dist] = []
price = 0
for instance in all_instance_price[dist]:
price = price + all_instance_price[dist][instance]
all_dist_price[dist].append(price)
return all_dist_price
def get_dist_idc():
SQL_IDC = '''
select
a.dist_id
,b.company
from
instances_center a
,instances_info b
where
a.app_name ='ccs'
and a.name=b.name
and a.date=b.date
and a.date=date_sub(CURDATE(),interval 1 day);
'''
idc_dict = {}
result = mysql_conn(SQL_IDC, **db_config)
for i in result:
dist_id = i[0]
idc = str(i[1])
idc_dict[dist_id] = idc
return idc_dict
def main():
get_servers()
get_ucenter_info()
count_all_dist_price()
date = (datetime.datetime.now() + datetime.timedelta(days=-1)).strftime("%Y-%m-%d")
all_dist_price = count_all_dist_price()
idc_dict = get_dist_idc()
online_info = get_online_number()
all_dist_price_per = []
for dist_id in all_dist_price:
price = Decimal(all_dist_price[dist_id][0])
if dist_id not in idc_dict:
continue
idc = idc_dict[dist_id]
try:
online_num = Decimal(online_info[dist_id])
except:
# 当新服部署后尚未开服时令人数为0
online_num = Decimal(0)
if int(online_num) == 0:
# 避免被除数为0
avg_price = price
else:
avg_price = Decimal(price / online_num).quantize(Decimal("0.000"))
all_dist_price_per.append([dist_id, online_num, price, avg_price,idc, date])
date = (datetime.datetime.now() + datetime.timedelta(days=-1)).strftime("%Y-%m-%d")
delete_sql = 'delete from game_server_price.asktao_dist_price where date = "%s";' % date
mysql_conn(delete_sql, **db_config)
sql = 'insert into game_server_price.asktao_dist_price value (%s,%s,%s,%s,%s,%s);'
mysql_conn(sql, all_dist_price_per, **db_config)
if __name__ == '__main__':
main()
----------------
from tencentcloud.common import credential
from tencentcloud.common.profile.client_profile import ClientProfile
from tencentcloud.common.profile.http_profile import HttpProfile
from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
from tencentcloud.cvm.v20170312 import cvm_client, models
from tencentcloud.cbs.v20170312 import cbs_client
from tencentcloud.cbs.v20170312 import models as cbsmodels
from aliyunsdkcore.client import AcsClient
from aliyunsdkecs.request.v20140526.DescribeInstancesRequest import DescribeInstancesRequest
from aliyunsdkecs.request.v20140526.DescribeDisksRequest import DescribeDisksRequest
from aliyunsdkcore.acs_exception.exceptions import ClientException
from aliyunsdkcore.acs_exception.exceptions import ServerException
from openstack import exceptions
from openstack import connection
import requests
import signer
import json
class cloud(object):
def __init__(self):
self.DISK_TYPE = {
"SAS": "premium",
"STAT": "basic",
"SSD": "ssd",
"CLOUD_BASIC": "basic",
"CLOUD_PREMIUM": "premium",
"CLOUD_SSD": "ssd"
}
def get_instances_from_api(self):
pass
def get_disk_from_api(self):
pass
def get_instances(self):
pass
def get_disks(self):
pass
class alicloud(cloud):
def get_instances_from_api(self, offset):
zone_list = ['cn-beijing','cn-shanghai']
server_list = []
for zone_i in zone_list:
try:
client = AcsClient('LTAI4G696nAcjQUPayU7FVyA', '', zone_i)
request = DescribeInstancesRequest()
request.set_accept_format('json')
request.set_PageNumber(offset)
request.set_PageSize(100)
response = client.do_action_with_exception(request)
info = json.loads(response)['Instances']['Instance']
for instance in info:
name = instance['InstanceName']
ip = instance['VpcAttributes']['PrivateIpAddress']['IpAddress'][0]
instance_type = instance['InstanceType']
id = instance['InstanceId']
server_list.append({"name": name, "ip": ip, "instance_type": instance_type, "company": "AliCloud", "id": id})
except Exception as err:
print(err)
return 0, server_list
def get_instances(self):
try:
server_list = []
for offset in range(20):
offset = offset + 1
flag, server_list_tmp = self.get_instances_from_api(offset)
if flag:
raise Exception("get tencent instances error")
if server_list_tmp == []:
break
server_list = server_list + server_list_tmp
return server_list
except Exception as err:
print(err)
return 1, err
def get_disk_from_api(self, offset):
zone_list = ['cn-beijing','cn-shanghai']
disks_list = []
for zone_i in zone_list:
try:
client = AcsClient('LTAI4G696nAcjQUPayU7FVyA', '', zone_i)
request = DescribeDisksRequest()
request.set_accept_format('json')
request.set_PageNumber(offset)
request.set_PageSize(100)
response = client.do_action_with_exception(request)
info = json.loads(response)['Disks']['Disk']
for disk in info:
server_id = disk['InstanceId']
disk_id = disk['DiskId']
disk_type = disk['Category']
dist_size = disk['Size']
disk_info = ['AliCloud', disk_id, server_id, disk_type, dist_size]
disks_list.append(disk_info)
except Exception as err:
print(err)
return 0, disks_list
def get_disks(self):
try:
disks_list = []
for offset in range(20):
offset = offset + 1
flag, disks_list_tmp = self.get_disk_from_api(offset)
if flag:
raise Exception("get tencent disks error")
if disks_list_tmp == []:
break
disks_list = disks_list + disks_list_tmp
return disks_list
except Exception as err:
print(err, 11)
return 1, err
def run_cloud(self):
instences = self.get_instances()
disks = self.get_disks()
return {"instences": instences, "disks": disks}
class tencent(cloud):
def get_instances_from_api(self, offset):
zone_list = ['ap-beijing','ap-shanghai']
server_list = []
for zone_i in zone_list:
try:
cred = credential.Credential("AKIDiV3GSXs7brvQhkqYlkV7XkmDV7g0A6ub", "")
httpProfile = HttpProfile()
httpProfile.endpoint = "cvm.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = cvm_client.CvmClient(cred, zone_i, clientProfile)
req = models.DescribeInstancesRequest()
params = {"Offset": offset, "Limit": 100}
params = json.dumps(params)
req.from_json_string(params)
instance_result = client.DescribeInstances(req).to_json_string()
instance_result = json.loads(instance_result)
for instance in instance_result["InstanceSet"]:
name = instance["InstanceName"]
ip = instance["PrivateIpAddresses"][0]
instance_type = instance["InstanceType"]
id = instance["InstanceId"]
status = instance["RestrictState"]
print(instance)
if status != "NORMAL":continue
server_list.append({"name": name,
"ip": ip,
"instance_type": instance_type,
"company": "Tencent",
"id": id
})
except Exception as err:
print(err)
return 0, server_list
def get_instances(self):
try:
server_list = []
for offset in range(20):
offset = offset * 100
flag, server_list_tmp = self.get_instances_from_api(offset)
if flag:
raise Exception("get tencent instances error")
if server_list_tmp == []:
break
server_list = server_list + server_list_tmp
return server_list
except Exception as err:
print(err)
def get_disk_from_api(self, offset):
disks_list = []
zone_list = ['ap-beijing','ap-shanghai']
for zone_i in zone_list:
try:
cred = credential.Credential("AKIDiV3GSXs7brvQhkqYlkV7XkmDV7g0A6ub", "")
httpProfile = HttpProfile()
httpProfile.endpoint = "cbs.tencentcloudapi.com"
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
client = cbs_client.CbsClient(cred, zone_i, clientProfile)
req = cbsmodels.DescribeDisksRequest()
params = {"Offset": offset, "Limit": 100}
params = json.dumps(params)
req.from_json_string(params)
disks_result = client.DescribeDisks(req).to_json_string()
disks_result = json.loads(disks_result)
for disk in disks_result['DiskSet']:
disk_id = disk['DiskId']
try:
server_id = disk['InstanceIdList'][0]
except:
server_id = 'not-mount'
disk_type = disk['DiskType']
dist_size = disk['DiskSize']
disk_info = ['Tencent', disk_id, server_id, disk_type, dist_size]
disks_list.append(disk_info)
except TencentCloudSDKException as err:
print(err)
return 0, disks_list
def get_disks(self):
try:
disks_list = []
for offset in range(20):
offset = offset * 100
flag, disks_list_tmp = self.get_disk_from_api(offset)
if flag:
raise Exception("get tencent instances error")
if disks_list_tmp == []:
break
disks_list = disks_list + disks_list_tmp
return disks_list
except Exception as err:
print(err)
def run_cloud(self):
instences = self.get_instances()
disks = self.get_disks()
return {"instences": instences, "disks": disks}
class huawei(cloud):
def get_instances_from_api(self):
try:
server_list = []
projectId = "968431fc7f2f4e7bac2cefdfe369c81d"
cloud = "myhuaweicloud.com"
region = "cn-north-4"
AK = "JJDCGNDVKNWKTK4YSSIP"
SK = ""
conn = connection.Connection(
project_id=projectId,
cloud=cloud,
region=region,
ak=AK,
sk=SK)
servers = conn.compute.servers()
for server in servers:
name = server.name
id = server.id
for key in server.addresses:
addr_id = key
ip = server.addresses[addr_id][0]['addr']
instance_type = server.flavor['id']
server_list.append({"name": name, "ip": ip, "instance_type": instance_type, "company": "HuaWei", "id": id})
return 0, server_list
except Exception as err:
print(err)
return 1, err
def get_instances(self):
try:
flag, server_list = self.get_instances_from_api()
if flag:
raise Exception("get huawei instances error")
return server_list
except Exception as err:
print(err)
def get_disks(self):
try:
disk_list = []
projectId = "968431fc7f2f4e7bac2cefdfe369c81d"
cloud = "myhuaweicloud.com"
region = "cn-north-4"
AK = "JJDCGNDVKNWKTK4YSSIP"
SK = ""
conn = connection.Connection(
project_id=projectId,
cloud=cloud,
region=region,
ak=AK,
sk=SK)
disks = conn.evs.volumes()
for m in disks:
for disk in m.volumes:
disk_id = disk['id']
server_id = disk['attachments'][0]['server_id']
disk_type = disk['volume_type']
dist_size = disk['size']
disk_info = ['HuaWei', disk_id, server_id, disk_type, dist_size]
disk_list.append(disk_info)
return disk_list
except Exception as err:
print(err)
return 1, err
def run_cloud(self):
instences = self.get_instances()
disks = self.get_disks()
return {"instences": instences, "disks": disks}
----------------
腾讯查询价格api---------
# -*- coding: utf-8 -*-
import os
import json
import types
from tencentcloud.common import credential
from tencentcloud.common.profile.client_profile import ClientProfile
from tencentcloud.common.profile.http_profile import HttpProfile
from tencentcloud.common.exception.tencent_cloud_sdk_exception import TencentCloudSDKException
from tencentcloud.cvm.v20170312 import cvm_client, models
try:
# 密钥信息从环境变量读取，需要提前在环境变量中设置 TENCENTCLOUD_SECRET_ID 和 TENCENTCLOUD_SECRET_KEY
# 使用环境变量方式可以避免密钥硬编码在代码中，提高安全性
# 生产环境建议使用更安全的密钥管理方案，如密钥管理系统(KMS)、容器密钥注入等
# 请参见：https://cloud.tencent.com/document/product/1278/85305
# 密钥可前往官网控制台 https://console.cloud.tencent.com/cam/capi 进行获取
cred = credential.Credential(os.getenv("TENCENTCLOUD_SECRET_ID"), os.getenv("TENCENTCLOUD_SECRET_KEY"))
# 使用临时密钥示例
# cred = credential.Credential("SecretId", "SecretKey", "Token")
# 实例化一个http选项，可选的，没有特殊需求可以跳过
httpProfile = HttpProfile()
httpProfile.endpoint = "cvm.tencentcloudapi.com"
# 实例化一个client选项，可选的，没有特殊需求可以跳过
clientProfile = ClientProfile()
clientProfile.httpProfile = httpProfile
# 实例化要请求产品的client对象,clientProfile是可选的
client = cvm_client.CvmClient(cred, "ap-beijing", clientProfile)
# 实例化一个请求对象,每个接口都会对应一个request对象
req = models.InquiryPriceRunInstancesRequest()
params = {
"Placement": {
"Zone": "ap-beijing-6"
},
"ImageId": "img-p5nkhc2v",
"InstanceChargeType": "PREPAID",
"InstanceChargePrepaid": {
"Period": 1
},
"InstanceType": "SA2.2XLARGE16"
}
req.from_json_string(json.dumps(params))
# 返回的resp是一个InquiryPriceRunInstancesResponse的实例，与请求对象对应
resp = client.InquiryPriceRunInstances(req)
# 输出json格式的字符串回包
print(resp.to_json_string())
except TencentCloudSDKException as err:
print(err)
----腾讯api返回：
{
"Response": {
"Price": {
"BandwidthPrice": {},
"InstancePrice": {
"Discount": 60,
"DiscountPrice": 286.98,
"OriginalPrice": 478.3
}
},
"RequestId": "bd16e011-f83d-4bbc-bb2d-c31361508e11"
}
}
-------------------------------------------------------------------------------------------------------------------------
阿里查询价格api---------
# -*- coding: utf-8 -*-
# This file is auto-generated, don't edit it. Thanks.
import os
import sys
from typing import List
from alibabacloud_ecs20140526.client import Client as Ecs20140526Client
from alibabacloud_credentials.client import Client as CredentialClient
from alibabacloud_tea_openapi import models as open_api_models
from alibabacloud_ecs20140526 import models as ecs_20140526_models
from alibabacloud_tea_util import models as util_models
from alibabacloud_tea_util.client import Client as UtilClient
class Sample:
def __init__(self):
pass
@staticmethod
def create_client() -> Ecs20140526Client:
"""
使用凭据初始化账号Client
@return: Client
@throws Exception
"""
# 工程代码建议使用更安全的无AK方式，凭据配置方式请参见：https://help.aliyun.com/document_detail/378659.html。
credential = CredentialClient()
config = open_api_models.Config(
credential=credential
)
# Endpoint 请参考 https://api.aliyun.com/product/Ecs
config.endpoint = f'ecs.cn-beijing.aliyuncs.com'
return Ecs20140526Client(config)
@staticmethod
def main(
args: List[str],
) -> None:
client = Sample.create_client()
describe_price_request = ecs_20140526_models.DescribePriceRequest(
region_id='cn-beijing',
instance_type='ecs.c5.xlarge',
price_unit='Month',
period=1
)
runtime = util_models.RuntimeOptions()
try:
# 复制代码运行请自行打印 API 的返回值
client.describe_price_with_options(describe_price_request, runtime)
except Exception as error:
# 此处仅做打印展示，请谨慎对待异常处理，在工程项目中切勿直接忽略异常。
# 错误 message
print(error.message)
# 诊断地址
print(error.data.get("Recommend"))
UtilClient.assert_as_string(error.message)
@staticmethod
async def main_async(
args: List[str],
) -> None:
client = Sample.create_client()
describe_price_request = ecs_20140526_models.DescribePriceRequest(
region_id='cn-beijing',
instance_type='ecs.c5.xlarge',
price_unit='Month',
period=1
)
runtime = util_models.RuntimeOptions()
try:
# 复制代码运行请自行打印 API 的返回值
await client.describe_price_with_options_async(describe_price_request, runtime)
except Exception as error:
# 此处仅做打印展示，请谨慎对待异常处理，在工程项目中切勿直接忽略异常。
# 错误 message
print(error.message)
# 诊断地址
print(error.data.get("Recommend"))
UtilClient.assert_as_string(error.message)
if __name__ == '__main__':
Sample.main(sys.argv[1:])
--------阿里api返回：
{
"RequestId": "D1F58F14-AAF7-585D-B3A5-1523CC5D94A1",
"PriceInfo": {
"Price": {
"OriginalPrice": 365,
"ReservedInstanceHourPrice": 0,
"DiscountPrice": 146,
"Currency": "CNY",
"DetailInfos": {
"DetailInfo": [
{
"OriginalPrice": 0,
"DiscountPrice": 0,
"Resource": "image",
"TradePrice": 0
},
{
"OriginalPrice": 358,
"DiscountPrice": 143.2,
"Resource": "instanceType",
"TradePrice": 214.8
},
{
"OriginalPrice": 7,
"DiscountPrice": 2.8,
"Resource": "systemDisk",
"TradePrice": 4.2
},
{
"OriginalPrice": 0,
"DiscountPrice": 0,
"Resource": "bandwidth",
"TradePrice": 0
}
]
},
"TradePrice": 219
},
"Rules": {
"Rule": [
{
"Description": "合同优惠_整单_6.0折",
"RuleId": 2000019367043
}
]
}
}
}
------------------------------------------------------------------------------------------------------------------
火山云询价api
# Example Code generated by Beijing Volcanoengine Technology.
from __future__ import print_function
import volcenginesdkcore
import volcenginesdkbilling
from volcenginesdkcore.rest import ApiException
if __name__ == '__main__':
# 注意示例代码安全，代码泄漏会导致AK/SK泄漏，有极大的安全风险。
configuration = volcenginesdkcore.Configuration()
configuration.ak = "Your AK"
configuration.sk = "Your SK"
configuration.region = "cn-beijing"
# set default configuration
volcenginesdkcore.Configuration.set_default(configuration)
# use global default configuration
api_instance = volcenginesdkbilling.BILLINGApi()
query_price_for_renew_request = volcenginesdkbilling.QueryPriceForRenewRequest(
instance_id_list=["i-ye3aogjxfkwh2yrey86c"],
product="ECS",
use_duration=1,
)
try:
# 复制代码运行示例，请自行打印API返回值。
api_instance.query_price_for_renew(query_price_for_renew_request)
except ApiException as e:
# 复制代码运行示例，请自行打印API错误信息。
# print("Exception when calling api: %s\n" % e)
pass
--------火山云询价api调用返回结果
{
"ResponseMetadata": {
"RequestId": "20250924090622B58F540645656224EA78",
"Action": "QueryPriceForRenew",
"Version": "2022-01-01",
"Service": "billing",
"Region": "cn-beijing"
},
"Result": {
"Currency": "CNY",
"TotalOriginalAmount": "561.17",
"TotalDiscountAmount": "252.53",
"InstanceAmountList": [
{
"InstanceID": "i-ye3aogjxfkwh2yrey86c",
"Product": "ECS",
"ConfigurationCode": "ecs.c3a.2xlarge.month",
"OriginalAmount": "561.17",
"DiscountAmount": "252.53"
}
],
"CalSerialNo": "CSN_d39k83j65irjk3r3543g",
"BaseResp": {
"StatusMessage": "",
"StatusCode": 0,
"HTTPStatusCode": 0,
"ErrorCode": ""
}
}
}
本文探讨了在不同Linux内核版本中实现文件系统UID/GID临时更改为root的方法。针对内核版本2.6.28及之前版本与之后版本的不同处理方式进行了详细对比，并介绍了prepare_creds()与override_creds()等函数的作用。
扫一扫
4809
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
