实例

更新时间：2025-01-23

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

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

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6	"github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10	// 设置您的ak、sk和要访问的endpoint
11	ak := "ak"
12	sk := "sk"
13	endpoint := "bcc.bj.baidubce.com"
14	// 创建bcc client
15	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17	IsOpenHostnameDomain := true
18	AutoSeqSuffix := true
19	RelationTag := false
20	IsOpenIpv6 := true
21	CdsAutoRenew := true
22	argsV2 := &api.CreateInstanceBySpecArgsV2{
23		// 镜像ID
24		ImageId: "m-***",
25		// 实例规格
26		Spec: "bcc.g5.c1m4",
27		// 待创建虚拟机实例的系统盘大小，单位GB，默认是40GB，范围为[40, 2048]GB，超过40GB按照云磁盘价格收费。注意指定的系统盘大小需要满足所使用镜像最小磁盘空间限制。
28		RootDiskSizeInGb: 20,
29		// 待创建虚拟机实例系统盘介质，默认使用SSD型云磁盘
30		RootDiskStorageType: api.StorageTypeEnhancedPl1,
31		// 待创建的CDS磁盘列表
32		CreateCdsList: []api.CreateCdsModel{
33			{
34				CdsSizeInGB: 50,
35				StorageType: api.StorageTypeEnhancedPl1,
36			},
37		},
38		// 公网带宽，单位为Mbps。必须为0~200之间的整数，为0表示不分配公网IP，默认为0Mbps
39		NetWorkCapacityInMbps: 10,
40		// 长度1～65个字节，字母开头，可包含字母数字-_/.字符。若不传该参数，服务会自动生成name。
41		EipName: "eipN***",
42		// 公网带宽计费方式，可选参数详见internetChargeType，若不指定internetChargeType，默认付费方式同BCC，预付费默认为包年包月按带宽，后付费默认为按使用带宽计费。
43		InternetChargeType: "BANDWIDTH_PREPAID",
44		// 批量创建（购买）的虚拟机实例个数，必须为大于0的整数，可选参数，缺省为1
45		PurchaseCount: 1,
46		// 虚拟机名字（可选）。默认都不指定name。如果指定name：批量时name作为名字的前缀。
47		//，后缀生成方式：name{ -序号}。如果没有指定name，则自动生成，方式：{instance-八位随机串-序号}。
48		//注：随机串从0~9a~z生成；序号按照count的数量级，依次递增，如果count为100，则序号从000~100递增，如果为10，则从00~10递增。
49		//支持大小写字母、数字、中文以及-_ /.特殊字符，必须以字母开头，长度1-65。
50		Name: "instance-***",
51		// 虚拟机主机名。默认都不指定hostname。如果指定hostname：批量时hostname作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
52		Hostname: "hostn***",
53		// 是否自动生成hostname domain（可选参数） 是:true 否:false
54		IsOpenHostnameDomain: &IsOpenHostnameDomain,
55		// 是否自动生成name和hostname有序后缀（可选参数） 是:true 否:false
56		AutoSeqSuffix: &AutoSeqSuffix,
57		// 待创建实例是否开启ipv6，只有当镜像和子网都支持ipv6时才可开启，true表示开启，false表示关闭，不传表示自动适配镜像和子网的ipv6支持情况
58		IsOpenIpv6: &IsOpenIpv6,
59		// 待创建的实例管理员密码，8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*()。
60		AdminPass: "***",
61		// 订单、计费相关参数
62		Billing: api.Billing{
63			PaymentTiming: api.PaymentTimingPrePaid,
64			Reservation: &api.Reservation{
65				ReservationLength:   1,
66				ReservationTimeUnit: "Month",
67			},
68		},
69		// 指定zone信息，默认为空，由系统自动选择，可通过调用查询可用区列表接口查询可用区列表。zoneName命名规范是“国家-region-可用区序列"，小写，例如北京可用区A为"cn-bj-a"。
70		ZoneName: "cn-bj-a",
71		// 指定subnet信息，为空时将使用默认子网
72		SubnetId: "sbn-***",
73		// 指定securityGroupIds信息，为空时将使用默认安全组
74		SecurityGroupIds: []string{"g-***"},
75		// 待创建实例指定的标签是否需要和已有标签键进行关联，默认为false。注意值为true时要保证该标签键已存在
76		RelationTag: &RelationTag,
77		// cds是否自动续费 是:true 否:false
78		CdsAutoRenew: &CdsAutoRenew,
79		// 自动快照策略ID
80		AspId: "asp-***",
81		// 指定实例所在的部署集id列表
82		DeployIdList: []string{"dset-***"},
83        // 指定弹性高性能计算集群id, 仅支持RDMA网络的套餐
84        EhcClusterId: "ehc-***"
85	}
86
87	createResult, err := bccClient.CreateInstanceBySpecV2(argsV2)
88	fmt.Println(err)
89	fmt.Println(createResult)
90}

提示：

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

创建竞价实例

使用以下代码可以创建BCC实例：

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6	"github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10	// 设置您的ak、sk和要访问的endpoint
11	ak := "ak"
12	sk := "sk"
13	endpoint := "bcc.bj.baidubce.com"
14	// 创建bcc client
15	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17	args := &api.CreateInstanceArgs{
18		// 镜像ID
19		ImageId: "m-***",
20		// 待创建虚拟机实例的类型
21		InstanceType:       "N6",
22		CpuCount:           1,
23		MemoryCapacityInGB: 4,
24		BidModel:           "market",
25		// 待创建虚拟机实例的系统盘大小，单位GB，默认是40GB，范围为[40, 2048]GB，超过40GB按照云磁盘价格收费。注意指定的系统盘大小需要满足所使用镜像最小磁盘空间限制。
26		RootDiskSizeInGb: 20,
27		// 待创建虚拟机实例系统盘介质，默认使用SSD型云磁盘
28		RootDiskStorageType: api.StorageTypeEnhancedPl1,
29		// 待创建的CDS磁盘列表
30		CreateCdsList: []api.CreateCdsModel{
31			{
32				CdsSizeInGB: 50,
33				StorageType: api.StorageTypeEnhancedPl1,
34			},
35		},
36		// 公网带宽，单位为Mbps。必须为0~200之间的整数，为0表示不分配公网IP，默认为0Mbps
37		NetWorkCapacityInMbps: 10,
38		// 长度1～65个字节，字母开头，可包含字母数字-_/.字符。若不传该参数，服务会自动生成name。
39		EipName: "eipN***",
40		// 批量创建（购买）的虚拟机实例个数，必须为大于0的整数，可选参数，缺省为1
41		PurchaseCount: 1,
42		// 虚拟机名字（可选）。默认都不指定name。如果指定name：批量时name作为名字的前缀。
43		//，后缀生成方式：name{ -序号}。如果没有指定name，则自动生成，方式：{instance-八位随机串-序号}。
44		//注：随机串从0~9a~z生成；序号按照count的数量级，依次递增，如果count为100，则序号从000~100递增，如果为10，则从00~10递增。
45		//支持大小写字母、数字、中文以及-_ /.特殊字符，必须以字母开头，长度1-65。
46		Name: "instance-***",
47		// 虚拟机主机名。默认都不指定hostname。如果指定hostname：批量时hostname作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
48		Hostname: "hostn***",
49		// 待创建的实例管理员密码，8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*()。
50		AdminPass: "***",
51		// 订单、计费相关参数
52		Billing: api.Billing{
53			PaymentTiming: api.PaymentTimingPrePaid,
54			Reservation: &api.Reservation{
55				ReservationLength:   1,
56				ReservationTimeUnit: "Month",
57			},
58		},
59		// 指定zone信息，默认为空，由系统自动选择，可通过调用查询可用区列表接口查询可用区列表。zoneName命名规范是“国家-region-可用区序列"，小写，例如北京可用区A为"cn-bj-a"。
60		ZoneName: "cn-bj-a",
61		// 指定subnet信息，为空时将使用默认子网
62		SubnetId: "sbn-***",
63		// 指定securityGroupIds信息，为空时将使用默认安全组
64		SecurityGroupIds: []string{"g-***"},
65		// 自动快照策略ID
66		AspId: "asp-***",
67		// 指定实例所在的部署集id列表
68		DeployIdList: []string{"dset-***"},
69	}
70
71	createResult, err := bccClient.CreateBidInstance(args)
72	fmt.Println(err)
73	fmt.Println(createResult)
74}

