Saltar al contenido principal

Nomada digital: Lleva tu home a todas partes

· 14 min de lectura
Oscar Adrian Ortiz Bustos
Contando lecturas...

Introducción​

Quisiera poder decir que solamente he perdido información una vez en mi vida, pero la realidad es que han sido varias. Desde que deja de funcionar un disco duro, hasta que accidentalmente borré archivos importantes. Estas experiencias me han enseñado la importancia de tener un entorno de trabajo portátil y seguro, porque uno nunca sabe cuándo puede necesitar acceder a sus archivos desde otro lugar.

WelcomeBanner

La última vez que me pasó fue particularmente dolorosa. Estaba trabajando en un proyecto importante cuando mi SSD decidió que era un buen momento para jubilarse (por que su generacion si puede) anticipadamente. Sin previo aviso, sin carta de despedida, simplemente dejó de funcionar.

Fue en ese momento que me di cuenta de que mi último backup completo tenía dos semanas de antigüedad. Dos semanas que parecían dos años cuando te das cuenta de todo lo que puedes perder. Después de llorar un poco y aceptar mi destino, decidí que nunca más me volvería a pasar.

Y no, no me refiero a hacer backups ocasionales cuando me acuerde, me refiero a automatizar completamente el proceso para que ni siquiera tenga que pensar en ello. Porque seamos honestos, si algo depende de que yo me acuerde de hacerlo manualmente, eventualmente lo voy a olvidar.

El problema del nómada moderno​

Cuando hablamos de ser un "nómada digital", no me refiero únicamente a esas personas que trabajan desde playas paradisíacas con una laptop y una piña colada. Me refiero a cualquiera que necesite tener su entorno de trabajo disponible en múltiples lugares: tu casa, el trabajo, la universidad, o ese café con WiFi decente.

El verdadero desafío no es solo tener los archivos disponibles, sino tener TODO tu entorno de trabajo: configuraciones, scripts, proyectos, documentos, ese wallpaper que te costó 30 minutos encontrar, etc. Y además, necesitas que esté sincronizado, actualizado y accesible desde cualquier lugar.

Ya he hablado antes sobre la gestión de dotfiles en otro artículo, así que hoy me voy a enfocar en algo igual de importante: mantener un backup completo y automático de tu directorio home.

La solución​

Después de probar varias soluciones, me decidí por una combinación que me ha funcionado perfectamente: rclone para la sincronización y Mega.nz como almacenamiento en la nube.

Por qué rclone​

rclone es como el rsync de los servicios en la nube. Es una herramienta de línea de comandos que te permite sincronizar archivos con más de 40 proveedores de almacenamiento en la nube diferentes. Es rápido, eficiente, open source y lo mejor de todo: se puede automatizar completamente.

Algunas de las razones por las que me encanta rclone:

  • Versatilidad: Soporta casi cualquier servicio de almacenamiento en la nube que se te ocurra
  • Sincronización inteligente: Solo transfiere los archivos que han cambiado
  • Configuración de exclusiones: Puedes excluir fácilmente carpetas que no necesitas respaldar
  • Encriptación: Soporta encriptación del lado del cliente si te preocupa la privacidad
  • Velocidad: Puede paralelizar las transferencias para máxima velocidad

Por qué Mega.nz​

Mega.nz ofrece 20GB gratuitos de almacenamiento, con encriptación de extremo a extremo. Si bien es cierto que Google Drive ofrece 15GB y ya tengo un artículo sobre cómo hacer backups allá, decidí usar Mega para este propósito por varias razones:

  • Más espacio gratuito: 20GB vs 15GB de Google Drive
  • Privacidad: Mega tiene encriptación de extremo a extremo por defecto
  • Diversificación: No poner todos los huevos en la misma canasta
  • Mejor rendimiento con rclone: En mi experiencia, las transferencias son más rápidas

Script​

Después de varios intentos y ajustes, terminé con un script que hace exactamente lo que necesito. Lo llamé creativamente cloudBackup porque como ya sabrás, no soy muy bueno poniendo nombres.

El script está ubicado en /usr/local/bin/cloudBackup.sh para que pueda ejecutarse desde cualquier lugar del sistema.

