Copias de Seguridad con BorgBackup: Guía Completa de Deduplicación y Encriptación

Introducción

BorgBackup (abreviado como Borg) es una solución moderna y sofisticada de copia de seguridad que revoluciona cómo los sistemas Linux manejan la protección de datos a través de deduplicación avanzada, compresión y encriptación autenticada. A diferencia de las herramientas tradicionales de copia de seguridad que almacenan copias completas de archivos para cada intervalo de copia de seguridad, Borg divide los datos en fragmentos definidos por contenido y almacena cada fragmento único solo una vez en todas las copias de seguridad. Este enfoque, combinado con compresión eficiente y encriptación fuerte, hace que Borg sea excepcionalmente eficiente en espacio mientras mantiene seguridad y rendimiento.

Desarrollado con lecciones aprendidas de herramientas anteriores de copia de seguridad con deduplicación, BorgBackup se ha convertido en el estándar de oro para copias de seguridad eficientes y seguras en entornos que van desde implementaciones de un solo servidor hasta infraestructura a gran escala. Organizaciones que gestionan terabytes de datos con requisitos de copia de seguridad diarios han logrado ratios de reducción de almacenamiento que exceden 50:1 a través de las capacidades de deduplicación de Borg, reduciendo drásticamente los costos de almacenamiento mientras mantienen historiales completos de copias de seguridad.

Esta guía completa explora BorgBackup desde conceptos fundamentales hasta implementación en producción, cubriendo instalación, gestión de repositorios, automatización de copias de seguridad, mecanismos de deduplicación, estrategias de encriptación, copias de seguridad remotas, procedimientos de restauración y escenarios de implementación del mundo real alineados con la regla de copia de seguridad 3-2-1.

Comprendiendo la Arquitectura de BorgBackup

Cómo Funciona BorgBackup

BorgBackup implementa una arquitectura sofisticada de múltiples capas:

Fragmentación definida por contenido: En lugar de respaldar archivos completos, Borg divide los datos en fragmentos de tamaño variable (típicamente 1-4MB) usando un algoritmo de hash rodante. Esto asegura que insertar datos al principio de un archivo no afecte los límites de fragmentos del contenido restante.

Deduplicación global: Borg mantiene un índice global de fragmentos en todas las copias de seguridad. Al crear nuevas copias de seguridad, Borg verifica si cada fragmento ya existe en el repositorio. Solo se almacenan fragmentos nuevos y únicos, independientemente de si los datos idénticos aparecen en diferentes archivos, directorios o archivos de copia de seguridad.

Compresión: Cada fragmento se comprime individualmente antes del almacenamiento, usando algoritmos como LZ4 (rápido), zstd (equilibrado) o zlib (alta compresión). Esto proporciona ahorros adicionales de espacio más allá de la deduplicación.

Encriptación autenticada: Todos los datos se encriptan del lado del cliente antes de la transmisión al repositorio. Borg soporta múltiples modos de encriptación incluyendo encriptación autenticada con AES-256-CTR + HMAC-SHA256, asegurando tanto confidencialidad como integridad.

Estructura del repositorio: Las copias de seguridad se almacenan como "archivos" dentro de un "repositorio". Cada archivo representa una copia de seguridad en un punto en el tiempo, pero todos los archivos dentro de un repositorio comparten el mismo pool de fragmentos deduplicado.

BorgBackup vs Soluciones Tradicionales de Copia de Seguridad

BorgBackup vs rsync/rsnapshot:

  • Rsync/rsnapshot: Deduplicación a nivel de archivo mediante enlaces duros
  • Borg: Deduplicación a nivel de bloque en todos los datos
  • Rsync/rsnapshot: Estructuras de directorios legibles por humanos
  • Borg: Formato de repositorio encriptado y deduplicado
  • Rsync/rsnapshot: Sin encriptación integrada
  • Borg: Encriptación obligatoria con modos autenticados

BorgBackup vs copias de seguridad tradicionales con tar:

  • Tar: Cada copia de seguridad es un archivo separado, copias completas de archivos
  • Borg: Pool de deduplicación global, almacenamiento a nivel de fragmentos
  • Tar: Compresión opcional por archivo
  • Borg: Compresión por fragmento con múltiples algoritmos
  • Tar: Sin encriptar por defecto
  • Borg: Encriptado por defecto

