dumpstore: A Lightweight ZFS NAS UI for Developers Who Hate Bloat

TL;DR:

I built dumpstore, a minimalist ZFS NAS management UI for Linux and FreeBSD. It’s a single Go binary with no database, no Node.js, and no containers—just a clean, auditable interface for managing your ZFS storage. If you’ve ever groaned at the complexity of TrueNAS or OpenMediaVault, this might be for you.

Why Another NAS UI?

A few years ago, I set up a Kobol Helios64 as my home NAS. I wanted a simple, lightweight UI to monitor and manage my ZFS pools—something that wouldn’t pull in a database, a container runtime, or a Node.js server.
I tried the usual suspects:

TrueNAS: Too heavy, and overkill for my needs also not running on arm64.
OpenMediaVault: Not ZFS-first, and the PHP stack felt dated.
Cockpit: Generic system management, but lacking deep ZFS integration.
Webmin: A security nightmare and way too broad.

None of them gave me what I wanted: a clean, no-nonsense window into my ZFS pools that stayed out of the way. So, I built dumpstore.

What Makes dumpstore Different?

dumpstore is designed for developers and sysadmins who:

Want minimal dependencies (just Go + Ansible).
Prefer auditable changes (Ansible playbooks for writes).
Need deep ZFS integration (snapshots, datasets, ACLs, iSCSI).
Care about cross-platform support (Linux and FreeBSD).
Key Features:

• Single Go Binary - No database, no runtime bloat. Just compile and run.
• Ansible for Writes - All mutations (e.g., creating datasets) are handled via Ansible playbooks.
• ZFS-First Design - Built for ZFS, with support for snapshots, datasets, and even iSCSI targets.
• Real-Time Monitoring - Server-Sent Events push updates to the UI (e.g., pool health, I/O stats).
• FreeBSD Support - Rare for NAS tools—dumpstore works seamlessly on FreeBSD.
• No Built-in Auth - Designed for trusted networks (use a reverse proxy for TLS/auth).

How It Works

Architecture:
dumpstore is split into two parts:

Backend (Go):

Handles REST API requests and Server-Sent Events (SSE).
Uses exec.Command for reads (e.g., zpool list, zfs get).
Uses Ansible playbooks for writes (e.g., creating datasets, users).

Frontend (Vanilla JS):

A single-page app that renders based on API responses.
No frameworks—just plain JS + CSS for speed and simplicity.

*Why Ansible for Writes?
*

• Idempotency: Running a playbook twice won’t break anything.
• Audit Trail: Every write operation logs what changed.
• Validation: Playbooks include assertions to catch bad inputs early.

Example: Creating a Dataset
When you create a dataset via the UI:

The frontend sends a POST /api/datasets request:

{
  "name": "tank/projects",
  "type": "filesystem",
  "compression": "lz4",
  "quota": "100G"
}

The backend validates the input and runs the zfs_dataset_create.yml Ansible playbook:

- name: Create ZFS dataset
  command: zfs create -o compression=lz4 -o quota=100G tank/projects

The playbook’s output is streamed back to the UI, showing success/failure.

Who Is dumpstore For?

dumpstore is ideal if you:

✅ Use ZFS (especially on Linux or FreeBSD).
✅ Want a lightweight UI (no database, no containers).
✅ Care about auditability (Ansible playbooks for writes).
✅ Prefer minimalism over enterprise-grade polish.

It’s not for you if you:

❌ Need built-in authentication (use a reverse proxy).
❌ Want plugins or apps (dumpstore focuses on storage, not apps).
❌ Use non-ZFS storage (e.g., Btrfs, ext4).

Getting Started
Installation
dumpstore is easy to install on any Linux or FreeBSD system with ZFS and Ansible:

# Clone the repo
git clone https://github.com/langerma/dumpstore.git
cd dumpstore

# Run the install script (as root)
sudo ./install.sh

The service will start on http://localhost:8080.

Change the listen address:

Edit /etc/systemd/system/dumpstore.service (Linux) or /usr/local/etc/rc.d/dumpstore (FreeBSD).
Enable TLS:

Use a reverse proxy like Nginx or Caddy. Example Nginx config:

server {
  listen 443 ssl;
  server_name nas.example.com;
  ssl_certificate /path/to/cert.pem;
  ssl_certificate_key /path/to/key.pem;
  location / {
    proxy_pass http://localhost:8080;
  }
}

Roadmap

Here’s what’s coming next:

• ZFS Native Encryption: Load/unload keys, manage encrypted datasets.
• Pool Import/Export: Safely import/export ZFS pools.
• Snapshot Diff: Show changes between snapshots (zfs diff).
• Optional Authentication: Basic HTTP auth or OAuth proxy support.
• Plugin System: Extend dumpstore with custom scripts.
• (See the GitHub roadmap for details.)

Why Open Source?

dumpstore is MIT-licensed because:

Transparency matters: You should know exactly what’s running on your NAS.
Community drives improvement: Pull requests and feedback make the project better.
NAS tools should be auditable: No hidden telemetry, no proprietary blobs.

How You Can Help

dumpstore is a community-driven project. Here’s how to get involved:

Try it out! Install dumpstore and open an issue if you hit snags.
Contribute code

Final Thoughts

dumpstore won’t replace TrueNAS for everyone - but if you’re a developer or sysadmin who wants a lightweight, auditable ZFS UI, it might be exactly what you’re looking for.
Give it a try: https://github.com/langerma/dumpstore

Questions? Drop a comment or open a GitHub issue!

What features would make it better? Let’s discuss!