def getDescribeLoadBalancers(self, addressType='internet'):
try:
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest(
)
request.set_AddressType(addressType)
response = self.clt.do_action_with_exception(request)
result = json.loads(response)
return True, result['LoadBalancers']['LoadBalancer']
except Exception, ex:
return False, str(ex)
def getserverlist():
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
response = client.do_action_with_exception(request)
test = json.loads(response)['LoadBalancers']['LoadBalancer']
if type(test) is list:
lens = len(test)
name_list = {}
for i in range(lens):
print u'名字 : %sid : %s' % (test[i]['LoadBalancerName'].ljust(20),
test[i]['LoadBalancerId'])
name_list[test[i]['LoadBalancerName']] = test[i]['LoadBalancerId']
def elb(ak, sk, region):
id_list = []
client = AcsClient(ak, sk, region)
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
request.set_accept_format('json')
response = client.do_action_with_exception(request)
response1 = str(response)
response1 = json.loads(response1)
for record in response1['LoadBalancers']['LoadBalancer']:
id_list.append({"l": record['LoadBalancerId'], "d": record['Address']})
return id_list
def get__lbids(self):
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
result = self._request(request)
slbs = result['LoadBalancers']['LoadBalancer']
#print json.dumps(slbs,sort_keys=True,indent=4, separators=(',', ': '))
lbid = []
# get www..com admin..com LoadBalancerId
for slb in slbs:
if slb['LoadBalancerName'] in self.lbs_config:
lbid.append(slb['LoadBalancerId'])
return lbid
def describeloadbalancer(self, loadbalancername):
'''查询slb信息'''
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
values = {
"RegionId": "cn-hangzhou",
"LoadBalancerName": str(loadbalancername)
}
info = self.request_api(request,
values)['LoadBalancers']['LoadBalancer']
if info:
return [
loadbalancer_info['LoadBalancerId']
for loadbalancer_info in info
]
def get_slb_from_name(self, slb_name):
"""
:param slb_name: str, specify slb instance name
:return: specify slb instance id
"""
slb_req = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
slb_res = self.client.do_action_with_exception(slb_req)
slbs = json.loads(slb_res.decode('utf-8'))
logging.debug('all slbs: {}'.format(json.dumps(slbs)))
# print(json.dumps(slbs, indent=2))
slb_list = slbs['LoadBalancers']['LoadBalancer']
for lb in slb_list:
if lb['LoadBalancerName'] == slb_name:
logging.debug('process slb: {}'.format(lb['LoadBalancerName']))
slb_id = lb['LoadBalancerId']
return slb_id
return None
def update_Slb():
Slb_Info = {}
client = AcsClient(Config.configs['AliAK']['AccessKey'],
Config.configs['AliAK']['AccessKeySecret'], RegionId)
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
response = client.do_action_with_exception(request)
SLBInfo = json.loads(response)
for SLBInstance in SLBInfo['LoadBalancers']['LoadBalancer']:
request = DescribeLoadBalancerAttributeRequest.DescribeLoadBalancerAttributeRequest(
)
request.set_LoadBalancerId(SLBInstance['LoadBalancerId'])
response = client.do_action_with_exception(request)
Slb_Info[SLBInstance['LoadBalancerId']] = json.loads(
response.decode('utf-8'))
conn.set('Slb_Info', json.dumps(Slb_Info))
def slb_info(self) -> GaugeMetricFamily:
req = DescribeSLB.DescribeLoadBalancersRequest()
gauge = self.info_template(
req,
'aliyun_meta_slb_info',
to_list=lambda data: data['LoadBalancers']['LoadBalancer'])
gauge_slb_info = None
for s in gauge.samples:
slb_id = s.labels['LoadBalancerId']
req_slb_attr = DescribeSLBAttr.DescribeLoadBalancerAttributeRequest(
)
req_slb_attr.set_LoadBalancerId(slb_id)
slb_attrs_resp = self.client.do_action_with_exception(req_slb_attr)
slb_attrs_info = json.loads(slb_attrs_resp)
for protocol_info in slb_attrs_info['ListenerPortsAndProtocol'][
'ListenerPortAndProtocol']:
protocol = protocol_info['ListenerProtocol']
port = protocol_info['ListenerPort']
req_slb_proto = None
if protocol == 'tcp':
req_slb_proto = DescribeSLBTcpAttr.DescribeLoadBalancerTCPListenerAttributeRequest(
)
elif protocol == 'http':
req_slb_proto = DescribeSLBHttpAttr.DescribeLoadBalancerHTTPListenerAttributeRequest(
)
elif protocol == 'https':
req_slb_proto = DescribeSLBHttpsAttr.DescribeLoadBalancerHTTPSListenerAttributeRequest(
)
req_slb_proto.set_LoadBalancerId(slb_id)
req_slb_proto.set_ListenerPort(int(port))
slb_protocol_resp = self.client.do_action_with_exception(
req_slb_proto)
slb_protocol_info: dict = json.loads(slb_protocol_resp)
if 'ForwardCode' in slb_protocol_info.keys():
continue
Bandwidth = slb_protocol_info['Bandwidth']
if gauge_slb_info is None:
gauge_slb_info = GaugeMetricFamily(
'aliyun_meta_slb_proto_bandwidth',
'protocolBandwidth',
labels=[
'instanceId', 'ListenerProtocol', 'ListenerPort'
])
gauge_slb_info.add_metric(
[slb_id, protocol, str(port)], value=float(Bandwidth))
return gauge_slb_info
def describe_loadbalancers(self, pagenumber=1):
"""
查询负载均衡实例列表
:return:
"""
try:
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
request.set_accept_format('json')
request.add_query_param('RegionId', self.instance_regionid)
request.add_query_param('PageSize', 20)
request.add_query_param('PageNumber', pagenumber)
# 发起请求
response = self.cli.do_action_with_exception(request)
response = response.decode('utf8')
return response
except Exception as ee:
log.error('ali_slb 查询负载均衡实例列表 error: {}'.format(ee))
def get_internet_type_slb(self, withbandwidth=False):
pageNumber = 1
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
request.set_PageSize(10)
request.set_PageNumber(pageNumber)
request.set_accept_format('json')
request.set_AddressType('internet')
request.set_NetworkType('classic')
request.set_LoadBalancerStatus('active')
if withbandwidth:
request.set_InternetChargeType('paybybandwidth')
response = self.client.do_action_with_exception(request)
response_dict = json.loads(response)
# 生成生成器
while response_dict.get('LoadBalancers').get('LoadBalancer'):
yield response_dict.get('LoadBalancers').get('LoadBalancer')
pageNumber += 1
request.set_PageNumber(pageNumber)
response = self.client.do_action_with_exception(request)
response_dict = json.loads(response)
def get_slb_instances(self, pageSize=100):
result = []
insert_result = []
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
request.set_accept_format('json')
for clt in self.clt_conn_list:
pageNumber = 1
request.set_query_params(
dict(PageNumber=pageNumber, PageSize=pageSize))
clt_result = json.loads(clt.do_action_with_exception(request))
result = result + clt_result['LoadBalancers']['LoadBalancer']
totalCount = clt_result['TotalCount']
while totalCount > pageNumber * pageSize:
request.set_query_params(
dict(PageNumber=pageNumber, PageSize=pageSize))
clt_result = json.loads(clt.do_action_with_exception(request),
encoding='utf-8')
result = result + clt_result['LoadBalancers']['LoadBalancer']
pageNumber += 1
for Instance in result:
insert_result.append({
'address_type':
Instance['AddressType'],
'instance_id':
Instance['LoadBalancerId'],
'instance_name':
Instance.get('LoadBalancerName', ''),
'address_ip_version':
Instance.get('AddressIPVersion'),
'network_type':
Instance.get('NetworkType'),
'address':
Instance['Address'],
'region':
Instance['RegionId'],
'status':
Instance['LoadBalancerStatus'],
'create_time':
Instance['CreateTime']
})
return insert_result
def slb_status(self, slbid):
slb = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
slb.set_accept_format('json')
if slbid:
slb.set_LoadBalancerId(slbid)
slb_r = self.clt.do_action(slb)
slb_json = json.loads(slb_r)
d = collections.OrderedDict()
for obj in slb_json.get('LoadBalancers').get('LoadBalancer'):
slb_name = obj.get('LoadBalancerName')
slb_id = obj.get('LoadBalancerId').encode('utf-8')
slb_type = obj.get('AddressType').encode('utf-8')
slb_regionid = obj.get('RegionId').encode('utf-8')
slb_status = obj.get('LoadBalancerStatus').encode('utf-8')
slb_ip = obj.get('Address').encode('utf-8')
attr_obj = self.get_slb_attrs(slb_id)
slb_backends = attr_obj.get('BackendServers').get('BackendServer')
slb_listeners = attrobj.get('ListenerPorts').get('ListenerPort')
slb_vgroups = self.list_vgroups(slb_id)
vss = []
if slb_vgroups:
for vg in slb_vgroups:
vgid = vg.get('VServerGroupId')
vgservers = self.list_vgroup_servers(vgid)
vgsrvinfo = {vgid: vgservers}
vss.append(vgsrvinfo)
d[slb_id] = {
'name': slb_name,
'type': slb_type,
'slb_ip': slb_ip,
'listeners': slb_listeners,
'slb_status': slb_status,
'slb_regionid': slb_regionid,
'backends': slb_backends,
'vgroups': slb_vgroups,
'vgroup_servers': vss
}
for k, v in d.items():
print '%s | %s' % (k, v)
def list_slb(self, name_only=False, **kwargs):
"""
获取实例列表信息
https://help.aliyun.com/document_detail/27582.html?spm=a2c4g.11186623.6.631.424952e51QEPuJ
:param name_only:
:param kwargs:
:return:
"""
result_list = []
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
regions = self.get_regions(id_only=True)
for region in regions:
request.set_PageSize(100)
request.set_PageNumber(1)
for k, v in kwargs.items():
request.add_query_param(k, v)
request.add_query_param('RegionId', region)
result = self.client.do_action(request)
result_list.extend(
result.get('LoadBalancers', {}).get('LoadBalancer', []))
total_count = float(result.get('TotalCount', 0))
if not total_count:
continue
page_count = float(result.get('PageSize', 1))
_p = total_count / page_count
if _p > 1:
for _p_num in range(2, int(_p) + 2):
request.set_PageNumber(_p_num)
result = self.client.do_action(request)
result_list.extend(
result.get('LoadBalancers').get('LoadBalancer'))
if name_only:
result_list = [i['InstanceName'] for i in result_list]
return result_list
def sync_all_slb(region_id):
# 设置参数
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
request.set_accept_format('json')
request.add_query_param('RegionId', region_id)
# 发起请求
response = clt.do_action(request)
LoadBalancers = json.loads(response)['LoadBalancers']
LoadBalancer = LoadBalancers['LoadBalancer']
slblist = []
for slb in LoadBalancer:
LoadBalancerId = slb['LoadBalancerId']
try:
LoadBalancerName = slb['LoadBalancerName']
except:
LoadBalancerName = ''
try:
NetworkType = slb['NetworkType']
except:
NetworkType = ''
LoadBalancerStatus = slb['LoadBalancerStatus']
Address = slb['Address']
AddressType = slb['AddressType']
CreateTime = slb['CreateTime'].replace("Z", "").replace("T", " ")
slbdict = {}
slbdict['LoadBalancerId'] = LoadBalancerId
slbdict['LoadBalancerName'] = LoadBalancerName
slbdict['LoadBalancerStatus'] = LoadBalancerStatus
slbdict['Address'] = Address
slbdict['AddressType'] = AddressType
slbdict['CreateTime'] = CreateTime
slbdict['NetworkType'] = NetworkType
slblist.append(slbdict)
return slblist
def get_slb_info(keys):
'''
keys字典内包含key_id key_secret region_id
:param keys:
:return:
'''
key_id = keys['key_id']
key_secret = keys['key_secret']
region_id = keys['region_id']
try:
client = AcsClient(key_id, key_secret, region_id)
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
request.set_PageSize(100)
response = client.do_action_with_exception(request)
response_json = json.loads(response)
Items = response_json['LoadBalancers']['LoadBalancer']
for item in Items:
instanceId = item.get('LoadBalancerId')
instanceName = item.get('LoadBalancerName')
productCode = 'slb'
businessLine = instanceName.split('-')[0]
env = instanceName.split('-')[0]
regionId = item.get('RegionId')
instanceNetworkType = item.get('NetworkType')
internetChargeType = item.get('InternetChargeType')
ipaddress = item.get('Address')
keys['instanceId'] = instanceId
ListenPorts = get_slb_item(keys).get('ListenPorts')
creationTime = item.get('CreateTime')
expiredTime = get_slb_item(keys).get('expiredTime')
status = item.get('LoadBalancerStatus')
if status == 'active':
status = '运行中'
elif status == 'inactive':
status = '停止'
BackendServer_re = get_slb_item(keys).get('BackendServers')
BackendServers = []
for i in BackendServer_re:
i_re = EcsInfo.objects.filter(instanceId=i).values('instanceName').first()
if i_re is not None:
BackendServers.append(i_re.get('instanceName'))
else:
BackendServers.append(i)
try:
SlbInfo.objects.get(instanceId = instanceId)
except SlbInfo.DoesNotExist:
SlbInfo.objects.create(
instanceId = instanceId, instanceName = instanceName, productCode = productCode, env = env,
businessLine = businessLine, regionId = regionId, status = status, ipaddress = ipaddress,
instanceNetworkType = instanceNetworkType, internetChargeType = internetChargeType,
BackendServers = BackendServers,ListenPorts = ListenPorts,
creationTime = creationTime, expiredTime = expiredTime
)
else:
SlbInfo.objects.filter(instanceId = instanceId).update(
instanceId=instanceId, instanceName=instanceName, productCode=productCode, env=env,
businessLine=businessLine, regionId=regionId, status=status, ipaddress=ipaddress,
instanceNetworkType=instanceNetworkType, internetChargeType = internetChargeType,
BackendServers=BackendServers,ListenPorts=ListenPorts,
creationTime=creationTime, expiredTime=expiredTime
)
except Exception as e:
print (e)
if __name__ == '__main__':
conn = pymysql.connect(user=dbUser,
passwd=dbPass,
host=dbHost,
db=dbName,
use_unicode=True,
charset="utf8")
cur = conn.cursor()
regions = [
"cn-qingdao", "cn-hangzhou", "cn-beijing", "cn-shanghai",
"cn-shenzhen", "cn-zhangjiakou"
]
for region in regions:
clt = client.AcsClient(accessKey, accessSecret, region)
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
request.set_accept_format('json')
request.set_PageSize(100)
request.set_PageNumber(1)
response = json.loads(clt.do_action_with_exception(request),
encoding='utf-8')
slb_info = response.get('LoadBalancers').get('LoadBalancer')
if slb_info:
save_or_update_data(slb_info)
total = response.get('TotalCount')
num = int(round(total / 100.0))
index = 1
while index < num:
index = index + 1
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest(
)
def getSlbList(self):
#获取SLB负载均衡实例
request = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
response = client.do_action_with_exception(request)
text = json.loads(response)['LoadBalancers']['LoadBalancer']
return text
SLB_REGION = "cn-qingdao"
# Initialize AcsClient instance
client = AcsClient(ALI_ACCESS_KEY, ALI_SECRET_KEY, SLB_REGION)
# Initialize a ecs request and set parameters
ecs_req = DescribeInstancesRequest.DescribeInstancesRequest()
ecs_req.set_PageSize(10)
# Print response, list all ecs instance:
ecs_res = client.do_action_with_exception(ecs_req)
instances = json.loads(ecs_res.decode('utf-8'))
# print(json.dumps(instances, indent=2))
# Initialize a slb request and set parameters
slb_req = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
slb_req.set_PageSize(10)
# Print response, list all slb instances:
slb_res = client.do_action_with_exception(slb_req)
slbs = json.loads(slb_res.decode('utf-8'))
# print(json.dumps(slbs, indent=2))
# init request:
# Get slb instance named: "remix.example.com_qd_slb"
slb_list = slbs['LoadBalancers']['LoadBalancer']
for lb in slb_list:
if lb['LoadBalancerName'] == SLB_NAME:
remix_slb_id = lb['LoadBalancerId']
print(remix_slb_id)
break
def slb_info(self) -> GaugeMetricFamily:
req = DescribeSLB.DescribeLoadBalancersRequest()
return self.info_template(
req,
'aliyun_meta_slb_info',
to_list=lambda data: data['LoadBalancers']['LoadBalancer'])
def get_slb_instances(cluster_id):
tags = [{"TagKey": "ack.aliyun.com", "TagValue": cluster_id}]
req = DescribeLoadBalancersRequest.DescribeLoadBalancersRequest()
req.set_Tags = json.dumps(tags)
resp = do_action(req)
return resp.get('LoadBalancers').get('LoadBalancer')
