args := &appblb.CreateLoadBalancerArgs{ 
    // Set instance name 
    Name:        "sdkBlb", 
    // Set instance description 
    Description: "sdk create", 
    // Set the vpc to which the instance belongs 
    VpcId:       vpcId, 
    // Set the subnet to which the instance belongs 
    SubnetId:    subnetId, 
} 

// To set a tag for the instance, you can set the tag by the following code and can't modify or delete the set tag. 
args.Tags = []model.TagModel{ 
    { 
        TagKey:   "key", 
        TagValue: "value", 
    }, 
} 
result, err := client.CreateLoadBalancer(args) 
if err != nil { 
    fmt.Println("create appblb failed:", err) 
} else { 
    fmt.Println("create appblb success: ", result) 
} 

args := &appblb.UpdateLoadBalancerArgs{ 
    Name:        "testSdk", 
    Description: "test desc", 
} 
err := client.UpdateLoadBalancer(blbId, args) 
if err != nil { 
    fmt.Println("update appblb failed:", err) 
} else { 
    fmt.Println("update appblb success") 
} 

args := &appblb.DescribeLoadBalancersArgs{} 

// Support query by LoadBalancer id, name and address. Matching rules support partial inclusion (regular is not supported) 
args.BlbId = blbId 
args.Name = blbName 
args.Address = blbAddress 
args.ExactlyMatch = true 

// Support to find the bound LoadBalancer of the BLB specified by the blbId parameter 
args.BlbId = blbId 

result, err := client.DescribeLoadBalancers(args) 
if err != nil { 
    fmt.Println("list all appblb failed:", err) 
} else { 
    fmt.Println("list all appblb success: ", result) 
} 

result, err := client.DescribeLoadBalancerDetail(blbId) 
if err != nil { 
    fmt.Println("get appblb detail failed:", err) 
} else { 
    fmt.Println("get appblb detail success: ", result) 
} 

err := client.DeleteLoadBalancer(blbId) 
if err != nil { 
    fmt.Println("delete appblb failed:", err) 
} else { 
    fmt.Println("delete appblb success") 
} 

args := &appblb.CreateAppServerGroupArgs{ 
    // Set server group name 
    Name: "sdkTest", 
    // Set server group description 
    Description: "sdk test desc", 
} 

// If you want to bind the back end server directly, you can set the following parameters. 
args.BackendServerList = []appblb.AppBackendServer{ 
    { 
        InstanceId: instanceId, 
        Weight:     50, 
    }, 
} 

result, err := client.CreateAppServerGroup(blbId, args) 
if err != nil { 
    fmt.Println("create server group failed:", err) 
} else { 
    fmt.Println("create server group success: ", result) 
} 

args := &appblb.UpdateAppServerGroupArgs{ 
    // Set the server group ID to be updated 
    SgId:        serverGroupId, 
    // Set new server group name 
    Name:        "testSdk", 
    // Set new server group description 
    Description: "test desc", 
} 
err := client.UpdateAppServerGroup(blbId, args) 
if err != nil { 
    fmt.Println("update server group failed:", err) 
} else { 
    fmt.Println("update server group success: ", result) 
} 

args := &appblb.DescribeAppServerGroupArgs{} 

// Conduct global query according to BLBID and name 
args.BlbId = blbId 
args.Name = servergroupName 
args.ExactlyMatch = true 

result, err := client.DescribeAppServerGroup(blbId, args) 
if err != nil { 
    fmt.Println("describe server group failed:", err) 
} else { 
    fmt.Println("describe server group success: ", result) 
} 

args := &appblb.DeleteAppServerGroupArgs{ 
    // Server group ID to delete 
    SgId: serverGroupId, 
} 
err := client.DeleteAppServerGroup(blbId, args) 
if err != nil { 
    fmt.Println("delete server group failed:", err) 
} else { 
    fmt.Println("delete server group success: ", result) 
} 

args := &appblb.CreateAppServerGroupPortArgs{ 
    // Server group ID to which the port belongs 
    SgId: serverGroupId, 
    // Listener port number 
    Port: 80, 
    // Listener protocol type 
    Type: "TCP", 
} 

// You can select to set the parameters of the corresponding health check protocols. 
args.HealthCheck = "TCP" 
args.HealthCheckPort = 30 
args.HealthCheckIntervalInSecond = 10 
args.HealthCheckTimeoutInSecond = 10 

result, err := client.CreateAppServerGroupPort(blbId, args) 
if err != nil { 
    fmt.Println("create server group port failed:", err) 
} else { 
    fmt.Println("create server group port success: ", result) 
} 