BorgBackup vs servicios de copia de seguridad en la nube:

  • Servicios en la nube: A menudo propietarios, dependencia del proveedor
  • Borg: Código abierto, documentación de formato disponible
  • Servicios en la nube: Precios variables, tarifas de salida de datos
  • Borg: Usar cualquier backend de almacenamiento (local, SSH, compatible con S3)
  • Servicios en la nube: Las claves de encriptación pueden ser gestionadas por el proveedor
  • Borg: Encriptación del lado del cliente, usted controla las claves

Características Clave y Beneficios

Eficiencia de espacio: Ratios de deduplicación de 10:1 a 50:1 o más dependiendo de la redundancia de datos y frecuencia de copia de seguridad.

Rendimiento: Las copias de seguridad incrementales son extremadamente rápidas ya que solo se procesan y almacenan fragmentos nuevos/modificados.

Seguridad: La encriptación autenticada protege tanto contra el acceso no autorizado como contra la manipulación.

Compresión: Múltiples algoritmos de compresión con diferentes compensaciones de velocidad/ratio.

Verificación de integridad: Verificación de consistencia integrada detecta corrupción.

Capacidad de montaje: Montar cualquier archivo como sistema de archivos de solo lectura para navegación y restauración selectiva.

Poda: Políticas de retención flexibles eliminan automáticamente copias de seguridad antiguas mientras preservan fragmentos deduplicados aún referenciados por archivos retenidos.

Multiplataforma: Funciona en Linux, macOS, BSD, Windows (vía WSL).

Instalación

Instalando BorgBackup

BorgBackup está disponible a través de gestores de paquetes estándar:

Ubuntu/Debian:

# Update package lists
sudo apt update

# Install BorgBackup
sudo apt install borgbackup

# Verify installation
borg --version

CentOS/Rocky Linux/RHEL:

# Enable EPEL repository
sudo dnf install epel-release

# Install BorgBackup
sudo dnf install borgbackup

# Verify installation
borg --version

Instalar desde binario (última versión):

# Download latest binary
cd /tmp
wget https://github.com/borgbackup/borg/releases/download/1.2.7/borg-linux64
chmod +x borg-linux64

# Move to system path
sudo mv borg-linux64 /usr/local/bin/borg

# Verify
borg --version

Salida esperada:

borg 1.2.x

Instalando BorgBackup desde el Código Fuente

Para las últimas características o compilaciones personalizadas:

# Install build dependencies (Ubuntu/Debian)
sudo apt install python3-dev python3-pip python3-virtualenv \
    libacl1-dev libssl-dev liblz4-dev libzstd-dev pkg-config

# Create virtual environment
python3 -m venv ~/borg-env
source ~/borg-env/bin/activate

# Install via pip
pip install borgbackup

# Verify
borg --version

Inicialización del Repositorio

Creando Tu Primer Repositorio

Un repositorio de Borg es el contenedor para todos tus archivos de copia de seguridad:

Repositorio local:

# Create repository directory
mkdir -p /backup/borg-repo

# Initialize repository with encryption
borg init --encryption=repokey /backup/borg-repo

Repositorio remoto vía SSH:

# Initialize on remote server
borg init --encryption=repokey user@backup-server:/backup/borg-repo

Inicializar con frase de contraseña:

# Borg will prompt for passphrase
borg init --encryption=repokey /backup/borg-repo
# Enter new passphrase:
# Enter same passphrase again:
# Repository created successfully

Comprendiendo los Modos de Encriptación

BorgBackup ofrece varios modos de encriptación con diferentes compensaciones de seguridad/conveniencia:

repokey (recomendado para la mayoría de usuarios):

  • Clave de encriptación almacenada en el repositorio
  • Protegida por frase de contraseña
  • El repositorio puede clonarse/moverse fácilmente
  • Recuperación ante desastres más fácil

keyfile:

  • Clave de encriptación almacenada en ~/.config/borg/keys/
  • Más seguro (el atacante necesita tanto el repo como el archivo de clave)
  • Debe respaldar el archivo de clave por separado
  • Recuperación ante desastres más compleja

repokey-blake2 / keyfile-blake2:

  • Igual que arriba pero usando BLAKE2b en lugar de SHA-256
  • Más rápido en CPUs modernas

authenticated:

  • Sin encriptación, solo autenticación
  • Detecta manipulación pero los datos son legibles
  • Usar solo para datos no sensibles

none:

  • Sin encriptación ni autenticación
  • No recomendado excepto para pruebas

Ejemplo con modo específico:

# Recommended: repokey mode
borg init --encryption=repokey /backup/borg-repo

