Luci4 Wiki Blog - linux:zfs

encryption

Anonymous (anonymous@undisclosed.example.com) — 2025-06-04T18:30:46+00:00

ZFS - Encryption

To automate the decryption of the ZFS pool on reboot, you can store the encryption key securely and configure ZFS to unlock the pool automatically. This can be achieved in several ways, but the most common method involves storing the key in a file (in a secure location) so it can be loaded automatically during boot.

Here’s how you can set up automatic decryption:

Automate ZFS Pool Decryption on Reboot

1. Create a Key File for the Pool

First, generate and store the encryption key in a file. If you used keyformat=passphrase, you'll need to create and store the passphrase in a secure location. If you're using a keyfile (keyformat=raw), follow these steps:

1- Create the keyfile (replace /etc/zfs/backup_pool.key with your desired file location):

sudo dd if=/dev/urandom of=/etc/zfs/backup_pool.key bs=32 count=1
sudo chmod 600 /etc/zfs/backup_pool.key

2- Set the key location to the keyfile:

sudo zfs set keylocation=file:/etc/zfs/backup_pool.key backup_pool

2. Ensure ZFS Can Load the Key Automatically on Boot

ZFS can load the key automatically at boot if it knows where to find the key. To set this up: Set up a systemd service to automatically load the ZFS key and mount the pool on boot.

1- Create a systemd service for key loading: Create a service to load the key at boot by creating a new file in the /etc/systemd/system/ directory, for example, zfs-load-backup-key.service.

sudo vim /etc/systemd/system/zfs-load-backup-key.service

2- Add the following content to the service file:

[Unit]
Description=Load ZFS encryption key for backup_pool
DefaultDependencies=no
After=zfs-import-cache.service

[Service]
Type=oneshot
ExecStart=/usr/sbin/zfs load-key backup_pool
RemainAfterExit=true

[Install]
WantedBy=multi-user.target

This service ensures that ZFS loads the key for the pool before mounting it.

3- Enable the systemd service to run at boot:

sudo systemctl enable zfs-load-backup-key.service

3. Enable the Necessary ZFS Systemd Services

Ensure that ZFS automatically imports and mounts the pool at boot. If you haven’t already done so, enable the following systemd services:

sudo systemctl enable zfs-import-cache
sudo systemctl enable zfs-mount
sudo systemctl enable zfs.target

4. Test the Setup

- Reboot the system to ensure that everything works automatically:

sudo reboot

-After rebooting, check that the pool is mounted:

zfs list

The pool should be automatically decrypted and mounted at /backup (or wherever you specified the mount point).

Security Considerations

- Storing the Key: The encryption key is stored in /etc/zfs/backup_pool.key by default in this example. Ensure the file is secure by using permissions (chmod 600), and consider placing it in a directory only accessible by root.

- Alternative Key Management: If you want additional security, you could use a hardware security module (HSM) or encrypted external key storage for storing keys. However, this is more complex and requires specialized hardware or configuration.

overview

Anonymous (anonymous@undisclosed.example.com) — 2025-06-08T14:34:22+00:00

ZFS on Linux

Overview

ZFS (Zettabyte File System) is both a filesystem and a volume manager. This means it handles disk management (like RAID, partitioning) and data layout (like EXT4 or Btrfs) in a unified way.

Core Concepts

Pool (zpool)	Group of physical disks, managed as a unit.
Vdev	Virtual device; pools are made of vdevs. Can be single, mirror, RAID-Z, etc.
Dataset	A ZFS-managed filesystem, like a subvolume or folder with its own settings.
Snapshot	A read-only, point-in-time copy of a dataset.
Clone	A writable copy of a snapshot.
Volume (zvol)	Block device managed by ZFS (e.g. for iSCSI or swap).

Installing ZFS

Ubuntu Server

sudo apt update
sudo apt install zfsutils-linux
sudo modprobe zfs

Arch Linux

Install required packages:

sudo pacman -S zfs-dkms zfs-utils

Load kernel module:

sudo modprobe zfs

If using a custom kernel, ensure you match with the right `dkms` version.

Creating a ZFS Pool

Basic Single Disk Pool

