BCC实例

更新时间：2024-07-16

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

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

使用以下代码可以创建BCC实例，包括普通型BCC、存储优化型BCC、计算优化型BCC、大数据机型BCC、GPU机型BCC、FPGA机型BCC：

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.Billing;
import com.baidubce.services.bcc.model.CreateCdsModel;
import com.baidubce.services.bcc.model.Reservation;
import com.baidubce.services.bcc.model.StorageType;
import com.baidubce.services.bcc.model.instance.CreateInstanceRequest;
import com.baidubce.services.bcc.model.instance.CreateInstanceResponse;

import java.util.ArrayList;
import java.util.List;

import static com.baidubce.services.bcc.model.instance.FpgaCardType.KU115;
import static com.baidubce.services.bcc.model.instance.GpuCardType.P4;

public class Main {
    public static void main(String[] args) {
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";

        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);

        BccClient client = new BccClient(bccClientConfiguration);

        CreateInstanceRequest instanceRequest = new CreateInstanceRequest();
        // 镜像ID
        instanceRequest.setImageId("m-***");
        // 待创建虚拟机实例的类型
        instanceRequest.setSpec("bcc.g5.c1m4");
        // 待创建虚拟机实例的系统盘大小，单位GB，默认是40GB，范围为[40, 2048]GB，超过40GB按照云磁盘价格收费。注意指定的系统盘大小需要满足所使用镜像最小磁盘空间限制。
        instanceRequest.setRootDiskSizeInGb(20);
        // 待创建虚拟机实例系统盘介质，默认使用SSD型云磁盘
        instanceRequest.setRootDiskStorageType("enhanced_ssd_pl1");
        // 指定zone信息，默认为空，由系统自动选择，可通过调用查询可用区列表接口查询可用区列表。zoneName命名规范是“国家-region-可用区序列"，小写，例如北京可用区A为"cn-bj-a"。
        instanceRequest.setZoneName("cn-bj-a");
        // 虚拟机名字。默认都不指定name。如果指定name：批量时name作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
        instanceRequest.setName("instance-***");
        List<CreateCdsModel> createCdsList = new ArrayList<CreateCdsModel>();
        createCdsList.add(new CreateCdsModel()
                .withCdsSizeInGB(50)
                .withStorageType("enhanced_ssd_pl1"));
        // 待创建的CDS磁盘列表
        instanceRequest.setCreateCdsList(createCdsList);
        // 公网带宽，单位为Mbps。必须为0~200之间的整数，为0表示不分配公网IP，默认为0Mbps
        instanceRequest.setNetworkCapacityInMbps(10);
        // 批量创建（购买）的虚拟机实例个数，必须为大于0的整数，可选参数，缺省为1
        instanceRequest.setPurchaseCount(1);
        // 虚拟机主机名。默认都不指定hostname。如果指定hostname：批量时hostname作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
        instanceRequest.setHostname("hostn***");
        // 是否自动生成name和hostname有序后缀（可选参数） 是:true 否:false
        instanceRequest.setAutoSeqSuffix(true);
        // 待创建的实例管理员密码，8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*()。
        instanceRequest.setAdminPass("***");
        // 订单、计费相关参数
        instanceRequest.setBilling(new Billing()
                .withPaymentTiming("Postpaid"));
        // 指定subnet信息，为空时将使用默认子网
        instanceRequest.setSubnetId("sbn-***");
        // 指定securityGroup信息，为空时将使用默认安全组
        instanceRequest.setSecurityGroupId("g-***");
        // 待创建实例指定的标签是否需要和已有标签键进行关联，默认为false。注意值为true时要保证该标签键已存在
        instanceRequest.setRelationTag(true);
        // 自动快照策略ID
        instanceRequest.setAspId("asp-***");
        // 指定实例所在的部署集id
        instanceRequest.setDeployId("dset-***");

        CreateInstanceResponse instance = client.createInstance(instanceRequest);
        System.out.println(instance.getInstanceIds());
    }
}

创建BCC请求是一个异步请求，返回200表明订单生成，后续可以通过查询返回的实例id信息了解BCC虚机的创建进度。

本接口用于创建一个或多个同配虚拟机实例。

创建实例需要实名认证，没有通过实名认证的可以前往百度开放云官网控制台中的安全认证下的实名认证中进行认证。

创建计费方式为后付费的实例需要账户现金余额+通用代金券大于100；预付费方式的实例则需要账户现金余额大于等于实例费用。

支持批量创建，且如果创建过程中有一个实例创建失败，所有实例将全部回滚，均创建失败，如果创建时包含CDS，CDS也会回滚。

缺省情形下，一个实例最多只能挂载5个云磁盘。

创建CDS磁盘和临时数据盘时，磁盘容量大小限制为5的倍数。

创建实例支持创建和添加临时数据盘，但不支持单独创建或添加临时数据盘。

临时数据盘不支持挂载、卸载、删除。

普通实例的临时数据盘最大不能超过500G。

指定子网和安全组创建，要求子网和安全组必须同时指定或同时不指定，同时指定的子网和安全组必须同属于一个VPC，都不指定会使用默认子网和默认安全组。

指定公网IP带宽创建，计费方式为按照带宽计费。

创建接口为异步创建，可通过查询实例详情接口查询实例状态

每个实例最多只能购买一块临时数据盘。

实例的临时数据盘默认只有hp1类型。

创建存储优化型实例必须购买临时数据盘，通过ephemeralDisks指定临时盘数据盘大小，默认nvme类型数据盘，无需指定。

创建请求详细使用请参考BCC API 文档创建实例（通过指定实例套餐规格） )

创建实例

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

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.Billing;
import com.baidubce.services.bcc.model.CreateCdsModel;
import com.baidubce.services.bcc.model.Reservation;
import com.baidubce.services.bcc.model.StorageType;
import com.baidubce.services.bcc.model.instance.CreateInstanceRequest;
import com.baidubce.services.bcc.model.instance.CreateInstanceResponse;

import java.util.ArrayList;
import java.util.List;

import static com.baidubce.services.bcc.model.instance.FpgaCardType.KU115;
import static com.baidubce.services.bcc.model.instance.GpuCardType.P4;

public class Main {
    public static void main(String[] args) {
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";

        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);

        BccClient client = new BccClient(bccClientConfiguration);

