实例

更新时间：2024-07-16

BCC实例是百度智能云上的云服务器操作实例，也是计费、权限控制等高级功能的管理实体。

创建实例

使用以下代码可以创建BCC实例，包括专属实例、普通型Ⅰ 型实例、普通型ⅠI 型实例、普通型ⅠII 型实例、GPU实例、计算优化I型实例、计算优化II型实例、存储优化I型实例：

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client, bcc_model

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    client = bcc_client.BccClient(config)

    # billing = bcc_model.Billing(paymentTiming='Postpaid', reservationLength=2, reservationTimeUnit='Month')
    response = client.create_instance(
        instance_type='N6', # 待创建虚拟机实例的类型
        cpu_count=1, # 待创建虚拟机实例的CPU核数
        memory_capacity_in_gb=4, # 待创建虚拟机实例的内存容量，单位GB
        image_id='m-***', # 镜像ID
        root_disk_size_in_gb=20, # 待创建虚拟机实例的系统盘大小，单位GB，默认是40GB，范围为[40, 2048]GB，超过40GB按照云磁盘价格收费。注意指定的系统盘大小需要满足所使用镜像最小磁盘空间限制。
        root_disk_storage_type='enhanced_ssd_pl1', # 待创建虚拟机实例系统盘介质，默认使用SSD型云磁盘
        create_cds_list=[ # 待创建的CDS磁盘列表
            bcc_model.CreateCdsModel(
                cdsSizeInGB=50, # CDS磁盘容量，必须为大于0的整数，单位为GB，大小为0~5120G
                storageType='enhanced_ssd_pl1')], # CDS磁盘存储类型，默认是hp1(高性能云磁盘)。
        eip_name='eip***', # 长度1～65个字节，字母开头，可包含字母数字-_/.字符。若不传该参数，服务会自动生成name。
        internet_charge_type='BANDWIDTH_PREPAID', # 公网带宽计费方式，若不指定internetChargeType，默认为按使用带宽计费。
        purchase_count=1, # 批量创建（购买）的虚拟机实例个数，必须为大于0的整数，可选参数，缺省为1。
        name='instance-***', # 虚拟机名字。默认都不指定name。如果指定name：批量时name作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
        hostname='hostn***', # 虚拟机主机名。。默认都不指定hostname。如果指定hostname：批量时hostname作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
        admin_pass='***', # 待指定的实例管理员密码，8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*()。
        zone_name='cn-bj-a', # 指定zone信息，默认为空，由系统自动选择，可通过调用查询可用区列表接口查询可用区列表。zoneName命名规范是“国家-region-可用区序列"，小写，例如北京可用区A为"cn-bj-a"。
        subnet_id='sbn-***', # 指定subnet信息，为空时将使用默认子网
        security_group_id='g-***', # 指定securityGroup信息，为空时将使用默认安全组
        asp_id='asp-***', # 自动快照策略ID
        tags=[bcc_model.TagModel('key***', 'value***')], # 待创建虚机的标签列表
    )
    print response

实例类型、GPU类型定义列表请参考列表

创建实例（通过规格参数）