创建实例

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

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6	"github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10	// 设置您的ak、sk和要访问的endpoint
11	ak := "ak"
12	sk := "sk"
13	endpoint := "bcc.bj.baidubce.com"
14	// 创建bcc client
15	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17	IsOpenHostnameDomain := true
18	AutoSeqSuffix := true
19	RelationTag := false
20	IsOpenIpv6 := true
21	CdsAutoRenew := true
22	argsV2 := &api.CreateInstanceArgsV2{
23		// 镜像ID
24		ImageId: "m-***",
25		// 待创建虚拟机实例的类型
26		InstanceType: "N6",
27		// 实例的CPU核数
28		CpuCount: 1,
29		// 实例的内存大小，单位为GB
30		MemoryCapacityInGB: 4,
31		// 待创建虚拟机实例的系统盘大小，单位GB，默认是40GB，范围为[40, 2048]GB，超过40GB按照云磁盘价格收费。注意指定的系统盘大小需要满足所使用镜像最小磁盘空间限制。
32		RootDiskSizeInGb: 20,
33		// 待创建虚拟机实例系统盘介质，默认使用SSD型云磁盘
34		RootDiskStorageType: api.StorageTypeEnhancedPl1,
35		// 待创建的CDS磁盘列表
36		CreateCdsList: []api.CreateCdsModel{
37			{
38				CdsSizeInGB: 50,
39				StorageType: api.StorageTypeEnhancedPl1,
40			},
41		},
42		// 公网带宽，单位为Mbps。必须为0~200之间的整数，为0表示不分配公网IP，默认为0Mbps
43		NetWorkCapacityInMbps: 10,
44		// 长度1～65个字节，字母开头，可包含字母数字-_/.字符。若不传该参数，服务会自动生成name。
45		EipName: "eipN***",
46		// 公网带宽计费方式，可选参数详见internetChargeType，若不指定internetChargeType，默认付费方式同BCC，预付费默认为包年包月按带宽，后付费默认为按使用带宽计费。
47		InternetChargeType: "BANDWIDTH_PREPAID",
48		// 批量创建（购买）的虚拟机实例个数，必须为大于0的整数，可选参数，缺省为1
49		PurchaseCount: 1,
50		// 虚拟机名字（可选）。默认都不指定name。如果指定name：批量时name作为名字的前缀。
51		//，后缀生成方式：name{ -序号}。如果没有指定name，则自动生成，方式：{instance-八位随机串-序号}。
52		//注：随机串从0~9a~z生成；序号按照count的数量级，依次递增，如果count为100，则序号从000~100递增，如果为10，则从00~10递增。
53		//支持大小写字母、数字、中文以及-_ /.特殊字符，必须以字母开头，长度1-65。
54		Name: "instance-***",
55		// 虚拟机主机名。默认都不指定hostname。如果指定hostname：批量时hostname作为名字的前缀。后端将加上后缀，后缀生成方式：name{ -序号}。
56		Hostname: "hostn***",
57		// 是否自动生成hostname domain（可选参数） 是:true 否:false
58		IsOpenHostnameDomain: &IsOpenHostnameDomain,
59		// 是否自动生成name和hostname有序后缀（可选参数） 是:true 否:false
60		AutoSeqSuffix: &AutoSeqSuffix,
61		// 待创建实例是否开启ipv6，只有当镜像和子网都支持ipv6时才可开启，true表示开启，false表示关闭，不传表示自动适配镜像和子网的ipv6支持情况
62		IsOpenIpv6: &IsOpenIpv6,
63		// 待创建的实例管理员密码，8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*()。
64		AdminPass: "***",
65		// 订单、计费相关参数
66		Billing: api.Billing{
67			PaymentTiming: api.PaymentTimingPrePaid,
68			Reservation: &api.Reservation{
69				ReservationLength:   1,
70				ReservationTimeUnit: "Month",
71			},
72		},
73		// 指定zone信息，默认为空，由系统自动选择，可通过调用查询可用区列表接口查询可用区列表。zoneName命名规范是“国家-region-可用区序列"，小写，例如北京可用区A为"cn-bj-a"。
74		ZoneName: "cn-bj-a",
75		// 指定subnet信息，为空时将使用默认子网
76		SubnetId: "sbn-***",
77		// 指定securityGroupIds信息，为空时将使用默认安全组
78		SecurityGroupIds: []string{"g-***"},
79		// 待创建实例指定的标签是否需要和已有标签键进行关联，默认为false。注意值为true时要保证该标签键已存在
80		RelationTag: &RelationTag,
81		// cds是否自动续费 是:true 否:false
82		CdsAutoRenew: &CdsAutoRenew,
83		// 自动快照策略ID
84		AspId: "asp-***",
85		// 指定实例所在的部署集id列表
86		DeployIdList: []string{"dset-***"},
87	}
88
89	createResult, err := bccClient.CreateInstanceV2(argsV2)
90	fmt.Println(err)
91	fmt.Println(createResult)
92}

提示：

创建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可选规格配置

取消竞价实例订单

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

1cancelBidOrderRequest := &CancelBidOrderRequest{
2    // 订单ID
3    OrderId     string "orderId"
4}
5if err := bccClient.CancelBidOrder(cancelBidOrderRequest); err != nil {
6    fmt.Println("CancelBidOrderRequest failed: ", err)
7} else {
8    fmt.Println("CancelBidOrderRequest success.")
9}

查询竞价实例套餐

通过以下代码可以查询竞价实例套餐

1if res, err := bccClient.ListBidFlavor(); err != nil {
2    fmt.Println("List bidding instance flavors failed: ", err)
3} else {
4    fmt.Println("List bidding instance flavors success, result: ", res)
5}

查询套餐列表

使用以下代码可以查询套餐列表

1package main
2
3import (
4    "fmt"
5    "github.com/baidubce/bce-sdk-go/services/bcc"
6    "github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10    // 设置您的ak、sk和要访问的endpoint
11    ak := "ak"
12    sk := "sk"
13    endpoint := "bcc.bj.baidubce.com"
14    //创建bcc client
15    bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17    args := &api.ListFlavorSpecArgs{
18		Specs: "bcc.g5.c2m8",
19		ZoneName: "cn-bj-b",
20	}
21	
22    if res, err := bccClient.ListFlavorSpec(args); err != nil {
23        fmt.Println("Get flavor list failed: ", err)
24    } else {
25        fmt.Println("Get flavor list success, result: ", res)
26    }
27}

查询竞价实例市场价

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

1createCdsList := []api.CreateCdsModel{{
2    // 设置CDS磁盘容量，必须为大于0的整数，单位为GB，大小为0~5120G，可选参数
3    CdsSizeInGB: 40,
4    // 设置CDS磁盘存储类别，默认为高性能型，可选参数
5    StorageType: api.StorageTypeHP1,
6    // 设置快照ID
7    SnapshotId:  "your-snapshot-id",
8    // 设置加密密钥，true或false
9    EncryptKey:  true,
10}}
11tagList := []model.TagModel{{
12    // 设置要查询的tagKey
13    TagKey:   "your-tag-key",
14    // 设置要查询的tagValue
15    TagValue: "your-tag-value",
16}}
17args := &api.GetBidInstancePriceArgs{
18    // 使用 uuid 生成一个长度不超过64位的ASCII字符串
19    ClientToken:           "random-uuid",
20     // 设置待查询的虚拟机实例类型，具体可选类型参见InstanceType
21    InstanceType:          "your-choose-instance-type",
22    // 设置待查询虚拟机实例的CPU核数
23    CpuCount:              1,
24    // 设置待查询虚拟机实例的内存容量
25    MemoryCapacityInGB:    2,
26    // 设置待查询虚拟机实例的系统盘大小，单位GB，默认是40GB，范围为[40, 100]GB，超过40GB按照云磁盘价格收费。注意指定的系统盘大小需要满足所使用镜像最小磁盘空间限制。
27    RootDiskSizeInGb:      45,
28    // 设置待查询虚拟机实例系统盘介质，默认使用SSD型云磁盘，可指定系统盘磁盘类型可参见StorageType
29    RootDiskStorageType:   api.StorageTypeCloudHP1,
30    // 设置待查询的CDS磁盘列表
31    CreateCdsList:           createCdsList,
32    // 设置批量查询（购买）的虚拟机实例个数，必须为大于0的整数，可选参数，缺省为1
33    PurchaseCount:         1,
34    // 设置虚拟机名字，可选参数
35    Name:                  "your-choose-instance-name",
36    // 设置实例管理员密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*()),可选参数
37    AdminPass:             "your-admin-pass",
38    // 设置待查询实例所要绑定的密钥对ID,可选参数
39    KeypairId:             "your-keypair-id",
40    // 设置自动快照策略ID,可选参数
41    AspId:                 "your-asp-id",
42    // 设置待查询虚拟机实例的镜像ID,可选参数
43    ImageId:               "your-image-id",
44    // 设置竞价实例出价模型， 市场价: "market" 自定义："custom",可选参数
45    BidModel:              "your-bid-model",
46    // 设置竞价实例出价金额，若是自定义出价，且出价金额小于市场价，则不允许创建。当bidModel='custom'时才有效,可选参数
47    BidPrice:              "your-bid-price",
48    // 设置公网带宽，单位为Mbps。必须为0~200之间的整数，为0表示不分配公网IP，默认为0Mbps,可选参数
49    NetWorkCapacityInMbps: 20,
50    // 设置待查询实例指定的标签是否需要和已有标签键进行关联，默认为false。注意值为true时要保证该标签键已存在,可选参数
51    RelationTag:           false,
52    // 设置待查询的标签列表,可选参数
53    Tags:                    tagList,
54    // 设置securityGroup信息，为空时将使用默认安全组,可选参数
55    SecurityGroupId:       "your-security-group-id",
56    // 设置subnet信息，为空时将使用默认子网,可选参数
57    SubnetId:              "your-subnet-id",
58    // 设置指定zone信息，默认为空，由系统自动选择,可选参数
59    ZoneName:              "your-zone-name",
60    // 设置公网带宽计费方式,可选参数
61    InternetChargeType:    "your-internet-charge-type",
62}
63if res, err := bccClient.GetBidInstancePrice(args); err != nil {
64    fmt.Println("Get bidding instance price failed: ", err)
65} else {
66    fmt.Println("Get bidding instance price success, result: ", res)
67}

