De CD a Opus: Workflow Completo (Parte 6/6) - Backup y Mantenimiento

AUDIO 10 Jun 2026 · 9 min lectura

Disco duro externo conectado a ordenador realizando backup de biblioteca musical

Introducción

He completado todo el proceso de digitalización:

Post 1: Estructura de carpetas
Post 2: Extracción con freeac
Post 3: Artwork en GIMP
Post 4: Conversión a Opus
Post 5: MediaElch y metadata

Ahora es momento de proteger el trabajo con:

Estrategias de backup inteligente
Verificación de integridad
Sincronización con móvil (KDE Connect)
Automatización del mantenimiento

Filosofía de Backup: Regla 3-2-1

La regla 3-2-1 para backups:

3 copias de los datos (original + 2 backups)
2 tipos de medios diferentes (disco local + externo)
1 copia fuera de ubicación (opcional: nube/otra casa)

Aplicado a mi biblioteca musical:

Copia 1: /home/jaume/Música/Mi música/     (disco principal)
Copia 2: /mnt/backup-externo/Musica/       (disco USB externo)
Copia 3: /mnt/nas/Backups/Musica/          (NAS o nube)

Estrategia de Backup Dual

Backup de WAV (Master)

Prioridad: ALTA

Los archivos WAV son nuestro master irreproducible:

Contienen el audio original sin pérdida
Son difíciles de recrear (requieren el CD físico)
Ocupan mucho espacio (~350 MB por álbum)

Frecuencia recomendada: Después de cada extracción + backup mensual completo

Backup de Opus (Reproducción)

Prioridad: MEDIA

Los archivos Opus son regenerables desde WAV:

Se pueden recrear con fLaCon desde WAV+CUE
Ocupan poco espacio (~35 MB por álbum)
Incluyen artwork y metadata

Frecuencia recomendada: Backup semanal/mensual

Herramienta Principal: rsync

rsync es la herramienta estándar para backups en Linux:

Copia solo archivos nuevos/modificados (incremental)
Preserva permisos, timestamps, enlaces
Puede comprimir durante transferencia
Soporta exclusiones y filtros

Instalación

sudo pacman -S rsync

Backup Básico de WAV

Comando básico:

rsync -avh --progress \
  "$HOME/Música/Mi música/wav/" \
  "/mnt/backup-externo/Musica/wav/"

Explicación de opciones:

-a (archive): preserva permisos, timestamps, enlaces
-v (verbose): muestra archivos copiados
-h (human-readable): tamaños legibles (MB, GB)
--progress: muestra progreso de cada archivo

Backup Completo (WAV + Opus)

#!/bin/bash
# backup-musica.sh

ORIGEN="$HOME/Música/Mi música/"
DESTINO="/mnt/backup-externo/Musica/"

echo "Iniciando backup de biblioteca musical..."
echo "Origen: $ORIGEN"
echo "Destino: $DESTINO"

# Verificar que el destino existe
if [ ! -d "$DESTINO" ]; then
    echo "❌ Error: Destino no accesible"
    exit 1
fi

# Backup de WAV (archivos master)
echo ""
echo "Copiando WAV (master)..."
rsync -avh --progress \
    --exclude=".*" \
    "$ORIGEN/wav/" \
    "$DESTINO/wav/"

# Backup de Opus (archivos de reproducción)
echo ""
echo "Copiando Opus..."
rsync -avh --progress \
    --exclude=".*" \
    "$ORIGEN/opus/" \
    "$DESTINO/opus/"

echo ""
echo "Backup completado"

Ejecutar:

chmod +x backup-musica.sh
./backup-musica.sh

Backup con Exclusiones

Si queremos excluir archivos temporales o cachés:

rsync -avh --progress \
    --exclude=".*" \
    --exclude="*.tmp" \
    --exclude="Temp/" \
    --exclude=".Trash*" \
    "$HOME/Música/Mi música/wav/" \
    "/mnt/backup-externo/Musica/wav/"

Backup con Eliminación de Archivos Obsoletos

⚠️ CUIDADO: Esto eliminará en el destino archivos que ya no existen en origen.

rsync -avh --progress --delete \
    "$HOME/Música/Mi música/wav/" \
    "/mnt/backup-externo/Musica/wav/"

Cuándo usar --delete:

Cuando reorganizo carpetas
Cuando elimino álbumes duplicados
Cuando quiero mantener destino = origen

Cuándo NO usarlo:

En backups "archive" (quiero conservar todo)
Si no estoy seguro de lo que voy a hacer

Backup Incremental con Timestamps

Para mantener múltiples versiones con fecha:

#!/bin/bash
# backup-musica-incremental.sh

