Cómo Crear un Script de Copia de Seguridad de Archivos Importantes en Linux

En un sistema Linux, hacer copias de seguridad regularmente es crucial para proteger tus datos, asegurar su integridad y facilitar la recuperación en caso de fallo. Tanto si trabajas con archivos personales, configuras un entorno de desarrollo o administras servidores, necesitas un plan de copias de seguridad fiable.

Una de las maneras más sencillas y flexibles de hacer copias de seguridad es escribiendo tu propio script, lo que te permite decidir qué copiar, cuándo y dónde almacenarlo. Esto también ahorra tiempo y reduce el riesgo de pérdida de datos.

En este artículo, aprenderás a crear un script de shell robusto que crea automáticamente copias de seguridad de tus archivos importantes, con manejo de errores, verificación de espacio en disco y opciones para copias incrementales.

Aprende también: Cómo hacer un back up del historial de terminal Linux

¿Por qué usar un script de copia de seguridad?

Usar un script de copia de seguridad en Linux ofrece a los administradores de sistemas más opciones y flexibilidad al proteger datos importantes.

Por eso es una buena idea:

• Copias de seguridad automáticas: Puedes programar la ejecución del script usando herramientas como cron, para que no tengas que hacer copias de seguridad manualmente.
• Control total: Tú decides qué incluir en las copias de seguridad, dónde guardarlas y con qué frecuencia. Ya sean copias diarias de /etc, instantáneas semanales de los directorios de inicio o simplemente directorios específicos.
• Robustez: Un script bien diseñado puede manejar errores, verificar recursos y optimizar el uso de espacio con copias incrementales.

Creando un script de copia de seguridad de archivos importantes

Abre una terminal y ve al directorio donde quieres guardar el script (por ejemplo, a tu directorio de inicio o /usr/local/bin/ para acceder desde todo el sistema).

Crea un archivo de script con un editor de texto como nano o vim:

nano backup_script.sh

A continuación, te mostramos un script mejorado que crea copias de seguridad comprimidas, verifica recursos y usa rsync para copias incrementales.

#!/bin/bash

# Define los directorios de origen y destino
SOURCE_DIR="/home/usuario/Documentos" # Directorio de origen para la copia de seguridad
BACKUP_DIR="/home/usuario/copias_seguridad" # Directorio de destino para las copias de seguridad
LOG_FILE="$BACKUP_DIR/backup_log.txt" # Archivo de log

# Crea una marca de tiempo para la copia de seguridad
TIMESTAMP=$(date +'%Y%m%d%H%M%S')

# Define el nombre del archivo de copia de seguridad comprimida
BACKUP_FILE="$BACKUP_DIR/backup_$TIMESTAMP.tar.gz"

# Verifica que el directorio de origen existe
if [ ! -d "$SOURCE_DIR" ]; then
    echo "Error: El directorio de origen $SOURCE_DIR no existe" >> "$LOG_FILE"
    exit 1
fi

# Verifica que el directorio de destino existe, si no, lo crea
if [ ! -d "$BACKUP_DIR" ]; then
    mkdir -p "$BACKUP_DIR" || { echo "Error: No se pudo crear $BACKUP_DIR" >> "$LOG_FILE"; exit 1; }
fi

# Verifica espacio disponible en el disco (mínimo 1 GB en bytes)
MIN_SPACE=$((1024*1024*1024))
AVAILABLE_SPACE=$(df --output=avail "$BACKUP_DIR" | tail -n 1)
if [ "$AVAILABLE_SPACE" -lt "$MIN_SPACE" ]; then
    echo "Error: Espacio insuficiente en $BACKUP_DIR" >> "$LOG_FILE"
    exit 1
fi

# Crea una copia incremental usando rsync
BACKUP_FOLDER="$BACKUP_DIR/backup_$TIMESTAMP"
mkdir -p "$BACKUP_FOLDER" || { echo "Error: No se pudo crear $BACKUP_FOLDER" >> "$LOG_FILE"; exit 1; }
rsync -a --delete "$SOURCE_DIR/" "$BACKUP_FOLDER" || { echo "Error: Fallo en rsync" >> "$LOG_FILE"; exit 1; }

# Comprime la copia de seguridad
tar -czf "$BACKUP_FILE" -C "$BACKUP_DIR" "backup_$TIMESTAMP" || { echo "Error: Fallo al crear $BACKUP_FILE" >> "$LOG_FILE"; exit 1; }