查询实例套餐库存

查询实例资源套餐规格对应的库存。

1// 实例类型
2instanceType := "instanceType"
3// CPU核数
4cpuCount := cpuCount
5// 内存容量（GB）
6memoryCapacityInGB := memoryCapacityInGB
7// 可用区名称
8zoneName := "zoneNamen"
9// GPU卡类型，GPU和VGPU可填
10gpuCard := "gpuCard"
11// GPU卡数量，GPU和VGPU可填
12cardCount := "cardCount"
13//本地盘信息
14ephemeralDisks := []EphemeralDisks{{
15      "storageType": "ssd",
16      "sizeInGB": sizeInGB,
17}}
18
19args := &api.CreateInstanceStockArgs{
20    InstanceType:     instanceType,
21    CpuCount: cpuCount,
22    MemoryCapacityInGB:  memoryCapacityInGB,
23    ZoneName:  zoneName,
24    GpuCard:  gpuCard,
25    CardCount:  cardCount,
26    EphemeralDisks:  ephemeralDisks,
27}
28if res, err := bccClient.GetInstanceCreateStock(args); err != nil {
29    fmt.Println("GetInstanceCreateStock failed: ", err)
30} else {
31    fmt.Println("GetInstanceCreateStock success: ", res)
32}

实例扩缩容库存查询

实例变配余量查询

1// 实例id
2instanceId := "instanceId"
3// CPU核数
4cpuCount := cpuCount
5// 内存容量（GB）
6memoryCapacityInGB := memoryCapacityInGB
7
8args := &api.CreateInstanceStockArgs{
9    InstanceId:     instanceId,
10    CpuCount: cpuCount,
11    MemoryCapacityInGB:  memoryCapacityInGB,
12}
13if res, err := bccClient.ResizeInstanceStockArgs(args); err != nil {
14    fmt.Println("ResizeInstanceStockArgs failed: ", err)
15} else {
16    fmt.Println("ResizeInstanceStockArgs success: ", res)
17}

查询部署集详情

通过以下代码利用部署集ID查询部署集详情

1// 设置你要查询的deploySetID
2deploySetID := "your-choose-deploy-set-id"
3if res, err := bccClient.GetDeploySet(deploySetID); err != nil {
4    fmt.Println("Delete deploy set failed: ", err)
5} else {
6    fmt.Println("Get deploy set success: ", res)
7}

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

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

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6	"github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10	// 设置您的ak、sk和要访问的endpoint
11	ak := "ak"
12	sk := "sk"
13	endpoint := "bcc.bj.baidubce.com"
14	//创建bcc client
15	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17	queryArgs := &api.DelInstanceDeployArgs{
18		DeploySetId: "dset-***",   //  部署集ID
19		InstanceIds: []string{"i-***", "i-***"},  // 实例ID列表
20	}
21	res, err := bccClient.DelInstanceDeploySet(queryArgs)
22	fmt.Println(err)
23	fmt.Println(res)
24}

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

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

1listInstanceArgs := &ListInstanceArgs{
2    // 批量获取列表的查询起始位置，是一个由系统产生的字符串
3    Marker          string
4	// 设置返回数据大小，缺省为1000
5    MaxKeys         int
6	// 通过internal Ip过滤
7    InternalIp      string
8	// 通过DedicatedHostId过滤
9    DedicatedHostId string
10	// 通过ZoneName过滤
11    ZoneName        string
12	// 通过KeypairId过滤
13    KeypairId       string
14}
15
16if res, err := bccClient.GetInstanceNoChargeList(listInstanceArgs); err != nil {
17    fmt.Println("GetInstanceNoChargeList failed: ", err)
18} else {
19    fmt.Println("GetInstanceNoChargeList success, result: ", res)
20}

查询实例列表

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

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6	"github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10	// 设置您的ak、sk和要访问的endpoint
11	ak := "ak"
12	sk := "sk"
13	endpoint := "bcc.bj.baidubce.com"
14	//创建bcc client
15	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17	listArgs := &api.ListInstanceArgs{
18		// 批量获取列表的查询的起始位置，是一个由系统生成的字符串
19		Marker:           "i-***",
20		// 每页包含的最大数量，最大数量通常不超过1000，缺省值为1000
21		MaxKeys:          1,
22		// 内网IP
23		InternalIp:       "192.168.***.***",
24		// 专属服务器ID
25		DedicatedHostId:  "d-***",
26		// 可用区信息
27		ZoneName:         "cn-bj-d",
28		// 多个实例ID，英文逗号分割，最多支持100个
29		InstanceIds:      "i-***",
30		// 多个实例名称，英文逗号分割，最多支持100个
31		InstanceNames:    "instance-***",
32		// 多个cds磁盘ID，英文逗号分割，最多支持100个
33		CdsIds:           "v-***",
34		// 多个部署集ID，英文逗号分割，最多支持100个
35		DeploySetIds:     "dset-***",
36		// 多个安全组ID，英文逗号分割，最多支持100个
37		SecurityGroupIds: "g-***",
38		// 支付方式（Prepaid / Postpaid）
39		PaymentTiming:    "Postpaid",
40		// 实例状态（Recycled / Running / Stopped / Stopping / Starting）
41		Status:           "Running",
42		// 多个标签，逗号分割，格式：tagKey:tagValue 或 tagKey
43		Tags:             "***",
44		// vpcId，只能与privateIps查询参数组合使用
45		VpcId:            "vpc-***",
46		// 多个内网IP，英文逗号分隔，最多支持100个，必须和vpcId组合使用
47		PrivateIps:       "192.168.***.***",             
48	}
49	res, err := bccClient.ListInstances(listArgs)
50	fmt.Println(err)
51	fmt.Println(res)
52}

查询回收站实例列表

以下代码可以查询回收站中的BCC虚机实例列表,支持通过虚机id，名字进行筛选

1package main
2
3import (
4    "fmt"
5    "github.com/baidubce/bce-sdk-go/services/bcc"
6    "github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10    // 设置您的ak、sk和要访问的endpoint
11    ak := "ak"
12    sk := "sk"
13    endpoint := "http://bcc.bj.baidubce.com"
14    // 创建bcc client
15    bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17    // 批量获取列表的查询的起始位置，是一个由系统生成的字符串,可选参数
18    marker := "marker***"
19    // 每页包含的最大数量，最大数量通常不超过1000。缺省值为1000,可选参数
20    maxKeys := 100
21    // 设置想要查询的付费类型,可选参数 Prepaid表示预付费，Postpaid表示后付费，不传表示都选
22    paymentTiming := "Postpaid"
23    // 设置想要查询的虚机id,可选参数
24    instanceId := "i-***"
25    // 设置想要查询的虚机名称,可选参数
26    name := "instance***"
27    // 设置想要查询虚机的回收开始时间(北京时间),可选参数 （闭区间）
28    recycleBegin := "2023-11-29T09:12:35Z"
29    // 设置想要查询虚机的回收结束时间(北京时间),可选参数 （开区间）
30    recycleEnd := "2023-11-30T09:12:35Z"
31    args := &api.ListRecycleInstanceArgs{
32        Marker:        marker,
33        MaxKeys:       maxKeys,
34        PaymentTiming: paymentTiming,
35        InstanceId:    instanceId,
36        Name:          name,
37        RecycleBegin:  recycleBegin,
38        RecycleEnd:    recycleEnd,
39    }
40    result, err := bccClient.ListRecycleInstances(args)
41    if err != nil {
42        fmt.Println("list instance failed:", err)
43    } else {
44        fmt.Println("list instance success: ", result)
45    }
46}

