1public void createBecBlb(BecClient client) {
2    CreateBecBlbRequest request = CreateBecBlbRequest.builder()
3            // 负载均衡类型，支持容器与虚机两种，分别对应"container"、"vm"
4            .lbType("vm")
5            // 付费方式，目前仅支持后付费方式("postpay")
6            .paymentMethod("postpay")
7            // 区域选择
8            .regionSelection("regional")
9            // 负载均衡所在区域信息
10            .region("EAST_CHINA")
11            // 负载均衡所在城市信息
12            .city("HANGZHOU")
13            // 负载均衡所属运营商信息
14            .serviceProvider("CHINA_MOBILE")
15            // 负载均衡名称
16            .blbName("bec-test")
17            // 是否需要公网ip
18            .needPublicIp(true)
19            // 负载均衡最大带宽限制，单位Mbps
20            .bandwidthInMbpsLimit(100)
21            .build();
22    CreateBecBlbResponse response = client.createBecBlb(request);
23}

1public void getBecBlbs(BecClient client) {
2    GetBecBlbsRequest request = new GetBecBlbsRequest();
3    // 负载均衡类型，支持"container"与"vm"两种类型，默认为"container"
4    request.setLbType("vm");
5    // 页码,默认单页显示
6    request.setPageNo(1);
7    // 单页结果数，默认值1000
8    request.setPageSize(10);
9    GetBecBlbsResponse response = client.getBecBlbs(request);
10}

1public void getBecBlb(BecClient client) {
2    GetBecBlbInstanceRequest request = new GetBecBlbInstanceRequest();
3    // 负载均衡Id
4    request.setBlbId("blbId");
5    GetBecBlbInstanceResponse response = client.getBecBlb(request);
6}

1public void deleteBecBlb(BecClient client) {
2    DeleteBecBlbRequest request = new DeleteBecBlbRequest();
3    // 负载均衡Id
4    request.setBlbId("blbId");
5    DeleteBecBlbResponse response = client.deleteBecBlb(request);
6}

1public void updateBecBlb(BecClient client) {
2    UpdateBecBlbRequest request = new UpdateBecBlbRequest();
3    // 负载均衡Id
4    request.setBlbId("blbId");
5    // 负载均衡名称
6    request.setBlbName("bec-blb-name");
7    UpdateBecBlbResponse response = client.updateBecBlb(request);
8}

1public void createBecBlbMonitorPort(BecClient client) {
2    CreateBecBlbMonitorPortRequest request = new CreateBecBlbMonitorPortRequest();
3
4    Port frontendPort = new Port();
5    // 端口号
6    frontendPort.setPort(8083);
7    // 使用协议名称
8    frontendPort.setProtocol("TCP");
9
10    HealthCheck healthCheck = new HealthCheck();
11    // UDP检查字符串
12    healthCheck.setHealthCheckString("udp");
13    // 健康阈值
14    healthCheck.setHealthyThreshold(3);
15    // 健康检查时间
16    healthCheck.setIntervalInSeconds(1);
17    // 响应超时时间
18    healthCheck.setTimeoutInSeconds(1);
19    // 不健康阈值
20    healthCheck.setUnhealthyThreshold(3);
21
22    // 负载均衡Id
23    request.setBlbId("blbId");
24    // 后端端口
25    request.setBackendPort(80);
26    // 负载均衡端口
27    request.setFrontendPort(frontendPort);
28    // 健康检查设置
29    request.setHealthCheck(healthCheck);
30    // 转发规则
31    request.setLbMode("wrr");
32    CreateBecBlbMonitorPortResponse response = client.createBecBlbMonitorPort(request);
33}

1public void getBlbMonitorPortList(BecClient client) {
2    GetBecBlbMonitorPortListRequest request = new GetBecBlbMonitorPortListRequest();
3    // 负载均衡Id
4    request.setBlbId("blbId");
5    GetBecBlbMonitorPortListResponse response = client.getBlbMonitorPortList(request);
6}

1public void getBecBlbMonitorPortDetails(BecClient client) {
2    GetBecBlbMonitorPortDetailsRequest request = new GetBecBlbMonitorPortDetailsRequest();
3    // 负载均衡Id
4    request.setBlbId("blbId");
5    // 负载均衡端
6    request.setPort(8083);
7    // 负载均衡协议
8    request.setProtocol("TCP");
9    GetBecBlbMonitorPortDetailsResponse response = client.getBecBlbMonitorPortDetails(request);
10}

