When Proxmox VE ZFS storage replication fits a cluster without shared storage
Scheduled ZFS replication gives you node-to-node copies of guest disks without shared storage, and the cost is a recovery point that can lag the last write. It fits a cluster whose nodes run local ZFS disks, where there is no SAN and no Ceph cluster, and where the business can accept that a failed node's guests restart from the most recent replicated copy. The feature sends guest disk data from one node to another on a schedule. The target holds a copy that is only as current as its last successful run, so any writes made after that run exist only on the source. If the source is lost, those writes are lost too.
Workloads that tolerate this lag are those where losing the last interval of changes can be recovered from somewhere else. Examples include stateless application servers, build agents, test environments and services whose durable data lives in an external database or object store that has its own replication. Workloads that do not tolerate it include databases that promise commit-level durability, transaction systems and any service where a lost write is a financial or regulatory event. Before you choose replication, ask each application owner for the maximum acceptable data loss in minutes and confirm that the application can resume cleanly from a copy taken at an earlier point.
Proxmox VE high availability is designed around shared storage. The HA documentation lists at least three cluster nodes for reliable quorum, shared storage for guests, redundant hardware, and watchdog-based fencing so a failed node is reset before its guests are recovered elsewhere. Shared storage matters because the surviving node can start a guest from the same disk the failed node was using. Replication removes that assumption, so combining it with HA means the recovery target starts from a copy that may be behind. Test this path on your own Proxmox VE version, confirm how HA handles replicated guests, and check whether any manual step is needed before you rely on it.
Before you commit, settle a short list of decisions: the number of nodes, the replication interval for each guest class, the agreed data loss window, the spare ZFS capacity each node needs for copies, and the fencing setup. Replication itself does not add a separate license. Proxmox VE subscriptions are priced per CPU socket per year, and all tiers include the same software features, so the subscription mainly affects support entitlements and access to the enterprise repository. When the loss window is unacceptable for a workload, shared storage such as Ceph is the alternative, but it brings its own hardware, network and operations requirements.
Which replication and HA design fits each workload
This table compares four ways to recover Proxmox VE guests after a node failure, from scheduled ZFS replication with manual steps to Ceph RBD with HA. Read each row for its recovery point, the steps after a failure, the storage it needs and the workloads it suits. The main takeaway is that replication limits data loss to the window set by your replication schedule, while shared storage and Ceph reduce that window at the cost of more infrastructure to operate.
| Design | Recovery point and steps | Storage hardware | Suits workloads |
|---|---|---|---|
| Replication only, manual recovery | The last completed replication is the recovery point. An operator starts guests on the surviving node after confirming the failure. | Local ZFS pools on each node. No shared storage is required. | Non-critical guests where some data loss and manual recovery steps are acceptable. |
| Replication with HA | The last completed replication sets the data loss window. Confirm automated restart behavior in the Proxmox VE documentation before relying on it. | Local ZFS on each node, at least three cluster nodes, and watchdog-based fencing so failed nodes reset first. | Guests that can lose recent changes but need automatic restart after a node failure. |
| Shared storage over iSCSI or NFS with HA | Guests read and write one shared copy, so the recovery point is close to current. HA restarts guests on another node after fencing. | External iSCSI or NFS array with redundant paths, at least three nodes, and watchdog fencing. | Workloads that need near-current data and a storage system the organization already operates. |
| Ceph RBD with HA | Data is stored as replicas across OSDs, so one node loss does not remove the only copy. Confirm replica and failure domain settings with your Ceph design. | Local drives for OSDs, one dedicated drive per OSD, bonded links across two switches, and enterprise SSDs for metadata. | Larger clusters with many guests, and teams with the capacity to run and monitor Ceph. |
How scheduled ZFS replication copies guest disks between nodes
Scheduled ZFS replication in Proxmox VE copies a guest's ZFS-backed virtual disks from the node where the guest runs to one or more other cluster nodes at a set schedule. Each run sends the disk's ZFS snapshot to the target, which keeps the last transferred state as a local copy. The copy is not shared storage: each node holds its own dataset, and the target only becomes useful when a guest is started there. Understanding that model is the starting point for checking whether replication fits a given recovery goal. The first transfer is a full copy of the disk, which can take a long time for large volumes and places heavy load on the source and the network. Later runs are incremental: they send only the blocks changed since the last common snapshot. Before relying on this, confirm in the Proxmox VE administration guide how the replication engine chooses between full and incremental transfers, what happens if the common snapshot is lost, and how a failed run is retried. Ask your team to test an initial sync on representative disk sizes in your own hardware, because transfer time depends on disk size, change rate and network path, not on a fixed figure. A replication job defines the guest it protects, the target node, and the schedule on which transfers run. Several jobs can exist per guest, each with its own target. Check in the documentation which schedule syntax is supported, the minimum interval, and any limits on concurrent jobs or bandwidth. Those values are configuration limits that can change between releases, so record the version you tested against and confirm them before you write a recovery design around a specific frequency. Replication does not start a guest on its own. Failover to a target is a deliberate action: the guest configuration is available on the target and the administrator, or HA manager if combined with HA, starts the guest there using the most recent replicated state. Confirm in the guide what happens to the guest configuration, which disks are attached, and whether a guest that is still running on the source can be started on the target. Document a runbook that covers this step, including how to confirm the source is down before starting the copy elsewhere, so two instances do not write to disks at the same time. The main risk to plan for is the gap between the last successful transfer and the failure. Any writes made after that point are lost on failover, so the replication schedule defines your recovery point. Test a failover in a non-production cluster, measure how much data is missing, and compare that result with what the business accepts.
Setting up ZFS replication between Proxmox VE nodes
This sequence takes a Proxmox VE cluster from repository and cluster checks through a working replication job, then tests a planned migration and a simulated node failure. Each step ends with a check the team records before moving on. The result is a replicated test guest and a documented baseline for the production design.
Align repositories and package versions on each node
The platform team sets the package repository on every node before anything else, because the repository choice decides which package versions the nodes patch from. Proxmox's package repositories documentation says the enterprise repository requires a valid subscription key and is recommended for production, while the no-subscription repository suits testing and non-production use. All subscription tiers include the same software features and differ in support entitlements and enterprise repository access, so confirm the tier and repository for every node. Done when each node shows the same repository configuration and comparable package versions in its update view, and the result is recorded in the build record.
Confirm cluster membership and quorum
The platform engineer checks that every intended node is a member of the same cluster and that the cluster has quorum before configuring any replication. Proxmox's High Availability documentation says HA needs at least three cluster nodes for reliable quorum, so if the cluster has fewer nodes, plan the HA design separately from replication. Use the cluster status view described in the Proxmox VE administration guide to check membership and quorum state, and take exact commands from that guide. Done when all nodes appear as members with quorum, and the status stays stable across several refreshes.
Confirm matching ZFS pools on each node
The storage engineer confirms that each node keeps guest disks on ZFS and that the pool used for guests has the same name on every node that will receive replicas. The replication target is referenced by storage identifier, so a name mismatch will cause jobs to fail later. Check the free capacity on each target pool against the guest disks planned for replication and record the figures in the design file. Done when each node lists the same ZFS-backed storage in the storage configuration with the expected free capacity. Replication does not replace backups, so keep the backup tool configured separately.
Confirm network reachability and SSH trust
The network engineer confirms that every node can reach every other node over the network path the replication traffic will use, and that the SSH trust the cluster relies on works in each direction. Test from each node to each other node, including name resolution if the cluster uses hostnames. Use the connectivity and trust checks described in the Proxmox VE administration guide and avoid ad hoc commands that are not documented there. Done when every pair of nodes connects without a password prompt or errors, and the results are recorded with the firewall rules in place.
Create the replication job for a test guest
The platform engineer creates a replication job for a non-critical test guest, choosing the target node and the schedule the design calls for. Pick a test guest whose disks sit on the ZFS pool, and set the schedule in the job options as the administration guide describes. The replication interval is the main input to the data loss window, so write down the chosen interval and the reasoning before the job runs. Done when the job appears in the replication list for the guest with the target node and interval shown as configured, and the design record matches the settings.
Run the replication job once manually
The engineer triggers the job once by hand before the schedule takes over, so the first full transfer happens while someone watches it. Keep the test guest in a known state while the first sync runs, and read the job log for errors. Record how long the first sync took in the change ticket so later runs have a comparison point. Done when the log reports success and the replication status shows a last sync time on the expected target. If the job fails, fix the cause in the storage or network checks above before enabling the schedule.
Verify target dataset and guest configuration
The engineer checks the replicated dataset on the target node and confirms the guest configuration arrived with it. Look for the guest's disk volumes under the expected ZFS dataset on the target, and compare the guest configuration on the target with the source. Confirm the guest is not running on the target, because a replica stays passive until a migration or recovery moves the guest. Done when the dataset exists with matching volume names, the configuration matches the source, and the results are recorded in the runbook.
Test planned migration and simulated node failure
The team tests two paths: a planned migration of the test guest to the target node, and a simulated node failure to see how recovery behaves. For the failure test, use a method agreed in the change plan. The High Availability documentation says watchdog-based fencing resets a failed node before its guests are recovered elsewhere, so confirm that fencing is in place before any failure test that depends on it. Record the data loss window observed by comparing the last replicated state with the state at the point of failure. Done when both tests finish as the runbook predicts, and the findings are reviewed before any production job is enabled.
How the data loss window follows the replication interval
After a node fails, a guest recovered from ZFS storage replication returns to the most recent replicated copy, not to the moment of failure. Any write made after the last successful replication run is lost. The data loss window is therefore the time between that last successful run and the failure. Schedule interval alone does not define it. Before you choose an interval in Proxmox VE, agree with the application owner how much recent data the workload can afford to lose, and write that number down as the target the design must meet.
Three factors determine how large the window gets in practice. The first is the replication interval, which sets how often a new snapshot is sent. The second is the transfer duration, which is the time each incremental send takes to finish on the link between nodes. A transfer that runs longer than the interval causes runs to queue or overlap, so the copy on the target can fall further behind than the schedule suggests. The third is a failed or delayed job. A failed run leaves the target at its previous state until a later run succeeds, so the window grows for as long as the job stays broken, and a failure that goes unnoticed can stretch the window without anyone seeing it.
Illustrative example only, with no measured values: suppose a replication job runs every interval I, and each transfer takes T to complete. If a node fails just before a run finishes, the most recent good copy can be roughly I plus T older than the failure moment. If one run also fails and the next success happens a full interval later, the exposure grows to about two intervals plus T. Work the calculation with your own schedule and measured transfer times, and check the result against the agreed target. If the answer exceeds the target, shorten the interval, reduce the transfer size or fix the link before go-live.
Measure the window in a test cluster that matches production as closely as you can. Create a guest that writes a timestamped marker to disk at a known rate, let at least one full replication cycle complete, then power off the source node without a clean shutdown. After recovery on the target, compare the last marker present with the time of failure. Repeat the test while a job is deliberately failed or throttled, and record the replication job status and the last successful sync time that Proxmox VE reports. Use these results to validate the window, not the schedule you intended.
Before you rely on the recovered guest, confirm with the Proxmox VE documentation how a guest recovered from a replicated copy reports its data state, including whether the last sync time or any consistency indication is shown and where. Your runbook should state who checks that state after a failover, which timestamp they compare against the agreed window, and how they document any loss that occurred. Plan that verification step as part of the failover procedure rather than leaving it to be discovered during an incident.
Security and operational considerations for replicated guest data
Replication creates extra copies of guest disks on other nodes, which changes your trust, access, encryption, monitoring, patching and backup controls. Each card below names one control you can verify on your own cluster before go-live.
SSH trust between nodes
Replication jobs connect from one node to another over SSH, so the keys that allow this form part of the trust boundary for every replicated guest disk. Check which keys exist on each node, who can read the private keys, and whether replication traffic uses a network that only cluster nodes can reach. Confirm how keys are removed when a node is retired, because a stale key on a decommissioned host still provides a path to replicated data.
Access control for replication jobs
Proxmox VE authenticates users through Linux PAM, the built-in authentication server, LDAP, Microsoft Active Directory or OpenID Connect realms. Map the roles that can create, edit or delete replication jobs to named directory groups, and keep that group small. Confirm that people who can change a job cannot also read guest disks they are not responsible for, using the permissions in your own role model.
Second factors for administrator accounts
Proxmox VE supports TOTP, WebAuthn, YubiKey OTP and recovery keys as second factors. Require one of them for every account that can change replication jobs or reach a node's shell. Store recovery keys offline with a named custodian, and confirm in your Proxmox VE version how second-factor enforcement is configured for each realm before you rely on it.
Encryption of every replica
Each replicated copy is another set of guest data at rest, so encryption must cover the source and every target node, including spare nodes. Confirm which encryption method your ZFS pools use, where the keys are stored and whether a rebooted target can unlock automatically. Manual unlock after a reboot can delay failover, so test the recovery sequence with your chosen method.
Monitoring of replication failures
A failed replication job does not stop guests from running, so it can stay broken without anyone noticing. Define who reviews replication job status, how failures reach that person, and how long a failed job may remain unresolved, because that period extends your effective data loss window. Test the alert path by breaking a target on purpose in a non-production cluster.
Patching through the correct repository
The Proxmox VE enterprise repository requires a valid subscription key and is recommended for production, while the no-subscription repository is suited to testing and non-production use. Confirm which repository each node uses, and keep all nodes on matching package levels before a failover test. Stage updates in a test cluster first, and confirm which support entitlements your subscription tier includes for upgrade issues.
Backup as a separate layer
Replication copies a deleted or corrupted guest disk to the target on the next run, so it does not protect against those events. Keep point-in-time backups in a separate system, such as Proxmox Backup Server, which provides incremental backups, deduplication and encryption. Confirm the retention period you need, and restore a sample guest on a schedule to prove that backups are usable.
When Ceph is the better design than ZFS replication
Move from node-local ZFS replication to Ceph when a guest must survive the loss of a host or disk without restoring from the most recent replicated snapshot. ZFS replication copies data between nodes on a schedule, so a failover starts from the last completed sync and any writes after it are lost. Ceph distributes each object across failure domains that you define in CRUSH rules, so a failed host or drive leads to data recovery across the remaining hardware rather than a switch to an older copy. The decision turns on workload recovery needs: how much data loss the application can tolerate, how quickly guests must restart after a failure, and how much capacity and write load you expect to grow into.
Ceph is a separate storage system, and your team must staff and patch it as one. It runs its own monitors, managers and OSDs, has its own network design and its own upgrade sequence, and it sits beneath Proxmox VE rather than inside it. The Ceph hardware recommendations call for a dedicated drive per OSD, moving WAL and DB onto shared SSDs for HDD-based OSDs, enterprise-class SSDs for metadata, bonded network links across two switches, and memory sized for peak use rather than quiet periods. They also advise benchmarking before you buy, because no two clusters behave alike. Confirm the minimum node count and network layout for your replication settings with the Ceph documentation before you size hardware.
The Ceph source is licensed under LGPL-2.1 or LGPL-3, and the project itself offers no paid edition, so the software carries no license fee. The cost of running Ceph sits elsewhere: servers, drives, switches and cabling; staff time for design, monitoring, drive replacement, capacity expansion and patching; and any vendor or partner support contract you choose. Design, benchmarking and the migration of guests off ZFS are largely one-time costs, while patching, monitoring and hardware refresh recur. When you request a quote, ask for each of these components separately, state which party carries each one, and list what the scope excludes, such as the Proxmox VE subscription that remains a separate purchase.
Plan the release lifecycle before you choose a version. The Ceph releases page lists Squid (19.2.x, latest 19.2.7) with an estimated end of life of October 31, 2026, and Tentacle (20.2.x, latest 20.2.4) with an estimated end of life of June 1, 2027. Actively maintained releases receive periodic backports and security fixes, so an estimated end-of-life date is the point at which you must have upgraded. Cephadm, the deployment method that runs Ceph as containers, was introduced in v15.2.0 (Octopus) and does not support older releases. Confirm that the Ceph release you select is supported by cephadm and that your upgrade plan reaches a supported release before the end-of-life date. If you run Ceph under Kubernetes instead, the cephadm documentation points to Rook, a CNCF Graduated project, as the alternative deployment path.
A practical rule is to stay with ZFS replication when your guests tolerate a bounded loss window and your team cannot yet operate a second storage platform. Choose Ceph when guests need storage that stays available through a node or drive failure, when you can dedicate hardware and staff to it, and when you expect the cluster to grow. Before you commit, run a short proof of concept on hardware close to your planned build, measure recovery time after a deliberate node failure, and record the staff hours each month for patching and monitoring. These measurements give you the figures that a quote and an upgrade plan need.
Limits to confirm in your environment before relying on replication
Replication is only as dependable as the behavior you verify in your own Proxmox VE version and environment. Each card below is a question to answer with Proxmox documentation or a lab test before you depend on a replica for recovery. Together, the answers set your recovery time and the amount of data you could lose.
Does HA restart replicated guests automatically?
Confirm whether HA restarts a replicated guest on another node automatically or waits for an operator to start it in your version. The answer decides how long a guest stays down after a node fails and whether your runbook needs a manual step. The HA documentation lists shared storage for guests, so confirm how that requirement applies to locally replicated disks. In a lab, power off a node that holds a replicated guest and record the time to recovery and the node where it restarts.
How are failed replication jobs surfaced?
Confirm how a failed replication job is reported, who sees the failure, and what alert fires when a job stops running. A job that fails quietly can leave a replica hours or days older than your recovery plan assumes, and nobody notices until a node is lost. Check the task log, the job status in the GUI, and whether your monitoring reads either source. In a lab, break a target dataset on purpose and confirm the alert reaches a named owner.
Do storage pools match across nodes?
Confirm that every replication target has a ZFS pool and storage definition that matches the source, including pool names, dataset layout and free capacity for the replicated copies. A mismatch may block migration or recovery, and it often appears only during an incident. Record the pool layout for each node in your build document, then check it after every hardware change, disk replacement or node rebuild.
Which guest types are supported?
Confirm which guests you will replicate, KVM virtual machines or LXC containers, and how each type behaves for scheduling, restart and disk handling in your version. Do not assume that a container with mount points or a virtual machine with passthrough devices replicates the same way as a plain disk image. Build a test matrix with one guest per type and each disk configuration you use, then run a replicate, fail and recover cycle for every entry.
Can the network carry each transfer?
Confirm the bandwidth each replication interval needs, because each run sends the blocks changed since the previous run. Measure how much your guests change under normal and peak load, then check whether transfers finish before the next scheduled run on the links you plan to use. Ask Proxmox which network interface carries replication traffic and whether you can dedicate one to it, so backup and guest traffic do not compete with transfers.
What does a major upgrade change?
Proxmox VE releases are supported at least as long as the matching Debian release receives security support, roughly three years according to the Proxmox VE FAQ. Proxmox VE 8 on Debian 12 reached end of life in August 2026, so a replication design built on it needs an upgrade plan now. Confirm the end-of-life date for your release, decide the order of node upgrades so existing replicas stay usable, and test replication and HA behavior on the new version before cutover.
Questions buyers ask before hiring help with ZFS replication
What drives the cost of setting up ZFS replication on Proxmox VE?
Node count, guest count and the testing scope drive most of the cost and effort. A two-node pair with a few guests and a simple test plan is a very different job from a cluster with dozens of guests, several replication jobs per node and a change process that needs evidence for each step. Other drivers include the state of existing hardware, the network paths between nodes and the number of storage pools to design. One-time work covers design, configuration, failover testing and runbooks. Recurring work covers monitoring replication health, patching and periodic restore tests. Ask any partner for a quote that lists each of these as separate line items with the assumptions behind them, so you can compare it with your own team's effort.
Does a Proxmox VE subscription replace the cost of implementation services?
No. The Proxmox VE subscription is a cost paid to Proxmox Server Solutions per CPU socket per year, and implementation services are a separate cost. The published tiers are Community at 120 euros, Basic at 370 euros, Standard at 550 euros and Premium at 1,100 euros per socket per year, with support tickets and response times differing by tier (Proxmox VE pricing page). All tiers include the same software features. The main differences are support entitlement and access to the enterprise repository, which Proxmox recommends for production. The software can be used without a subscription, but the no-subscription repository is described for testing and non-production use, so confirm your repository choice before go-live. DeployOpen does not publish prices. Its quote follows from the written scope, so ask for the subscription and the services as two separate figures.
How long does ZFS replication setup take on Proxmox VE?
No fixed duration applies to every environment, because the timeline depends on the scope you agree in writing. The main drivers are the number of nodes, the number and size of guest disks (the initial sync time grows with the data volume), the network bandwidth between nodes, and the number of replication jobs and their intervals. Integration with HA adds design and failover testing, and each test cycle includes failover and failback checks that take time to repeat. Change windows and approval steps also set the pace, especially in regulated environments. Ask for a schedule tied to milestones such as design sign-off, lab validation, production cutover and acceptance tests, and confirm any version-specific behavior against the Proxmox VE documentation before the schedule is fixed.
What does our team need to provide for a replication project?
The work needs a test window, access and decisions from your side, all agreed in writing before work starts. You will need a test window that uses production-like data, access to the hypervisors, switches, storage and cluster management interface through agreed accounts, and a named technical contact who can approve changes. The most important input is a recovery point objective for each workload, agreed with the application owners, because it sets the replication interval. You also need to decide which guests replicate, provide hardware and network details, and confirm a backup and rollback plan for each cutover. Without these inputs, the design will rest on assumptions, and those assumptions tend to surface during failover testing.
Can our own team set up ZFS replication without outside help?
Yes, a capable internal team can build ZFS replication on Proxmox VE using the official documentation and a lab that matches your production hardware and versions. The skills needed include Linux administration, ZFS pool design, Proxmox cluster concepts and high availability, network configuration for bridges and VLANs, backup and restore procedures, and scripting for repeatable runbooks. Failure testing is the step teams most often underestimate, because it needs a planned test window and clear pass criteria. Use the no-subscription repository in the lab and the enterprise repository for production, as Proxmox describes. A partner is most useful when your team lacks one of these skills, has no lab, or cannot schedule the failover tests without disrupting other work.
When is Ceph a better fit than ZFS replication in Proxmox VE?
Ceph fits better when guests need shared storage across nodes, when you want to scale storage out over time, or when an asynchronous copy that lags behind is unacceptable. ZFS replication runs on a schedule, so data written since the last successful run can be lost on failover. Ceph has its own hardware requirements: a dedicated drive per OSD, WAL and DB on shared SSDs for HDD-based OSDs, enterprise-class SSDs for metadata, bonded network links across two switches, memory sized for peak use, and benchmarking before purchase. The Ceph source is licensed under LGPL, and the project offers no paid edition, so the cost sits in hardware, people and support. Switching to Ceph changes the quote to include storage design, benchmarks, network work, larger test plans and ongoing operations. Ask for both options compared on the same written scope.
How does the recovery point objective set the replication interval?
The replication interval is the main lever for the recovery point objective, because the data you can lose on failover is roughly the time since the last successful sync. Agree the recovery point objective with each application owner before choosing an interval. Shorter intervals reduce potential loss but add network and storage I/O, so test that each job finishes well within its interval under real load. Integration with HA also matters: confirm how HA restarts guests from the replicated copy, what state those guests return in, and whether any manual steps remain in your Proxmox VE version. Put the recovery point and recovery time objectives for each workload into the statement of work so the design and the acceptance tests use the same targets.
How DeployOpen works on this
DeployOpen plans, builds and documents Proxmox VE ZFS storage replication inside infrastructure you control, starting from a written scope. Work covers the node layout, replication schedule, HA integration and failure tests that your team needs to rely on it. Engagements are fixed-scope, and ongoing support is available as a retainer.
How we scope
- Node inventory, ZFS pool layout and the storage each guest needs to replicate
- Target recovery point for each guest group, and the data loss window you will accept
- Written scope listing deliverables, responsibilities and acceptance tests before any work starts
How we build
- Configure ZFS datasets and replication jobs on each node pair, with schedules set per workload
- Integrate HA rules only where the three-node quorum and watchdog fencing requirements are in place
- Test planned node loss and failover, and record measured data loss against the agreed window
How we hand over
- Runbooks for checking replication jobs, manual failover, failback and job recovery
- Documented node, pool and job configuration stored in a location your organization owns
- Handover session with your operators covering alerting, monitoring and the escalation path
How we support
- Retainer options for monitoring replication health, reviewing job lag and tuning schedules
- Patching and version upgrades planned against the Proxmox VE release and Debian support timeline
- Failover tests repeated after hardware, pool or cluster changes to confirm recovery still works