# High security: keyfile mode
borg init --encryption=keyfile /backup/borg-repo

# Performance optimized
borg init --encryption=repokey-blake2 /backup/borg-repo

Gestión de Claves

Exportar clave de encriptación (crítico para recuperación ante desastres):

# Export key to file
borg key export /backup/borg-repo /secure/location/borg-key-backup.txt

# Store passphrase securely
# Use password manager, encrypted file, or physical safe

Importar clave (durante recuperación):

# Import previously exported key
borg key import /backup/borg-repo /secure/location/borg-key-backup.txt

Cambiar frase de contraseña:

# Change repository passphrase
borg key change-passphrase /backup/borg-repo

Variables de Entorno para Automatización

Configurar variables de entorno para copias de seguridad automatizadas:

# Add to backup script or .bashrc
export BORG_REPO='/backup/borg-repo'
export BORG_PASSPHRASE='your-secure-passphrase'

# For remote repositories
export BORG_REPO='user@backup-server:/backup/borg-repo'
export BORG_RSH='ssh -i /root/.ssh/borg-backup-key'

Advertencia de seguridad: Almacenar frases de contraseña en texto plano reduce la seguridad. Considere:

  • Usar agente SSH para copias de seguridad remotas
  • Almacenar frase de contraseña en archivo encriptado
  • Usar credenciales systemd o HashiCorp Vault

Creando Copias de Seguridad

Creación Básica de Copia de Seguridad

Crear tu primer archivo de copia de seguridad:

# Create backup archive
borg create \
    /backup/borg-repo::backup-2026-01-11 \
    /home \
    /etc \
    /var/www

# Syntax: borg create REPOSITORY::ARCHIVE-NAME SOURCE [SOURCE...]

Con marca de tiempo:

# Use date in archive name
borg create \
    /backup/borg-repo::backup-$(date +%Y%m%d-%H%M%S) \
    /home /etc /var/www

Salida detallada:

# Show detailed progress
borg create --progress --stats \
    /backup/borg-repo::backup-$(date +%Y%m%d) \
    /home /etc /var/www

Ejemplo de salida:

Creating archive at "/backup/borg-repo::backup-20260111"
------------------------------------------------------------------------------
Archive name: backup-20260111
Archive fingerprint: abc123def456
Time (start): Sat, 2026-01-11 14:30:00
Time (end):   Sat, 2026-01-11 14:35:42
Duration: 5 minutes 42.18 seconds
Number of files: 45231
------------------------------------------------------------------------------
                       Original size      Compressed size    Deduplicated size
This archive:               5.23 GB              3.87 GB              156.32 MB
All archives:              15.69 GB             11.61 GB                3.21 GB
------------------------------------------------------------------------------

Excluyendo Archivos y Directorios

Optimizar copias de seguridad excluyendo datos innecesarios:

Usando patrones --exclude:

borg create \
    --exclude '*.tmp' \
    --exclude '*.log' \
    --exclude 'cache/' \
    --exclude 'node_modules/' \
    /backup/borg-repo::backup-$(date +%Y%m%d) \
    /home /var/www

Usando archivo de exclusión:

Crear /etc/borg/exclude-patterns.txt:

# Temporary files
*.tmp
*.swp
*.bak
~*

# Caches
.cache/
__pycache__/
*.pyc
node_modules/
vendor/

# Logs
*.log
/var/log/

# System directories
/proc/
/sys/
/dev/
/run/
/tmp/

# Build artifacts
*.o
*.so
.git/

Usar en comando de copia de seguridad:

borg create \
    --exclude-from /etc/borg/exclude-patterns.txt \
    /backup/borg-repo::backup-$(date +%Y%m%d) \
    /

Opciones de Compresión

Borg soporta múltiples algoritmos de compresión:

Sin compresión (más rápido):

borg create --compression none \
    /backup/borg-repo::backup-$(date +%Y%m%d) \
    /home

LZ4 (muy rápido, compresión moderada):

borg create --compression lz4 \
    /backup/borg-repo::backup-$(date +%Y%m%d) \
    /home

Zstd (equilibrado, recomendado):

# Default level (3)
borg create --compression zstd \
    /backup/borg-repo::backup-$(date +%Y%m%d) \
    /home

# Custom level (1-22, higher = better compression, slower)
borg create --compression zstd,10 \
    /backup/borg-repo::backup-$(date +%Y%m%d) \
    /home

Zlib (alta compresión, más lento):

# Level 0-9
borg create --compression zlib,9 \
    /backup/borg-repo::backup-$(date +%Y%m%d) \
    /home