        CreateInstanceRequest instanceRequest = new CreateInstanceRequest();
        // 镜像ID
        instanceRequest.setImageId("m-***");
        // 待创建虚拟机实例的类型
        instanceRequest.setInstanceType("N6");
        // 待创建虚拟机实例的CPU核数
        instanceRequest.setCpuCount(1);
        // 待创建虚拟机实例的内存容量，单位GB
        instanceRequest.setMemoryCapacityInGB(4);
        // 待创建虚拟机实例的系统盘大小，单位GB，默认是40GB，范围为[40, 2048]GB，超过40GB按照云磁盘价格收费。注意指定的系统盘大小需要满足所使用镜像最小磁盘空间限制。
        instanceRequest.setRootDiskSizeInGb(20);
        // 待创建虚拟机实例系统盘介质，默认使用SSD型云磁盘
        instanceRequest.setRootDiskStorageType("enhanced_ssd_pl1");
        // 指定zone信息，默认为空，由系统自动选择，可通过调用查询可用区列表接口查询可用区列表。zoneName命名规范是“国家-region-可用区序列"，小写，例如北京可用区A为"cn-bj-a"。
        instanceRequest.setZoneName("cn-bj-a");
        // 虚拟机名字。默认都不指定name。如果指定name：批量时name作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
        instanceRequest.setName("instance-***");
        List<CreateCdsModel> createCdsList = new ArrayList<CreateCdsModel>();
        createCdsList.add(new CreateCdsModel()
                .withCdsSizeInGB(50)
                .withStorageType("enhanced_ssd_pl1"));
        // 待创建的CDS磁盘列表
        instanceRequest.setCreateCdsList(createCdsList);
        // 公网带宽，单位为Mbps。必须为0~200之间的整数，为0表示不分配公网IP，默认为0Mbps
        instanceRequest.setNetworkCapacityInMbps(10);
        // 批量创建（购买）的虚拟机实例个数，必须为大于0的整数，可选参数，缺省为1
        instanceRequest.setPurchaseCount(1);
        // 虚拟机主机名。默认都不指定hostname。如果指定hostname：批量时hostname作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
        instanceRequest.setHostname("hostn***");
        // 是否自动生成name和hostname有序后缀（可选参数） 是:true 否:false
        instanceRequest.setAutoSeqSuffix(true);
        // 待创建的实例管理员密码，8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*()。
        instanceRequest.setAdminPass("***");
        // 订单、计费相关参数
        instanceRequest.setBilling(new Billing()
                .withPaymentTiming("Postpaid"));
        // 指定subnet信息，为空时将使用默认子网
        instanceRequest.setSubnetId("sbn-***");
        // 指定securityGroup信息，为空时将使用默认安全组
        instanceRequest.setSecurityGroupId("g-***");
        // 待创建实例指定的标签是否需要和已有标签键进行关联，默认为false。注意值为true时要保证该标签键已存在
        instanceRequest.setRelationTag(true);
        // 自动快照策略ID
        instanceRequest.setAspId("asp-***");
        // 指定实例所在的部署集id
        instanceRequest.setDeployId("dset-***");

        CreateInstanceResponse instance = client.createInstance(instanceRequest);
        System.out.println(instance.getInstanceIds());
    }
}

创建BCC请求是一个异步请求，返回200表明订单生成，后续可以通过查询返回的实例id信息了解BCC虚机的创建进度。

本接口用于创建一个或多个同配虚拟机实例。

创建实例需要实名认证，没有通过实名认证的可以前往百度开放云官网控制台中的安全认证下的实名认证中进行认证。

创建计费方式为后付费的实例需要账户现金余额+通用代金券大于100；预付费方式的实例则需要账户现金余额大于等于实例费用。

支持批量创建，且如果创建过程中有一个实例创建失败，所有实例将全部回滚，均创建失败，如果创建时包含CDS，CDS也会回滚。

缺省情形下，一个实例最多只能挂载5个云磁盘。

创建CDS磁盘和临时数据盘时，磁盘容量大小限制为5的倍数。

创建实例支持创建和添加临时数据盘，但不支持单独创建或添加临时数据盘。

临时数据盘不支持挂载、卸载、删除。

普通实例的临时数据盘最大不能超过500G。

指定子网和安全组创建，要求子网和安全组必须同时指定或同时不指定，同时指定的子网和安全组必须同属于一个VPC，都不指定会使用默认子网和默认安全组。

指定公网IP带宽创建，计费方式为按照带宽计费。

创建接口为异步创建，可通过查询实例详情接口查询实例状态

可通过该接口指定专属服务器创建实例，专属实例不参与计费。专属实例只能通过ephemeralDisks创建临时盘并指定磁盘类型。

每个实例最多只能购买一块临时数据盘。

实例的临时数据盘默认只有hp1类型。

通过instanceType字段指定需要创建的虚机类型，目前API支持创建的虚机类型参见下述InstanceType。参数(instanceType，cpuCount，memoryCapacityInGB)可以确定需要的机型以及配置。

创建存储优化型实例必须购买临时数据盘，通过ephemeralDisks指定临时盘数据盘大小，默认nvme类型数据盘，无需指定。

创建请求详细使用请参考BCC API 文档创建实例

创建FPGA BCC虚机需要使用指定的(CPU、内存、本地数据盘、FPGA卡类型以及专用镜像), 详细请参考BCC API 文档FPGA型BCC可选规格配置

创建GPU BCC虚机需要使用指定的(CPU、内存、本地数据盘、GPU卡类型), 详细请参考BCC API 文档GPU型BCC可选规格配置

创建竞价实例

使用以下代码可以创建BCC竞价实例，包括普通型Ⅰ型实例、普通型Ⅲ型实例：

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.Billing;
import com.baidubce.services.bcc.model.CreateCdsModel;
import com.baidubce.services.bcc.model.instance.CreateInstanceRequest;
import com.baidubce.services.bcc.model.instance.CreateInstanceResponse;

import java.util.ArrayList;
import java.util.List;


public class Main {
    public static void main(String[] args) {
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";

        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);

        BccClient client = new BccClient(bccClientConfiguration);

