集群

1public void createCluster(BesClient client) {
2    // 构建集群的请求体
3    BesCreateClusterRequest createOrderRequestVo = new BesCreateClusterRequest();
4    // 创建节点类型模板
5    BesCreateClusterRequest.ModuleInfo dataNodeModuleInfo = new BesCreateClusterRequest.ModuleInfo();
6    // 创建节点类型模板
7    BesCreateClusterRequest.ModuleInfo kibanaNodeModuleInfo2 = new BesCreateClusterRequest.ModuleInfo();
8    List<BesCreateClusterRequest.ModuleInfo> moduleInfoList = new ArrayList<BesCreateClusterRequest.ModuleInfo>();
9    // 创建集群的付费方式
10    BesCreateClusterRequest.ClusterBilling clusterBilling = new BesCreateClusterRequest.ClusterBilling();
11    // 设置创建集群的名称
12    createOrderRequestVo.setName({clusterName});
13    // 设置创建集群的密码
14    createOrderRequestVo.setPassword({passwrod});
15    // 设置集群所配置的节点类型
16    dataNodeModuleInfo.setType(ModuleType.ES_NODE);
17    // 设置该节点类型的节点数量
18    dataNodeModuleInfo.setInstanceNum(1);
19    // 设置es节点的机型（新老节点配置见代码下方说明）
20    dataNodeModuleInfo.setSlotType(SlotType.CALCULATE_V1);
21    // 设置集群所配置的节点类型
22    kibanaNodeModuleInfo.setType(ModuleType.KIBANA);
23    // 设置该节点类型的节点数量 （必须创建1个kibana节点)
24    kibanaNodeModuleInfo.setInstanceNum(1);
25    // 指定kibana节点的机型 老套餐是免费附赠的 值必须和ES节点配置相同 （新老节点配置见代码下方说明）
26    kibanaNodeModuleInfo.setSlotType(SlotType.CALCULATE_V1);
27    moduleInfoList.add(dataNodeModuleInfo);
28    moduleInfoList.add(kibanaNodeModuleInfo);
29    // 设置集群的付费方式为预付费 （后付费为POSTPAY）
30    clusterBilling.setPaymentType(PaymentType.PREPAY);
31    // 设置创建集群的时长 （后付费为0）
32    clusterBilling.setTime(1);
33    createOrderRequestVo.setModules(moduleInfoList);
34    createOrderRequestVo.setBilling(clusterBilling);
35    // 设置集群版本 （sdk支持的版本是'7.4.2'、'6.5.3'、'5.5.0'，其中创建'6.5.3'、'5.5.0'版本需要提工单进行开通）
36    createOrderRequestVo.setVersion("7.4.2");
37    // 设置创建集群时用的可用区 （见代码下方说明）
38    createOrderRequestVo.setAvailableZone({可用区名称});
39    // 设置创建集群时用的安全组 （见代码下方说明）
40    createOrderRequestVo.setSecurityGroupId({安全组ID});
41    // 设置创建集群时用的子网（见代码下方说明）
42    createOrderRequestVo.setSubnetUuid({子网ID});
43    // 设置创建集群时用的VPC（见代码下方说明）
44    createOrderRequestVo.setVpcId({VpcId});
45    // 是否是老套餐
46    createOrderRequestVo.setOldPackage(true);
47    BesCreateClusterResponse deploy = besClient.createCluster(createOrderRequestVo);
48}

