集群

1def create_cluster_example(self):
2    """
3    创建集群
4    """
5    # 创建集群的名称
6    # 支持字母(a-z及A-Z)、数字(0-9),长度小于20个字符
7    name = 'your cluster name'
8    
9    # 创建集群的密码
10    # 支持小写字母(a-z)、大写字母(A-Z)、数字(0-9)、下划线(_) ,并且至少包含其中三种, 长度6~12个字符
11    password = 'your cluster password'
12    
13    # 设置节点类型信息
14    # type表示节点的类型；es_node表示es节点、kibana表示kibana节点
15    # instance_num表示节点的数量
16    # slot_type表示资源配置类型（新旧套餐的资源配置类型，详见代码下方说明）
17    slot_type = 'calculate_v1'
18    modules = [Module(type='es_node', instance_num=1, slot_type=slot_type),
19               Module(type='kibana', instance_num=1, slot_type=slot_type)]
20    
21    # 创建集群的版本，sdk支持的版本是'7.4.2'、'6.5.3'、'5.5.0'，其中创建'6.5.3'、'5.5.0'版本需要提工单进行开通
22    version = '7.4.2'
23    
24    # 设置是否为新套餐集群，True表示老套餐、False表示新套餐
25    is_old_package = True
26
27    # 设置创建集群时用的可用区（见代码下方说明）     
28    available_zone = 'available_zone'
29
30    # 设置安全组ID（见代码下方说明）
31    security_group_id = 'security_group_id'
32
33    # 设置子网ID（见代码下方说明）
34    subnet_uuid = 'subnet_uuid'
35
36    # 设置创建集群时用的VPC（见代码下方说明）
37    vpc_id = 'vpc_id'
38  
39    # 创建集群计费信息
40    # payment_type表示付费方式，'postpay'表示后付费、'prepay'表示预付费
41    # time表示购买时长，单位是月；payment_type为'postpay'时，设置为0
42    billing = Billing(payment_type='postpay', time=0)
43
44    response = client.create_cluster(name=name,
45                                     password=password,
46                                     modules=modules,
47                                     version=version,
48                                     is_old_package=is_old_package,
49                                     available_zone=available_zone,
50                                     security_group_id=security_group_id,
51                                     subnet_uuid=subnet_uuid,
52                                     vpc_id=vpc_id,
53                                     billing=billing)
54    assertEqual(type(response), baidubce.bce_response.BceResponse)
55    
56    # 输出响应
57    print(response)
58    if response.success:
59        # 执行成功
60        print(response.status)  # http响应码
61        print(response.result)  # 返回结果
62    else:
63        # 执行失败
64        print(
65            response.status,  # http响应码
66            response.code,    # 错误码
67            response.error.message  # 报错信息
68        )

1def create_cluster_example(self):
2    """
3    创建集群
4    """
5    # 创建集群的名称
6    # 支持字母(a-z及A-Z)、数字(0-9),长度小于20个字符
7    name = 'your cluster name'
8    
9    # 创建集群的密码
10    # 支持小写字母(a-z)、大写字母(A-Z)、数字(0-9)、下划线(_) ,并且至少包含其中三种, 长度6~12个字符
11    password = 'your cluster password'
12    
13    # 设置节点磁盘信息
14    # type表示磁盘类型（见代码下方说明）
15    # size表示磁盘大小，单位是G
16    disk_slot_info = DiskSlotInfo(type='premium_ssd', size=50)
17    
18    # 设置节点类型信息
19    # type表示节点的类型；es_node表示es节点、kibana表示kibana节点
20    # instance_num表示节点的数量
21    # slot_type表示资源配置类型（新旧套餐的资源配置类型，详见代码下方说明）
22    # disk_slot_info表示磁盘信息
23    modules = [Module(type='es_node', instance_num=1, slot_type='bes.g3.c2m8', disk_slot_info=disk_slot_info),
24               Module(type='kibana', instance_num=1, slot_type='bes.c3.c1m2')]
25    
26    # 创建集群的版本，sdk支持的版本是'7.4.2'(低于该版本的es集群不支持新套餐)
27    version = '7.4.2'
28    
29    # 设置是否为新套餐集群，True表示老套餐、False表示新套餐
30    is_old_package = False
31
32    # 设置创建集群时用的可用区（见代码下方说明）     
33    available_zone = 'available_zone'
34
35    # 设置安全组ID（见代码下方说明）
36    security_group_id = 'security_group_id'
37
38    # 设置子网ID（见代码下方说明）
39    subnet_uuid = 'subnet_uuid'
40
41    # 设置创建集群时用的VPC（见代码下方说明）
42    vpc_id = 'vpc_id'
43  
44    # 创建集群计费信息
45    # payment_type表示付费方式，'postpay'表示后付费、'prepay'表示预付费
46    # time表示购买时长，单位是月；payment_type为'postpay'时，设置为0
47    billing = Billing(payment_type='postpay', time=0)
48
49    response = client.create_cluster(name=name,
50                                     password=password,
51                                     modules=modules,
52                                     version=version,
53                                     is_old_package=is_old_package,
54                                     available_zone=available_zone,
55                                     security_group_id=security_group_id,
56                                     subnet_uuid=subnet_uuid,
57                                     vpc_id=vpc_id,
58                                     billing=billing)
59    assertEqual(type(response), baidubce.bce_response.BceResponse)
60    
61    # 输出响应
62    print(response)
63    if response.success:
64        # 执行成功
65        print(response.status)  # http响应码
66        print(response.result)  # 返回结果
67    else:
68        # 执行失败
69        print(
70            response.status,  # http响应码
71            response.code,    # 错误码
72            response.error.message  # 报错信息
73        )