#!/bin/bash
set -euo pipefail

# Configuration
readonly VERSION="2.0.2"
readonly SOURCE="/home/neandertech"
DEST="mega:backup-home"
readonly EXCLUDE_FILE="${HOME}/.rclone-exclude"
LOG_DIR="${HOME}/.local/log/cloudBackup"
LOG_FILE="${LOG_DIR}/backup-$(date +%Y%m%d-%H%M%S).log"

# Color codes for terminal output
readonly COLOR_GREEN='\033[0;32m'
readonly COLOR_BLUE='\033[0;34m'
readonly COLOR_RED='\033[0;31m'
readonly COLOR_RESET='\033[0m'

# Initialize log directory
mkdir -p "${LOG_DIR}"

log_info() {
    echo -e "${COLOR_BLUE}[INFO]${COLOR_RESET} ${*}"
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [INFO] ${*}" >> "${LOG_FILE}"
}

log_success() {
    echo -e "${COLOR_GREEN}[SUCCESS]${COLOR_RESET} ${*}"
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [SUCCESS] ${*}" >> "${LOG_FILE}"
}

log_error() {
    echo -e "${COLOR_RED}[ERROR]${COLOR_RESET} ${*}" >&2
    echo "[$(date '+%Y-%m-%d %H:%M:%S')] [ERROR] ${*}" >> "${LOG_FILE}"
}

# Parse command line arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        -r|--remote)
            DEST="$2"
            shift 2
            ;;
        *)
            echo "Unknown option: $1" >&2
            exit 1
            ;;
    esac
done

# Create exclusion file if it doesn't exist
if [ ! -f "${EXCLUDE_FILE}" ]; then
    log_info "Creating exclusion file: ${EXCLUDE_FILE}"
    cat > "${EXCLUDE_FILE}" << 'EOF'