1public void createCluster(BesClient client) {
2     // 构建集群的请求体
3    BesCreateClusterRequest createOrderRequestVo = new BesCreateClusterRequest();
4    // 创建节点类型模板
5    BesCreateClusterRequest.dataNodeModuleInfo moduleInfo = new BesCreateClusterRequest.ModuleInfo();
6    BesCreateClusterRequest.ModuleInfo KibanaNodeModuleInfo = new BesCreateClusterRequest.ModuleInfo();
7    List<BesCreateClusterRequest.ModuleInfo> moduleInfoList = new ArrayList<BesCreateClusterRequest.ModuleInfo>();
8    // 创建集群的付费方式
9    BesCreateClusterRequest.ClusterBilling clusterBilling = new BesCreateClusterRequest.ClusterBilling();
10    // 设置创建集群的名称
11    createOrderRequestVo.setName({clusterName});
12    // 设置创建集群的密码
13    createOrderRequestVo.setPassword({passwrod});
14    // 设置集群所配置的节点类型
15    dataNodeModuleInfo.setType(ModuleType.ES_NODE);
16    // 设置该节点类型的节点数量
17    dataNodeModuleInfo.setInstanceNum(1);
18    // 设置es节点的机型
19    dataNodeModuleInfo.setSlotType(SlotType.BES_C3_CPU_2_MEM_4);
20    // 磁盘信息(新版套餐磁盘需要单独指定大小)
21    DiskSlotInfo dataNodeDiskSlotInfo = new DiskSlotInfo();
22    // 磁盘大小 单位G 最小为50G premium_ssd最大为6144G ssd最大为20480G
23    dataNodeDiskSlotInfo.setSize(50);
24    // 磁盘类型 （现支持PREMIUM_SSD和SSD两种磁盘类型）
25    dataNodeDiskSlotInfo.setType(DiskType.PREMIUM_SSD);
26    // 设置磁盘信息
27    dataNodeModuleInfo.setDiskSlotInfo(dataNodeDiskSlotInfo);
28    // 设置集群所配置的节点类型
29    kibanaNodeModuleInfo.setType(ModuleType.KIBANA);
30    // 设置该节点类型的节点数量 （必须创建1个kibana节点)
31    kibanaNodeModuleInfo.setInstanceNum(1);
32    // 指定kibana节点的机型 新套餐中bes.c3.c1m2为免费节点 （新老节点配置见代码下方说明）
33    kibanaNodeModuleInfo.setSlotType(SlotType.KIBANA_C3_CPU_1_MEM_2);
34    
35    moduleInfoList.add(dataNodeModuleInfo);
36    moduleInfoList.add(kibanaNodeModuleInfo);
37    // 设置集群的付费方式为预付费 （后付费为POSTPAY）
38    clusterBilling.setPaymentType(PaymentType.PREPAY);
39    // 设置创建集群的时长 （后付费为0）
40    clusterBilling.setTime(1);
41    createOrderRequestVo.setModules(moduleInfoList);
42    createOrderRequestVo.setBilling(clusterBilling);
43    // 设置集群版本 （新套餐只支持7.4.2）
44    createOrderRequestVo.setVersion("7.4.2");
45    // 设置创建集群时用的可用区 （见代码下方说明）
46    createOrderRequestVo.setAvailableZone({可用区名称});
47    // 设置创建集群时用的安全组 （见代码下方说明）
48    createOrderRequestVo.setSecurityGroupId({安全组ID});
49    // 设置创建集群时用的子网（见代码下方说明）
50    createOrderRequestVo.setSubnetUuid({子网ID});
51    // 设置创建集群时用的VPC（见代码下方说明）
52    createOrderRequestVo.setVpcId({VpcId});
53    // 是否是老套餐
54    createOrderRequestVo.setOldPackage(false);
55    BesCreateClusterResponse deploy = besClient.createCluster(createOrderRequestVo);
56}