1def create_cluster_example(self):
2    """
3    创建集群
4    """
5    # 创建集群的名称
6    # 支持字母(a-z及A-Z)、数字(0-9),长度小于20个字符
7    name = 'your cluster name'
8    
9    # 创建集群的密码
10    # 支持小写字母(a-z)、大写字母(A-Z)、数字(0-9)、下划线(_) ,并且至少包含其中三种, 长度6~12个字符
11    password = 'your cluster password'
12    
13    # 设置专用master节点磁盘信息
14    # size表示磁盘大小，单位是G
15    # 专用master节点的磁盘类型需设置为premium_ssd，固定不变
16    # 专用master节点的磁盘大小需设置为20G，固定不变
17    dedicated_master_disk_slot_info = DiskSlotInfo(type='premium_ssd', size=20)
18
19    # 设置节点磁盘信息（非专用master节点）
20    # type表示磁盘类型（见代码下方说明）
21    # size表示磁盘大小，单位是G
22    disk_slot_info = DiskSlotInfo(type='premium_ssd', size=50)
23    
24    # 设置节点类型信息
25    # type表示节点的类型；es_node表示es节点、kibana表示kibana节点、es_dedicated_master表示专用master节点
26    # instance_num表示节点的数量（专用master节点的数量只能设置为3或者5）
27    # slot_type表示资源配置类型（新旧套餐、专用master节点的资源配置类型，详见代码下方说明）
28    # disk_slot_info表示磁盘信息
29    modules = [Module(type='es_node', instance_num=1, slot_type='bes.g3.c2m8', disk_slot_info=disk_slot_info),
30               Module(type='kibana', instance_num=1, slot_type='bes.c3.c1m2'),
31               Module(type='es_dedicated_master', instance_num=3, slot_type='bes.g3.c2m8',
32                                                        disk_slot_info=dedicated_master_disk_slot_info)]
33    
34    # 创建集群的版本，sdk支持的版本是'7.4.2'(低于该版本的es集群不支持新套餐)
35    # 只有新套餐集群支持专用master节点的创建
36    version = '7.4.2'
37    
38    # 设置是否为新套餐集群，True表示老套餐、False表示新套餐
39    is_old_package = False
40
41    # 设置创建集群时用的可用区（见代码下方说明）     
42    available_zone = 'available_zone'
43
44    # 设置安全组ID（见代码下方说明）
45    security_group_id = 'security_group_id'
46
47    # 设置子网ID（见代码下方说明）
48    subnet_uuid = 'subnet_uuid'
49
50    # 设置创建集群时用的VPC（见代码下方说明）
51    vpc_id = 'vpc_id'
52  
53    # 创建集群计费信息
54    # payment_type表示付费方式，'postpay'表示后付费、'prepay'表示预付费
55    # time表示购买时长，单位是月；payment_type为'postpay'时，设置为0
56    billing = Billing(payment_type='postpay', time=0)
57
58    response = client.create_cluster(name=name,
59                                     password=password,
60                                     modules=modules,
61                                     version=version,
62                                     is_old_package=is_old_package,
63                                     available_zone=available_zone,
64                                     security_group_id=security_group_id,
65                                     subnet_uuid=subnet_uuid,
66                                     vpc_id=vpc_id,
67                                     billing=billing)
68    assertEqual(type(response), baidubce.bce_response.BceResponse)
69    
70    # 输出响应
71    print(response)
72    if response.success:
73        # 执行成功
74        print(response.status)  # http响应码
75        print(response.result)  # 返回结果
76    else:
77        # 执行失败
78        print(
79            response.status,  # http响应码
80            response.code,    # 错误码
81            response.error.message  # 报错信息
82        )