sudo zpool create mypool /dev/sdX

With Options:

sudo zpool create \
  -o ashift=12 \
  -o autotrim=on \
  -O compression=lz4 \
  -O normalization=formD \
  -O atime=off \
  mypool /dev/sdX

Option	Description
`-o ashift=12`	Aligns to 4K sectors. Recommended for modern HDDs/SSDs.
`-o autotrim=on`	Enables SSD TRIM support.
`-O compression=lz4`	Enables lightweight compression.
`-O normalization=formD`	Unicode normalization, important for international filenames.
`-O atime=off`	Disables access time updates for better performance.

RAID-Z Pool

sudo zpool create myraid raidz /dev/sd{b,c,d}

raidz = Single parity (RAID-5 equivalent)
raidz2 = Double parity (RAID-6)
raidz3 = Triple parity

Mirror Pool (RAID-1)

sudo zpool create mymirror mirror /dev/sdX /dev/sdY

📂 Creating Datasets

A dataset is a ZFS-managed subvolume with independent settings.

sudo zfs create mypool/mydataset

Common Dataset Options

sudo zfs set \
  compression=zstd \
  atime=off \
  quota=20G \
  recordsize=1M \
  mountpoint=/mnt/mydataset \
  mypool/mydataset

Property	Description
`compression=zstd`	Transparent compression using Zstandard.
`atime=off`	Disables last-accessed time.
`quota=20G`	Limits dataset to 20GB.
`recordsize=1M`	Optimize for large files (default is 128K, change based on workload).
`mountpoint=/mnt/mydataset`	Auto-mount location.

To open/edit files:

vim /mnt/mydataset/config.json

Snapshots and Clones

Create a Snapshot

sudo zfs snapshot mypool/mydataset@before-upgrade

List Snapshots

zfs list -t snapshot

Roll Back to Snapshot

sudo zfs rollback mypool/mydataset@before-upgrade

Note: This will destroy any changes made since that snapshot.

Clone a Snapshot (Writable)

sudo zfs clone mypool/mydataset@before-upgrade mypool/mydataset-clone

Creating Zvols (Block Devices)

Zvols are used for swap, VM disks, iSCSI, etc.

sudo zfs create -V 8G mypool/vm_swap
sudo mkswap /dev/zvol/mypool/vm_swap
sudo swapon /dev/zvol/mypool/vm_swap

🔧 Maintenance Tasks

Check Pool Health

sudo zpool status

Scrub Pool (verify checksums)

sudo zpool scrub mypool

Use `zpool status` afterward to see scrub results.

Export / Import

sudo zpool export mypool
sudo zpool import mypool

Destroy Datasets or Pools

sudo zfs destroy mypool/mydataset
sudo zpool destroy mypool

📊 EXT4 vs Btrfs vs ZFS

Feature	EXT4	Btrfs	ZFS
Snapshots	❌ No	✅ Native	✅ Native
Checksumming	Metadata only	✅ Data + Metadata	✅ Data + Metadata
Compression	❌ No	✅ (zlib, zstd, lzo)	✅ (lz4, zstd, gzip)
RAID Support	❌ External only	✅ (limited, flaky)	✅ RAID-Z, mirror, etc.
Deduplication	❌ No	⚠️ Experimental	✅ (RAM intensive)
Scrubbing	❌ No	✅	✅
Max Volume Size	1 EiB	16 EiB	256 ZiB
Encryption	❌ LUKS only	✅ Native	✅ Native
Performance	✅ High	⚠️ Varies	⚠️ Needs RAM, very fast

Sample Workflow Script

# Create pool with good defaults
sudo zpool create -o ashift=12 \
  -O compression=lz4 \
  -O atime=off \
  -O normalization=formD \
  mypool /dev/sdX

# Create dataset for backups
sudo zfs create mypool/backups
sudo zfs set quota=100G mypool/backups
sudo zfs set mountpoint=/mnt/backups mypool/backups

# Take daily snapshot (use cron)
sudo zfs snapshot mypool/backups@$(date +%Y-%m-%d)

# Optional scrub every Sunday (via cron)
sudo zpool scrub mypool