FECHA=$(date +%Y-%m-%d_%H%M)
ORIGEN="$HOME/Música/Mi música/"
DESTINO_BASE="/mnt/backup-externo/Musica/backups/"
DESTINO="${DESTINO_BASE}backup-${FECHA}/"

mkdir -p "$DESTINO"

echo "Backup incremental: $FECHA"

rsync -avh --progress \
    --link-dest="${DESTINO_BASE}backup-latest/" \
    "$ORIGEN" \
    "$DESTINO"

# Actualizar enlace al último backup
rm -f "${DESTINO_BASE}backup-latest"
ln -s "$DESTINO" "${DESTINO_BASE}backup-latest"

echo "Backup guardado en: $DESTINO"

Ventaja: Solo ocupa espacio de archivos nuevos/modificados (usa hardlinks)

Verificación de Integridad

Generar Checksums (MD5/SHA256)

Genero checksums para verificar que mis archivos no se corrompan:

#!/bin/bash
# generar-checksums.sh

MUSICA_DIR="$HOME/Música/Mi música/wav"
CHECKSUM_FILE="$MUSICA_DIR/checksums-wav.sha256"

echo "🔍 Generando checksums SHA256..."

cd "$MUSICA_DIR"
find . -type f \( -name "*.wav" -o -name "*.cue" -o -name "*.log" \) \
    -exec sha256sum {} \; > "$CHECKSUM_FILE"

echo "Checksums guardados en: $CHECKSUM_FILE"

Verificar Checksums

#!/bin/bash
# verificar-checksums.sh

MUSICA_DIR="$HOME/Música/Mi música/wav"
CHECKSUM_FILE="$MUSICA_DIR/checksums-wav.sha256"

echo "🔍 Verificando integridad de archivos..."

cd "$MUSICA_DIR"
sha256sum -c "$CHECKSUM_FILE"

if [ $? -eq 0 ]; then
    echo "Todos los archivos verificados correctamente"
else
    echo "¡ADVERTENCIA! Algunos archivos están corruptos"
fi

Detección de Duplicados

Busco archivos duplicados para ahorrar espacio:

# Instalar fdupes
sudo pacman -S fdupes

# Buscar duplicados en toda la biblioteca
fdupes -r "$HOME/Música/Mi música/opus/"

# Buscar y mostrar solo duplicados
fdupes -r -n "$HOME/Música/Mi música/opus/"

# Modo interactivo (me pregunta cuál conservar)
fdupes -r -d "$HOME/Música/Mi música/opus/"

Sincronización con Móvil: KDE Connect

KDE Connect permite sincronizar música entre entre el PC y móvil Android/iOS.

Instalación

En Arch Linux:

sudo pacman -S kdeconnect

En Android:

Play Store: KDE Connect
F-Droid: KDE Connect

Configuración Inicial

Abro KDE Connect en el PC:

   kdeconnect-app

Emparejo dispositivos:
- En el móvil, abro KDE Connect
- Busco mi PC en la lista
- Click en "Emparejar"
- Acepto en ambos dispositivos
Verifico conexión:

   kdeconnect-cli -l

Debería ver mi dispositivo conectado.

Sincronizar Música con Móvil

Método 1: Compartir archivos directamente

# Obtener ID del dispositivo
kdeconnect-cli -l

# Enviar álbum completo al móvil
kdeconnect-cli -d <DEVICE_ID> --share \
    "$HOME/Música/Mi música/opus/a-z/ABBA/2014 - Gold/"

Método 2: Usar carpeta compartida

Configuro carpeta compartida en KDE Connect:
- Settings → SFTP → Enable
- Monto el sistema de archivos del móvil
Monto dispositivo:

   kdeconnect-cli -d <DEVICE_ID> --sftp

Accedo a carpeta Music del móvil:

   cd ~/run/user/1000/kdeconnect/<DEVICE_ID>/

Copio música:

   rsync -avh --progress \
       "$HOME/Música/Mi música/opus/a-z/Queen/" \
       ~/run/user/1000/kdeconnect/<DEVICE_ID>/Music/Queen/

Script de Sincronización Automática

#!/bin/bash
# sync-music-to-phone.sh

DEVICE_ID="nuestro_device_id_aqui"
ORIGEN="$HOME/Música/Mi música/opus/a-z/"
DESTINO_MOVIL="$HOME/run/user/1000/kdeconnect/$DEVICE_ID/Music/"

echo "📱 Sincronizando música con móvil..."

# Verificar que el dispositivo está conectado
if ! kdeconnect-cli -d "$DEVICE_ID" --ping; then
    echo "❌ Error: Dispositivo no conectado"
    exit 1
fi

