阿里雲slb sdk使用示例

原創 白鵬 2019-02-28 08:37

SDK開發指南

負載均衡SLB支持Java、Python、C++、Go、C#和PHP SDK開發。

下表列舉了各語言SDK的GitHub下載地址和開發指南，更多SDK的信息，請訪問阿里雲SDK平臺。
SDK GitHub下載地址 說明文檔
Java SDK SLB Java SDK 快速開始
Python SDK SLB Python SDK 快速開始
Go SDK SLB Go SDK 快速開始
C# SDK SLB C# SDK 快速開始
PHP SDK SLB PHP SDK 快速開始

安裝阿里雲Python SDK

介紹如何在本地搭建可以運行負載均衡Python SDK示例的Python開發環境。

背景信息

  • 阿里雲Python SDK支持Python 2.7或更高版本。
  • 要運行負載均衡的Python SDK示例，您需要安裝阿里雲Python SDK的核心庫和SLB Python SDK。

操作步驟

  1. 安裝Python。
    1. 登錄Python下載地址。
    2. 下載2.7或更高版本的Python。

      在下載列表中選擇Window平臺安裝包，包格式爲：python-XYZ.msi 文件 ， XYZ 爲你要安裝的版本號。

    3. 下載後，雙擊下載包，進入Python安裝嚮導，使用默認設置即可。
    4. 設置環境變量。
      在Path行添加python安裝路徑和pip命令運行程序所在的目錄，目錄之間以;分隔。 
      C:\Python27;C:\Python27\Scripts
    5. 在cmd命令行，執行python命令，顯示類似如下，進入Python交互式環境，表示Python安裝成功。 
      
Python 2.7.15 (v2.7.15:ca079a3ea3, Apr 30 2018, 16:30:26) [MSC v.1500 64 bit (AM
D64)] on win32
Type "help", "copyright", "credits" or "license" for more information.
>>>
  2. 安裝阿里雲SDK核心庫。
    • 如果您使用Python 2.x，執行以下命令，安裝阿里雲SDK核心庫： 
      pip install aliyun-python-sdk-core
    • 如果您使用Python 3.x，執行以下命令，安裝阿里雲SDK核心庫： 
      pip install aliyun-python-sdk-core-v3

    關於Python及PIP的使用說明，請參考Python文檔。

  3. 執行如下命令，安裝SLB SDK。 
    pip install aliyun-python-sdk-slb
  4. 執行如下命令，雲監控SDK。 
    pip install aliyun-python-sdk-cms

準備工作

在運行SLB場景功能的SDK文件前，需要先在sdk_examples\sdk_lib文件夾下完成公共文件配置。

在開始運行示例腳本前，確保您已完成以下準備工作：

  • 獲取AccessKey。

    確保您已經有了用於身份驗證的AccessKey ID和AccessKey Secret。如果尚未生成AK，參考創建AccessKey。

  • 確保您的阿里雲賬戶金額不少於100元。

setup.py

記錄項目模塊添加到python path的規則。

setup.py中定義哪些模塊需要加入到python path和第三方依賴，安裝完成後，其他python項目可以使用setup.py中定義的模塊。

def find_version(*file_paths):
    version_file = read(*file_paths)
    version_match = re.search(r"^__version__ = ['\"]([^'\"]*)['\"]",
                              version_file, re.M)
    if version_match:
        return version_match.group(1)
    raise RuntimeError("Unable to find version string.")

setup(
    name='sdk_lib',
    version='0.1',
    license='GPL',
    auxxexxil='[email protected]',
    description='aliyun sdk_examples library.',
    packages=['sdk_lib'
              ],
    zip_safe=False,
    py_modules=[],
    package_data = {'': ['*.conf']}
)


創建和刪除SLB實例

介紹如何使用Python SDK創建一個SLB實例，創建成功後刪除該實例。

背景信息

在華北3張家口地域創建一個名爲SLB1的SLB實例，主可用區爲cn-zhangjiakou-a，備可用區爲cn-zhangjiakou-b，實例計費類型爲按量計費，規格爲slb.s1.small，監聽的帶寬峯值爲1Mbps，其他參數使用默認值。實例創建成功後，刪除該實例。

操作步驟

  1. 在下載的SDK目錄中，打開$aliyun-openapi-python-sdk-examples\sdk_examples\examples\slb文件夾。
  2. 使用編輯器打開slb_quick_start.py文件，您需要配置用戶鑑權參數ACS_CLIENT，其他參數根據實際情況配置後，保存退出。 
    #encoding=utf-8
import sys
import json


#調用AcsClient參數進行身份驗證
from aliyunsdkcore.client import AcsClient

#使用阿里雲官方sdk的異常處理模塊
from aliyunsdkcore.acs_exception.exceptions import ServerException, ClientException

#調用創建SLB實例API   
from aliyunsdkslb.request.v20140515 import CreateLoadBalancerRequest

#調用刪除SLB實例API  
from aliyunsdkslb.request.v20140515 import DeleteLoadBalancerRequest

#異常處理邏輯
from sdk_lib.exception import ExceptionHandler

#命令行打印日誌  
from sdk_lib.common_util import CommonUtil

#用戶身份驗證參數配置
ACS_CLIENT = AcsClient(
    'your-access-key-id',     #your-access-key-id
    'your-access-key-secret',   #your-access-key-secret
    'cn-zhangjiakou',     #your-region-id
)
'''
創建slb實例->刪除slb實例
'''

def create_load_balancer(params):
    '''
    create_load_balancer：創建slb實例
    官網API參考鏈接：https://help.aliyun.com/document_detail/27577.html
    '''
    try:
	#設置調用參數
	request = CreateLoadBalancerRequest.CreateLoadBalancerRequest() 
	request.set_MasterZoneId(params["master_zone_id"]) 
	request.set_SlaveZoneId(params["slave_zone_id"]) 
	request.set_LoadBalancerName(params["load_balancer_name"]) 
	request.set_PayType(params["pay_balancer_type"]) 
	request.set_LoadBalancerSpec(params["load_balancer_spec"]) 
	request.set_Bandwidth(params["balancer_listener_bandwith"])
	#發送調用請求並接收返回數據
	response = ACS_CLIENT.do_action_with_exception(request)
	response_json = json.loads(response)
	#返回結果	
	return response_json
    except ServerException as e:
        ExceptionHandler.server_exception(e)
    except ClientException as e:
        ExceptionHandler.client_exception(e)

def delete_load_balancer(load_balancer_id):
    '''
    delete_load_balancer：刪除slb實例
    官網API參考鏈接：https://help.aliyun.com/document_detail/27579.html
    '''
    try:
        request = DeleteLoadBalancerRequest.DeleteLoadBalancerRequest()
        #負載均衡實例的ID
        request.set_LoadBalancerId(load_balancer_id)
        response = ACS_CLIENT.do_action_with_exception(request)
        response_json = json.loads(response)
        return response_json
    except ServerException as e:
        ExceptionHandler.server_exception(e)
    except ClientException as e:
        ExceptionHandler.client_exception(e)

def main():
    #設置創建SLB的實例參數值
    params = {} 
    #設置新建SLB實例的主可用區爲cn-zhangjiakou-a 
    params["master_zone_id"] = "cn-zhangjiakou-a" 
    #設置新建SLB實例的主可用區爲cn-zhangjiakou-b 
    params["slave_zone_id"] = "cn-zhangjiakou-b" 
    #設置新建SLB實例的名稱爲SLB1 
    params["load_balancer_name"] = "SLB1"
    #設置新建SLB實例的計費類型爲按量計費
    params["pay_balancer_type"] = "PayOnDemand"
    #設置新建SLB實例的規格爲slb.s1.small
    params["load_balancer_spec"] = "slb.s1.small"
    #監聽的帶寬峯值爲6Mbps
    params["balancer_listener_bandwith"] = "1"
	
    #創建slb實例
    #獲取create_load_balancer函數返回值，load_balancer_json爲結果的json串
    load_balancer_json = create_load_balancer(params)
    #打印 load_balancer_json結果，其中"create_load_balancer"是對json串起的名字
    CommonUtil.log("create_load_balancer", load_balancer_json)

    #刪除slb實例
    #刪除返回的LoadBalancerId對應的SLB實例
    load_balancer_json = delete_load_balancer(load_balancer_json["LoadBalancerId"])
    #打印 load_balancer_json結果
    CommonUtil.log("delete_load_balancer", load_balancer_json)


if __name__ == "__main__":
    sys.exit(main())
  3. 進入setup.py所在的目錄，執行如下命令，完成環境初始化配置。 
    python setup.py install
  4. 進入slb_quick_start.py所在的目錄，執行如下命令，運行創建和刪除SLB實例示例。 
    python slb_quick_start.py
    系統顯示類似如下：
    
---------------------------create_load_balancer---------------------------
{
  "VpcId": "",
  "AddressIPVersion": "ipv4",
  "LoadBalancerName": "SLB1",
  "ResourceGroupId": "rg-acfmxxxxxxxxxy",
  "VSwitchId": "",
  "RequestId": "070A9361-EA2B-4A4E-91E8-F70C1E47866A",
  "Address": "172.16.XX.XX",
  "NetworkType": "classic",
  "LoadBalancerId": "lb-8vbninnfxxxxxxxxxxxxx"
}