查询指定实例详情

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

1// 设置你要操作的instanceId
2instanceId := "your-choose-instance-id"
3
4result, err := client.GetInstanceDetail(instanceId)
5if err != nil {
6    fmt.Println("get instance detail failed:", err)
7} else 
8    fmt.Println("get instance detail success ", result)
9}

启动实例

如下代码可以启动一个实例

1package main
2
3import (
4    "fmt"
5    "github.com/baidubce/bce-sdk-go/services/bcc"
6)
7
8func main() {
9    // 设置您的ak、sk和要访问的endpoint
10    ak := "ak"
11    sk := "sk"
12    endpoint := "http://bcc.bj.baidubce.com"
13    // 创建bcc client
14    bccClient, _ := bcc.NewClient(ak, sk, endpoint)
15    // 设置你要操作的instanceId
16    instanceId := "i-***"
17    err := bccClient.StartInstance(instanceId)
18    if err != nil {
19        fmt.Println("start instance failed:", err)
20    } else {
21        fmt.Println("start instance success")
22    }
23}

提示：

实例状态必须为Stopped，调用此接口才能成功返回，否则返回409错误

该接口调用后，实例会进入Starting状态

停止实例

如下代码可以停止一个实例

1// 以下代码可以强制停止一个实例
2err := client.StopInstance(instanceId, true)
3if err != nil {
4    fmt.Println("stop instance failed:", err)
5} else {
6    fmt.Println("stop instance success")
7}

停止实例(支持强制停止&关机不计费)

使用以下代码停止实例:

1package main
2import (
3	"fmt"
4	"github.com/baidubce/bce-sdk-go/services/bcc"
5)
6func main() {
7	// 设置您的ak、sk和要访问的endpoint
8	ak := "ak"
9	sk := "sk"
10	endpoint := "http://bcc.bj.baidubce.com"
11	// 创建bcc client
12	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
13	err := bccClient.StopInstanceWithNoCharge(
14		// 待停止的实例ID
15		"i-***",
16		// 指定实例是否强制关机，可选值：True、False，缺省为false
17		true,
18		// 指定实例是否关机不计费，可选值：true、false，缺省为false
19		true) 
20	fmt.Println(err)
21}

提示：

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

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

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

重启实例

如下代码可以重启实例

1package main
2
3import (
4    "fmt"
5    "github.com/baidubce/bce-sdk-go/services/bcc"
6)
7
8func main() {
9    // 设置您的ak、sk和要访问的endpoint
10    ak := "ak"
11    sk := "sk"
12    endpoint := "http://bcc.bj.baidubce.com"
13    // 创建bcc client
14    bccClient, _ := bcc.NewClient(ak, sk, endpoint)
15    // 设置你要操作的instanceId
16    instanceId := "i-***"
17    err := bccClient.RebootInstance(instanceId, true)
18    if err != nil {
19        fmt.Println("reboot instance failed:", err)
20    } else {
21        fmt.Println("reboot instance success")
22    }
23}

提示：

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

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

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

修改实例密码

如下代码可以修改实例密码

1    package main
2
3    import (
4        "fmt"
5        "github.com/baidubce/bce-sdk-go/services/bcc"
6        "github.com/baidubce/bce-sdk-go/services/bcc/api"
7    )
8
9    func main() {
10        // 设置您的ak、sk和要访问的endpoint
11        ak := "ak"
12        sk := "sk"
13        endpoint := "bcc.bj.baidubce.com"
14        // 创建bcc client
15        bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16		// 实例ID
17        instanceId := "i-***"              
18        args := &api.ChangeInstancePassArgs{
19			// 实例管理员密码
20            AdminPass: "***",   
21        }
22        err := bccClient.ChangeInstancePass(instanceId, args)
23        if err != nil {
24            fmt.Println("change instance password failed:", err)
25        } else {
26            fmt.Println("change instance password success")
27        }
28    }

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

修改实例属性

如下代码可以修改实例属性

1package main
2
3import (
4    "fmt"
5    "github.com/baidubce/bce-sdk-go/services/bcc"
6    "github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10    // 设置您的ak、sk和要访问的endpoint
11    ak := "ak"
12    sk := "sk"
13    endpoint := "http://bcc.bj.baidubce.com"
14    // 创建bcc client
15    bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16    // 设置你要操作的instanceId
17    instanceId := "i-***"
18    args := &api.ModifyInstanceAttributeArgs{
19        // 修改instance的名称
20        Name: "Instance***",
21    }
22    err := bccClient.ModifyInstanceAttribute(instanceId, args)
23    if err != nil {
24        fmt.Println("modify instance failed:", err)
25    } else {
26        fmt.Println("modify instance success")
27    }
28}

提示：

目前该接口仅支持修改实例名称或网卡队列数

修改实例描述

如下代码可以修改实例描述

1package main
2
3import (
4    "fmt"
5    "github.com/baidubce/bce-sdk-go/services/bcc"
6    "github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10    // 设置您的ak、sk和要访问的endpoint
11    ak := "ak"
12    sk := "sk"
13    endpoint := "http://bcc.bj.baidubce.com"
14    // 创建bcc client
15    bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16    // 设置你要操作的instanceId
17    instanceId := "i-***"
18    modifyArgs := &api.ModifyInstanceDescArgs{
19        // 修改描述
20        Description: "test modify",
21    }
22    err := bccClient.ModifyInstanceDesc(instanceId, modifyArgs)
23    if err != nil {
24        fmt.Println("modify instance failed:", err)
25    } else {
26        fmt.Println("modify instance success")
27    }
28}

修改实例主机名

如下代码可以修改实例主机名

1    package main
2
3    import (
4        "fmt"
5        "github.com/baidubce/bce-sdk-go/services/bcc"
6        "github.com/baidubce/bce-sdk-go/services/bcc/api"
7    )
8
9    func main() {
10        // 设置您的ak、sk和要访问的endpoint
11        ak := "ak"
12        sk := "sk"
13        endpoint := "bcc.bj.baidubce.com"
14        // 创建bcc client
15        bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16        
17        // 设置你要操作的instanceId
18        instanceId := "i-***"
19        args := &api.ModifyInstanceHostnameArgs{
20            // 设置想要修改的新主机名
21            Hostname: "new-hostname***",
22            // 设置是否开启domain，可选参数 true表示开启 false和null 表示关闭
23            IsOpenHostnameDomain: true,
24            // 设置是否自动重启，可选参数 true表示重启，false和null表示不重启
25            Reboot: true,
26        }
27        err := client.ModifyInstanceHostname(instanceId, args)
28        if err != nil {
29            fmt.Println("modify instance hostname failed:", err)
30        } else {
31            fmt.Println("modify instance hostname success")
32        }
33    }

重装实例

如下代码可以重装实例

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6	"github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10	// 设置您的ak、sk和要访问的endpoint
11	ak := "ak"
12	sk := "sk"
13	endpoint := "bcc.bj.baidubce.com"
14	//创建bcc client
15	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17	IsOpenHostEye := true
18	IsPreserveData := true
19	args := &api.RebuildInstanceArgsV2{
20		// 指定的镜像ID
21		ImageId:        "m-***",
22		// 机器密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*())，密码需要加密传输
23		AdminPass:      "***",
24		// 待重装实例所要绑定的密钥对ID，必须传递adminPass、keypairId其中一个参数
25		KeypairId:      "k-***",
26		// 是否开启主机安全，默认开启
27		IsOpenHostEye:  &IsOpenHostEye,
28		// 是否保留数据重装，默认保留
29		IsPreserveData: &IsPreserveData, 
30	}
31	// i-*** 为指定的实例ID
32	err := bccClient.RebuildInstanceV2("i-***", args) 
33	fmt.Println(err)
34}

重装实例（批量）