1public void updateBecBlbMonitorPort(BecClient client) {
2    UpdateBecBlbMonitorPortRequest request = new UpdateBecBlbMonitorPortRequest();
3
4    Port frontendPort = new Port();
5    // 使用协议名称
6    frontendPort.setProtocol("TCP");
7    // 端口号
8    frontendPort.setPort(8083);
9
10    HealthCheck healthCheck = new HealthCheck();
11    // 不健康阈值
12    healthCheck.setUnhealthyThreshold(3);
13    // 响应超时时间
14    healthCheck.setTimeoutInSeconds(1);
15    // 健康检查时间
16    healthCheck.setIntervalInSeconds(2);
17    // 健康阈值
18    healthCheck.setHealthyThreshold(4);
19    // UDP检查字符串
20    healthCheck.setHealthCheckString("wohao");
21
22    // 负载均衡Id
23    request.setBlbId("blbId");
24    // 健康检查设置
25    request.setHealthCheck(healthCheck);
26    // 后端端口
27    request.setBackendPort(8083);
28    // 负载均衡端口
29    request.setFrontendPort(frontendPort);
30    // 转发规则
31    request.setLbMode("wrr");
32
33    UpdateBecBlbMonitorPortResponse response = client.updateBecBlbMonitorPort(request);
34}

1public void getBecBlbBackendPodList(BecClient client) {
2    GetBecBlbBackendPodListRequest request = new GetBecBlbBackendPodListRequest();
3    // 负载均衡Id
4    request.setBlbId("blbId");
5    GetBecBlbBackendPodListResponse response = client.getBecBlbBackendPodList(request);
6}

1public void getBecBlbBackendBindingStsList(BecClient client) {
2    GetBecBlbBackendBindingStsListRequest request = new GetBecBlbBackendBindingStsListRequest();
3    // 负载均衡Id
4    request.setBlbId("blbId");
5    GetBecBlbBackendBindingStsListResponse response = client.getBecBlbBackendBindingStsList(request);
6}

1public void getBecBlbBindingPodListWithSts(BecClient client) {
2    GetBecBlbBindingPodListWithStsRequest request = new GetBecBlbBindingPodListWithStsRequest();
3    // 负载均衡Id
4    request.setBlbId("blbId");
5    // 部署名称
6    request.setStsName("stsName");
7    GetBecBlbBindingPodListWithStsResponse response = client.getBecBlbBindingPodListWithSts(request);
8}

1public void createBecBlbBinding(BecClient client) {
2    CreateBecBlbBindingRequest request = new CreateBecBlbBindingRequest();
3
4    // 负载均衡Id
5    request.setBlbId("blbId");
6    // 部署名称
7    request.setDeploymentId("deploymentId");
8    // 权重
9    request.setDefaultWeight(80);
10
11    // 容器组\虚机实例列表
12    List<Backends> podWeight = new LinkedList<Backends>();
13    Backends backends = new Backends();
14    // 容器组\虚机实例名称
15    backends.setName("name");
16    // 容器组\虚机实例权重
17    backends.setWeight(20);
18    // 容器组\虚机实例
19    podWeight.add(backends);
20    // 容器组\虚机实例列表
21    request.setPodWeight(podWeight);
22    CreateBecBlbBindingResponse response = client.createBecBlbBinding(request);
23}

1public void updateBecBlbBindPodWeight(BecClient client) {
2    UpdateBecBlbBindPodWeightRequest request = new UpdateBecBlbBindPodWeightRequest();
3
4   // 后端服务器信息
5    List<Backends> podWeightList = new ArrayList<Backends>();
6    Backends backends = new Backends();
7    // 后端服务器权重
8    backends.setWeight(100);
9    // 后端服务器名称
10    backends.setName("name");
11    podWeightList.add(backends);
12
13    // 负载均衡Id
14    request.setBlbId("blbId");
15    request.setPodWeightList(podWeightList);
16
17    UpdateBecBlbBindPodWeightResponse response = client.updateBecBlbBindPodWeight(request);
18}

1public void getBecBlbResourceMetrics(BecClient client) {
2    GetBecBlbResourceMetricsRequest request = new GetBecBlbResourceMetricsRequest();
3    // 负载均衡Id
4    request.setBlbId("blbId");
5    // 监控指标类型，支持bandwidth_receive（入网带宽）、bandwidth_transmit（出网带宽）、traffic_receive（入网流量）、traffic_transmit（出网流量）
6    request.setType("bandwidth_receive");
7    // 支持"extranet"、"intranet"，分别对应公网、内网
8    request.setIpType("extranet");
9    // 偏移时间
10    request.setOffsetInSeconds(3600);
11    // 数据点间隔（单位：分钟）
12    request.setStepInMin(5);
13
14    GetBecBlbResourceMetricsResponse response = client.getBecBlbResourceMetrics(request);
15}