使用以下代码可以通过规格参数创建BCC实例

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client, bcc_model

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    client = bcc_client.BccClient(config)

    # billing = bcc_model.Billing(paymentTiming='Postpaid', reservationLength=2, reservationTimeUnit='Month')
    response = client.create_instance_by_spec(
        spec='bcc.g5.c1m4', # 实例规格
        image_id='m-***', # 镜像ID
        root_disk_size_in_gb=20, # 待创建虚拟机实例的系统盘大小，单位GB，默认是40GB，范围为[40, 2048]GB，超过40GB按照云磁盘价格收费。注意指定的系统盘大小需要满足所使用镜像最小磁盘空间限制。
        root_disk_storage_type='enhanced_ssd_pl1', # 待创建虚拟机实例系统盘介质，默认使用SSD型云磁盘
        create_cds_list=[ # 待创建的CDS磁盘列表
            bcc_model.CreateCdsModel(
                cdsSizeInGB=50, # CDS磁盘容量，必须为大于0的整数，单位为GB，大小为0~5120G
              # CDS磁盘存储类型，默认是hp1(高性能云磁盘)。 storageType='enhanced_ssd_pl1')],
        eip_name='eip***', # 长度1～65个字节，字母开头，可包含字母数字-_/.字符。若不传该参数，服务会自动生成name。
        internet_charge_type='BANDWIDTH_PREPAID', # 公网带宽计费方式，若不指定internetChargeType，默认为按使用带宽计费。
        purchase_count=1, # 批量创建（购买）的虚拟机实例个数，必须为大于0的整数，可选参数，缺省为1。
        name='instance-***', # 虚拟机名字。默认都不指定name。如果指定name：批量时name作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
        hostname='hostn***', # 虚拟机主机名。。默认都不指定hostname。如果指定hostname：批量时hostname作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
        admin_pass='***', # 待指定的实例管理员密码，8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*()。
        zone_name='cn-bj-a', # 指定zone信息，默认为空，由系统自动选择，可通过调用查询可用区列表接口查询可用区列表。zoneName命名规范是“国家-region-可用区序列"，小写，例如北京可用区A为"cn-bj-a"。
        subnet_id='sbn-***', # 指定subnet信息，为空时将使用默认子网
        security_group_id='g-***', # 指定securityGroup信息，为空时将使用默认安全组
        asp_id='asp-***', # 自动快照策略ID
        tags=[bcc_model.TagModel('key***', 'value***')], # 待创建虚机的标签列表
    )
    print response

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

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

使用以下代码可以在特定服务器中创建BCC实例：

    def create_instance_from_dedicated_host_with_encrypted_password(self):
          #如果用户未指定client_token参数,用uuid4生成一个随机字符串给client_token
          generate_client_token = str(uuid.uuid4())
          client_token = generate_client_token()

          #设置镜像id
          image_id = 'your-choose-image-id'
          
          #设置专属服务器id
          dedicated_host_id = 'your-choose-dedicated-host-id'

          #设置实例名
          instance_name = 'your-choose-instance-name' + client_token

          #设置实例管理员密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*())
          admin_pass = 'your-admin-pass'

          #指定subnet信息，为空时将使用默认子网
          subnet_id = 'your-choose-subnet-id'

          #指定security_group_id信息，为空时将使用默认安全组
          security_group_id = 'your-choose-security-group-id'

          #DCC专属服务器实例可以创建多块本地盘，需要指定磁盘类型及大小

          #其它类型只能用一块本地盘，使用默认类型，只需指定大小

          #设置创建本地磁盘大小
          ephemeral_disk = EphemeralDisk(6144)

          #设置本地盘类型为默认类型
          ephemeral_disks = [ephemeral_disk.__dict__, ephemeral_disk.__dict__]
          self.assertEqual(
                type(self.client.create_instance_from_dedicated_host_with_encrypted_password(1, #设置创建BCC的CPU核数
                                                                     2, #设置创建BCC的内存大小GB
                                                                     image_id, #设置创建BCC的镜像
                                                                     dedicated_host_id, #设置创建BCC的专属服务器
                                                                   purchase_count=1,# 批量创建BCC实例时使用，必须为大于0的整数
                                                                     name=instance_name,# 设置创建BCC的名称
                                                                     admin_pass=admin_pass,# 设置实例管理员密码
                                                                   subnet_id=subnet_id,# 指定subnet信息，为空时将使用默认子网
                                                                     security_group_id=security_group_id,# 指定securityGroup信息，为空时将使用默认安全组
                                                                     client_token=client_token
                                                                     ephemeral_disks) #设置创建BCC的本地盘
                baidubce.bce_response.BceResponse)

在专属服务器上创建实例

使用以下代码可以在特定服务器中创建BCC实例：

    def create_instance_from_dedicated_host(self):
          #如果用户未指定client_token参数,用uuid4生成一个随机字符串给client_token
          generate_client_token = str(uuid.uuid4())
          client_token = generate_client_token()

          #设置镜像id
          image_id = 'your-choose-image-id'
          
          #设置专属服务器id
          dedicated_host_id = 'your-choose-dedicated-host-id'

          #设置实例名
          instance_name = 'your-choose-instance-name' + client_token

          #设置实例管理员密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*())
          admin_pass = 'your-admin-pass'

          #指定subnet信息，为空时将使用默认子网
          subnet_id = 'your-choose-subnet-id'

          #指定security_group_id信息，为空时将使用默认安全组
          security_group_id = 'your-choose-security-group-id'

          #DCC专属服务器实例可以创建多块本地盘，需要指定磁盘类型及大小

          #其它类型只能用一块本地盘，使用默认类型，只需指定大小

          #设置创建本地磁盘大小
          ephemeral_disk = EphemeralDisk(6144)

          #设置本地盘类型为默认类型
          ephemeral_disks = [ephemeral_disk.__dict__, ephemeral_disk.__dict__]
          self.assertEqual(
                type(self.client.create_instance_from_dedicated_host(1, #设置创建BCC的CPU核数
                                                                     2, #设置创建BCC的内存大小GB
                                                                     image_id, #设置创建BCC的镜像
                                                                     dedicated_host_id, #设置创建BCC的专属服务器
                                                                   purchase_count=1,# 批量创建BCC实例时使用，必须为大于0的整数
                                                                     name=instance_name,# 设置创建BCC的名称
                                                                     admin_pass=admin_pass,# 设置实例管理员密码
                                                                   subnet_id=subnet_id,# 指定subnet信息，为空时将使用默认子网
                                                                     security_group_id=security_group_id,# 指定securityGroup信息，为空时将使用默认安全组
                                                                     client_token=client_token
                                                                     ephemeral_disks) #设置创建BCC的本地盘
                baidubce.bce_response.BceResponse)

查询实例列表

以下代码可以查询BCC虚机实例列表,支持通过内网ip、专属服务器id、可用区名称进行筛选:

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    `AK = `b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    res = client.list_instances(marker='i-***',  # 批量获取列表的查询的起始位置，是一个由系统生成的字符串
                                max_keys=1,  # 每页包含的最大数量，最大数量通常不超过1000，缺省值为1000
                                internal_ip='192.168.***.***',  # 内网IP
                                dedicated_host_id='d-***',  # 专属服务器ID
                                zone_name='cn-bj-d',  # 可用区信息
                                instance_ids='i-***',  # 多个实例ID，英文逗号分割，最多支持100个
                                instance_names='***',  # 多个实例名称，英文逗号分割，最多支持100个
                                cds_ids='v-***',  # 多个cds磁盘ID，英文逗号分割，最多支持100个
                                deployset_ids='dset-***',  # 多个部署集ID，英文逗号分割，最多支持100个
                                security_group_ids='g-***',  # 多个安全组ID，英文逗号分割，最多支持100个
                                payment_timing='Postpaid',  # 支付方式（Prepaid / Postpaid）
                                status='Running',  # 实例状态（Recycled / Running / Stopped / Stopping / Starting）
                                tags='***',  # 多个标签，逗号分割，格式：tagKey:tagValue 或 tagKey
                                vpc_id='vpc-***',  # vpcId，只能与privateIps查询参数组合使用
                                private_ips='192.168.***.***',  # 多个内网IP，英文逗号分隔，最多支持100个，必须和vpcId组合使用
                                )
    print(res)

查询实例详情

使用以下代码可以查询指定BCC虚机的详细信息：

    def get_instance(self): 

          #设置你要操作的instance_id
          instance_id = 'your-choose-instance-id'
          #设置是否返回创建失败信息,True表示返回创建失败信息,默认为False
          contains_failed = True
          self.assertEqual(
                type(self.client.get_instance(instance_id, contains_failed=contains_failed)), 
                baidubce.bce_response.BceResponse)

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

以下代码可以根据实例ID批量查询实例列表

    from baidubce.auth.bce_credentials import BceCredentials
    from baidubce.bce_client_configuration import BceClientConfiguration
    from baidubce.services.bcc import bcc_client

    if __name__ == '__main__':
        # 设置您的ak、sk和要访问的地域
        HOST = b'http://bcc.bj.baidubce.com'
        AK = b'ak'
        SK = b'sk'
        # 设置默认配置
        config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                        endpoint=HOST)
        # 创建bcc client
        client = bcc_client.BccClient(config)

        resp = client.list_instance_by_instance_ids(instance_ids=['i-***', 'i-***', 'i-***'], # 待查询的实例id列表
                                                    marker='123', # 批量获取列表的查询的起始位置
                                                    max_keys=10000, # 每页包含的最大数量
                                                    )
        print(resp)

启动实例

使用以下代码可以启动指定BCC虚机实例：

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)
    # 设置你要操作的instance_id
    instance_id = 'i-***'
    resp = client.start_instance(instance_id)
    print(resp)

停止实例

使用以下代码可以停止指定BCC虚机实例：

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client, bcc_model

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = 'http://bcc.bj.baidubce.com'
    AK = 'ak'
    SK = 'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    resp = client.stop_instance(
        instance_id='i-***',                     # 待停止的实例ID
        force_stop=False,                             # 指定实例是否强制关机，可选值：True、False，缺省为false
        stopWithNoCharge=True                         # 指定实例是否关机不计费，可选值：true、false，缺省为false
    )
    print(resp)

重启实例

使用以下代码可以重启指定BCC虚机实例：

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)
    # 设置你要操作的instance_id
    instance_id = 'i-***'
    # 重启实例
    resp = client.reboot_instance(instance_id)
    print(resp)