使用以下代码重装实例:

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6	"github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10	// 设置您的ak、sk和要访问的endpoint
11	ak := "ak"
12	sk := "sk"
13	endpoint := "bcc.bj.baidubce.com"
14	//创建bcc client
15	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17	InstanceIds := []string{"i-***", "i-***"}
18	IsOpenHostEye := true
19	IsPreserveData := true
20	args := &api.RebuildBatchInstanceArgsV2{
21		// 指定的实例ID列表，最多100个
22		InstanceIds:    InstanceIds,
23		// 指定的镜像ID
24		ImageId:        "m-***",
25		// 机器密码(8-16位字符，英文，数字和符号必须同时存在，符号仅限!@#$%^*())，密码需要加密传输
26		AdminPass:      "***",
27		// 待重装实例所要绑定的密钥对ID，必须传递adminPass、keypairId其中一个参数
28		KeypairId:      "k-***",
29		// 是否开启主机安全，默认开启
30		IsOpenHostEye:  &IsOpenHostEye,
31		// 是否保留数据重装，默认保留
32		IsPreserveData: &IsPreserveData, 
33	}
34	err := bccClient.BatchRebuildInstancesV2(args)
35	fmt.Println(err)
36}

提示：

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

释放实例

如下代码可以释放实例

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6)
7
8func main() {
9	// 设置您的ak、sk和要访问的endpoint
10	ak := "ak"
11	sk := "sk"
12	endpoint := "bcc.bj.baidubce.com"
13	// 创建bcc client
14	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
15
16	err := bccClient.DeleteInstance("i-cNpT****") // 待删除虚机ID 
17	fmt.Println(err)
18}

释放实例（POST）

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

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6	"github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10	// 设置您的ak、sk和要访问的endpoint
11	ak := "ak"
12	sk := "sk"
13	endpoint := "bcc.bj.baidubce.com"
14	//创建bcc client
15	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17	args := &api.DeleteInstanceWithRelateResourceArgs{
18		// 是否关联释放当前时刻，实例挂载的EIP和数据盘
19		RelatedReleaseFlag:    true,
20		// 是否释放云磁盘快照
21		DeleteCdsSnapshotFlag: true,
22		// 实例释放时是否删除关联的ENI
23		DeleteRelatedEnisFlag: true,
24		// 实例释放时是否进入回收站
25		BccRecycleFlag:        true, 
26	}
27	// i-*** 为待释放实例的ID
28	err := bccClient.DeleteInstanceWithRelateResource("i-***", args) 
29	fmt.Println(err)
30}

批量释放实例（POST）

使用以下代码批量释放实例:

1    package main
2
3    import (
4        "fmt"
5        "github.com/baidubce/bce-sdk-go/services/bcc"
6        "github.com/baidubce/bce-sdk-go/services/bcc/api"
7    )
8
9    func main() {
10        // 设置您的ak、sk和要访问的endpoint
11        ak := "ak"
12        sk := "sk"
13        endpoint := "bcc.bj.baidubce.com"
14        // 创建bcc client
15        bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16        
17        deleteInstanceWithRelateResourceArgs := &api.BatchDeleteInstanceWithRelateResourceArgs{
18            // 释放的时候是否关联释放当前时刻，实例挂载的eip+数据盘
19            // (只有该字段为true时 deleteCdsSnapshotFlag字段才会有效，若该字段为false,deleteCdsSnapshotFlag字段的值无效）
20            RelatedReleaseFlag: true,
21            // 设置是否释放云磁盘快照
22            DeleteCdsSnapshotFlag: true,
23            // 设置是否进入回收站
24            BccRecycleFlag: true,
25            // 设置是否释放弹性网卡
26            DeleteRelatedEnisFlag: true,
27            // 批量释放的实例id，最多100个
28            InstanceIds: []string{"i-***"},
29        }
30        if err := bccClient.BatchDeleteInstanceWithRelateResource(deleteInstanceWithRelateResourceArgs); err != nil {
31            fmt.Println("release instance failed: ", err)
32        } else {
33            fmt.Println("release instance success.")
34        }
35    }

释放预付费实例（POST）

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

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

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

1    package main
2
3    import (
4        "fmt"
5        "github.com/baidubce/bce-sdk-go/services/bcc"
6        "github.com/baidubce/bce-sdk-go/services/bcc/api"
7    )
8
9    func main() {
10        // 设置您的ak、sk和要访问的endpoint
11        ak := "ak"
12        sk := "sk"
13        endpoint := "bcc.bj.baidubce.com"
14        // 创建bcc client
15        bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16        
17        deletePrepaidInstanceWithRelateResourceArgs := &api.DeletePrepaidInstanceWithRelateResourceArgs{
18            // 批量释放的实例id
19            InstanceId: "i-***",
20            // 是否关联释放当前实例挂载的EIP和数据盘(只有该字段为true时 DeleteCdsSnapshotFlag字段才会有效，若该字段为false,DeleteCdsSnapshotFlag字段的值无效）
21            RelatedReleaseFlag: true,
22            // 设置是否释放云磁盘快照
23            DeleteCdsSnapshotFlag: true,
24            // 设置是否释放弹性网卡
25            DeleteRelatedEnisFlag: true,
26        }
27        if err := bccClient.DeletePrepaidInstanceWithRelateResource(deletePrepaidInstanceWithRelateResourceArgs); err != nil {
28            fmt.Println("release instance failed: ", err)
29        } else {
30            fmt.Println("release instance success.")
31        }
32    }

释放回收站实例

回收站实例7天后自动释放，清理回收站资源，可以使用以下代码将其释放:

1package main
2
3import (
4    "fmt"
5    "github.com/baidubce/bce-sdk-go/services/bcc"
6    "github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10    // 设置您的ak、sk和要访问的endpoint
11    ak := "ak"
12    sk := "sk"
13    endpoint := "bcc.bj.baidubce.com"
14    // 创建bcc client
15    bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16	
17	// 待操作的实例ID
18	instanceId := "i-***"
19	// 请求释放回收站中的某个实例
20	err := bccClient.DeleteRecycledInstance(instanceId)
21	fmt.Println(err)
22}

提示：

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

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

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

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

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

后付费实例定时释放，到达预设时间后自动释放bcc，自动释放时间可查询实例详情ReleaseTime。设定空字符串可以取消定时释放。请谨慎使用该功能，避免遗忘定时设置

1package main
2import (
3	"fmt"
4	"github.com/baidubce/bce-sdk-go/services/bcc"
5)
6func main() {
7	// 设置您的ak、sk和要访问的endpoint
8	ak := "ak"
9	sk := "sk"
10	endpoint := "http://bcc.bj.baidubce.com"
11	// 创建bcc client
12	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
13	err := bccClient.AutoReleaseInstance(
14		// 实例ID
15		"i-***",
16		// 释放时间，格式yyyy-MM-dd'T'HH:mm:ss'Z'
17		"2024-05-01T07:58:09Z") 
18	fmt.Println(err)
19}

提示：

只有付费类型为Postpaid的后付费实例允许设定自动释放

本实例系统盘快照及实例快照都会被释放

本实例已挂载CDS云磁盘都会被自动卸载，不会被释放

实例释放后不可恢复

关联的网卡资源会被自动卸载，且被释放

释放保护

使用以下代码可以为BCC实例设置释放保护，实例当前设置可查询实例详情DeletionProtection，默认0不保护，1释放保护中（创建和查询入口限v2版本使用）:

1args := &api.DeletionProtectionArgs {
2// 释放保护状态 0不启用，1启用
3    DeletionProtection : 0,
4}
5// 设置你要操作的instanceId
6instanceId := "your-choose-instance-id"
7
8if err := bccClient.ModifyDeletionProtection(instanceId, args); err != nil {
9    fmt.Println("modifyDeletionProtection failed: ", err)
10} else {
11    fmt.Println("modifyDeletionProtection success.")
12}

提示：

后付费和预付费均可开启释放保护

已开启释放保护的实例将无法通过控制台或API释放，只有在关闭的情况下才能被手动释放。定时释放，欠费释放以及实例过期释放不受释放保护属性的影响

实例释放保护默认不开启

变配实例

使用以下代码可以选择CPU,MemoryCapacityInGB,EphemeralDisks,EnableJumboFrame变配指定BCC实例:

1resizeInstanceArgs := &ResizeInstanceArgs{
2    // BCC核数
3    CpuCount: CpuCount
4    // BCC的内存大小GB
5    MemoryCapacityInGB: MemoryCapacityInGB
6	// 临时盘数据盘大小
7    EphemeralDisks        []EphemeralDisk  "ephemeralDisks"
8    // 是否开启Jumbo帧，true开启，false不开启。
9	// 默认为空，为空时：
10	// 变配到不支持Jumbo帧的规格时，不开启Jumbo帧；
11	// 从不支持变配到支持的规格时，不开启Jumbo帧；
12	// 从支持到支持得规格是，若实例变配前开启Jumbo帧，变配后也开启Jumbo帧，若变配前不开启，则变配后也不开启。
13    EnableJumboFrame       *bool           enableJumboFrame,
14}
15// 设置你要操作的instanceId
16instanceId := "your-choose-instance-id"
17
18if err := bccClient.ResizeInstance(instanceId, resizeInstanceArgs); err != nil {
19    fmt.Println("resize instance failed: ", err)
20} else {
21    fmt.Println("resize instance success.")
22}

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

使用以下代码可以选择Spec,EnableJumboFrame变配指定BCC实例:

1resizeInstanceArgs := &ResizeInstanceArgs{
2    // 实例套餐规格
3    Spec               string          "spec"
4    // 是否开启Jumbo帧，true开启，false不开启。
5	// 默认为空，为空时：
6	// 变配到不支持Jumbo帧的规格时，不开启Jumbo帧；
7	// 从不支持变配到支持的规格时，不开启Jumbo帧；
8	// 从支持到支持得规格是，若实例变配前开启Jumbo帧，变配后也开启Jumbo帧，若变配前不开启，则变配后也不开启。
9    EnableJumboFrame   *bool           enableJumboFrame
10}
11// 设置你要操作的instanceId
12instanceId := "your-choose-instance-id"
13
14if err := bccClient.ResizeInstanceBySpec(instanceId, resizeInstanceArgs); err != nil {
15    fmt.Println("resize instance failed: ", err)
16} else {
17    fmt.Println("resize instance success.")
18}

绑定安全组

使用以下代码绑定安全组:

1// 设置你要操作的instanceId
2instanceId := "your-choose-instance-id"
3// 设置BCC绑定的安全组
4SecurityGroupId := "SecurityGroupId"
5
6if err := bccClient.BindSecurityGroup(instanceId, SecurityGroupId); err != nil {
7    fmt.Println("Bind Security Group failed: ", err)
8} else {
9    fmt.Println("Bind Security Group success.")
10}

解绑安全组

使用以下代码解绑安全组:

1// 设置你要操作的instanceId
2instanceId := "your-choose-instance-id"
3// 设置BCC解绑的安全组
4SecurityGroupId := "SecurityGroupId"
5
6if err := bccClient.UnBindSecurityGroup(instanceId, SecurityGroupId); err != nil {
7    fmt.Println("UnBind Security Group failed: ", err)
8} else {
9    fmt.Println("UnBind Security Group success.")
10}

提示：

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

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

实例扩缩容

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6	"github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10	// 设置您的ak、sk和要访问的endpoint
11	ak := "ak"
12	sk := "sk"
13	endpoint := "bcc.bj.baidubce.com"
14	// 创建bcc client
15	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16	// 待变配的实例配置参数
17	resizeArgs := &api.ResizeInstanceArgs{
18		CpuCount:           4,    // CPU核数
19		MemoryCapacityInGB: 16,   // 内存大小，单位GB
20		LiveResize:         true, // 是否支持在线扩容，默认为false
21	}
22	err := bccClient.ResizeInstance("i-SrzD****", resizeArgs)
23	fmt.Println(err)
24}

提示：

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

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

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

实例扩缩容之后会重启一次，可选择热升级进行扩缩容，不影响业务中断，热升级的限制请参考文档热升级的限制

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

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

查询实例VNC地址

如下代码可以查询实例的VNC地址

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6)
7
8func main() {
9	// 设置您的ak、sk和要访问的endpoint
10	ak := "ak"
11	sk := "sk"
12	endpoint := "bcc.bj.baidubce.com"
13	//创建bcc client
14	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
15	// i-*** 为虚拟机实例ID
16	res, err := bccClient.GetInstanceVNC("i-***") 
17	fmt.Println(err)
18	fmt.Println(res)
19}

提示：

VNC地址一次使用后即失效

URL地址有效期为10分钟

实例续费

对BCC虚机的续费操作，可以延长过期时长，以下代码可以对实例及关联产品进行续费

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6	"github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10	// 设置您的ak、sk和要访问的endpoint
11	ak := "ak"
12	sk := "sk"
13	endpoint := "bcc.bj.baidubce.com"
14	//创建bcc client
15	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16	// 虚拟机实例ID
17    instanceId := "i-***" 
18	args := &api.PurchaseReservedArgs{
19		// 设置实例关联续费标识，默认为空字符串
20		RelatedRenewFlag: "CDS",
21		// 订单详情
22		Billing: api.Billing{
23			// 续费方式，本接口针对预付费实例进行续费
24			PaymentTiming: api.PaymentTimingPrePaid,
25			// 续费时长和单位
26			Reservation: &api.Reservation{
27				// 续费时长
28				ReservationLength:   1,
29				// 续费单位为月
30				ReservationTimeUnit: "month", 
31			},
32		},
33		// 幂等性Token，是一个长度不超过64位的ASCII字符串
34		ClientToken: "random-uuid", 
35	}
36
37	res, err := bccClient.InstancePurchaseReserved(instanceId, args)
38	fmt.Println(err)
39	fmt.Println(res)
40}

注意：

关联续费产品(relatedRenewFlag)可选：

CDS 只对BCC实例关联的预付费CDS进行续费

EIP 只对BCC实例关联的预付费EIP进行续费

MKT 只对BCC实例关联的预付费MKT进行续费

CDS_EIP 只对BCC实例关联的预付费CDS、EIP进行续费

CDS_MKT 只对BCC实例关联的预付费CDS、MKT进行续费

EIP_MKT 只对BCC实例关联的预付费EIP、MKT进行续费

CDS_EIP_MKT 只对BCC实例关联的预付费CDS、EIP、MKT进行续费

提示：

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

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

该接口是一个异步接口。

专属实例不支持续费。

实例变更子网

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

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6	"github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10	// 设置您的ak、sk和要访问的endpoint
11	ak := "ak"
12	sk := "sk"
13	endpoint := "bcc.bj.baidubce.com"
14	//创建bcc client
15	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17	args := &api.InstanceChangeSubnetArgs{
18		// 虚拟机实例ID
19		InstanceId: "i-***",
20		// 变更后的子网ID
21		SubnetId:   "sbn-***",
22		// 指定内网IP，不指定则随机生成
23		InternalIp: "10.59.***.***",
24		// 变更后是否重启
25		Reboot:     true,
26        // 普通安全组，仅变更vpc时生效，不支持同时指定EnterpriseSecurityGroupIds
27        SecurityGroupIds: []string{"g-i24fkh******"},
28        // 企业安全组，仅变更vpc时生效，不支持同时指定SecurityGroupIds
29        EnterpriseSecurityGroupIds: []string{"esg-i24fkh******"},
30	}
31
32	err := bccClient.InstanceChangeSubnet(args)
33	fmt.Println(err)
34}

提示：

变更子网后默认自动重启，用户选择是否执行该操作。

变更子网的范围目前仅支持在同AZ下变更子网，不支持跨AZ或跨VPC变更子网，如果从普通子网变更至NAT专属子网请先手动解绑EIP。

实例变更VPC

如下代码可以变更实例的VPC

1package main
2
3import (
4	"fmt"
5
6	"github.com/baidubce/bce-sdk-go/services/bcc"
7	"github.com/baidubce/bce-sdk-go/services/bcc/api"
8)
9
10func main() {
11	// 设置您的ak、sk和要访问的endpoint
12	ak := "ak"
13	sk := "sk"
14	endpoint := "bcc.bj.baidubce.com"
15	// 创建bcc client
16	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
17
18	args := &api.InstanceChangeVpcArgs{
19		InstanceId:       "i-AgPa****",               //	实例ID
20		SubnetId:         "sbn-wwqfr3rd****",         //	子网ID
21		InternalIp:       "192.168.*.*",            //	内网IP
22		SecurityGroupIds: []string{"g-cfbk8xa0****"}, //	安全组ID
23	}
24	err := bccClient.InstanceChangeVpc(args)
25	if err != nil {
26		fmt.Println(err)
27	}
28}

提示：

变更VPC后默认自动重启，用户选择是否执行该操作。

变更VPC后仅保留主网卡主IP（在新子网中自动分配），实例上的辅助IP、弹性网卡和安全组等信息不跟随主体迁移。

安全组和企业安全组不能同时指定。