snippet.cpp

by:
▖     ▘▖▖
▌ ▌▌▛▘▌▙▌
▙▖▙▌▙▖▌ ▌
 
edited: June 2025

raid

Anonymous (anonymous@undisclosed.example.com) — 2025-06-08T01:06:24+00:00

ZFS offers powerful software RAID features built into its storage pool (zpool) layer. Unlike traditional software RAID tools like mdadm, ZFS RAID is tightly integrated with the filesystem, offering data integrity, easier management, and better recovery options.

Here's a breakdown of the software RAID options ZFS supports:

ZFS RAID Options

1. Mirror (RAID-1)

Description: Data is duplicated across two or more disks. Best for redundancy and read performance.

sudo zpool create mymirror mirror /dev/sdX /dev/sdY

You can use more than two disks (mirror /dev/sdX /dev/sdY /dev/sdZ) – ZFS will mirror across all.
If one disk fails, data is safe.
Read speed is improved (ZFS reads in parallel from mirrors).

2. RAID-Z (Single Parity, RAID-5 Equivalent)

Description: Uses parity to recover from a single disk failure.

sudo zpool create myraid raidz /dev/sd{b,c,d}

Minimum 3 disks required.
If one disk fails, ZFS reconstructs data using parity.
Write performance is better than mdadm RAID-5 but not as good as mirrors.

3. RAID-Z2 (Double Parity, RAID-6 Equivalent)

Description: Tolerates two disk failures.

sudo zpool create myraid2 raidz2 /dev/sd{b,c,d,e,f}

Minimum 4 disks.
Parity is spread across the disks.
More redundancy but lower usable storage.

4. RAID-Z3 (Triple Parity)

Description: Tolerates three disk failures.

sudo zpool create myraid3 raidz3 /dev/sd{b,c,d,e,f,g}

Minimum 5 disks.
Extremely fault-tolerant. Useful for archival, enterprise systems, or critical NAS.

Comparison of RAID Levels in ZFS

Mirror	2	1 (or N-1)	50% (if 2 disks)	Fast reads, writes may scale linearly
RAID-Z	3	1	N - 1	Efficient, safe for moderate setups
RAID-Z2	4	2	N - 2	High safety, good for medium/large arrays
RAID-Z3	5	3	N - 3	Max safety, best for critical data

Important RAID Concepts in ZFS

`ashift`

-o ashift=12

Sets the sector size to 2^12 (4096 bytes). Best for modern disks (especially SSDs). You cannot change this later.

Add Hot Spares

ZFS can keep extra disks idle, ready to take over when another fails:

sudo zpool add mypool spare /dev/sdX

ZFS will automatically replace a failed disk with a spare.

🚨 Avoid This: Striped Pools Across Multiple Disks

sudo zpool create badpool /dev/sdX /dev/sdY

This creates a striped pool with no redundancy.
If any one disk fails, the entire pool is lost.

Never use multiple disks in a single pool without mirroring or RAID-Z.

—

🛡️ Replacing a Failed Disk in ZFS RAID

Check pool:

sudo zpool status

Offline the failed disk:

sudo zpool offline mypool /dev/sdX

Replace it:

sudo zpool replace mypool /dev/sdX /dev/sdY

Monitor resilvering:

sudo zpool status

ZFS will rebuild the data on the new disk automatically.

Test a RAID-Z Pool

sudo zpool create -o ashift=12 \
  -O compression=lz4 \
  -O atime=off \
  testpool raidz /dev/sd{b,c,d}

sudo zfs create testpool/files
echo "Hello ZFS RAID-Z" | sudo tee /testpool/files/test.txt
sudo zfs snapshot testpool/files@first

Then simulate a failure by detaching or offlining a disk and using zpool status, replace, and resilver.

snippet.cpp

by:
▖     ▘▖▖
▌ ▌▌▛▘▌▙▌
▙▖▙▌▙▖▌ ▌
 
edited: June 2025

usb_backup

Anonymous (anonymous@undisclosed.example.com) — 2025-06-08T01:06:47+00:00

Complete Guide: Setting Up ZFS on a USB Drive for Backups

