Si administras servidores Linux o simplemente tienes un equipo con datos que no te puedes permitir perder, aprender a usar rsync para automatizar copias de seguridad es casi obligatorio. No hace falta montar una suite carÃsima ni depender de herramientas cerradas: con unos cuantos comandos bien pensados puedes tener un sistema de backups sólido, eficiente y fácil de mantener.
A lo largo de esta guÃa vas a ver desde lo más básico de rsync hasta montajes avanzados: copias locales, remotas por SSH, estilo Time Machine con snapshots, scripts listos para producción, cron, systemd timers, exclusiones, rotaciones y verificación. Consulta nuestra comparativa de métodos de copia de seguridad para decidir estrategia. La idea es que termines el artÃculo con un plan claro y comandos que puedas prácticamente copiar y adaptar a tu entorno.
Qué es rsync y por qué se usa tanto para backups
Rsync es una herramienta de lÃnea de comandos pensada para sincronizar archivos y directorios entre dos ubicaciones, ya sea en el mismo equipo o entre máquinas diferentes, normalmente a través de SSH o con su propio demonio rsyncd.
La gracia de rsync frente a un simple cp o un scp es que implementa un algoritmo inteligente de transferencia diferencial de bloques: compara origen y destino y solo envÃa los cambios, no el archivo entero cada vez. Si tienes muchos datos y solo se modifican pequeños trozos, el ahorro de tiempo y ancho de banda es brutal.
Además, rsync puede preservar prácticamente todos los metadatos: permisos, propietarios, grupos, marcas de tiempo, enlaces simbólicos, dispositivos… Por eso es tan útil para copias de seguridad «serias», donde no solo importa el contenido, sino también cómo está montado el sistema de ficheros.
Otra ventaja importante es que rsync funciona tanto localmente como en remoto: puedes usarlo para sincronizar dos carpetas del mismo servidor, para tirar de un servidor remoto a tu máquina de backup o para empujar datos a un NAS o a un VPS remoto usando SSH.
Instalar y comprobar rsync en distintas distribuciones
Aunque muchas distros ya traen rsync instalado, es buena idea verificar la instalación y actualizar a una versión reciente tanto en la máquina origen como en la de destino antes de montar tus copias automáticas.
En sistemas basados en Debian o Ubuntu puedes hacer algo tan sencillo como:
rsync --version
sudo apt update
sudo apt install rsync
En distribuciones tipo RHEL, CentOS, Rocky Linux u otras derivadas, el procedimiento serÃa muy similar, cambiando el gestor de paquetes pero con la misma idea de asegurar que rsync está disponible y al dÃa en ambos extremos.
rsync --version
sudo dnf install rsync # En sistemas modernos
sudo yum install rsync # En sistemas más antiguos
Opciones básicas de rsync que usarás todo el rato
Aunque rsync tiene un buen arsenal de parámetros, en la práctica para copias de seguridad vas a tirar el 90 % del tiempo de un conjunto pequeño de opciones que conviene memorizar.
La estructura general del comando es bastante directa, pero hay un detalle que da mucho juego: la barra final en las rutas cambia el comportamiento.
Sintaxis genérica:
rsync ORIGEN DESTINO
La diferencia clave está en cómo tratas el directorio origen:
# Copia el directorio como tal dentro del destino
rsync -av /source/dir /backup/
# Copia SOLO el contenido del directorio al destino
rsync -av /source/dir/ /backup/
Algunas de las opciones más usadas en backups son especialmente prácticas porque combinan muchas cosas en poco texto:
- -a: modo archivo. Equivale a -rlptgoD (recursivo, conserva enlaces simbólicos, permisos, tiempos, grupo, propietario y archivos especiales).
- -v: modo «verboso». Muestra qué está haciendo y qué ficheros va tocando.
- -z: comprime los datos durante la transferencia, ideal para copias remotas sobre Internet.
- -h: hace que los tamaños se vean «bonitos» (MB, GB…), perfecto para humanos.
- -P: combina progreso y archivos parciales, para ver cómo va la cosa y poder reanudar.
- –delete: borra en destino los archivos que ya no existen en origen, dejando una réplica exacta.
- -n / –dry-run: simula la ejecución sin tocar nada, fantástico para no liarla.
- –exclude / –exclude-from: permite excluir patrones o una lista completa de rutas que no quieres copiar.
- –link-dest: crea hard links con una copia anterior, base de los backups incrementales tipo Time Machine.
Copias locales manuales y primeros ejemplos
El primer paso antes de automatizar nada es tener comandos de copia manual claros y probados. Vamos a repasar casos tÃpicos que luego usaremos dentro de scripts.
Si quieres clonar tu directorio personal en un disco de respaldo local, el comando mÃnimo quedarÃa tal que asÃ:
rsync -av /home/usuario/ /mnt/disco_backup/usuario/
Este rsync recorre tu home completa preservando permisos, fechas y estructura, y solo copia lo que falte o haya cambiado desde la última vez, lo que ya es una copia incremental muy apañada sin complicarse la vida.
Otro caso clásico es sincronizar datos de proyectos, fotos o documentos entre dos carpetas del mismo servidor o incluso de discos diferentes, para tener un segundo juego local siempre fresquito.
rsync -av /media/fotos/ /backup/fotos/
Cuando se trata de datos sensibles del sistema, como /etc o /var/www, es normal querer una copia que sea un espejo exacto, eliminando del backup lo que desaparece en el origen. Ahà entra en juego la famosa opción de borrado.
rsync -av --delete /var/www/ /backup/www/
Backups remotos seguros con SSH
Donde rsync brilla de verdad es cuando lo combinas con SSH para mandar copias fuera del servidor, ya sea a otro nodo en tu red, a un NAS o a un VPS en Internet. De esta forma no dependes de un único equipo y cumples parte de la famosa regla 3-2-1 (al menos una copia fuera del sitio).
Lo ideal es configurar autenticación por clave pública en lugar de ir metiendo contraseñas a mano todo el rato. Una vez tengas la llave copiada al servidor de backup, los comandos se vuelven muy naturales.
# Empujar datos locales a un servidor remoto de backup
rsync -avz /etc/ backup@servidor-remoto:/backups/etc/
# Traer datos de un servidor remoto a tu máquina de respaldo
rsync -avz backup@servidor-remoto:/var/www/ /backups/www/
En escenarios un poco más finos, puedes ajustar cifrado, puerto o compresión de SSH desde el propio rsync con -e, por ejemplo si tu servidor escucha en otro puerto o quieres exprimir un enlace lento.
rsync -avz \
-e "ssh -p 2222 -c -o Compression=no" \
/origen/ backup@servidor-remoto:/destino/
Un truco útil cuando hay conexiones flojas o redes compartidas es utilizar –bwlimit para no saturar el enlace y no dejar a nadie sin Internet mientras lanzas un tocho de respaldo.
rsync -avz --bwlimit=5000 /datos/ backup@servidor-remoto:/backups/datos/
Copias completas, diferenciales e incrementales con rsync
Aunque rsync ya hace transferencias diferenciales a nivel de bloque, a nivel de estrategia de backup interesa pensar en tres tipos de copias: completas, diferenciales e incrementales, que puedes implementar directamente con opciones de rsync.
Una copia completa no tiene misterio: recrea todo el contenido del origen en el destino, ideal como backup inicial o para tener una referencia limpia.
# Copia completa de un árbol de directorios
rsync -a /ruta/origen/ /ruta/destino/
La copia diferencial se construye sobre esa base y se dedica a mantener el destino alineado con el origen, copiando cambios y eliminando lo que ya no existe. Es lo que sueles querer cuando hablas de tener un espejo del sistema.
# Copia diferencial, manteniendo el destino idéntico al origen
rsync -a --delete /ruta/origen/ /ruta/destino/
La parte más jugosa es la copia incremental «de verdad», donde además de sincronizar, guardas historiales por fecha sin duplicar datos. Aquà entra en juego la opción –link-dest, que crea hard links contra una copia previa para los archivos que no han cambiado.
# Copia incremental apoyada en una copia previa
rsync -a --link-dest=/ruta/a/copiaprevia \
/ruta/origen/ /ruta/destino-incremental/
Con este enfoque, cada carpeta de respaldo parece una copia completa, pero internamente los archivos idénticos comparten bloques en disco, lo que reduce muchÃsimo el espacio usado y permite navegar por snapshots históricos de manera simple.
Backups estilo Time Machine con snapshots y hard links
Mucha gente quiere replicar en Linux la comodidad de Time Machine de macOS con sus snapshots por fecha. Con rsync es perfectamente posible combinando –link-dest, un poco de shell y algo de organización.
La idea es mantener un directorio current que apunta al último respaldo bueno, y al mismo tiempo ir creando carpetas con timestamp (fecha-hora) que representan cada snapshot. Los archivos sin cambios se enlazan con hard links al snapshot anterior y solo se escriben bloques nuevos cuando realmente hay diferencias.
Un comando tÃpico en ese esquema podrÃa ser algo como:
rsync -avPh --delete \
--link-dest="$TARGETDIR/current" \
"$SOURCEDIR/$USER/" \
"$TARGETDIR/$USER-$TIMESTAMP"
Luego un script se encarga de actualizar el enlace simbólico current para que siempre apunte al último snapshot, y de mantener un pequeño historial ordenado por fecha. Con eso puedes navegar por copias antiguas simplemente entrando a la carpeta que te interese.
La automatización viene sola: guardas el script en algo tipo /usr/local/bin/rsync-time-machine y lo programas para que se ejecute a diario con cron a la hora que mejor te venga.
0 5 * * * bash /usr/local/bin/rsync-time-machine
Automatizar copias con cron en el dÃa a dÃa
Llega un punto en el que hacer las copias a mano deja de tener sentido; lo normal es programar los backups con cron para que se ejecuten solos a horas valle (de madrugada, por ejemplo) y olvidarte salvo para revisar los logs de vez en cuando.
La mecánica es siempre la misma: preparas un script que haga la copia completa con todas las opciones (exclusiones, logs, etc.), le das permisos de ejecución y lo enchufas a crontab del usuario adecuado o al root si toca tocar todo el sistema.
Un ejemplo de script sencillo para copia local podrÃa ser:
#!/bin/bash
SOURCE_DIR="/home"
BACKUP_DIR="/backup/home"
LOG_FILE="/var/log/backup/rsync-local.log"
DATE=$(date +"%Y-%m-%d %H:%M:%S")
mkdir -p «$BACKUP_DIR» «$(dirname «$LOG_FILE»)»
echo » Inicio de backup local» >> «$LOG_FILE»
rsync -av –delete \
–exclude=’*.tmp’ \
–exclude=’.cache’ \
–exclude=’Downloads/*’ \
«$SOURCE_DIR/» «$BACKUP_DIR/» >> «$LOG_FILE» 2>&1
if ; then
echo » Backup completado correctamente» >> «$LOG_FILE»
else
echo » Backup con errores» >> «$LOG_FILE»
fi
Una vez tengas el script en, por ejemplo, /usr/local/bin/rsync-local-backup.sh y marcado como ejecutable, lo añades a cron para que se lance a una hora concreta.
sudo chmod +x /usr/local/bin/rsync-local-backup.sh
sudo crontab -e
Dentro de crontab podrÃas poner algo como:
0 2 * * * /usr/local/bin/rsync-local-backup.sh
Timers de systemd: una alternativa moderna a cron
En sistemas modernos muchas veces merece la pena usar systemd timers en lugar de cron, sobre todo si quieres integrar mejor los servicios, gestionar dependencias de red o tener logs centralizados en journalctl.
La idea es definir un servicio que ejecute tu script de backup y un timer que indique cuándo lanzarlo. El servicio podrÃa ser algo como:
Description=Rsync Backup Service
After=network-online.target
Wants=network-online.target
Type=oneshot
ExecStart=/usr/local/bin/rsync-remote-backup.sh
User=root
StandardOutput=journal
StandardError=journal
TimeoutSec=7200
WantedBy=multi-user.target
Y el timer asociado se definirÃa asÃ, para un backup diario a las 2 de la mañana con algo de aleatoriedad para no saturar todo a la vez:
Description=Daily Rsync Backup Timer
Requires=rsync-backup.service
OnCalendar=*-*-* 02:00:00
Persistent=true
RandomizedDelaySec=10min
WantedBy=timers.target
Con eso ya solo queda recargar systemd, activar el timer y comprobar que se programa correctamente y que el log del servicio muestra que las copias se lanzan cuando toca.
sudo systemctl daemon-reload
sudo systemctl enable --now rsync-backup.timer
systemctl list-timers
journalctl -u rsync-backup.service
Organizar backups rotativos: diarios, semanales y mensuales
Si quieres algo un poco más currado que una única copia fija, puedes montar una estructura de backups rotativos: diarios, semanales y mensuales, usando enlaces duros para ahorrar espacio y find para limpiar lo viejo.
Un patrón clásico consiste en tener un directorio current que se actualiza cada vez con rsync y luego clonar ese árbol con hard links hacia carpetas daily, weekly y monthly según el dÃa.
#!/bin/bash
SOURCE_DIR="/var/www"
BACKUP_ROOT="/backup/www"
CURRENT="$BACKUP_ROOT/current"
DAILY="$BACKUP_ROOT/daily"
WEEKLY="$BACKUP_ROOT/weekly"
MONTHLY="$BACKUP_ROOT/monthly"
DATE=$(date +%Y%m%d)
DOW=$(date +%u)
DOM=$(date +%d)
mkdir -p «$CURRENT» «$DAILY» «$WEEKLY» «$MONTHLY»
rsync -av –delete –link-dest=»$CURRENT» \
«$SOURCE_DIR/» «$CURRENT/»
&& cp -al «$CURRENT» «$DAILY/$DATE»
&& cp -al «$CURRENT» «$WEEKLY/$DATE»
&& cp -al «$CURRENT» «$MONTHLY/$DATE»
find «$DAILY» -maxdepth 1 -type d -mtime +7 -exec rm -rf {} \;
find «$WEEKLY» -maxdepth 1 -type d -mtime +28 -exec rm -rf {} \;
find «$MONTHLY» -maxdepth 1 -type d -mtime +365 -exec rm -rf {} \;
Con este sistema tienes una ventana histórica bastante razonable sin llenar el disco de copias completas, y cada snapshot sigue siendo navegable como una carpeta normal.
Si tus datos cambian rápido o son muy pesados, puedes ajustar dÃas de retención, frecuencias o incluso combinar esto con snapshots de LVM o ZFS para garantizar consistencia de bases de datos o máquinas virtuales.
Monitorizar, verificar y saber si tus copias sirven para algo
Tener tareas de backup ejecutándose a diario está muy bien, pero si nadie comprueba el resultado no te sirve de mucho. Es importante montar un mÃnimo de monitorización para saber si la última copia se hizo y cuándo.
Una táctica sencilla es dejar un pequeño marcador en la carpeta de destino cada vez que una copia termina bien, por ejemplo un archivo .last-backup-success con la fecha. Luego un script externo, o incluso una comprobación de Nagios/Icinga, puede alertar si ese archivo es demasiado antiguo.
MARKER="/backup/www/.last-backup-success"
if ; then
echo "Marcador de backup no encontrado"
exit 1
fi
Otra costumbre sana es revisar los logs de rsync en busca de errores o tasas de transferencia raras. Un script que extraiga estadÃsticas de «Number of files», «Total size», «Speedup» y similares te da una foto rápida de cómo van las cosas.
Y, por supuesto, lo que realmente marca la diferencia es que te acostumbres cada cierto tiempo a hacer una restauración real: coge un archivo concreto, recupera una versión de ayer o de la semana pasada y comprueba que abre bien. Es la única forma de tener la seguridad de que, si un dÃa todo sale mal, tus copias de seguridad estarán a la altura.
Si vas consolidando todas estas piezas —un rsync bien configurado, automatización con cron o systemd, rotación sensata, monitorización y pruebas de restauración— acabarás con un sistema de backups en Linux sólido, flexible y barato, que aprovecha al máximo las bondades del software libre sin obligarte a renunciar a comodidad ni a fiabilidad.