        CreateInstanceRequest instanceRequest = new CreateInstanceRequest();
        // 镜像ID
        instanceRequest.setImageId("m-***");
        // 待创建虚拟机实例的类型
        instanceRequest.setSpec("bcc.g5.c1m4");
        // 抢占实例出价模型， 市场价: "market" 自定义："custom"。
        instanceRequest.setBidModel("market");
        // 待创建虚拟机实例的CPU核数
        instanceRequest.setCpuCount(1);
        // 待创建虚拟机实例的内存容量，单位GB
        instanceRequest.setMemoryCapacityInGB(4);
        // 待创建虚拟机实例的系统盘大小，单位GB，默认是40GB，范围为[40, 2048]GB，超过40GB按照云磁盘价格收费。注意指定的系统盘大小需要满足所使用镜像最小磁盘空间限制。
        instanceRequest.setRootDiskSizeInGb(20);
        // 待创建虚拟机实例系统盘介质，默认使用SSD型云磁盘
        instanceRequest.setRootDiskStorageType("enhanced_ssd_pl1");
        // 指定zone信息，默认为空，由系统自动选择，可通过调用查询可用区列表接口查询可用区列表。zoneName命名规范是“国家-region-可用区序列"，小写，例如北京可用区A为"cn-bj-a"。
        instanceRequest.setZoneName("cn-bj-a");
        // 虚拟机名字。默认都不指定name。如果指定name：批量时name作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
        instanceRequest.setName("instance-***");
        List<CreateCdsModel> createCdsList = new ArrayList<CreateCdsModel>();
        createCdsList.add(new CreateCdsModel()
                .withCdsSizeInGB(50)
                .withStorageType("enhanced_ssd_pl1"));
        // 待创建的CDS磁盘列表
        instanceRequest.setCreateCdsList(createCdsList);
        // 公网带宽，单位为Mbps。必须为0~200之间的整数，为0表示不分配公网IP，默认为0Mbps
        instanceRequest.setNetworkCapacityInMbps(10);
        // 批量创建（购买）的虚拟机实例个数，必须为大于0的整数，可选参数，缺省为1
        instanceRequest.setPurchaseCount(1);
        // 虚拟机主机名。默认都不指定hostname。如果指定hostname：批量时hostname作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
        instanceRequest.setHostname("host***");
        // 是否自动生成name和hostname有序后缀（可选参数） 是:true 否:false
        instanceRequest.setAutoSeqSuffix(true);
        // 待创建的实例管理员密码，8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*()。
        instanceRequest.setAdminPass("***");
        // 订单、计费相关参数
        instanceRequest.setBilling(new Billing()
                .withPaymentTiming("Postpaid"));
        // 指定subnet信息，为空时将使用默认子网
        instanceRequest.setSubnetId("sbn-***");
        // 指定securityGroup信息，为空时将使用默认安全组
        instanceRequest.setSecurityGroupId("g-***");
        // 待创建实例指定的标签是否需要和已有标签键进行关联，默认为false。注意值为true时要保证该标签键已存在
        instanceRequest.setRelationTag(true);
        // 自动快照策略ID
        instanceRequest.setAspId("asp-***");
        // 指定实例所在的部署集id
        instanceRequest.setDeployId("dset-***");

        CreateInstanceResponse instance = client.createBidInstance(instanceRequest);
        System.out.println(instance.getInstanceIds());
    }
}

创建BCC请求是一个异步请求，返回200表明订单生成，后续可以通过查询返回的竞价实例id信息了解BCC虚机的创建进度。

本接口用于创建一个或多个同配虚拟机竞价实例。

创建竞价实例需要实名认证，没有通过实名认证的可以前往百度开放云官网控制台中的安全认证下的实名认证中进行认证。

创建计费方式为后付费的竞价实例需要账户现金余额+通用代金券大于100；预付费方式的竞价实例则需要账户现金余额大于等于竞价实例费用。

支持批量创建，且如果创建过程中有一个实例创建失败，所有实例将全部回滚，均创建失败，如果创建时包含CDS，CDS也会回滚。

缺省情形下，一个实例最多只能挂载5个云磁盘。

创建CDS磁盘和临时数据盘时，磁盘容量大小限制为5的倍数。

普通实例的临时数据盘最大不能超过500G。

指定子网和安全组创建，要求子网和安全组必须同时指定或同时不指定，同时指定的子网和安全组必须同属于一个VPC，都不指定会使用默认子网和默认安全组。

指定公网IP带宽创建，计费方式为按照带宽计费。

创建接口为异步创建，可通过查询实例详情接口查询实例状态 )

查询竞价实例套餐

以下代码可以查询BCC虚机竞价套餐

public static void listBidFlavor(BccClient bccClient) {
    // 执行查询竞价实例套餐操作
    ListBccBidFlavorResponse listBccBidFlavorResponse = bccClient.listBidFlavor();

    for(ZoneResource zoneResource: listBccBidFlavorResponse.getZoneResources()) {
        System.out.println(zoneResource.getZoneName());    
    }
}

查询竞价实例市场价

以下代码可以查询竞价实例市场价

public static void getBidInstancePrice(BccClient bccClient) {
    GetBidInstancePriceRequest getBidInstancePriceRequest = new GetBidInstancePriceRequest();
    // 设置待查询的竞价实例类型为普通型BCC Ⅰ型
    getBidInstancePriceRequest.setInstanceType(InstanceType.N1.name());
    // 设置待查询的竞价实例类型为普通型BCC Ⅲ型
    getBidInstancePriceRequest.setInstanceType(InstanceType.N3.name());
    // 设置待查询的竞价实例的CPU核数
    getBidInstancePriceRequest.setCpuCount(cpuCount);
    // 设置待查询的竞价实例的内存大小GB
    getBidInstancePriceRequest.setMemoryCapacityInGB(memoryCapacityInGB);
    // 设置待查询的竞价实例的系统盘大小
    getBidInstancePriceRequest.setRootDiskSizeInGb(rootDiskSizeInGb);
    // 设置待查询的竞价实例的系统盘介质
    getBidInstancePriceRequest.setRootDiskStorageType(rootDiskStorageType);
    
    List<CreateCdsModel> createCdsModelList = new ArrayList<CreateCdsModel>();
    // 新建空白的CDS数据盘，类型为高性能型
    createCdsModelList.add(new CreateCdsModel().withStorageType(StorageType.hp1).withCdsSizeInGB(5));
    // 设置待查询的竞价实例的CDS磁盘列表
    getBidInstancePriceRequest.setCreateCdsList(createCdsList);
    // 设置待查询的竞价实例的购买个数
    getBidInstancePriceRequest.setPurchaseCount(purchaseCount);

    // 执行查询竞价实例市场价的操作
    GetBidInstancePriceResponse getBidInstancePriceResponse = bccClient.getBidInstancePrice(getBidInstancePriceRequest);
    
    // 获取待查询的竞价实例总价
    System.out.println(getBidInstancePriceResponse.getMoney());
    // 获取待查询的竞价实例购买个数
    System.out.println(getBidInstancePriceResponse.getCount());
    // 获取待查询的竞价实例的单个价格
    System.out.println(getBidInstancePriceResponse.getPerMoney());
}

取消竞价实例订单

以下代码可以取消竞价实例订单

public static void cancelBidOrder(BccClient bccClient) {
    CancelBidOrderRequest cancelBidOrderRequest = new CancelBidOrderRequest();
    // 设置待取消的竞价实例订单ID
    cancelBidOrderRequest.setOrderId();
    // 执行取消竞价实例订单操作
    CancelBidOrderResponse cancelBidOrderResponse = client.cancelBidOrder(cancelBidOrderRequest);
    cancelBidOrderResponse.getOrderId();
}