1public void createCluster(BesClient client) {
2    // 构建集群的请求体
3    BesCreateClusterRequest createOrderRequestVo = new BesCreateClusterRequest();
4    // 创建节点类型模板
5    BesCreateClusterRequest.dataNodeModuleInfo moduleInfo = new BesCreateClusterRequest.ModuleInfo();
6    BesCreateClusterRequest.ModuleInfo KibanaNodeModuleInfo = new BesCreateClusterRequest.ModuleInfo();
7    BesCreateClusterRequest.ModuleInfo masterNodeModuleInfo = new BesCreateClusterRequest.ModuleInfo();
8    List<BesCreateClusterRequest.ModuleInfo> moduleInfoList = new ArrayList<BesCreateClusterRequest.ModuleInfo>();
9    // 创建集群的付费方式
10    BesCreateClusterRequest.ClusterBilling clusterBilling = new BesCreateClusterRequest.ClusterBilling();
11    // 设置创建集群的名称
12    createOrderRequestVo.setName({clusterName});
13    // 设置创建集群的密码
14    createOrderRequestVo.setPassword({passwrod});
15    // 设置集群所配置的节点类型
16    dataNodeModuleInfo.setType(ModuleType.ES_NODE);
17    // 设置该节点类型的节点数量
18    dataNodeModuleInfo.setInstanceNum(1);
19    // 设置es节点的机型
20    dataNodeModuleInfo.setSlotType(SlotType.BES_C3_CPU_2_MEM_4);
21    // 磁盘信息(新版套餐磁盘需要单独指定大小)
22    DiskSlotInfo dataNodeDiskSlotInfo = new DiskSlotInfo();
23    // 磁盘大小 单位G 最小为50G premium_ssd最大为6144G ssd最大为20480G
24    dataNodeDiskSlotInfo.setSize(50);
25    // 磁盘类型 （现支持PREMIUM_SSD和SSD两种磁盘类型）
26    dataNodeDiskSlotInfo.setType(DiskType.PREMIUM_SSD);
27    // 设置磁盘信息
28    dataNodeModuleInfo.setDiskSlotInfo(dataNodeDiskSlotInfo);
29    // 设置集群所配置的节点类型
30    kibanaNodeModuleInfo.setType(ModuleType.KIBANA);
31    // 设置该节点类型的节点数量 （必须创建1个kibana节点)
32    kibanaNodeModuleInfo.setInstanceNum(1);
33    // 指定kibana节点的机型 新套餐中bes.c3.c1m2为免费节点 （新老节点配置见代码下方说明）
34    kibanaNodeModuleInfo.setSlotType(SlotType.KIBANA_C3_CPU_1_MEM_2);
35    
36    // 设置集群所配置的节点类型
37    masterNodeModuleInfo.setType(ModuleType.ES_DEDICATED_MASTER);
38    // 设置该节点类型的节点数量 （必须3或5节点)
39    masterNodeModuleInfo.setInstanceNum(3);
40    // 设置专用master节点的机型（专用master节点配置见代码下方说明）
41    masterNodeModuleInfo.setSlotType(SlotType.BES_G3_CPU_2_MEM_8);
42    // 磁盘信息
43     DiskSlotInfo masterNodeDiskSlotInfo = new DiskSlotInfo();
44     // 磁盘大小（master节点固定20g）
45    masterNodeDiskSlotInfo.setSize(20);
46    // 磁盘类型（master节点类型固定为PREMIUM_SSD）
47    masterNodeDiskSlotInfo.setType(DiskType.PREMIUM_SSD);
48    masterNodeDiskSlotInfo.setDiskSlotInfo(masterNodeDiskSlotInfo);
49    
50    moduleInfoList.add(dataNodeModuleInfo);
51    moduleInfoList.add(kibanaNodeModuleInfo);
52    moduleInfoList.add(masterNodeModuleInfo);
53    // 设置集群的付费方式为预付费 （后付费为POSTPAY）
54    clusterBilling.setPaymentType(PaymentType.PREPAY);
55    // 设置创建集群的时长 （后付费为0）
56    clusterBilling.setTime(1);
57    createOrderRequestVo.setModules(moduleInfoList);
58    createOrderRequestVo.setBilling(clusterBilling);
59    // 设置集群版本 （新套餐只支持7.4.2）
60    createOrderRequestVo.setVersion("7.4.2");
61    // 设置创建集群时用的可用区 （见代码下方说明）
62    createOrderRequestVo.setAvailableZone({可用区名称});
63    // 设置创建集群时用的安全组 （见代码下方说明）
64    createOrderRequestVo.setSecurityGroupId({安全组ID});
65    // 设置创建集群时用的子网（见代码下方说明）
66    createOrderRequestVo.setSubnetUuid({子网ID});
67    // 设置创建集群时用的VPC（见代码下方说明）
68    createOrderRequestVo.setVpcId({VpcId});
69    // 是否是老套餐(带有专有master的集群必须为新套餐)
70    createOrderRequestVo.setOldPackage(false);
71    BesCreateClusterResponse deploy = besClient.createCluster(createOrderRequestVo);
72}