Compresión adaptativa (auto-detectar compresibilidad):

borg create --compression auto,zstd,10 \
    /backup/borg-repo::backup-$(date +%Y%m%d) \
    /home

Script de Copia de Seguridad de Producción

Script completo para entornos de producción:

#!/bin/bash
# /usr/local/bin/borg-backup.sh

set -e

# Configuration
export BORG_REPO='/backup/borg-repo'
export BORG_PASSPHRASE='your-secure-passphrase'

BACKUP_NAME="backup-$(date +%Y%m%d-%H%M%S)"
LOG_FILE="/var/log/borg-backup.log"
ADMIN_EMAIL="[email protected]"

# Logging function
log() {
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $*" | tee -a "$LOG_FILE"
}

# Error handler
error_exit() {
    log "ERROR: $1"
    echo "Borg backup failed: $1" | mail -s "Backup FAILED - $(hostname)" "$ADMIN_EMAIL"
    exit 1
}

log "Starting Borg backup: $BACKUP_NAME"

# Pre-backup: Database dumps
log "Creating database dumps..."
mysqldump --all-databases --single-transaction | gzip > /var/backups/mysql-all.sql.gz || \
    error_exit "MySQL dump failed"

# Create backup
log "Creating Borg archive..."
borg create \
    --verbose \
    --stats \
    --progress \
    --compression zstd,6 \
    --exclude-from /etc/borg/exclude-patterns.txt \
    "::$BACKUP_NAME" \
    /home \
    /etc \
    /var/www \
    /var/backups \
    /opt \
    /root 2>&1 | tee -a "$LOG_FILE"

if [ ${PIPESTATUS[0]} -ne 0 ]; then
    error_exit "Borg create failed"
fi

# Prune old backups
log "Pruning old archives..."
borg prune \
    --verbose \
    --list \
    --keep-daily=7 \
    --keep-weekly=4 \
    --keep-monthly=12 \
    2>&1 | tee -a "$LOG_FILE"

if [ ${PIPESTATUS[0]} -ne 0 ]; then
    error_exit "Borg prune failed"
fi

# Compact repository (free space from pruned archives)
log "Compacting repository..."
borg compact 2>&1 | tee -a "$LOG_FILE"

# Verify integrity (periodic check)
DAY_OF_MONTH=$(date +%d)
if [ "$DAY_OF_MONTH" == "01" ]; then
    log "Running monthly integrity check..."
    borg check --verify-data 2>&1 | tee -a "$LOG_FILE"
fi

log "Backup completed successfully: $BACKUP_NAME"

# Send success notification
echo "Backup completed successfully at $(date)" | \
    mail -s "Backup SUCCESS - $(hostname)" "$ADMIN_EMAIL"

exit 0

Hacer ejecutable:

sudo chmod +x /usr/local/bin/borg-backup.sh

Gestión de Archivos y Retención

Listando Archivos

Ver todas las copias de seguridad en el repositorio:

# List all archives
borg list /backup/borg-repo

# Output:
# backup-20260105-020000    Sat, 2026-01-05 02:00:00
# backup-20260106-020000    Sun, 2026-01-06 02:00:00
# backup-20260107-020000    Mon, 2026-01-07 02:00:00

Listar archivos en archivo específico:

# List all files
borg list /backup/borg-repo::backup-20260111

# List specific directory
borg list /backup/borg-repo::backup-20260111 | grep '/etc/'

# List with details
borg list --short /backup/borg-repo::backup-20260111 /home/user/

Información del Repositorio

Obtener estadísticas del repositorio:

# Repository info
borg info /backup/borg-repo

# Output:
# Repository ID: abc123...
# Location: /backup/borg-repo
# Encrypted: Yes (repokey)
# Cache: /root/.cache/borg/abc123
# Security dir: /root/.config/borg/security/abc123
#                        Original size      Compressed size    Deduplicated size
# All archives:              150.23 GB             95.87 GB               12.34 GB

Información específica del archivo:

# Info for specific archive
borg info /backup/borg-repo::backup-20260111

Podando Archivos

Implementar políticas de retención automáticamente:

Sintaxis del comando prune:

borg prune \
    --keep-daily=7 \
    --keep-weekly=4 \
    --keep-monthly=12 \
    --keep-yearly=2 \
    /backup/borg-repo