---------------------------delete_load_balancer---------------------------
{
  "RequestId": "4825E5BB-5131-4A1E-AF67-0EF3E8E5B323"
}

創建TCP監聽

使用Python SDK給SLB實例創建TCP監聽，創建完成後刪除SLB實例。

前提條件

在華北3張家口地域已經有兩臺狀態爲運行中的ECS實例。

背景信息

本次示例分爲以下幾步，爲SLB實例添加TCP監聽並刪除實例：
  1. 在華北3張家口地域創建一個名爲SLB1的SLB實例，主可用區爲cn-zhangjiakou-a，備可用區爲cn-zhangjiakou-b，實例計費類型爲按量計費，規格爲slb.s1.small，其他配置使用系統默認值。
  2. 將張家口地域的兩臺ECS實例添加到默認服務器組，用來分發流量，ECS實例的後端服務權重都爲100。
  3. 創建TCP監聽，SLB實例前端使用的端口爲80，後端服務器開放用來接收請求的端口爲80，健康檢查協議爲TCP，不限制監聽帶寬峯值，其他使用默認值。
  4. TCP監聽創建完成後，從默認服務器組中移除ECS實例。
  5. 刪除新建的SLB實例。

操作步驟

  1. 在下載的SDK目錄中，打開$aliyun-openapi-python-sdk-examples\sdk_examples\examples\slb文件夾。
  2. 使用編輯器打開slb_create_tcp_listener.py文件，您需要配置用戶鑑權參數ACS_CLIENT，其他參數根據實際情況配置後，保存退出。 
    #encoding=utf-8
import json
import sys

#調用AcsClient參數進行身份驗證
from aliyunsdkcore.client import AcsClient
#使用阿里雲官方sdk的異常處理模塊
from aliyunsdkcore.acs_exception.exceptions import ServerException, ClientException
#調用創建SLB實例API   
from aliyunsdkslb.request.v20140515 import CreateLoadBalancerRequest
#調用添加默認服務器組API
from aliyunsdkslb.request.v20140515 import AddBackendServersRequest
#調用添加TCP監聽API
from aliyunsdkslb.request.v20140515 import CreateLoadBalancerTCPListenerRequest
#調用從默認服務器組中移除ECS實例API
from aliyunsdkslb.request.v20140515 import RemoveBackendServersRequest
#調用刪除SLB實例API  
from aliyunsdkslb.request.v20140515 import DeleteLoadBalancerRequest
#命令行打印日誌  
from sdk_lib.common_util import CommonUtil
#異常處理邏輯
from sdk_lib.exception import ExceptionHandler

'''
創建slb實例->添加後端服務器->創建tcp監聽->刪除後端服務器->刪除slb實例
'''
#client參數配置
ACS_CLIENT = AcsClient(
    'your-access-key-id',     #your-access-key-id
    'your-access-key-secret',   #your-access-key-secret
    'cn-zhangjiakou',     #your-region-id
)

TRY_TIME = 3

def create_load_balancer(params):
    '''
    create_load_balancer：創建slb實例
    官網API參考鏈接：https://help.aliyun.com/document_detail/27577.html
    '''
    try:
        #設置創建SLB實例的調用參數
	request = CreateLoadBalancerRequest.CreateLoadBalancerRequest() 
	request.set_MasterZoneId(params["master_zone_id"]) 
	request.set_SlaveZoneId(params["slave_zone_id"]) 
	request.set_LoadBalancerName(params["load_balancer_name"]) 
	request.set_PayType(params["pay_balancer_type"]) 
	request.set_LoadBalancerSpec(params["load_balancer_spec"]) 
	#發送調用請求並接收返回數據
	response = ACS_CLIENT.do_action_with_exception(request)
	response_json = json.loads(response)
	#返回結果	
	return response_json
    except ServerException as e:
        ExceptionHandler.server_exception(e)
    except ClientException as e:
        ExceptionHandler.client_exception(e)
		
def add_backend_servers(params):
    '''
    add_backend_servers：添加後端服務器
    官網API參考鏈接: https://help.aliyun.com/document_detail/27632.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
	    #設置添加默認服務器組的調用參數
            request = AddBackendServersRequest.AddBackendServersRequest()
            #負載均衡實例的ID
            request.set_LoadBalancerId(params["load_balancer_id"])
            #要添加的後端服務器列表
            request.set_BackendServers(params["backend_servers"])
	    #發送調用請求並接收返回數據
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
	    #返回結果
            return response_json
        except ServerException as e:
            if ExceptionHandler.server_exception(e):
                return e
        except ClientException as e:
            if ExceptionHandler.client_exception(e):
                return e
        finally:
            counter += 1

def create_tcp_listener(params):
    '''
    create_tcp_listener：創建tcp監聽
    官網API參考鏈接: https://help.aliyun.com/document_detail/27594.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
	    #設置創建TCP監聽的調用參數
            request = CreateLoadBalancerTCPListenerRequest.CreateLoadBalancerTCPListenerRequest()
            #負載均衡實例的ID
            request.set_LoadBalancerId(params["load_balancer_id"])
	    #負載均衡實例前端使用的端口
            request.set_ListenerPort(params["listener_port"])
            #負載均衡實例後端使用的端口
            request.set_BackendServerPort(params["backend_server_port"])
            #監聽的健康檢查協議
            request.set_HealthCheckType(params["listener_health_check"])
	    #設置監聽的帶寬峯值
            request.set_Bandwidth(params["listener_bandwidth"])
	    #發送調用請求並接收返回數據
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
	    #返回結果
            return response_json
        except ServerException as e:
            if ExceptionHandler.server_exception(e):
                return e
        except ClientException as e:
            if ExceptionHandler.client_exception(e):
                return e
        finally:
            counter += 1