# Montar SFTP
kdeconnect-cli -d "$DEVICE_ID" --sftp

# Esperar a que se monte
sleep 2

# Sincronizar música
rsync -avh --progress \
    --include="*.opus" \
    --include="folder.jpg" \
    --exclude="*" \
    "$ORIGEN" \
    "$DESTINO_MOVIL"

echo "✅ Sincronización completada"

Obtener DEVICE_ID:

kdeconnect-cli -l | grep "- "

Sincronización Selectiva (Solo Favoritos)

Crea una lista de artistas/álbumes favoritos:

# favoritos.txt
ABBA/2014 - Gold
Queen/1975 - A Night at the Opera
David Bowie/1972 - The Rise and Fall of Ziggy Stardust

Script:

#!/bin/bash
# sync-favorites.sh

FAVORITOS="$HOME/Música/favoritos.txt"
ORIGEN="$HOME/Música/Mi música/opus/a-z/"
DESTINO_MOVIL="$HOME/run/user/1000/kdeconnect/$DEVICE_ID/Music/"

while IFS= read -r album; do
    echo "📀 Sincronizando: $album"
    rsync -avh --progress \
        "$ORIGEN/$album/" \
        "$DESTINO_MOVIL/$album/"
done < "$FAVORITOS"

Automatización con Cron/Systemd

Backup Automático Semanal con Cron

# Editar crontab
crontab -e

# Añadir backup todos los domingos a las 2:00 AM
0 2 * * 0 /home/jaume/scripts/backup-musica.sh >> /home/jaume/logs/backup-musica.log 2>&1

Backup Automático con Systemd Timer

Creo el servicio:

sudo nano /etc/systemd/system/backup-musica.service

[Unit]
Description=Backup de biblioteca musical
After=network.target

[Service]
Type=oneshot
User=jaume
ExecStart=/home/jaume/scripts/backup-musica.sh

Ahora el timer:

sudo nano /etc/systemd/system/backup-musica.timer

[Unit]
Description=Ejecutar backup de música semanalmente

[Timer]
OnCalendar=weekly
Persistent=true

[Install]
WantedBy=timers.target

Y por último, activo:

sudo systemctl daemon-reload
sudo systemctl enable backup-musica.timer
sudo systemctl start backup-musica.timer

Verifico:

systemctl list-timers | grep backup-musica

Monitoreo de Espacio en Disco

Script de Monitoreo

#!/bin/bash
# monitor-espacio.sh

MUSICA_DIR="$HOME/Música/Mi música/"
UMBRAL=90  # Alerta si supera 90% de uso

USO=$(df -h "$MUSICA_DIR" | awk 'NR==2 {print $5}' | sed 's/%//')

echo "💾 Uso de disco en $MUSICA_DIR: ${USO}%"

if [ "$USO" -gt "$UMBRAL" ]; then
    echo "⚠️ ADVERTENCIA: Espacio bajo (>${UMBRAL}%)"

    # Mostrar carpetas más grandes
    echo ""
    echo "📊 Carpetas más grandes:"
    du -h --max-depth=2 "$MUSICA_DIR" | sort -rh | head -10
fi

Estadísticas de Biblioteca

#!/bin/bash
# stats-biblioteca.sh

MUSICA_DIR="$HOME/Música/Mi música/"

echo "📊 Estadísticas de Biblioteca Musical"
echo "===================================="

# WAV
echo ""
echo "📀 WAV (Master):"
WAV_COUNT=$(find "$MUSICA_DIR/wav" -name "*.wav" | wc -l)
WAV_SIZE=$(du -sh "$MUSICA_DIR/wav" | cut -f1)
echo "  Archivos: $WAV_COUNT"
echo "  Tamaño total: $WAV_SIZE"

# Opus
echo ""
echo "🎧 Opus (Reproducción):"
OPUS_COUNT=$(find "$MUSICA_DIR/opus" -name "*.opus" | wc -l)
OPUS_SIZE=$(du -sh "$MUSICA_DIR/opus" | cut -f1)
echo "  Archivos: $OPUS_COUNT"
echo "  Tamaño total: $OPUS_SIZE"

# Artistas
echo ""
echo "🎤 Artistas:"
ARTISTAS=$(find "$MUSICA_DIR/opus/a-z" -maxdepth 1 -type d | wc -l)
echo "  Total: $((ARTISTAS - 1))"  # -1 para excluir la carpeta a-z

# Albums
echo ""
echo "💿 Álbumes:"
ALBUMS=$(find "$MUSICA_DIR/opus/a-z" -mindepth 2 -maxdepth 2 -type d | wc -l)
echo "  Total: $ALBUMS"

echo ""
echo "===================================="