1def resize_cluster_example(self):
2
3    # 指定集群的名称
4    name = 'your cluster name'
5    
6    # 指定付费方式，'postpay'表示后付费、'prepay'表示预付费
7    payment_type = 'postpay'
8    
9    # 指定集群id
10    cluster_id = 'your cluster id'
11    
12    # 集群版本
13    version = '7.4.2'
14
15    # 扩容信息
16    # 设置实例类型type='es_node' 节点配置类型 slot_type = 'calculate_v1'，扩容节点数量 desire_instance_num=2 
17    modules_resize = [
18        Module(type='es_node', slot_type='calculate_v1', version=version, desire_instance_num=2)]
19
20    # 区域    
21    region = 'bj'
22    response = client.resize_cluster(name=name,
23                                     payment_type=payment_type,
24                                     cluster_id=cluster_id,
25                                     region=region,
26                                     modules=modules_resize)
27    assertEqual(type(response), baidubce.bce_response.BceResponse)
28    if response.success:
29        print(response.status)  # http响应码
30        print(response.result)  # 返回结果
31    else:
32        print(
33            response.status,  # http响应码
34            response.code,  # 错误码
35            response.error.message  # 报错信息
36        )

1# 例子：升级ES节点配置类型
2def upgrade_es_slot_type_example(self):
3
4    # 指定集群的名称
5    name = 'your cluster name'
6
7    # 指定付费方式，'postpay'表示后付费、'prepay'表示预付费
8    payment_type = 'postpay'
9
10    # 指定集群id
11    cluster_id = 'your cluster id'
12
13    # 集群版本
14    version = '7.4.2'
15
16    # 升配信息
17    # 实例类型type='es_node' 
18    # 目标节点配置类型（高于当前操作集群配置类型） slot_type = 'bes.g3.c4m16' 
19    # 节点数量(与当前操作集群保持一致) desire_instance_num=2
20    modules_upgrade_es = [
21        Module(type='es_node', slot_type='bes.g3.c4m16', version=version, desire_instance_num=2)]
22
23    # 区域
24    region = 'bj'
25    response = client.resize_cluster(name=name,
26                                     payment_type=payment_type,
27                                     cluster_id=cluster_id,
28                                     region=region,
29                                     modules=modules_upgrade_es)
30    assertEqual(type(response), baidubce.bce_response.BceResponse)
31    if response.success:
32        print(response.status)  # http响应码
33        print(response.result)  # 返回结果
34    else:
35        print(
36            response.status,  # http响应码
37            response.code,  # 错误码
38            response.error.message  # 报错信息
39        )

1# 例子：升级ES磁盘容量
2def upgrade_es_disk_size_example(self):
3
4    # 指定集群的名称
5    name = 'your cluster name'
6
7    # 指定付费方式，'postpay'表示后付费、'prepay'表示预付费
8    payment_type = 'postpay'
9
10    # 指定集群id
11    cluster_id = 'your cluster id'
12
13    # 集群版本
14    version = '7.4.2'
15
16    # 升配信息
17    # 磁盘类型type（升配不能修改磁盘类型，与当前操作集群保持一致）
18    # 目标磁盘大小size（大于当前操作集群的磁盘大小配置）
19    # 由于磁盘扩容技术升级，对于2021年3月19日0点之后创建的集群，支持磁盘在线热扩容，之前的集群暂不支持磁盘扩容。
20    upgrade_disk_slot_Info = DiskSlotInfo( type="ssd", size=51 )
21    
22    # 实例类型type='es_node' 
23    # 节点配置类型（与当前操作集群保持一致）slot_type = 'bes.g3.c4m16'
24    # 节点数量（与当前操作集群保持一致）desire_instance_num=2，
25    modules_upgrade_es = [
26        Module(type='es_node', slot_type='bes.g3.c4m16', version=version, 
27        desire_instance_num=2, disk_slot_info=upgrade_disk_slot_Info)]
28
29    # 区域
30    region = 'bj'
31    response = client.resize_cluster(name=name,
32                                     payment_type=payment_type,
33                                     cluster_id=cluster_id,
34                                     region=region,
35                                     modules=modules_upgrade_es)
36    assertEqual(type(response), baidubce.bce_response.BceResponse)
37    if response.success:
38        print(response.status)  # http响应码
39        print(response.result)  # 返回结果
40    else:
41        print(
42            response.status,  # http响应码
43            response.code,  # 错误码
44            response.error.message  # 报错信息
45        )