def remove_backend_servers(params):
    '''
    add_backend_servers：刪除後端服務器
    官網API參考鏈接: https://help.aliyun.com/document_detail/27633.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
	    #設置刪除後端服務器的調用參數
            request = RemoveBackendServersRequest.RemoveBackendServersRequest()
            #負載均衡實例的ID
            request.set_LoadBalancerId(params["load_balancer_id"])
            #要刪除的後端服務器列表
            request.set_BackendServers(params["backend_servers"])
            #發送調用請求並接收返回數據
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
	    #返回結果
            return response_json
        except ServerException as e:
            if ExceptionHandler.server_exception(e):
                return e
        except ClientException as e:
            if ExceptionHandler.client_exception(e):
                return e
        finally:
            counter += 1

def delete_load_balancer(load_balancer_id):
    '''
    delete_load_balancer：刪除slb實例
    官網API參考鏈接：https://help.aliyun.com/document_detail/27579.html
    '''
    try:
	#設置刪除SLB實例的調用參數
        request = DeleteLoadBalancerRequest.DeleteLoadBalancerRequest()
        #負載均衡實例的ID
        request.set_LoadBalancerId(load_balancer_id)
        #發送調用請求並接收返回數據
        response = ACS_CLIENT.do_action_with_exception(request)
        response_json = json.loads(response)
	#返回結果
        return response_json
    except ServerException as e:
        ExceptionHandler.server_exception(e)
    except ClientException as e:
        ExceptionHandler.client_exception(e)
		
def main():
    params = {}
	
    #設置創建SLB實例的參數
    #設置新建SLB實例的主可用區爲cn-zhangjiakou-a 
    params["master_zone_id"] = "cn-zhangjiakou-a" 
    #設置新建SLB實例的主可用區爲cn-zhangjiakou-b 
    params["slave_zone_id"] = "cn-zhangjiakou-b" 
    #設置新建SLB實例的名稱爲SLB1 
    params["load_balancer_name"] = "SLB1"
    #設置新建SLB實例的計費類型爲按量計費
    params["pay_balancer_type"] = "PayOnDemand"
    #設置新建SLB實例的規格爲slb.s1.small
    params["load_balancer_spec"] = "slb.s1.small"
    #設置添加到默認服務器組的ECS的實例ID和權重
    params["backend_servers"] = [{"ServerId":"i-8vbe8yi8krxxxxxxxxxxw","Weight":"100"},{"ServerId":"i-8vbe8yi8kccxxxxxxxxxv","Weight":"100"}]

    #設置添加TCP監聽的參數
    #前端使用的端口爲80
    params["listener_port"] = 80
    #後端服務器開放用來接收請求的端口爲80
    params["backend_server_port"] = 80
    #健康檢查協議爲TCP
    params["listener_health_check"] = "tcp"
    #TCP監聽的帶寬峯值爲-1，即不限制帶寬峯值
    params["listener_bandwidth"] = -1
	
	
    #創建slb實例
    #獲取create_load_balancer函數返回值，load_balancer_json爲結果的json串
    load_balancer_json = create_load_balancer(params)
    #打印 load_balancer_json結果，其中"create_load_balancer"是對json串起的名字
    CommonUtil.log("create_load_balancer", load_balancer_json)

    #slb實例id
    params["load_balancer_id"] = load_balancer_json["LoadBalancerId"]

    #添加後端服務器
    load_balancer_json = add_backend_servers(params)
    CommonUtil.log("add_backend_servers", load_balancer_json)

    #創建tcp監聽
    load_balancer_json = create_tcp_listener(params)
    CommonUtil.log("create_tcp_listener", load_balancer_json)

    #刪除後端服務器
    load_balancer_json = remove_backend_servers(params)
    CommonUtil.log("remove_backend_servers", load_balancer_json)

    #刪除slb實例
    #刪除返回的LoadBalancerId對應的SLB實例
    load_balancer_json = delete_load_balancer(load_balancer_json["LoadBalancerId"])
    #打印 load_balancer_json結果
    CommonUtil.log("delete_load_balancer", load_balancer_json)


if __name__ == "__main__":
    sys.exit(main())
  3. 進入setup.py所在的目錄，執行如下命令，完成環境初始化配置。 
    python setup.py install
  4. 進入slb_create_tcp_listener.py所在的目錄，執行如下命令，運行創建TCP監聽示例。 
    python slb_create_tcp_listener.py
    系統顯示類似如下：
    ---------------------------create_load_balancer---------------------------
{
  "VpcId": "",
  "AddressIPVersion": "ipv4",
  "LoadBalancerName": "SLB1",
  "ResourceGroupId": "rg-acfmxazb4pxxxxx",
  "VSwitchId": "",
  "RequestId": "8E72DFDD-E510-4D65-9063-F47B62DE9887",
  "Address": "39.98.xx.xx",
  "NetworkType": "classic",
  "LoadBalancerId": "lb-8vbjd6pzphvjoq29xxxxx"
}

---------------------------add_backend_servers---------------------------
{
  "RequestId": "F6BF0E0B-5837-48A3-9CEC-2EE2CED5293A",
  "BackendServers": {
    "BackendServer": [
      {
        "ServerId": "i-8vbe8yi8krqri2axxxxx",
        "Type": "ecs",
        "Weight": 100
      },
      {
        "ServerId": "i-8vbe8yi8krqri2xxxxxx",
        "Type": "ecs",
        "Weight": 100
      }
    ]
  },
  "LoadBalancerId": "lb-8vbjd6pzphvjoq29xxxxx"
}

---------------------------create_tcp_listener---------------------------
{
  "RequestId": "6FF090BD-DF9F-49C6-84A6-30F2D9F88489"
}

---------------------------remove_backend_servers---------------------------
{
  "RequestId": "F7D62969-D7F0-4022-95FA-1710DA448B6A",
  "BackendServers": {
    "BackendServer": []
  },
  "LoadBalancerId": "lb-8vbjd6pzphvjoq29xxxxx"
}

---------------------------delete_load_balancer---------------------------
{
  "RequestId": "1A8CB48F-8242-49A9-9958-E762B1E9BA4D"
}




更新HTTPS證書

介紹如何使用Python SDK給一個SLB實例創建一個HTTPS監聽，並更新該實例下HTTPS監聽使用的服務器證書。

前提條件

在華北3張家口地域已經有兩臺狀態爲運行中的ECS實例。

背景信息

本次示例分爲以下幾步，爲SLB實例添加HTTPS監聽，更新HTTPS監聽的證書。
  1. 在華北3張家口地域創建一個名爲SLB1的SLB實例，主可用區爲cn-zhangjiakou-a，備可用區爲cn-zhangjiakou-b，實例計費類型爲按量計費，規格爲slb.s1.small，其他配置使用系統默認值。
  2. 將張家口地域的兩臺ECS實例添加到默認服務器組，用來分發流量，ECS實例的後端服務權重都爲100。
  3. 上傳服務器證書。
  4. 創建HTTPS監聽，SLB實例前端使用的端口爲80，後端服務器開放用來接收請求的端口爲443，關閉健康檢查和會話保持，監聽帶寬峯值爲6Mbps，其他使用默認值。
  5. 上傳新的服務器證書。
  6. 更新新建HTTPS監聽的服務器證書。
  7. 刪除新建的SLB實例。

操作步驟

  1. 在下載的SDK目錄中，打開$aliyun-openapi-python-sdk-examples\sdk_examples\examples\slb文件夾。
  2. 使用編輯器打開upload_server_certificate.py文件，您需要配置用戶鑑權參數ACS_CLIENT，其他參數根據實際情況配置後，保存退出。 
    
#encoding=utf-8
import sys
import json

#調用AcsClient參數進行身份驗證
from aliyunsdkcore.client import AcsClient
#使用阿里雲官方sdk的異常處理模塊
from aliyunsdkcore.acs_exception.exceptions import ServerException, ClientException
#調用上傳證書的API
from aliyunsdkslb.request.v20140515 import UploadServerCertificateRequest
#調用創建SLB實例API   
from aliyunsdkslb.request.v20140515 import CreateLoadBalancerRequest
#調用添加默認服務器組API
from aliyunsdkslb.request.v20140515 import AddBackendServersRequest
#調用創建HTTPS監聽的API
from aliyunsdkslb.request.v20140515 import CreateLoadBalancerHTTPSListenerRequest
#調用修改HTTPS監聽的API
from aliyunsdkslb.request.v20140515 import SetLoadBalancerHTTPSListenerAttributeRequest
#調用刪除SLB實例API  
from aliyunsdkslb.request.v20140515 import DeleteLoadBalancerRequest
##異常處理邏輯
from sdk_lib.exception import ExceptionHandler
#命令行導入日誌
from sdk_lib.common_util import CommonUtil

#用戶身份鑑權參數配置
ACS_CLIENT = AcsClient(
    'your-access-key-id',     #your-access-key-id
    'your-access-key-secret',   #your-access-key-secret
    'cn-zhangjiakou',     #your-region-id
)
#失敗重試次數
TRY_TIME = 3
'''
創建slb實例->上傳服務器證書->創建https監聽->上傳新的服務器證書
->循環修改https監聽配置
'''
def create_load_balancer(params):
    '''
    create_load_balancer：創建slb實例
    官網API參考鏈接：https://help.aliyun.com/document_detail/27577.html
    '''
    try:
        #設置創建SLB實例的調用參數
        request = CreateLoadBalancerRequest.CreateLoadBalancerRequest() 
        request.set_MasterZoneId(params["master_zone_id"]) 
        request.set_SlaveZoneId(params["slave_zone_id"]) 
        request.set_LoadBalancerName(params["load_balancer_name"]) 
        request.set_PayType(params["pay_balancer_type"]) 
        #發送調用請求並接收返回數據
        response = ACS_CLIENT.do_action_with_exception(request)
        response_json = json.loads(response)
        #返回結果    
        return response_json
    except ServerException as e:
        ExceptionHandler.server_exception(e)
    except ClientException as e:
        ExceptionHandler.client_exception(e)
        
def add_backend_servers(params):
    '''
    add_backend_servers：添加後端服務器
    官網API參考鏈接: https://help.aliyun.com/document_detail/27632.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
            #設置添加默認服務器組的調用參數
            request = AddBackendServersRequest.AddBackendServersRequest()
            #負載均衡實例的ID
            request.set_LoadBalancerId(params["load_balancer_id"])
            #要添加的後端服務器列表
            request.set_BackendServers(params["backend_servers"])
            #發送調用請求並接收返回數據
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
            #返回結果
            return response_json
        except ServerException as e:
            if ExceptionHandler.server_exception(e):
                return e
        except ClientException as e:
            if ExceptionHandler.client_exception(e):
                return e
        finally:
            counter += 1

def upload_server_certificate(params):
    '''
    upload_server_certificate：上傳服務器證書
    官網API參考鏈接: https://help.aliyun.com/document_detail/34181.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
            request = UploadServerCertificateRequest.UploadServerCertificateRequest()
            #要上傳的公鑰證書
            request.set_ServerCertificate(params["server_certificate"])
            #需要上傳的私鑰
            request.set_PrivateKey(params["private_key"])
            #發送調用請求並接收返回數據
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
            #返回結果
            return response_json
        except ServerException as e:
            ExceptionHandler.server_exception(e)
        except ClientException as e:
            ExceptionHandler.client_exception(e)
        finally:
            counter += 1

def create_https_listener(params):
    '''
    create_https_listener：創建HTTPS監聽
    官網API參考鏈接: https://help.aliyun.com/document_detail/27593.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
            request = CreateLoadBalancerHTTPSListenerRequest.CreateLoadBalancerHTTPSListenerRequest()
            #負載均衡實例的ID
            request.set_LoadBalancerId(params["load_balancer_id"])
            #監聽的帶寬峯值
            request.set_Bandwidth(params["bandwidth"])
            #負載均衡實例前端使用的端口
            request.set_ListenerPort(params["listener_port"])
            #是否開啓健康檢查
            request.set_HealthCheck(params["health_check"])
            #是否開啓會話保持
            request.set_StickySession(params["sticky_session"])
            #負載均衡實例後端使用的端口
            request.set_BackendServerPort(params["backend_server_port"])
            #服務器證書的ID
            request.set_ServerCertificateId(params["server_certificate_id"])
            #發送調用請求並接收返回數據
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
            #返回結果
            return response_json
        except ServerException as e:
            ExceptionHandler.server_exception(e)
        except ClientException as e:
            ExceptionHandler.client_exception(e)
        finally:
            counter += 1

