Efficient LVM Snapshot Synchronization for Xen VM Backup: A Block-Level Differential Transfer Solution


1 views

When backing up Xen virtual machines stored in LVM volumes, we face two critical constraints:

  • Minimizing storage overhead (no space for temporary local copies)
  • Reducing network bandwidth during transfers

Traditional tools fall short for this specific use case:

# Inefficient full copy (avoid this)
dd if=/dev/xenVG/SERVER001OS | ssh backup "dd of=backup.img"

Instead, consider these specialized solutions:

1. BDSync - Block Device Synchronizer

This tool performs binary diffs between block devices:

# Install bdsync
apt-get install bdsync

# Basic usage
bdsync "ssh backup cat backup.img" /dev/xenVG/SERVER001OS | ssh backup "bdsync backup.img"

2. DRBD with LVM Snapshots

For environments already using DRBD (as mentioned in the original scenario):

# Create snapshot
lvcreate -s -n SERVER001OS_snap -L 10G /dev/xenVG/SERVER001OS

# Sync via DRBD
drbdadm primary SERVER001OS_snap
drbdadm connect SERVER001OS_snap

While standard rsync doesn't handle block devices well, we can combine it with other tools:

# Create sparse file representation
dd if=/dev/xenVG/SERVER001OS_snap bs=1M conv=sparse of=temp.img

# Rsync with sparse file support
rsync -avzS temp.img backup:/mnt/backups/SERVER001OS.img

# Cleanup
rm temp.img
lvremove /dev/xenVG/SERVER001OS_snap

Here's a complete solution using lvmsync (requires Python):

#!/bin/bash
VM_NAME="SERVER001OS"
SNAP_SIZE="10G"
BACKUP_SERVER="backup.example.com"
BACKUP_PATH="/mnt/backups"

# Create snapshot
lvcreate -s -n ${VM_NAME}_snap -L ${SNAP_SIZE} /dev/xenVG/${VM_NAME}

# Sync using lvmsync
lvmsync --xen --compress /dev/xenVG/${VM_NAME}_snap \
  ssh://${BACKUP_SERVER}${BACKUP_PATH}/${VM_NAME}.img

# Remove snapshot
lvremove -f /dev/xenVG/${VM_NAME}_snap
  • For initial full sync: Use bdsync or dd with compression
  • For subsequent incremental syncs: lvmsync with --changes-since flag
  • Network optimization: Consider mbuffer for network throttling

Always verify backups using checksums:

# Generate checksum
sha256sum /dev/xenVG/SERVER001OS > /tmp/original.sha256

# Verify backup
ssh backup "sha256sum ${BACKUP_PATH}/SERVER001OS.img" | diff - /tmp/original.sha256

When dealing with Xen virtual machines stored in LVM volumes, traditional backup methods like full dd transfers become impractical due to bandwidth constraints. The fundamental challenge lies in synchronizing block-level changes between LVM snapshots and remote backup servers efficiently.

First, create a consistent snapshot of your Xen VM's LVM volume:

lvcreate -L 10G -s -n SERVER001OS_backup /dev/xenVG/SERVER001OS

Several tools can handle block-level differential transfers:

1. bdsync - Block Device Synchronization

bdsync --diffsize --blocksize=4096 /dev/xenVG/SERVER001OS_backup \
"ssh backupServer bdsync --server /mnt/largeDisk/SERVER001OS.img" \
| ssh backupServer "bdsync --patch /mnt/largeDisk/SERVER001OS.img"

2. Using ddrescue with Compression

ddrescue /dev/xenVG/SERVER001OS_backup - | pv | gzip | \
ssh backupServer "gunzip > /mnt/largeDisk/SERVER001OS.img"

3. LVM Thin Provisioning with rsync

For thin-provisioned LVM volumes:

lvconvert --type thin-pool xenVG/xenPool
lvcreate -V 100G -T xenVG/xenPool -n SERVER001OS_thin
dd if=/dev/xenVG/SERVER001OS of=/dev/xenVG/SERVER001OS_thin bs=4M
rsync -avz --sparse /dev/xenVG/SERVER001OS_thin backupServer:/mnt/largeDisk/

Create a cron job script that handles the entire workflow:

#!/bin/bash
SNAP_SIZE="10G"
VM_NAME="SERVER001OS"
BACKUP_SERVER="backupServer"
LV_PATH="/dev/xenVG/${VM_NAME}"
SNAP_NAME="${VM_NAME}_snap_$(date +%Y%m%d)"
BACKUP_PATH="/mnt/largeDisk/${VM_NAME}.img"

# Create snapshot
lvcreate -L ${SNAP_SIZE} -s -n ${SNAP_NAME} ${LV_PATH}

# Sync with bdsync
bdsync --diffsize --blocksize=4096 "/dev/xenVG/${SNAP_NAME}" \
"ssh ${BACKUP_SERVER} bdsync --server ${BACKUP_PATH}" \
| ssh ${BACKUP_SERVER} "bdsync --patch ${BACKUP_PATH}"

# Remove snapshot
lvremove -f /dev/xenVG/${SNAP_NAME}
  • Use larger block sizes (4M-16M) for better throughput
  • Consider network compression when bandwidth is limited
  • Schedule backups during low-usage periods
  • Monitor snapshot sizes to prevent volume group exhaustion

To verify backup integrity and prepare for recovery:

ssh backupServer "qemu-img check /mnt/largeDisk/SERVER001OS.img"

For disaster recovery:

dd if=/mnt/largeDisk/SERVER001OS.img of=/dev/xenVG/SERVER001OS_RECOVERED bs=4M
lvrename /dev/xenVG /dev/xenVG/SERVER001OS_RECOVERED SERVER001OS