Opciones de retención:

  • --keep-hourly=N: Mantener N copias de seguridad por hora
  • --keep-daily=N: Mantener N copias de seguridad diarias
  • --keep-weekly=N: Mantener N copias de seguridad semanales (última copia de seguridad de cada semana)
  • --keep-monthly=N: Mantener N copias de seguridad mensuales (última copia de seguridad de cada mes)
  • --keep-yearly=N: Mantener N copias de seguridad anuales (última copia de seguridad de cada año)

Ejemplo: Rotación GFS:

borg prune \
    --list \
    --show-rc \
    --keep-daily=7 \
    --keep-weekly=4 \
    --keep-monthly=6 \
    --keep-yearly=2 \
    /backup/borg-repo

Ejecución en seco antes de la poda real:

# Test pruning without deleting
borg prune \
    --dry-run \
    --list \
    --keep-daily=7 \
    --keep-weekly=4 \
    /backup/borg-repo

Compactando el Repositorio

Después de podar, recuperar espacio:

# Compact repository (Borg 1.2+)
borg compact /backup/borg-repo

# Older versions: use
borg prune --keep-daily=7 /backup/borg-repo
# Space is automatically reclaimed

Eliminando Archivos Específicos

Eliminar archivos individuales:

# Delete specific archive
borg delete /backup/borg-repo::backup-20260105

# Delete multiple archives
borg delete \
    /backup/borg-repo::backup-20260105 \
    /backup/borg-repo::backup-20260106

# Delete entire repository (DANGEROUS!)
borg delete /backup/borg-repo

Procedimientos de Restauración

Montando Archivos

Montar copia de seguridad como sistema de archivos de solo lectura para navegar:

# Create mount point
mkdir -p /mnt/borg-mount

# Mount latest archive
LATEST=$(borg list /backup/borg-repo | tail -1 | cut -d' ' -f1)
borg mount /backup/borg-repo::$LATEST /mnt/borg-mount

# Browse backup
ls -la /mnt/borg-mount/home/user/

# Unmount when done
borg umount /mnt/borg-mount

Montar todos los archivos:

# Mount entire repository (all archives)
borg mount /backup/borg-repo /mnt/borg-mount

# Each archive appears as subdirectory
ls /mnt/borg-mount/
# backup-20260105-020000/
# backup-20260106-020000/
# backup-20260111-020000/

# Browse specific archive
ls /mnt/borg-mount/backup-20260111-020000/home/

# Unmount
borg umount /mnt/borg-mount

Extrayendo Archivos

Restaurar archivos desde los archivos:

Extraer archivo completo:

# Extract to current directory
borg extract /backup/borg-repo::backup-20260111

# Extract to specific location
cd /restore-location
borg extract /backup/borg-repo::backup-20260111

Extraer archivos/directorios específicos:

# Extract single file
borg extract /backup/borg-repo::backup-20260111 home/user/document.txt

# Extract directory
borg extract /backup/borg-repo::backup-20260111 etc/

# Extract multiple paths
borg extract /backup/borg-repo::backup-20260111 \
    home/user/ \
    etc/nginx/ \
    var/www/

Extraer con diferentes rutas:

# Strip leading path components
borg extract --strip-components=2 \
    /backup/borg-repo::backup-20260111 \
    home/user/documents/
# Results in: documents/ in current directory

Restauración Completa del Sistema

Restaurar sistema completo después de un desastre:

# Boot from live USB/rescue system

# Partition and format disks
parted /dev/sda mklabel gpt
parted /dev/sda mkpart primary ext4 1MiB 100%
mkfs.ext4 /dev/sda1

# Mount target filesystem
mount /dev/sda1 /mnt/target

# Initialize Borg (import key if needed)
export BORG_REPO='user@backup-server:/backup/borg-repo'
export BORG_PASSPHRASE='your-passphrase'

# Extract latest backup
cd /mnt/target
LATEST=$(borg list $BORG_REPO | tail -1 | cut -d' ' -f1)
borg extract "::$LATEST"

# Reinstall bootloader
mount --bind /dev /mnt/target/dev
mount --bind /proc /mnt/target/proc
mount --bind /sys /mnt/target/sys
chroot /mnt/target
grub-install /dev/sda
update-grub
exit

# Unmount and reboot
umount /mnt/target/dev /mnt/target/proc /mnt/target/sys
umount /mnt/target
reboot

Copias de Seguridad Remotas

Repositorios Remotos Basados en SSH

Respaldar a servidor remoto a través de SSH:

Configurar autenticación SSH:

# Generate SSH key
ssh-keygen -t ed25519 -f ~/.ssh/borg-backup-key -N ""