修改实例密码

使用以下代码可以修改指定BCC虚机实例的管理员密码：

    from baidubce.auth.bce_credentials import BceCredentials
    from baidubce.bce_client_configuration import BceClientConfiguration
    from baidubce.services.bcc import bcc_client, bcc_model


    if __name__ == '__main__':
        # 设置您的ak、sk和要访问的地域
        HOST = b'http://bcc.bj.baidubce.com'
        AK = b'ak'
        SK = b'sk'
        # 设置默认配置
        config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                        endpoint=HOST)
        # 创建bcc client
        client = bcc_client.BccClient(config)

        # 设置你要操作的instance_id
        instance_id = 'i-***'
        # 设置新的密码
        admin_pass = '***

        resp = client.modify_instance_password(instance_id, admin_pass)
        print(resp)

修改实例属性

使用以下代码可以修改指定BCC虚机实例的名称或网卡队列数：

    def modify_instance_attributes(self):

          #设置你要操作的instance_id
          instance_id = 'your-choose-instance-id'
          name = 'name_modify'    
          neteth_queuecount = 3  # 新的网卡队列数
          self.assertEqual(
                type(self.client.modify_instance_attributes(instance_id,
                                                             name=name,
                                                             neteth_queuecount= neteth_queuecount)), 
                baidubce.bce_response.BceResponse)