def set_https_listener_attribute(params):
    '''
    set_https_listener_attribute：修改HTTPS監聽的配置
    官網API參考鏈接: https://help.aliyun.com/document_detail/27603.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
            request = SetLoadBalancerHTTPSListenerAttributeRequest.SetLoadBalancerHTTPSListenerAttributeRequest()
            #負載均衡實例的ID
            request.set_LoadBalancerId(params["load_balancer_id"])
            #監聽的帶寬峯值
            request.set_Bandwidth(params["bandwidth"])
            #負載均衡實例前端使用的端口
            request.set_ListenerPort(params["listener_port"])
            #是否開啓健康檢查
            request.set_HealthCheck(params["health_check"])
            #是否開啓會話保持
            request.set_StickySession(params["sticky_session"])
            #服務器證書的ID
            request.set_ServerCertificateId(params["server_certificate_id"])
            #發送調用請求並接收返回數據
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
            #返回結果
            return response_json
        except ServerException as e:
            ExceptionHandler.server_exception(e)
        except ClientException as e:
            ExceptionHandler.client_exception(e)
        finally:
            counter += 1
            
def delete_load_balancer(load_balancer_id):
    '''
    delete_load_balancer：刪除slb實例
    官網API參考鏈接：https://help.aliyun.com/document_detail/27579.html
    '''
    try:
        #設置刪除SLB實例的調用參數
        request = DeleteLoadBalancerRequest.DeleteLoadBalancerRequest()
        #負載均衡實例的ID
        request.set_LoadBalancerId(load_balancer_id)
        #發送調用請求並接收返回數據
        response = ACS_CLIENT.do_action_with_exception(request)
        response_json = json.loads(response)
        #返回結果
        return response_json
    except ServerException as e:
        ExceptionHandler.server_exception(e)
    except ClientException as e:
        ExceptionHandler.client_exception(e)

def main():
    params = {}
    #設置創建SLB實例的參數
    #設置新建SLB實例的主可用區爲cn-zhangjiakou-a 
    params["master_zone_id"] = "cn-zhangjiakou-a" 
    #設置新建SLB實例的主可用區爲cn-zhangjiakou-b 
    params["slave_zone_id"] = "cn-zhangjiakou-b" 
    #設置新建SLB實例的名稱爲SLB1 
    params["load_balancer_name"] = "SLB1"
    #設置新建SLB實例的計費類型爲按量計費
    params["pay_balancer_type"] = "PayOnDemand"

    #設置添加到默認服務器組的ECS的實例ID和權重
    params["backend_servers"] = [{"ServerId":"i-8vbe8yixxxxxxxxxxxxxw","Weight":"100"},{"ServerId":"i-8vbe8yxxxxxxxxxxxxxj9v","Weight":"100"}]
    
    #設置上傳服務器證書的參數
    
    #設置創建HTTPS監聽的參數
    #關閉健康檢查
    params["health_check"] = "off"
    #設置監聽的帶寬峯值
    params["bandwidth"] = 6
    #負載均衡實例前端使用的端口
    params["listener_port"] = 80
    #設置負載均衡實例後端使用的端口
    params["backend_server_port"] = 443
    #關閉會話保持
    params["sticky_session"] = "off"

    #創建slb實例
    #獲取create_load_balancer函數返回值，load_balancer_json爲結果的json串
    load_balancer_json = create_load_balancer(params)
    #打印 load_balancer_json結果，其中"create_load_balancer"是對json串起的名字
    CommonUtil.log("create_load_balancer", load_balancer_json)
    
    #上傳服務器證書
    #要上傳的公鑰證書
    params["server_certificate"] = "-----BEGIN CERTIFICATE-----xxxxxxx-----END CERTIFICATE-----"
    params["private_key"] = "-----BEGIN RSA PRIVATE KEY-----xxxxxxxxxxx-----END RSA PRIVATE KEY-----"
    CommonUtil.log("upload_server_certificate", result_json)
    params["server_certificate_id"] = result_json["ServerCertificateId"]

    #slb實例id
    params["load_balancer_id"] = load_balancer_json["LoadBalancerId"]
    
    #創建https監聽
    result_json = create_https_listener(params)
    CommonUtil.log("create_https_listener", result_json)

    #上傳新的服務器證書
    #要上傳的新公鑰證書
    params["server_certificate"] = "-----BEGIN CERTIFICATE-----xxxxxxx-----END CERTIFICATE-----"
    params["private_key"] = "-----BEGIN RSA PRIVATE KEY-----xxxxxxxxxxx-----END RSA PRIVATE KEY-----"
    result_json = upload_server_certificate(params)
    CommonUtil.log("upload_server_certificate", result_json)
    #
    params["server_certificate_id"] = result_json["ServerCertificateId"]

    #修改https監聽配置
    result_json = set_https_listener_attribute(params)
    CommonUtil.log("set_https_listener_attribute", result_json)

    #刪除slb實例
    #刪除返回的LoadBalancerId對應的SLB實例
    load_balancer_json = delete_load_balancer(load_balancer_json["LoadBalancerId"])
    #打印 load_balancer_json結果
    CommonUtil.log("delete_load_balancer", load_balancer_json)

if __name__ == "__main__":
    sys.exit(main())
  3. 進入setup.py所在的目錄，執行如下命令，完成環境初始化配置。 
    python setup.py install
  4. 進入upload_server_certificate.py所在的目錄，執行如下命令，運行更新HTTPS證書示例。 
    python upload_server_certificate.py
    系統顯示類似如下：
    ---------------------------create_load_balancer---------------------------
{
  "VpcId": "",
  "AddressIPVersion": "ipv4",
  "LoadBalancerName": "SLB1",
  "ResourceGroupId": "rg-axxxxxxxxxxxy",
  "VSwitchId": "",
  "RequestId": "1DEF72EE-CA5C-449D-9E97-2CE460DE7F7A",
  "Address": "39.98.97.8",
  "NetworkType": "classic",
  "LoadBalancerId": "lb-8vxxxxxxxxxxxf"
}

---------------------------upload_server_certificate---------------------------
{
  "ExpireTimeStamp": 1732169065000,
  "RegionIdAlias": "cn-zhangjiakou",
  "AliCloudCertificateName": "",
  "RegionId": "cn-zhangjiakou",
  "CommonName": "test",
  "ServerCertificateName": "test",
  "ExpireTime": "2024-11-21T06:04:25Z",
  "ResourceGroupId": "rg-axxxxxxxxxxxyy",
  "RequestId": "D6FB8B7C-B0EA-43E7-AD8F-E0201A9E1A13",
  "Fingerprint": "cd:90:1b:7b:49:4d:1d:90:f6:01:de:9a:81:7d:31:a7:38:1d:84:8d",

  "AliCloudCertificateId": "",
  "IsAliCloudCertificate": 0,
  "ServerCertificateId": "12xxxxxxxxxxxx3_16xxxxxxxxxx6_-1xxxxxxxx13_-1xxxxxx72"
}

---------------------------create_https_listener---------------------------
{
  "RequestId": "FC70EDC8-06EC-4E1C-97BE-D81571DA23B4"
}

---------------------------upload_server_certificate---------------------------
{
  "ExpireTimeStamp": 1567857600000,
  "RegionIdAlias": "cn-zhangjiakou",
  "AliCloudCertificateName": "",
  "RegionId": "cn-zhangjiakou",
  "CommonName": "doc.aliyun-slb.top",
  "ServerCertificateName": "doc.aliyun-slb.top",
  "ExpireTime": "2019-09-07T12:00:00Z",
  "ResourceGroupId": "rg-acxxxxxxxxxxxxy",
  "RequestId": "913E991F-BCC9-4A3D-9802-19084E2CE271",
  "Fingerprint": "8c:47:1b:a7:8f:02:27:3a:35:7c:e3:47:4a:5f:55:02:ed:e3:57:1e",

  "SubjectAlternativeNames": {
    "SubjectAlternativeName": [
      "doc.aliyun-slb.top"
    ]
  },
  "AliCloudCertificateId": "",
  "IsAliCloudCertificate": 0,
  "ServerCertificateId": "12xxxxxxxxxxxx3_16xxxxxxx716_4xxxxxxx4_-14xxxxxxxxxx9"
}

---------------------------set_https_listener_attribute-------------------------
--
{
  "RequestId": "14275D2B-20F2-4D96-9FC8-7BB2B110155C"
}

---------------------------delete_load_balancer---------------------------
{
  "RequestId": "2A1DF87C-842A-4C1E-AA61-23EB365EB86F"
}



查看監控

介紹如何使用Python SDK查看SLB實例的監控參數並配置告警。

前提條件

在華北3張家口地域已經有兩臺狀態爲運行中的ECS實例。

背景信息

本次示例分爲以下幾步，查看新建SLB實例的監控參數並設置告警：
  1. 在華北3張家口地域新建一個名爲SLB1的按量付費實例，主可用區爲cn-zhangjiakou-a，備可用區爲cn-zhangjiakou-b。
  2. 爲新建SLB實例創建一個TCP監聽，SLB實例前端使用的端口爲80，後端服務器開放用來接收請求的端口爲80，健康檢查協議爲TCP，將張家口地域的兩臺ECS實例添加到默認服務器組，用來分發流量，ECS實例的後端服務權重都爲100。
  3. 查詢新建SLB實例QPS使用率。
  4. 創建告警，當新建SLB實例QPS使用率平均值大於等於35時，發起告警。
  5. 刪除新建實例。

操作步驟

  1. 在下載的SDK目錄中，打開$aliyun-openapi-python-sdk-examples\sdk_examples\examples\slb文件夾。
  2. 使用編輯器打開slb_monitor.py文件，您需要配置用戶鑑權參數ACS_CLIENT，其他參數根據實際情況配置後，保存退出。 
    #encoding=utf-8
import sys
import json

#調用AcsClient參數進行身份驗證
from aliyunsdkcore.client import AcsClient
#使用阿里雲官方sdk的異常處理模塊
from aliyunsdkcore.acs_exception.exceptions import ServerException, ClientException
#異常處理邏輯
from sdk_lib.exception import ExceptionHandler
#調用創建SLB實例API   
from aliyunsdkslb.request.v20140515 import CreateLoadBalancerRequest
#調用添加默認服務器組API
from aliyunsdkslb.request.v20140515 import AddBackendServersRequest
#調用添加TCP監聽API
from aliyunsdkslb.request.v20140515 import CreateLoadBalancerTCPListenerRequest
#調用雲監控的接口查看SLB的最新監控數據
from aliyunsdkcms.request.v20180308 import QueryMetricLastRequest
#調用雲監控的接口爲SLB實例創建報警規則
from aliyunsdkcms.request.v20180308 import CreateAlarmRequest
#調用刪除SLB實例API  
from aliyunsdkslb.request.v20140515 import DeleteLoadBalancerRequest
#命令行導入日誌
from sdk_lib.common_util import CommonUtil

#用戶身份驗證參數配置
ACS_CLIENT = AcsClient(
    'your-access-key-id',     #your-access-key-id
    'your-access-key-secret',   #your-access-key-secret
    'cn-zhangjiakou',     #your-region-id
)
#失敗重試次數
TRY_TIME = 3

'''
創建slb實例->創建tcp監聽->創建後端服務器->
查詢slb實例端口當前併發連接數->創建告警規則
'''

def create_load_balancer(params):
    '''
    create_load_balancer：創建slb實例
    官網API參考鏈接：https://help.aliyun.com/document_detail/27577.html
    '''
    try:
        #設置創建SLB實例的調用參數
	request = CreateLoadBalancerRequest.CreateLoadBalancerRequest() 
	request.set_MasterZoneId(params["master_zone_id"]) 
	request.set_SlaveZoneId(params["slave_zone_id"]) 
	request.set_LoadBalancerName(params["load_balancer_name"]) 
	request.set_PayType(params["pay_balancer_type"]) 
	#發送調用請求並接收返回數據
	response = ACS_CLIENT.do_action_with_exception(request)
	response_json = json.loads(response)
	#返回結果	
	return response_json
    except ServerException as e:
        ExceptionHandler.server_exception(e)
    except ClientException as e:
        ExceptionHandler.client_exception(e)
		
def add_backend_servers(params):
    '''
    add_backend_servers：添加後端服務器
    官網API參考鏈接: https://help.aliyun.com/document_detail/27632.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
            #設置添加默認服務器組的調用參數
            request = AddBackendServersRequest.AddBackendServersRequest()
            #負載均衡實例的ID
            request.set_LoadBalancerId(params["load_balancer_id"])
            #要添加的後端服務器列表
            request.set_BackendServers(params["backend_servers"])
	    #發送調用請求並接收返回數據
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
	    #返回結果
            return response_json
        except ServerException as e:
            if ExceptionHandler.server_exception(e):
                return e
        except ClientException as e:
            if ExceptionHandler.client_exception(e):
                return e
        finally:
            counter += 1