1 BesResizeClusterRequest besResizeClusterRequest = new BesResizeClusterRequest();
2        BesResizeClusterRequest.ModuleDesc moduleDesc = new BesResizeClusterRequest.ModuleDesc();
3        BesResizeClusterRequest.ModuleDesc moduleDesc2 = new BesResizeClusterRequest.ModuleDesc();
4        DiskSlotInfo diskSlotInfo = new DiskSlotInfo();
5        List<BesResizeClusterRequest.ModuleDesc> modules = new ArrayList<BesResizeClusterRequest.ModuleDesc>();
6        // 设置集群所在区域
7        besResizeClusterRequest.setRegion("bj");
8        // 设置需要扩容集群名称
9        besResizeClusterRequest.setName("isTest0309");
10        // 设置支付方式
11        besResizeClusterRequest.setPaymentType(PaymentType.POSTPAY);
12        // 设置需要升配的集群ID
13        besResizeClusterRequest.setClusterId(clusterId);
14        
15        // 设置节点类型
16        moduleDesc.setType(ModuleType.ES_NODE);
17        // 设置机型（如果是升配机型，数量和磁盘大小需要和升配前保持一致）
18        moduleDesc.setSlotType(SlotType.BES_G3_CPU_8_MEM_32);
19        // 节点数量
20        moduleDesc.setDesireInstanceNum(2);
21        // 磁盘类型
22        diskSlotInfo.setType(DiskType.PREMIUM_SSD);
23        // 磁盘大小（如果是升配磁盘，数量和机型需要和升配前保持一致）
24        diskSlotInfo.setSize(60);
25        moduleDesc.setDiskSlotInfo(diskSlotInfo);
26
27        // 设置节点类型
28        moduleDesc2.setType(ModuleType.KIBANA);
29        // 设置机型（如果是升配机型，数量和磁盘大小需要和升配前保持一致）
30        moduleDesc2.setSlotType(SlotType.BES_C3_CPU_2_MEM_4);
31        // 节点数量
32        moduleDesc2.setDesireInstanceNum(1);
33
34        modules.add(moduleDesc);
35        modules.add(moduleDesc2);
36        besResizeClusterRequest.setModules(modules);
37        BesCreateClusterResponse besCreateClusterResponse = this.besClient.resizeCluster(besResizeClusterRequest);

1public void resizeCluster(BesClient client) {
2    BesResizeClusterRequest besResizeClusterRequest = new BesResizeClusterRequest();
3    BesResizeClusterRequest.ModuleDesc moduleDesc = new BesResizeClusterRequest.ModuleDesc();
4    List<BesResizeClusterRequest.ModuleDesc> modules = new ArrayList<BesResizeClusterRequest.ModuleDesc>();
5    // 设置集群所在区域
6    besResizeClusterRequest.setRegion("bj");
7    // 设置需要扩容集群名称
8    besResizeClusterRequest.setName("clusterName");
9    // 设置付费方式
10    besResizeClusterRequest.setPaymentType(PaymentType.PREPAY);
11    // 设置需要扩容集群ID
12    besResizeClusterRequest.setDeployId("clusterId");
13    // 设置需要扩容集群版本（需和创建时的集群版本一致）
14    moduleDesc.setVersion("7.4.2");
15    // 设置需要扩容的节点类型
16    moduleDesc.setType(ModuleType.ES_NODE);
17    // 设置需要扩容的节点配置类型 （需和创建时的类型一致）
18    moduleDesc.setSlotType(SlotType.BES_C3_CPU_8_MEM_16);
19    // 设置需要扩容后的节点数量 (数量不可少于当前es_node节点数量)
20    moduleDesc.setDesireInstanceNum(2);
21    modules.add(moduleDesc);
22    besResizeClusterRequest.setModules(modules);
23    BesCreateClusterResponse besCreateClusterResponse = this.besClient.resizeCluster(besResizeClusterRequest);
24}

1public void listClusters(BesClient client) {
2	BesListClusterRequest besListClusterRequest = new BesListClusterRequest();
3    // 当前页数（最小1）
4    besListClusterRequest.setPageNo(1);
5    // 设置每页展示几个集群信息(最小20)
6    besListClusterRequest.setPageSize(20);
7    BesListClusterResponse besListClusterResponse = besClient.clusterList(besListClusterRequest);
8}