向指定实例批量添加指定ip

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6	"github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10	// 设置您的ak、sk和要访问的endpoint
11	ak := "ak"
12	sk := "sk"
13	endpoint := "bcc.bj.baidubce.com"
14	//创建bcc client
15	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17	privateIps := []string{"192.168.***.***", "192.168.***.***"}
18	batchAddIpArgs := &api.BatchAddIpArgs{
19		// 实例ID
20		InstanceId:                     "i-***",
21		// 辅助IP，最多100个，和SecondaryPrivateIpAddressCount不可同时使用
22		PrivateIps:                     privateIps,
23		// 是否是多IPV6，添加IPV6辅助地址必须是true
24		AllocateMultiIpv6Addr:          false,
25		// 自动分配IP数量，和PrivateIps不可同时使用
26		//SecondaryPrivateIpAddressCount: 2,           
27		// 幂等性Token，使用 uuid 生成一个长度不超过64位的ASCII字符串，可选参数
28		ClientToken:                    "random-uuid", 
29	}
30	res, err := bccClient.BatchAddIP(batchAddIpArgs)
31	fmt.Println(err)
32	fmt.Println(res)
33}

批量删除指定实例的ip

1privateIps := []string{"192.168.1.25"}
2instanceId := "your-choose-instance-id"
3// 幂等性Token，使用 uuid 生成一个长度不超过64位的ASCII字符串，可选参数
4clientToken := "clientToken"
5batchDelIpArgs := &api.BatchDelIpArgs{
6	InstanceId:     instanceId,
7    // 辅助IP，最多100个
8	PrivateIps:     privateIps,
9    ClientToken:    clientToken,
10}
11if err := client.BatchDelIP(batchDelIpArgs); err != nil {
12    fmt.Println("delete ips failed: ", err)
13} else {
14    fmt.Println("delete ips success.")
15}

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

自动续费仅限预付费产品

1package main
2import (
3	"fmt"
4	"github.com/baidubce/bce-sdk-go/services/bcc"
5	"github.com/baidubce/bce-sdk-go/services/bcc/api"
6)
7func main() {
8	// 设置您的ak、sk和要访问的endpoint
9	ak := "ak"
10	sk := "sk"
11	endpoint := "http://bcc.bj.baidubce.com"
12	// 创建bcc client
13	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14	bccAutoRenewArgs := &api.BccCreateAutoRenewArgs{
15		// 实例ID
16		InstanceId:    "i-***",
17		// 续费周期单位，可选值：year, month
18		RenewTimeUnit: "year",
19		// 续费时长
20		RenewTime:     1,
21		// 是否合并cds自动续费，默认值为true
22		RenewCds:      false,
23		// 是否合并eip自动续费，默认值为true
24		RenewEip:      false,        
25	}
26	err := bccClient.BatchCreateAutoRenewRules(bccAutoRenewArgs)
27	fmt.Println(err)
28}

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

自动续费仅限预付费产品

1package main
2import (
3	"fmt"
4	"github.com/baidubce/bce-sdk-go/services/bcc"
5	"github.com/baidubce/bce-sdk-go/services/bcc/api"
6)
7func main() {
8	// 设置您的ak、sk和要访问的endpoint
9	ak := "ak"
10	sk := "sk"
11	endpoint := "http://bcc.bj.baidubce.com"
12	// 创建bcc client
13	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14	bccDeleteAutoRenewArgs := &api.BccDeleteAutoRenewArgs{
15		// 实例ID
16		InstanceId: "i-***",
17		// 是否合并cds自动续费，默认值为true。
18		RenewCds:   false,
19		// 是否合并eip自动续费，默认值为true。
20		RenewEip:   false,        
21	}
22	err := bccClient.BatchDeleteAutoRenewRules(bccDeleteAutoRenewArgs)
23	fmt.Println(err)
24}

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

仅限后付费产品，预付费资源走续费接口

1package main
2
3import (
4    "fmt"
5    "github.com/baidubce/bce-sdk-go/services/bcc"
6    "github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10    // 设置您的ak、sk和要访问的endpoint
11    ak := "ak"
12    sk := "sk"
13    endpoint := "http://bcc.bj.baidubce.com"
14    // 创建bcc client
15    bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17    args := &api.RecoveryInstanceArgs{
18        InstanceIds: []api.RecoveryInstanceModel{
19            {
20                InstanceId: "i-***",
21            },
22            {
23                InstanceId: "i-***",
24            },
25        },
26    }
27    if err := bccClient.RecoveryInstance(args); err != nil {
28        fmt.Println("recovery instance failed: ", err)
29    } else {
30        fmt.Println("recovery instance success")
31    }
32}

计费变更-转预付费

使用以下代码对实例计费变更-转预付费:

1package main
2
3import (
4	"fmt"
5	"github.com/baidubce/bce-sdk-go/services/bcc"
6	"github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10	// 设置您的ak、sk和要访问的endpoint
11	ak := "ak"
12	sk := "sk"
13	endpoint := "bcc.bj.baidubce.com"
14	// 创建bcc client
15	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17	args := &api.ChangeToPrepaidRequest{
18		Duration:    1,    // 转预付费时长，单位为月
19	}
20	result, err := bccClient.ChangeToPrepaid("i-cVh8****", args) // 虚机ID, 转预付费参数
21	fmt.Println(err)
22	fmt.Println(result)
23}

实例绑定标签

使用以下代码对实例绑定标签:

1    package main
2
3    import (
4        "fmt"
5        "github.com/baidubce/bce-sdk-go/model"
6        "github.com/baidubce/bce-sdk-go/services/bcc"
7        "github.com/baidubce/bce-sdk-go/services/bcc/api"
8    )
9
10    func main() {
11        // 设置您的ak、sk和要访问的endpoint
12        ak := "ak"
13        sk := "sk"
14        endpoint := "bcc.bj.baidubce.com"
15        // 创建bcc client
16        bccClient, _ := bcc.NewClient(ak, sk, endpoint)
17
18        // 设置想要绑定的标签
19        args := &api.BindTagsRequest{
20            ChangeTags: []model.TagModel{
21                {
22                    TagKey:   "Key***",
23                    TagValue: "Value***",
24                },
25            },
26        }
27        // 设置你要操作的instanceId
28        instanceId := "i-***"
29        if err := bccClient.BindInstanceToTags(instanceId, args); err != nil {
30            fmt.Println("BindInstanceToTags failed: ", err)
31        } else {
32            fmt.Println("BindInstanceToTags success.")
33        }
34    }

实例解绑标签

使用以下代码对实例解绑标签:

1    package main
2
3    import (
4        "fmt"
5        "github.com/baidubce/bce-sdk-go/model"
6        "github.com/baidubce/bce-sdk-go/services/bcc"
7        "github.com/baidubce/bce-sdk-go/services/bcc/api"
8    )
9
10    func main() {
11        // 设置您的ak、sk和要访问的endpoint
12        ak := "ak"
13        sk := "sk"
14        endpoint := "bcc.bj.baidubce.com"
15        // 创建bcc client
16        bccClient, _ := bcc.NewClient(ak, sk, endpoint)
17
18        // 设置想要解绑的标签
19        args := &api.UnBindTagsRequest{
20            ChangeTags: []model.TagModel{
21                {
22					TagKey:   "Key***",
23					TagValue: "Value***",
24                },
25            },
26        }
27        // 设置你要操作的instanceId
28        instanceId := "i-***"
29        if err := bccClient.UnBindInstanceToTags(instanceId, args); err != nil {
30            fmt.Println("UnBindInstanceToTags failed: ", err)
31        } else {
32            fmt.Println("UnBindInstanceToTags success.")
33        }
34    }

查询可以变配的实例规格

使用以下代码可以查询可以变配的实例规格

1    package main
2
3    import (
4        "fmt"
5        "github.com/baidubce/bce-sdk-go/services/bcc"
6        "github.com/baidubce/bce-sdk-go/services/bcc/api"
7    )
8
9    func main() {
10        // 设置您的ak、sk和要访问的endpoint
11        ak := "ak"
12        sk := "sk"
13        endpoint := "bcc.bj.baidubce.com"
14        // 创建bcc client
15        bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16        
17        listAvailableResizeSpecsArgs := &api.ListAvailableResizeSpecsArgs{
18			// 实例规格
19			Spec: "bcc.ic5.c1m1",
20			// 可用区
21            Zone: "cn-bj-d",            
22        }
23        res, _ := bccClient.ListAvailableResizeSpecs(listAvailableResizeSpecsArgs)
24        fmt.Println(res)
25    }

批量转预付费

使用以下代码可以将实例批量转预付费，若需要对实例关联的cds变更，则必须在CdsList中传入所有需要转为预付费的cdsId，若所有cds均变更计费传入all。