.cache/**
.local/share/Trash/**
node_modules/**
.npm/**
.mozilla/firefox/*/Cache/**
.config/Code/Cache/**
*.tmp
*.log
.thumbnails/**
venv/**
__pycache__/**
EOF
fi

log_info "Backup started at $(date '+%Y-%m-%d %H:%M:%S')"
log_info "Source: ${SOURCE}"
log_info "Destination: ${DEST}"

# Perform backup
rclone sync "${SOURCE}" "${DEST}" \
    --exclude-from="${EXCLUDE_FILE}" \
    --fast-list \
    --transfers=8 \
    --checkers=16 \
    --buffer-size=64M \
    --timeout=300s \
    --retries=3 \
    --progress \
    --stats=30s \
    --stats-one-line \
    --log-level=INFO \
    --log-file="${LOG_FILE}"

if [ $? -eq 0 ]; then
    log_success "Backup completed successfully"
    log_info "Finished at $(date '+%Y-%m-%d %H:%M:%S')"
    log_info "Log file: ${LOG_FILE}"

    # Show storage statistics
    log_info "Storage statistics:"
    rclone about "${DEST}"
else
    log_error "Backup failed"
    log_error "Check full log at: ${LOG_FILE}"
    exit 1
fi
MEJORA

Este script es una versión mejorada de mi post anterior sobre backups a Google Drive. Aquí están las mejoras clave:

  • Añadido soporte multi-remote (puedes usarlo con Mega, Google Drive, Dropbox, etc.)
  • Mejores prácticas de bash con set -euo pipefail
  • Sistema de logging profesional con archivos timestamped
  • Parámetros de rclone optimizados para mejor rendimiento
  • Manejo robusto de errores

Desglose del script​

Déjame explicarte las partes importantes del script:

1. Configuración inicial​

set -euo pipefail

Esta línea hace que el script sea más robusto:

  • set -e: Sale inmediatamente si cualquier comando falla
  • set -u: Trata las variables no definidas como error
  • set -o pipefail: Los pipes fallan si cualquier comando en ellos falla

Esto nos permite detectar errores temprano y evitar comportamientos inesperados. Me gusta pensarlo como el try-catch de los scripts bash, al menos en la parte de "catch", lo que a su vez nos permite tener un logging más limpio y eficaz.

ErrorHandling

2. Variables​

readonly VERSION="2.0.2"
readonly SOURCE="/home/neandertech"
DEST="mega:backup-home"
readonly EXCLUDE_FILE="${HOME}/.rclone-exclude"
LOG_DIR="${HOME}/.local/log/cloudBackup"
LOG_FILE="${LOG_DIR}/backup-$(date +%Y%m%d-%H%M%S).log"
  • SOURCE: Tu directorio home completo
  • DEST: El destino, configurable con -r para cambiar de remote
  • EXCLUDE_FILE: Archivo con las carpetas y archivos a excluir
  • LOG_DIR: Directorio de logs con fallback al home del usuario
  • LOG_FILE: Archivo de log único por cada ejecución con timestamp

3. Logging​

El script usa funciones dedicadas para logging que escriben tanto en la terminal (con colores) como en el archivo de log. Esto facilita el debugging y el monitoreo.

LoggingExample

4. Multi-remote​

# Parse command line arguments
while [[ $# -gt 0 ]]; do
    case $1 in
        -r|--remote)
            DEST="$2"
            shift 2
            ;;
    esac
done

Ahora puedes especificar diferentes remotes:

cloudBackup.sh -r gdrive:backups
cloudBackup.sh -r dropbox:backup-home

5. Comando rclone sync​

rclone sync "${SOURCE}" "${DEST}" \
    --exclude-from="${EXCLUDE_FILE}" \
    --fast-list \
    --transfers=8 \
    --checkers=16 \
    --buffer-size=64M \
    --timeout=300s \
    --retries=3 \
    --progress \
    --stats=30s \
    --stats-one-line \
    --log-level=INFO \
    --log-file="${LOG_FILE}"

Aquí está la magia. Déjame explicar cada flag:

  • sync: Hace que el destino sea idéntico al origen
  • --exclude-from: Lee las exclusiones desde un archivo
  • --fast-list: Usa listado rápido para mejor rendimiento
  • --transfers 8: Transfiere 8 archivos simultáneamente (más rápido)
  • --checkers 16: Verifica 16 archivos simultáneamente
  • --buffer-size 64M: Buffer más grande para mejores transferencias
  • --timeout 300s: Timeout de 5 minutos para operaciones
  • --retries 3: Reintenta hasta 3 veces en caso de fallo
  • --progress: Muestra el progreso en tiempo real
  • --stats 30s: Muestra estadísticas cada 30 segundos
  • --stats-one-line: Estadísticas en una sola línea
  • --log-level INFO: Nivel de detalle informativo
  • --log-file: Guarda todo en un archivo de log

6. Verificación​

El script verifica si la operación fue exitosa usando funciones de logging profesionales. También muestra el espacio usado en el remote para que sepas cuánto almacenamiento te queda.

Exclusiones​

Una parte fundamental del backup es saber qué NO respaldar. No tiene sentido llenar tu espacio en la nube con cachés, archivos temporales o node_modules que pesan gigas.

Por que si, todos hemos pasado por esto:

NodeModules

Mi archivo .rclone-exclude se ve así:

.cache/**
.local/share/Trash/**
node_modules/**
.npm/**
.mozilla/firefox/*/Cache/**
.config/Code/Cache/**
.config/Code/CachedData/**
*.tmp
*.log
.thumbnails/**
venv/**
__pycache__/**

Qué excluir​

  • .cache/**: Cachés del sistema que se pueden regenerar
  • .local/share/Trash/**: Tu papelera, no necesitas respaldar basura
  • node_modules/**: Si trabajas con Node.js, sabes que esto puede ocupar gigas y se puede reinstalar con npm install
  • .npm/**: Caché de npm
  • Cachés de navegadores: Se regeneran automáticamente
  • venv/**: Entornos virtuales de Python que se pueden recrear
  • __pycache__/**: Archivos compilados de Python que se regeneran automáticamente
NOTA

Usamos el patrón ** para excluir recursivamente todas las subcarpetas. Esto es más eficiente que solo /.

IMPORTANTE

No excluyas carpetas sin pensarlo dos veces. Asegúrate de que realmente puedas recrear o no necesites esos archivos.

Configuración​

Ahora viene la parte práctica. Te voy a mostrar cómo configurar todo desde cero.

1. Instalar rclone​

En la mayoría de distribuciones Linux, rclone está en los repositorios:

# Debian/Ubuntu
sudo apt install rclone

# Arch Linux
sudo pacman -S rclone

# Fedora
sudo dnf install rclone

También puedes instalarlo con el script oficial:

curl https://rclone.org/install.sh | sudo bash

2. Configurar Mega.nz​

Ejecuta el asistente de configuración:

rclone config

El asistente te guiará paso a paso:

  1. Selecciona n para crear un nuevo remote
  2. Dale un nombre, por ejemplo mega
  3. Selecciona el número correspondiente a Mega
  4. Ingresa tu usuario y contraseña de Mega
  5. Deja las opciones avanzadas por defecto (solo presiona Enter)
  6. Confirma la configuración
NOTA

Necesitas tener una cuenta en Mega.nz. Si no la tienes, crea una en mega.nz o en el servicio que prefieras usar.

3. Archivo de exclusiones​

nvim ~/.rclone-exclude

Copia el contenido que te mostré anteriormente y ajústalo a tus necesidades.

4. Script de backup​

sudo nvim /usr/local/bin/cloudBackup.sh

Copia el script completo, ajusta las rutas según tu usuario y guarda.

Dale permisos de ejecución:

sudo chmod +x /usr/local/bin/cloudBackup.sh

5. Probar el script​

Antes de automatizarlo, pruébalo manualmente:

sudo cloudBackup.sh

La primera ejecución tomará tiempo porque tiene que subir todo. Las siguientes serán mucho más rápidas porque solo subirá los cambios.

Automatización​

Aquí es donde la magia realmente sucede. Vamos a automatizar el backup para que se ejecute sin que tengamos que acordarnos.

Opción 1: Cron​

Edita el crontab:

sudo crontab -e

Agrega una línea para ejecutar el backup. Por ejemplo, todos los días a las 2 AM:

0 2 * * * /usr/local/bin/cloudBackup.sh >> /var/log/cloudBackup-cron.log 2>&1

O cada 6 horas:

0 */6 * * * /usr/local/bin/cloudBackup.sh >> /var/log/cloudBackup-cron.log 2>&1