args := &appblb.UpdateAppServerGroupPortArgs{ 
	 // Server group ID to which the port belongs 
    SgId: serverGroupId, 
    // Port Id, returned by the created application type server group port 
    PortId: portId, 
    // Set the health check protocol parameters 
    HealthCheck:                 "TCP", 
    HealthCheckPort:             30, 
    HealthCheckIntervalInSecond: 10, 
    HealthCheckTimeoutInSecond:  10, 
} 
err := client.UpdateAppServerGroupPort(blbId, args) 
if err != nil { 
    fmt.Println("update server group port failed:", err) 
} else { 
    fmt.Println("update server group port success: ", result) 
} 

args := &appblb.DeleteAppServerGroupPortArgs{ 
	 // Server group ID to which the port belongs 
    SgId:        serverGroupId, 
	 / / port service ID list to be deleted 
    PortIdList:  []string{portId}, 
} 
err := client.DeleteAppServerGroupPort(blbId, args) 
if err != nil { 
    fmt.Println("delete server group port failed:", err) 
} else { 
    fmt.Println("delete server group port success: ", result) 
} 

args := &appblb.CreateBlbRsArgs{ 
    BlbRsWriteOpArgs: appblb.BlbRsWriteOpArgs{ 
        // ID of the server group to which the RS belongs 
        SgId:        serverGroupId, 
        // Configure the list and weight of back end server 
        BackendServerList: []appblb.AppBackendServer{  
            {InstanceId: instanceId, Weight: 30}, 
        }, 
    }, 
} 
err := client.CreateBlbRs(blbId, args) 
if err != nil { 
    fmt.Println("create blbRs failed:", err) 
} else { 
    fmt.Println("create blbRs success: ", result) 
} 

args := &appblb.UpdateBlbRsArgs{ 
    BlbRsWriteOpArgs: appblb.BlbRsWriteOpArgs{ 
        // ID of the server group to which the RS belongs 
        SgId:        serverGroupId, 
        // Configure the list and weight of back end server to be updated. 
        BackendServerList: []appblb.AppBackendServer{ 
            {InstanceId: instanceId, Weight: 60}, 
        }, 
    }, 
} 
err := client.UpdateBlbRs(blbId, args) 
if err != nil { 
    fmt.Println("update blbRs failed:", err) 
} else { 
    fmt.Println("update blbRs success: ", result) 
} 

args := &appblb.DescribeBlbRsArgs{ 
	 // ID of the server group to which the RS belongs 
    SgId: serverGroupId, 
} 
result, err := client.DescribeBlbRs(blbId, args) 
if err != nil { 
    fmt.Println("describe blbRs failed:", err) 
} else { 
    fmt.Println("describe blbRs success: ", result) 
} 

args := &appblb.DeleteBlbRsArgs{ 
	 // ID of the server group to which the RS belongs 
    SgId: serverGroupId, 
    // List of instances to be deleted from the RS list 
    BackendServerIdList: []string{instanceId}, 
} 
err := client.DeleteBlbRs(blbId, args) 
if err != nil { 
    fmt.Println("delete blbRs failed:", err) 
} else { 
    fmt.Println("delete blbRs success: ", result) 
} 

result, err := client.DescribeRsMount(blbId, serverGroupId) 
if err != nil { 
    fmt.Println("describe mount Rs list failed:", err) 
} else { 
    fmt.Println("describe mount Rs list success: ", result) 
} 

result, err := client.DescribeRsUnMount(blbId, serverGroupId) 
if err != nil { 
    fmt.Println("describe unmount Rs list failed:", err) 
} else { 
    fmt.Println("describe unmount Rs list success: ", result) 
} 

args := &appblb.CreateAppTCPListenerArgs{ 
    // The monitoring port of listener should be within 1-65535. 
    ListenerPort: 90, 
    // Load balance algorithm, support RoundRobin/LeastConnection/Hash 
    Scheduler: "RoundRobin", 
    // TCP sets the link timeout time as 900 seconds by default. It should be an integer between 10-4000. 
    TcpSessionTimeout: 1000, 
} 
err := client.CreateAppTCPListener(BLBID, args) 
if err != nil { 
    fmt.Println("create TCP Listener failed:", err) 
} else { 
    fmt.Println("create TCP Listener success") 
} 

