Server Cloning with Clonezilla

Clonezilla is a powerful, free disk imaging and cloning tool that enables rapid server deployment, backups, and disaster recovery. This comprehensive guide covers creating bootable media, performing disk/partition imaging, network cloning, multicast distribution, and PXE-based deployment strategies.

Clonezilla Overview

Clonezilla provides:

  • Disk cloning: Complete server replication including partition tables and bootloaders
  • Image backup: Create compressed images for archive and recovery
  • Network mode: Clone over LAN using SSH, SAMBA, or NFS
  • Multicast: Efficiently clone one image to multiple servers simultaneously
  • PXE boot: Integrate with existing infrastructure for automated deployment

Creating Bootable Clonezilla Media

Download Clonezilla

# Download latest Clonezilla ISO
cd /tmp
wget https://sourceforge.net/projects/clonezilla/files/stable/clonezilla-live-*.iso

# Verify file integrity
sha256sum clonezilla-live-*.iso
# Compare with checksum from project page

# List available images
ls -lh clonezilla-live-*.iso

Create Bootable USB Drive

# Identify USB device (careful - this will overwrite data!)
lsblk

# Method 1: Using dd (for Linux systems)
# WARNING: Replace sdX with your USB device identifier
USB_DEVICE="/dev/sdb"
ISO_FILE="clonezilla-live-3.1.0-13-amd64.iso"

# Unmount the USB if already mounted
sudo umount "${USB_DEVICE}"1

# Write ISO to USB
sudo dd if="$ISO_FILE" of="$USB_DEVICE" bs=4M status=progress
sync

echo "USB drive created at $USB_DEVICE"

# Method 2: Using Etcher (more user-friendly)
# On macOS:
# brew install balena-etcher
# etcher select clonezilla-live-3.1.0-13-amd64.iso
# etcher select /dev/diskX
# etcher flash

# Method 3: Using GNOME Disks GUI
# sudo apt install gnome-disk-utility
# gnome-disks

Create Bootable CD/DVD

# For optical media
ISO_FILE="clonezilla-live-3.1.0-13-amd64.iso"

# Using growisofs (for DVD)
growisofs -dvd-compat -Z /dev/dvd="$ISO_FILE"

# Using xorriso (more modern)
xorriso -as cdrecord -v dev=/dev/cdrom -eject "$ISO_FILE"

# Using dd
dd if="$ISO_FILE" of=/dev/sr0 bs=4M status=progress

Disk and Partition Imaging

Full Disk Imaging

# Boot into Clonezilla and start the interface
# Select: Start_Clonezilla -> device-image -> Beginner mode

# Command line equivalent for full disk backup:
create_full_disk_image() {
    local source_device="/dev/sda"
    local image_path="/mnt/clonezilla-storage/server-backup"
    local image_name="prod-server-full-$(date +%Y%m%d)"
    
    mkdir -p "$image_path"
    
    echo "Creating full disk image: $image_name"
    
    # Use clonezilla's command line tools
    ocs-sr \
        -q2 \
        -j2 \
        -z1p \
        -i 2000 \
        -sfsck \
        -c \
        -r \
        -e1 auto \
        -e2 \
        -p true \
        savedisk "$image_name" "$source_device"
    
    if [ $? -eq 0 ]; then
        echo "Full disk image created successfully"
        ls -lh "$image_path/$image_name"
    else
        echo "Error: Disk imaging failed"
        return 1
    fi
}

# create_full_disk_image

Partition-Level Imaging

# Create image of specific partition only
create_partition_image() {
    local source_partition="/dev/sda1"
    local image_path="/mnt/clonezilla-storage"
    local image_name="partition-root-$(date +%Y%m%d)"
    
    mkdir -p "$image_path"
    
    echo "Creating partition image: $image_name"
    
    # For single partition
    ocs-sr \
        -q2 \
        -j2 \
        -z1p \
        -i 2000 \
        -sfsck \
        -c \
        -r \
        -e1 auto \
        -e2 \
        -p true \
        saveparts "$image_name" "$source_partition"
    
    if [ $? -eq 0 ]; then
        echo "Partition image created: $image_path/$image_name"
    fi
}

# Image compression options
# -z0: No compression (fastest, largest)
# -z1: gzip (default)
# -z9: Maximum compression (slowest, smallest)

