File Storage

Shared NFS file systems for instances and Kubernetes ReadWriteMany volumes.

Shared file systems for your instances and Kubernetes clusters. A file system is an NFS share in your network: any number of machines mount it at once and see the same files, and Kubernetes uses it for ReadWriteMany volumes. Find it under File Storage in the console.

Concepts

  • File system — one share (fs-…) with a size you choose (10 GiB to 10 TiB). It lives in one zone and serves the whole network over NFSv4.2. It is always encrypted.
  • Mount address — a private address in the network. Clients mount <address>:/.
  • Snapshot — a read-only copy of the whole file system at one moment, visible to every client under .snapshots/<name>.

What runs underneath, so you know what you are relying on: a machine of its own in your network serves the share from an encrypted volume (LUKS2; the key is released by Deutsche Cloud only to that machine). The volume holds the data; if the machine fails, Deutsche Cloud builds a new one on the same volume at the same address within minutes, and clients mounted with hard (the default below) continue when it answers again. Every write a client is told is done is on the volume (sync), never only in memory.

Create a file system

  1. Open File Storage and choose Create file system.
  2. Enter a name and a size, choose a zone, a machine, the network and the key that protects the volume's key, and choose Create file system.

It is ready in a few minutes; its page then shows the mount address.

API: POST /efs/api/file-systems with { "name": "shared-media", "sizeGib": 100, "availabilityZoneId": "de1a" }. CLI: dcloud efs file-systems create --name shared-media --size-gib 100.

Choosing the zone and machine:

  • Put the file system in the zone of the instances that use it most. Clients in the other zone work too, about 3 ms further away (see the numbers below).
  • performance-2 (2 vCPU, 4 GiB) suits a team share; performance-4 and performance-8 serve more clients at once and cache more of the data in memory.

Mount it on an instance

On the instance (Ubuntu: sudo apt install nfs-common):

sudo mkdir -p /mnt/efs
sudo mount -t nfs4 -o nfsvers=4.2,hard,noatime,nconnect=4 <mount address>:/ /mnt/efs

To mount at boot, add to /etc/fstab:

<mount address>:/ /mnt/efs nfs4 nfsvers=4.2,hard,noatime,nconnect=4,_netdev,nofail 0 0

The file system's page shows both lines with its address filled in. Only machines in the file system's network can mount it; it has no public address that answers.

Use it from Kubernetes (ReadWriteMany)

Install the upstream NFS CSI driver once per cluster, then a StorageClass that points at the file system. Each claim gets its own directory on the share:

helm repo add csi-driver-nfs https://raw.githubusercontent.com/kubernetes-csi/csi-driver-nfs/master/charts
helm install csi-driver-nfs csi-driver-nfs/csi-driver-nfs -n kube-system --version v4.11.0
apiVersion: storage.k8s.io/v1
kind: StorageClass
metadata:
  name: files-<file system id>
provisioner: nfs.csi.k8s.io
parameters:
  server: <mount address>
  share: /
reclaimPolicy: Delete
volumeBindingMode: Immediate
mountOptions: [nfsvers=4.2, hard, nconnect=4]
---
apiVersion: v1
kind: PersistentVolumeClaim
metadata:
  name: shared-data
spec:
  accessModes: [ReadWriteMany]
  storageClassName: files-<file system id>
  resources:
    requests:
      storage: 10Gi

The cluster's nodes must be in the file system's network. The requested size is not enforced per claim; the file system's size is the limit for all of them together.

Snapshots

A snapshot is taken in a moment and shares unchanged data with the live file system, so it costs space only as files change afterwards.

  1. On the file system's page, enter a name under Snapshots and choose Take snapshot.
  2. Within about 15 seconds every client sees it read-only at <mount point>/.snapshots/<name>.

To recover a file, copy it back: cp -a /mnt/efs/.snapshots/before-upgrade/reports /mnt/efs/.

API: POST /efs/api/file-systems/<id>/snapshots with { "name": "before-upgrade" }; DELETE /efs/api/file-systems/<id>/snapshots/<snapshot name>.

Snapshots live on the file system's own volume. A thin volume that runs completely full stops every write, so Deutsche Cloud protects it: no new snapshot is taken while the volume is 80 % full, and at 90 % the oldest snapshot is removed (the activity feed says which). Grow the file system or delete snapshots before that.

Snapshots are not backups: they are on the same volume. Backups to object storage are coming; until then, copy what you cannot lose to a bucket.

Grow a file system

On its page, enter the new size under Grow. Clients keep their mounts; the new space appears within a minute. A file system never shrinks.

API: PATCH /efs/api/file-systems/<id> with { "sizeGib": 200 }.

Delete a file system

Unmount it everywhere first. On its page, under Danger zone, choose Delete file system and type its name. Its machine, its volume with every file and snapshot, and its encryption key are deleted; nothing can be recovered.

API: DELETE /efs/api/file-systems/<id>.

Performance

Measured on 2026-11-12 with the default settings above (server performance-4, 100 GiB, clients performance-4):

Workload Same zone Other zone
Sequential write / read (4 × 1 GiB) 295 / 1556 MiB/s 294 / 959
Small files, one process (10,000 × 4 KiB) 52 files/s 26/s
Small files, 50 processes on two clients 450 files/s
fsync after every 4 KiB write, one process: p50 / p99 5.5 / 16 ms 8 / 15 ms
fsync writes, 50 processes 1,800 per second

Large files are limited by the volume (about 300 MiB/s). Every write is made durable before it is acknowledged, which costs about 5 ms per synchronous operation: one process creating many small files is slow, many processes together are much faster. For build caches and node_modules, use the instance's local disk.

IAM actions

Action Access
efs:DescribeFileSystems, efs:DescribeSnapshots read
efs:CreateFileSystem, efs:UpdateFileSystem write
efs:DeleteFileSystem write, destructive
efs:CreateSnapshot write
efs:DeleteSnapshot write, destructive

Resource: rn:ews:<region>:<org>:efs:file-system/<id>. A customer key (kmsKeyId) also needs kms:Encrypt on that key at creation.

Run outside Germany (Helsinki, fi1)

File systems are in Germany (de1) unless your organization decides otherwise. After an administrator turns on Allow EU locations outside Germany (Settings → Data location), zone fi1a (Helsinki, Finland) appears in the create form, marked "outside Germany"; through the API send "regionId": "fi1". Its machine, disk and snapshots are in Helsinki, and it serves a network in fi1. Without the setting the create answers 403.

What is not supported yet

  • Backups to object storage, and restoring a whole file system from a snapshot (copy files back).
  • A file system spanning zones; access points; per-directory quotas; NFSv3 and SMB.
  • Changing the machine of an existing file system (ask support).

Troubleshooting

Symptom Cause Fix
mount.nfs4: Connection timed out The client is not in the file system's network Launch the instance in that network
mount.nfs4: access denied by server The client's address is outside the network CIDR Mount over the private network, not a public address
Writes hang for a minute, then continue The machine was being replaced Nothing; hard mounts wait and continue
A snapshot disappeared The volume reached 90 % Grow the file system; the activity feed names the snapshot
Snapshot … could not be taken: … full The volume is over 80 % Grow the file system or delete snapshots
Did this page help you?