Clonación de Servidor con Clonezilla

Clonezilla es una herramienta potente y gratuita de copia de seguridad y clonación de discos que permite el despliegue rápido de servidores, copias de seguridad y recuperación ante desastres. Esta guía integral cubre la creación de medios arrancables, imaginación de discos/particiones, clonación en red, distribución multicast y estrategias de despliegue basadas en PXE.

Tabla de Contenidos

1. Descripción General de Clonezilla
2. Crear Medios Arrancables de Clonezilla
3. Copia de Seguridad de Discos y Particiones
4. Clonación en Red
5. Clonación Multicast
6. Restauración desde Imágenes
7. Despliegue por PXE Boot
8. Automatización y Scripting
9. Conclusión

Descripción General de Clonezilla

Clonezilla proporciona:

• Clonación de discos: Replicación completa de servidor incluyendo tablas de partición y bootloaders
• Copia de seguridad de imágenes: Crear imágenes comprimidas para archivo y recuperación
• Modo de red: Clonar sobre LAN usando SSH, SAMBA o NFS
• Multicast: Clonar eficientemente una imagen a múltiples servidores simultáneamente
• PXE boot: Integrar con infraestructura existente para despliegue automatizado

Crear Medios Arrancables de Clonezilla

Descargar Clonezilla

# Descargar el ISO más reciente de Clonezilla
cd /tmp
wget https://sourceforge.net/projects/clonezilla/files/stable/clonezilla-live-*.iso

# Verificar integridad del archivo
sha256sum clonezilla-live-*.iso
# Comparar con checksum de la página del proyecto

# Listar imágenes disponibles
ls -lh clonezilla-live-*.iso

Crear Unidad USB Arrancable

# Identificar dispositivo USB (¡cuidado - esto sobrescribirá datos!)
lsblk

# Método 1: Usar dd (para sistemas Linux)
# ADVERTENCIA: Reemplazar sdX con tu identificador de dispositivo USB
USB_DEVICE="/dev/sdb"
ISO_FILE="clonezilla-live-3.1.0-13-amd64.iso"

# Desmontar el USB si ya está montado
sudo umount "${USB_DEVICE}"1

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

echo "Unidad USB creada en $USB_DEVICE"

# Método 2: Usar Etcher (más amigable)
# En macOS:
# brew install balena-etcher
# etcher select clonezilla-live-3.1.0-13-amd64.iso
# etcher select /dev/diskX
# etcher flash

# Método 3: Usar GNOME Disks GUI
# sudo apt install gnome-disk-utility
# gnome-disks

Crear CD/DVD Arrancable

# Para medios ópticos
ISO_FILE="clonezilla-live-3.1.0-13-amd64.iso"

# Usar growisofs (para DVD)
growisofs -dvd-compat -Z /dev/dvd="$ISO_FILE"

# Usar xorriso (más moderno)
xorriso -as cdrecord -v dev=/dev/cdrom -eject "$ISO_FILE"

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

Copia de Seguridad de Discos y Particiones

Imagen Completa de Disco

# Crear imagen de disco completo con dd
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 "Creando imagen de disco completo: $image_name"
    
    # Usar herramientas de línea de comandos de Clonezilla
    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 "Imagen de disco completo creada exitosamente"
        ls -lh "$image_path/$image_name"
    else
        echo "Error: Imaginación de disco fallida"
        return 1
    fi
}

# create_full_disk_image

Imagen a Nivel de Partición

# Crear imagen de partición específica solamente
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 "Creando imagen de partición: $image_name"
    
    # Para partición única
    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 "Imagen de partición creada: $image_path/$image_name"
    fi
}

# Opciones de compresión
# -z0: Sin compresión (más rápido, más grande)
# -z1: gzip (por defecto)
# -z9: Compresión máxima (más lento, más pequeño)