# Elimina la carpeta temporal de rsync
rm -rf "$BACKUP_FOLDER" || { echo "Error: No se pudo eliminar $BACKUP_FOLDER" >> "$LOG_FILE"; exit 1; }

# Registra en el log la finalización de la copia de seguridad
if [ -f "$BACKUP_FILE" ] && [ -s "$BACKUP_FILE" ]; then
    echo "Copia de seguridad comprimida creada a las $TIMESTAMP" >> "$LOG_FILE"
else
    echo "Error: La copia de seguridad $BACKUP_FILE no se creó correctamente" >> "$LOG_FILE"
    exit 1
fi

# Elimina copias de seguridad antiguas (más de 30 días)
find "$BACKUP_DIR" -type f -name "backup_*.tar.gz" -mtime +30 -exec rm -f {} \; || { echo "Error: No se pudieron eliminar copias antiguas" >> "$LOG_FILE"; }

Explicación del script:

• SOURCE_DIR: Directorio que contiene los archivos a copiar.
• BACKUP_DIR: Directorio donde se almacenarán las copias de seguridad.
• LOG_FILE: Archivo para registrar eventos y errores.
• Verificación de directorios: Se comprueba que SOURCE_DIR existe y se crea BACKUP_DIR si no está presente.
• Verificación de espacio: Se asegura que haya al menos 1 GB disponible en el disco antes de proceder.
• rsync -a --delete: Realiza una copia incremental, transfiriendo solo los cambios y eliminando archivos que ya no están en el origen.
• tar -czf: Comprime la copia en un archivo .tar.gz para ahorrar espacio.
• Manejo de errores: Cada comando crítico (mkdir, rsync, tar, rm) se verifica, y se registra un mensaje de error si falla.
• Limpieza: Se elimina la carpeta temporal creada por rsync tras la compresión.
• Log detallado: Se registra el éxito o fallo de la copia, incluyendo detalles específicos.
• find: Elimina copias de seguridad antiguas (más de 30 días) con manejo de errores.

Guarda y cierra el script (en nano, pulsa CTRL + X, luego Y para confirmar y pulsa Enter).

Haz el script ejecutable:

chmod +x backup_script.sh

Ejecuta el script manualmente para probarlo:

./backup_script.sh

Si está configurado correctamente, creará una copia de seguridad comprimida en BACKUP_DIR y registrará el resultado en LOG_FILE.

Programar el script de copia de seguridad con Cron

Para automatizar la copia de seguridad, usa cron, el programador de tareas de Linux.

Abre el archivo de configuración de cron:

crontab -e

Añade una tarea para ejecutar el script diariamente a las 2 de la madrugada:

0 2 * * * /ruta/completa/a/backup_script.sh

Nota: Usa la ruta absoluta del script (por ejemplo, /home/usuario/backup_script.sh) para evitar errores.

Verifica los logs de cron para confirmar que el script se ejecuta correctamente. En sistemas basados en Debian/Ubuntu, usa:

grep CRON /var/log/syslog

En sistemas basados en Red Hat/CentOS, revisa:

grep CRON /var/log/cron

Enviar la copia de seguridad a un servidor remoto con scp

Si quieres guardar las copias de seguridad en un servidor remoto (por ejemplo, en un VPS de respaldo o NAS), puedes cargar el archivo usando el comando scp.

Añade lo siguiente al final del script:

# Define la información del servidor remoto
REMOTE_USER="tu_usuario"
REMOTE_HOST="tu_ip_servidor"
REMOTE_DIR="/ruta/remota/de/copia/seguridad"

# Envía el archivo de copia de seguridad al servidor remoto
scp "$BACKUP_FILE" "$REMOTE_USER@$REMOTE_HOST:$REMOTE_DIR" || { echo "Error: Fallo al enviar $BACKUP_FILE a $REMOTE_HOST" >> "$LOG_FILE"; exit 1; }

Configura SSH: Genera una clave SSH con ssh-keygen y cópiala al servidor remoto con ssh-copy-id $REMOTE_USER@$REMOTE_HOST para autenticación sin contraseña.

Lee también: Mejores Prácticas de Seguridad para Mitigar Ataques de Secure Shell (SSH)

Conclusión

Crear un script de copia de seguridad en Linux es una manera sencilla y práctica de proteger tus datos contra pérdidas accidentales. Al programar la ejecución del script con cron, puedes automatizar el proceso de copia de seguridad para que tus archivos importantes se guarden regularmente sin necesidad de hacerlo manualmente.

Aprende también: Script Bash para obtener alerta de batería baja en Linux