> ## Documentation Index
> Fetch the complete documentation index at: https://www.latitude.sh/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# File storage

> Shared NFS filesystems you mount on bare metal servers over the private storage network

File storage gives you persistent filesystems that several servers can mount at the same time. A filesystem lives independently of any server: you create it in a project, and servers in the same project and location mount it over NFS through a private storage network. Data stays on the filesystem when servers are reinstalled or removed.

## Prerequisites

* A verified team with a payment method or credit balance, and a project in a location where file storage is available. The create flow only lists those locations.
* A bare metal server in the same project and location as the filesystem, bonded onto a [public network](/docs/networking/public-networks). Bonding gives the server the redundant `bond0` link the storage network is delivered on. See [Network bonding](/docs/servers/network-bonding).
* One of the [supported operating systems](#supported-operating-systems) if you want the server to be configured automatically.

## Creating a filesystem

<Steps>
  <Step title="Open the create flow">
    In the dashboard, go to **Storage** > **File storage** and click **Create filesystem**.
  </Step>

  <Step title="Choose a location">
    Pick the location. The filesystem must be in the same location as the servers that will mount it.
  </Step>

  <Step title="Configure">
    Set the size, from 32 GB to 20 TB, and choose the NFS protocols to enable: **NFSv4**, **NFSv3**, or both. A name is suggested for you; you can change it using letters, numbers, hyphens and underscores. Names must be unique within the project.
  </Step>

  <Step title="Create">
    Click **Create filesystem**. The filesystem opens on its detail page. Once it is provisioned, the page shows its endpoint, mount path and the mount command.
  </Step>
</Steps>

## Connecting servers to the storage network

Servers reach the filesystem over a private storage network: a VLAN on top of the server's bond, with an address in your project's storage range. Creating the first filesystem or block volume in a location sets up this network for the project. A server joins it when it is deployed or reinstalled on a public network.

* **New servers** deployed on a public network in the filesystem's project and location join automatically.
* **Existing servers** deployed before the filesystem was created need a reinstall to join.

Deploying or reinstalling with a [supported operating system](#supported-operating-systems) configures the storage VLAN and routes and installs the NFS client, so the server is ready to mount.

<Warning>
  Reinstalling erases the server's disks. Back up anything you need first.
</Warning>

## Mounting the filesystem

The **Mount on a server** card on the filesystem page shows the command for your filesystem, with its endpoint and mount path filled in. Run it on each server that needs access:

```bash theme={null}
sudo mkdir -p /mnt/shared-data
sudo mount -t nfs -o vers=4 <endpoint>:<mount-path> /mnt/shared-data
```

To mount the filesystem on boot, add it to `/etc/fstab`. The `_netdev` option makes the system wait for the network before mounting:

```bash theme={null}
echo "<endpoint>:<mount-path> /mnt/shared-data nfs vers=4,_netdev 0 0" | sudo tee -a /etc/fstab
```

Use `vers=3` if you only enabled NFSv3. Replace `/mnt/shared-data` if you want the filesystem somewhere else.

<Info>
  Mounting requires an NFS client: `nfs-common` on Debian and Ubuntu, `nfs-utils` on RHEL-based systems. Supported operating systems install it on deploy and reinstall.
</Info>

Access is limited to servers on your project's storage network. There are no credentials to manage: any server on that network can mount the filesystem with read and write access, and `root` on the server keeps its permissions on the filesystem.

## Performance

Measured with `fio` and direct I/O from a server with a 2×10 Gbps bond to a filesystem in the same location:

| Workload | Default mount | With `nconnect=8` |
| - | - | - |
| Sequential read, 1 MiB | 1.0 GB/s | 2.3 GB/s |
| Sequential write, 1 MiB | 1.0 GB/s | 1.5 GB/s |
| Random read, 4 KiB | 40K IOPS | 63K IOPS |
| Random write, 4 KiB | 27K IOPS | 25K IOPS |

Results depend on the server's network capacity and the workload.

By default, the mount uses a single TCP connection, and the bond carries it on one link. Add `nconnect=8` to open eight connections and spread the traffic over both links:

```bash theme={null}
sudo mount -t nfs -o vers=4,nconnect=8 <endpoint>:<mount-path> /mnt/shared-data
```

To mount on boot with the same option, use it in the filesystem's `/etc/fstab` entry. If you already added an entry, edit it instead of appending a second line:

```text theme={null}
<endpoint>:<mount-path> /mnt/shared-data nfs vers=4,nconnect=8,_netdev 0 0
```

Use `vers=3` in both commands if you only enabled NFSv3.

Throughput grows with the number of parallel requests. A single 4 KiB request takes about 0.3 ms to read and 0.9 ms to write, and creating a file takes about 2 ms. Keep workloads that create many small files or call `fsync` often, such as builds and package installs, on local disks.

## Resizing

Filesystems can grow, but not shrink. Resizing is available through the API, up to 20 TB.

## Deleting

Before deleting a filesystem, unmount it on every server and remove its `/etc/fstab` entry so the next boot doesn't wait for a filesystem that is no longer there:

```bash theme={null}
sudo umount /mnt/shared-data
```

Then use **Delete filesystem** in the filesystem's actions menu and type its name to confirm. Deleting a filesystem permanently removes its data. Mounts left on servers stop working.

## Supported operating systems

Automatic storage network configuration on deploy and reinstall is available for these images:

* Debian 13
* Ubuntu 24.04 and 26.04
* AlmaLinux 9 and 10
* Rocky Linux 9 and 10

On other operating systems, contact support to configure the storage network.

## Current limits

* A filesystem can be up to 20 TB.
* Filesystems can grow but not shrink, and resizing isn't available in the dashboard yet.
* A filesystem can only be mounted by servers in the same project and location.
* Servers join the storage network on deploy or reinstall on a public network. Servers without a bond need a reinstall on a public network first.

These limits are being worked on and will be lifted in upcoming releases.

## Pricing

File storage is billed on provisioned capacity while the filesystem exists, whether or not it is mounted. The total for the size you choose is shown in the create flow before you confirm. Traffic between your servers and the filesystem is [free](/docs/storage/egress#file-storage).


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.