Opción 2: Systemd timer​

Si prefieres systemd (como yo), puedes crear un timer:

Crea el servicio en /etc/systemd/system/cloudBackup.service:

[Unit]
Description=Backup home directory to Mega.nz
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
ExecStart=/usr/local/bin/cloudBackup.sh
User=root

[Install]
WantedBy=multi-user.target

Crea el timer en /etc/systemd/system/cloudBackup.timer:

[Unit]
Description=Run backup to Mega.nz daily
Requires=cloudBackup.service

[Timer]
OnCalendar=daily
OnBootSec=15min
Persistent=true

[Install]
WantedBy=timers.target

Activa y habilita el timer:

sudo systemctl daemon-reload
sudo systemctl enable cloudBackup.timer
sudo systemctl start cloudBackup.timer

Verifica que esté activo:

sudo systemctl list-timers

Recuperación​

De nada sirve tener backups si no sabes cómo recuperar tus archivos. Con rclone es muy sencillo.

Recuperar todo​

rclone sync mega:backup-home /home/usuario --progress

Recuperar archivo específico​

rclone copy mega:backup-home/ruta/al/archivo.txt /home/usuario/recuperados/

Listar archivos​

rclone ls mega:backup-home

Tamaño del backup​

rclone size mega:backup-home

Seguridad​

Aunque Mega tiene encriptación de extremo a extremo, aquí hay algunas recomendaciones:

  1. Contraseña fuerte: Usa una contraseña robusta para tu cuenta de Mega
  2. Autenticación de dos factores: Actívala en Mega
  3. Encriptación adicional: Si tienes datos muy sensibles, considera usar el módulo de encriptación de rclone
  4. Revisa las exclusiones: Asegúrate de no estar subiendo archivos con contraseñas o tokens