args := &appblb.UpdateAppTCPListenerArgs{ 
    UpdateAppListenerArgs: appblb.UpdateAppListenerArgs{ 
        // The listener port to be updated 
        ListenerPort: 90, 
        // Update the algorithm of load balance 
        Scheduler:    "Hash", 
        // Update the timeout time of tcp link 
        TcpSessionTimeout: 2000, 
    }, 
} 
err := client.UpdateAppTCPListener(BLBID, args) 
if err != nil { 
    fmt.Println("update TCP Listener failed:", err) 
} else { 
    fmt.Println("update TCP Listener success") 
} 

args := &appblb.DescribeAppListenerArgs{ 
    // The listener port to query 
    ListenerPort: 90, 
} 
result, err := client.DescribeAppTCPListeners(BLBID, args) 
if err != nil { 
    fmt.Println("describe TCP Listener failed:", err) 
} else { 
    fmt.Println("describe TCP Listener success: ", result) 
} 

args := &appblb.CreateAppUDPListenerArgs{ 
    // The monitoring port of listener should be within 1-65535. 
    ListenerPort: 80, 
    // Load balance algorithm, support RoundRobin/LeastConnection/Hash 
    Scheduler:    "RoundRobin", 
} 
err := client.CreateAppUDPListener(BLBID, args) 
if err != nil { 
    fmt.Println("create UDP Listener failed:", err) 
} else { 
    fmt.Println("create UDP Listener success") 
} 

args := &appblb.UpdateAppUDPListenerArgs{ 
    UpdateAppListenerArgs: appblb.UpdateAppListenerArgs{ 
        // The listener port to be updated 
        ListenerPort: 80, 
        // Update the algorithm of load balance 
        Scheduler:    "Hash", 
    }, 
} 
err := client.UpdateAppUDPListener(BLBID, args) 
if err != nil { 
    fmt.Println("update UDP Listener failed:", err) 
} else { 
    fmt.Println("update UDP Listener success") 
} 

args := &appblb.DescribeAppListenerArgs{ 
    // The listener port to query 
    ListenerPort: 80, 
} 
result, err := client.DescribeAppUDPListeners(BLBID, args) 
if err != nil { 
    fmt.Println("describe UDP Listener failed:", err) 
} else { 
    fmt.Println("describe UDP Listener success: ", result) 
} 

args := &appblb.CreateAppHTTPListenerArgs{ 
    // The monitoring port of listener should be within 1-65535. 
    ListenerPort: 80, 
    // Load balance algorithm, support RoundRobin/LeastConnection 
    Scheduler:    "RoundRobin", 
} 
err := client.CreateAppHTTPListener(BLBID, args) 
if err != nil { 
    fmt.Println("create HTTP Listener failed:", err) 
} else { 
    fmt.Println("create HTTP Listener success") 
} 

args := &appblb.UpdateAppHTTPListenerArgs{ 
	 // The listener port to be updated 
    ListenerPort: 80, 
    // Update the algorithm of load balance 
    Scheduler:    "LeastConnection", 
    // Enable the session persistence feature 
    KeepSession:  true, 
} 
err := client.UpdateAppHTTPListener(BLBID, args) 
if err != nil { 
    fmt.Println("update HTTP Listener failed:", err) 
} else { 
    fmt.Println("update HTTP Listener success") 
} 

args := &appblb.DescribeAppListenerArgs{ 
    // The listener port to query 
    ListenerPort: 80, 
} 
result, err := client.DescribeAppHTTPListeners(BLBID, args) 
if err != nil { 
    fmt.Println("describe HTTP Listener failed:", err) 
} else { 
    fmt.Println("describe HTTP Listener success: ", result) 
} 

args := &appblb.CreateAppHTTPSListenerArgs{ 
    // The monitoring port of listener should be within 1-65535. 
    ListenerPort: 80, 
    // Load balance algorithm, support RoundRobin/LeastConnection 
    Scheduler:    "RoundRobin", 
    // Configure the certificate list 
    CertIds:      []string{certId}, 
} 
err := client.CreateAppHTTPSListener(BLBID, args) 
if err != nil { 
    fmt.Println("create HTTPS Listener failed:", err) 
} else { 
    fmt.Println("create HTTPS Listener success") 
} 

args := &appblb.UpdateAppHTTPSListenerArgs{ 
	 // The listener port to be updated 
    ListenerPort: 80, 
    // Update the algorithm of load balance 
    Scheduler:    "LeastConnection", 
    // Enable the session persistence feature 
    KeepSession:  true, 
    // Configure the certificate list 
    CertIds:      []string{certId}, 
} 
err := client.UpdateAppHTTPSListener(BLBID, args) 
if err != nil { 
    fmt.Println("update HTTPS Listener failed:", err) 
} else { 
    fmt.Println("update HTTPS Listener success") 
} 