重装实例

使用以下代码可以使用镜像重建指定BCC虚机实例:

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    res = client.rebuild_instance(instance_id="i-***",  # 指定的实例ID
                                  image_id="m-***",  # 指定的镜像ID
                                  admin_pass="***",  # 机器密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*())，密码需要加密传输
                                  key_pair_id="k-***",  # 待重装实例所要绑定的密钥对ID，必须传递adminPass、keypairId其中一个参数
                                  )
    print(res)

重装实例（批量）

使用以下代码批量重装实例:

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    res = client.batch_rebuild_instances(instance_ids=["i-***", "i-***"],  # 指定的实例ID列表，最多100个
                                         image_id="m-***",  # 指定的镜像ID
                                         admin_pass="***",  # 机器密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*())，密码需要加密传输
                                         keypair_id="k-***",  # 待重装实例所要绑定的密钥对ID，必须传递adminPass、keypairId其中一个参数
                                         )
    print(res)

释放实例

对于后付费Postpaid以及预付费Prepaid过期的BCC虚机实例，可以使用以下代码将其释放:

    from baidubce.auth.bce_credentials import BceCredentials
    from baidubce.bce_client_configuration import BceClientConfiguration
    from baidubce.services.bcc import bcc_client
    
    if __name__ == '__main__':
        # 设置您的ak、sk和要访问的地域
        HOST = b'http://bcc.bj.baidubce.com'
        AK = b'ak'
        SK = b'sk'
        # 设置默认配置
        config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                        endpoint=HOST)
        # 创建bcc client
        client = bcc_client.BccClient(config)
    
        resp = client.release_instance(instance_id='i-sxb2****') # 释放实例ID
        print (resp)

实例扩缩容