Walkthrough formatting, creating, and optimizing a ZFS pool on a 10TB USB drive, specifically for daily backups, with a focus on performance, reliability, and efficiency.

1. Pre-Installation Checks

Before proceeding, ensure:
- USB drive is connected and detected
- ZFS utilities are istalled

1.1 Install ZFS (if not already installed)

sudo apt update
sudo apt install -y zfsutils-linux

1.2 Identify the USB Drive

Find the correct device name:

lsblk -o NAME,SIZE,MODEL,MOUNTPOINT

The 10TB drive should look like /dev/sdX (where X is the correct letter).

2. Prepare the Drive (Partitioning & Formatting)

ZFS can use raw disks, but it's recommended to partition it for flexibility.

2.1 Wipe Existing Data (Optional)

To ensure a clean setup, erase any existing partitions:

sudo wipefs -a /dev/sdX
sudo dd if=/dev/zero of=/dev/sdX bs=1M count=100 status=progress

2.2 Create a Single GPT Partition

Use parted to create a GPT partition spanning the whole drive:

sudo parted /dev/sdX --script mklabel gpt
sudo parted /dev/sdX --script mkpart primary 0% 100%

Get the partition name (likely /dev/sdX1):

lsblk -o NAME,SIZE,MODEL,MOUNTPOINT

3. Create & Optimize the ZFS Pool

Now, we create a ZFS pool with the best options for a single USB backup drive.

3.1 Create the ZFS Pool with Optimized Settings

sudo zpool create -o ashift=12 \
      -o autotrim=on \
      -O compression=lz4 \
      -O atime=off \
      -O sync=disabled \
      -O recordsize=1M \
      -O xattr=sa \
      -O acltype=posix \
      -m /backup \
      backup_pool /dev/sdX1

Explanation of Options:

Option	Purpose
`-o ashift=12`	Optimizes for 4K sector drives (prevents misaligned writes).
`-o autotrim=on`	Enables automatic TRIM for SSDs (harmless for HDDs).
`-O compression=lz4`	Fast compression to reduce space usage and speed up writes.
`-O atime=off`	Disables access time updates (reduces unnecessary writes).
`-O sync=disabled`	Improves write performance for backups only (⚠️ use with care).
`-O recordsize=1M`	Optimizes for large files (suitable for backups).
`-O xattr=sa`	Stores extended attributes more efficiently.
`-O acltype=posix`	Enables POSIX ACLs for better file permissions.
`-m /backup`	Mounts the pool at `/backup`.

4. Verify & Check Pool Status

Check that ZFS is properly set up:

zpool status
zfs list

Expected output:

NAME         STATE     READ WRITE CKSUM
backup_pool  ONLINE       0     0     0

5. Automate Snapshots & Incremental Backups

5.1 Daily Snapshots

ZFS snapshots are still useful for local protection before syncing to the server. In this case backups use rsync instead of zfs send, because the drives on the server are BTRFS and EXT4.

Automatically create daily snapshots:

sudo crontab -e

Add the following line:

0 2 * * * /usr/sbin/zfs snapshot backup_pool@pre-rsync-$(date +\%F)

This ensures a ZFS snapshot is taken before rsync runs, preventing backup corruption if files change during the process.

5.2 Incremental Backup Script

Since the server uses Btrfs and Ext4, the ZFS incremental backup method (zfs send/recv) won't work, because it requires both the source and destination to be ZFS.

Alternative Incremental Backup Method (Compatible with Any Filesystem)

Use rsync to efficiently copy only changed files to your server.

1. Create an Incremental Backup Script

Save this as /usr/local/bin/backup-to-server.sh:

snippet.sh

#!/bin/bash
 
SRC="/data_to_backup/"  # Replace with the source directory you want to back up
DEST="/backup/"         # Replace with your ZFS pool mount point on the USB drive
 
# Use rsync with hard links to save space and make incremental backups
rsync -aAXHv --delete --progress \
      --link-dest="$DEST/latest" \
      "$SRC" "$DEST/backup-$(date +%F)"
 
# Update the "latest" symlink to point to the newest backup
rm -rf "$DEST/latest"
ln -s "$DEST/backup-$(date +%F)" "$DEST/latest"
 
