实例
更新时间：2025-01-23
创建实例
使用以下代码可以创建BCC实例，包括专属实例、普通型Ⅰ 型实例、普通型ⅠI 型实例、普通型ⅠII 型实例、GPU实例、计算优化I型实例、计算优化II型实例、存储优化I型实例：
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client, bcc_model
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
11 endpoint=HOST)
12 client = bcc_client.BccClient(config)
13
14 response = client.create_instance(
15 instance_type='N6', # 待创建虚拟机实例的类型
16 cpu_count=1, # 待创建虚拟机实例的CPU核数
17 memory_capacity_in_gb=4, # 待创建虚拟机实例的内存容量，单位GB
18 image_id='m-***', # 镜像ID
19 root_disk_size_in_gb=20, # 待创建虚拟机实例的系统盘大小，单位GB，默认是40GB，范围为[40, 2048]GB，超过40GB按照云磁盘价格收费。注意指定的系统盘大小需要满足所使用镜像最小磁盘空间限制。
20 root_disk_storage_type='enhanced_ssd_pl1', # 待创建虚拟机实例系统盘介质，默认使用SSD型云磁盘
21 create_cds_list=[ # 待创建的CDS磁盘列表
22 bcc_model.CreateCdsModel(
23 cdsSizeInGB=50, # CDS磁盘容量，必须为大于0的整数，单位为GB，大小为0~5120G
24 storageType='enhanced_ssd_pl1')], # CDS磁盘存储类型，默认是hp1(高性能云磁盘)。
25 eip_name='eip***', # 长度1～65个字节，字母开头，可包含字母数字-_/.字符。若不传该参数，服务会自动生成name。
26 internet_charge_type='BANDWIDTH_PREPAID', # 公网带宽计费方式，若不指定internetChargeType，默认为按使用带宽计费。
27 purchase_count=1, # 批量创建（购买）的虚拟机实例个数，必须为大于0的整数，可选参数，缺省为1。
28 name='instance-***', # 虚拟机名字。默认都不指定name。如果指定name：批量时name作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
29 hostname='hostn***', # 虚拟机主机名。默认都不指定hostname。如果指定hostname：批量时hostname作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
30 admin_pass='***', # 待创建的实例管理员密码，8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*()。
31 zone_name='cn-bj-a', # 指定zone信息，默认为空，由系统自动选择，可通过调用查询可用区列表接口查询可用区列表。zoneName命名规范是“国家-region-可用区序列"，小写，例如北京可用区A为"cn-bj-a"。
32 subnet_id='sbn-***', # 指定subnet信息，为空时将使用默认子网
33 security_group_id='g-***', # 指定securityGroup信息，为空时将使用默认安全组
34 asp_id='asp-***', # 自动快照策略ID
35 tags=[bcc_model.TagModel('key***', 'value***')], # 待创建虚机的标签列表
36 )
37 print(response)创建实例（通过规格参数）
使用以下代码可以通过规格参数创建BCC实例
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client, bcc_model
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
11 endpoint=HOST)
12 client = bcc_client.BccClient(config)
13
14 response = client.create_instance_by_spec(
15 spec='bcc.g5.c1m4', # 实例规格
16 image_id='m-***', # 镜像ID
17 root_disk_size_in_gb=20, # 待创建虚拟机实例的系统盘大小，单位GB，默认是40GB，范围为[40, 2048]GB，超过40GB按照云磁盘价格收费。注意指定的系统盘大小需要满足所使用镜像最小磁盘空间限制。
18 root_disk_storage_type='enhanced_ssd_pl1', # 待创建虚拟机实例系统盘介质，默认使用SSD型云磁盘
19 create_cds_list=[ # 待创建的CDS磁盘列表
20 bcc_model.CreateCdsModel(
21 cdsSizeInGB=50, # CDS磁盘容量，必须为大于0的整数，单位为GB，大小为0~5120G
22 storageType='enhanced_ssd_pl1')], # CDS磁盘存储类型，默认是hp1(高性能云磁盘)。
23 eip_name='eip***', # 长度1～65个字节，字母开头，可包含字母数字-_/.字符。若不传该参数，服务会自动生成name。
24 internet_charge_type='BANDWIDTH_PREPAID', # 公网带宽计费方式，若不指定internetChargeType，默认为按使用带宽计费。
25 purchase_count=1, # 批量创建（购买）的虚拟机实例个数，必须为大于0的整数，可选参数，缺省为1。
26 name='instance-***', # 虚拟机名字。默认都不指定name。如果指定name：批量时name作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
27 hostname='hostn***', # 虚拟机主机名。。默认都不指定hostname。如果指定hostname：批量时hostname作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
28 admin_pass='***', # 待创建的实例管理员密码，8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*()。
29 zone_name='cn-bj-a', # 指定zone信息，默认为空，由系统自动选择，可通过调用查询可用区列表接口查询可用区列表。zoneName命名规范是“国家-region-可用区序列"，小写，例如北京可用区A为"cn-bj-a"。
30 subnet_id='sbn-***', # 指定subnet信息，为空时将使用默认子网
31 security_group_id='g-***', # 指定securityGroup信息，为空时将使用默认安全组
32 asp_id='asp-***', # 自动快照策略ID
33 tags=[bcc_model.TagModel('key***', 'value***')], # 待创建虚机的标签列表
34 )
35 print(response)-
必传参数：
- 规格名称（例如 bcc.g4.c1m1）
- 镜像ID
- 可选参数：参考普通创建实例接口
创建实例在专属服务器
使用以下代码可以在特定服务器中创建BCC实例：
Python3
1 def create_instance_from_dedicated_host(self):
2 #如果用户未指定client_token参数,用uuid4生成一个随机字符串给client_token
3 generate_client_token = str(uuid.uuid4())
4 client_token = generate_client_token()
5
6 #设置镜像id
7 image_id = 'your-choose-image-id'
8
9 #设置专属服务器id
10 dedicated_host_id = 'your-choose-dedicated-host-id'
11
12 #设置实例名
13 instance_name = 'your-choose-instance-name' + client_token
14
15 #设置实例管理员密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*())
16 admin_pass = 'your-admin-pass'
17
18 #指定subnet信息，为空时将使用默认子网
19 subnet_id = 'your-choose-subnet-id'
20
21 #指定security_group_id信息，为空时将使用默认安全组
22 security_group_id = 'your-choose-security-group-id'
23
24 #DCC专属服务器实例可以创建多块本地盘，需要指定磁盘类型及大小
25 #其它类型只能用一块本地盘，使用默认类型，只需指定大小
26
27 #设置创建本地磁盘大小
28 ephemeral_disk = EphemeralDisk(6144)
29
30 #设置本地盘类型为默认类型
31 ephemeral_disks = [ephemeral_disk.__dict__, ephemeral_disk.__dict__]
32
33 self.assertEqual(
34 type(self.client.create_instance_from_dedicated_host(1, #设置创建BCC的CPU核数
35 2, #设置创建BCC的内存大小GB
36 image_id, #设置创建BCC的镜像
37 dedicated_host_id, #设置创建BCC的专属服务器
38 purchase_count=1,# 批量创建BCC实例时使用，必须为大于0的整数
39 name=instance_name,# 设置创建BCC的名称
40 admin_pass=admin_pass,# 设置实例管理员密码
41 subnet_id=subnet_id,# 指定subnet信息，为空时将使用默认子网
42 security_group_id=security_group_id,# 指定securityGroup信息，为空时将使用默认安全组
43 client_token=client_token
44 ephemeral_disks) #设置创建BCC的本地盘
45
46 baidubce.bce_response.BceResponse)创建实例在专属服务器（支持对明文密码加密）
Python3
1使用以下代码可以在特定服务器中创建BCC实例：
2
3 def create_instance_from_dedicated_host_with_encrypted_password(self):
4 #如果用户未指定client_token参数,用uuid4生成一个随机字符串给client_token
5 generate_client_token = str(uuid.uuid4())
6 client_token = generate_client_token()
7
8 #设置镜像id
9 image_id = 'your-choose-image-id'
10
11 #设置专属服务器id
12 dedicated_host_id = 'your-choose-dedicated-host-id'
13
14 #设置实例名
15 instance_name = 'your-choose-instance-name' + client_token
16
17 #设置实例管理员密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*())
18 admin_pass = 'your-admin-pass'
19
20 #指定subnet信息，为空时将使用默认子网
21 subnet_id = 'your-choose-subnet-id'
22
23 #指定security_group_id信息，为空时将使用默认安全组
24 security_group_id = 'your-choose-security-group-id'
25
26 #DCC专属服务器实例可以创建多块本地盘，需要指定磁盘类型及大小
27 #其它类型只能用一块本地盘，使用默认类型，只需指定大小
28
29 #设置创建本地磁盘大小
30 ephemeral_disk = EphemeralDisk(6144)
31
32 #设置本地盘类型为默认类型
33 ephemeral_disks = [ephemeral_disk.__dict__, ephemeral_disk.__dict__]
34
35 self.assertEqual(
36 type(self.client.create_instance_from_dedicated_host_with_encrypted_password(1, #设置创建BCC的CPU核数
37 2, #设置创建BCC的内存大小GB
38 image_id, #设置创建BCC的镜像
39 dedicated_host_id, #设置创建BCC的专属服务器
40 purchase_count=1,# 批量创建BCC实例时使用，必须为大于0的整数
41 name=instance_name,# 设置创建BCC的名称
42 admin_pass=admin_pass,# 设置实例管理员密码
43 subnet_id=subnet_id,# 指定subnet信息，为空时将使用默认子网
44 security_group_id=security_group_id,# 指定securityGroup信息，为空时将使用默认安全组
45 client_token=client_token
46 ephemeral_disks) #设置创建BCC的本地盘
47
48 baidubce.bce_response.BceResponse)查询实例列表
以下代码可以查询BCC虚机实例列表,支持通过内网ip、专属服务器id、可用区名称进行筛选:
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 res = client.list_instances(marker='i-***', # 批量获取列表的查询的起始位置，是一个由系统生成的字符串
17 max_keys=1, # 每页包含的最大数量，最大数量通常不超过1000，缺省值为1000
18 internal_ip='192.168.***.***', # 内网IP
19 dedicated_host_id='d-***', # 专属服务器ID
20 zone_name='cn-bj-d', # 可用区信息
21 instance_ids='i-***', # 多个实例ID，英文逗号分割，最多支持100个
22 instance_names='***', # 多个实例名称，英文逗号分割，最多支持100个
23 cds_ids='v-***', # 多个cds磁盘ID，英文逗号分割，最多支持100个
24 deployset_ids='dset-***', # 多个部署集ID，英文逗号分割，最多支持100个
25 security_group_ids='g-***', # 多个安全组ID，英文逗号分割，最多支持100个
26 payment_timing='Postpaid', # 支付方式（Prepaid / Postpaid）
27 status='Running', # 实例状态（Recycled / Running / Stopped / Stopping / Starting）
28 tags='***', # 多个标签，逗号分割，格式：tagKey:tagValue 或 tagKey
29 vpc_id='vpc-***', # vpcId，只能与privateIps查询参数组合使用
30 private_ips='192.168.***.***', # 多个内网IP，英文逗号分隔，最多支持100个，必须和vpcId组合使用
31 )
32 print(res)查询实例详情
使用以下代码可以查询指定BCC虚机的详细信息：
Python3
1 def get_instance(self):
2 #设置你要操作的instance_id
3 instance_id = 'your-choose-instance-id'
4 #设置是否返回创建失败信息,True表示返回创建失败信息,默认为False
5 contains_failed = True
6 self.assertEqual(
7 type(self.client.get_instance(instance_id, contains_failed)),
8
9 baidubce.bce_response.BceResponse)启动实例
使用以下代码可以启动指定BCC虚机实例：
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15 # 设置你要操作的instance_id
16 instance_id = 'i-***'
17 resp = client.start_instance(instance_id)
18 print(resp)停止实例
使用以下代码可以停止指定BCC虚机实例：
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client, bcc_model
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = 'http://bcc.bj.baidubce.com'
8 AK = 'ak'
9 SK = 'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.stop_instance(
17 instance_id='i-***', # 待停止的实例ID
18 force_stop=False, # 指定实例是否强制关机，可选值：True、False，缺省为false
19 stopWithNoCharge=True # 指定实例是否关机不计费，可选值：true、false，缺省为false
20 )
21 print(resp)重启实例
使用以下代码可以重启指定BCC虚机实例：
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15 # 设置你要操作的instance_id
16 instance_id = 'i-***'
17 # 重启实例
18 resp = client.reboot_instance(instance_id)
19 print(resp)修改实例密码
使用以下代码可以修改指定BCC虚机实例的管理员密码：
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 # 设置你要操作的instance_id
17 instance_id = 'i-***'
18 # 设置新的密码
19 admin_pass = '***'
20 # 执行修改实例密码的操作
21 resp = client.modify_instance_password(instance_id, admin_pass)
22 print(resp)修改实例属性
使用以下代码可以修改指定BCC虚机实例的名称或网卡队列数：
Python3
1 def modify_instance_attributes(self):
2
3 #设置你要操作的instance_id
4 instance_id = 'your-choose-instance-id'
5 name = 'name_modify'
6 neteth_queuecount = 3 # 新的网卡队列数
7 self.assertEqual(
8 type(self.client.modify_instance_attributes(instance_id,
9 name=name,
10 neteth_queuecount= neteth_queuecount)),
11 baidubce.bce_response.BceResponse)修改实例描述(新)
使用以下代码可以修改指定BCC虚机实例的描述：
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15 # 设置你要操作的instance_id
16 instance_id = 'i-***'
17 # 修改instance的描述
18 desc = 'your_new_description'
19 resp = client.modify_instance_desc(instance_id, desc)
20 print(resp)重装实例
使用以下代码可以使用镜像重建指定BCC虚机实例:
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 res = client.rebuild_instance(instance_id="i-***", # 指定的实例ID
17 image_id="m-***", # 指定的镜像ID
18 admin_pass="***", # 机器密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*())，密码需要加密传输
19 key_pair_id="k-***", # 待重装实例所要绑定的密钥对ID，必须传递adminPass、keypairId其中一个参数
20 )
21 print(res)释放实例
对于后付费Postpaid以及预付费Prepaid过期的BCC虚机实例，可以使用以下代码将其释放:
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.release_instance(instance_id='i-sxb2****') # 释放实例ID
17 print (resp)实例扩缩容
支持对BCC虚机的CPU以及内存进行扩容操作，具体可参考以下代码：
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.resize_instance(instance_id="i-sxb2****", # 实例id
17 cpu_count=4, # cpu核数
18 memory_capacity_in_gb=16, # 内存大小
19 live_resize=True, # 是否是在线变配
20 enable_jumbo_frame=False) # 是否开启Jumbo帧，True开启Jumbo帧，Flase关闭Jumbo帧。默认为空，为空表示：变配到不支持Jumbo帧的规格时，不开启Jumbo帧；
21 # 从不支持变配到支持的规格时，不开启Jumbo帧；从支持到支持得规格是，若实例变配前开启Jumbo帧，变配后也开启Jumbo帧，若变配前不开启，则变配后也不开启。
22 print (resp)将实例加入安全组
以下代码可以将指定BCC虚机实例加入到指定安全组内：
Python3
1 def bind_instance_to_security_group(self):
2
3 #指定security_group_id信息
4 security_group_id = 'your-choose-security-group-id'
5
6 #设置你要操作的instance_id
7 instance_id = 'your-choose-instance-id'
8
9 self.assertEqual(
10 type(self.client.bind_instance_to_security_group(instance_id,security_group_id)),
11
12 baidubce.bce_response.BceResponse)将实例移出安全组
以下代码可以将指定实例移出指定安全组中：
Python3
1 def unbind_instance_from_security_group(self):
2
3 #指定security_group_id信息
4 security_group_id = 'your-choose-security-group-id'
5
6 #设置你要操作的instance_id
7 instance_id = 'your-choose-instance-id'
8
9 self.assertEqual(
10
11 type(self.client.unbind_instance_from_security_group(instance_id,security_group_id)),
12
13 baidubce.bce_response.BceResponse)绑定实例到标签(新)
以下代码可以将指定BCC虚机实例绑定指定标签：
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client, bcc_model
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 # 输入标签信息，支持一次绑定多个标签
17 instance_tag1 = bcc_model.TagModel(tagKey='TestKey01',tagValue='TestValue01')
18 instance_tag2 = bcc_model.TagModel(tagKey='TestKey02',tagValue='TestValue02')
19 instance_tag_list = []
20 instance_tag_list.append(instance_tag1)
21 instance_tag_list.append(instance_tag2)
22 # 设置你要操作的instance_id
23 instance_id = 'i-***'
24
25 # 执行绑定绑定实例到标签的操作
26 resp = client.bind_instance_to_tags(instance_id=instance_id, tags=instance_tag_list)
27 print(resp)解绑实例标签(新)
以下代码可以将指定BCC虚机实例解绑指定标签：
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client, bcc_model
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 # 输入标签信息，支持一次绑定多个标签
17 instance_tag1 = bcc_model.TagModel(tagKey='Key***',tagValue='Value***')
18 instance_tag2 = bcc_model.TagModel(tagKey='Key***',tagValue='Value***')
19 instance_tag_list = []
20 instance_tag_list.append(instance_tag1)
21 instance_tag_list.append(instance_tag2)
22 # 设置你要操作的instance_id
23 instance_id = 'i-***'
24
25 # 执行解绑实例标签的操作
26 resp = client.unbind_instance_from_tags(instance_id=instance_id, tags=instance_tag_list)
27 print(resp)查询实例地址
使用以下代码可以查询指定BCC虚机实例的VNC URL:
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 print(client.get_instance_vnc("i-***")) # i-*** 为虚拟机实例ID实例续费
对BCC虚机的续费操作，可以延长过期时长，以下代码可以对磁盘进行续费：
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4from baidubce.services.bcc import bcc_model
5
6if __name__ == '__main__':
7 # 设置您的ak、sk和要访问的地域
8 HOST = b'http://bcc.bj.baidubce.com'
9 AK = b'ak'
10 SK = b'sk'
11 # 设置默认配置
12 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
13 endpoint=HOST)
14 # 创建bcc client
15 client = bcc_client.BccClient(config)
16
17 res = client.purchase_reserved_instance(instance_id='i-***', # 虚拟机实例ID
18 billing=bcc_model.Billing('Prepaid', 1), # 订单详情，本接口针对预付费实例进行续费，续费单位为月
19 related_renew_flag='CDS_EIP', # 设置实例关联续费标识，默认为空字符串
20 client_token='random-uuid' # 幂等性Token，是一个长度不超过64位的ASCII字符串
21 )
22 print(res)创建抢占实例
使用以下代码可以创建BCC抢占实例：
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client, bcc_model
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
11 endpoint=HOST)
12 client = bcc_client.BccClient(config)
13
14 response = client.create_instance_of_bid(
15 bid_model='market', # 抢占实例出价模型， 市场价: "market" 自定义："custom"。
16 instance_type='N6', # 待创建虚拟机实例的类型
17 cpu_count=1, # 待创建虚拟机实例的CPU核数
18 memory_capacity_in_gb=4, # 待创建虚拟机实例的内存容量，单位GB
19 image_id='m-***', # 镜像ID
20 root_disk_size_in_gb=20, # 待创建虚拟机实例的系统盘大小，单位GB，默认是40GB，范围为[40, 2048]GB，超过40GB按照云磁盘价格收费。注意指定的系统盘大小需要满足所使用镜像最小磁盘空间限制。
21 root_disk_storage_type='enhanced_ssd_pl1', # 待创建虚拟机实例系统盘介质，默认使用SSD型云磁盘
22 create_cds_list=[ # 待创建的CDS磁盘列表
23 bcc_model.CreateCdsModel(
24 cdsSizeInGB=50, # CDS磁盘容量，必须为大于0的整数，单位为GB，大小为0~5120G
25 storageType='enhanced_ssd_pl1')], # CDS磁盘存储类型，默认是hp1(高性能云磁盘)。
26 eip_name='eipN***', # 长度1～65个字节，字母开头，可包含字母数字-_/.字符。若不传该参数，服务会自动生成name。
27 internet_charge_type='BANDWIDTH_PREPAID', # 公网带宽计费方式，若不指定internetChargeType，默认为按使用带宽计费。
28 purchase_count=1, # 批量创建（购买）的虚拟机实例个数，必须为大于0的整数，可选参数，缺省为1。
29 name='instance-***', # 虚拟机名字。默认都不指定name。如果指定name：批量时name作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
30 hostname='host***', # 虚拟机主机名。默认都不指定hostname。如果指定hostname：批量时hostname作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
31 admin_pass='***', # 待创建的实例管理员密码，8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*()。
32 zone_name='cn-bj-a', # 指定zone信息，默认为空，由系统自动选择，可通过调用查询可用区列表接口查询可用区列表。zoneName命名规范是“国家-region-可用区序列"，小写，例如北京可用区A为"cn-bj-a"。
33 subnet_id='sbn-***', # 指定subnet信息，为空时将使用默认子网
34 security_group_id='g-***', # 指定securityGroup信息，为空时将使用默认安全组
35 asp_id='asp-***', # 自动快照策略ID
36 tags=[bcc_model.TagModel('key***', 'value***')], # 待创建虚机的标签列表
37 )
38 print(response)
39 查询回收站实例列表
使用以下代码可以查询回收站实例列表
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.list_recycled_instances(payment_timing="postpaid", recycle_begin='2023-11-21T20:00:00Z')
17 print(resp)定时释放 (限定后付费实例)
使用以下代码可以设置后付费实例定时释放，到达预设时间后自动释放bcc，自动释放时间可查询实例详情ReleaseTime。
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client, bcc_model
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = 'http://bcc.bj.baidubce.com'
8 AK = 'ak'
9 SK = 'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.auto_release_instance(
17 instance_id="i-***", # 实例ID
18 release_time='2023-12-15T14:20:00Z') # 释放时间，格式yyyy-MM-dd'T'HH:mm:ss'Z'
19 print(resp)查询关联部署集的实例详情
使用以下代码可以查询关联了部署集的实例详情
Python3
1def test_get_instance_with_deploy_set(self):
2
3 instance_id = "i-oUXBvdIx"
4 self.assertEqual(
5 type(self.client.get_instance_with_deploy_set(instance_id)),
6 baidubce.bce_response.BceResponse)
7 print(self.client.get_instance(instance_id))查询关联部署集和失败相关字段实例详情
使用以下代码可以查询关联部署集和失败相关字段实例详情
Python3
1def test_get_instance_with_deploy_set_and_failed(self):
2 """
3 test case for get_instance
4 """
5 instance_id = "i-oUXBvdIx"
6 self.assertEqual(
7 type(self.client.get_instance_with_deploy_set_and_failed(instance_id)),
8 baidubce.bce_response.BceResponse)
9 print(self.client.get_instance(instance_id))删除实例与部署集之间的关系
使用以下代码可以删除实例与部署集之间的关系
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.del_instance_deploy(instance_id_list=['i-***', 'i-***'], # 实例ID列表
17 deploy_set_id='dset-***' # 部署集ID
18 )修改实例主机名
使用以下代码可以修改实例主机名
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.modify_instance_hostname(instance_id="i-***", # 指定的实例ID
17 hostname="new-hostname", # 实例主机名
18 reboot=True, # 是否自动重启
19 is_open_hostname_domain=True, # 是否开启hostname domain
20 )后付费资源从回收站恢复计费
使用以下代码可以将后付费资源从回收站恢复计费
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 # 需要从回收站恢复计费的实例id
17 instance_ids = ["i-***", "i-***"]
18 resp = client.recovery_instances(instance_ids)
19 print(resp)查询竞价实例市场价
使用以下代码可以查询竞价实例市场价
Python3
1def test_get_bid_instance_price(self):
2 """
3 test case for get_bid_instance_price
4 """
5 resp = self.client.get_bid_instance_price(instance_type='N3', cpu_count=1, memory_cap_in_gb=1,
6 root_disk_size_in_gb=20)
7 self.assertEqual(
8 type(resp),
9 baidubce.bce_response.BceResponse)
10 if resp is not None and resp.content is not None:
11 print(json.loads(resp.content.decode('utf-8')))
12 else:
13 print(resp)查询竞价实例套餐
使用以下代码可以查询竞价实例套餐
Python3
1def test_list_bid_flavor(self):
2 """
3 test case for list_bid_flavor
4 """
5 resp = self.client.list_bid_flavor()
6 self.assertEqual(
7 type(resp),
8 baidubce.bce_response.BceResponse)
9 if resp is not None and resp.content is not None:
10 print(json.loads(resp.content.decode('utf-8')))
11 else:
12 print(resp)释放保护
使用以下代码可以为BCC实例设置释放保护，实例当前设置可查询实例详情DeletionProtection，默认0不保护，1释放保护中:
Python3
1def test_modify_deletion_protection(self):
2 """
3 test case for modify_deletion_protection
4 """
5 resp = self.client.modify_deletion_protection("i-XS7Db00e", 1)
6 self.assertEqual(
7 type(resp),
8 baidubce.bce_response.BceResponse)
9 if resp is not None and resp.content is not None:
10 print(json.loads(resp.content.decode('utf-8')))
11 else:
12 print(resp)查询实例套餐价格
通过以下代码可以查询实例资源套餐规格对应的价格
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.get_price_by_spec(spec_id="g5", # 实例规格族id
17 spec="bcc.g5.c2m8", # 实例套餐规格
18 payment_timing="prepay", # 付费方式，包括Postpaid(后付费)，Prepaid(预付费)两种
19 zone_name="cn-bj-d", # 可用区名称
20 purchase_num=2, # 实例数量
21 purchase_length=2 # 购买时长，单位：月
22 )
23 print(resp)实例变更子网
如下代码可以变更实例的子网
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http:/bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 res = client.instance_change_subnet(instance_id="i-***", # 虚拟机实例ID
17 subnet_id="sbn-***", # 变更后的子网ID
18 internal_ip="10.59.***.***", # 指定内网IP，不指定则随机生成
19 reboot=True, # 变更后是否重启
20 security_group_ids=["g-p8x***"], # 普通安全组，不支持和企业安全组同时指定，仅变更VPC时生效
21 enterprise_security_group_ids=["esg-***"], # 企业安全组，不支持和普通安全组同时指定，仅变更VPC时生效
22 client_token='random-uuid' # 幂等性Token，是一个长度不超过64位的ASCII字符串
23 )
24 print(res)实例变更VPC
如下代码可以变更实例的VPC
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client, bcc_model
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15 instance_id = "i-oUXB****" # 实例id
16 subnet_id = "sbn-5k3wawcr****" # 子网id
17 internal_ip = "192.168.*.*" # 内网ip
18 resp = client.instance_change_vpc(instance_id=instance_id, subnet_id=subnet_id, internal_ip=internal_ip)
19 print (resp)查询实例绑定的弹性网卡列表
使用以下代码可以查询实例绑定的弹性网卡列表
Python3
1 def test_list_instance_enis(self):
2 """
3 test case for list_instance_enis
4 """
5 resp = self.client.list_instance_enis(instance_id="i-oUXBvdIx")
6 self.assertEqual(
7 type(resp),
8 baidubce.bce_response.BceResponse)
9 if resp is not None and resp.content is not None:
10 print(json.loads(resp.content.decode('utf-8')))
11 else:
12 print(resp)查询实例套餐规格(新)
通过以下代码可以查询实例资源套餐规格列表信息
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.list_flavor_spec(zone_name='cn-bj-d')
17 print(resp)变配实例（通过实例套餐规格）
使用以下代码可以选择CPU,MemoryCapacityInGB,EphemeralDisks变配指定BCC实例:
Python3
1 def test_resize_instance_by_spec(self):
2 """
3 test case for resize_instance_by_spec
4 """
5 resp = self.client.resize_instance_by_spec(instance_id="i-oUXBvdIx", spec='bcc.ic1.c1m1')
6 self.assertEqual(
7 type(resp),
8 baidubce.bce_response.BceResponse)
9 if resp is not None and resp.content is not None:
10 print(json.loads(resp.content.decode('utf-8')))
11 else:
12 print(resp)重装实例（批量）
使用以下代码批量重装实例:
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 res = client.batch_rebuild_instances(instance_ids=["i-***", "i-***"], # 指定的实例ID列表，最多100个
17 image_id="m-***", # 指定的镜像ID
18 admin_pass="***", # 机器密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*())，密码需要加密传输
19 keypair_id="k-***", # 待重装实例所要绑定的密钥对ID，必须传递adminPass、keypairId其中一个参数
20 )
21 print(res)计费变更-转预付费
使用以下代码对实例计费变更-转预付费:
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.change_to_prepaid(instance_id="i-sxb2****", # 实例ID
17 duration=2, # 续费时长，单位为月
18 relation_cds=True) # 是否关联CDS转预付费
19 print (resp)查询可关机不计费的实例列表
查询可关机不计费的BCC实例列表：
Python3
1 def test_list_instance_no_charge(self):
2 """
3 test case for list_instance_no_charge
4 """
5 resp = self.client.list_instance_no_charge(keypair_id='k-Mk1c8QPE', zone_name='cn-bj-a')
6 self.assertEqual(
7 type(resp),
8 baidubce.bce_response.BceResponse)
9 if resp is not None and resp.content is not None:
10 print(json.loads(resp.content.decode('utf-8')))
11 else:
12 print(resp)取消竞价实例订单
通过以下代码可以取消竞价实例订单
Python3
1 def test_cancel_bid_order(self):
2 """
3 test case for cancel_bid_order
4 """
5 resp = self.client.cancel_bid_order(order_id='test_id')
6 self.assertEqual(
7 type(resp),
8 baidubce.bce_response.BceResponse)
9 if resp is not None and resp.content is not None:
10 print(json.loads(resp.content.decode('utf-8')))
11 else:
12 print(resp)开通自动续费（包含关联产品）
自动续费仅限预付费产品
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client, bcc_model
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = 'http://bcc.bj.baidubce.com'
8 AK = 'ak'
9 SK = 'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.batch_create_auto_renew_rules(
17 instance_id='i-***', # 实例ID
18 renew_eip=True, # 是否合并eip自动续费，默认值为True
19 renew_cds=True, # 是否合并cds自动续费，默认值为True
20 renew_time=2, # 续费时长
21 renew_time_unit='year' # 续费时间单位，month/year
22 )
23
24 print(resp)关闭自动续费（包含关联产品）
自动续费仅限预付费产品
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client, bcc_model
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = 'http://bcc.bj.baidubce.com'
8 AK = 'ak'
9 SK = 'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.batch_delete_auto_renew_rules(
17 instance_id='i-***', # 实例id
18 renew_eip=True, # 是否合并关闭eip自动续费，默认值为True
19 renew_cds=True # 是否合并关闭cds自动续费，默认值为True
20 )
21 print(resp)释放回收站实例
回收站实例7天后自动释放，清理回收站资源，可以使用以下代码将其释放:
Python3
1# !/usr/bin/env python
2# coding=utf-8
3from baidubce.services.bcc import bcc_client
4from baidubce.auth.bce_credentials import BceCredentials
5from baidubce.bce_client_configuration import BceClientConfiguration
6
7
8if __name__ == '__main__':
9 # 设置您的ak、sk和要访问的地域
10 HOST = b'http://bcc.bj.baidubce.com'
11 AK = b'ak'
12 SK = b'sk'
13 # 设置默认配置
14 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
15 endpoint=HOST)
16 # 创建bcc client
17 client = bcc_client.BccClient(config)
18 # 实例ID
19 instanceId = "i-***"
20 # 请求从回收站中删除实例
21 response = client.delete_recycled_instance(instance_id=instanceId)
22 print(response)根据实例ID批量查询实例列表
以下代码可以根据实例ID批量查询实例列表
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.list_instance_by_instance_ids(instance_ids=['i-***', 'i-***', 'i-***'], # 待查询的实例id列表
17 marker='123', # 批量获取列表的查询的起始位置
18 max_keys=1000, # 每页包含的最大数量
19 )
20 print(resp)批量删除实例
以下代码可以批量删除实例，同时也可以选择删除其关联的资源
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.batch_delete_instance_with_related_resource(instance_ids=['i-***'], # 实例ID，最多100个
17 related_release_flag=True, # 删除实例时是否同时删除关联的资源
18 )
19 print(resp)批量重启实例
使用以下代码可以批量重启实例
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15 # 实例ID，最多100个
16 resp = client.batch_start_instance(instance_ids=['i-***', 'i-***'])
17 print(resp)批量停止实例
使用以下代码可以批量停止实例
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client, bcc_model
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = 'http://bcc.bj.baidubce.com'
8 AK = 'ak'
9 SK = 'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.batch_stop_instance(
17 instance_ids=['i-***', 'i-***'], # 实例id组成的集合，最多100个
18 force_stop=False, # 指定实例是否强制关机，可选值：True、False
19 stop_with_no_charge=True # 是否关机计费
20 )
21 print(resp)批量变配实例
使用以下代码可以批量变配实例
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 # 执行批量变配实例的操作
17 resp = client.batch_resize_instance(instance_ids=['i-***'], # 实例id组成的集合，最多30个
18 spec='bcc.g5.c8m32', # 批量变配的实例规格
19 subnet_id='sbn-***', # 子网id
20 logical_zone='cn-bj-d', # 可用区
21 internal_ip_v4='ipv4', 内网IP
22 )
23 print(resp)查询可以变配的实例规格
使用以下代码可以查询可以变配的实例规格
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 # 执行查询可以变配的实例规格的操作
17 resp = client.list_available_resize_specs(instance_ids=['i-***'], # 实例ID。实例ID、实例规格和规格族ID有且只能传一个
18 # spec='bcc.g5.c2m8', # 实例规格
19 # spec_id='subnet_id', # 规格族ID
20 # logical_zone='zone_name', # 实例所在可用区。若传入spec或specId，则该参数为必填。
21 )
22 print(resp)批量转预付费
使用以下代码可以将实例批量转预付费，若需要对实例关联的cds变更，则必须在CdsList中传入所有需要转为预付费的cdsId，若所有cds均变更计费传入all。
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4from baidubce.services.bcc.bcc_model import PayTimingChangeReqModel
5
6if __name__ == '__main__':
7 # 设置您的ak、sk和要访问的地域
8 HOST = b'http://bcc.bj.baidubce.com'
9 AK = b'ak'
10 SK = b'sk'
11 # 设置默认配置
12 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
13 endpoint=HOST)
14 # 创建bcc client
15 client = bcc_client.BccClient(config)
16
17 req1 = PayTimingChangeReqModel('i-***', cdsList=['all'], autoPay=True, duration=1)
18 req2 = PayTimingChangeReqModel('i-***', cdsList=['all'], duration=1)
19 req = [req1, req2]
20 # req集合元素最多100个
21 resp = client.batch_change_instance_to_prepay(req)
22 print(resp)批量转后付费
使用以下代码可以将实例批量转后付费，若需要对实例关联的cds变更，则必须在CdsList中传入所有需要转为后付费的cdsId，若所有cds均变更计费传入all。
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4from baidubce.services.bcc.bcc_model import PayTimingChangeReqModel
5
6if __name__ == '__main__':
7 # 设置您的ak、sk和要访问的地域
8 HOST = b'http://bcc.bj.baidubce.com'
9 AK = b'ak'
10 SK = b'sk'
11 # 设置默认配置
12 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
13 endpoint=HOST)
14 # 创建bcc client
15 client = bcc_client.BccClient(config)
16
17 req1 = PayTimingChangeReqModel('i-***', cdsList=['all'])
18 req2 = PayTimingChangeReqModel('i-***', cdsList=['all'])
19 req = [req1, req2]
20 # req集合元素最多100个
21 resp = client.batch_change_instance_to_postpay(req)
22 print(resp)获取实例角色列表
使用以下代码可以获取实例角色列表
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client, bcc_model
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 # 执行获取实例角色列表的操作
17 resp = client.list_instance_roles()
18 print(resp)绑定角色
使用以下代码可以为BCC实例绑定角色
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client, bcc_model
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 # 执行绑定角色的操作
17 resp = client.bind_instance_role(['i-***', 'i-***'], # 实例ID列表
18 role_name='BCC_Test', # 角色名称
19 )
20 print(resp)解绑角色
使用以下代码可以为BCC实例解绑角色
Python3
1 from baidubce.auth.bce_credentials import BceCredentials
2 from baidubce.bce_client_configuration import BceClientConfiguration
3 from baidubce.services.bcc import bcc_client, bcc_model
4
5 if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 # 执行解绑角色的操作
17 resp = client.unbind_instance_role(['i-***', 'i-***'], # 实例ID列表
18 role_name='BCC_Test' # 角色名称
19 )
20 print(resp)添加Ipv6
使用以下代码可以为BCC实例添加Ipv6
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client, bcc_model
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = 'http://bcc.bj.baidubce.com'
8 AK = 'ak'
9 SK = 'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 resp = client.add_ipv6(
17 instance_id='i-***', # 实例id
18 ipv6_address='240c:4081:8005:ca0b:***:***', # ipv6地址，为空表示自动分配ipv6
19 reboot=True) # 是否重启，true表示重启，为空表示不重启
20 print(resp)释放Ipv6
使用以下代码可以为BCC实例释放Ipv6
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client, bcc_model
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = 'http://bcc.bj.baidubce.com'
8 AK = 'ak'
9 SK = 'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15 resp = client.delete_ipv6(
16 instance_id='i-***', # 实例id
17 reboot=True) # 是否重启，true表示重启，为空表示不重启
18 print(resp)批量添加主网卡辅助IP
如下代码可以批量添加主网卡辅助IP：
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 private_ips = ["192.168.***.***", "192.168.***.***"]
17 res = client.batch_add_ip(instance_id="i-***", # 实例ID
18 private_ips=private_ips, # 辅助IP，最多100个，和SecondaryPrivateIpAddressCount不可同时使用
19 # secondary_private_ip_address_count=2 # 自动分配IP数量，和PrivateIps不可同时使用
20 allocate_multi_ipv6_addr=True # 是否分配IPV6，创建IPV6必须是True
21 )
22 print(res)批量删除网卡辅助IP
如下代码可以批量删除主网卡辅助IP：
Plain Text
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 private_ips = ["192.168.***.***", "192.168.***.***"]
17 res = client.batch_delete_ip(instance_id="i-***", # 实例ID
18 private_ips=private_ips, # 辅助IP，最多100个
19 )
20 print(res)释放实例（POST）
使用以下代码释放单个后付费云服务器实例：
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 res = client.release_instance_with_related_resources(instance_id="i-***", # 实例id
17 related_release_flag=True, # 是否关联释放当前时刻，实例挂载的EIP和数据盘
18 delete_cds_snapshot_flag=True, # 是否释放云磁盘快照
19 delete_related_enis_flag=True, # 实例释放时是否删除关联的ENI
20 bcc_recycle_flag=True # 实例释放时是否进入回收站
21 )
22 print(res)释放预付费实例（POST）
释放预付费云服务器实例，释放后实例所使用的物理资源都被收回，相关数据全部丢失且不可恢复。 释放的时候默认只释放云服务器实例和系统盘，用户可以选择是否关联释放云服务器实例挂载的EIP和数据盘，关联的EIP和数据盘需全部释放或全部不释放，不支持选择部分释放，部分不释放。 当选择关联释放EIP和数据盘，云磁盘快照可选择一同关联释放，若数据盘不关联释放，云磁盘快照也不支持关联释放。
Python3
1from baidubce.auth.bce_credentials import BceCredentials
2from baidubce.bce_client_configuration import BceClientConfiguration
3from baidubce.services.bcc import bcc_client
4
5if __name__ == '__main__':
6 # 设置您的ak、sk和要访问的地域
7 HOST = b'http://bcc.bj.baidubce.com'
8 AK = b'ak'
9 SK = b'sk'
10 # 设置默认配置
11 config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
12 endpoint=HOST)
13 # 创建bcc client
14 client = bcc_client.BccClient(config)
15
16 res = client.release_prepaid_instance_with_related_resources(instance_id="i-***", # 实例id
17 related_release_flag=True, # 是否关联释放当前实例挂载的EIP和数据盘（只有该字段为true时 delete_cds_snapshot_flag字段才会有效，若该字段为false,delete_cds_snapshot_flag字段的值无效）
18 delete_cds_snapshot_flag=True, # 是否释放云磁盘快照
19 delete_related_enis_flag=True, # 实例释放时是否删除关联的ENI
20 )
21 print(res)