# Copy to remote server
ssh-copy-id -i ~/.ssh/borg-backup-key.pub user@backup-server

# Test connection
ssh -i ~/.ssh/borg-backup-key user@backup-server "echo SSH OK"

Inicializar repositorio remoto:

export BORG_RSH='ssh -i ~/.ssh/borg-backup-key'
borg init --encryption=repokey user@backup-server:/backup/borg-repo

Crear copia de seguridad remota:

borg create \
    --compression zstd,6 \
    --exclude-from /etc/borg/exclude-patterns.txt \
    user@backup-server:/backup/borg-repo::backup-$(date +%Y%m%d) \
    /home /etc /var/www

Script de copia de seguridad remota:

#!/bin/bash
# /usr/local/bin/borg-remote-backup.sh

export BORG_REPO='user@backup-server:/backup/borg-repo'
export BORG_PASSPHRASE='your-secure-passphrase'
export BORG_RSH='ssh -i /root/.ssh/borg-backup-key'

borg create \
    --compression zstd,6 \
    --exclude-from /etc/borg/exclude-patterns.txt \
    "::backup-$(hostname)-$(date +%Y%m%d-%H%M%S)" \
    /home /etc /var/www /opt

borg prune \
    --keep-daily=7 \
    --keep-weekly=4 \
    --keep-monthly=12

Repositorios de Solo Anexar

Proteger contra ransomware previniendo la eliminación:

Inicializar repositorio de solo anexar:

# On backup server, create repository
borg init --encryption=repokey /backup/borg-repo

# Configure as append-only
borg config /backup/borg-repo append_only 1

Restringir acceso SSH (en servidor de copia de seguridad):

Editar ~/.ssh/authorized_keys:

command="borg serve --append-only --restrict-to-path /backup/borg-repo",restrict ssh-ed25519 AAAA...

Esto permite a los clientes:

  • Crear nuevos archivos
  • Listar archivos
  • Extraer archivos

Pero previene:

  • Eliminar archivos
  • Modificar archivos existentes
  • Podar

Podando repos de solo anexar (solo del lado del servidor):

# On backup server (manual or scheduled)
borg prune --keep-daily=7 --keep-weekly=4 /backup/borg-repo

Automatización y Programación

Implementación de Temporizador Systemd

Crear archivo de servicio (/etc/systemd/system/borg-backup.service):

[Unit]
Description=BorgBackup Service
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/borg-backup.sh
User=root
Nice=19
IOSchedulingClass=2
IOSchedulingPriority=7

# Security hardening
PrivateTmp=yes
ProtectSystem=strict
ProtectHome=read-only
ReadWritePaths=/backup /var/log /var/backups

# Timeout after 6 hours
TimeoutSec=21600

[Install]
WantedBy=multi-user.target

Crear archivo de temporizador (/etc/systemd/system/borg-backup.timer):

[Unit]
Description=BorgBackup Daily Timer
Requires=borg-backup.service

[Timer]
OnCalendar=daily
OnCalendar=*-*-* 02:00:00
Persistent=true
RandomizedDelaySec=30min

[Install]
WantedBy=timers.target

Habilitar temporizador:

sudo systemctl daemon-reload
sudo systemctl enable --now borg-backup.timer
sudo systemctl list-timers borg-backup.timer

Programación Basada en Cron

Configuración alternativa con cron:

# Edit root crontab
sudo crontab -e

# Daily backup at 2 AM
0 2 * * * /usr/local/bin/borg-backup.sh >> /var/log/borg-cron.log 2>&1

Monitoreo y Verificación

Verificación de Integridad

Verificación regular de integridad:

# Quick check (metadata only)
borg check /backup/borg-repo

# Full check (verify data)
borg check --verify-data /backup/borg-repo

# Check specific archive
borg check /backup/borg-repo::backup-20260111

Verificación mensual automatizada:

#!/bin/bash
# /usr/local/bin/borg-verify.sh

export BORG_REPO='/backup/borg-repo'
export BORG_PASSPHRASE='your-passphrase'

# Full verification
borg check --verify-data 2>&1 | tee /var/log/borg-verify.log

if [ ${PIPESTATUS[0]} -eq 0 ]; then
    echo "Repository verification successful" | \
        mail -s "Borg Verification OK" [email protected]
else
    echo "Repository verification FAILED" | \
        mail -s "Borg Verification FAILED" [email protected]
fi

Programar mensualmente:

# First day of month at 3 AM
0 3 1 * * /usr/local/bin/borg-verify.sh

Script de Monitoreo de Copia de Seguridad

#!/bin/bash
# /usr/local/bin/monitor-borg-backup.sh

export BORG_REPO='/backup/borg-repo'
export BORG_PASSPHRASE='your-passphrase'

MAX_AGE_HOURS=26
ADMIN_EMAIL="[email protected]"

# Get latest archive
LATEST=$(borg list --short "$BORG_REPO" | tail -1)

if [ -z "$LATEST" ]; then
    echo "ERROR: No archives found in repository" | \
        mail -s "Borg Monitoring ALERT" "$ADMIN_EMAIL"
    exit 1
fi

# Get archive creation time
ARCHIVE_TIME=$(borg info "::$LATEST" | grep "^Time" | grep "start" | awk '{print $4, $5, $6}')
ARCHIVE_EPOCH=$(date -d "$ARCHIVE_TIME" +%s 2>/dev/null || date -j -f "%Y-%m-%d %H:%M:%S" "$ARCHIVE_TIME" +%s)
CURRENT_EPOCH=$(date +%s)
AGE_HOURS=$(( (CURRENT_EPOCH - ARCHIVE_EPOCH) / 3600 ))

if [ $AGE_HOURS -gt $MAX_AGE_HOURS ]; then
    echo "WARNING: Latest backup is $AGE_HOURS hours old (>$MAX_AGE_HOURS)" | \
        mail -s "Borg Backup Age Alert" "$ADMIN_EMAIL"
    exit 1
else
    echo "OK: Latest backup ($LATEST) is $AGE_HOURS hours old"
    exit 0
fi

Escenarios de Implementación del Mundo Real

Escenario 1: Copia de Seguridad Personal de Estación de Trabajo

Requisitos:

  • Directorio home del usuario
  • Archivos de configuración
  • Copias de seguridad automatizadas diarias
  • Retención de 30 días

Configuración:

# Initialize repository
borg init --encryption=repokey ~/backups/borg-repo

# Create backup script
cat > ~/bin/borg-backup.sh << 'EOF'
#!/bin/bash
export BORG_REPO="$HOME/backups/borg-repo"
export BORG_PASSPHRASE="my-secure-passphrase"

borg create \
    --compression zstd,6 \
    --exclude-from "$HOME/.config/borg/exclude.txt" \
    "::backup-$(date +%Y%m%d-%H%M%S)" \
    "$HOME"

borg prune --keep-daily=30
EOF

chmod +x ~/bin/borg-backup.sh

# Create exclude file
cat > ~/.config/borg/exclude.txt << 'EOF'
.cache/
Downloads/
.local/share/Trash/
*.tmp
node_modules/
EOF

# Schedule with cron
crontab -e
# Add: 0 12 * * * ~/bin/borg-backup.sh

Escenario 2: Copia de Seguridad de Producción de Servidor Web

Requisitos:

  • Múltiples sitios web
  • Volcados de base de datos
  • Repositorio de copia de seguridad remoto
  • Monitoreo y alertas

Implementación:

#!/bin/bash
# /usr/local/bin/borg-production-backup.sh

set -e

export BORG_REPO='[email protected]:/backups/web-server'
export BORG_PASSPHRASE='strong-production-passphrase'
export BORG_RSH='ssh -i /root/.ssh/borg-key'

LOG="/var/log/borg-production.log"
ADMIN="[email protected]"

log() {
    echo "[$(date)] $*" | tee -a "$LOG"
}

# Pre-backup: database dumps
log "Creating database dumps"
mkdir -p /var/backups/db-dumps

mysqldump --all-databases --single-transaction \
    | gzip > /var/backups/db-dumps/mysql-all.sql.gz

sudo -u postgres pg_dumpall \
    | gzip > /var/backups/db-dumps/postgresql-all.sql.gz

# Create backup
log "Creating Borg archive"
borg create \
    --compression zstd,8 \
    --exclude-from /etc/borg/exclude.txt \
    --stats \
    "::backup-$(hostname)-$(date +%Y%m%d-%H%M%S)" \
    /var/www \
    /etc \
    /var/backups/db-dumps \
    /opt

# Prune old backups
log "Pruning old archives"
borg prune \
    --keep-hourly=24 \
    --keep-daily=7 \
    --keep-weekly=4 \
    --keep-monthly=12

# Verify
log "Verifying repository"
borg check --last 1