# Delete backups older than 7 days
find "$DEST" -maxdepth 1 -type d -name "backup-*" -mtime +7 -exec rm -rf {} \;

Make it executable:

sudo chmod +x /usr/local/bin/backup-to-server.sh

2. Automate Daily Incremental Backups

Edit cron:

sudo crontab -e

Add:

0 2 * * * /usr/local/bin/backup-to-server.sh

This runs at 2 AM daily, copying only changed files to your server.

How This Works

- Uses rsync to copy files while preserving permissions, timestamps, and symlinks. - Deletes removed files (--delete) to match the source. - Uses --link-dest to create hard-linked snapshots, saving disk space. - Maintains a “latest” symlink, making it easy to restore files.

6. Auto-Cleanup Old Snapshots

Make sure only ZFS snapshots older than 7 days are deleted, while leaving rsync backups untouched.

sudo crontab -e

Cron job for cleanup:

0 3 * * * /usr/sbin/zfs list -t snapshot -o name | grep backup_pool@pre-rsync | head -n -7 | xargs -n1 zfs destroy

This keeps the last 7 days of ZFS snapshots while avoiding unnecessary storage bloat.

7. Prevent USB Sleep & Power Issues

Since rsync runs incremental backups instead of a full zfs send, the USB drive may be idle for longer periods. If the drive enters sleep mode too aggressively, consider using udev rules for persistent power settings.

7.1 Disable Drive Sleep

Some USB drives aggressively spin down. Prevent this:

snippet.sh

sudo hdparm -B 254 /dev/sdX
sudo hdparm -S 0 /dev/sdX

7.2 Reduce Write Caching Risks

Prevent data loss if the USB drive is unplugged suddenly:

echo 1 | sudo tee /sys/block/sdX/device/scsi_disk/*/cache_type

This sets cache_type = 1, which means “Write Through” mode.

Every write goes directly to the disk instead of being cached.
Safer for USB drives: If unplugged suddenly, less risk of data loss.
Downside: Slightly slower performance.

To Make This Persistent Across Reboots

Since /sys/block/sdX settings reset after reboot, add this to a startup script: Edit /etc/rc.local (or create it if missing):

#!/bin/bash
echo 1 | sudo tee /sys/block/sdX/device/scsi_disk/*/cache_type
exit 0

Make it executable:

sudo chmod +x /etc/rc.local

This ensures the setting is applied every time the system starts.

7.2b (alternative) Udev Rule for Write Caching

Instead of using /sys/block/sdX, use a udev rule:

echo 'ACTION=="add", SUBSYSTEM=="block", KERNEL=="sd?", ATTR{queue/write_cache}="0"' | sudo tee /etc/udev/rules.d/99-usb-write-cache.rules

This method disables write caching at the block device level. Difference from Option 1:

It applies to all USB drives (not just one specific drive).
Works persistently without needing /etc/rc.local.
Can be less effective depending on the drive firmware.

8. Mount the ZFS Pool at Boot

ZFS should automatically mount the pool, but ensure it imports on reboot:

sudo systemctl enable zfs-import-cache
sudo systemctl enable zfs-mount
sudo systemctl enable zfs.target

These services are responsible for:

zfs-import-cache: Imports the ZFS pools at boot.
zfs-mount: Mounts the datasets.
zfs.target: Ensures ZFS is correctly integrated into the boot process.

These steps should guarantee that the drive is mounted at /backup on reboot.

If the pool does not mount automatically:

sudo zpool import backup_pool

9. Verify the Setup

Check status:

zpool status backup_pool
zfs list

Test snapshot & backup:

zfs snapshot backup_pool@test
zfs list -t snapshot
zfs destroy backup_pool@test

Conclusion

ZFS fully optimized for 10TB USB backup drive
- Performance: Optimized writes (sync=disabled), large record size (1M), and compression (lz4).
- Reliability: Checksums detect corruption, snapshots provide rollback, and backups are incremental.
- Efficiency: Automated snapshots, incremental transfers, and old snapshot cleanup.
—

ZFS with one pool and one filesystem