支持对BCC虚机的CPU以及内存进行扩缩容操作，具体可参考以下代码：

    from baidubce.auth.bce_credentials import BceCredentials
    from baidubce.bce_client_configuration import BceClientConfiguration
    from baidubce.services.bcc import bcc_client
    
    if __name__ == '__main__':
        # 设置您的ak、sk和要访问的地域
        HOST = b'http://bcc.bj.baidubce.com'
        AK = b'ak'
        SK = b'sk'
        # 设置默认配置
        config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                        endpoint=HOST)
        # 创建bcc client
        client = bcc_client.BccClient(config)
    
        resp = client.resize_instance(instance_id="i-sxb2****",  # 实例id
                                      cpu_count=4,  # cpu核数
                                      memory_capacity_in_gb=16, # 内存大小
                                      live_resize=True) # 是否是在线变配
        print (resp)

将实例加入安全组

以下代码可以将指定BCC虚机实例加入到指定安全组内：

    def bind_instance_to_security_group(self):

          #指定security_group_id信息
          security_group_id = 'your-choose-security-group-id'

          #设置你要操作的instance_id
          instance_id = 'your-choose-instance-id'
          self.assertEqual(type(self.client.bind_instance_to_security_group(instance_id, security_group_id)), 
                baidubce.bce_response.BceResponse)

将实例移出安全组

以下代码可以将指定实例移出指定安全组中：

    def unbind_instance_from_security_group(self):

          #指定security_group_id信息
          security_group_id = 'your-choose-security-group-id'

          #设置你要操作的instance_id
          instance_id = 'your-choose-instance-id'
          self.assertEqual(
                type(self.client.unbind_instance_from_security_group(instance_id, security_group_id)), 
                baidubce.bce_response.BceResponse)

绑定实例到标签

以下代码可以将指定BCC虚机实例绑定指定标签：

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client, bcc_model

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    # 输入标签信息，支持一次绑定多个标签
    instance_tag1 = bcc_model.TagModel(tagKey='TestKey01',tagValue='TestValue01')
    instance_tag2 = bcc_model.TagModel(tagKey='TestKey02',tagValue='TestValue02')
    instance_tag_list = []
    instance_tag_list.append(instance_tag1)
    instance_tag_list.append(instance_tag2)
    # 设置你要操作的instance_id
    instance_id = 'i-***'

    # 执行绑定绑定实例到标签的操作
    resp = client.bind_instance_to_tags(instance_id=instance_id, tags=instance_tag_list)
    print(resp)

解绑实例标签

以下代码可以将指定BCC虚机实例解绑指定标签：

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client, bcc_model

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    # 输入标签信息，支持一次绑定多个标签
    instance_tag1 = bcc_model.TagModel(tagKey='Key***',tagValue='Value***')
    instance_tag2 = bcc_model.TagModel(tagKey='Key***',tagValue='Value***')
    instance_tag_list = []
    instance_tag_list.append(instance_tag1)
    instance_tag_list.append(instance_tag2)
    # 设置你要操作的instance_id
    instance_id = 'i-***'

    # 执行解绑实例标签的操作
    resp = client.unbind_instance_from_tags(instance_id=instance_id, tags=instance_tag_list)
    print(resp)

查询实例地址

使用以下代码可以查询指定BCC虚机实例的VNC URL:

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    print(client.get_instance_vnc("i-***"))  # i-*** 为虚拟机实例ID

实例续费

对BCC虚机的续费操作，可以延长过期时长，以下代码可以对磁盘进行续费：

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client
from baidubce.services.bcc import bcc_model

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    res = client.purchase_reserved_instance(instance_id='i-***',  # 虚拟机实例ID
                                            billing=bcc_model.Billing('Prepaid', 1),  # 订单详情，本接口针对预付费实例进行续费，续费单位为月
                                            related_renew_flag='CDS_EIP',  # 设置实例关联续费标识，默认为空字符串
                                            client_token='random-uuid'  # 幂等性Token，是一个长度不超过64位的ASCII字符串
                                            )
    print(res)

开通自动续费

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client, bcc_model

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = 'http://bcc.bj.baidubce.com'
    AK = 'ak'
    SK = 'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    resp = client.batch_create_auto_renew_rules(
        instance_id='i-***', # 实例ID
        renew_time=2, # 续费时长
        renew_time_unit='year', # 续费时间单位，month/year
        renew_eip=True,  # 是否合并开启eip自动续费，默认值为True
        renew_cds=True,  # 是否合并开启cds自动续费，默认值为True
    )

    print(resp)