def create_tcp_listener(params):
    '''
    create_tcp_listener：創建tcp監聽
    官網API參考鏈接: https://help.aliyun.com/document_detail/27594.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
	    #設置創建TCP監聽的調用參數
            request = CreateLoadBalancerTCPListenerRequest.CreateLoadBalancerTCPListenerRequest()
            #負載均衡實例的ID
            request.set_LoadBalancerId(params["load_balancer_id"])
	    #負載均衡實例前端使用的端口
            request.set_ListenerPort(params["listener_port"])
            #負載均衡實例後端使用的端口
            request.set_BackendServerPort(params["backend_server_port"])
	    #監聽的健康檢查協議
            request.set_HealthCheckType(params["listener_health_check"])
	    #設置監聽的帶寬峯值
            request.set_Bandwidth(params["listener_bandwidth"])
	    #發送調用請求並接收返回數據
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
	    #返回結果
            return response_json
        except ServerException as e:
            if ExceptionHandler.server_exception(e):
                return e
        except ClientException as e:
            if ExceptionHandler.client_exception(e):
                return e
        finally:
            counter += 1

def query_metric_last(params):
    '''
    query_metric_last：查詢指定監控對象的最新監控數據
    官網API參考鏈接: https://help.aliyun.com/document_detail/51939.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
            request = QueryMetricLastRequest.QueryMetricLastRequest()
            #名字空間，表明監控數據所屬產品
            request.set_Project(params["project"])
            #監控項名稱
            request.set_Metric(params["metric_name"])
            #過濾項
            request.set_Dimensions(params['dimensions'])
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
            return response_json
        except ServerException as e:
            ExceptionHandler.server_exception(e)
        except ClientException as e:
            ExceptionHandler.client_exception(e)
        finally:
            counter += 1

