> ## Documentation Index > Fetch the complete documentation index at: https://gcore.com/docs/llms.txt > Use this file to discover all available pages before exploring further. # Create and configure a volume export const MethodSection = ({children}) => children ?? null; export const MethodSwitch = ({children}) => { const tabs = React.Children.toArray(children).map(c => { if (!c || !c.props) return null; if (c.props.id) return c; const inner = c.props.children; if (inner && inner.props && inner.props.id) return inner; return null; }).filter(Boolean); const firstId = tabs.length > 0 ? tabs[0].props.id : ""; const [active, setActive] = React.useState(firstId); React.useEffect(() => { try { const saved = localStorage.getItem("gcore_docs_method"); if (saved && tabs.find(t => t.props.id === saved)) { setActive(saved); } } catch (_) {} }, []); React.useEffect(() => { try { document.querySelectorAll("h2[id], h3[id]").forEach(heading => { const visible = heading.offsetParent !== null; document.querySelectorAll(`a[href="#${heading.id}"]`).forEach(link => { if (link.closest("h1,h2,h3,h4,h5,h6")) return; const li = link.closest("li"); if (li) li.style.display = visible ? "" : "none"; }); }); } catch (_) {} window.dispatchEvent(new Event("scroll")); }, [active]); const handleClick = id => { setActive(id); try { localStorage.setItem("gcore_docs_method", id); } catch (_) {} }; return
{tabs.map(tab => { const isActive = active === tab.props.id; return ; })}
{tabs.map(tab =>
{tab.props.children}
)}
; };

You can view, create, and manage volumes in the Gcore Customer Portal on the **Volumes** page. Here's how to navigate the page:

Volumes page with numbered UI elements

1. **Volumes**: View all volumes created in a project.

2. **Instance**: Check if a volume is attached to a Virtual Machine.

3. **IOPS limit/burst**: Check the maximum number of read and write operations a volume can handle in a second and when a burst traffic occurs.

4. **MBps limit/burst**: Check the bandwidth limit for a volume and a max bandwidth when a burst traffic occurs.

5. **Without attachments**: View all volumes that aren't attached to a Virtual Machine.

In the following sections, you'll find information on how to create and manage volumes. For a general overview of volumes and available volume types, check out our [dedicated guide](/cloud/virtual-instances/volumes/about-volumes).

## Create a volume

You can create volumes in several ways: [when creating a Virtual Machine](/cloud/virtual-instances/create-an-instance), from the **Volumes** page, or from a snapshot. The latter two approaches are described in the following sections.