查询实例列表

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

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.InstanceModel;
import com.baidubce.services.bcc.model.instance.ListInstancesRequest;
import com.baidubce.services.bcc.model.instance.ListInstancesResponse;

public class ListInstances {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration().withProtocol(Protocol.HTTP).withCredentials(new DefaultBceCredentials(ak, sk)).withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        ListInstancesRequest listInstancesRequest = new ListInstancesRequest();
        // 批量获取列表的查询的起始位置，是一个由系统生成的字符串
        listInstancesRequest.setMarker("i-***");   
        // 每页包含的最大数量，最大数量通常不超过1000，缺省值为1000
        listInstancesRequest.setMaxKeys(1);  
        // 内网IP
        listInstancesRequest.setInternalIp("192.168.***.***");  
        // 专属服务器ID
        listInstancesRequest.setDedicatedHostId("d-***");  
        // 可用区信息
        listInstancesRequest.setZoneName("cn-bj-d");  
        // 多个标签，逗号分割，格式：tagKey:tagValue 或 tagKey
        listInstancesRequest.setKeypairId("***"); 
        ListInstancesResponse listInstancesResponse = client.listInstances(listInstancesRequest);

        for (InstanceModel instanceModel : listInstancesResponse.getInstances()) {
            System.out.println(instanceModel);
        }
    }
}

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

使用以下代码可以查询可关机不计费的实例列表，支持通过内网ip、密钥对id、可用区名称进行筛选:

public static void getInstanceNoChargeList(BccClient bccClient) {
    ListGetInstanceNoChargeRequest listGetInstanceNoChargeRequest = listGetInstanceNoChargeRequest();
    // 设置分页标志
    listGetInstanceNoChargeRequest.setMarker(instanceId);
    // 设置分页返回数据大小，默认为1000，最大数量不超过1000
    listGetInstanceNoChargeRequest.setMaxKeys(maxKeys);
    // 通过internalIp进行查询
    listGetInstanceNoChargeRequest.setInternalIp(internalIp);
    // 通过keypairId进行查询
    listGetInstanceNoChargeRequest.setKeypairId(keypairId);
    // 通过可用区名称进行查询
    listGetInstanceNoChargeRequest.setZoneName(zoneName);
    // 执行查询可关机不计费的实例列表的接口
    ListInstancesResponse response = bccClient.getInstanceNoChargeList(listGetInstanceNoChargeRequest);

    for(InstanceModel instanceModel: response.getInstances()){
        System.out.println(instanceModel.getId());
    }
}

查询实例详情

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

public static void getInstanceDetail(BccClient bccClient) {
    // 查询指定BCC虚机的详细信息
    InstanceModel instanceModel = bccClient.getInstance(instanceId).getInstance();
    System.out.println(instanceModel.getName());
}

根据实例ID查询实例列表

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.ListInstanceByIdsRequest;
import com.baidubce.services.bcc.model.instance.ListInstancesResponse;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration().withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk)).withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);
        // 根据实例ID查询实例列表
        ListInstanceByIdsRequest request = new ListInstanceByIdsRequest()
                .withInstanceIds(Arrays.asList("i-sZcdKAZR", "i-CH47zOoW"));
        ListInstancesResponse response = client.listInstanceByIds(request);
        System.out.println(response);
    }
}

启动实例

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

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;

public class StartInstance {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "http://bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        // 设置BCC虚机id
        String instanceId = "i-***";
        // 执行修改BCC操作
        client.startInstance(instanceId);
    }
}

接口调用成功后实例进入 Starting 状态。实例状态必须为 Stopped，调用此接口才可以成功返回，否则提示409错误。

停止实例

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

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.instance.StopInstanceRequest;

public class StopInstance {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "http://bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        StopInstanceRequest stopInstanceRequest = new StopInstanceRequest();
        // 设置BCC虚机id
        stopInstanceRequest.setInstanceId("i-***");
        // 设置是否强制停止，强制停止等同于断电处理，可能丢失实例操作系统中未写入磁盘的数据
        stopInstanceRequest.setForceStop(Boolean.FALSE);
        // 设置是否关机不计费，TRUE为关机不计费，FALSE为关机计费。注意：只有白名单用户才可以实行关机不计费
        stopInstanceRequest.setStopWithNoCharge(Boolean.FALSE);
        // 执行BCC虚机停止操作
        client.stopInstance(stopInstanceRequest);
    }
}

系统后台会在实例实际 Stop 成功后进入“已停止”状态。

只有状态为 Running 的实例才可以进行此操作，否则提示 409 错误。

实例支持强制停止，强制停止等同于断电处理，可能丢失实例操作系统中未写入磁盘的数据。

批量停止实例

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

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import java.util.Arrays;
import com.baidubce.services.bcc.model.instance.BatchStopInstanceRequest;

public class StopInstance {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "http://bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        BatchStopInstanceRequest stopInstanceRequest = new BatchStopInstanceRequest();
        // 设置BCC虚机ids
        stopInstanceRequest.setInstanceIds(Arrays.asList("i-KEmEve**","i-0nPl9W**"));
        // 设置是否强制停止，强制停止等同于断电处理，可能丢失实例操作系统中未写入磁盘的数据
        stopInstanceRequest.setForceStop(Boolean.FALSE);
        // 设置是否关机不计费，TRUE为关机不计费，FALSE为关机计费。注意：只有白名单用户才可以实行关机不计费
        stopInstanceRequest.setStopWithNoCharge(Boolean.FALSE);
        // 执行BCC虚机停止操作
        client.batchStopInstance(stopInstanceRequest);
    }
}

系统后台会在实例实际 Stop 成功后进入“已停止”状态。

只有状态为 Running 的实例才可以进行此操作，否则提示 409 错误。

实例支持强制停止，强制停止等同于断电处理，可能丢失实例操作系统中未写入磁盘的数据。

重启实例

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

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.RebootInstanceRequest;

public class RebootInstance {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "http://bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        // 设置BCC虚机id
        String instanceId = "i-***";
        // 执行修改BCC操作
        client.rebootInstance(new RebootInstanceRequest().withInstanceId(instanceId));
    }
}

只有状态为 Running 的实例才可以进行此操作，否则提示 409 错误。

接口调用成功后实例进入 Starting 状态。

支持强制重启，强制重启等同于传统服务器的断电重启，可能丢失实例操作系统中未写入磁盘的数据。

修改实例密码

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

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.instance.ModifyInstancePasswordRequest;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient bccClient = new BccClient(bccClientConfiguration);

        ModifyInstancePasswordRequest modifyInstancePasswordRequest = new ModifyInstancePasswordRequest();
        // 设置BCC虚机id
        modifyInstancePasswordRequest.setInstanceId("i-***");
        // 设置BCC虚机新密码
        modifyInstancePasswordRequest.setAdminPass("***");
        
        bccClient.modifyInstancePassword(modifyInstancePasswordRequest);
    }
}