log "Backup completed successfully"
echo "Production backup completed" | mail -s "Backup Success" "$ADMIN"

Escenario 3: Copia de Seguridad Centralizada Multi-Servidor

Requisitos:

  • 10 servidores de aplicación
  • Servidor de copia de seguridad central
  • Repositorios individuales por servidor
  • Monitoreo consolidado

Configuración del servidor de copia de seguridad central:

# /backup/borg-repos/
# ├── server01/
# ├── server02/
# ├── server03/
# ...

Script de copia de seguridad por servidor:

#!/bin/bash
# On each application server

HOSTNAME=$(hostname -s)
export BORG_REPO="backup-server:/backup/borg-repos/$HOSTNAME"
export BORG_PASSPHRASE="passphrase-for-$HOSTNAME"
export BORG_RSH='ssh -i /root/.ssh/borg-key'

borg create \
    --compression zstd,6 \
    "::backup-$(date +%Y%m%d-%H%M%S)" \
    /etc /home /var/www /opt

borg prune --keep-daily=7 --keep-weekly=4 --keep-monthly=6

Monitoreo centralizado (en servidor de copia de seguridad):

#!/bin/bash
# /usr/local/bin/monitor-all-backups.sh

REPOS_DIR="/backup/borg-repos"
MAX_AGE_HOURS=26

for repo in "$REPOS_DIR"/*; do
    if [ -d "$repo" ]; then
        server_name=$(basename "$repo")
        export BORG_REPO="$repo"

        # Get latest archive age
        latest=$(borg list --short "$BORG_REPO" 2>/dev/null | tail -1)

        if [ -z "$latest" ]; then
            echo "WARNING: $server_name has no backups"
        else
            echo "OK: $server_name latest backup: $latest"
        fi
    fi
done

Solución de Problemas

Repositorio Bloqueado

Síntoma: Failed to create/acquire the lock

Causa: La copia de seguridad anterior no se completó limpiamente

Solución:

# Check for running borg processes
ps aux | grep borg

# If no processes, break lock
borg break-lock /backup/borg-repo

# If process exists, wait or kill it

Problemas de Sincronización de Caché

Síntoma: Cache is newer than repository

Solución:

# Delete cache
rm -rf ~/.cache/borg/

# Rebuild cache
borg list /backup/borg-repo

Sin Espacio Durante la Copia de Seguridad

Síntoma: No space left on device

Soluciones:

# Check repository size
borg info /backup/borg-repo

# Prune aggressively
borg prune --keep-daily=3 /backup/borg-repo

# Compact repository
borg compact /backup/borg-repo

# Check and increase storage
df -h /backup

Conclusión

BorgBackup representa un enfoque moderno y sofisticado para la protección de datos, combinando deduplicación, compresión y encriptación para ofrecer copias de seguridad eficientes y seguras. Su fragmentación definida por contenido y deduplicación global permiten ahorros dramáticos de almacenamiento mientras mantienen historiales completos de copias de seguridad que abarcan meses o años.

Puntos clave:

  1. Inicializar de manera segura: Elegir el modo de encriptación apropiado y proteger las frases de contraseña/claves cuidadosamente.

  2. Optimizar configuración: Usar algoritmos de compresión apropiados y patrones de exclusión para su caso de uso.

  3. Automatizar consistentemente: Implementar temporizadores systemd o trabajos cron con manejo robusto de errores.

  4. Podar regularmente: Mantener políticas de retención para equilibrar el historial con el consumo de almacenamiento.

  5. Monitorear activamente: Verificar que las copias de seguridad se completen exitosamente y ejecutar verificaciones periódicas de integridad.

  6. Probar la restauración: Los simulacros regulares de restauración aseguran confianza en las capacidades de recuperación.

  7. Asegurar adecuadamente: Usar modo de solo anexar, proteger claves SSH y encriptar repositorios apropiadamente.

BorgBackup es particularmente adecuado para entornos con:

  • Copias de seguridad frecuentes de grandes conjuntos de datos con cambios incrementales
  • Necesidad de períodos de retención largos (meses/años)
  • Requisitos de seguridad que necesitan encriptación
  • Presupuestos de almacenamiento limitados que se benefician de la deduplicación

Combinado con una planificación adecuada, automatización, monitoreo y la regla de copia de seguridad 3-2-1 (mantener repositorios Borg localmente, remotamente y en diferentes medios), BorgBackup proporciona protección de datos de nivel empresarial adecuada para todo, desde estaciones de trabajo personales hasta infraestructura de producción.