# Speed up imaging with parallel processing
create_fast_disk_image() {
    local source_device="/dev/sda"
    local image_path="/mnt/clonezilla-storage"
    local image_name="fast-backup-$(date +%Y%m%d)"
    
    # Use parallel processing for faster cloning
    ocs-sr \
        -q2 \
        -j4 \
        -z0 \
        -i 0 \
        -c \
        -r \
        savedisk "$image_name" "$source_device"
}

Image Verification

# Verify image integrity after creation
verify_clonezilla_image() {
    local image_path=$1
    
    echo "Verifying image: $image_path"
    
    # Check image structure
    if [ -d "$image_path" ]; then
        echo "Image contents:"
        ls -la "$image_path/"
        
        # Look for indicator files (clonezilla creates these)
        if [ -f "$image_path/disk" ]; then
            echo "✓ Disk image detected (full disk)"
        elif [ -f "$image_path/parts" ]; then
            echo "✓ Partition image detected"
        fi
        
        # Check for disk info file
        if [ -f "$image_path/info-disk" ]; then
            echo "Disk information:"
            cat "$image_path/info-disk"
        fi
    else
        echo "Error: Image path not found"
        return 1
    fi
}

Network Cloning

SSH-Based Network Cloning

# Configure network storage for Clonezilla
configure_network_storage() {
    # On backup server: Create storage location
    mkdir -p /mnt/clonezilla-images
    chmod 755 /mnt/clonezilla-images
    
    # Generate SSH keys for automated access
    ssh-keygen -t rsa -N "" -f /root/.ssh/clonezilla_key
    
    # Copy public key to client
    # ssh-copy-id -i /root/.ssh/clonezilla_key.pub backup@client-server
}

# Clone to remote SSH server
clone_to_ssh_storage() {
    local remote_host="backup-server.example.com"
    local remote_user="backup"
    local remote_path="/mnt/clonezilla-images"
    local source_device="/dev/sda"
    local image_name="server-clone-$(date +%Y%m%d)"
    
    echo "Cloning to remote SSH storage"
    
    ocs-sr \
        -q2 \
        -j2 \
        -z1p \
        -i 2000 \
        -c \
        -r \
        -e1 auto \
        -e2 \
        -p true \
        -sfsck \
        savedisk "$image_name" "$source_device"
    
    # Transfer image via SSH
    echo "Transferring image to $remote_host"
    
    rsync -avz --progress \
        "/home/partimag/$image_name" \
        "$remote_user@$remote_host:$remote_path/"
}

# Clone from remote NFS
clone_from_nfs() {
    local nfs_server="nfs.example.com"
    local nfs_path="/export/clonezilla-images"
    local mount_point="/mnt/clonezilla-nfs"
    local image_name="server-backup-20240101"
    local target_device="/dev/sda"
    
    # Mount NFS storage
    mkdir -p "$mount_point"
    mount -t nfs "$nfs_server:$nfs_path" "$mount_point"
    
    # Restore from NFS image
    ocs-sr \
        -q2 \
        -j2 \
        -c \
        -r \
        -e1 auto \
        -e2 \
        -p reboot \
        restoredisk "$image_name" "$target_device"
}

SAMBA-Based Cloning

# Mount SAMBA share for image storage
setup_samba_cloning() {
    local samba_host="nas.example.com"
    local samba_share="clonezilla"
    local samba_user="backup_user"
    local mount_point="/mnt/clonezilla-samba"
    
    mkdir -p "$mount_point"
    
    # Mount SAMBA share
    mount -t cifs \
        "//$samba_host/$samba_share" \
        "$mount_point" \
        -o username="$samba_user",password="secure_password",uid=0,gid=0,file_mode=0755
    
    # Verify mount
    df -h "$mount_point"
}

# Store image on SAMBA via Clonezilla
clone_to_samba() {
    local samba_mount="/mnt/clonezilla-samba"
    local source_device="/dev/sda"
    local image_name="workstation-backup-$(date +%Y%m%d)"
    
    echo "Cloning to SAMBA storage at $samba_mount"
    
    ocs-sr \
        -q2 \
        -j2 \
        -z1p \
        -c \
        -r \
        savedisk "$image_name" "$source_device"
}

Multicast Cloning

Deploy a single image to multiple servers simultaneously using multicast streaming.

