def set_info_by_vips(self): """ Return {'lb_id': 'vip', ...} """ try: client = clb_client.ClbClient(self.get_credential, self.region) req = clb_model.DescribeLoadBalancersRequest() req.LoadBalancerVips = self.vips ret_str = client.DescribeLoadBalancers( req).to_json_string(indent=2) ret_obj = json.loads(ret_str) if ret_obj.get("TotalCount") < len(self.vips) == 1: self.region = "ap-hongkong" self.vpc = self.get_vpc() client = clb_client.ClbClient(self.get_credential, self.region) req = clb_model.DescribeLoadBalancersRequest() req.LoadBalancerVips = self.vips ret_str = client.DescribeLoadBalancers( req).to_json_string(indent=2) ret_obj = json.loads(ret_str) result = {} [result.setdefault(lb.get("LoadBalancerVips")[0], lb.get( "LoadBalancerId")) for lb in ret_obj.get("LoadBalancerSet")] self.load_balance_info.update(result) except TencentCloudSDKException: print(traceback.format_exc()) exit(1)
def add_rules(self, load_balance_id, listener_id, domain): try: client = clb_client.ClbClient(self.get_credential, self.region) req = clb_model.CreateRuleRequest() req.LoadBalancerId = load_balance_id req.ListenerId = listener_id req.Rules = [ { "Domain": domain, "Url": "/", "ForwardType": "HTTP", "TargetType": "NODE" }, ] # req.Rules = [{"Domain": domain, "Url": "/", "ForwardType": "HTTP", "TargetType": "NODE", "SessionExpireTime": 300}, ] ret_str = client.CreateRule(req).to_json_string() print("AddRule Success: AddRule args: %s %s %s" % (load_balance_id, listener_id, domain)) return json.loads(ret_str).get("RequestId"), json.loads( ret_str).get("LocationIds")[0] except TencentCloudSDKException, error: print("Exception Occur: AddRule args: %s %s %s" % (load_balance_id, listener_id, domain)) print(error) exit(1)
def init_client(self, region): self._region = region if True: try: cred = credential.Credential( self._tencent_id, self._tencent_key) if self._region in self._regions: endpoint = self._api+'.tencentcloudapi.com' hp=http_profile.HttpProfile() hp.endpoint = endpoint cp = client_profile.ClientProfile() cp.httpProfile = hp self._client = clb_client.ClbClient(cred, region, cp) # if region.find('ap-shenzhen-fsi'): # endpoint = self._api+'.tencentcloudapi.com' # hp=http_profile.HttpProfile() # hp.endpoint = endpoint # cp = client_profile.ClientProfile() # cp.httpProfile = hp # self._client = clb_client.ClbClient(cred, "ap-shenzhen-fsi", cp) # else: # print self._region # self._client = clb_client.ClbClient(cred, self._region) except TencentCloudSDKException as err: print(err) except Exception as e: print str(e)
def bind_rs(self, load_balance_id, target_obj): try: client = clb_client.ClbClient(self.get_credential, self.region) req = clb_model.BatchRegisterTargetsRequest() req.LoadBalancerId = load_balance_id req.Targets = target_obj client.BatchRegisterTargets(req).to_json_string(indent=2) print("Bindrs success !") except TencentCloudSDKException: print(traceback.format_exc()) exit(1)
def get_clb(Region_Id): """ 查询 CLB 列表 :param config_dict: :return: InstanceId """ describe_request = clb_models.DescribeLoadBalancersRequest() try: clt = clb_client.ClbClient(cred, Region_Id) response = clt.DescribeLoadBalancers(describe_request) result_content = response.to_json_string() return json.loads(result_content) except TencentCloudSDKException as e: print(e)
def _delete_listener_exec(self, load_balance_id, listener_id): try: client = clb_client.ClbClient(self.get_credential, self.region) req = clb_model.DeleteListenerRequest() req.LoadBalancerId = load_balance_id req.ListenerId = listener_id ret_str = client.DeleteListener(req).to_json_string(indent=2) request_id = json.loads(ret_str).get("RequestId") print("Delete Listener Request: %s " % request_id) self.wait_request(request_id) print("[Delete Listener] Success! info: %s, %s" % (load_balance_id, listener_id)) except TencentCloudSDKException: print(traceback.format_exc()) exit(1)
def create_listener(self, load_balance_id, protocol, vport): try: client = clb_client.ClbClient(self.get_credential, self.region) req = clb_model.CreateListenerRequest() req.LoadBalancerId = load_balance_id req.Protocol = protocol req.Ports = [int(vport), ] ret_obj = json.loads(client.CreateListener( req).to_json_string(indent=2)) print("CreateListener success: %s %s %s" % (load_balance_id, protocol, str(vport))) return ret_obj.get("RequestId"), ret_obj.get("ListenerIds")[0] except TencentCloudSDKException: print(traceback.format_exc()) print("Exception occur: CreateListener args: %s %s %s" % (load_balance_id, protocol, str(vport)))
def cust_bind_rs(self, region, load_balance_id, listener_id, new_rs, rs_port): try: self.region = region self.vpc = self.get_vpc() client = clb_client.ClbClient(self.get_credential, self.region) req = clb_model.RegisterTargetsRequest() req.LoadBalancerId = load_balance_id req.ListenerId = listener_id req.Targets = [{"Port": int(rs_port), "EniIp": new_rs}] ret_str = client.RegisterTargets(req).to_json_string(indent=2) request_id = json.loads(ret_str).get("RequestId") print("Bind request: %s" % request_id) self.wait_request(request_id) print("[Bind rs] Success! Info: %s, %s, %s, %s, %s" % (region, load_balance_id, listener_id, new_rs, rs_port)) except TencentCloudSDKException: print(traceback.format_exc()) exit(1)
def query_listener(self, load_balance_id): """ :param load_balance_id: :return: { "443": { "rules": { "a.gwgo.qq.com": "loc-bb9y1k05" }, "listener_id": "lbl-ansoslhl" } } """ try: client = clb_client.ClbClient(self.get_credential, self.region) req = clb_model.DescribeListenersRequest() req.LoadBalancerId = load_balance_id ret_str = client.DescribeListeners(req).to_json_string(indent=2) ret_obj = json.loads(ret_str) listeners = ret_obj.get("Listeners") listener_obj = {} for listener in listeners: if listener.get("Protocol") == "HTTPS": vport = listener.get("Port") listener_id = listener.get("ListenerId") rule_obj = {} rules = listener.get("Rules") if len(rules) > 0: for rule in rules: rule_obj.setdefault(rule.get("Domain"), rule.get("LocationId")) listener_obj.setdefault(str(vport), { "listener_id": listener_id, "rules": rule_obj }) print("QueryListener Success: %s" % load_balance_id) print(json.dumps(listener_obj, indent=2, ensure_ascii=False)) return listener_obj except TencentCloudSDKException, error: print("Exception Occur: QueryListener args: %s" % load_balance_id) print(error) exit(1)
def set_info_by_vips(self): """ Return {'lb_id': 'vip', ...} """ try: client = clb_client.ClbClient(self.get_credential, self.region) req = clb_model.DescribeLoadBalancersRequest() req.LoadBalancerVips = self.vips ret_str = client.DescribeLoadBalancers(req).to_json_string( indent=2) ret_obj = json.loads(ret_str) result = {} [ result.setdefault( lb.get("LoadBalancerVips")[0], lb.get("LoadBalancerId")) for lb in ret_obj.get("LoadBalancerSet") ] self.load_balance_info.update(result) except TencentCloudSDKException, error: print(error) exit(1)
def wait_request(self, request_id): client = clb_client.ClbClient(self.get_credential, self.region) req = clb_model.DescribeTaskStatusRequest() req.TaskId = request_id count = 0 while count <= 10: time.sleep(2) ret_str = client.DescribeTaskStatus(req).to_json_string() status = json.loads(ret_str).get("Status") if status == 0: print("Request %s exec done" % request_id) break elif status == 1: print("Request %s occur error, please check! ") break elif status == 2: count += 1 print("Request %s is doing, and will retry %s times!" % (request_id, str(count)))
def create_listener(self, load_balance_id, vport, cert_id): try: client = clb_client.ClbClient(self.get_credential, self.region) req = clb_model.CreateListenerRequest() req.LoadBalancerId = load_balance_id req.ListenerNames = ["https_" + str(vport)] req.Ports = [ int(vport), ] req.Protocol = "HTTPS" req.Certificate = {"SSLMode": "UNIDIRECTIONAL", "CertId": cert_id} ret_str = client.CreateListener(req).to_json_string() print("CreateListener Success: CreateListener args: %s %s %s" % (load_balance_id, vport, cert_id)) return json.loads(ret_str).get("ListenerIds")[0] except TencentCloudSDKException, error: print("Exception Occur: CreateListener args: %s %s %s" % (load_balance_id, vport, cert_id)) print(error) exit(1)
def bind_host(self, load_balance_id, listener_id, rule_id, new_rs): try: re.sub(r",$", "", new_rs) new_rs_list = new_rs.split(",") client = clb_client.ClbClient(self.get_credential, self.region) req = clb_model.RegisterTargetsRequest() req.LoadBalancerId = load_balance_id req.ListenerId = listener_id req.LocationId = rule_id req.Targets = [{ "EniIp": rs.split(":")[0], "Port": int(rs.split(":")[1]) } for rs in new_rs_list] client.RegisterTargets(req).to_json_string(indent=2) print("BindHost Success: %s %s %s %s " % (load_balance_id, listener_id, rule_id, new_rs)) except TencentCloudSDKException, error: print("Exception Occur: BindHost args: %s %s %s %s" % (load_balance_id, listener_id, rule_id, new_rs)) print(error) exit(1)
def query_listener(self, load_balance_id): try: client = clb_client.ClbClient(self.get_credential, self.region) req = clb_model.DescribeListenersRequest() req.LoadBalancerId = load_balance_id ret_str = client.DescribeListeners(req).to_json_string(indent=2) ret_obj = json.loads(ret_str) listeners = ret_obj.get("Listeners") listener_obj = {} for listener in listeners: if listener.get("Protocol") in ["TCP", "UDP"]: vport = listener.get("Port") protocol = listener.get("Protocol") listener_id = listener.get("ListenerId") protocol_vport_key = protocol + str(vport) listener_obj.setdefault(protocol_vport_key, listener_id) print("QueryListener Success: %s" % load_balance_id) return listener_obj except TencentCloudSDKException: print("Exception Occur: QueryListener args: %s" % load_balance_id) print(traceback.format_exc()) exit(1)
def _get_clb_client(): cred = credential.Credential(TENCENTCLOUD_SECRET_ID, TENCENTCLOUD_SECRET_KEY) return clb_client.ClbClient(cred, REGION)