args := &appblb.DescribeAppListenerArgs{ 
    // The listener port to query 
    ListenerPort: 80, 
} 
result, err := client.DescribeAppHTTPSListeners(BLBID, args) 
if err != nil { 
    fmt.Println("describe HTTPS Listener failed:", err) 
} else { 
    fmt.Println("describe HTTPS Listener success: ", result) 
} 

args := &appblb.CreateAppSSLListenerArgs{ 
    // The monitoring port of listener should be within 1-65535. 
    ListenerPort: 80, 
    // Load balance algorithm, support RoundRobin/LeastConnection/Hash 
    Scheduler:    "RoundRobin", 
    // Configure the certificate list 
    CertIds:      []string{certId}, 
} 
err := client.CreateAppSSLListener(BLBID, args) 
if err != nil { 
    fmt.Println("create SSL Listener failed:", err) 
} else { 
    fmt.Println("create SSL Listener success") 
} 

args := &appblb.UpdateAppSSLListenerArgs{ 
	 // The listener port to be updated 
    ListenerPort: 80, 
    // Update the algorithm of load balance 
    Scheduler:    "LeastConnection", 
    // Configure the certificate list 
    CertIds:      []string{certId}, 
} 
err := client.UpdateAppSSLListener(BLBID, args) 
if err != nil { 
    fmt.Println("update SSL Listener failed:", err) 
} else { 
    fmt.Println("update SSL Listener success") 
} 

args := &appblb.DescribeAppListenerArgs{ 
    // The listener port to query 
    ListenerPort: 80, 
} 
result, err := client.DescribeAppSSLListeners(BLBID, args) 
if err != nil { 
    fmt.Println("describe SSL Listener failed:", err) 
} else { 
    fmt.Println("describe SSL Listener success: ", result) 
} 

args := &appblb.DeleteAppListenersArgs{ 
    // Monitoring port of listener to be deleted 
    PortList:    []uint16{80}, 
} 
err := client.DeleteAppListeners(BLBID, args) 
if err != nil { 
    fmt.Println("delete Listeners failed:", err) 
} else { 
    fmt.Println("delete Listeners success: ", result) 
} 

args := &appblb.CreatePolicysArgs{ 
    // Monitoring port of listener of policy to be bound 
    ListenerPort: 80, 
    // For the policies to be bound, TCP/UDP/SSL only supports binding of one policy, and HTTP/HTTPS supports binding of multiple policies. 
    AppPolicyVos: []appblb.AppPolicy{ 
    { 
        // Policy description 
        Description:      "test policy", 
        // Server group ID bound to the policy 
        AppServerGroupId: servergroupId, 
        // Target port number 
        BackendPort:      80, 
        // Policy priority, the valid value ranges from 1 to 32768 
        Priority:         301, 
        // Rule list of policy, TCP/UDP/SSL only supports {*: *} Policy 
        RuleList: []appblb.AppRule{ 
                { 
                    Key:   "*", 
                    Value: "*", 	 
                }, 
            }, 
        }, 
    }, 
} 
err := client.CreatePolicys(blbId, args) 
if err != nil { 
    fmt.Println("create policy failed:", err) 
} else { 
    fmt.Println("create policy success") 
} 

args := &appblb.DescribePolicysArgs{ 
    // The listener port to query 
    Port: 80, 
} 
result, err := client.DescribePolicys(blbId, args) 
if err != nil { 
    fmt.Println("describe policy failed:", err) 
} else { 
    fmt.Println("describe policy success: ", result) 
} 

args := &appblb.DeletePolicysArgs{ 
    // Port number of the listener where the policy is located to be deleted 
    Port: 80, 
    // Policy ID list to be deleted 
    PolicyIdList: []string{describeResult.PolicyList[0].Id}, 
} 
err := client.DeletePolicys(blbId, args) 
if err != nil { 
    fmt.Println("delete policy failed:", err) 
} else { 
    fmt.Println("delete policy success") 
} 

// blbClient is a created BLB Client object. 
blbDetail, err := blbClient.DescribeLoadBalancerDetail(blbId) 
if err != nil { 
	 switch realErr := err.(type) { 
	 case *bce.BceClientError: 
	 	 fmt.Println("client occurs error:", realErr.Error()) 
	 case *bce.BceServiceError: 
	 	 fmt.Println("service occurs error:", realErr.Error()) 
	 default: 
	 	 fmt.Println("unknown error:", err) 
	 } 
} else { 
	 fmt.Println("get appblb detail success: ", blbDetail) 
}