应用型负载均衡
更新时间：2025-08-11
应用型BLB实例
创建APPBLB实例
Go
1func createBecAppBlbV2(client *bec.Client) {
2 request := &api.CreateAppBlbRequest{
3 // 负载均衡描述，非必需
4 Desc: "desc",
5 // 负载均衡名称，必需
6 Name: "wj-name",
7 // 是否需要公网IPV4，非必需
8 NeedPublicIp: true,
9 // 负载均衡所在节点ID，必需
10 RegionId: "cn-baoding1-ix",
11 // 指定运营商，取值为"ct"、"un"、"cm"，分别是电信、联通、移动，目前仅支持指定一个运营商，非必需
12 SubServiceProviders: []string{"cm"},
13 // 负载均衡子网ID，非必需
14 SubnetId: "sbn-ahbknbnjipkw",
15 // 负载均衡VPC ID，非必需
16 VpcId: "vpc-06shaxptznid",
17 }
18 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
19 clientToken := "123456789"
20 response, err := client.CreateAppBlb(clientToken, request)
21 if err != nil {
22 fmt.Printf("createBecAppBlbV2 error: %v\n", err)
23 return
24 }
25 fmt.Printf("createBecAppBlbV2 response: %+v\n", response)
26}修改APPBLB实例
Go
1func updateBecAppBlbV2(client *bec.Client) {
2 request := &api.ModifyBecBlbRequest{
3 // 负载均衡名称，非必需
4 Name: "wj-new-name",
5 // 负载均衡描述，非必需
6 Desc: "desc",
7 }
8 // 负载均衡ID，必需
9 blbId := "applb-cn-baoding1-ix-urufwu6p"
10 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
11 clientToken := "123456789"
12 err := client.UpdateAppBlb(clientToken, blbId, request)
13 if err != nil {
14 fmt.Printf("updateBecAppBlbV2 error: %v\n", err)
15 return
16 }
17}查询APPBLB实例列表
Go
1func getBecAppBlbsV2(client *bec.Client) {
2 request := &api.MarkerRequest{
3 // 标记查询的起始位置，填blbId
4 Marker: "marker",
5 // 每页包含的最大数量，1-1000，默认1000
6 MaxKeys: 1000,
7 }
8
9 response, err := client.GetAppBlbList(request)
10 if err != nil {
11 fmt.Printf("getBecAppBlbsV2 error: %v\n", err)
12 return
13 }
14 fmt.Printf("getBecAppBlbsV2 response: %+v\n", response)
15}查询APPBLB实例详情
Go
1func getBecAppBlbV2(client *bec.Client) {
2 // 负载均衡ID，必需
3 blbId := "applb-cn-baoding1-ix-urufwu6p"
4 response, err := client.GetAppBlbDetails(blbId)
5 if err != nil {
6 fmt.Printf("getBecAppBlbV2 error: %v\n", err)
7 return
8 }
9 fmt.Printf("getBecAppBlbV2 response: %+v\n", response)
10}删除APPBLB实例
Go
1func deleteBecAppBlbV2(client *bec.Client) {
2 // 负载均衡ID，必需
3 blbId := "applb-cn-baoding1-ix-urufwu6p"
4 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
5 clientToken := "123456789"
6 err := client.DeleteAppBlbInstance(blbId, clientToken)
7 if err != nil {
8 fmt.Printf("deleteBecAppBlbV2 error: %v\n", err)
9 return
10 }
11}应用型BLB监听器
创建TCP监听器
Go
1func createBecAppBlbTCPListenerV2(client *bec.Client) {
2 request := &api.CreateBecAppBlbTcpListenerRequest{
3 // 监听器的监听端口，需为1-65535间的整数，必需
4 ListenerPort: 8090,
5 // 负载均衡算法，支持3种方式：RoundRobin、LeastConnection、Hash，必需
6 Scheduler: "RoundRobin",
7 // TCP设置连接超时时间（单位：秒），默认900，需为10-4000间的整数，非必需
8 TcpSessionTimeout: 1000,
9 }
10 // 负载均衡ID，必需
11 blbId := "applb-cn-baoding1-ix-urufwu6p"
12 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
13 clientToken := "123456789"
14 err := client.CreateTcpListener(clientToken, blbId, request)
15 if err != nil {
16 fmt.Printf("CreateBecAppBlbTCPListenerV2 error: %v\n", err)
17 return
18 }
19}创建UDP监听器
Go
1func createBecAppBlbUDPListenerV2(client *bec.Client) {
2 request := &api.CreateBecAppBlbUdpListenerRequest{
3 // 监听器的监听端口，需为1-65535间的整数，必需
4 ListenerPort: 8090,
5 // 负载均衡算法，支持3种方式：RoundRobin、LeastConnection、Hash，必需
6 Scheduler: "RoundRobin",
7 // UDP会话超时时间（单位：秒），默认900，需为10-4000间的整数，非必需
8 UdpSessionTimeout: 1000,
9 }
10 // 负载均衡ID，必需
11 blbId := "applb-cn-baoding1-ix-urufwu6p"
12 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
13 clientToken := "123456789"
14 err := client.CreateUdpListener(clientToken, blbId, request)
15 if err != nil {
16 fmt.Printf("CreateBecAppBlbUDPListenerV2 error: %v\n", err)
17 return
18 }
19}新建监听器策略
Go
1func createBecAppBlbListenerPoliciesV2(client *bec.Client) {
2 createAppPolicy := api.AppPolicyVo{
3 // 策略绑定IP组标识符，必需
4 AppIpGroupId: "bec_ip_group-lh3utupb",
5 // 策略优先级，有效取值范围是1-32768，必需
6 Priority: 1,
7 // 策略描述默认为空，非必需
8 Desc: "description",
9 }
10
11 request := &api.CreateAppBlbPoliciesRequest{
12 // 监听器的监听端口，必需
13 ListenerPort: 8090,
14 // 当监听器端口下有多个协议时，type必传
15 Type: "TCP",
16 // 监听器绑定策略列表，必需
17 AppPolicyVos: []api.AppPolicyVo{createAppPolicy},
18 }
19 // 负载均衡ID，必需
20 blbId := "applb-cn-baoding1-ix-urufwu6p"
21 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
22 clientToken := "123456789"
23 err := client.CreateListenerPolicy(clientToken, blbId, request)
24 if err != nil {
25 fmt.Printf("CreateBecAppBlbListenerPoliciesV2 error: %v\n", err)
26 return
27 }
28}修改TCP监听器
Go
1func updateBecAppBlbTCPListenerV2(client *bec.Client) {
2 request := &api.UpdateBecAppBlbTcpListenerRequest{
3 // 负载均衡算法，支持3种方式：RoundRobin、LeastConnection、Hash，非必需
4 Scheduler: "LeastConnection",
5 // TCP设置连接超时时间（单位：秒），需为10-4000间的整数，非必需
6 TcpSessionTimeout: 2000,
7 }
8 // 负载均衡ID，必需
9 blbId := "applb-cn-baoding1-ix-urufwu6p"
10 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
11 clientToken := "123456789"
12 // TCP监听器端口，必需
13 listenerPort := "8090"
14 err := client.UpdateTcpListener(clientToken, blbId, listenerPort, request)
15 if err != nil {
16 fmt.Printf("UpdateBecAppBlbTCPListenerV2 error: %v\n", err)
17 return
18 }
19}修改UDP监听器
Go
1func updateBecAppBlbUDPListenerV2(client *bec.Client) {
2 request := &api.UpdateBecAppBlbUdpListenerRequest{
3 // 负载均衡算法，支持3种方式：RoundRobin、LeastConnection、Hash，非必需
4 Scheduler: "LeastConnection",
5 // UDP会话超时时间（单位：秒），需为10-4000间的整数，非必需
6 UdpSessionTimeout: 2000,
7 }
8 // 负载均衡ID，必需
9 blbId := "applb-cn-baoding1-ix-urufwu6p"
10 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
11 clientToken := "123456789"
12 // UDP监听器端口，必需
13 listenerPort := "8090"
14 err := client.UpdateUdpListener(clientToken, blbId, listenerPort, request)
15 if err != nil {
16 fmt.Printf("UpdateBecAppBlbUDPListenerV2 error: %v\n", err)
17 return
18 }
19}查询TCP监听器
Go
1func getBecAppBlbTCPListenersV2(client *bec.Client) {
2 listReq := api.MarkerRequest{
3 // 标记查询的起始位置，非必需
4 Marker: "marker",
5 // 每页最大数量，非必需
6 MaxKeys: 100,
7 }
8
9 request := &api.GetBecAppBlbListenerRequest{
10 // 监听器端口，非必需
11 ListenerPort: 8090,
12 // 分页参数，非必需
13 MarkerRequest: listReq,
14 }
15 // 负载均衡ID，必需
16 blbId := "applb-cn-baoding1-ix-urufwu6p"
17 resp, err := client.GetTcpListener(blbId, request)
18 if err != nil {
19 fmt.Printf("Get TCP Listeners error: %v\n", err)
20 } else {
21 fmt.Printf("Get TCP Listeners response: %+v\n", resp)
22 }
23}查询UDP监听器
Go
1func getBecAppBlbUDPListenersV2(client *bec.Client) {
2 listReq := api.MarkerRequest{
3 Marker: "marker",
4 MaxKeys: 100,
5 }
6
7 request := &api.GetBecAppBlbListenerRequest{
8 ListenerPort: 8090,
9 MarkerRequest: listReq,
10 }
11 // 负载均衡ID，必需
12 blbId := "applb-cn-baoding1-ix-urufwu6p"
13 resp, err := client.GetUdpListener(blbId, request)
14 if err != nil {
15 fmt.Printf("Get UDP Listeners error: %v\n", err)
16 } else {
17 fmt.Printf("Get UDP Listeners response: %+v\n", resp)
18 }
19}查询监听器策略
Go
1func getBecAppBlbListenerPoliciesV2(client *bec.Client) {
2 listReq := api.MarkerRequest{
3 Marker: "marker",
4 MaxKeys: 100,
5 }
6
7 request := &api.GetBlbListenerPolicyRequest{
8 // BLB下监听器端口号，必需
9 Port: 8090,
10 // 当监听器端口下有多个协议时，type必传，非必需
11 Type: "TCP",
12 // 分页参数，非必需
13 MarkerRequest: listReq,
14 }
15 // 负载均衡ID，必需
16 blbId := "applb-cn-baoding1-ix-urufwu6p"
17 resp, err := client.GetListenerPolicy(blbId, request)
18 if err != nil {
19 fmt.Printf("Get Listener Policies error: %v\n", err)
20 } else {
21 fmt.Printf("Get Listener Policies response: %+v\n", resp)
22 }
23}删除监听器策略
Go
1func deleteBecAppBlbListenerPoliciesV2(client *bec.Client) {
2 request := &api.DeleteAppBlbPoliciesRequest{
3 // 策略前端端口，必需
4 Port: 8090,
5 // 所有待释放的策略标识符，一起组成一个数组，必需
6 PolicyIdList: []string{"bec_policy-obwoyc9o"},
7 // 当监听器端口下有多个协议时，type必传，非必需
8 Type: "TCP",
9 }
10 // 负载均衡ID，必需
11 blbId := "applb-cn-baoding1-ix-urufwu6p"
12 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
13 clientToken := "12345678"
14 err := client.DeleteListenerPolicy(clientToken, blbId, request)
15 if err != nil {
16 fmt.Printf("Delete Listener Policies error: %v\n", err)
17 }
18}删除监听器
Go
1func batchDeleteBecAppBlbListenersV2(client *bec.Client) {
2 tcpListener := api.PortTypeList{
3 // 监听器端口，必需
4 Port: 8090,
5 // 监听器协议类型，必需
6 Type: "TCP",
7 }
8 udpListener := api.PortTypeList{
9 Port: 8090,
10 Type: "UDP",
11 }
12
13 request := &api.DeleteBlbListenerRequest{
14 // 待删除的监听器端口和协议列表，必需
15 PortTypeList: []api.PortTypeList{tcpListener, udpListener},
16 }
17 // 负载均衡ID，必需
18 blbId := "applb-cn-baoding1-ix-urufwu6p"
19 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
20 clientToken := "123456789"
21 err := client.DeleteAppBlbListener(blbId, clientToken, request)
22 if err != nil {
23 fmt.Printf("Batch Delete Listeners error: %v\n", err)
24 }
25}应用型BLB IP组
创建IP组
Go
1func createBecAppBlbIpGroupV2(client *bec.Client) {
2 member := &api.BlbIpGroupMember{
3 // IP地址，必需
4 Ip: "192.168.1.1",
5 // 端口号，取值范围1~65535，必需
6 Port: 8080,
7 // 权重，取值范围0~100，必需
8 Weight: 50,
9 }
10 request := &api.CreateBlbIpGroupRequest{
11 // IP组描述，非必需
12 Desc: "desc",
13 // IP组挂载的IP组成员列表，非必需
14 MemberList: []api.BlbIpGroupMember{*member},
15 // IP组名称，必需
16 Name: "wj-ipgroup1",
17 }
18 // 负载均衡ID，必需
19 blbId := "applb-cn-baoding1-ix-urufwu6p"
20 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
21 clientToken := "123456789"
22 response, err := client.CreateIpGroup(clientToken, blbId, request)
23 if err != nil {
24 fmt.Printf("createBecAppBlbIpGroupV2 error: %v\n", err)
25 }
26 fmt.Printf("createBecAppBlbIpGroupV2 response: %+v\n", response)
27}更新IP组
Go
1func updateBecAppBlbIpGroupV2(client *bec.Client) {
2 request := &api.UpdateBlbIpGroupRequest{
3 // IP组描述，非必需
4 Desc: "new desc",
5 // IP组ID，必需
6 IpGroupId: "bec_ip_group-mw0ghg7s",
7 // IP组名称，非必需
8 Name: "new name",
9 }
10 // 负载均衡ID，必需
11 blbId := "applb-cn-baoding1-ix-urufwu6p"
12 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
13 clientToken := "123456789"
14 err := client.UpdateIpGroup(clientToken, blbId, request)
15 if err != nil {
16 fmt.Printf("updateBecAppBlbIpGroupV2 error: %v\n", err)
17 }
18}查询IP组列表
Go
1func getBecAppBlbIpGroupsV2(client *bec.Client) {
2 list := api.MarkerRequest{
3 // 标记查询的起始位置，非必需
4 Marker: "marker-value",
5 // 每页包含的最大数量，1-1000，默认1000，非必需
6 MaxKeys: 100,
7 }
8 request := &api.GetBlbIpGroupListRequest{
9 // 设置name是否完全匹配，非必需
10 ExactlyMatch: true,
11 // IP组名称，非必需
12 Name: "new name",
13 // 分页参数，非必需
14 MarkerRequest: list,
15 }
16 // 负载均衡ID，必需
17 blbId := "applb-cn-baoding1-ix-urufwu6p"
18 response, err := client.GetIpGroup(blbId, request)
19 if err != nil {
20 fmt.Printf("getBecAppBlbIpGroupsV2 error: %v\n", err)
21 return
22 }
23 fmt.Printf("getBecAppBlbIpGroupsV2 response: %+v\n", response)
24}删除IP组
Go
1func deleteBecAppBlbIpGroupV2(client *bec.Client) {
2 request := &api.DeleteBlbIpGroupRequest{
3 // IP组ID，必需
4 IpGroupId: "bec_ip_group-lh3utupb",
5 }
6 // 负载均衡ID，必需
7 blbId := "applb-cn-baoding1-ix-urufwu6p"
8 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
9 clientToken := "123456789"
10 err := client.DeleteIpGroup(clientToken, blbId, request)
11 if err != nil {
12 fmt.Printf("deleteBecAppBlbIpGroupV2 error: %v\n", err)
13 return
14 }
15}创建IP组协议
Go
1func createBecAppBlbIpGroupBackendPoliciesV2(client *bec.Client) {
2 request := &api.CreateBlbIpGroupBackendPolicyRequest{
3 // 健康检查类型，TCP、HTTP、UDP、ICMP，必需
4 HealthCheck: "TCP",
5 // 不健康阈值，即连续多少次健康检查失败后，屏蔽该后端服务器。默认为3，需为2-5间的整数，非必需
6 HealthCheckDownRetry: 3,
7 // 发往后端服务器的健康检查请求的Host头域，例如”localhost”，默认为空，当健康检查协议为HTTP时生效，非必需
8 HealthCheckHost: "localhost",
9 // 健康检查间隔（单位：秒），默认为3，需为1-10间的整数，非必需
10 HealthCheckIntervalInSecond: 3,
11 // 健康检查正常时的HTTP状态码，支持5类状态码的组合，例如”http_1xx|http_2xx”。当健康检查协议为HTTP时生效，非必需
12 HealthCheckNormalStatus: "http_2xx",
13 // 健康检查端口，IP组协议为HTTP协议时必传
14 HealthCheckPort: 8080,
15 // 健康检查超时（单位：秒），默认为3，需为1-60间的整数，非必需
16 HealthCheckTimeoutInSecond: 3,
17 // 健康阈值，即连续多少次健康检查成功后，重新将该后端服务器置为可用，默认为3，需为2-5间的整数，非必需
18 HealthCheckUpRetry: 3,
19 // 健康检查路径，默认/，当健康检查协议为HTTP时生效，非必需
20 HealthCheckUrlPath: "/",
21 // IP组ID，必需
22 IpGroupId: "bec_ip_group-mw0ghg7s",
23 // IP组协议类型，TCP、HTTP、UDP，必需
24 Type: "TCP",
25 // UDP健康检查字符串，UDP健康检查字符串，当健康检查协议为UDP时必传
26 UdpHealthCheckString: "test-udp-check",
27 }
28 // 负载均衡ID，必需
29 blbId := "applb-cn-baoding1-ix-urufwu6p"
30 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
31 clientToken := "123456789"
32 response, err := client.CreateIpGroupPolicy(clientToken, blbId, request)
33 if err != nil {
34 fmt.Printf("createBecAppBlbIpGroupBackendPoliciesV2 error: %v\n", err)
35 return
36 }
37 fmt.Printf("createBecAppBlbIpGroupBackendPoliciesV2 response: %+v\n", response)
38}更新IP组协议
Go
1func updateBecAppBlbIpGroupPolicyV2(client *bec.Client) {
2 request := &api.UpdateBlbIpGroupBackendPolicyRequest{
3 // 不健康阈值，即连续多少次健康检查失败后，屏蔽该后端服务器。默认为3，需为2-5间的整数，非必需
4 HealthCheckDownRetry: 3,
5 // 发往后端服务器的健康检查请求的Host头域，例如”localhost”，默认为空，当健康检查协议为HTTP时生效，非必需
6 HealthCheckHost: "localhost",
7 // 健康检查间隔（单位：秒），默认为3，需为1-10间的整数，非必需
8 HealthCheckIntervalInSecond: 3,
9 // 健康检查正常时的HTTP状态码，支持5类状态码的组合，例如”http_1xx|http_2xx”。当健康检查协议为HTTP时生效，非必需
10 HealthCheckNormalStatus: "http_2xx",
11 // 健康检查端口，IP组协议为HTTP协议时必传
12 HealthCheckPort: 8080,
13 // 健康检查超时（单位：秒），默认为3，需为1-60间的整数，非必需
14 HealthCheckTimeoutInSecond: 3,
15 // 健康阈值，即连续多少次健康检查成功后，重新将该后端服务器置为可用，默认为3，需为2-5间的整数，非必需
16 HealthCheckUpRetry: 4,
17 // 健康检查路径，默认/，当健康检查协议为HTTP时生效，非必需
18 HealthCheckUrlPath: "/",
19 // IP组协议ID，必需
20 Id: "bec_ip_group_policy-bv5hzqka",
21 // IP组ID，必需
22 IpGroupId: "bec_ip_group-mw0ghg7s",
23 // UDP健康检查字符串，UDP健康检查字符串，当健康检查协议为UDP时必传
24 UdpHealthCheckString: "new-check",
25 }
26 // 负载均衡ID，必需
27 blbId := "applb-cn-baoding1-ix-urufwu6p"
28 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
29 clientToken := "12345678"
30 err := client.UpdateIpGroupPolicy(clientToken, blbId, request)
31 if err != nil {
32 fmt.Printf("updateBecAppBlbIpGroupPolicyV2 error: %v\n", err)
33 return
34 }
35}查询IP组协议列表
Go
1func getBecAppBlbIpGroupPoliciesV2(client *bec.Client) {
2 markerRequest := api.MarkerRequest{
3 // 标记查询的起始位置，非必需
4 Marker: "marker-value",
5 // 每页包含的最大数量，1-1000，默认1000，非必需
6 MaxKeys: 100,
7 }
8 request := &api.GetBlbIpGroupPolicyListRequest{
9 // IP组ID，必需
10 IpGroupId: "bec_ip_group-mw0ghg7s",
11 // 分页参数，非必需
12 MarkerRequest: markerRequest,
13 }
14 // 负载均衡ID，必需
15 blbId := "applb-cn-baoding1-ix-urufwu6p"
16 response, err := client.GetIpGroupPolicyList(blbId, request)
17 if err != nil {
18 fmt.Printf("getBecAppBlbIpGroupPoliciesV2 error: %v\n", err)
19 return
20 }
21 fmt.Printf("getBecAppBlbIpGroupPoliciesV2 response: %+v\n", response)
22}删除IP组协议
Go
1func deleteBecAppBlbIpGroupBackendPoliciesV2(client *bec.Client) {
2 request := &api.DeleteBlbIpGroupBackendPolicyRequest{
3 // IP组协议ID列表，必需
4 BackendPolicyIdList: []string{"bec_ip_group_policy-bv5hzqka"},
5 // IP组ID，必需
6 IpGroupId: "bec_ip_group-mw0ghg7s",
7 }
8 // 负载均衡ID，必需
9 blbId := "applb-cn-baoding1-ix-urufwu6p"
10 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
11 clientToken := "123456789"
12 err := client.DeleteIpGroupPolicy(clientToken, blbId, request)
13 if err != nil {
14 fmt.Printf("deleteBecAppBlbIpGroupBackendPoliciesV2 error: %v\n", err)
15 return
16 }
17}创建IP组成员
Go
1func createBecAppBlbIpGroupMembersV2(client *bec.Client) {
2 member := &api.BlbIpGroupMember{
3 // IP地址，必需
4 Ip: "192.168.1.2",
5 // 端口号，取值范围1~65535，必需
6 Port: 8081,
7 // 权重，取值范围0~100，必需
8 Weight: 60,
9 }
10 request := &api.CreateBlbIpGroupMemberRequest{
11 // IP组ID，必需
12 IpGroupId: "bec_ip_group-mw0ghg7s",
13 // IP组成员列表，必需
14 MemberList: []api.BlbIpGroupMember{*member},
15 }
16 // 负载均衡ID，必需
17 blbId := "applb-cn-baoding1-ix-urufwu6p"
18 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
19 clientToken := "123456789"
20 response, err := client.CreateIpGroupMember(clientToken, blbId, request)
21 if err != nil {
22 fmt.Printf("createBecAppBlbIpGroupMembersV2 error: %v\n", err)
23 return
24 }
25 fmt.Printf("createBecAppBlbIpGroupMembersV2 response: %+v\n", response)
26}更新IP组成员
Go
1func updateBecAppBlbIpGroupMembersV2(client *bec.Client) {
2 member := &api.UpdateBlbIpGroupMember{
3 // IP组成员ID，必需
4 MemberId: "bec_ip_member-uo3yg7py",
5 // 端口，非必需
6 Port: 8082,
7 // 权重，非必需
8 Weight: 70,
9 }
10 request := &api.UpdateBlbIpGroupMemberRequest{
11 // IP组ID，必需
12 IpGroupId: "bec_ip_group-mw0ghg7s",
13 // IP组成员列表，必需
14 MemberList: []api.UpdateBlbIpGroupMember{*member},
15 }
16 // 负载均衡ID，必需
17 blbId := "applb-cn-baoding1-ix-urufwu6p"
18 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
19 clientToken := "123456789"
20 err := client.UpdateIpGroupMember(clientToken, blbId, request)
21 if err != nil {
22 fmt.Printf("updateBecAppBlbIpGroupMembersV2 error: %v\n", err)
23 return
24 }
25}查询IP组成员列表
Go
1func getBecAppBlbIpGroupMembersV2(client *bec.Client) {
2 markerRequest := api.MarkerRequest{
3 // 标记查询的起始位置，非必需
4 Marker: "marker-value",
5 // 每页包含的最大数量，1-1000，默认1000，非必需
6 MaxKeys: 100,
7 }
8 request := &api.GetBlbIpGroupMemberListRequest{
9 // IP组ID，必需
10 IpGroupId: "bec_ip_group-mw0ghg7s",
11 // 分页参数，非必需
12 MarkerRequest: markerRequest,
13 }
14 // 负载均衡ID，必需
15 blbId := "applb-cn-baoding1-ix-urufwu6p"
16 response, err := client.GetIpGroupMemberList(blbId, request)
17 if err != nil {
18 fmt.Printf("getBecAppBlbIpGroupMembersV2 error: %v\n", err)
19 return
20 }
21 fmt.Printf("getBecAppBlbIpGroupMembersV2 response: %+v\n", response)
22}删除IP组成员
Go
1func deleteBecAppBlbIpGroupMembersV2(client *bec.Client) {
2 request := &api.DeleteBlbIpGroupBackendMemberRequest{
3 // IP组ID，必需
4 IpGroupId: "bec_ip_group-mw0ghg7s",
5 // IP组成员ID列表，必需
6 MemberIdList: []string{"bec_ip_member-y8k6tbu2"},
7 }
8 // 负载均衡ID，必需
9 blbId := "applb-cn-baoding1-ix-urufwu6p"
10 // 幂等性Token，是一个长度不超过64位的ASCII字符串，非必需
11 clientToken := "123456789"
12 err := client.DeleteIpGroupMember(clientToken, blbId, request)
13 if err != nil {
14 fmt.Printf("deleteBecAppBlbIpGroupMembersV2 error: %v\n", err)
15 return
16 }
17}