Recuperación de Archivos Dañados

Detectar Archivos WAV Corruptos

#!/bin/bash
# verificar-wav.sh

MUSICA_DIR="$HOME/Música/Mi música/wav"

echo "🔍 Verificando archivos WAV..."

find "$MUSICA_DIR" -name "*.wav" | while read -r wav_file; do
    # Verificar con ffmpeg
    if ! ffmpeg -v error -i "$wav_file" -f null - 2>&1 | grep -q "error"; then
        echo "✅ OK: $wav_file"
    else
        echo "❌ CORRUPTO: $wav_file"
    fi
done

Regenerar Opus desde WAV

Si un archivo Opus se daña, regeneramos desde WAV:

#!/bin/bash
# regenerar-opus.sh

ALBUM_WAV="$HOME/Música/Mi música/wav/a-z/ABBA/2014 - Gold/"
ALBUM_OPUS="$HOME/Música/Mi música/opus/a-z/ABBA/2014 - Gold/"

echo "🔧 Regenerando Opus desde WAV..."

# Eliminar Opus dañados
rm -rf "$ALBUM_OPUS"

# Usar fLaCon para regenerar
# (Abre fLaCon, carga el CUE, convierte)
flacon "$ALBUM_WAV/ABBA - Gold.cue"

Troubleshooting Común

Problema: Backup muy lento

Causa: Transferencia de archivos grandes sin compresión

Solución:

# Añadir compresión durante transferencia
rsync -avhz --progress \
    "$ORIGEN" \
    "$DESTINO"

Problema: rsync falla por permisos

Causa: El destino no tiene permisos de escritura

Solución:

# Verificar permisos del destino
ls -ld /mnt/backup-externo/Musica/

# Corregir permisos
sudo chown -R jaume:jaume /mnt/backup-externo/Musica/

Problema: KDE Connect no se conecta

Causa: Firewall bloqueando puertos

Solución:

# Abrir puertos necesarios (1714-1764 TCP/UDP)
sudo firewall-cmd --permanent --add-port=1714-1764/tcp
sudo firewall-cmd --permanent --add-port=1714-1764/udp
sudo firewall-cmd --reload

Problema: Disco de backup se llena

Causa: Backups incrementales acumulados

Solución:

# Eliminar backups antiguos (mantener últimos 7 días)
find /mnt/backup-externo/Musica/backups/ \
    -type d -mtime +7 \
    -exec rm -rf {} \;

Script Todo-en-Uno

master-maintenance.sh:

#!/bin/bash
# master-maintenance.sh

echo "🎵 === MANTENIMIENTO DE BIBLIOTECA MUSICAL ==="
echo ""

# 1. Estadísticas
echo "📊 1. Estadísticas..."
~/scripts/stats-biblioteca.sh

# 2. Verificar espacio
echo ""
echo "💾 2. Monitoreo de espacio..."
~/scripts/monitor-espacio.sh

# 3. Backup
echo ""
echo "💾 3. Ejecutando backup..."
~/scripts/backup-musica.sh

# 4. Verificar integridad
echo ""
echo "🔍 4. Verificando integridad..."
~/scripts/verificar-checksums.sh

echo ""
echo "✅ Mantenimiento completado"

Resumen del Post 6

✅ He logrado:

Configurar backup incremental con rsync
Verificar integridad con checksums
Sincronizar música con móvil (KDE Connect)
Automatizar backups con cron/systemd
Monitorear espacio y estadísticas
Recuperar archivos dañados

📁 Scripts creados:

backup-musica.sh (backup completo)
sync-music-to-phone.sh (KDE Connect)
verificar-checksums.sh (integridad)
stats-biblioteca.sh (estadísticas)
master-maintenance.sh (todo-en-uno)

🎯 Mi biblioteca está ahora:

✅ Protegida con backups regulares
✅ Verificada en integridad
✅ Sincronizada con móvil
✅ Monitoreada automáticamente

¡Serie Completada! 🎉

He completado todo el workflow de digitalización profesional:

✅ Organización del Sistema
✅ Extracción con freeac
✅ Edición de Artwork en GIMP
✅ Conversión a Opus con fLaCon
✅ MediaElch y Metadata Extendido
✅ Backup y Mantenimiento (estás aquí)

Mi colección de CDs ahora está:

Digitalizada en formato lossless (WAV) y eficiente (Opus)
Organizada profesionalmente
Con artwork y metadata completo
Protegida con backups
Lista para disfrutar en cualquier dispositivo

¿Tienes dudas sobre backups o sincronización? ¿Usas otra estrategia? Comparte tu experiencia en los comentarios.

Ayúdame a mejorar con tu puntuación.

Comentarios