def create_alarm(params):
    '''
    create_alarm：創建報警規則，可以爲某一個實例創建報警規則，也可以爲多個實例同時創建報警規則
    官網API參考鏈接: https://help.aliyun.com/document_detail/51910.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
            request = CreateAlarmRequest.CreateAlarmRequest()

            #產品名稱，參考各產品對應的project
            request.set_Namespace(params["name_space"])
            #報警規則名稱
            request.set_Name(params["name"])
            #相應產品對應的監控項名稱，參考各產品metric定義
            request.set_MetricName(params["metric_name"])
            #報警規則對應實例列表
            request.set_Dimensions(params["dimensions"])
            #統計方法，必須與定義的metric一致
            request.set_Statistics(params["statistics"])
            #報警比較符
            request.set_ComparisonOperator(params["comparison_operator"])
            #報警閾值，目前只開放數值類型功能
            request.set_Threshold(params["threshold"])
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
            return response_json
        except ServerException as e:
            ExceptionHandler.server_exception(e)
        except ClientException as e:
            ExceptionHandler.client_exception(e)
        finally:
            counter += 1
			
def delete_load_balancer(load_balancer_id):
    '''
    delete_load_balancer：刪除slb實例
    官網API參考鏈接：https://help.aliyun.com/document_detail/27579.html
    '''
    try:
	#設置刪除SLB實例的調用參數
        request = DeleteLoadBalancerRequest.DeleteLoadBalancerRequest()
        #負載均衡實例的ID
        request.set_LoadBalancerId(load_balancer_id)
        #發送調用請求並接收返回數據
        response = ACS_CLIENT.do_action_with_exception(request)
        response_json = json.loads(response)
	#返回結果
        return response_json
    except ServerException as e:
        ExceptionHandler.server_exception(e)
    except ClientException as e:
        ExceptionHandler.client_exception(e)

def main():
    params = {}
    #設置創建SLB實例的參數
    #設置新建SLB實例的主可用區爲cn-zhangjiakou-a 
    params["master_zone_id"] = "cn-zhangjiakou-a" 
    #設置新建SLB實例的主可用區爲cn-zhangjiakou-b 
    params["slave_zone_id"] = "cn-zhangjiakou-b" 
    #設置新建SLB實例的名稱爲SLB1 
    params["load_balancer_name"] = "SLB1"
    #設置新建SLB實例的計費類型爲按量計費
    params["pay_balancer_type"] = "PayOnDemand"

    #設置添加到默認服務器組的ECS的實例ID和權重
    params["backend_servers"] = [{"ServerId":"i-8vbe8xxxxxxxxxxxw","Weight":"100"},{"ServerId":"i-8vbe8yixxxxxxxxxxxxv","Weight":"100"}]

    #設置添加TCP監聽的參數
    #前端使用的端口爲80
    params["listener_port"] = 80
    #後端服務器開放用來接收請求的端口爲80
    params["backend_server_port"] = 80
    #健康檢查協議爲TCP
    params["listener_health_check"] = "tcp"
    #TCP監聽的帶寬峯值爲-1，即不限制帶寬峯值
    params["listener_bandwidth"] = -1
	
    #設置查詢監控項的參數
    #設置監控數據所屬產品
    params["project"] = "acs_slb_dashboard"
    #設置監控項名稱
    params["traffic_tx_new"] = "InstanceQpsUtilization"
	
    #設置創建告警的參數
    #設置告警規則所屬產品
    params["name_space"] = "acs_slb_dashboard"
    #設置告警規則名稱
    params["name"] = "slb_alarm"
    #設置告警中SLB對應的監控項名稱
    params["metric_name"] = "InstanceQpsUtilization"
    #設置統計方法
    params["statistics"] = "Average"
    #設置報警比較符
    params["comparison_operator"] = ">="
    #設置報警閾值
    params["threshold"] = 35
	
	
    #創建slb實例
    #獲取create_load_balancer函數返回值，load_balancer_json爲結果的json串
    load_balancer_json = create_load_balancer(params)
    #打印 load_balancer_json結果，其中"create_load_balancer"是對json串起的名字
    CommonUtil.log("create_load_balancer", load_balancer_json)

    #slb實例id
    params["load_balancer_id"] = load_balancer_json["LoadBalancerId"]

    #創建tcp監聽
    result_json = create_tcp_listener(params)
    CommonUtil.log("create_tcp_listener", result_json)

    #創建後端服務器
    result_json = add_backend_servers(params)
    CommonUtil.log("add_backend_servers", result_json)

    #查詢slb實例QPS使用率
    params["dimensions"] = '[{"instanceId":"' + load_balancer_json["LoadBalancerId"] + '"}]'
    result_json = query_metric_last(params)
    CommonUtil.log("query_metric_last", result_json)

    #創建告警規則
    params["metric_name"] = "InstanceQpsUtilization"
    result_json = create_alarm(params)
    CommonUtil.log("create_alarm", result_json)

    #刪除slb實例
    #刪除返回的LoadBalancerId對應的SLB實例
    load_balancer_json = delete_load_balancer(load_balancer_json["LoadBalancerId"])
    #打印 load_balancer_json結果
    CommonUtil.log("delete_load_balancer", load_balancer_json)

if __name__ == "__main__":
    sys.exit(main())
  3. 進入setup.py所在的目錄，執行如下命令，完成環境初始化配置。 
    python setup.py install
  4. 進入slb_monitor.py所在的目錄，執行如下命令，運行查看監控示例。 
    python slb_monitor.py
    系統顯示類似如下：
    ---------------------------create_load_balancer---------------------------
{
  "VpcId": "",
  "AddressIPVersion": "ipv4",
  "LoadBalancerName": "SLB1",
  "ResourceGroupId": "rg-axxxxxxxxxx",
  "VSwitchId": "",
  "RequestId": "661DDF49-FD2B-46C1-8E38-FDE5E62C8448",
  "Address": "39.xx.xx.xx4",
  "NetworkType": "classic",
  "LoadBalancerId": "lb-8vbtxxxxxxxxxxx1hn"
}

---------------------------create_tcp_listener---------------------------
{
  "RequestId": "7ED453FF-7DF6-4F4F-81A0-670EED9EB997"
}

---------------------------add_backend_servers---------------------------
{
  "RequestId": "4B730606-BD44-4A6B-BE9E-118E9606B064",
  "BackendServers": {
    "BackendServer": [
      {
        "ServerId": "i-8xxxxxxxxxxf4z",
        "Type": "ecs",
        "Weight": 100
      },
      {
        "ServerId": "i-8xxxxxxxxxxxxx",
        "Type": "ecs",
        "Weight": 100
      }
    ]
  },
  "LoadBalancerId": "lb-8xxxxxxxxxxxxxx"
}

---------------------------query_metric_last---------------------------
{
  "Code": "200",
  "Period": "60",
  "RequestId": "15FD2461-FD94-451F-ABE3-D281DB453161",
  "Datapoints": "[]"
}

---------------------------create_alarm---------------------------
{
  "Code": "200",
  "Data": "53547DF14168E368073BE8E34E1522DE25854224",
  "RequestId": "8652E53F-74AD-413B-B2D9-103BFE557FAC",
  "Success": true
}

---------------------------delete_load_balancer---------------------------
{
  "RequestId": "D6CCD259-41C2-4D5C-A644-19A0E96F1D4C"
}

克隆實例

介紹如何使用Python SDK克隆SLB實例。

前提條件

在華北3張家口地域已經有兩臺狀態爲運行中的ECS實例。

背景信息

本次示例分爲以下幾步，克隆SLB實例：
  1. 在華北3張家口地域創建一個名爲SLB1的SLB實例，主可用區爲cn-zhangjiakou-a，備可用區爲cn-zhangjiakou-b，實例計費類型爲按量計費，規格爲slb.s1.small，其他配置使用系統默認值。
  2. 將張家口地域的兩臺ECS實例添加到默認服務器組，用來分發流量，ECS實例的後端服務權重都爲100。
  3. 創建TCP監聽，SLB實例前端使用的端口爲80，後端服務器開放用來接收請求的端口爲80，健康檢查協議爲TCP，不限制監聽帶寬峯值，其他使用默認值。
  4. 查詢實例SLB1的信息，作爲克隆實例的入參。
  5. 克隆新的SLB實例。
  6. 刪除SLB1實例。
  7. 查詢克隆實例的信息。
  8. 刪除克隆實例。

操作步驟

  1. 在下載的SDK目錄中，打開$aliyun-openapi-python-sdk-examples\sdk_examples\examples\slb文件夾。
  2. 使用編輯器打開configration_clone.py文件，您需要配置用戶鑑權參數ACS_CLIENT，其他參數根據實際情況配置後，保存退出。 
    #encoding=utf-8
import sys
import json


#調用AcsClient參數進行身份驗證
from aliyunsdkcore.client import AcsClient
#使用阿里雲官方sdk的異常處理模塊
from aliyunsdkcore.acs_exception.exceptions import ServerException, ClientException
#命令行打印日誌
from sdk_lib.common_util import CommonUtil
#異常處理邏輯
from sdk_lib.exception import ExceptionHandler
#調用創建SLB實例API   
from aliyunsdkslb.request.v20140515 import CreateLoadBalancerRequest
#調用添加默認服務器組API
from aliyunsdkslb.request.v20140515 import AddBackendServersRequest
#調用添加TCP監聽API
from aliyunsdkslb.request.v20140515 import CreateLoadBalancerTCPListenerRequest
#調用查詢SLB實例信息API
from aliyunsdkslb.request.v20140515 import DescribeLoadBalancerAttributeRequest
#調用創建SLB實例API克隆實例
from aliyunsdkslb.request.v20140515 import CreateLoadBalancerRequest
#調用刪除SLB實例API  
from aliyunsdkslb.request.v20140515 import DeleteLoadBalancerRequest

'''
創建slb實例->添加tcp監聽->查詢slb實例->slb實例克隆->刪除slb實例
'''

#用戶身份驗證參數配置
ACS_CLIENT = AcsClient(
    'your-access-key-id',     #your-access-key-id
    'your-access-key-secret',   #your-access-key-secret
    'cn-zhangjiakou',     #your-region-id
)
#失敗重試次數
TRY_TIME = 3

def create_load_balancer(params):
    '''
    create_load_balancer：創建slb實例
    官網API參考鏈接：https://help.aliyun.com/document_detail/27577.html
    '''
    try:
	#設置創建SLB實例的調用參數
	request = CreateLoadBalancerRequest.CreateLoadBalancerRequest() 
	request.set_MasterZoneId(params["master_zone_id"]) 
	request.set_SlaveZoneId(params["slave_zone_id"]) 
	request.set_LoadBalancerName(params["load_balancer_name"]) 
	request.set_PayType(params["pay_balancer_type"]) 
	request.set_LoadBalancerSpec(params["load_balancer_spec"]) 
	#發送調用請求並接收返回數據
	response = ACS_CLIENT.do_action_with_exception(request)
	response_json = json.loads(response)
	#返回結果	
	return response_json
    except ServerException as e:
        ExceptionHandler.server_exception(e)
    except ClientException as e:
        ExceptionHandler.client_exception(e)
		
def add_backend_servers(params):
    '''
    add_backend_servers：添加後端服務器
    官網API參考鏈接: https://help.aliyun.com/document_detail/27632.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
	    #設置添加默認服務器組的調用參數
            request = AddBackendServersRequest.AddBackendServersRequest()
            #負載均衡實例的ID
            request.set_LoadBalancerId(params["load_balancer_id"])
            #要添加的後端服務器列表
            request.set_BackendServers(params["backend_servers"])
	    #發送調用請求並接收返回數據
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
	    #返回結果
            return response_json
        except ServerException as e:
            if ExceptionHandler.server_exception(e):
                return e
        except ClientException as e:
            if ExceptionHandler.client_exception(e):
                return e
        finally:
            counter += 1

