ZFS on Leo's Technical Log

Do You Really Need ZFS? A Practical Storage Guide for Home and Power Users

Mon, 01 Dec 2025 00:00:00 +0000

graph TD Start[Start Choosing a Storage Solution] --> Q1{Is your total data
under 4TB?} Q1 -->|Yes| Q2{Do multiple devices
need access?} Q1 -->|No| Q3{Is your budget
over ~$400?} Q2 -->|No| Q2a{Do you want
automatic backups?} Q2 -->|Yes| NAS1[2-bay entry NAS
Synology / QNAP
Built-in filesystem] Q2a -->|No| HDD[External drive
Cheapest & simplest
Manual backups] Q2a -->|Yes| NAS1 Q3 -->|No| HDD Q3 -->|Yes| Q4{Linux experience?} Q4 -->|No| NAS2[4-bay prebuilt NAS
Synology / QNAP
RAID5 / SHR] Q4 -->|Yes| Q5{Willing to spend time
learning & maintaining?} Q5 -->|No| NAS2 Q5 -->|Yes| Q6{More than 20TB
of data?} Q6 -->|No| Q7{Is maximum data
integrity critical?} Q6 -->|Yes| Q8{Budget over ~$1,400?} Q7 -->|No| Q7a{Less than
8GB RAM?} Q7 -->|Yes| Q7b{At least
16GB RAM?} Q7a -->|Yes| MDADM1[mdadm RAID1/10
Flexible & cheap] Q7a -->|No| Q7b Q7b -->|No| MDADM1 Q7b -->|Yes| ZFS1[ZFS on Linux / TrueNAS
Checksums & snapshots] Q8 -->|No| Q9{At least
32GB RAM?} Q8 -->|Yes| Q10{High random I/O
performance needed?} Q9 -->|No| MDADM2[mdadm RAID6/10
Large arrays] Q9 -->|Yes| ZFS2[ZFS RAIDZ2
Large storage pools] Q10 -->|Yes| HWRAID[Hardware RAID
BBU protected cache] Q10 -->|No| ZFS2

Introduction

ZFS has a reputation problem.

In many tech communities, it is often portrayed as the “correct” way to store data—anything else is seen as risky or amateur. At the same time, seasoned admins warn that ZFS is complex, memory-hungry, and easy to misuse.

So where does that leave ordinary users, home labbers, and small NAS builders?

This article takes a pragmatic, experience-driven look at whether you actually need ZFS, and how to choose a storage solution that fits your data size, budget, and willingness to maintain it.

1. External Drives vs NAS: Start Simple

When an External Drive Is Enough

An external hard drive is often dismissed as “too simple”, but for many people it is the right answer.

External drives work well if:

Your total data is under 4TB
You mainly back up one machine
You are on a tight budget
Backups are occasional, not continuous

For example, backing up a laptop with photos, documents, and personal files does not justify a NAS or RAID. A single 2–4TB external drive plus periodic backups is cheap, reliable, and easy to understand.

Complexity is a cost. Avoid it unless you truly need it.

When a NAS Makes Sense

A NAS becomes attractive once your needs grow beyond a single device.

A NAS is a good fit if:

Multiple devices need shared access
You want automatic, scheduled backups
Services must be online 24/7 (media server, downloads, remote access)
Your data volume is growing steadily

Even a basic 2-bay NAS provides redundancy, convenience, and automation that external drives cannot match.

2. Do NAS Users Need ZFS?

Prebuilt NAS: Usually No

If you are using a commercial NAS (Synology, QNAP, etc.), you almost certainly do not need ZFS.

Synology’s Btrfs implementation already provides snapshots and checksums
QNAP’s default filesystems are well-tested and supported
Vendor GUIs, updates, and documentation matter more than filesystem purity

Installing ZFS on a prebuilt NAS usually adds risk and complexity without clear benefits.

Self-Built NAS: Maybe

ZFS becomes interesting once you move into self-built systems.

ZFS is worth considering if:

Data integrity truly matters (irreplaceable photos, archives, work data)
You understand concepts like pools, vdevs, datasets, and scrubs
You have enough RAM (16GB minimum is realistic)
Your storage layout is planned long-term, not constantly changing

ZFS’s biggest strength is end-to-end checksumming and self-healing. Silent data corruption does happen—but whether it matters depends on your data.

A Reality Check for Most Users

For most home NAS users:

Vendor filesystems are good enough
ZFS features are underutilized
Proper backups matter more than filesystem choice

ZFS is powerful—but power only helps if you know how to use it.

3. When Does a Linux Storage Server Make Sense?

Self-built Linux storage is not about saving money—it is about control.

It makes sense if:

You enjoy learning and maintaining systems
You already use Linux comfortably
You need custom workloads (VMs, containers, heavy media processing)
Your data exceeds 20TB and keeps growing

If you value your time more than tinkering, a prebuilt NAS is still the better tool.

4. Choosing the Right Storage Technology

mdadm: Simple and Flexible