只有 Running 和 Stopped 状态的实例才可以用调用接口，否则提示 409 错误。

修改实例属性

使用以下代码可以修改指定虚机的属性，目前只支持修改BCC虚机的名称属性:

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.ModifyInstanceAttributesRequest;

public class ModifyAttributeInstance {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "http://bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        // 设置BCC虚机id
        String instanceId = "i-***";
        // 设置该虚机的描述
        String newName = "newInstanceName";
        // 执行修改BCC操作
        client.modifyInstanceAttributes(
                new ModifyInstanceAttributesRequest()
                        .withInstanceId(instanceId)
                        .withName(newName)
        );
    }
}

修改实例描述

使用以下代码可以修改特定实例描述信息：

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.ModifyInstanceDescRequest;

public class ModifyDescInstance {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "http://bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        // 设置BCC虚机id
        String instanceId = "i-***";
        // 设置该虚机的描述
        String newDesc = "modify desc";
        // 执行修改BCC操作
        client.modifyInstanceDesc(
                new ModifyInstanceDescRequest()
                        .withInstanceId(instanceId)
                        .withDesc(newDesc)
        );
    }
}

只有 Running 和 Stopped 状态的实例才可以调用该接口，否则提示 409 错误。

重装实例

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

package com.baidubce.services.bcc;

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.RebuildInstanceRequest;

public class RebuildInstance {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration().withProtocol(Protocol.HTTP).withCredentials(new DefaultBceCredentials(ak, sk)).withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        RebuildInstanceRequest req = new RebuildInstanceRequest();
        // 指定的实例ID
        req.setInstanceId("i-***");  
        // 指定的镜像ID
        req.setImageId("m-***");  
        // 机器密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*())，密码需要加密传输
        req.setAdminPass("***");  
        // 待重装实例所要绑定的密钥对ID，必须传递adminPass、keypairId其中一个参数
        req.setKeypairId("k-***");  
 
        client.rebuildInstance(req);
    }
}

实例重装后，基于原系统盘的快照会自动删除，基于原系统盘的自定义镜像会保留。

重装实例(批量重装)

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

package com.baidubce.services.bcc;

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.RebuildBatchInstanceRequest;

import java.util.ArrayList;
import java.util.List;

public class BatchRebuildInstances {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration().withProtocol(Protocol.HTTP).withCredentials(new DefaultBceCredentials(ak, sk)).withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        RebuildBatchInstanceRequest req = new RebuildBatchInstanceRequest();
        List<String> instanceIds = new ArrayList<String>();
        instanceIds.add("i-***");
        instanceIds.add("i-***");

        // 指定的实例ID列表，最多100个
        req.setInstanceIds(instanceIds);  
        // 指定的镜像ID
        req.setImageId("m-***");  
        // 机器密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*())，密码需要加密传输
        req.setAdminPass("***");  
        // 待重装实例所要绑定的密钥对ID，必须传递adminPass、keypairId其中一个参数
        req.setKeypairId("k-***");  

        client.rebuildBatchInstance(req);
    }
}

实例重装后，基于原系统盘的快照会自动删除，基于原系统盘的自定义镜像会保留。

计费变更-转预付费

以下代码用于将实例计费模式由后付费转预付费

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.instance.ChangeToPrepaidRequest;
import com.baidubce.services.bcc.model.instance.ChangeToPrepaidResponse;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        ChangeToPrepaidRequest changeToPrepaidRequest = new ChangeToPrepaidRequest();
        changeToPrepaidRequest.setInstanceId("i-lC39****"); // 虚机ID
        changeToPrepaidRequest.setDuration(2);  // 预付费时长，单位为月	
        ChangeToPrepaidResponse response = client.changeToPrepaid(changeToPrepaidRequest);
        System.out.println(response.getOrderId()); // 订单ID
    }
}

释放实例

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

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        client.releaseInstance("i-eRnq****");   // 待释放实例ID
    }
}

释放单个云服务器实例，释放后实例所使用的物理资源都被收回，相关数据全部丢失且不可恢复。

只有付费类型为Postpaid或者付费类型为Prepaid且已过期的实例才可以释放。

实例释放后，已挂载的CDS磁盘自动卸载，，基于此CDS磁盘的快照会保留。

实例释放后，基于原系统盘的快照会自动删除，基于原系统盘的自定义镜像会保留。

释放实例(POST请求的释放)

释放单个云服务器实例，释放后实例所使用的物理资源都被收回，相关数据全部丢失且不可恢复。

释放的时候默认只释放实例和系统盘，用户可以选择是否关联释放当前时刻，实例挂载的eip+数据盘（只能统一释放完或者不释放。而不是挂载的数据盘释放一个或者多个）是否一起释放。

package com.baidubce.services.bcc;
import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.ReleaseInstanceByPostRequest;
public class ReleaseInstance {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration().withProtocol(Protocol.HTTP).withCredentials(new DefaultBceCredentials(ak, sk)).withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);
        ReleaseInstanceByPostRequest req = new ReleaseInstanceByPostRequest();
        // 实例id
        req.setInstanceId("i-***");  
        // 是否关联释放当前时刻，实例挂载的EIP和数据盘
        req.setRelatedReleaseFlag(true);  
        // 是否释放云磁盘快照
        req.setDeleteCdsSnapshotFlag(true);  
        client.releaseInstanceByPost(req);
        }
    }

批量释放实例

批量释放云服务器实例，释放后实例所使用的物理资源都被收回，相关数据全部丢失且不可恢复。

释放的时候默认只释放实例和系统盘，用户可以选择是否关联释放当前时刻，实例挂载的eip+数据盘（只能统一释放完或者不释放。而不是挂载的数据盘释放一个或者多个）是否一起释放。

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.instance.ReleaseMultipleInstancesRequest;
import java.util.ArrayList;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient bccClient = new BccClient(bccClientConfiguration);
        ReleaseMultipleInstancesRequest releaseMultipleInstancesRequest = new ReleaseMultipleInstancesRequest();
        // 设置待释放的实例id列表
        List<String> instanceIds = new ArrayList<String>();
        instanceIds.add("i-***");
        instanceIds.add("i-***");
        releaseMultipleInstancesRequest.setInstanceIds(instanceIds);
        // 是否关联释放当前时刻，实例挂载的EIP和数据盘
        releaseMultipleInstancesRequest.setRelatedReleaseFlag(true);
        // 是否释放云磁盘快照
        releaseMultipleInstancesRequest.setDeleteCdsSnapshotFlag(true);
        // 实例释放时是否进入回收站
        releaseMultipleInstancesRequest.setBccRecycleFlag(true);
        // 实例释放时是否删除关联的ENI
        releaseMultipleInstancesRequest.setDeleteRelatedEnisFlag(true);
        bccClient.releaseMultipleInstanceByPost(releaseMultipleInstancesRequest);
    }
}