1public void getClusterDetail(BesClient client) {
2    BesClusterDetailRequest besClusterDetailRequest = new BesClusterDetailRequest();
3    // 设置需要查询的集群ID
4    besClusterDetailRequest.setClusterId(clusterId);
5    BesClusterDetailResponse besClusterDetailResponse = besClient.clusterDetail(besClusterDetailRequest);
6}

1public void stopCluster(BesClient client) {
2    BesStopClusterRequest besStopClusterRequest = new BesStopClusterRequest();
3    // 设置需要停止的集群ID
4    besStopClusterRequest.setClusterId(clusterId);
5    besClient.stopCluster(besStopClusterRequest);
6}

1public void startCluster(BesClient client) {
2	BesStartClusterRequest besStartClusterRequest = new BesStartClusterRequest();
3    // 设置需要启动的集群ID
4    besStartClusterRequest.setClusterId(clusterId);
5    besClient.startCluster(besStartClusterRequest);
6}

1public void deleteCluster(BesClient client) {
2    BesDeleteClusterRequest besDeleteClusterRequest = new BesDeleteClusterRequest();
3    // 设置需要删除的集群ID
4    besDeleteClusterRequest.setClusterId(clusterId);
5    besClient.deleteCluster(besDeleteClusterRequest);
6}

1public void getRenewList(BesClient client) {
2   BesGetRenewListRequest listAutoRenew = new BesGetRenewListRequest();
3        # 排序规则：desc降序、asc升序
4        listAutoRenew.setOrder("desc");
5        # 排序字段
6        listAutoRenew.setOrderBy("expireTime");
7        # 页数 
8        listAutoRenew.setPageNo(1);
9        # 页大小
10        listAutoRenew.setPageSize(15);
11        # 多少天内过期（与当前时间比较）
12        listAutoRenew.setDaysToExpiration(15);
13        besClient.getRenewList(listAutoRenew);
14}

1public void renewCluster(BesClient client) {
2   BesGetRenewListRequest listAutoRenew = new BesGetRenewListRequest();
3        BesRenewClusterRequest besRenewClusterRequest = new BesRenewClusterRequest();
4        # 集群ID
5        besRenewClusterRequest.setClusterId(clusterId);
6         # 续费时长，单位:月
7        besRenewClusterRequest.setTime(1);
8
9        besClient.renewCluster(besRenewClusterRequest);
10}

1public void createAutoRenewRule(BesClient client) {
2   BesCreateAutoRenewRuleRequest createAutoRenewRuleRequest = new BesCreateAutoRenewRuleRequest();
3        List<String> clusterIds = new ArrayList<String>();
4        clusterIds.add(clusterId);
5        // 集群ID
6        createAutoRenewRuleRequest.setClusterIds(clusterIds);
7        // 用户ID
8        createAutoRenewRuleRequest.setUserId("XXX");
9        // 续费时长
10        createAutoRenewRuleRequest.setRenewTime(1);
11        // 续费时间单位 支持month，yea
12        createAutoRenewRuleRequest.setRenewTimeUnit("month");
13        besClient.createAutoRenewRule(createAutoRenewRuleRequest);
14}

1public void getutoRenewRuleList(BesClient client) {
2   besClient.getAutoRenewRuleList();
3}

1public void updateAutoRenewRule(BesClient client) {
2   BesUpdateAutoRenewRuleRequest updateAutoRenewRuleRequest = new BesUpdateAutoRenewRuleRequest();
3        // 集群ID
4        updateAutoRenewRuleRequest.setClusterId(clusterId);
5        // 续费时长
6        updateAutoRenewRuleRequest.setRenewTime(2);
7        // 续费时间单位 支持month，year
8        updateAutoRenewRuleRequest.setRenewTimeUnit("month");
9        besClient.updateAutoRenewRule(updateAutoRenewRuleRequest);
10}

1public void deleteAutoRenewRule(BesClient client) {
2    // 集群ID
3    deleteAutoRenewRuleRequest.setClusterId(clusterId);
4    besClient.deleteAutoRenewRule(deleteAutoRenewRuleRequest);
5}