Linux software RAID (mdadm) is often underrated.

It works well when:

Budgets are limited
Arrays are small to medium (4–8 drives)
Flexibility matters more than elegance

Important caveats:

Rebuilds on large disks can take days
RAID5 is risky with modern drive sizes
A UPS is not optional

RAID1 and RAID10 remain the safest mdadm choices.

Hardware RAID: Still Relevant

Hardware RAID is unfashionable, but not obsolete.

It excels when:

Random I/O performance is critical
Arrays are large (8+ disks)
Downtime is unacceptable

If you go this route:

Use reputable vendors (LSI/Broadcom)
Ensure cache protection (BBU or supercapacitor)
Verify OS and drive compatibility

ZFS: Powerful, Opinionated, Demanding

ZFS shines when:

Data integrity is non-negotiable
Snapshots and clones are core workflows
Plenty of RAM is available
The system is designed upfront and left mostly unchanged

ZFS struggles when:

RAM is scarce (<8GB)
Storage layouts change frequently
Hardware or power is unreliable

ZFS rewards discipline—and punishes shortcuts.

5. High-Level Comparison

Solution	Performance	Flexibility	Reliability	Cost	Best For
mdadm	Medium	High	Medium	Low	Home servers, small arrays
Hardware RAID	High	Low	High	High	Performance-critical workloads
ZFS	Medium–High	Medium	High	Medium	Integrity-focused users

6. Practical Recommendations

A Sensible Upgrade Path

Beginner (<4TB)
External drive + manual backups

Intermediate (4–12TB)
2–4 bay NAS with vendor filesystem

Advanced (>12TB, technical users)
Self-built Linux server with ZFS or mdadm

Professional (>50TB, critical data)
Hardware RAID + enterprise drives + UPS + offsite backups

Principles That Actually Matter

Backups beat RAID: RAID does not protect against deletion, malware, or disasters
Follow 3-2-1 backups: 3 copies, 2 media types, 1 offsite
Choose systems you can maintain long-term
Simpler systems fail less often

Conclusion

Most people do not need ZFS.

They need reliable hardware, boring configurations, and tested backups.

ZFS is an excellent tool—when used for the right reasons, by users who understand its trade-offs. For everyone else, a simpler solution will be safer, cheaper, and easier to live with.

The best storage system is not the most advanced one—it is the one you can keep running correctly for years.

ZFS Core Concepts and a Quick Start Guide

Sun, 30 Nov 2025 00:00:00 +0000

Introduction

ZFS (Zettabyte File System) is a revolutionary storage system originally developed by Sun Microsystems and now maintained by the OpenZFS community. Unlike traditional file systems, ZFS is not just a filesystem—it is a complete storage management solution that integrates volume management and filesystem functionality into a single coherent system.

In this article, we’ll walk through the core concepts behind ZFS and get hands-on by creating our first ZFS storage pool on Linux.

What Is ZFS?

First released in 2005, ZFS was designed with an ambitious goal: to build a filesystem that would never silently corrupt data. To achieve this, ZFS introduced a number of groundbreaking features, including Copy-on-Write (CoW), end-to-end checksumming, snapshots, and clones.

Key Features of ZFS

Strong data integrity guarantees Every data block is protected by a checksum, allowing ZFS to detect and even repair silent data corruption.
Massive scalability Theoretical maximum storage capacity reaches 256 quadrillion zettabytes.
Simplified administration No need for manual partitioning or traditional formatting workflows.
Advanced built-in features Snapshots, clones, compression, deduplication, and more.
Flexible RAID support Native support for mirrors and RAID-Z configurations.

ZFS Design Philosophy

ZFS stands out largely because of a few fundamental design principles.

1. End-to-End Data Integrity

ZFS computes a checksum for every block of data and stores that checksum in the parent block rather than alongside the data itself. This design allows ZFS to detect corruption anywhere along the data path—whether caused by failing disks, faulty controllers, or firmware bugs.

If redundancy is available, ZFS can automatically repair corrupted data without user intervention.

2. Copy-on-Write (CoW)

ZFS never overwrites existing data. When data is modified, it is written to a new location, and only after the write succeeds are the metadata pointers updated.

This approach provides several important benefits:

Transactional semantics that keep the filesystem always consistent
Near-zero-cost snapshots
Elimination of the classic “write hole” problem

3. Storage Pooling

ZFS abstracts physical storage devices into a storage pool. All filesystems draw space from this shared pool, removing the rigid constraints of traditional partition-based layouts.

Filesystems can grow dynamically as needed—no resizing or re-partitioning required.

4. Simplified Management

ZFS embraces the idea that “everything belongs to the filesystem.” Tasks that traditionally require multiple tools (fdisk, mkfs, lvm, etc.) can all be performed using a unified ZFS command set, significantly reducing operational complexity.

Core Concepts

To work effectively with ZFS, it’s essential to understand a few core abstractions.

Storage Pools