释放预付费实例(POST)

释放预付费云服务器实例，释放后实例所使用的物理资源都被收回，相关数据全部丢失且不可恢复。

释放的时候默认只释放云服务器实例和系统盘，用户可以选择是否关联释放云服务器实例挂载的EIP和数据盘，关联的EIP和数据盘需全部释放或全部不释放，不支持选择部分释放，部分不释放。

当选择关联释放EIP和数据盘，云磁盘快照可选择一同关联释放，若数据盘不关联释放，云磁盘快照也不支持关联释放。

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.instance.ReleasePrepaidInstanceRequest;
import java.util.ArrayList;
import java.util.List;
public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient bccClient = new BccClient(bccClientConfiguration);
        ReleasePrepaidInstanceRequest releasePrepaidInstanceRequest = new ReleasePrepaidInstanceRequest();
        // 设置待释放的实例id列表
        releasePrepaidInstanceRequest.setInstanceId("i-***");
        // 是否关联释放当前实例挂载的EIP和数据盘(只有该字段为true时 deleteCdsSnapshotFlag字段才会有效，若该字段为false,deleteCdsSnapshotFlag字段的值无效)
        releasePrepaidInstanceRequest.setRelatedReleaseFlag(true);
        // 是否释放云磁盘快照
        releasePrepaidInstanceRequest.setDeleteCdsSnapshotFlag(true);
        // 实例释放时是否删除关联的ENI
        releasePrepaidInstanceRequest.setDeleteRelatedEnisFlag(true);
        bccClient.releasePrepaidInstanceByPost(releasePrepaidInstanceRequest);
    }
}

实例扩缩容

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

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.instance.ResizeInstanceRequest;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        ResizeInstanceRequest resizeInstanceRequest = new ResizeInstanceRequest();
        resizeInstanceRequest.setInstanceId("i-lC39****");  //待变配实例ID
        resizeInstanceRequest.setCpuCount(4);   //CPU核数
        resizeInstanceRequest.setMemoryCapacityInGB(16);  //内存大小,单位GB
        client.resizeInstance(resizeInstanceRequest);
    }
}

实例计费方式为预付费时，不能进行缩容操作

实例计费方式为后付费时，可弹性扩缩容

只有实例Running或Stopped状态时可以进行扩缩容操作

实例扩缩容之后会重启一次

异步接口，可通过查询实例详情接口查看扩缩容状态是否完成

专属实例可以通过指定的cpu、内存以及临时盘大小，专属实例临时盘大小只支持扩容而不支持缩容，具体请参考API文档实例扩缩容

实例扩缩容（通过指定实例套餐规格）

为指定虚机扩缩容，目前支持通过更新实例套餐规格对虚机的CPU以及内存进行扩缩容操作。

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.instance.ResizeInstanceRequest;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient bccClient = new BccClient(bccClientConfiguration);

        ResizeInstanceRequest resizeInstanceRequest = new ResizeInstanceRequest();
        // 设置BCC虚机id
        resizeInstanceRequest.setInstanceId("i-***");
        // 设置新的套餐规格
        resizeInstanceRequest.setSpec("bcc.g5.c4m16");
        
        bccClient.resizeInstanceBySpec(resizeInstanceRequest);
    }
}

只有实例Running或Stopped状态时可以进行扩缩容操作

实例扩缩容之后会重启一次

异步接口，可通过查询实例详情接口查看扩缩容状态是否完成

将实例加入安全组

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

public static void bindInstanceToSecurityGroup(BccClient bccClient) {
    BindSecurityGroupRequest bindSecurityGroupRequest = new BindSecurityGroupRequest();
    // 设置安全组id
    bindSecurityGroupRequest.setSecurityGroupId(securityGroupId);
    // 设置BCC虚机实例id
    bindSecurityGroupRequest.setInstanceId(instanceId);
    // 执行将实例加入安全组操作
    bccClient.bindInstanceToSecurityGroup(bindSecurityGroupRequest);
}

每个实例最多关联10个安全组。

将实例移出安全组

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

public static void unbindInstanceFromSecurityGroup(BccClient bccClient) {
    UnbindSecurityGroupRequest unbindSecurityGroupRequest = new UnbindSecurityGroupRequest();
    // 设置安全组id
    unbindSecurityGroupRequest.setSecurityGroupId(securityGroupId);
    // 设置BCC虚机实例id
    unbindSecurityGroupRequest.setInstanceId(instanceId);
    // 执行将实例移出安全组操作
    bccClient.unbindInstanceFromSecurityGroup(unbindSecurityGroupRequest);
}

每个实例至少关联一个安全组，默认关联默认安全组。

如果实例仅属于一个安全组，尝试移出时，请求会报 403 错。

查询实例VNC地址

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

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.GetInstanceVncResponse;

public class GetInstanceVnc {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration().withProtocol(Protocol.HTTP).withCredentials(new DefaultBceCredentials(ak, sk)).withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);
        // i-*** 为虚拟机实例ID
        GetInstanceVncResponse response = client.getInstanceVnc("i-***");  
        System.out.println(response.getVncUrl());
    }
}

VNC地址一次使用后即失效

URL地址有效期为10分钟

实例续费

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

package com.baidubce.services.bcc;

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.Billing;
import com.baidubce.services.bcc.model.Reservation;
import com.baidubce.services.bcc.model.instance.PurchaseReservedInstanceRequeset;
import com.baidubce.services.bcc.model.instance.PurchaseReservedInstanceResponse;

public class PurchaseReservedInstance {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration().withProtocol(Protocol.HTTP).withCredentials(new DefaultBceCredentials(ak, sk)).withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        PurchaseReservedInstanceRequeset req = new PurchaseReservedInstanceRequeset();
        // 虚拟机实例ID
        req.setInstanceId("i-***");  
        // 幂等性Token，是一个长度不超过64位的ASCII字符串
        req.setClientToken("random-uuid");  
        // 订单详情
        req.setBilling(new Billing()  
                // 续费方式，本接口针对预付费实例进行续费
                .withPaymentTiming("Prepaid")  
                // 续费时长和单位，续费单位为月
                .withReservation(new Reservation()  
                // 续费时长
                .withReservationLength(1))  
        );
        // 设置实例关联续费标识，默认为空字符串
        req.setRelatedRenewFlag("CDS");  
        
        PurchaseReservedInstanceResponse res = client.purchaseReservedInstance(req);
        System.out.println(res);
    }
}

BCC虚机实例扩缩容期间不能进行续费操作。

