Disk
Updated at：2025-10-20
Create a CDS disk
Support creating a cloud disk server (CDS)or creating a CDS disk from a CDS data disk snapshot. You can create a CDS disk by referring to the following code:
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 args := &api.CreateCDSVolumeArgs{
15 PurchaseCount: 2, // Purchase count
16 CdsSizeInGB: 5, // Disk size
17 StorageType: api.StorageTypeHdd, // Storage class
18 ChargeType: api.PaymentTimingPostPaid, // Bill type
19 ZoneName: "cn-bj-c", // Availability zone
20 Name: "test-create-cds", // Disk name
21 Description: "test-desc", // Disk description
22 Tags: []model.TagModel{ // Bound tags
23 {
24 // Tag key
25 TagKey: "Key-***",
26 // Tag value
27 TagValue: "Value***",
28 },
29 },
30 }
31 result, err := bccClient.CreateCDSVolume(args)
32 if err != nil {
33 fmt.Println("create CDS volume failed:", err)
34 } else {
35 fmt.Println("create CDS volume success: ", result)
36 }
37}Prompt:
- The CDS disk creation API is asynchronous. You can query the disk status through the [Query Disk Details](#Query disk details) API. For detailed use of the API, please refer to the BCC API documentation Query Disk Details
Query the disk list
You can query all disk lists with the following code. It supports pagination queries and filtering based on the BCC instance ID to which the cloud disk server is attached:
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 // Parameters for querying the disk list
15 queryArgs := &api.ListCDSVolumeArgs{
16 Marker: "v-3uIJ", // Starting disk ID
17 MaxKeys: 10, // Maximum count of results to return
18 InstanceId: "i-cVh8", // Instance ID to which the disk is attached
19 ZoneName: "cn-bj-a", // Availability zone
20 ClusterId: "DC-rWKx****", // Dedicated cluster ID
21 }
22 res, err := bccClient.ListCDSVolume(queryArgs)
23 if err != nil {
24 fmt.Println(err)
25 } else {
26 fmt.Println(res)
27 }
28}Query disk details
You can retrieve detailed information about a specific disk with its disk ID, and you can query disk details with the following code:
Go
1package main
2import (
3 "fmt"
4 "github.com/baidubce/bce-sdk-go/services/bcc"
5)
6func main() {
7 // Set your AK, SK and the endpoint to be accessed
8 ak := "ak"
9 sk := "sk"
10 endpoint := "bcc.bj.baidubce.com"
11 // Create a BCC client
12 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
13
14 // Retrieve detailed information for a specified CDS volume
15 res, err := bccClient.GetCDSVolumeDetail("v-3uIJ****") // Specify the CDS disk ID
16 if err != nil {
17 fmt.Println(err)
18 } else {
19 fmt.Println(res)
20 }
21}Attach a CDS disk
You can attach a detached disk to a corresponding BCC instance. The following code attaches a CDS disk to the corresponding BCC instance:
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "http://bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 args := &api.AttachVolumeArgs{
15 // Set instance ID to which the disk will be mounted
16 InstanceId: "i-***",
17 }
18 result, err := bccClient.AttachCDSVolume(
19 // Set the disk ID to be attached
20 "v-***",
21 args)
22 fmt.Println(result)
23 fmt.Println(err)
24}Prompt:
- The CDS disk must be attached to a BCC instance located in the same zone; otherwise, a 403 error will occur.
- Mounting is only permitted when the disk status is "Available" and the instance status is either "Running" or "Stopped." Otherwise, calling this API will result in a 409 error.
Detach a CDS disk
You can detach an already attached disk from its corresponding BCC virtual machine. The following code can be used to detach a CDS disk:
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "http://bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 args := &api.DetachVolumeArgs{
15 // Set instance ID to which the disk will be mounted
16 InstanceId: "i-***",
17 }
18 err := bccClient.DetachCDSVolume(
19 // Set the disk ID to be attached
20 "v-***",
21 args)
22 fmt.Println(err)
23}Prompt:
- This operation can only be performed when the instance is in the Running or Stopped state; otherwise, a 409 error will occur.
- If the disk with the given volumeId is not attached to the instance with the given instanceId, the operation will fail, and a 404 error will occur.
Release a CDS disk
It is used to release unattached CDS disk. Specify whether to delete snapshots associated with the disk. By default, all snapshots of the disk will be retained, but the association with the disk will be removed.
Go
1err = client.DeleteCDSVolume(volumeId)
2if err != nil {
3 fmt.Println("delete CDS volume failed:", err)
4} else {
5 fmt.Println("delete CDS volume success")
6}Prompt:
- An attached CDS disk cannot be released, and system disks cannot be released either.
- Once released, a disk cannot be recovered. By default, all snapshots of the disk will be retained, but their association with the disk will be removed.
- This operation can only be executed when the disk status is "Available," "Expired," or "Error." Otherwise, a 409 error will be returned.
Release a disk (POST)
Prompt:
- This API releases unattached CDS disks; system disks cannot be released.
- Users can decide whether to delete snapshots associated with the disk. By default, all disk snapshots will be kept, but their association with the disk will be removed.
- Users can specify whether to move the disk to the recycle bin
- This operation can only be executed when the disk status is "Available," "Expired," or "Error." Otherwise, a 409 error will be returned.
- If the disk corresponding to the volumeId does not exist, a 404 error will be returned You can release a disk with the following code:
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14
15 // Disk ID
16 volumeId := "v-***"
17 args := &api.DeleteCDSVolumeArgs{
18 // Whether to delete automatic snapshots associated with the disk
19 AutoSnapshot: "on",
20 // Whether to delete manual snapshots associated with the disk
21 ManualSnapshot: "on",
22 // Whether to move the disk to the recycle bin; if set to off, the disk will be released directly without entering the recycle bin
23 Recycle: "off",
24 }
25
26 // Request to release the disk
27 err := bccClient.DeleteCDSVolumeNew(volumeId, args)
28 fmt.Println(err)
29}Rename a disk
You can rename a CDS disk with the following code:
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 volumeId := "" // Disk ID to be renamed
15 args := &api.RenameCSDVolumeArgs{
16 Name: "testVolume", // New disk name
17 }
18 err := bccClient.RenameCDSVolume(volumeId, args)
19 if err != nil {
20 fmt.Println("rename CDS volume failed", err)
21 } else {
22 fmt.Println("rename CDS volume success")
23 }
24}Modify disk properties
You can modify the name and description of a specified disk with the following code:
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 args := &api.ModifyCSDVolumeArgs{
15 CdsName: "name", // CDS name to be modified
16 Desc: "desc", // Modified CDS description
17 }
18 volumeId := "v-vG0z****" // Disk ID
19 err := bccClient.ModifyCDSVolume(volumeId, args)
20 if err != nil {
21 fmt.Println("modify CDS volume failed: ", err)
22 } else {
23 fmt.Println("modify CDS volume success")
24 }
25}Shift charge for disks
You can change the disk charge type using the code provided below. Two conversions are supported: from pay-as-you-go (postpay) to subscription (prepay) and vice versa. When switching to subscription (prepay), you must specify the purchase period.
- You can switch a subscribed (prepaid) disk to a pay-as-you-go (postpaid) billing model using the following code.
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14
15 // Disk ID
16 volumeId := "v-***"
17 args := &api.ModifyChargeTypeCSDVolumeArgs{
18 Billing: &api.Billing{
19 // Postpay flag, optional
20 PaymentTiming: api.PaymentTimingPostPaid,
21 },
22 }
23 // Request to change a prepaid disk to be postpaid
24 err := bccClient.ModifyChargeTypeCDSVolume(volumeId, args)
25 fmt.Println(err)
26}
- You can change a pay-as-you-go (postpaid) disk to a subscribed (prepaid) disk with the following code:
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 // Disk ID
15 volumeId := "v-***"
16 args := &api.ModifyChargeTypeCSDVolumeArgs{
17 Billing: &api.Billing{
18 // Prepay flag, optional
19 PaymentTiming: api.PaymentTimingPrePaid,
20 Reservation: &api.Reservation{
21 // Reserved duration, in month, value range [1,9]
22 ReservationLength: 1,
23 // Unit of reserved duration. Currently, only month is supported, and it is not required.
24 ReservationTimeUnit: "month",
25 },
26 },
27 }
28 // Request to change the postpaid disk to the prepaid disk
29 err := bccClient.ModifyChargeTypeCDSVolume(volumeId, args)
30 fmt.Println(err)
31}Enable automatic renewal for disks
You can enable automatic renewal for disks with the following code:
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14
15 volumeId := "v-***"
16 renewTimeUnit := "month"
17 // Set auto-renewal period: 1-9 for monthly renewal, 1-3 for yearly renewal
18 renewTime := 4
19 args := &api.AutoRenewCDSVolumeArgs{
20 // Disk ID
21 VolumeId: volumeId,
22 // Unit of renewal time, current value: month
23 RenewTimeUnit: renewTimeUnit,
24 // Renewal time, value range: 1-9
25 RenewTime: renewTime,
26 }
27 err := bccClient.AutoRenewCDSVolume(args)
28 fmt.Println(err)
29}
- Note: Auto-renewal is only supported for data disks.
- Note: Auto-renewal cannot be performed for disks with an expired status.
- This asynchronous API allows you to check the disk expiration time using the Query Disk Details API.
Disable automatic renewal for disks
You can disable auto-renewal for disks with the following code:
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14
15 volumeId := "v-***"
16 args := &api.CancelAutoRenewCDSVolumeArgs{
17 // Disk ID
18 VolumeId: volumeId,
19 }
20 err := bccClient.CancelAutoRenewCDSVolume(args)
21 fmt.Println(err)
22}
- Note: Auto-renewal can only be disabled for data disks.
- This asynchronous API allows you to check the disk expiration time using the Query Disk Details API.
Disk expansion
You can expand the disk size with the following code:
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 // Disk ID
15 volumeId := "v-***"
16 // Request parameter for expanding the disk size
17 args := &api.ResizeCSDVolumeArgs{
18 // Expansion size, in GB
19 NewCdsSizeInGB: 60,
20 // Expansion type
21 NewVolumeType: api.StorageTypeEnhancedPl1,
22 }
23
24 // Request to expand the CDS disk, changing both disk type and size
25 err := bccClient.ResizeCDSVolume(volumeId, args)
26 fmt.Println(err)
27}Prompt:
- Disks can only be expanded; reducing their size is not supported.
- Only disks in the "Available" status can undergo expansion operation
- Disk expansion is executed by an asynchronous API; the disk expansion status can be queried through the [Query Disk Details](#Query disk details) API.
Roll back disk data
You can use a snapshot of the specified disk itself to roll back disk data, and you can perform disk data rollback with the following code:
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 volumeId := "v-zBms****" // Disk ID
15
16 args := &api.RollbackCSDVolumeArgs{
17 SnapshotId: "s-HkbJ****", // Snapshot ID
18 }
19 err := bccClient.RollbackCDSVolume(volumeId, args)
20 if err != nil {
21 fmt.Println(err)
22 }
23}Prompt:
- The disk must be in the "Available" status to initiate a rollback.
- The snapshot ID specified must originate from the same disk ID.
- When rolling back a system disk, ensure the instance status is either Running or Stopped before initiating this operation.
- When rolling back a system disk snapshot, all data generated on the system disk after the snapshot was created will be completely lost and cannot be recovered.
Renew a disk
Renewing a disk extends its expiration duration. You can renew a disk with the following code:
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 // Configuration parameters for the instance to be modified
15 args := &api.PurchaseReservedCSDVolumeArgs{
16 Billing: &api.Billing{
17 PaymentTiming: api.PaymentTimingPrePaid,
18 Reservation: &api.Reservation{
19 ReservationLength: 1, // Renewal period
20 ReservationTimeUnit: "month", // Unit of renewal period
21 },
22 },
23 }
24 volumeId := "v-dj5Q****" // Disk ID
25 err := bccClient.PurchaseReservedCDSVolume(volumeId, args)
26 if err != nil {
27 fmt.Println("purchase reserve CDS volume failed:", err)
28 } else {
29 fmt.Println("purchase reserve CDS volume success")
30 }
31}Release a CDS disk (new)
You can release a CDS disk along with its associated snapshots and specify whether to move them to the recycle bin with the following code
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 // Disk ID
15 volumeId := "v-***"
16 args := &api.DeleteCDSVolumeArgs{
17 // Whether to delete automatic snapshots associated with the disk
18 AutoSnapshot: "on",
19 // Whether to delete manual snapshots associated with the disk
20 ManualSnapshot: "on",
21 // Whether to move the disk to the recycle bin; if set to off, the disk will be released directly without entering the recycle bin
22 Recycle: "off",
23 }
24
25 // Request to release the disk
26 err := bccClient.DeleteCDSVolumeNew(volumeId, args)
27 fmt.Println(err)
28}Prompt:
- This API releases unattached CDS disks; system disks cannot be released.
- Compared to the old API, this version provides functionality for controlling whether snapshots associated with the disk should be deleted.
Query disk information available for purchase in a specific availability zone
You can query disk information available for purchase in a designated availability zone with the following code
GO
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 // Availability zone name; when the passed zoneName is an empty string or an invalid zone, purchasable disk information for all availability zones will be returned.
15 zoneName := "cn-bj-d"
16
17 // Request to query purchasable disk information in the availability zone
18 result, err := bccClient.GetAvailableDiskInfo(zoneName)
19 fmt.Println(err)
20 fmt.Println(result)
21}Bind a tag to a disk
You can bind a tag to a specified disk with the following code
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 // Disk ID
15 volumeId := "v-***"
16 tagArgs := &api.TagVolumeArgs{
17 // Whether to bind the tag to the associated resource
18 RelationTag: false,
19 ChangeTags: []api.Tag{
20 {
21 // Tag key
22 TagKey: "Key-***",
23 // Tag value
24 TagValue: "Value***",
25 },
26 {
27 // Tag key
28 TagKey: "Key-***",
29 // Tag value
30 TagValue: "Value***",
31 },
32 },
33 }
34 // Request to bind a tag to the disk
35 err := bccClient.TagVolume(volumeId, tagArgs)
36 fmt.Println(err)
37}Unbind a tag from a disk
You can bind a tag to a specified disk with the following code
Go
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 // Set your AK, SK and the endpoint to be accessed
9 ak := "ak"
10 sk := "sk"
11 endpoint := "bcc.bj.baidubce.com"
12 // Create a BCC client
13 bccClient, _ := bcc.NewClient(ak, sk, endpoint)
14 // Disk ID
15 volumeId := "v-***"
16 tagArgs := &api.TagVolumeArgs{
17 // Whether to unbind the tag from the associated resource
18 RelationTag: false,
19 ChangeTags: []api.Tag{
20 {
21 // Tag key
22 TagKey: "Key-***",
23 // Tag value
24 TagValue: "Value***",
25 },
26 {
27 // Tag key
28 TagKey: "Key-***",
29 // Tag value
30 TagValue: "Value***",
31 },
32 },
33 }
34 // Request to unbind a tag from the disk
35 err := bccClient.UntagVolume(volumeId, tagArgs)
36 fmt.Println(err)
37}