Rotación de copias en Bash: retención e integridad
Automatiza la rotación de copias en Bash con archivos diarios, semanales y mensuales, retención, cifrado y verificación de integridad.
Visión General
Una copia programada puede fallar de dos formas: el archivo puede ser ilegible o la limpieza puede borrar la última copia útil. Esta receta crea archivos tar.gz con fecha, conserva niveles diarios, semanales y mensuales, comprueba cada archivo nuevo antes de publicarlo y solo entonces elimina los antiguos.
Cuándo Usar
Este flujo encaja en un servidor Linux que necesita:
- Conserva puntos diarios y promueve algunas copias a niveles semanales o mensuales.
- Comprime archivos para reducir el espacio de cada copia completa.
- Detén la limpieza si falla la creación o la comprobación del archivo nuevo.
- Añade cifrado o almacenamiento remoto sin cambiar la política local de rotación.
Este método con tar no sustituye los volcados propios de una base de datos ni las instantáneas del sistema de archivos cuando necesitas una captura transaccionalmente coherente.
Solución
Copias de seguridad en Bash con rotación por niveles
#!/usr/bin/env bash
set -euo pipefail
SOURCE_DIR="${1:-/var/app/data}"
BACKUP_DIR="${2:-/var/backups/app}"
DAILY_RETENTION=7
WEEKLY_RETENTION=4
MONTHLY_RETENTION=3
if [[ ! -d "$SOURCE_DIR" ]]; then
echo "ERROR: No existe el directorio de origen: $SOURCE_DIR" >&2
exit 1
fi
mkdir -p "$BACKUP_DIR/daily" "$BACKUP_DIR/weekly" "$BACKUP_DIR/monthly"
TODAY=$(date +%Y-%m-%d)
DAY_OF_WEEK=$(date +%u)
DAY_OF_MONTH=$(date +%d)
ARCHIVE="$BACKUP_DIR/daily/app-$TODAY.tar.gz"
TEMP_ARCHIVE=$(mktemp "$BACKUP_DIR/daily/.app-$TODAY.XXXXXX")
trap 'rm -f -- "$TEMP_ARCHIVE"' EXIT
# Crear y probar el archivo temporal antes de reemplazar la copia del día
tar -czf "$TEMP_ARCHIVE" -C "$(dirname "$SOURCE_DIR")" "$(basename "$SOURCE_DIR")"
tar -tzf "$TEMP_ARCHIVE" > /dev/null
mv -f -- "$TEMP_ARCHIVE" "$ARCHIVE"
trap - EXIT
# Promover a semanal los domingos
if [[ "$DAY_OF_WEEK" == "7" ]]; then
cp "$ARCHIVE" "$BACKUP_DIR/weekly/app-week-$TODAY.tar.gz"
fi
# Promover a mensual el primer día del mes
if [[ "$DAY_OF_MONTH" == "01" ]]; then
cp "$ARCHIVE" "$BACKUP_DIR/monthly/app-month-$TODAY.tar.gz"
fi
# Eliminar copias antiguas
find "$BACKUP_DIR/daily" -maxdepth 1 -type f -mtime "+$DAILY_RETENTION" -delete
find "$BACKUP_DIR/weekly" -maxdepth 1 -type f -mtime "+$((WEEKLY_RETENTION * 7))" -delete
find "$BACKUP_DIR/monthly" -maxdepth 1 -type f -mtime "+$((MONTHLY_RETENTION * 30))" -delete
echo "Copia completada: $ARCHIVE"
Explicación
Este esquema escalonado diario/semanal/mensual es la clásica rotación GFS (grandfather-father-son): el nivel hijo guarda copias recientes granulares y los archivos semanales/mensuales conservan puntos de recuperación a largo plazo.
El script escribe primero en un archivo temporal dentro de daily y lo lista con tar -tzf antes de moverlo a su nombre definitivo. Como ambos archivos están en el mismo sistema de archivos, el cambio de nombre no deja visible una copia diaria incompleta. Con set -euo pipefail, cualquier fallo al crear, probar o promocionar el archivo detiene el script antes de la limpieza.
Los domingos y el primer día del mes, el archivo diario comprobado se copia a sus niveles de retención. Esas copias consumen espacio adicional: no se deduplican. find -mtime cuenta periodos completos de 24 horas; por eso, “7 días” es un límite por antigüedad, no una garantía de conservar días naturales.
Variantes
Archivos complementarios: todos estos scripts están en el repositorio complementario de bash-backup-rotation-script, un .sh ejecutable por variante. El flujo con archivos tar favorece copias completas y fáciles de mover. Usa la variante con rsync cuando la mayoría de los archivos no cambie; usa S3 para guardar una copia fuera del servidor. Mantén la limpieza local independiente para que una caída del servicio remoto no active el borrado local.
| Nivel | Promoción | Ajuste de retención | Efecto en almacenamiento |
|---|---|---|---|
| Diario | Cada ejecución correcta | DAILY_RETENTION días | Un archivo comprimido por fecha |
| Semanal | Copia los domingos | WEEKLY_RETENTION × 7 días | Una copia completa adicional |
| Mensual | Copia el día 1 | MONTHLY_RETENTION × 30 días | Aproximación a meses; copia completa adicional |
| Remoto | Carga tras validar el archivo local | Política de ciclo de vida de S3 | Copia remota y coste de almacenamiento aparte |
Los límites de find -mtime se basan en la antigüedad, no en el número de fechas del calendario. Si necesitas conservar exactamente N copias, rota por nombres ordenados y prueba los cambios de mes y las ejecuciones omitidas.
Copia cifrada con GPG
#!/usr/bin/env bash
set -euo pipefail
SOURCE_DIR="${1:-/var/app/data}"
BACKUP_DIR="${2:-/var/backups/app}"
GPG_RECIPIENT="${3:-admin@example.com}"
RETENTION_DAYS=30
# Sustituye el ejemplo por la huella de la clave pública del destinatario.
mkdir -p "$BACKUP_DIR/encrypted"
TODAY=$(date +%Y-%m-%d)
ARCHIVE="$BACKUP_DIR/encrypted/app-$TODAY.tar.gz.gpg"
TEMP_ARCHIVE=$(mktemp "$BACKUP_DIR/encrypted/.app-$TODAY.XXXXXX")
trap 'rm -f -- "$TEMP_ARCHIVE"' EXIT
# Crear y cifrar la copia en una tubería (sin guardar un archivo sin cifrar)
tar -czf - -C "$(dirname "$SOURCE_DIR")" "$(basename "$SOURCE_DIR")" | \
gpg --encrypt --recipient "$GPG_RECIPIENT" --output "$TEMP_ARCHIVE"
# Comprobar que GPG puede leer las cabeceras; no sustituye una restauración.
if ! gpg --list-packets "$TEMP_ARCHIVE" > /dev/null 2>&1; then
echo "ERROR: Falló la comprobación del archivo cifrado" >&2
exit 1
fi
mv -f -- "$TEMP_ARCHIVE" "$ARCHIVE"
trap - EXIT
echo "[$(date -Iseconds)] Copia cifrada creada: $ARCHIVE"
# Eliminar archivos cifrados antiguos solo después de comprobar el nuevo.
find "$BACKUP_DIR/encrypted" -name '*.gpg' -type f -mtime "+$RETENTION_DAYS" -delete
# Descifrar para restaurar:
# gpg --decrypt app-2026-01-15.tar.gz.gpg | tar -xzf - -C /restore/path
Instantáneas incrementales con rsync
#!/usr/bin/env bash
set -euo pipefail
SOURCE_DIR="${1:-/var/app/data}"
BACKUP_DIR="${2:-/var/backups/rsync}"
SNAPSHOT_COUNT=7
mkdir -p "$BACKUP_DIR"
TODAY=$(date +%Y-%m-%d)
CURRENT_SNAPSHOT="$BACKUP_DIR/snapshot-$TODAY"
# Los nombres usan fechas ISO, así que el orden alfabético es cronológico.
# En la primera ejecución no hay --link-dest; cada destino es una instantánea independiente.
LAST_SNAPSHOT=""
for snapshot in "$BACKUP_DIR"/snapshot-*/; do
[[ -d "$snapshot" ]] || continue
snapshot="${snapshot%/}"
if [[ "$snapshot" != "$CURRENT_SNAPSHOT" ]]; then
if [[ -z "$LAST_SNAPSHOT" || "$snapshot" > "$LAST_SNAPSHOT" ]]; then
LAST_SNAPSHOT="$snapshot"
fi
fi
done
RSYNC_ARGS=(-a --delete)
if [[ -n "$LAST_SNAPSHOT" ]]; then
RSYNC_ARGS+=(--link-dest="$LAST_SNAPSHOT")
fi
rsync "${RSYNC_ARGS[@]}" "$SOURCE_DIR/" "$CURRENT_SNAPSHOT/"
# Comprobar el tamaño y el número de archivos de la instantánea
SNAPSHOT_SIZE=$(du -sh "$CURRENT_SNAPSHOT" | cut -f1)
FILE_COUNT=$(find "$CURRENT_SNAPSHOT" -type f | wc -l)
echo "[$(date -Iseconds)] Instantánea creada: $CURRENT_SNAPSHOT ($FILE_COUNT archivos, $SNAPSHOT_SIZE)"
# Rotar instantáneas fechadas sin dividir las rutas que contienen espacios.
snapshots=()
snapshot_count=0
for snapshot in "$BACKUP_DIR"/snapshot-*/; do
[[ -d "$snapshot" ]] || continue
snapshots[snapshot_count]="${snapshot%/}"
snapshot_count=$((snapshot_count + 1))
done
if (( snapshot_count > SNAPSHOT_COUNT )); then
remove_count=$((snapshot_count - SNAPSHOT_COUNT))
for ((i = 0; i < remove_count; i++)); do
snapshot="${snapshots[i]}"
rm -r -- "$snapshot"
echo "[$(date -Iseconds)] Instantánea antigua eliminada: $snapshot"
done
fi
# Reporte de uso de disco
TOTAL_SIZE=$(du -sh "$BACKUP_DIR" | cut -f1)
echo "[$(date -Iseconds)] Tamaño total de las copias: $TOTAL_SIZE"
Carga a S3 con validación de checksum
El ejemplo usa el checksum de la solicitud de AWS CLI en vez de comparar el objeto con metadata independiente. Para configurar perfiles y credenciales, consulta Scripts de Bash para AWS CLI.
#!/usr/bin/env bash
set -euo pipefail
BACKUP_DIR="${1:-/var/backups/app}"
S3_BUCKET="${2:-my-app-backups}"
S3_PREFIX="${3:-daily}"
TODAY=$(date +%Y-%m-%d)
ARCHIVE="$BACKUP_DIR/daily/app-$TODAY.tar.gz"
# La CLI de AWS envía una suma SHA-256; S3 rechaza la carga si no coincide.
# No la compares con metadatos propios: son campos distintos.
aws s3 cp "$ARCHIVE" "s3://$S3_BUCKET/$S3_PREFIX/app-$TODAY.tar.gz" \
--checksum-algorithm SHA256 \
--metadata "created=$(date -I),host=$(hostname)" \
--no-progress
# Listar copias recientes en S3
echo "=== Copias recientes en S3 ==="
aws s3 ls "s3://$S3_BUCKET/$S3_PREFIX/" --recursive | tail -10
Configura el ciclo de vida de S3 por separado del trabajo diario. La API put-bucket-lifecycle-configuration reemplaza toda la política del bucket; consulta y combina las reglas existentes antes de aplicar otra.
Comprobación de integridad de los archivos
#!/usr/bin/env bash
set -euo pipefail
BACKUP_DIR="${1:-/var/backups/app}"
echo "[$(date -Iseconds)] Iniciando comprobación de archivos..."
FAILURES=0
for archive in "$BACKUP_DIR"/daily/*.tar.gz; do
[[ -f "$archive" ]] || continue
filename=$(basename "$archive")
# Listar lee el flujo comprimido y las cabeceras tar; no sustituye una restauración.
if ! tar -tzf "$archive" > /dev/null 2>&1; then
echo "FALLO: $filename — archivo tar dañado"
FAILURES=$((FAILURES + 1))
continue
fi
# Verificar conteo de archivos en el archivo
FILE_COUNT=$(tar -tzf "$archive" | wc -l)
ARCHIVE_SIZE=$(du -h "$archive" | cut -f1)
echo "OK: $filename — $FILE_COUNT archivos, $ARCHIVE_SIZE"
done
if (( FAILURES > 0 )); then
echo "[$(date -Iseconds)] Comprobación FALLIDA: $FAILURES archivos dañados"
exit 1
fi
echo "[$(date -Iseconds)] Todos los archivos pasaron la comprobación de lectura"
Gestión de copias con Python, shutil y tarfile
import shutil
import tarfile
from datetime import datetime
from pathlib import Path
class BackupManager:
"""Gestiona copias con retención diaria, semanal y mensual."""
def __init__(self, source: str, backup_dir: str,
daily_retention: int = 7,
weekly_retention: int = 4,
monthly_retention: int = 3):
self.source = Path(source)
self.backup_dir = Path(backup_dir)
self.daily_retention = daily_retention
self.weekly_retention = weekly_retention
self.monthly_retention = monthly_retention
for subdir in ['daily', 'weekly', 'monthly']:
(self.backup_dir / subdir).mkdir(parents=True, exist_ok=True)
def create_backup(self) -> Path:
today = datetime.now().strftime('%Y-%m-%d')
archive_path = self.backup_dir / 'daily' / f'app-{today}.tar.gz'
with tarfile.open(archive_path, 'w:gz') as tar:
tar.add(self.source, arcname=self.source.name)
self._promote_backups(today)
self._cleanup_old_backups()
return archive_path
def _promote_backups(self, today: str) -> None:
now = datetime.now()
if now.weekday() == 6: # Domingo
shutil.copy2(
self.backup_dir / 'daily' / f'app-{today}.tar.gz',
self.backup_dir / 'weekly' / f'app-week-{today}.tar.gz'
)
if now.day == 1:
shutil.copy2(
self.backup_dir / 'daily' / f'app-{today}.tar.gz',
self.backup_dir / 'monthly' / f'app-month-{today}.tar.gz'
)
def _cleanup_old_backups(self) -> None:
cutoff = datetime.now()
for subdir, retention in [
('daily', self.daily_retention),
('weekly', self.weekly_retention * 7),
('monthly', self.monthly_retention * 30),
]:
dir_path = self.backup_dir / subdir
for archive in dir_path.glob('*.tar.gz'):
age = (cutoff - datetime.fromtimestamp(archive.stat().st_mtime)).days
if age > retention:
archive.unlink()
print(f"Copia antigua eliminada: {archive.name} ({age} días)")
def verify_backup(self, archive_path: Path) -> bool:
try:
with tarfile.open(archive_path, 'r:gz') as tar:
members = tar.getmembers()
return len(members) > 0
except (tarfile.TarError, EOFError) as e:
print(f"Falló la comprobación de la copia: {e}")
return False
# Ejemplo de uso
manager = BackupManager('/var/app/data', '/var/backups/app')
archive = manager.create_backup()
if manager.verify_backup(archive):
print(f"Copia creada y comprobada: {archive}")
else:
print("¡Falló la comprobación de la copia!")
Backup de base de datos con pg_dump
#!/usr/bin/env bash
set -euo pipefail
DB_NAME="myapp"
DB_USER="postgres" # expects ~/.pgpass or PGUSER auth — no password prompt in cron
BACKUP_DIR="/backups/db"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
DUMP_FILE="${BACKUP_DIR}/db_${TIMESTAMP}.sql.gz"
mkdir -p "${BACKUP_DIR}"
# pipefail makes the pipeline fail if pg_dump fails, not just gzip
pg_dump -U "${DB_USER}" -w "${DB_NAME}" | gzip > "${DUMP_FILE}"
gzip -t "${DUMP_FILE}"
# Keep last 14 days — only runs when the dump above succeeded
find "${BACKUP_DIR}" -name "db_*.sql.gz" -type f -mtime +14 -delete
echo "Database backup created: db_${TIMESTAMP}.sql.gz"
Para MySQL usa mysqldump --single-transaction — produce un snapshot consistente de InnoDB sin el antipatrón FLUSH TABLES WITH READ LOCK (un lock de mysql -e se libera en cuanto ese cliente sale).
Script de restauración
#!/usr/bin/env bash
set -euo pipefail
# restore-backup.sh — extrae un archivo en un directorio vacío para inspección
BACKUP_FILE="${1:?Usage: $0 <backup_file>}"
RESTORE_DIR="/tmp/restore"
mkdir -p "${RESTORE_DIR}"
if [[ "$BACKUP_FILE" == *.gpg ]]; then
gpg -d "${BACKUP_FILE}" | tar -xzf - -C "${RESTORE_DIR}"
else
tar -xzf "${BACKUP_FILE}" -C "${RESTORE_DIR}"
fi
echo "Restaurado en ${RESTORE_DIR} — verifica el árbol antes de copiar nada sobre datos en vivo"
Programación con cron
# Run daily at 2 AM, append output to a log
0 2 * * * /opt/scripts/backup.sh >> /var/log/backup.log 2>&1
# Alert by mail on failure
0 2 * * * /opt/scripts/backup.sh || echo "Backup failed" | mail -s "Backup Alert" admin@example.com
Chequeo de espacio en disco antes del backup
#!/usr/bin/env bash
set -euo pipefail
BACKUP_DIR="/backups"
SOURCE_DIR="/var/www/myapp"
mkdir -p "${BACKUP_DIR}" # df falla si el directorio no existe — créalo primero
# df -kP es POSIX: kilobytes en GNU y BSD, una línea de salida
available_kb=$(df -kP "${BACKUP_DIR}" | awk 'NR==2 {print $4}')
required_kb=$(du -sk "${SOURCE_DIR}" | awk '{print $1}')
available_gb=$((available_kb / 1024 / 1024))
if [ "$available_kb" -lt "$required_kb" ]; then
echo "ERROR: solo ${available_gb}GB libres en ${BACKUP_DIR}, la fuente necesita $((required_kb / 1024 / 1024))GB"
exit 1
fi
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
tar -czf "${BACKUP_DIR}/backup_${TIMESTAMP}.tar.gz" -C "${SOURCE_DIR}" .
echo "Backup creado con ${available_gb}GB de espacio libre"
Acelerar backups grandes
# pigz comprime usando todos los núcleos (solo GNU tar — bsdtar no tiene -I)
tar -I pigz -cf "${BACKUP_FILE}" -C "${SOURCE_DIR}" .
# Skip caches, logs, and temp files
tar -czf "${BACKUP_FILE}" --exclude="*.log" --exclude="*.tmp" --exclude="cache/*" --exclude="node_modules/*" -C "${SOURCE_DIR}" .
# No dejes que el backup ahogue la I/O de producción
ionice -c 3 tar -czf "${BACKUP_FILE}" -C "${SOURCE_DIR}" .
Mejores Prácticas
- Prueba las restauraciones, no solo el listado del archivo. Un tar legible puede contener datos equivocados; compara el árbol restaurado y sus permisos con los valores esperados.
- Guarda una copia fuera del host de origen. Otro directorio del mismo disco desaparece si falla el disco; usa otro host o una cuenta de almacenamiento aparte.
- Cifra antes de subir datos sensibles. Usa GPG con la clave pública del destinatario; no dejes el correo de ejemplo sin cambiar.
- Protege los niveles de retención contra el borrado. Object Lock o un destino de solo anexado reduce el impacto si se comprometen las credenciales del host.
- Avisa tanto de fallos como de ejecuciones omitidas. Conserva el log y supervisa el código de salida y la fecha de la última copia correcta.
Errores Comunes
- Borrar copias antes de validar la nueva. Crea y lista el archivo nuevo antes de ejecutar cualquier limpieza.
- Guardar las copias en el mismo disco que el origen. Un fallo de disco destruye tanto los datos como sus copias.
- Usar solo la fecha si el trabajo puede correr más de una vez al día. Añade la hora o un identificador de ejecución para no sobrescribir el archivo anterior.
- Ignorar códigos de salida. Si tar falla pero la limpieza continúa,
find -deletepuede borrar copias anteriores sin reemplazarlas. - Ejecutar como root sin necesidad. Una cuenta de servicio dedicada limita el daño si se compromete el programador; dale lectura al origen y escritura en el directorio de copias.
Ver También
- Manual de GNU tar — creación, listado y extracción de archivos
- Comprobación de integridad de objetos en Amazon S3 — validación de sumas en objetos cargados
- Manual de rsync — opciones
--link-desty archivado
Preguntas frecuentes
¿Cómo restauro una copia?
Extráela en un directorio nuevo y vacío con tar -xzf app-YYYY-MM-DD.tar.gz -C /restore/path. Revisa el árbol de archivos y sus permisos antes de copiar nada sobre datos activos.
¿Puedo usar rsync en lugar de tar?
Usa rsync si la mayoría de los archivos no cambia; la variante --link-dest comparte esos archivos entre instantáneas fechadas. Elige tar cuando necesites un archivo comprimido independiente y fácil de mover.
¿Qué hago si los archivos cambian durante la copia?
Pausa las escrituras o toma antes una instantánea del sistema de archivos o de la base de datos. Tar copia los archivos uno a uno, así que un directorio activo puede mezclar datos de momentos distintos. Para bases de datos, usa el volcado o la instantánea propia del motor y documenta la recuperación en el manual operativo.
Recursos Relacionados
Scripts de Bash para AWS CLI
Un conjunto de scripts de Bash que envuelven AWS CLI para aprovisionar, etiquetar, auditar y limpiar recursos de AWS, incluidos despliegues multi-cuenta.
RecipeRotación y Compresión de Logs en Bash
Rota, comprime y purga logs de aplicaciones con configuraciones de logrotate y scripts bash personalizados —incluyendo zstd, copytruncate, chequeo de disco y envío a S3.
RecipeComprimir y Descomprimir Archivos con ZIP, GZIP y TAR
Crea y extrae archivos ZIP, GZIP y TAR en Python, Node.js, Java y Bash con lectura en streaming y patrones de extracción segura.
RecipeRotar Archivos de Log
Cómo implementar rotación de logs por tamaño, fecha y cantidad para prevenir la exaustión de disco en Python, Node.js, Java y Linux.
RecipeScripting en Bash para Automatización DevOps y Tareas de
Como escribir scripts Bash robustos para automatizar despliegues, monitoreo de sistemas, rotacion de logs y tareas de mantenimiento rutinarias