1package main
2
3import (
4    "fmt"
5    "github.com/baidubce/bce-sdk-go/services/bcc"
6    "github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10    // 设置您的ak、sk和要访问的endpoint
11    ak := "ak"
12    sk := "sk"
13    endpoint := "http://bcc.bj.baidubce.com"
14    // 创建bcc client
15    bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16    // InstanceId最多100个
17    batchChangeInstanceToPrepayArgs := &api.BatchChangeInstanceToPrepayArgs{
18        Config: []api.PrepayConfig{
19            {
20                InstanceId: "i-***",
21                Duration:   1,
22                CdsList: []string{
23                    "v-***",
24                    "v-***",
25                },
26            },
27            {
28                InstanceId: "i-***",
29                Duration:   1,
30                CdsList: []string{
31                    "all",
32                },
33            },
34        },
35    }
36    result, err := bccClient.BatchChangeInstanceToPrepay(batchChangeInstanceToPrepayArgs)
37    if err != nil {
38        fmt.Println("batch change instance to prepay failed:", err)
39    } else {
40        fmt.Println("batch change instance to prepay success: ", result)
41    }
42}

批量转后付费

使用以下代码可以将实例批量转后付费，若需要对实例关联的cds变更，则必须在CdsList中传入所有需要转为后付费的cdsId，若所有cds均变更计费传入all。

1package main
2
3import (
4    "fmt"
5    "github.com/baidubce/bce-sdk-go/services/bcc"
6    "github.com/baidubce/bce-sdk-go/services/bcc/api"
7)
8
9func main() {
10    // 设置您的ak、sk和要访问的endpoint
11    ak := "ak"
12    sk := "sk"
13    endpoint := "http://bcc.bj.baidubce.com"
14    // 创建bcc client
15    bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16    // InstanceId最多100个
17    batchChangeInstanceToPostArgs := &api.BatchChangeInstanceToPostpayArgs{
18        Config: []api.PostpayConfig{
19            {
20                InstanceId: "i-***",
21                CdsList: []string{
22                    "v-***",
23                    "v-***",
24                },
25            },
26            {
27                InstanceId: "i-***",
28                CdsList: []string{
29                    "all",
30                },
31            },
32        },
33    }
34    result, err := bccClient.BatchChangeInstanceToPostpay(batchChangeInstanceToPostArgs)
35    if err != nil {
36        fmt.Println("batch change instance to postpay failed:", err)
37    } else {
38        fmt.Println("batch change instance to postpay success: ", result)
39    }
40}

获取实例角色列表

使用以下代码可以获取实例角色列表

1    package main
2
3    import (
4        "fmt"
5        "github.com/baidubce/bce-sdk-go/services/bcc"
6        "github.com/baidubce/bce-sdk-go/services/bcc/api"
7    )
8
9    func main() {
10        // 设置您的ak、sk和要访问的endpoint
11        ak := "ak"
12        sk := "sk"
13        endpoint := "bcc.bj.baidubce.com"
14        // 创建bcc client
15        bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17        result, err := bccClient.ListInstanceRoles()
18        if err != nil {
19            fmt.Println("list instance roles failed:", err)
20        } else {
21            fmt.Println("list instance roles success: ", result)
22        }
23    }

绑定角色

使用以下代码可以为BCC实例绑定角色

1    package main
2
3    import (
4        "fmt"
5        "github.com/baidubce/bce-sdk-go/services/bcc"
6        "github.com/baidubce/bce-sdk-go/services/bcc/api"
7    )
8
9    func main() {
10        // 设置您的ak、sk和要访问的endpoint
11        ak := "ak"
12        sk := "sk"
13        endpoint := "bcc.bj.baidubce.com"
14        // 创建bcc client
15        bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16        
17        // 设置想要绑定的标签
18        bindInstanceRoleArgs := &api.BindInstanceRoleArgs{
19            RoleName: "BCC_***",
20            Instances: []api.Instances{
21                {
22                    InstanceId: "i-***",
23                },
24            },
25        }
26
27        if err := bccClient.BindInstanceRole(bindInstanceRoleArgs); err != nil {
28            fmt.Println("bind instance role failed: ", err)
29        } else {
30            fmt.Println("bind instance role success.")
31        }

解绑角色

使用以下代码可以为BCC实例解绑角色

1    package main
2
3    import (
4        "fmt"
5        "github.com/baidubce/bce-sdk-go/services/bcc"
6        "github.com/baidubce/bce-sdk-go/services/bcc/api"
7    )
8
9    func main() {
10        // 设置您的ak、sk和要访问的endpoint
11        ak := "ak"
12        sk := "sk"
13        endpoint := "bcc.bj.baidubce.com"
14        // 创建bcc client
15        bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17        // 设置想要绑定的标签
18        unbindInstanceRoleArgs := &api.UnBindInstanceRoleArgs{
19            RoleName: "BCC_***",
20            Instances: []api.Instances{
21                {
22                    InstanceId: "i-***",
23                },
24            },
25        }
26
27        if err := bccClient.UnBindInstanceRole(unbindInstanceRoleArgs); err != nil {
28            fmt.Println("unbind instance role failed: ", err)
29        } else {
30            fmt.Println("unbind instance role success.")
31        }
32    }

添加Ipv6

使用以下代码可以为BCC实例添加Ipv6

1package main
2
3import (
4	"fmt"
5
6	"github.com/baidubce/bce-sdk-go/services/bcc"
7	"github.com/baidubce/bce-sdk-go/services/bcc/api"
8)
9
10func main() {
11	// 设置您的ak、sk和要访问的endpoint
12	ak := "ak"
13	sk := "sk"
14	endpoint := "http://bcc.bj.baidubce.com"
15	// 创建bcc client
16	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
17
18	addIpv6Args := &api.AddIpv6Args{
19		// 实例ID
20		InstanceId:  "i-***",
21		// IPv6地址
22		Ipv6Address: "240c:4081:8005:ca0b:***:***",
23		// 是否重启实例
24		Reboot:      true,                      
25	}
26
27	result, err := bccClient.AddIpv6(addIpv6Args)
28	fmt.Println(result)
29	fmt.Println(err)
30}

释放Ipv6

使用以下代码可以为BCC实例释放Ipv6

1package main
2import (
3	"fmt"
4	"github.com/baidubce/bce-sdk-go/services/bcc"
5	"github.com/baidubce/bce-sdk-go/services/bcc/api"
6)
7func main() {
8	// 设置您的ak、sk和要访问的endpoint
9	ak := "ak"
10	sk := "sk"
11	endpoint := "http://bcc.bj.baidubce.com"
12	// 创建bcc client
13	bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14
15	addIpv6Args := &api.DeleteIpv6Args{
16		// 实例ID
17		InstanceId: "i-***",
18		// 是否重启实例
19		Reboot:     true,         
20	}
21	err := bccClient.DeleteIpv6(addIpv6Args)
22	fmt.Println(err)
23}

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

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

1    package main
2
3    import (
4        "fmt"
5        "github.com/baidubce/bce-sdk-go/services/bcc"
6        "github.com/baidubce/bce-sdk-go/services/bcc/api"
7    )
8
9    func main() {
10        // 设置您的ak、sk和要访问的endpoint
11        ak := "ak"
12        sk := "sk"
13        endpoint := "bcc.bj.baidubce.com"
14        // 创建bcc client
15        bccClient, _ := bcc.NewClient(ak, sk, endpoint)
16
17        args := &api.ListInstanceByInstanceIdArgs{
18            // 待查询的实例id列表，最多100个
19            InstanceIds: []string{
20                "i-***",
21                "i-***",
22            },
23        }
24        result, err := bccClient.ListInstanceByInstanceIds(args)
25        if err != nil {
26            fmt.Println("list instance failed:", err)
27        } else {
28            fmt.Println("list instance success: ", result)
29        }
30    }

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

使用以下代码可以查询实例绑定的弹性网卡列表

1// 设置你要操作的instanceId，最多100个
2instanceId := "instanceId"
3if res, err := BCC_CLIENT.ListInstanceEnis(instanceId); err != nil {
4	fmt.Println("Get specific instance eni failed: ", err)
5} else {
6	fmt.Println("Get specific instance eni success, result: ", res)
7}

查询实例自定义数据

使用以下代码可以查询实例自定义数据

1// 设置你要操作的instanceId
2    args := &api.DescribeInstanceUserDataArg{
3		InstanceId: "i-b34ycow2",
4	}
5	result, err := BCC_CLIENT.getInstanceUserData(args)
6	fmt.Println(result)
7	fmt.Println(err)

可用区

磁盘

云服务器 BCC