# Acelerar imaginación con procesamiento paralelo
create_fast_disk_image() {
    local source_device="/dev/sda"
    local image_path="/mnt/clonezilla-storage"
    local image_name="fast-backup-$(date +%Y%m%d)"
    
    # Usar procesamiento paralelo para clonación más rápida
    ocs-sr \
        -q2 \
        -j4 \
        -z0 \
        -i 0 \
        -c \
        -r \
        savedisk "$image_name" "$source_device"
}

Verificación de Imagen

# Verificar integridad de imagen después de la creación
verify_clonezilla_image() {
    local image_path=$1
    
    echo "Verificando imagen: $image_path"
    
    # Verificar estructura de imagen
    if [ -d "$image_path" ]; then
        echo "Contenido de imagen:"
        ls -la "$image_path/"
        
        # Buscar archivos indicadores (Clonezilla crea estos)
        if [ -f "$image_path/disk" ]; then
            echo "✓ Imagen de disco detectada (disco completo)"
        elif [ -f "$image_path/parts" ]; then
            echo "✓ Imagen de partición detectada"
        fi
        
        # Verificar archivo de información de disco
        if [ -f "$image_path/info-disk" ]; then
            echo "Información de disco:"
            cat "$image_path/info-disk"
        fi
    else
        echo "Error: Ruta de imagen no encontrada"
        return 1
    fi
}

Clonación en Red

Clonación Basada en SSH

# Configurar almacenamiento en red para Clonezilla
configure_network_storage() {
    # En servidor de copia de seguridad: Crear ubicación de almacenamiento
    mkdir -p /mnt/clonezilla-images
    chmod 755 /mnt/clonezilla-images
    
    # Generar claves SSH para acceso automatizado
    ssh-keygen -t rsa -N "" -f /root/.ssh/clonezilla_key
    
    # Copiar clave pública al cliente
    # ssh-copy-id -i /root/.ssh/clonezilla_key.pub backup@client-server
}

# Clonar a servidor SSH remoto
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 "Clonando a almacenamiento SSH remoto"
    
    ocs-sr \
        -q2 \
        -j2 \
        -z1p \
        -i 2000 \
        -c \
        -r \
        -e1 auto \
        -e2 \
        -p true \
        -sfsck \
        savedisk "$image_name" "$source_device"
    
    # Transferir imagen vía SSH
    echo "Transfiriendo imagen a $remote_host"
    
    rsync -avz --progress \
        "/home/partimag/$image_name" \
        "$remote_user@$remote_host:$remote_path/"
}

# Clonar desde NFS remoto
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"
    
    # Montar almacenamiento NFS
    mkdir -p "$mount_point"
    mount -t nfs "$nfs_server:$nfs_path" "$mount_point"
    
    # Restaurar desde imagen NFS
    ocs-sr \
        -q2 \
        -j2 \
        -c \
        -r \
        -e1 auto \
        -e2 \
        -p reboot \
        restoredisk "$image_name" "$target_device"
}

Clonación Basada en SAMBA

# Montar compartición SAMBA para almacenamiento de imágenes
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"
    
    # Montar compartición SAMBA
    mount -t cifs \
        "//$samba_host/$samba_share" \
        "$mount_point" \
        -o username="$samba_user",password="secure_password",uid=0,gid=0,file_mode=0755
    
    # Verificar montaje
    df -h "$mount_point"
}

# Almacenar imagen en SAMBA vía 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 "Clonando a almacenamiento SAMBA en $samba_mount"
    
    ocs-sr \
        -q2 \
        -j2 \
        -z1p \
        -c \
        -r \
        savedisk "$image_name" "$source_device"
}

Clonación Multicast

Desplegar una única imagen a múltiples servidores simultáneamente usando streaming multicast.

# Configurar servidor multicast de Clonezilla
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 "Configurando servidor multicast de Clonezilla"
    
    # Instalar paquetes requeridos
    apt-get install -y drbl clonezilla
    
    # Configurar parámetros multicast
    cat > /etc/ocs/clonezilla-default << 'EOF'
# Configuración multicast
DRBL_BRANCH="stable"
CLONEZILLA_MODE="full"
MULTICAST_PORT="10001"
MULTICAST_IP="224.0.0.1"
EOF
}