A storage pool is the foundation of ZFS. It consists of one or more virtual devices (vdevs) and represents a shared pool of storage capacity and I/O resources.

Key characteristics:

Pools can be expanded by adding new devices
Performance depends on the layout and type of vdevs
All filesystems in the pool share the same space and I/O bandwidth

Virtual Devices (vdevs)

A vdev is the basic building block of a ZFS pool. Common vdev types include:

Single disk – simplest setup, no redundancy
Mirror – similar to RAID 1, full data replication
RAID-Z – ZFS-native RAID with parity
- RAID-Z1: single parity, tolerates 1 disk failure
- RAID-Z2: double parity, tolerates 2 disk failures
- RAID-Z3: triple parity, tolerates 3 disk failures

Important: Pool redundancy is determined by its vdevs. If any single vdev fails, the entire pool fails. For production systems, every vdev should provide adequate redundancy.

Datasets

In ZFS, dataset is a generic term that includes:

Filesystems – mountable directory trees
Volumes (zvols) – block devices, commonly used for VM disks
Snapshots – read-only point-in-time copies
Clones – writable copies created from snapshots

Datasets are hierarchical and can inherit properties from their parent datasets.

Properties

Many ZFS features are controlled via dataset properties, such as:

compression – lz4, gzip, zstd, etc.
quota – space usage limits
reservation – guaranteed space
atime – access time updates
copies – number of data replicas

Properties can be set at any level and inherited by child datasets.

Snapshots and Clones

Snapshots are one of ZFS’s most powerful features:

Created almost instantly
Consume no space initially
Only store changed data blocks
Can be rolled back or sent to another system

Clones are writable datasets created from snapshots:

Initially share all data blocks with the snapshot
Consume additional space only for modified data
Can diverge independently over time

Hands-On: Installing and Using ZFS on Linux

Let’s install ZFS and create our first storage pool. The examples below use Ubuntu/Debian.

Step 1: Install ZFS

sudo apt update
sudo apt install zfsutils-linux

zfs version
zpool version

For CentOS/RHEL:

sudo yum install epel-release
sudo yum install https://zfsonlinux.org/epel/zfs-release-2-2$(rpm --eval "%{dist}").noarch.rpm
sudo yum install kernel-devel zfs
sudo modprobe zfs

Step 2: Prepare Disks

Identify available disks:

lsblk

Warning: Creating a ZFS pool will erase all data on the selected disks.

Step 3: Create Your First Pool

Single-disk pool (not recommended for production):

sudo zpool create mypool /dev/sdb
sudo zpool status mypool

Step 4: Create a Mirrored Pool (Recommended)

sudo zpool create mypool mirror /dev/sdb /dev/sdc

Step 5: Create a RAID-Z Pool

sudo zpool create mypool raidz /dev/sdb /dev/sdc /dev/sdd

Step 6: Pool Management Commands

sudo zpool list
sudo zpool status -v mypool
sudo zpool iostat mypool 1
sudo zpool get all mypool

Step 7: Create Filesystems

sudo zfs create mypool/data
sudo zfs create mypool/data/projects
zfs list

Set custom mountpoints:

sudo zfs set mountpoint=/mnt/mydata mypool/data

Step 8: Common Property Settings

sudo zfs set compression=lz4 mypool/data
sudo zfs set atime=off mypool/data
sudo zfs set quota=10G mypool/data

Step 9: Working with Snapshots

sudo zfs snapshot mypool/data@backup-2024-11-28
zfs list -t snapshot
sudo zfs rollback mypool/data@backup-2024-11-28
sudo zfs destroy mypool/data@backup-2024-11-28

Step 10: Monitoring and Maintenance

sudo zpool scrub mypool
sudo zpool status mypool
sudo zpool history mypool

Practical Tips

Automated Snapshots

Use cron to create daily snapshots and clean up old ones.

ZFS Send/Receive for Backups

Efficient full and incremental replication between systems using zfs send and zfs receive.

Performance Tuning

Adjust ARC size and monitor cache efficiency via /proc/spl/kstat/zfs/arcstats.

Frequently Asked Questions

Can disks be removed from a ZFS pool? Not directly. Mirrors can be detached, but RAID-Z pools must be rebuilt.

How do I expand a pool? Add new vdevs using zpool add.

Is ZFS fast? Yes—especially with sufficient RAM. A common guideline is 1 GB RAM per TB of storage.

Does ZFS support encryption? Yes. Native encryption is supported at the dataset level.

Conclusion

ZFS is a powerful and reliable storage platform that seamlessly combines volume management and filesystem functionality. While it introduces several new concepts, its core ideas are straightforward: pooled storage, copy-on-write, and end-to-end data integrity.

By following this guide, you’ve learned how to create pools, filesystems, and snapshots, and how to manage a basic ZFS setup. From here, you can explore advanced features such as replication, encryption, and deduplication.

Best practices to remember:

Always use redundancy in production
Run regular scrubs
Make extensive use of snapshots
Provision enough memory for optimal performance

Happy hacking with ZFS 🚀