# Setup Clonezilla multicast server
setup_multicast_server() {
    local multicast_ip="224.0.0.1"
    local multicast_port="10001"
    local image_path="/mnt/images/prod-server-20240101"
    local source_device="/dev/sda"
    
    echo "Setting up Clonezilla multicast server"
    
    # Install required packages
    apt-get install -y drbl clonezilla
    
    # Configure multicast parameters
    cat > /etc/ocs/clonezilla-default << 'EOF'
# Multicast settings
DRBL_BRANCH="stable"
CLONEZILLA_MODE="full"
MULTICAST_PORT="10001"
MULTICAST_IP="224.0.0.1"
EOF
}

# Start multicast clone session
start_multicast_clone() {
    local image_name="production-server-20240101"
    local dest_devices="/dev/sda"
    
    echo "Starting multicast clone session"
    echo "Image: $image_name"
    echo "Devices: $dest_devices"
    echo "Waiting for clients to boot..."
    
    # Clients boot into Clonezilla via PXE
    # Select: device-image -> remote mode -> Multicast -> Join existing session
    
    # Monitor multicast session
    ocs-ondemand -m join multicast
}

Restoring from Images

Full Disk Restoration

# Restore entire disk from image
restore_full_disk() {
    local image_path="/mnt/clonezilla-images/prod-server-20240101"
    local target_device="/dev/sda"
    
    echo "WARNING: This will overwrite entire disk $target_device"
    read -p "Continue? (yes/no) " -r
    
    if [[ $REPLY != "yes" ]]; then
        echo "Cancelled"
        return 1
    fi
    
    echo "Restoring disk image..."
    
    ocs-sr \
        -q2 \
        -j2 \
        -c \
        -r \
        -e1 auto \
        -e2 \
        -p reboot \
        restoredisk "$image_path" "$target_device"
    
    if [ $? -eq 0 ]; then
        echo "Disk restoration completed - server rebooting"
    fi
}

# Restore with partition size adjustment
restore_with_resize() {
    local image_name="prod-server-backup"
    local target_device="/dev/sda"
    
    # "-e1 auto" automatically resizes partitions to fit target disk
    ocs-sr \
        -q2 \
        -c \
        -r \
        -e1 auto \
        -e2 \
        -p reboot \
        restoredisk "$image_name" "$target_device"
}

Partition-Level Restoration

# Restore specific partition
restore_partition() {
    local image_name="partition-root-backup"
    local target_partition="/dev/sda1"
    
    echo "Restoring partition $target_partition from image $image_name"
    
    ocs-sr \
        -q2 \
        -c \
        -r \
        -p true \
        restoreparts "$image_name" "$target_partition"
}

# Selective file recovery (mount and browse)
mount_image_for_recovery() {
    local image_path="/mnt/clonezilla-images/server-backup"
    local recovery_mount="/mnt/image-recovery"
    
    mkdir -p "$recovery_mount"
    
    # Get disk image info
    if [ -f "$image_path/disk" ]; then
        # Extract and mount filesystem
        # This process depends on image format and filesystem
        
        echo "Mounting image for file-level recovery"
        # Detailed mounting depends on specific image structure
    fi
}

PXE Boot Deployment

DRBL Server Setup

# Setup DRBL (Distributed Replicated Block Level) server
setup_drbl_server() {
    # Install DRBL packages
    apt-get install -y drbl clonezilla
    
    # Configure DRBL
    drblsrv-offline
    
    # Setup PXE boot
    drblpxeconfig -i
    
    # Configure DHCP
    cat > /etc/dhcp/dhcpd.conf << 'EOF'
subnet 10.0.0.0 netmask 255.255.255.0 {
    range 10.0.0.100 10.0.0.200;
    option routers 10.0.0.1;
    option domain-name-servers 10.0.0.1;
    
    # PXE boot configuration
    next-server 10.0.0.10;  # DRBL server IP
    filename "pxelinux.0";
}
EOF
    
    systemctl restart dhcp
}

# Configure image for PXE deployment
configure_pxe_image() {
    local image_name="prod-server-20240101"
    local drbl_server="/usr/lib/drbl/samples"
    
    # Place image in DRBL image directory
    cp -r "/mnt/clonezilla-images/$image_name" \
        "/opt/drbl/images/"
    
    # Configure DRBL to serve this image
    cat > /opt/drbl/images/$image_name/clonezilla.conf << 'EOF'
# Clonezilla deployment configuration
CLONEZILLA_MODE="full"
TARGET_IMAGE="prod-server-20240101"
RESTORE_MODE="auto"
SHUTDOWN_AFTER="no"
EOF
}

PXE Boot Client Configuration