# Iniciar sesión de clonación multicast
start_multicast_clone() {
    local image_name="production-server-20240101"
    local dest_devices="/dev/sda"
    
    echo "Iniciando sesión de clonación multicast"
    echo "Imagen: $image_name"
    echo "Dispositivos: $dest_devices"
    echo "Esperando a clientes para arrancar..."
    
    # Los clientes arrancan en Clonezilla vía PXE
    # Seleccionar: device-image -> remote mode -> Multicast -> Join existing session
    
    # Monitorear sesión multicast
    ocs-ondemand -m join multicast
}

Restauración desde Imágenes

Restauración Completa de Disco

# Restaurar disco completo desde imagen
restore_full_disk() {
    local image_path="/mnt/clonezilla-images/prod-server-20240101"
    local target_device="/dev/sda"
    
    echo "ADVERTENCIA: Esto sobrescribirá disco completo $target_device"
    read -p "¿Continuar? (sí/no) " -r
    
    if [[ $REPLY != "yes" ]]; then
        echo "Cancelado"
        return 1
    fi
    
    echo "Restaurando imagen de disco..."
    
    ocs-sr \
        -q2 \
        -j2 \
        -c \
        -r \
        -e1 auto \
        -e2 \
        -p reboot \
        restoredisk "$image_path" "$target_device"
    
    if [ $? -eq 0 ]; then
        echo "Restauración de disco completada - servidor reiniciando"
    fi
}

# Restaurar con ajuste de tamaño de partición
restore_with_resize() {
    local image_name="prod-server-backup"
    local target_device="/dev/sda"
    
    # "-e1 auto" redimensiona automáticamente particiones para ajustar disco objetivo
    ocs-sr \
        -q2 \
        -c \
        -r \
        -e1 auto \
        -e2 \
        -p reboot \
        restoredisk "$image_name" "$target_device"
}

Restauración a Nivel de Partición

# Restaurar partición específica
restore_partition() {
    local image_name="partition-root-backup"
    local target_partition="/dev/sda1"
    
    echo "Restaurando partición $target_partition desde imagen $image_name"
    
    ocs-sr \
        -q2 \
        -c \
        -r \
        -p true \
        restoreparts "$image_name" "$target_partition"
}

# Recuperación selectiva de archivos (montar y explorar)
mount_image_for_recovery() {
    local image_path="/mnt/clonezilla-images/server-backup"
    local recovery_mount="/mnt/image-recovery"
    
    mkdir -p "$recovery_mount"
    
    # Obtener información de imagen de disco
    if [ -f "$image_path/disk" ]; then
        # Extraer y montar sistema de archivos
        # Este proceso depende de formato de imagen y sistema de archivos
        
        echo "Montando imagen para recuperación a nivel de archivo"
        # El montaje detallado depende de la estructura de imagen específica
    fi
}

Despliegue por PXE Boot

Configuración de Servidor DRBL

# Configurar servidor DRBL (Distributed Replicated Block Level)
setup_drbl_server() {
    # Instalar paquetes DRBL
    apt-get install -y drbl clonezilla
    
    # Configurar DRBL
    drblsrv-offline
    
    # Configurar PXE boot
    drblpxeconfig -i
    
    # Configurar 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;
    
    # Configuración de PXE boot
    next-server 10.0.0.10;  # IP del servidor DRBL
    filename "pxelinux.0";
}
EOF
    
    systemctl restart dhcp
}

# Configurar imagen para despliegue PXE
configure_pxe_image() {
    local image_name="prod-server-20240101"
    local drbl_server="/usr/lib/drbl/samples"
    
    # Colocar imagen en directorio de imágenes DRBL
    cp -r "/mnt/clonezilla-images/$image_name" \
        "/opt/drbl/images/"
    
    # Configurar DRBL para servir esta imagen
    cat > /opt/drbl/images/$image_name/clonezilla.conf << 'EOF'
# Configuración de despliegue de Clonezilla
CLONEZILLA_MODE="full"
TARGET_IMAGE="prod-server-20240101"
RESTORE_MODE="auto"
SHUTDOWN_AFTER="no"
EOF
}

