Backup, replication and continuity across complex architectures
Composing protection across VM, container and distributed storage: what covers what.

A platform is not one object, so it cannot have one backup. The virtual machine, the volume a container writes into, the distributed pool underneath both, the declarations that rebuild the platform and the credentials that open all of it are five different things, protected by five mechanisms, each good at one failure and blind to the next. Composing them means asking, at each level, what is copied, what is left exposed, and who can restore it.
The unit of composition is the level
Protection composes only when each layer is asked a question it can answer. Replication answers whether another copy of a block exists right now; a backup, whether a copy exists from before the change; configuration as code, whether the platform can be built again; a credential, whether any of the others can be read. Stacking them does not produce a system that survives everything; it produces a chain whose weakest promise is the one that binds.
The composite recovery point is not the best number in the inventory but the worst one on the path from the service to its data. A pool replicating synchronously under a declaration updated quarterly, whose key existed only on the host that burned, has a recovery point of one quarter and, in practice, no restore.
composition runs one way: each layer is only as recoverable
as the layer it depends on
service ....................... rebuilt from declarations
|
configuration artefacts ....... the last commit who can read it?
|
VM image / host volume ........ a snapshot of a machine who can boot it?
|
container volume .............. the application's data who knows the app?
|
distributed pool .............. replication, NOT a copy deletes propagate
|
credentials and keys .......... without them, nothing above restores
=================================================================
the independent copy .......... immutable / offline / offsite
-> this row sets the real RPO
Objectives before components: the frame that fixes the numbers
The vocabulary predates the products. The contingency planning guide fixes three numbers and their order: the RPO is the point in time, before the outage, to which data can be recovered from the most recent copy; the RTO is the maximum time a resource may stay unavailable; and it sits under a Maximum Tolerable Downtime, because “the RTO must normally be shorter than the MTD”. Its seven-step process runs from policy to plan maintenance, and step six decides whether the rest is evidence or hope: “Testing validates recovery capabilities, whereas training prepares recovery personnel for plan activation and exercising the plan identifies planning gaps”.
The frame prices the strategy and names the people: its ladder of alternate sites ends at the mirrored site, “the most expensive choice, but it ensures virtually 100 percent availability”; procedures are written so that a technician can “recover the system without intimate system knowledge”; and the plan must assume that “a disruption could render some personnel unavailable to respond”.
What each level actually holds
The virtual machine is the coarsest unit: a machine as an image, root volume and attached volumes together, which is why a hypervisor-level copy preserves the machine as one object. Its blind spot is everything that is not a disk — the declaration that built it, and the key material inside it.
A container volume is the opposite granularity, and the composition question starts at its edge: “A volume’s contents exist outside the lifecycle of a given container. When a container is destroyed, the writable layer is destroyed with it.” The volume sits “within a directory on the Docker host”; the image is rebuilt, not restored.
Distributed storage changes the question rather than answering it. Ceph gives each zone its own cluster and states the purpose: “The presence of multiple zones in a given zonegroup provides disaster recovery for that zonegroup”, and since “Each zone is active and can receive write operations”, the second copy is live, not a snapshot. Windows Storage Replica makes the same trade at block level and pins its consistency groups on write ordering, so that “the data is written on the destination server sequentially”.
ZFS sits between the two, turning snapshots into a stream: the incremental form sends “all intermediary snapshots from the first snapshot to the second snapshot”, while the replication form preserves the shape as well as the bytes, so a stream can be kept, not merely replayed. Configuration is the fifth artefact: the declarations, plus the images they launch.
Where the independent copy lives, and what it costs
Replication and backup diverge at the fault-domain boundary. Microsoft states the limit without hedging: delete everything on the source and “Storage Replica replicates the deletion instantly to the other volume, irrevocably removing the data from both servers.” Replication covers the loss of a node, not of the data — a geo-replicated object store inherits the same pass-through, since Ceph serves a bucket only from “the zonegroup where the bucket resides”.
The independent copy is paid for twice: deduplication by what it saves — “For modified files, only modified Blobs have to be saved in a subsequent backup” — and encryption by what it adds, “The complete encryption overhead is 32 bytes” per file, plus a key kept reachable and unexposed. Immutability closes the loop: in compliance mode “a protected object version can’t be overwritten or deleted by any user”, the root account included, until the date passes, and variable retention is offered as exactly “a configurable recovery window against ransomware or accidental deletion”.
Continuity read backwards: ransomware as a restore requirement
The ransomware guide reads as a restore requirement, not a backup requirement: it asks for a copy the attacker cannot reach — “maintain offline, encrypted backups of data” — and for a test, to “regularly test your backups”, because ransomware variants “find and delete any accessible” backups. Recovery is then an ordering — “restore data from offline, encrypted backups based on a prioritization of critical services” — driven by a list prepared beforehand, “based on a predefined critical asset list”. It also names the artefacts that are not user data: the image templates a system is rebuilt from, and source code or executables “stored with backups, escrowed”. The characteristic failure of a composed scheme is a deletion that replicated, not a slow backup.
The matrix: what covers what, at what RPO, and who can restore it
| Level | What the copy is | What it covers | Recovery point it can meet | Who restores it, and how long |
|---|---|---|---|---|
| VM / host image | a machine image: system disk, attached volumes, the boot path | the machine as one object; a rebuild on clean hardware | the snapshot schedule — hours, or the replication lag | the virtualization operator; boot and reattach, minutes to hours once capacity exists |
| Container volume | the directory the container persists into, on the host | the application’s data; the image is rebuilt, not restored | the volume schedule; the image, the last push | the application team; untar into a new container, minutes — if the image is still pullable |
| Distributed pool / object store | a live replica across nodes, zones or sites | the loss of a node, a rack, a zone; never the loss of the data | replication lag: near zero synchronous, unbounded asynchronous | the storage team; promote a zone, minutes — and only once sync has caught up |
| Configuration artefacts | the declarations and machine images that rebuild the platform | how to build the platform again, not what was on it | the last commit or push | whoever wrote the declaration; redeploy, tens of minutes to hours |
| Credentials and keys | the escrowed key material, held offline | the ability to read every copy above | the escrow date — a stale key is no copy at all | a named holder, offline; the restore does not start before that |
Read the matrix in two directions. Down the rows, the composite recovery point is the worst cell on the path, not the best: a synchronous pool under a declaration updated quarterly still loses a quarter of its history. Across the rows, replication appears at more than one level and is a copy at none — availability with a deletion pass-through. And the last column has no product behind it: recovery is a procedure executed by named people who must be trained, duplicated and reachable.
Level and prerequisites
L5 — composing protection across a platform, rather than the mechanics of any single copy. The reader should know what a backup chain is and what a copy owns (the L3 sheets Full, incremental and differential backup and Retention, immutability and separate copies) and how a decision between two sites is made (sheet 6, Multi-site disaster recovery).
Where to go next
- Server & Virtualization — the area this sheet belongs to.
- Sister sheets in preparation: Distributed systems and failure domains (the fault-domain vocabulary); Distributed storage: consistency and availability trade-offs (what a live replica guarantees); Multi-site disaster recovery (the two-site decision); Management-plane isolation.
References
- NIST, Contingency Planning Guide for Federal Information Systems, SP 800-34 Rev. 1 — the RPO/RTO/MTD definitions and their ordering, the seven-step process, alternate sites and offsite criteria, testing and training, and the key-management rule for encrypted offsite copies.
- Amazon Web Services, Disaster recovery options in the cloud (Disaster Recovery of Workloads on AWS whitepaper) — backup and restore, continuous replication versus point-in-time copies, infrastructure as code, recovery-point windows and promotion times.
- restic, References — Design (restic 0.19.1 documentation) — content-defined chunking and deduplication, the encryption and authentication format and its overhead, and the threat model’s limits.
- Amazon Web Services, Locking objects with Object Lock (Amazon S3 User Guide) — the WORM model, retention periods and modes, legal holds, and the ransomware recovery window.
- Ceph, Multi-Site (Ceph Object Gateway documentation, development version) — zones, zonegroups and realms, active-active replication, sync status and promotion, and failover and disaster recovery.
- CISA / MS-ISAC, Ransomware Guide — offline encrypted backups and testing, gold images and escrowed code, restoration prioritised by critical-asset list.
- OpenZFS, zfs-send(8) (OpenZFS documentation, master) — incremental and replicated send streams, raw sends of encrypted datasets, redaction.
- Microsoft, Storage Replica overview (Windows Server) — synchronous and asynchronous block replication, consistency groups, seeded initial sync, and the explicit statement that replication is not a backup.
- Docker, Volumes (Docker documentation) — the lifecycle of a volume and its storage on the host, and the container’s writable layer.