Block Volumes

A volume is a network block device. You attach it to an instance where it appears as an additional disk you can partition, format, and mount — ideal for data that must outlive the instance's root disk.

Create a volume

Under Storage → Volumes → Create, choose a name, a size (in GiB), a volume type, an availability zone, and optionally encryption at rest:

Type	For
ssd	General-purpose SSD (the default)
nvme	High-performance NVMe
hdd	Capacity / archival

fm storage volume create --name data-1 --size 100 --type ssd --zone falkenberg --encrypted

resource "frostmoln_volume" "data" {
  name        = "data-1"
  size_gb     = 100
  volume_type = "ssd"
  zone        = "falkenberg"
  encrypted   = true
}

Attach and mount

Attach a volume to an instance from the volume detail page, the instance's Storage tab, or the CLI. A volume attaches to one instance at a time (an instance can have many volumes):

fm storage volume attach data-1 web-1            # optional: --device /dev/vdb

With Terraform the attachment is its own resource, not an argument on the volume:

resource "frostmoln_volume_attachment" "data" {
  volume_id   = frostmoln_volume.data.id
  instance_id = frostmoln_instance.web.id
  device_path = "/dev/vdb" # optional
}

Then log in and mount it:

sudo mkfs.ext4 /dev/vdb
sudo mkdir -p /mnt/data && sudo mount /dev/vdb /mnt/data

Add it to /etc/fstab to mount on boot. Detach with fm storage volume detach data-1 (use --force only if necessary).

Resize

Volumes can grow (not shrink):

fm storage volume resize data-1 200

A volume can be grown while it is attached and mounted — the instance keeps running and there is no need to detach first.

Growing the volume does not grow what is on it. Inside the instance, extend the partition and then the filesystem:

sudo growpart /dev/vdb 1     # skip if the volume has no partition table
sudo resize2fs /dev/vdb1     # xfs_growfs /mount/point on XFS

Snapshots

Capture a point-in-time snapshot of a volume, and create new volumes from a snapshot:

fm storage snapshot create --name data-1-snap --volume data-1
fm storage snapshot list --volume data-1
# Restore = create a NEW volume from the snapshot (snapshot_id at create time)

There is no in-place "restore over" an existing volume — you create a fresh volume from the snapshot and attach it.

Kubernetes volumes

When a workload in a managed Kubernetes cluster requests storage with a PersistentVolumeClaim, the cluster creates a block volume for it. These volumes appear in your volume list like any other, labelled Kubernetes, so you can see all the storage you are billed for.

While the cluster exists, the cluster manages the volume. The volume list and detail page show which cluster it belongs to and, once known, the claim's namespace and name. Change the volume through its PersistentVolumeClaim in the cluster — for example, raise the claim's storage request to grow it. Changes made from the portal, the CLI or the API (rename, tags, resize, attach, detach, snapshot, clone, restore, delete) are refused with a 409 conflict, and the portal disables them.

Volumes kept when a cluster is deleted become ordinary volumes. They appear as ordinary volumes shortly after the cluster is deleted, labelled From deleted cluster with the cluster's name. You can then attach, snapshot, resize or delete them like any other volume. They are billed as block storage for as long as they exist, so delete the volumes you no longer need.

In the CLI, fm storage volume list shows where each volume comes from in its SOURCE column, and fm storage volume get adds a Kubernetes section:

SOURCE	Meaning
k8s:<cluster>/<namespace>/<claim>	Managed by a live cluster (just k8s:<cluster> while the claim is unknown)
k8s:deleted:<cluster>	Kept from a deleted cluster — now an ordinary volume
-	Any other volume

Notes and limits

• Single-attach — one instance at a time.
• Resize is grow-only; the availability zone is fixed at creation.
• Volumes are billed by provisioned size (per type) for as long as they exist, attached or not.

Related

• Compute / Instances · Object Storage