Configuración de Cliente PXE Boot

# Configurar clientes para PXE boot
configure_pxe_client() {
    # En BIOS/UEFI: Establecer PXE/Red como dispositivo de arranque primario
    # Guardar y reiniciar
    
    # Secuencia de arranque del cliente:
    # 1. La interfaz de red solicita DHCP
    # 2. El servidor DHCP proporciona IP y dirección del servidor PXE
    # 3. El cliente descarga el bootloader pxelinux.0
    # 4. El bootloader carga kernel y Clonezilla
    # 5. El usuario selecciona imagen de restauración y disco objetivo
    # 6. La imagen se restaura automáticamente
}

# Despliegue automatizado vía PXE
automate_pxe_deployment() {
    # Crear configuración de Clonezilla no asistida
    cat > /opt/drbl/images/ocs/ocs-live.conf << 'EOF'
# Configuración de despliegue automatizado
OCS_MODE="restore"
OCS_IMAGING_MODE="disk"
TARGET_IMAGE_NAME="prod-server-20240101"
TARGET_DISK="/dev/sda"
AUTO_SHUTDOWN="yes"
SKIP_CONFIRMATION="yes"
EOF
    
    # Los clientes configurados para restauración automática desde esta imagen al arrancar
}

Automatización y Scripting

Copia de Seguridad Diaria Automatizada

# Copia de seguridad diaria automatizada a almacenamiento en red
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)] Iniciando copia de seguridad de Clonezilla" >> "$LOG_FILE"

# Asegurar que el repositorio existe
mkdir -p "$IMAGE_REPOSITORY"

# Crear copia de seguridad
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)] Copia de seguridad completada: $IMAGE_NAME" >> "$LOG_FILE"
    
    # Rotar imágenes antiguas (mantener 30 días)
    find "$IMAGE_REPOSITORY" -maxdepth 1 -type d -mtime +$RETENTION_DAYS -exec rm -rf {} \;
    
    # Sincronizar a ubicación remota
    rsync -avz --delete \
        "$IMAGE_REPOSITORY/" \
        [email protected]:/backups/clonezilla/ \
        >> "$LOG_FILE" 2>&1
else
    echo "[$(date)] Copia de seguridad FALLIDA" >> "$LOG_FILE"
fi
EOF

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

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

Operaciones por Lotes de Clonezilla

# Clonar múltiples servidores a imágenes
batch_image_servers() {
    local servers=("web01" "web02" "db01" "db02")
    local image_repository="/mnt/clonezilla-images"
    
    for server in "${servers[@]}"; do
        echo "Imaginando $server..."
        
        # SSH al servidor y crear imagen
        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
        
        # Transferir imagen de vuelta
        rsync -avz "root@$server:/home/partimag/" \
            "$image_repository/"
    done
}

# Restaurar imágenes a múltiples objetivos
batch_restore() {
    local image_name="prod-server-template"
    local target_hosts=("server03" "server04" "server05")
    
    for target in "${target_hosts[@]}"; do
        echo "Restaurando $image_name a $target"
        
        # Arrancar objetivo en Clonezilla
        # Ejecutar restauración
        # Esperar a completación
    done
}

Conclusión

Clonezilla proporciona capacidades de clonación y copia de seguridad de discos a nivel empresarial:

1. Medios Arrancables: Crear USB o CD para necesidades de clonación inmediata
2. Clonación en Red: Integrar con SSH, NFS o SAMBA para almacenamiento remoto
3. Multicast: Desplegar única imagen a múltiples servidores simultáneamente
4. Integración PXE: Automatizar despliegue vía arranque en red
5. Automatización: Script de imaginación diaria y procedimientos de recuperación ante desastres

Usar Clonezilla para provisión rápida de servidores, recuperación ante desastres e migraciones de infraestructura. Combinar con pruebas regulares para asegurar que las imágenes se restauren correctamente cuando sea necesario.