# Configure clients for PXE boot
configure_pxe_client() {
    # In BIOS/UEFI: Set PXE/Network as primary boot device
    # Save and restart
    
    # Client boot sequence:
    # 1. Network interface requests DHCP
    # 2. DHCP server provides IP and PXE server address
    # 3. Client downloads pxelinux.0 bootloader
    # 4. Bootloader loads kernel and Clonezilla
    # 5. User selects restore image and target disk
    # 6. Image restores automatically
}

# Automated deployment via PXE
automate_pxe_deployment() {
    # Create unattended Clonezilla configuration
    cat > /opt/drbl/images/ocs/ocs-live.conf << 'EOF'
# Automated deployment settings
OCS_MODE="restore"
OCS_IMAGING_MODE="disk"
TARGET_IMAGE_NAME="prod-server-20240101"
TARGET_DISK="/dev/sda"
AUTO_SHUTDOWN="yes"
SKIP_CONFIRMATION="yes"
EOF
    
    # Clients configured to auto-restore from this image on boot
}

Automation and Scripting

Automated Daily Imaging

# Automated daily backup to network storage
cat > /usr/local/bin/daily-clonezilla-backup.sh << 'EOF'
#!/bin/bash

SOURCE_DEVICE="/dev/sda"
IMAGE_REPOSITORY="/mnt/clonezilla-images"
IMAGE_NAME="server-daily-$(date +%Y%m%d)"
RETENTION_DAYS=30
LOG_FILE="/var/log/clonezilla-backup.log"

echo "[$(date)] Starting Clonezilla backup" >> "$LOG_FILE"

# Ensure repository exists
mkdir -p "$IMAGE_REPOSITORY"

# Create backup
ocs-sr \
    -q2 \
    -j4 \
    -z1p \
    -i 0 \
    -c \
    -r \
    -e1 auto \
    -e2 \
    -p true \
    savedisk "$IMAGE_NAME" "$SOURCE_DEVICE" \
    >> "$LOG_FILE" 2>&1

if [ $? -eq 0 ]; then
    echo "[$(date)] Backup completed: $IMAGE_NAME" >> "$LOG_FILE"
    
    # Rotate old images (keep 30 days)
    find "$IMAGE_REPOSITORY" -maxdepth 1 -type d -mtime +$RETENTION_DAYS -exec rm -rf {} \;
    
    # Sync to offsite location
    rsync -avz --delete \
        "$IMAGE_REPOSITORY/" \
        [email protected]:/backups/clonezilla/ \
        >> "$LOG_FILE" 2>&1
else
    echo "[$(date)] Backup FAILED" >> "$LOG_FILE"
fi
EOF

chmod +x /usr/local/bin/daily-clonezilla-backup.sh

# Schedule daily backup
(crontab -l 2>/dev/null; echo "0 2 * * * /usr/local/bin/daily-clonezilla-backup.sh") | crontab -

Clonezilla Batch Operations

# Clone multiple servers to images
batch_image_servers() {
    local servers=("web01" "web02" "db01" "db02")
    local image_repository="/mnt/clonezilla-images"
    
    for server in "${servers[@]}"; do
        echo "Imaging $server..."
        
        # SSH to server and create image
        ssh "root@$server" << 'CMD'
mkdir -p /mnt/clonezilla-work
ocs-sr \
    -q2 \
    -j2 \
    -z1p \
    -c \
    -r \
    savedisk "$(hostname)-$(date +%Y%m%d)" "/dev/sda"
CMD
        
        # Transfer image back
        rsync -avz "root@$server:/home/partimag/" \
            "$image_repository/"
    done
}

# Restore images to multiple targets
batch_restore() {
    local image_name="prod-server-template"
    local target_hosts=("server03" "server04" "server05")
    
    for target in "${target_hosts[@]}"; do
        echo "Restoring $image_name to $target"
        
        # Boot target into Clonezilla
        # Execute restoration
        # Poll for completion
    done
}

Conclusion

Clonezilla provides enterprise-grade disk cloning and imaging capabilities:

  1. Bootable Media: Create USB or CD for immediate cloning needs
  2. Network Cloning: Integrate with SSH, NFS, or SAMBA for remote storage
  3. Multicast: Deploy single image to many servers simultaneously
  4. PXE Integration: Automate deployment via network boot
  5. Automation: Script daily imaging and disaster recovery procedures

Use Clonezilla for rapid server provisioning, disaster recovery, and infrastructure migrations. Combine with regular testing to ensure images restore correctly when needed.