Using ZFS on a server with only one pool and one filesystem (without redundancy) can still offer several advantages, even though you're not leveraging its redundancy features like mirroring (RAID1) or parity (RAIDZ). Here are some benefits:

1. Data Integrity with Checksumming

ZFS detects silent data corruption (bit rot) using checksums on all data and metadata.
Even without redundancy, ZFS will alert you if corruption occurs, which most traditional filesystems (like ext4 or XFS) do not do.

2. Snapshots & Rollbacks

You can take snapshots of your filesystem, allowing you to revert to a previous state if needed.
Useful for backups, testing, or recovering from accidental deletions.

3. Compression (Transparent)

ZFS supports transparent compression (e.g., LZ4, ZSTD), reducing disk space usage and potentially improving performance.

4. Automatic Space Management with Copy-on-Write (CoW)

ZFS avoids overwriting existing data until the new data is fully written.
This minimizes data corruption risks from unexpected crashes.

5. Efficient Storage Management with Datasets

Even if you have only one filesystem (zfs create tank), you can create multiple datasets (tank/home, tank/var/log, etc.).
Each dataset can have independent quotas, snapshots, and settings.

6. Native Encryption

If you need encryption, ZFS provides built-in encryption that is per-dataset with no performance penalty compared to LUKS.

7. Flexible Volume Management

You can later add redundancy by attaching additional drives (e.g., convert to a mirror).
No need for LVM, as ZFS natively handles volume management.

8. Adaptive Read Caching (ARC)

ZFS intelligently caches data in RAM, improving read performance.
If you later add an SSD, you can use it as an L2ARC (secondary cache).

9. No Need for fsck

Unlike traditional filesystems, ZFS does not require periodic fsck checks after crashes.

Downsides of Using ZFS Without Redundancy

- Single Point of Failure: If the disk dies, you lose everything. - Higher RAM Usage: ZFS works best with at least 4GB+ of RAM. - Slightly Higher Write Overhead: Due to CoW, small writes might be slower compared to ext4 on HDDs.

When the ZFS pool is on a single USB drive used for daily backups, the Single Point of Failure (SPOF) risk is reduced because:
1. Primary Data is on the Server

Even if the USB drive fails, your original data is still available on the server.

2. ZFS Features Benefit Backups

Snapshots: You can use ZFS snapshots to create point-in-time backups.
- Incremental Sends: ZFS allows efficient incremental backups using zfs send | zfs recv, reducing backup time and bandwidth.
- Compression: You can save space with lz4 or zstd compression.
- Data Integrity: If bit rot or corruption occurs, ZFS will detect it.

3. Potential Optimization for USB Backup Use Case

ashift=12: If using an advanced format drive (4K sectors), set ashift=12 at pool creation.
- zfs set atime=off: Disables access time updates, improving performance.
- zfs set compression=lz4: Saves space without slowing down writes.
- zfs set sync=disabled (optional): Improves write performance for backups (use only if acceptable).

### Final Thoughts
Using ZFS on a single USB drive for backups makes sense if you want:
- Data integrity (checksums)
- Snapshots and efficient incremental backups
- Compression to save space
However, USB drives can fail, so you may want an additional backup strategy, such as:
- A second backup drive rotated periodically
- Offsite/cloud backup for disaster recovery

Other notes

Enable Compression

Activate LZ4 compression to improve read/write performance:([Rdiffweb][1])

zfs set compression=lz4 rpool/backups

To prevent rdiff-backup from compressing data, use:([Rdiffweb][1])

rdiff-backup --no-compression ...

Optimize Cache Usage

Configure ZFS to store only metadata in its cache:([Rdiffweb][1])

sudo zfs set primarycache=metadata rpool/backups
sudo zfs set secondarycache=metadata rpool/backups

Consider Deduplication

Enable deduplication to save space when identical data blocks are present:([Rdiffweb][1])

sudo zfs set dedup=on rpool/backups

Note: Deduplication increases RAM usage; assess its impact based on your data.([Rdiffweb][1])

5. Support Non-UTF-8 Characters

Allow non-UTF-8 characters for compatibility with various filesystems:([Rdiffweb][1])