**Info** You can only use a volume in the same region where a Virtual Machine is created. 1\. In the Gcore Customer Portal, navigate to **Cloud** > **Storage**. 2\. Click **Create volume**. Volumes page with numbered storage and create volume tabs 3\. A new **Add volume** page will open. Here you can customize volume settings. Dialog with options for configuring new volume 4\. Specify how many GB of disk space you need. If it exceeds your current limit, [send a request for quota increase](/cloud/getting-started/request-a-quota-increase#how-to-send-a-request). 5\. Select the [volume type](/cloud/virtual-instances/volumes/about-volumes#available-volume-types). Faster volume types are designed for latency-sensitive transactional operations and storing critical data. Slower volumes are more suitable for archived or non-critical data and for less frequent operations. 6\. (Optional) Attach the volume to a Virtual Machine. A volume can only be used in the same region where a VM is created. 7\. Create a name for the volume. You can use Latin letters, numbers, underscores, spaces, and dots. The name should be between 3 and 63 characters long. **Tip** When you add volumes via the Gcore Customer Portal or API, you don't have to keep volume names consistent in the operating system (like sda, sdb, or sdc). We recommend using Universally Unique Identifiers (UUID) instead of names for OS operations. 8\. (Optional) To add metadata to a volume, specify tags as key-value pairs. 9\. Click **Save**. Your volume will appear on the **Volumes** page. If you need to quickly duplicate or back up information on your Virtual Machine or provision new resources from pre-existing data, you can create a volume from a snapshot of an existing volume. To create a volume: 1\. In the Gcore Customer Portal, navigate to **Cloud** > **Snapshots**. 2\. Find the snapshot you want to create volume from and click on the three-dot icon to open snapshot settings. Snapshots tab with expanded settings menu 3\. Click **Create volume**. 4\. Select the Virtual Machine to which you want to attach a new volume. 5\. Click **Create**. Create volume dialog with options to select Virtual Machine and add volume name The volume will appear on the **Volumes** page. ## Attach volumes to an existing Virtual Machine

If a volume is attached to a Virtual Machine, you'll see the VM name on the **Volumes** page in the **Instance** column. Otherwise, you'll see the "Attach to instance" link. You can attach more than one volume to a Virtual Machine. However, volumes can only be used in the same region where the VM is created.

You can attach volumes to a Virtual Machine either from the **Volumes** page or from the VM settings.

1\. In the Gcore Customer Portal, navigate to **Cloud** > **Storage**. 2\. Find the volume that you want to attach and click **Attach to instance**. Volumes page with annotated attach to Virtual Machine link 3\. Select the Virtual Machine from the **Choose instance to attach to** dropdown. 4\. (Optional) Add an attachment tag. Attach volume dialog with options to select Virtual Machine and add a tag 5\. Click **Attach volume**. You've successfully attached a volume to the Virtual Machine. 1\. In the Gcore Customer Portal, navigate to **Cloud** > **Virtual instances**. 2\. Find the Virtual Machine you want to update and click its name to open it. Virtual Machines tab with two created instances 3\. Open the **Volumes** tab. 4\. Click **Add volume**. Volumes tab with Add volume button highlighted 5\. Click **Use existing** to attach an existing volume to an Virtual Machine. You can also create a new volume here. Click **Create new** and configure the settings as described under the [Create a volume](/cloud/virtual-instances/volumes/create-and-configure-volumes#create-a-volume) section. 6\. Select the volume that you want to attach to the Virtual Machine. 7\. (Optional). Add an attachment tag. Add volume menu with options to add Virtual Machine and tags 8\. Click **Add volume**. You've successfully attached a volume to the Virtual Machine. ## Manage volumes

The options for managing volumes differ depending on the volume you want to modify: boot or regular.

If you have a large number of volumes, you can also search for volumes by name or UUID values to find the one you need.

### Rename a volume

You can rename both boot and regular volumes:

1. In the Gcore Customer Portal, navigate to **Cloud** > **Storage**.

2. Click the three-dot icon next to the volume you want to rename.

Volumes tab with expanded settings menu

3. Click **Rename**.

4. Enter a new name.

5. Select **Save** to apply the changes.

Rename volume dialog

Your volume has been renamed.

### Detach a volume from a Virtual Machine

You can only detach regular volumes. The boot volume cannot be detached from an Virtual Machine as long as the VM exists. If you want to detach a boot volume, you need to delete the VM first.

To detach a volume:

1. In the Gcore Customer Portal, navigate to **Cloud** > **Storage**.

2. Click the three-dot icon next to the volume you want to detach.

Volumes tab with expanded settings menu

3. Choose the Virtual Machine from which you want to detach a volume.

4. Select **Confirm**.

Dialog asking to select a VM to detach the volume from

You've detached a volume from the Virtual Machine.

**Warning** Detaching a volume will not cancel your payment unless you delete the volume. You can also add a detached volume to any Virtual Machine at any time. ### Resize a volume

You can resize both boot and regular volumes:

1. In the Gcore Customer Portal, navigate to **Cloud** > **Storage**.

2. Click the three-dot icon next to the volume you want to resize.

Volumes tab with expanded settings menu

3. In the **Resize volume** dialog that opens, you can see your current volume size in GB. Enter the new volume size.

4. Click **Resize volume** to apply the changes.

Dialog asking for a new volume size

You've changed your volume size.

**Warning** If you have snapshots for this volume, after you increase the size, you won't be able to [revert from the last snapshot](/cloud/virtual-instances/volumes/create-and-configure-volumes#revert-volume-from-snapshot). You can only create a new volume from this volume's snapshot. ### Change volume type

This option is available for regular volumes of High IOPS and Standard types. You can't change the type of boot volume. However, you can create a new volume from a volume snapshot with the required type.

**Info** Before proceeding with the following instructions, make sure that a volume is detached from a Virtual Machine. Otherwise, the **Retype** button won't appear in your settings list.

To retype a volume:

1. In the Gcore Customer Portal, navigate to **Cloud** > **Storage**.

2. Click the three-dot icon next to the volume you want to retype.

Volumes tab with expanded settings menu

3. Click **Retype**.

4. Select the desired volume type and then click **Retype** to apply the updates.

Dialog asking to select a new volume type

You've successfully changed the volume type.

If you have multiple volumes attached to one Virtual Machine, you can use the `rsync` and `cp` utilities to migrate data between volumes within an operating system.

### Take a volume snapshot

You can create a volume snapshot and use it later for backup, further recovery, and deploying new Virtual Machines from snapshots of boot volumes.

To take a snapshot:

1. In the Gcore Customer Portal, navigate to **Cloud** > **Storage**.

2. Click the three-dot icon next to the needed volume.

Volumes tab with expanded settings menu

3. Click **Take snapshot**.

4. Enter snapshot name.

5. Click **Take snapshot**.

Dialog asking to add a snapshot name

The snapshot will appear on the **Snapshots** page, along with the other created snapshots.

### Revert volume to the latest snapshot

In case of an accidental data loss or data corruption, you might need to restore a volume to its previous state. If you [made a snapshot of that volume](/cloud/virtual-instances/volumes/create-and-configure-volumes#take-volume-snapshot), you can roll your volume back to the state when that snapshot was taken.

**Info** Before proceeding with the following instructions, make sure that the volume is [detached from an instance](/cloud/virtual-instances/volumes/create-and-configure-volumes#detach-a-volume-from-an-instance) and that you have the volume's snapshot. Otherwise, you'll get an error when trying to revert the volume to its previous state.

To revert a volume:

1. In the Gcore Customer Portal, navigate to **Cloud** > **Storage**.

2. Click the three-dot icon next to the volume you want to revert.

Volumes tab with expanded settings menu

3. Click **Revert to the latest snapshot**.

4. Click **Revert**.

Dialog asking to confirm volume reverting **Info** After resizing a volume, reversion is unavailable because the latest snapshot is taken for the old size. You can only create a new volume. For the new size, create a new snapshot. ### Create an image from a bootable volume

You can create an image from a boot volume and use that image to create a new Virtual Machine.

1. In the Gcore Customer Portal, navigate to **Cloud** > **Storage**.

2. Click the three-dot icon next to the volume from which you want to create an image.

Volumes tab with expanded settings menu

3. Select **Create image**.

4. Specify the image name.

5. Select architecture.

6. Click **Create image**.

Dialog to select image and and architecture

Within a few minutes, the image will be created and available on the **Images** page.

### Delete volume

You can delete a regular volume that's not attached to a Virtual Machine. Boot volumes can only be deleted together with the VM.

To delete a volume:

1. In the Gcore Customer Portal, navigate to **Cloud** > **Storage**.

2. Click the three-dot icon next to the volume you want to remove.

Volumes tab with expanded settings menu

3. Click **Delete**.

4. Confirm your action by typing "Delete" in the text field.

5. Click **Delete volume.**

Dialog asking to confirm volume deletion

The volume has been removed from the Gcore Customer Portal.

**Tip** You can also use the **Actions** dropdown to delete multiple volumes at once. For this option to be active, you must have at least one regular volume that is not attached to any Virtual Machine.

Volumes are persistent network-attached disks for Virtual Machines. Data survives VM reboots, and a volume can be detached from one VM and re-attached to another in the same region.

An [API token](/account-settings/api-tokens) is required, along with a [project ID](/api-reference/cloud/projects/list-projects) and [region ID](/api-reference/cloud/regions/list-regions).

Open a bash terminal and set these as environment variables before running the examples:

```bash theme={null} export GCORE_API_KEY="{YOUR_API_KEY}" export GCORE_CLOUD_PROJECT_ID="{YOUR_PROJECT_ID}" export GCORE_CLOUD_REGION_ID="{YOUR_REGION_ID}" export INSTANCE_ID="{YOUR_INSTANCE_ID}" ``` **INSTANCE\_ID** is the UUID of a virtual machine in the same region. It is required only for the attach and detach steps. To create a VM, see [Create a virtual machine](/cloud/virtual-instances/create-an-instance). ## Quickstart

The scripts below create a 10 GiB standard volume, attach it to the VM identified by `INSTANCE_ID`, resize it to 20 GiB, then detach and delete it.

```python theme={null} import os from gcore import Gcore # Step 1. Initialize the client. client = Gcore() # Step 2. Create a 10 GiB standard volume. volume = client.cloud.volumes.create_and_poll( name="data-volume", source="new-volume", size=10, type_name="standard", ) volume_id = volume.id print(f"Volume: {volume_id}") # Step 3. Attach the volume to an existing VM. instance_id = os.environ["INSTANCE_ID"] client.cloud.volumes.attach_to_instance_and_poll( volume_id, instance_id=instance_id, ) print(f"Attached to {instance_id}") # Step 4. Resize the volume to 20 GiB (works while attached). volume = client.cloud.volumes.resize_and_poll(volume_id, size=20) print(f"Resized to {volume.size} GiB") # Step 5. Detach the volume from the VM. client.cloud.volumes.detach_from_instance_and_poll( volume_id, instance_id=instance_id, ) print("Detached") # Step 6. Delete the volume. client.cloud.volumes.delete_and_poll(volume_id) print("Deleted") ``` ```go theme={null} package main import ( "context" "fmt" "log" gcore "github.com/G-Core/gcore-go" "github.com/G-Core/gcore-go/cloud" ) func main() { // Step 1. Initialize the client. client := gcore.NewClient() ctx := context.Background() // Step 2. Create a 10 GiB standard volume. volume, err := client.Cloud.Volumes.NewAndPoll(ctx, cloud.VolumeNewParams{ OfNewVolume: &cloud.VolumeNewParamsBodyNewVolume{ Name: "data-volume", Size: 10, TypeName: "standard", }, }) if err != nil { log.Fatalf("create volume: %v", err) } volumeID := volume.ID fmt.Printf("Volume: %s\n", volumeID) // Step 3. Attach the volume to an existing VM. instanceID := os.Getenv("INSTANCE_ID") if err = client.Cloud.Volumes.AttachToInstanceAndPoll(ctx, volumeID, cloud.VolumeAttachToInstanceParams{ InstanceID: instanceID, }); err != nil { log.Fatalf("attach volume: %v", err) } fmt.Printf("Attached to %s\n", instanceID) // Step 4. Resize the volume to 20 GiB (works while attached). resized, err := client.Cloud.Volumes.ResizeAndPoll(ctx, volumeID, cloud.VolumeResizeParams{ Size: 20, }) if err != nil { log.Fatalf("resize volume: %v", err) } fmt.Printf("Resized to %d GiB\n", resized.Size) // Step 5. Detach the volume from the VM. if err = client.Cloud.Volumes.DetachFromInstanceAndPoll(ctx, volumeID, cloud.VolumeDetachFromInstanceParams{ InstanceID: instanceID, }); err != nil { log.Fatalf("detach volume: %v", err) } fmt.Println("Detached") // Step 6. Delete the volume. if err = client.Cloud.Volumes.DeleteAndPoll(ctx, volumeID, cloud.VolumeDeleteParams{}); err != nil { log.Fatalf("delete volume: %v", err) } fmt.Println("Deleted") } ``` ## Step-by-step

Each step below explains what the call does, which parameters matter, and what the response looks like. Use this section to understand the flow or to debug a specific step.

### Step 1. Create a volume A [volume](/api-reference/cloud#tag/Volumes/operation/VolumeCreate.post) must be in the same region as the VM it will attach to. Use `source: "new-volume"` for blank storage, or `"snapshot"` to restore from an existing [snapshot](/cloud/virtual-instances/snapshots/take-a-snapshot-of-your-file-system). | Parameter | Required | Description | | ----------- | -------- | ----------------------------------------------------------------------------------------------- | | `name` | Yes | Display name. Latin letters, numbers, underscores, spaces, dots. 3-63 characters. | | `source` | Yes | `"new-volume"` for blank storage, `"snapshot"` to create from a snapshot. | | `size` | Yes | Volume size in GiB. Minimum 1. | | `type_name` | No | `"standard"` (default), `"ssd_hiiops"`, `"cold"`, or `"ultra"`. Available types vary by region. | ```python theme={null} import os from gcore import Gcore client = Gcore() volume = client.cloud.volumes.create_and_poll( name="data-volume", source="new-volume", size=10, type_name="standard", ) volume_id = volume.id ``` ```go theme={null} package main import ( "context" "fmt" "log" "os" gcore "github.com/G-Core/gcore-go" "github.com/G-Core/gcore-go/cloud" ) func main() { client := gcore.NewClient() ctx := context.Background() volume, err := client.Cloud.Volumes.NewAndPoll(ctx, cloud.VolumeNewParams{ OfNewVolume: &cloud.VolumeNewParamsBodyNewVolume{ Name: "data-volume", Size: 10, TypeName: "standard", }, }) if err != nil { log.Fatalf("create volume: %v", err) } volumeID := volume.ID fmt.Printf("Volume: %s\n", volumeID) } ``` ```bash theme={null} curl -X POST "https://api.gcore.com/cloud/v1/volumes/$GCORE_CLOUD_PROJECT_ID/$GCORE_CLOUD_REGION_ID" \ -H "Authorization: APIKey $GCORE_API_KEY" \ -H "Content-Type: application/json" \ -d '{ "name": "data-volume", "source": "new-volume", "size": 10, "type_name": "standard" }' ``` Response: ```json theme={null} {"tasks": ["278b11f6-e93b-48b6-b6fc-d045cb00156c"]} ``` Poll GET /cloud/v1/tasks/{task_id} every 5 seconds until `state` is `FINISHED`: ```json theme={null} { "state": "FINISHED", "created_resources": { "volumes": ["3298c2d7-aed9-4000-a784-9f066b0843b2"] } } ``` Save the volume ID and export it: ```bash theme={null} export VOLUME_ID="{VOLUME_ID}" ``` The SDK methods poll automatically and return the created volume object; read the ID from `volume.id`. ### Step 2. Attach to a Virtual Machine A volume can be attached to one VM at a time; both must be in the same region. Once attached, the OS sees the volume as a new block device, such as `/dev/sdb`. | Parameter | Required | Description | | ------------- | -------- | ---------------------- | | `instance_id` | Yes | UUID of the target VM. | ```python theme={null} # client initialized in Step 1 client.cloud.volumes.attach_to_instance_and_poll( volume_id, instance_id=os.environ["INSTANCE_ID"], ) ``` ```go theme={null} // client and ctx initialized in Step 1 err := client.Cloud.Volumes.AttachToInstanceAndPoll(ctx, volumeID, cloud.VolumeAttachToInstanceParams{ InstanceID: os.Getenv("INSTANCE_ID"), }) if err != nil { log.Fatalf("attach volume: %v", err) } ``` ```bash theme={null} curl -X POST \ "https://api.gcore.com/cloud/v2/volumes/$GCORE_CLOUD_PROJECT_ID/$GCORE_CLOUD_REGION_ID/$VOLUME_ID/attach" \ -H "Authorization: APIKey $GCORE_API_KEY" \ -H "Content-Type: application/json" \ -d '{"instance_id": "'"$INSTANCE_ID"'"}' ``` Response: ```json theme={null} {"tasks": ["c74f1abc-6d3e-4f2a-9b1e-7a83c2d15f4e"]} ``` Poll GET /cloud/v1/tasks/{task_id} every 5 seconds until `state` is `FINISHED`. The volume `status` changes to `"in-use"` once attached. ### Step 3. Resize a volume Volume size can only be increased, not decreased. Resizing works while the volume is attached to a running VM - no downtime required. | Parameter | Required | Description | | --------- | -------- | ------------------------------------------------------- | | `size` | Yes | New size in GiB. Must be greater than the current size. | ```python theme={null} # client initialized in Step 1 volume = client.cloud.volumes.resize_and_poll(volume_id, size=20) print(f"New size: {volume.size} GiB") ``` ```go theme={null} // client and ctx initialized in Step 1 resized, err := client.Cloud.Volumes.ResizeAndPoll(ctx, volumeID, cloud.VolumeResizeParams{ Size: 20, }) if err != nil { log.Fatalf("resize volume: %v", err) } fmt.Printf("New size: %d GiB\n", resized.Size) ``` ```bash theme={null} curl -X POST \ "https://api.gcore.com/cloud/v1/volumes/$GCORE_CLOUD_PROJECT_ID/$GCORE_CLOUD_REGION_ID/$VOLUME_ID/extend" \ -H "Authorization: APIKey $GCORE_API_KEY" \ -H "Content-Type: application/json" \ -d '{"size": 20}' ``` Response: ```json theme={null} {"tasks": ["e91f3abc-7d4e-5c2f-9a3b-8b85c4d37f6e"]} ``` Poll GET /cloud/v1/tasks/{task_id} every 5 seconds until `state` is `FINISHED`. After resizing, extend the filesystem inside the OS to claim the new space - for example, `resize2fs` for ext4 or `xfs_growfs` for XFS. If the volume has snapshots, resizing it prevents reverting to those snapshots. Only snapshots taken after the resize can be used for reversion. ### Step 4. Detach from a Virtual Machine Only non-boot volumes can be detached. Detaching preserves all data; the volume reverts to `"available"` status and can be re-attached to any VM in the same region. ```python theme={null} # client initialized in Step 1 client.cloud.volumes.detach_from_instance_and_poll( volume_id, instance_id=os.environ["INSTANCE_ID"], ) ``` ```go theme={null} // client and ctx initialized in Step 1 err := client.Cloud.Volumes.DetachFromInstanceAndPoll(ctx, volumeID, cloud.VolumeDetachFromInstanceParams{ InstanceID: os.Getenv("INSTANCE_ID"), }) if err != nil { log.Fatalf("detach volume: %v", err) } ``` ```bash theme={null} curl -X POST \ "https://api.gcore.com/cloud/v2/volumes/$GCORE_CLOUD_PROJECT_ID/$GCORE_CLOUD_REGION_ID/$VOLUME_ID/detach" \ -H "Authorization: APIKey $GCORE_API_KEY" \ -H "Content-Type: application/json" \ -d '{"instance_id": "'"$INSTANCE_ID"'"}' ``` Response: ```json theme={null} {"tasks": ["d85e2cde-4f3a-5b1c-8d2e-9c74f3a26e5d"]} ``` Poll GET /cloud/v1/tasks/{task_id} every 5 seconds until `state` is `FINISHED`. ## Clean up

Only detached volumes can be deleted. Boot volumes are deleted together with the VM when the instance delete call is issued.

```python theme={null} # client initialized in Step 1 client.cloud.volumes.delete_and_poll(volume_id) ``` ```go theme={null} // client and ctx initialized in Step 1 err := client.Cloud.Volumes.DeleteAndPoll(ctx, volumeID, cloud.VolumeDeleteParams{}) if err != nil { log.Fatalf("delete volume: %v", err) } ``` ```bash theme={null} curl -X DELETE \ "https://api.gcore.com/cloud/v1/volumes/$GCORE_CLOUD_PROJECT_ID/$GCORE_CLOUD_REGION_ID/$VOLUME_ID" \ -H "Authorization: APIKey $GCORE_API_KEY" ``` Response: ```json theme={null} {"tasks": ["f02g4bcd-8e5f-6d3a-0b4c-9c96d5e48g7f"]} ``` Poll GET /cloud/v1/tasks/{task_id} every 5 seconds until `state` is `FINISHED`. Billing for the volume stops immediately after deletion.

Provision block storage — boot volumes from an OS image, blank data disks, or restored snapshots. The full attribute reference is on the [`gcore_cloud_volume`](https://registry.terraform.io/providers/G-Core/gcore/latest/docs/resources/cloud_volume) resource page.

## Create a volume

The most common use case is `source = "image"` — this creates a boot volume from an OS image and is required when provisioning a Virtual Machine. Use `"new-volume"` for a blank data volume, or `"snapshot"` to restore from an existing snapshot.

For a boot volume, pass the image UUID via a variable. To find the UUID, open the Gcore Customer Portal, navigate to **Cloud** > **Images**, and copy the ID from the image details. IDs are region-specific — use the ID from the region where you are creating the volume.

```hcl theme={null} variable "image_id" { type = string description = "OS image UUID (region-specific). Find it in Cloud > Images." } resource "gcore_cloud_volume" "boot" { project_id = var.project_id region_id = var.region_id name = "boot-volume" source = "image" image_id = var.image_id size = 20 type_name = "standard" } output "boot_volume_id" { value = gcore_cloud_volume.boot.id } ```

For a blank data volume:

```hcl theme={null} resource "gcore_cloud_volume" "example" { project_id = var.project_id region_id = var.region_id name = "data-volume" source = "new-volume" size = 10 type_name = "standard" } output "volume_id" { value = gcore_cloud_volume.example.id } ``` ## Attach to a VM

Set `instance_id_to_attach_to` to attach the volume to a [Virtual Machine](/cloud/virtual-instances/create-an-instance). Both the volume and the VM must be in the same region.

```hcl theme={null} resource "gcore_cloud_volume" "example" { project_id = var.project_id region_id = var.region_id name = "data-volume" source = "new-volume" size = 10 type_name = "standard" instance_id_to_attach_to = var.instance_id } ```

To detach, remove the `instance_id_to_attach_to` attribute and run `terraform apply`.

## Resize a volume

Increase `size` and run `terraform apply` — volume size can only be increased.

```hcl theme={null} resource "gcore_cloud_volume" "example" { project_id = var.project_id region_id = var.region_id name = "data-volume" source = "new-volume" size = 20 # increased from 10 type_name = "standard" } ``` ```bash theme={null} terraform apply ``` ## Change volume type

Change `type_name` and run `terraform apply`.

Changing `type_name` recreates the volume — the existing volume is deleted and a new one is created with a new ID. Detach the volume from any Virtual Machine before making this change. ```hcl theme={null} resource "gcore_cloud_volume" "example" { project_id = var.project_id region_id = var.region_id name = "data-volume" source = "new-volume" size = 20 type_name = "ssd_hiiops" # changed from "standard" } ``` ```bash theme={null} terraform apply ``` ## Delete a volume

Remove the resource block — Terraform detects the missing declaration and deletes the volume on the next `terraform apply`.

```hcl theme={null} # Remove or comment out this block: # resource "gcore_cloud_volume" "example" { # name = "data-volume" # source = "new-volume" # size = 20 # type_name = "ssd_hiiops" # ... # } ``` ```bash theme={null} terraform apply ``` ## Import a volume

Use when a volume was created outside Terraform and needs to be managed as code.

```hcl theme={null} resource "gcore_cloud_volume" "example" { project_id = var.project_id region_id = var.region_id name = "data-volume" source = "new-volume" size = 20 type_name = "standard" } ``` ```bash theme={null} terraform import gcore_cloud_volume.example '//' ```