实例

更新时间：2025-08-20

创建实例（通过指定实例套餐规格）

使用以下代码可以通过规格参数创建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        eni_ids=["eni-***"] # 待挂载的弹性网卡短ID列表。批量创建时会根据传入数量平均分配到实例上，所以请保证传入的弹性网卡id数量是实例数量的整数倍，且每个实例分配的eni数量不超过实例能挂载的最大数量。ebc裸金属实例暂不支持。eniIds数量大小最多为5000。
35    )
36    print(response)

必传参数：
- 规格名称（例如 bcc.g4.c1m1）
- 镜像ID
可选参数：参考普通创建实例接口

创建实例（已废弃，建议使用“创建实例（通过指定实例套餐规格）”）

使用以下代码可以创建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)

类型编码请参考实例类型、磁盘类型、GPU类型

创建专属服务器的子实例

使用以下代码可以在特定服务器中创建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)

常见问题

地域

云服务器 BCC

云服务器 BCC

实例

创建实例（通过指定实例套餐规格）

创建实例（已废弃，建议使用“创建实例（通过指定实例套餐规格）”）

创建专属服务器的子实例

创建实例在专属服务器（支持对明文密码加密）

查询实例列表

查询实例详情

启动实例

停止实例

重启实例

修改实例密码

修改实例属性

修改实例描述(新)

重装实例

释放实例

实例扩缩容

将实例加入安全组

将实例移出安全组

绑定实例到标签(新)

解绑实例标签(新)

查询实例地址

实例续费

创建抢占实例

查询回收站实例列表

定时释放 (限定后付费实例)

查询关联部署集的实例详情

查询关联部署集和失败相关字段实例详情

删除实例与部署集之间的关系

修改实例主机名

后付费资源从回收站恢复计费

查询竞价实例市场价

查询竞价实例套餐

释放保护

查询实例套餐价格

实例变更子网

实例变更VPC

查询实例绑定的弹性网卡列表

查询实例套餐规格(新)

变配实例（通过实例套餐规格）

重装实例（批量）

计费变更-转预付费

查询可关机不计费的实例列表

取消竞价实例订单

开通自动续费（包含关联产品）

关闭自动续费（包含关联产品）

释放回收站实例

根据实例ID批量查询实例列表

批量删除实例

批量重启实例

批量停止实例

批量变配实例

查询可以变配的实例规格

批量转预付费

批量转后付费

获取实例角色列表

绑定角色

解绑角色

添加Ipv6

释放Ipv6

批量添加主网卡辅助IP

批量删除网卡辅助IP

释放实例（POST）

释放预付费实例（POST）