删除自动续费

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client, bcc_model

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = 'http://bcc.bj.baidubce.com'
    AK = 'ak'
    SK = 'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    resp = client.batch_delete_auto_renew_rules(
        instance_id='i-***', # 实例id
        renew_eip=True, # 是否合并关闭eip自动续费，默认值为True
        renew_cds=True  # 是否合并关闭cds自动续费，默认值为True
    )
    print(resp)

实例变更子网

如下代码可以变更实例的子网：

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    res = client.instance_change_subnet(instance_id="i-***",  # 虚拟机实例ID
                                        subnet_id="sbn-***",  # 变更后的子网ID
                                        internal_ip="10.59.***.***",  # 指定内网IP，不指定则随机生成
                                        reboot=True,  # 变更后是否重启
                                        client_token='random-uuid'  # 幂等性Token，是一个长度不超过64位的ASCII字符串
                                        )
    print(res)

批量添加主网卡辅助IP

如下代码可以批量添加主网卡辅助IP：

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    private_ips = ["192.168.***.***", "192.168.***.***"]
    res = client.batch_add_ip(instance_id="i-***",  # 实例ID
                              private_ips=private_ips,  # 辅助IP，和SecondaryPrivateIpAddressCount不可同时使用
                              # secondary_private_ip_address_count=2  # 自动分配IP数量，和PrivateIps不可同时使用
                              allocate_multi_ipv6_addr=True  # 是否分配IPV6，创建IPV6必须是True
                              )
    print(res)

批量删除网卡辅助IP

如下代码可以批量删除网卡辅助IP：

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    private_ips = ["192.168.***.***", "192.168.***.***"]
    res = client.batch_delete_ip(instance_id="i-***",  # 实例ID
                              private_ips=private_ips  # 辅助IP
                                )
    print(res)

释放实例（POST）

使用以下代码释放单个后付费云服务器实例：

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    res = client.release_instance_with_related_resources(instance_id="i-***",  # 实例id
                                                         related_release_flag=True,  # 是否关联释放当前时刻，实例挂载的EIP和数据盘
                                                         delete_cds_snapshot_flag=True,  # 是否释放云磁盘快照
                                                         delete_related_enis_flag=True,  # 实例释放时是否删除关联的ENI
                                                         bcc_recycle_flag=True  # 实例释放时是否进入回收站
                                                         )
    print(res)

释放预付费实例（POST）

释放预付费云服务器实例，释放后实例所使用的物理资源都被收回，相关数据全部丢失且不可恢复。释放的时候默认只释放云服务器实例和系统盘，用户可以选择是否关联释放云服务器实例挂载的EIP和数据盘，关联的EIP和数据盘需全部释放或全部不释放，不支持选择部分释放，部分不释放。当选择关联释放EIP和数据盘，云磁盘快照可选择一同关联释放，若数据盘不关联释放，云磁盘快照也不支持关联释放。

from baidubce.auth.bce_credentials import BceCredentials
from baidubce.bce_client_configuration import BceClientConfiguration
from baidubce.services.bcc import bcc_client

if __name__ == '__main__':
    # 设置您的ak、sk和要访问的地域
    HOST = b'http://bcc.bj.baidubce.com'
    AK = b'ak'
    SK = b'sk'
    # 设置默认配置
    config = BceClientConfiguration(credentials=BceCredentials(AK, SK),
                                    endpoint=HOST)
    # 创建bcc client
    client = bcc_client.BccClient(config)

    res = client.release_prepaid_instance_with_related_resources(instance_id="i-***",  # 实例id
                                                         related_release_flag=True,  # 是否关联释放当前实例挂载的EIP和数据盘(只有该字段为true时 delete_cds_snapshot_flag字段才会有效，若该字段为false,delete_cds_snapshot_flag字段的值无效)
                                                         delete_cds_snapshot_flag=True,  # 是否释放云磁盘快照
                                                         delete_related_enis_flag=True,  # 实例释放时是否删除关联的ENI)
    print(res)

BccClient

磁盘

百度智能云

云服务器 BCC