sudo zfs create -o utf8only=off rpool/backups

This setting cannot be changed after dataset creation.([Rdiffweb][1])

Implementing these configurations can optimize ZFS for rdiff-backup, enhancing backup performance and compatibility.

snippet.cpp

by:
▖     ▘▖▖
▌ ▌▌▛▘▌▙▌
▙▖▙▌▙▖▌ ▌
 
edited: June 2025

Luci4 Wiki Blog - linux:zfs

encryption

ZFS - Encryption

Automate ZFS Pool Decryption on Reboot

1. Create a Key File for the Pool

2. Ensure ZFS Can Load the Key Automatically on Boot

3. Enable the Necessary ZFS Systemd Services

4. Test the Setup

Security Considerations

overview

ZFS on Linux

Overview

Core Concepts

Installing ZFS

Ubuntu Server

Arch Linux

Creating a ZFS Pool

Basic Single Disk Pool

With Options:

RAID-Z Pool

Mirror Pool (RAID-1)

📂 Creating Datasets

Common Dataset Options

Snapshots and Clones

Create a Snapshot

List Snapshots

Roll Back to Snapshot

Clone a Snapshot (Writable)

Creating Zvols (Block Devices)

🔧 Maintenance Tasks

Check Pool Health

Scrub Pool (verify checksums)

Export / Import

Destroy Datasets or Pools

📊 EXT4 vs Btrfs vs ZFS

Sample Workflow Script

raid

ZFS RAID Options

1. Mirror (RAID-1)

2. RAID-Z (Single Parity, RAID-5 Equivalent)

3. RAID-Z2 (Double Parity, RAID-6 Equivalent)

4. RAID-Z3 (Triple Parity)

Comparison of RAID Levels in ZFS

Important RAID Concepts in ZFS

`ashift`

Add Hot Spares

🚨 Avoid This: Striped Pools Across Multiple Disks

🛡️ Replacing a Failed Disk in ZFS RAID

Test a RAID-Z Pool

usb_backup

Complete Guide: Setting Up ZFS on a USB Drive for Backups

1. Pre-Installation Checks

1.1 Install ZFS (if not already installed)

1.2 Identify the USB Drive

2. Prepare the Drive (Partitioning & Formatting)

2.1 Wipe Existing Data (Optional)

2.2 Create a Single GPT Partition

3. Create & Optimize the ZFS Pool

3.1 Create the ZFS Pool with Optimized Settings

Explanation of Options:

4. Verify & Check Pool Status

5. Automate Snapshots & Incremental Backups

5.1 Daily Snapshots

**5.2 Incremental Backup Script**

**Alternative Incremental Backup Method (Compatible with Any Filesystem)**

**1. Create an Incremental Backup Script**

**2. Automate Daily Incremental Backups**

**How This Works**

**6. Auto-Cleanup Old Snapshots**

**7. Prevent USB Sleep & Power Issues**

**7.1 Disable Drive Sleep**

**7.2 Reduce Write Caching Risks**

7.2b (alternative) Udev Rule for Write Caching

**8. Mount the ZFS Pool at Boot**

**9. Verify the Setup**

**Conclusion**

ZFS with one pool and one filesystem

1. **Data Integrity with Checksumming**

2. **Snapshots & Rollbacks**

3. **Compression (Transparent)**

5.2 Incremental Backup Script

Alternative Incremental Backup Method (Compatible with Any Filesystem)

1. Create an Incremental Backup Script

2. Automate Daily Incremental Backups

How This Works

6. Auto-Cleanup Old Snapshots

7. Prevent USB Sleep & Power Issues

7.1 Disable Drive Sleep

7.2 Reduce Write Caching Risks

8. Mount the ZFS Pool at Boot

9. Verify the Setup

Conclusion

1. Data Integrity with Checksumming

2. Snapshots & Rollbacks

3. Compression (Transparent)

4. Automatic Space Management with Copy-on-Write (CoW)

5. Efficient Storage Management with Datasets

6. Native Encryption

7. Flexible Volume Management

8. Adaptive Read Caching (ARC)

9. No Need for fsck

Downsides of Using ZFS Without Redundancy