续费时若实例已欠费停机，续费成功后有个BCC虚机实例启动的过程。

该接口是一个异步接口。

专属实例不支持续费。

实例绑定标签

以下代码用于实例绑定标签

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.TagModel;
import com.baidubce.services.bcc.model.instance.BindTagsRequest;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient bccClient = new BccClient(bccClientConfiguration);

        BindTagsRequest bindTagsRequest = new BindTagsRequest();
        // 设置想要绑定的标签
        List<TagModel> changeTags = new ArrayList<TagModel>();
        TagModel tagModel = new TagModel().withTagKey("Key***").withTagValue("Value***");
        changeTags.add(tagModel);
        bindTagsRequest.setChangeTags(changeTags);
        // 设置对应的实例ID
        bindTagsRequest.setInstanceId("i-***");
        
        bccClient.bindInstanceToTags(bindTagsRequest);
    }
}

给实例绑定标签，用于分类和查找。

实例解绑标签

以下代码用于实例解绑标签

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.TagModel;
import com.baidubce.services.bcc.model.instance.UnbindTagsRequest;

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient bccClient = new BccClient(bccClientConfiguration);

        UnbindTagsRequest unbindTagsRequest = new UnbindTagsRequest();
        // 设置想要绑定的标签
        List<TagModel> changeTags = new ArrayList<TagModel>();
        TagModel tagModel = new TagModel().withTagKey("Key***").withTagValue("Value***");
        changeTags.add(tagModel);
        unbindTagsRequest.setChangeTags(changeTags);
        // 设置对应的实例ID
        unbindTagsRequest.setInstanceId("i-***");
        
        bccClient.unbindInstanceFromTags(unbindTagsRequest);
    }
}

解绑实例上定义的标签。

可以同时解绑多个标签。

实例变更子网

package com.baidubce.services.bcc;

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.ChangeInstanceSubnetRequest;

public class ChangeSubnet {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration().withProtocol(Protocol.HTTP).withCredentials(new DefaultBceCredentials(ak, sk)).withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        ChangeInstanceSubnetRequest req = new ChangeInstanceSubnetRequest();
        // 虚拟机实例ID
        req.setInstanceId("i-***");  
        // 变更后的子网ID
        req.setSubnetId("sbn-***");  
        // 变更后是否重启
        req.setReboot(true);  
        // 变更普通安全组，仅变更vpc时生效,不支持和EnterpriseSecurityGroupIds同时设置
        req.setSecurityGroupIds(Collections.singletonList("g-***"));
        // 变更企业安全组，仅变更vpc时生效,不支持和SecurityGroupIds同时设置
        req.setEnterpriseSecurityGroupIds(Collections.singletonList("esg-***"));
        client.updateInstanceSubnet(req);
    }
}

变更实例所属的子网。变更子网后默认自动重启，用户选择是否执行该操作。变更子网的范围目前仅支持在同AZ下变更子网，不支持跨AZ或跨VPC变更子网，如果从普通子网变更至NAT专属子网请先手动解绑EIP

查询实例套餐规格

查询实例资源套餐规格列表信息。创建虚机时建议使用参数(spec)指定需要的机型以及配置：

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.flavor.ListFlavorSpecRequest;
import com.baidubce.services.bcc.model.flavor.ListBccFlavorSpecResponse;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient bccClient = new BccClient(bccClientConfiguration);

        ListFlavorSpecRequest listFlavorSpecRequest = new ListFlavorSpecRequest();
        // 设置可用区
        listFlavorSpecRequest.setZoneName("cn-bj-d");
        
        ListBccFlavorSpecResponse response = bccClient.listFlavorSpec(listFlavorSpecRequest);
        System.out.println(response);
    }
}

默认获取当前地域下所有可用区的实例套餐规格，可通过设置可用区获取指定可用区下的实例套餐规格。

查询实例套餐价格

查询实例资源套餐规格对应的价格。：

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.BccClient;
import com.baidubce.services.bcc.BccClientConfiguration;
import com.baidubce.services.bcc.model.instance.BccPriceRequest;
import com.baidubce.services.bcc.model.instance.BccPriceResponse;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient bccClient = new BccClient(bccClientConfiguration);

        BccPriceRequest bccPriceRequest = new BccPriceRequest();
        // 设置实例规格族
        bccPriceRequest.setSpecId("g5");
        // 设置实例套餐规格
        bccPriceRequest.setSpec("bcc.g5.c2m8");
        // 设置可用区
        bccPriceRequest.setZoneName("cn-bj-d");
        // 设置计费方式
        bccPriceRequest.setPaymentTiming("prepay");
        // 设置购买时长（单位：月）
        bccPriceRequest.setPurchaseLength(2);
        // 设置购买数量
        bccPriceRequest.setPurchaseCount(2);
        
        BccPriceResponse response = bccClient.getPriceBySpec(bccPriceRequest);
        System.out.println(response);
    }
}

设置实例规格族会获取当前规格族下所有套餐的价格

设置实例套餐规格获取当前套餐的价格

付费方式，后付费：Postpaid，预付费：Prepaid

查询可变配规格

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.ListAvailableResizeSpecRequest;
import com.baidubce.services.bcc.model.instance.ListAvailableResizeSpecResponse;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        ListAvailableResizeSpecRequest request = new ListAvailableResizeSpecRequest()
                .withSpec("bcc.ic4.c1m1").withZone("cn-bj-a");
        ListAvailableResizeSpecResponse response = client.listAvailableResizeSpec(request);
        System.out.println(response);
    }
}

获取实例网卡信息

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.ListInstanceEnisRequest;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);
        // 设置实例ID
        ListInstanceEnisRequest request = new ListInstanceEnisRequest().withInstanceId("i-CH47****");
        System.out.println(client.listRecycleInstance());
    }
}

实例变更vpc

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.model.AbstractBceResponse;
import com.baidubce.services.bcc.model.instance.ChangeVpcRequest;
import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        // 变更vpc
        ChangeVpcRequest request = new ChangeVpcRequest()
                .withInstanceId("i-sZcd****")
                .withSubnetId("sbn-3rgdxbbn****")
                .withSecurityGroupIds(Arrays.asList("g-63vdycz*****"));
        AbstractBceResponse response = client.changeVpc(request);
        System.out.println(response.getMetadata().getBceRequestId());
    }
}

开机状态下实例重启，关机状态下实例不重启