ADVERTENCIA

Nunca subas a la nube archivos como .env, credentials.json, claves SSH sin protección, o cualquier cosa que contenga secretos.

Casos de uso​

Déjame contarte cómo este sistema me ha salvado más de una vez:

Cambio de laptop​

Cuando recientemente cambié mi laptop principal por una nueva, el proceso fue ridículamente simple:

  1. Instalé el sistema operativo base
  2. Instalé rclone y configuré el remote de Mega
  3. Ejecuté rclone sync mega:backup-home /home/neandertech
  4. Esperé a que terminara la sincronización

En menos de una hora tenía mi entorno completo funcionando en la nueva máquina. Todos mis proyectos, configuraciones, documentos, todo.

Incidente del café​

No fue mi café, fue el de un compañero, pero sí, una laptop murió por ahogamiento. Afortunadamente, su backup estaba actualizado de esa misma mañana. Perdió la laptop, pero no perdió ni un solo archivo.

Múltiples lugares​

Como trabajo desde casa, la universidad y a veces desde la oficina, necesito tener acceso a mis archivos desde cualquier lugar. Con este sistema, solo necesito sincronizar antes de empezar a trabajar y todo está actualizado.

Comparación con Google Drive​

Si ya leíste mi artículo sobre hacer backups a Google Drive con Python y cron, te estarás preguntando cuál es la diferencia. Aquí te lo explico:

Google Drive (HomeBack)​

  • Usa Python y la API de Google Drive
  • Más complejo de configurar
  • Limitado a 15GB gratuitos
  • Requiere credenciales OAuth
  • Perfecto si ya estás en el ecosistema de Google

Mega.nz (cloudBackup.sh)​

  • Usa solo bash y rclone
  • Configuración más simple
  • 20GB gratuitos
  • Solo necesitas usuario y contraseña
  • Mejor privacidad con encriptación de extremo a extremo

Personalmente, uso ambos. Google Drive para proyectos y documentos mas específicos y Mega para el backup completo de mi home. Redundancia nunca está de más.

Monitoreo​

Una vez que automatizas algo, es fácil olvidarte de ello. Hasta que algo falla y te das cuenta semanas después. Para evitar eso, aquí hay algunas estrategias:

Revisar logs​

Los logs ahora se guardan con timestamp en ~/.local/log/cloudBackup/:

# Ver el último log
ls -t ~/.local/log/cloudBackup/backup-*.log | head -1 | xargs tail -f

# O ver todos los logs recientes
tail -n 100 ~/.local/log/cloudBackup/backup-$(date +%Y%m%d)-*.log

Notificaciones​

Puedes modificar el script para que te envíe un correo si algo falla. Si instalaste mi herramienta neocomposer, puedes usarla:

# Al final del script, si falla
if [ $? -ne 0 ]; then
    echo "Backup falló" | neocomposer -s "Error en backup"
    exit 1
fi

Espacio disponible​

Mega te avisa cuando estás cerca del límite, pero es bueno revisar:

rclone about mega:backup-home

StorageStats

Conclusión​

Ser un verdadero nómada digital no se trata solo de poder trabajar desde cualquier lugar, se trata de tener la tranquilidad de que tus datos están seguros sin importar qué pase con tu hardware. Un disco duro puede fallar, una laptop puede caerse, pero si tus datos están respaldados automáticamente en la nube, puedes dormir tranquilo.

Este sistema me ha funcionado perfectamente durante meses. Es simple, automatizado y confiable. No tengo que acordarme de hacer backups porque el sistema lo hace por mí. Y esa es la mejor forma de garantizar que realmente se hagan.

Si aún no tienes un sistema de backups automatizado, te invito a que implementes este o alguno similar. No esperes a perder datos importantes para darte cuenta de su importancia. Créeme, ya pasé por eso y no es nada agradable.

¿Tienes alguna otra estrategia para mantener tus datos seguros? ¿Usas algún otro servicio de almacenamiento en la nube? Déjamelo saber en los comentarios.

"La información es poder. La información compartida es poder multiplicado."

— Anónimo
Escrito por un humano