StackPractices
intermediate Por Mathias Paulenko

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.

flowchart diagram: Crear archivo temporal

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.

NivelPromociónAjuste de retenciónEfecto en almacenamiento
DiarioCada ejecución correctaDAILY_RETENTION díasUn archivo comprimido por fecha
SemanalCopia los domingosWEEKLY_RETENTION × 7 díasUna copia completa adicional
MensualCopia el día 1MONTHLY_RETENTION × 30 díasAproximación a meses; copia completa adicional
RemotoCarga tras validar el archivo localPolítica de ciclo de vida de S3Copia 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

  1. 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.
  2. 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.
  3. Cifra antes de subir datos sensibles. Usa GPG con la clave pública del destinatario; no dejes el correo de ejemplo sin cambiar.
  4. 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.
  5. 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

  1. Borrar copias antes de validar la nueva. Crea y lista el archivo nuevo antes de ejecutar cualquier limpieza.
  2. Guardar las copias en el mismo disco que el origen. Un fallo de disco destruye tanto los datos como sus copias.
  3. 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.
  4. Ignorar códigos de salida. Si tar falla pero la limpieza continúa, find -delete puede borrar copias anteriores sin reemplazarlas.
  5. 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

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.