def create_tcp_listener(params):
    '''
    create_tcp_listener：創建tcp監聽
    官網API參考鏈接: https://help.aliyun.com/document_detail/27594.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
            #設置創建TCP監聽的調用參數
            request = CreateLoadBalancerTCPListenerRequest.CreateLoadBalancerTCPListenerRequest()
            #負載均衡實例的ID
            request.set_LoadBalancerId(params["load_balancer_id"])
	    #負載均衡實例前端使用的端口
            request.set_ListenerPort(params["listener_port"])
            #負載均衡實例後端使用的端口
            request.set_BackendServerPort(params["backend_server_port"])
	    #監聽的健康檢查協議
            request.set_HealthCheckType(params["listener_health_check"])
	    #設置監聽的帶寬峯值
            request.set_Bandwidth(params["listener_bandwidth"])
	    #發送調用請求並接收返回數據
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
	    #返回結果
            return response_json
        except ServerException as e:
            if ExceptionHandler.server_exception(e):
                return e
        except ClientException as e:
            if ExceptionHandler.client_exception(e):
                return e
        finally:
            counter += 1

#查詢slb實例
def describe_load_balancer_attribute(params):
    '''
    describe_load_balancer_attribute：查詢指定負載均衡實例的詳細信息
    官網API參考鏈接: https://help.aliyun.com/document_detail/27583.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
            request = DescribeLoadBalancerAttributeRequest.DescribeLoadBalancerAttributeRequest()
            #負載均衡實例的id
            request.set_LoadBalancerId(params["load_balancer_id"])
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
            return response_json
        except ServerException as e:
            ExceptionHandler.server_exception(e)
        except ClientException as e:
            ExceptionHandler.client_exception(e)
        finally:
            counter += 1

#克隆slb實例
def create_load_balancer_clone(params):
    '''
    create_load_balancer：創建slb實例
    官網API參考鏈接：https://help.aliyun.com/document_detail/27577.html
    '''
    counter = 0
    while counter < TRY_TIME:
        try:
            request = CreateLoadBalancerRequest.CreateLoadBalancerRequest()
            #主可用區
            request.set_MasterZoneId(params["master_zone_id"])
            #備可用區
            request.set_SlaveZoneId(params["slave_zone_id"])
            #付費類型
            request.set_PayType(params["pay_balancer_type"])
            #資源組id
            request.set_ResourceGroupId(params["resource_group_id"])
            #負載均衡實例的ip版本
            request.set_AddressIPVersion(params["address_ip_version"])
            #負載均衡實例的網絡類型
            request.set_AddressType(params["address_type"])
            #實例名稱
            request.set_LoadBalancerName(params["load_balancer_name"])
            response = ACS_CLIENT.do_action_with_exception(request)
            response_json = json.loads(response)
            return response_json
        except ServerException as e:
            ExceptionHandler.server_exception(e)
        except ClientException as e:
            ExceptionHandler.client_exception(e)
        finally:
            counter += 1
def delete_load_balancer(load_balancer_id):
    '''
    delete_load_balancer：刪除slb實例
    官網API參考鏈接：https://help.aliyun.com/document_detail/27579.html
    '''
    try:
	#設置刪除SLB實例的調用參數
        request = DeleteLoadBalancerRequest.DeleteLoadBalancerRequest()
        #負載均衡實例的ID
        request.set_LoadBalancerId(load_balancer_id)
        #發送調用請求並接收返回數據
        response = ACS_CLIENT.do_action_with_exception(request)
        response_json = json.loads(response)
	#返回結果
        return response_json
    except ServerException as e:
        ExceptionHandler.server_exception(e)
    except ClientException as e:
        ExceptionHandler.client_exception(e)

def main():
    params = {}
    #設置創建SLB實例的參數
    #設置新建SLB實例的主可用區爲cn-zhangjiakou-a 
    params["master_zone_id"] = "cn-zhangjiakou-a" 
    #設置新建SLB實例的主可用區爲cn-zhangjiakou-b 
    params["slave_zone_id"] = "cn-zhangjiakou-b" 
    #設置新建SLB實例的名稱爲SLB1 
    params["load_balancer_name"] = "SLB1"
    #設置新建SLB實例的計費類型爲按量計費
    params["pay_balancer_type"] = "PayOnDemand"
    #設置新建SLB實例的規格爲slb.s1.small
    params["load_balancer_spec"] = "slb.s1.small"
	
    #設置添加到默認服務器組的ECS的實例ID和權重
    params["backend_servers"] = [{"ServerId":"i-8vxxxxx","Weight":"100"},{"ServerId":"i-8vbe8xxxxxxxv","Weight":"100"}]
	
    #設置添加TCP監聽的參數
    #前端使用的端口爲80
    params["listener_port"] = 80
    #後端服務器開放用來接收請求的端口爲80
    params["backend_server_port"] = 80
    #健康檢查協議爲TCP
    params["listener_health_check"] = "tcp"
    #TCP監聽的帶寬峯值爲-1，即不限制帶寬峯值
    params["listener_bandwidth"] = -1

    #創建slb實例
    #獲取create_load_balancer函數返回值，load_balancer_json爲結果的json串
    result_json = create_load_balancer(params)
    #打印 load_balancer_json結果，其中"create_load_balancer"是對json串起的名字
    CommonUtil.log("create_load_balancer", result_json)
    
    #讀取新建SLB實例的ID和名稱
    load_balancer_id = result_json["LoadBalancerId"]
    params["load_balancer_id"] = load_balancer_id
    params["LoadBalancerName"] = result_json["LoadBalancerName"]

    #創建tcp監聽
    result_json = create_tcp_listener(params)
    CommonUtil.log("create_tcp_listener", result_json)

    #查詢slb實例
    result_json = describe_load_balancer_attribute(params)
    CommonUtil.log("describe_load_balancer_attribute", result_json)
    #需要顯示的查詢新建SLB實例信息
    params["master_zone_id"] = result_json["MasterZoneId"]
    params["slave_zone_id"] = result_json["SlaveZoneId"]
    params["pay_balancer_type"] = result_json["PayType"]
    params["resource_group_id"] = result_json["ResourceGroupId"]
    params["address_ip_version"] = result_json["AddressIPVersion"]
    params["address_type"] = result_json["AddressType"]
    params["load_balancer_name"] = result_json["LoadBalancerName"]
	
    #根據SLB1的配置，克隆一個新的實例
    result_json = create_load_balancer_clone(params)
    CommonUtil.log("create_load_balancer_clone", result_json)
	
    #讀取克隆實例ID
    clone_load_balancer_id = result_json["LoadBalancerId"]
	
    #刪除第一個實例
    #刪除返回的LoadBalancerId對應的SLB實例
    result_json = delete_load_balancer(load_balancer_id)
    #打印 load_balancer_json結果
    CommonUtil.log("delete_load_balancer", result_json)
	
    #查詢克隆出來的實例信息
    params["load_balancer_id"] = clone_load_balancer_id
    result_json = describe_load_balancer_attribute(params)
    CommonUtil.log("describe_load_balancer_attribute", result_json)
	

    #刪除克隆出來的實例
    #刪除返回的LoadBalancerId對應的SLB實例
    result_json = delete_load_balancer(clone_load_balancer_id)
    #打印 load_balancer_json結果
    CommonUtil.log("delete_load_balancer", result_json)

if __name__ == "__main__":
    sys.exit(main())
  3. 進入setup.py所在的目錄，執行如下命令，完成環境初始化配置。 
    python setup.py install
  4. 進入configration_clone.py所在的目錄，執行如下命令，運行克隆實例示例。 
    python configration_clone.py
    系統顯示類似如下：
    ---------------------------create_load_balancer---------------------------
{
  "VpcId": "",
  "AddressIPVersion": "ipv4",
  "LoadBalancerName": "SLB1",
  "ResourceGroupId": "rg-acfxxxxxxxxxxy",
  "VSwitchId": "",
  "RequestId": "544656CD-4DC9-47CB-B4DA-9371C0098F37",
  "Address": "39.xx.xx.xx",
  "NetworkType": "classic",
  "LoadBalancerId": "lb-8vbermxxxxxxxxx90l"
}

---------------------------create_tcp_listener---------------------------
{
  "RequestId": "4FCAFA1B-A6A8-4AA7-AB26-788C4F1506DA"
}

---------------------------describe_load_balancer_attribute---------------------
------
{
  "LoadBalancerStatus": "inactive",
  "HasReservedInfo": "false",
  "InternetChargeType": "paybytraffic",
  "EndTime": "2999-09-08T16:00:00Z",
  "VpcId": "",
  "RegionIdAlias": "cn-zhangjiakou",
  "RegionId": "cn-zhangjiakou",
  "ListenerPortsAndProtocal": {
    "ListenerPortAndProtocal": [
      {
        "ListenerPort": 80,
        "ListenerProtocal": "tcp"
      }
    ]
  },
  "ResourceGroupId": "rg-acfxxxxxxxaiy",
  "CreateTimeStamp": 1551254179000,
  "VSwitchId": "",
  "Address": "39.98.97.43",
  "AddressIPVersion": "ipv4",
  "LoadBalancerSpec": "slb.s1.small",
  "EndTimeStamp": 32493801600000,
  "ListenerPortsAndProtocol": {
    "ListenerPortAndProtocol": [
      {
        "ListenerProtocol": "tcp",
        "ListenerPort": 80
      }
    ]
  },
  "LoadBalancerId": "lb-8vxxxxxxxxxx90l",
  "AddressType": "internet",
  "RequestId": "9D696BEF-18C2-4EFD-92F4-434580964A51",
  "BackendServers": {
    "BackendServer": []
  },
  "MasterZoneId": "cn-zhangjiakou-a",
  "PayType": "PayOnDemand",
  "SlaveZoneId": "cn-zhangjiakou-b",
  "Bandwidth": 5120,
  "LoadBalancerName": "SLB1",
  "NetworkType": "classic",
  "CreateTime": "2019-02-27T07:56:19Z",
  "ListenerPorts": {
    "ListenerPort": [
      80
    ]
  }
}