批量转包年包月

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.BatchChangeToPrepaidRequest;
import com.baidubce.services.bcc.model.instance.BatchChangeToPrepaidResponse;
import com.baidubce.services.bcc.model.instance.ChangeToPrepaidRequest;
import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);

        // 指定计费变更的虚机ID和包年包月时长（单位：月）
        BatchChangeToPrepaidRequest request = new BatchChangeToPrepaidRequest();
        List<ChangeToPrepaidRequest> configList = new ArrayList<>();
        configList.add(new ChangeToPrepaidRequest().withInstanceId("i-sZcdKAZR").withDuration(1));
        configList.add(new ChangeToPrepaidRequest().withInstanceId("i-CH47zOoW").withDuration(1));
        request.setConfig(configList);
 
        BatchChangeToPrepaidResponse response = client.batchChangeToPrepaid(request);
        System.out.println(response);
    }
}

查询回收站实例列表

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.ListInstancesResponse;
import com.baidubce.services.bcc.model.instance.ListRecycleInstanceRequest;
import java.util.Calendar;
import java.util.Date;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);
        // 查询指定时间范围内进入回收站的后付费实例
        Date today = new Date();
        Calendar calendar = Calendar.getInstance();
        calendar.setTime(today);
        calendar.add(Calendar.DATE, -1);
        Date lastDay = calendar.getTime();
        ListRecycleInstanceRequest request = new ListRecycleInstanceRequest()
                .withRecycleBegin(lastDay)
                .withRecycleEnd(today);
                .withPaymentTiming(PaymentTiming.Postpaid)
        ListInstancesResponse response = client.listRecycleInstance(request);
        System.out.println(response);
    }
}

释放回收站实例

使用以下代码可以从回收站释放指定实例

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.ListInstancesResponse;
import com.baidubce.services.bcc.model.instance.ListRecycleInstanceRequest;
import java.util.Calendar;
import java.util.Date;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);
        client.deleteRecycledInstance("i-***");
    }
}

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

使用以下代码可以删除实例与部署集之间的关系

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.ListInstancesResponse;
import com.baidubce.services.bcc.model.instance.ListRecycleInstanceRequest;
import java.util.Calendar;
import java.util.Date;

public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);
        DeleteInstanceDeploysetRequest deleteInstanceDeploysetRequest = new DeleteInstanceDeploysetRequest();
        deleteInstanceDeploysetRequest
                .withDeployId("dset-NXyUzFou")
                .withInstanceIdList(Collections.singletonList("i-pKq2Bnhf"));
        client.deleteInstanceDeploySet(deleteInstanceDeploysetRequest);
    }
}

添加Ipv6

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.InstanceIpv6Request;
import com.baidubce.services.bcc.model.instance.InstanceAddIpv6Response;


public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);
        // 添加ipv6
        InstanceIpv6Request request = new InstanceIpv6Request();
        request.setInstanceId("i-0nPl9WFJ");
        request.setIpv6Address("2400:da00:e003:0:41c:4100:0:5");
        request.setReboot(false);

        InstanceAddIpv6Response response = client.addIpv6(request);
        System.out.println(response);
    }
}

释放Ipv6

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.InstanceIpv6Request;


public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);
        // 释放ipv6
        InstanceIpv6Request request = new InstanceIpv6Request();
        request.setInstanceId("i-0nPl9WFJ");
        request.setIpv6Address("2400:da00:e003:0:41c:4100:0:5");
        request.setReboot(false);
        client.delIpv6(request);
    }
}

批量添加主网卡辅助IP

使用以下代码可以为BCC批量增加主网卡辅助IP

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.BatchAddIpRequest;


public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);
        // 为主网卡分配ipv6
        BatchAddIpRequest request = new BatchAddIpRequest();
        request.setInstanceId("i-udU7HS0a");
        request.setAllocateMultiIpv6Addr(true);
        request.setSecondaryPrivateIpAddressCount(2);
        client.batchAddIp(request);
    }
}

批量删除主网卡辅助IP

使用以下代码可以为BCC批量删除主网卡辅助IP

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.BatchDeleteIpRequest;

import java.util.Collections;


public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);
        // 为主网卡释放ipv6
        InstanceIpv6Request request = new InstanceIpv6Request();
        request.setInstanceId("i-0nPl9WFJ");
        request.setPrivateIps(Collections.singletonList("2400:da00:e003:0:41c:4100:0:5"));
        client.batchDeleteIp(request);
    }
}

创建自动续费规则

使用以下代码可以为BCC创建自动续费规则

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.BatchDeleteIpRequest;

import java.util.Collections;


public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);
        // 创建自动续费规则
        client.createAutoRenewRule(new BccAutoRenewRequest()
                    .withInstanceId("i-dl2s537H")
                    .withRenewTimeUnit("month")
                    .withRenewTime(1)
                    .withRenewEip(true)
                    .withRenewCds(true));
    }
}

删除自动续费规则

使用以下代码可以为BCC删除自动续费规则

import com.baidubce.BceClientConfiguration;
import com.baidubce.Protocol;
import com.baidubce.auth.DefaultBceCredentials;
import com.baidubce.services.bcc.model.instance.BatchDeleteIpRequest;

import java.util.Collections;


public class Main {
    public static void main(String[] args) {
        // 设置您的ak、sk和要访问的endpoint
        String endpoint = "bcc.bj.baidubce.com";
        String ak = "ak";
        String sk = "sk";
        // 设置默认配置
        BceClientConfiguration bccClientConfiguration = new BccClientConfiguration()
                .withProtocol(Protocol.HTTP)
                .withCredentials(new DefaultBceCredentials(ak, sk))
                .withEndpoint(endpoint);
        // 创建bcc client
        BccClient client = new BccClient(bccClientConfiguration);
        // 删除自动续费规则
        client.deleteAutoRenewRule(new BccAutoRenewRequest()
                    .withInstanceId("i-dl2s537H")
                    .withRenewEip(true)
                    .withRenewCds(true));
    }
}

BccClient

磁盘

云服务器 BCC

BCC实例

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

创建实例

创建竞价实例

查询竞价实例套餐

查询竞价实例市场价

取消竞价实例订单

查询实例列表

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

查询实例详情

根据实例ID查询实例列表

启动实例

停止实例

批量停止实例

重启实例

修改实例密码

修改实例属性

修改实例属性

修改实例描述

重装实例

重装实例(批量重装)

计费变更-转预付费

释放实例

释放实例(POST请求的释放)

批量释放实例

释放预付费实例(POST)

实例扩缩容

实例扩缩容（通过指定实例套餐规格）

将实例加入安全组

将实例移出安全组

查询实例VNC地址

实例续费

实例绑定标签

实例解绑标签

实例变更子网

查询实例套餐规格

查询实例套餐价格

查询可变配规格

获取实例网卡信息

实例变更vpc

批量转包年包月

查询回收站实例列表

释放回收站实例

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

添加Ipv6

释放Ipv6

批量添加主网卡辅助IP

批量删除主网卡辅助IP

创建自动续费规则

删除自动续费规则