1def get_cluster_list_example(self):
2    response = client.get_cluster_list(page_no=1, page_size=100)
3    assertEqual(type(response), baidubce.bce_response.BceResponse)
4    page = response.page
5    if page is None:
6        return
7    for cluster in (page.result or []):
8        print(cluster.cluster_id)

1def get_cluster_detail_example(self):
2    cluster_id = 'your cluster id'
3    response = client.get_cluster_detail(cluster_id=cluster_id)
4    assertEqual(type(response), baidubce.bce_response.BceResponse)
5    print(response)

1def stop_cluster_example(self):
2    cluster_id = 'your cluster id'
3    response = client.stop_cluster(cluster_id=cluster_id)
4    if response.success:
5        # 执行成功
6        print(response.status)  # http响应码
7    else:
8        # 执行失败
9        print(
10            response.status,  # http响应码
11            response.code,    # 错误码
12            response.error.message  # 报错信息
13        )

1def start_cluster_example(self):
2    cluster_id = 'your cluster id'
3    response = client.start_cluster(cluster_id=cluster_id)
4    if response.success:
5        # 执行成功
6        print(response.status)  # http响应码
7    else:
8        # 执行失败
9        print(
10            response.status,  # http响应码
11            response.code,    # 错误码
12            response.error.message  # 报错信息
13        ) 

1def delete_cluster_example(self):
2    cluster_id = 'your cluster id'
3    response = client.delete_cluster(cluster_id=cluster_id) 
4    if response.success:
5        # 执行成功
6        print(response.status)  # http响应码
7    else:
8        # 执行失败
9        print(
10            response.status,  # http响应码
11            response.code,    # 错误码
12            response.error.message  # 报错信息
13        )

1def get_renew_list_example(self):
2    # 页数 
3    page_no=1
4    # 页大小
5    page_size=2
6    # 排序规则：desc降序、asc升序
7    order='desc'
8    # 排序字段
9    order_by='expireTime'
10    # 多少天内过期（与当前时间比较）
11    days_to_expiration=70
12
13    response = client.get_renew_list(page_no=1,
14                                     page_size=2,
15                                     order='desc',
16                                     order_by='expireTime',
17                                     days_to_expiration=70)
18    assertEqual(type(response), baidubce.bce_response.BceResponse)
19    print(response)
20    page = response.page
21    if page is None:
22        return
23    for cluster in (page.result or []):
24        print('cluster.cluster_id:' + cluster.cluster_id)

1def renew_cluster_example(self):
2    cluster_id = 'your cluster id'
3    # 续费时长，单位:月
4    time = 1
5    response = client.renew_cluster(cluster_id=cluster_id, time=time)
6    print(response)

1def create_auto_renew_rule_example(self):
2    cluster_id = 'cluster_id'
3    cluster_ids = [cluster_id]
4    user_id = 'user_id'
5    renew_time_unit = 'month'
6    renew_time = 2
7    region = 'bj'
8    response = client.create_auto_renew_rule(cluster_ids=cluster_ids, user_id=user_id, region=region,
9                                                  renew_time_unit=renew_time_unit, renew_time=renew_time)
10    assertEqual(type(response), baidubce.bce_response.BceResponse)
11    print(response)

1def update_auto_renew_rule_example(self):
2    cluster_id = 'cluster_id'
3    renew_time_unit = 'month'
4    renew_time = 3
5    response = client.update_auto_renew_rule(cluster_id=cluster_id,
6                                             renew_time_unit=renew_time_unit,
7                                             renew_time=renew_time)
8    assertEqual(type(response), baidubce.bce_response.BceResponse)
9    print(response)

1def delete_auto_renew_rule_example(self):
2    cluster_id = 'cluster_id'
3    response = client.delete_auto_renew_rule(cluster_id=cluster_id)
4    assertEqual(type(response), baidubce.bce_response.BceResponse)
5    print(response)

1def get_auto_renew_rule_list_example(self):
2    response = client.get_auto_renew_rule_list()
3    assertEqual(type(response), baidubce.bce_response.BceResponse)
4    print(response)