---------------------------create_load_balancer_clone---------------------------

{
  "VpcId": "",
  "AddressIPVersion": "ipv4",
  "LoadBalancerName": "SLB1",
  "ResourceGroupId": "rg-acxxxxxxxxxxiy",
  "VSwitchId": "",
  "RequestId": "0E051B90-1C32-4270-A653-F7FBB03E3E5C",
  "Address": "xx.xx.xx.xx",
  "NetworkType": "classic",
  "LoadBalancerId": "lb-8xxxxxxxxxxxxxx"
}

---------------------------delete_load_balancer---------------------------
{
  "RequestId": "14703145-BC19-4032-A5F5-6DD49AED6885"
}

---------------------------describe_load_balancer_attribute---------------------
------
{
  "LoadBalancerStatus": "active",
  "HasReservedInfo": "false",
  "InternetChargeType": "paybytraffic",
  "EndTime": "2999-09-08T16:00:00Z",
  "VpcId": "",
  "RegionIdAlias": "cn-zhangjiakou",
  "RegionId": "cn-zhangjiakou",
  "ListenerPortsAndProtocal": {
    "ListenerPortAndProtocal": []
  },
  "ResourceGroupId": "rg-acfxxxxxxxxxiy",
  "CreateTimeStamp": 1551254182000,
  "VSwitchId": "",
  "Address": "39.98.97.36",
  "AddressIPVersion": "ipv4",
  "MasterZoneId": "cn-zhangjiakou-a",
  "EndTimeStamp": 32493801600000,
  "ListenerPortsAndProtocol": {
    "ListenerPortAndProtocol": []
  },
  "LoadBalancerId": "lb-8vxxxxxxxxxxx",
  "AddressType": "internet",
  "RequestId": "6345BAD4-B7EB-4280-9C7B-BB1324A77E32",
  "BackendServers": {
    "BackendServer": []
  },
  "PayType": "PayOnDemand",
  "SlaveZoneId": "cn-zhangjiakou-b",
  "Bandwidth": 5120,
  "LoadBalancerName": "SLB1",
  "NetworkType": "classic",
  "CreateTime": "2019-02-27T07:56:22Z",
  "ListenerPorts": {
    "ListenerPort": []
  }
}

---------------------------delete_load_balancer---------------------------
{
  "RequestId": "DC7C11D0-E21E-49AE-9695-F0171960D0F1"
}




發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

Python網絡爬蟲的時候json=就是讓你少寫個json.dumps()

大家好，我是皮皮。 一、前言 前幾天在Python白銀交流羣【空翼】問了一個Python網絡爬蟲的問題，提問截圖如下： 登錄請求地址是這個： 二、實現過程 這裏【甯同學】給了一個提示，如下所示： 估計很多小夥伴和我一樣會有一個疑問吧，

原創 2024-05-29 10:02:33

記錄一次cnvd事件型證書漏洞挖掘

事件起因是因爲要搞畢設了，在爲這個苦惱，突然負責畢設的老師說得到cnvd下發的證書結合你的漏洞挖掘的過程是可以當成畢設的，當時又學習了一段時間的web滲透方面的知識，於是踏上了廢寢忘食的cnvd證書漏洞挖掘的日子。 前言：聽羣友們說，一般可

原創 2024-05-28 11:16:19

【終極指南】使用Python可視化分析文本情感傾向

本文分享自華爲雲社區《Python理解文本情感傾向的終極指南》，作者： 檸檬味擁抱。 情感分析是一種通過自然語言處理技術來識別、提取和量化文本中的情感傾向的方法。Python在這一領域有着豐富的庫和工具，如NLTK、TextBlob和VAD

原創 2024-05-28 10:58:03

今天！通義靈碼在北京、成都、杭州三城開講啦

通義靈碼自從入職阿里雲以來備受行業關注。5 月 24 日，阿里雲工程師奔赴北京、成都、杭州三城，向企業和開發者介紹並演示通義靈碼，通義靈碼依然是大家話題的C位，並收穫了衆多粉絲。 @杭州 阿里雲金融創新峯會 今天，2024 阿里雲金融創新峯

原創 2024-05-27 21:13:46

解讀注意力機制原理，教你使用Python實現深度學習模型

本文分享自華爲雲社區《使用Python實現深度學習模型：注意力機制（Attention）》，作者：Echo_Wish。 在深度學習的世界裏，注意力機制（Attention Mechanism）是一種強大的技術，被廣泛應用於自然語言處理（NL

原創 2024-05-27 10:58:44

安裝筆記本應用商店的pycharm，再安排pandas等模塊，說是沒有打包工具?

大家好，我是Python進階者。 一、前言 前幾天在Python最強王者交流羣【斌】問了一個Python庫安裝的問題。 求教大佬：華爲筆記本，麒麟系統，安裝筆記本應用商店的pycharm，再安排pandas等模塊，說是沒有打包工具，再安裝

原創 2024-05-25 10:02:28

從入門到精通：掌握Scrapy框架的關鍵技巧

在當今信息爆炸的時代，獲取並利用網絡數據成爲了許多行業的核心競爭力之一。而作爲一名數據分析師、網絡研究者或者是信息工作者，要想獲取網絡上的大量數據，離不開網絡爬蟲工具的幫助。而Scrapy框架作爲Python語言中最爲強大的網絡爬蟲框架之

原創 2024-05-25 00:09:06

面向AI的開發：從大模型（LLM）、檢索增強生成（RAG）到智能體（Agent）的應用

引言 隨着人工智能技術的飛速發展，大型語言模型（LLM）、檢索增強生成（RAG）和智能體（Agent）已經成爲推動該領域進步的關鍵技術，這些技術不僅改變了我們與機器的交互方式，而且爲各種應用和服務的開發提供了前所未有的可能性。正確理解這三者

原創 2024-05-24 23:57:39

對話阿里云云原生產品負責人李國強：推進可觀測產品與OpenTelemetry開源生態全面融合

5 月 22 日，在最新一期的飛天發佈時刻上，阿里雲宣佈多款可觀測產品全面升級，其中一項是應用實時監控服務 ARMS 在業內率先推進了與 OpenTelemetry 開源生態的全面融合，極大豐富了可觀測的數據類型及規模，大幅增強了 ARMS

原創 2024-05-24 21:13:50

昔日輝煌不再，PHP老矣，尚能飯否？

導語 | 近期 TIOBE 最新指數顯示，PHP 的流行度降至了歷史最低，排在第 17 名，同時，在年度 Stack Overflow 開發者調查報告中，PHP 在開發者中的受歡迎程度已經從之前的約 30% 萎縮至現在的 18%。“P

原創 2024-05-23 23:48:42

一文教你基於LangChain和ChatGLM3搭建本地知識庫問答

本文分享自華爲雲社區《【雲駐共創】LangChain＋ChatGLM3實現本地知識庫，轉華爲雲ModelArts，實現大模型AI應用開發》 ，作者：葉一一。 一、前言 本期華爲雲的講師是華爲雲EI開發生態的工程師傑森，分享主題是：基於La

原創 2024-05-23 10:58:28

Python實現大麥網搶票的四大關鍵技術點解析

前言 隨着互聯網的普及和發展，線上購票已經成爲人們生活中不可或缺的一部分。然而，在搶購熱門演出門票時，往往會遇到搶票難、搶票快的問題，有時候一秒鐘的延遲就意味着與心儀的演出擦肩而過。爲了解決這個問題，技術愛好者們開始探索利用Python

原創 2024-05-23 00:18:04

用python開發一個類似的交互查詢系統.用什麼庫方便？

大家好，我是Python進階者。 一、前言 前幾天在Python白銀交流羣【fashjon】問了一個Python庫的問題，問題如下：用python開發一個類似的交互查詢系統.用什麼庫方便？ 二、實現過程 這裏【啥也不懂】給了一個指導：PY

原創 2024-05-22 10:02:33

Selenium與PhantomJS：自動化測試與網頁爬蟲的完美結合

在當今互聯網時代，自動化測試和網頁爬蟲技術成爲了不可或缺的工具，它們不僅提高了開發效率，也爲數據採集和分析提供了便利。而Selenium與PhantomJS的結合，則爲這兩個領域的應用帶來了全新的可能性。本文將介紹Selenium與Pha

原創 2024-05-22 00:09:17

用好AppBuilder-SDK，每天都能偷偷早下班

本文主要是對這次AppBuilder-SDK直播課程的文字總結，主題是如何在Python中使用AppBuilder-SDK（使用的IDE 爲 PyCharm社區版）感興趣的朋友也可以去看直播課回放。 直播課： AppBuil

原創 2024-05-21 12:12:15