Hoy aprenderemos cómo, mediante herramientas de línea de comandos como MegaFuse, podemos realizar backups de nuestros servidores directamente usando servicios de nube como MEGA.

---

Escenario inicial

Supongamos que disponemos de un servidor en Internet, y no tenemos (o no queremos usar) tanto espacio en disco para almacenar nuestros backups o copias de seguridad.

Una solución sería programar un script (o utilizar alguna herramienta automatizada como Bacula) para realizar nuestros backups, y periódicamente descargarlos a nuestro ordenador.

Esta descarga puede ser también automatizada, rsync, scp o ftp/ftps incluso pueden sernos de utilidad.

Pero pensemos, teniendo servicios de almacenamiento en la nube, como Dropbox, Mega, GDrive, o incluso, servicios montados por nosotros con herramientas como OwnCloud, por qué no aprovecharlos?

Caso particular de Mega

Primero y principal, no dispongo de un servidor con capacidad de almacenamiento y un owncloud montado.

Por otro lado, Dropbox me da poco espacio de almacenamiento para cuentas nuevas, y no me resulta suficiente para mis backups.

Aunque Google Drive tiene más capacidad, y pueden montarse directorios en el sistema utilizando sistemas de archivos FUSE como el desarrollado por OcamL, me ha resultado más cómodo trabajar, me he decantado por utilizar MegaFuse, un sistema de archivos FUSE que conecta directamente con una cuenta de MEGA de 50G cifrados, suficientes para almacenar los backups que necesito 🙂

Opciones de Mega

Como mencioné, vamos a utilizar MegaFuse en esta oportunidad, pero no es la única alternativa que tenemos para trabajar con Mega.

Con una herramienta particular denominada MegaTools podemos autenticarnos en nuestra cuenta de Mega, listar archivos, subir y bajar archivos, etc, y sería de utilidad.

¿Por qué decidí usar MegaFuse?

Simplemente porque me resultó más atractivo montar el directorio raíz de una cuenta de Mega en un punto de montaje Linux como se monta cualquier dispositivo, y copiar el backup directamente dentro del directorio montado, con lo que se sincronizará en la cuenta de Mega.

Las otras opciones las iremos analizando en otros artículos 🙂

Instalando MegaFuse

Vamos a hacer la prueba de concepto sobre un Debian 8.6, pero es válido para casi cualquier distro.

En Debian vamos a instalar los siguientes paquetes necesarios para compilar MegaFuse y utizarlo.

sudo apt-get install libcrypto++-dev libcurl4-openssl-dev libdb5.3++-dev libfreeimage-dev libreadline-dev libfuse-dev make

Luego vamos a proceder a descargar la aplicación desde este link, en mi caso, bajé la última versión disponible al tiempo de escribir este artículo:

cd /opt/
# clonamos el repo oficial:
git clone https://github.com/matteoserva/MegaFuse
cd MegaFuse
# y compilamos:
make

Si obtenemos algún error relacionado relacionado con la función «ceil» similar a este:

src/file_cache_row.cpp:72:13: error: ‘ceil’ was not declared in this scope

Podemos encontrar la solución modificando un par de líneas de código fuente siguiendo este enlace.

Ahora dispondremos del binario compilado (si no hubo ningún error) en /opt/MegaFuse/MegaFuse

Configuración de la cuenta

Me creé una cuenta para backups de archivos de JuncoTIC en Mega, y creé un archivo de configuración en mi directorio home llamado .megafuse.conf con el siguiente contenido:

USERNAME = nombre_de_login_mega
PASSWORD = contraseña_super_secreta_123123
MOUNTPOINT = /tmp/mega/
CACHEPATH = /tmp/megacache/

Username y Password sirven para el login a los servidores de Mega.

MountPoint y CachePath son utilizados para especificar el punto de montaje de la cuenta de mega en el sistema, y su directorio de cache temporal.

En este caso particular, ambos los he creado dentro de TMP, puesto que la idea es realizar el backup, montar la cuenta de mega usando FUSE, copiar el contenido, y desmontar.

Le damos permisos restringidos, puesto que es un archivo crítico por contener username y password de un servicio:

sudo chmod 0600 ~/.megafuse.conf

Y el script de backup

Ahora, un pequeño script de backup que realiza todas las tareas de backup que necesito, y por supuesto, puede ser modificado y adaptado a cada necesidad.

Este script:

• Crea backup de las bases de datos Mysql que dispongo en el sistema
• Crea backup en tarball de los archivos de sitios web que tengo en /var/www/html (es un web hosting)

Si necesitamos algo más, será cuestión de editarlo y agregarle lo que nos parezca.

#!/bin/bash
# Diego Cordoba - @d1cor / juncotic.com

# Nombre del servidor sobre el que estamos realizando el backup
SERVER="NombreDelServidor"

# Directorio temporal de backup (para tar)
TMP_DIR="/home/admin/tmp/bkp"
 
# Credenciales de acceso a la DB
MYSQL_USER="backup_user"
MYSQL_PASSWORD="supersecretisimo123"

# Especificacion del basedir para los sitios web:
WEBS_DIR="/var/www/html"

# Binario de MegaFuse a ejecutar:
MEGA_BIN=/opt/MegaFuse/MegaFuse
MEGA_CONF=/home/admin/.megafuse.conf

# Punto de montaje Mega y cache path (deben coincidir con los del archivos de conf .megafuse.conf
MOUNTPOINT="/tmp/mega"
CACHEPATH="/tmp/megacache"

# calculamos la fecha para diferenciar a los backups
DATE="$(date +%Y%m%d_%H%M%S)"

##################################
## Creamos el dir temporal de backup
rm -rf ${TMP_DIR}
mkdir ${TMP_DIR}
cd ${TMP_DIR}
 
# Backup de la db mysql
echo "MYSQL Backup"
mkdir ${TMP_DIR}/mysql
for db in $(mysql -u${MYSQL_USER} -p${MYSQL_PASSWORD} -e 'show databases;' | grep -Ev "^(Database|mysql|information_schema|performance_schema|phpmyadmin)$"); do
    echo "Procesando db: ${db}"
    mysqldump --opt -u${MYSQL_USER} -p${MYSQL_PASSWORD} "${db}" | gzip > ${TMP_DIR}/mysql/${db}_$(date +%F_%T).sql.gz
done

echo "Y un sql.gz de toda la base de datos, por las dudas :)"
mysqldump --opt -u${MYSQL_USER} -p${MYSQL_PASSWORD} --ignore-table=mysql.event --all-databases | gzip > ${TMP_DIR}/mysql/ALL_DATABASES_$(date +%F_%T).sql.gz

##################################

# Backup websites
echo "Backup de websites"
mkdir ${TMP_DIR}/websites
for dir in $(find ${WEBS_DIR} -mindepth 1 -maxdepth 1 -type d)
do
    echo "Procesando dir: $dir"
    cd $(dirname ${dir})
    sudo tar czf ${TMP_DIR}/websites/$(basename ${dir}).tar.gz $(basename ${dir})
    cd - > /dev/null
done

##################################

## Eliminamos dirs de cache y mountpoint, y los re-creamos
rm -rf $MOUNTPOINT/
rm -rf $CACHEPATH/

mkdir $MOUNTPOINT
mkdir $CACHEPATH

echo "Montando directorio Mega"
sudo umount megafuse
$MEGA_BIN -c $MEGA_CONF &> /dev/null &

## Esperamos  a que se monte para seguir
while  [ $(mount|grep megafuse|wc -l) -ne 1 ]; do
    echo "esperando que mega monte..."
    sleep 1
done

## si no está creado el dir del backup del server en Mega, lo creamos
[ ! -d $MOUNTPOINT/backup_${SERVER} ] && mkdir $MOUNTPOINT/backup_${SERVER}
 
echo "Moviendo al dir montado..."
mv ${TMP_DIR} $MOUNTPOINT/backup_${SERVER}/$DATE
sync

# Esperamos un tiempo prudencial para desmontar el directorio y limpiar los temporales
# (Esto es Alpha, aquí reemplazar por un codigo mas elegante please :P)
sleep 600
echo "limpiando"
sudo umount $MOUNTPOINT
sudo rm -rf ${TMP_DIR}

# Matando al proceso de MegaFuse por si quedó algo dando vueltas...
sudo kill -9 $(ps fax|grep .megafuse.conf|grep -v grep |awk -F' ' '{print $1}')

Algunas notas sobre el script:

• Este script realiza el backup completo de base de datos y directorios de websites, y luego monta la cuenta de mega en el mountpoint especificado, y luego lo desmonta.
  Una opción es montarlo por default al iniciar el sistema, y nunca desmontarlo… esto es simplemente un ejemplo.
• El script realiza backups completos únicamente, pero podría utilizarse tar también para realizar backups incrementales cada día, y guardar los cambios también en Mega.
• El script es una modificación y adaptación del que publicó Mateo Matei en su sitio personal.

Por último, faltaría cronear la ejecución del script periódicamente para que, por ejemplo, todos los domingos a las 5 de la mañana, realice el backup semanal (o a la periodicidad que resulte cómodo).

El nombre de este script, en mi caso, es megafusebkp.sh.

Para ello:

crontab -e

Y agregamos algo similar a esto:

0 5 * * 0 /home/admin/scripts/megafusebkp.sh 2>&1|tee -a /home/admin/scripts/logs/megafusegpk.log

En este caso el script se ejecuta todos los domingos a las 5.00 de la mañana, y la salida estándar y de error es almacenada en un archivo de log dentro de mi home, llamado megafusebkp.log así puedo saber si el backup se realizó correctamente o no 🙂

Finalmente, si entramos en la cuenta de Mega configurada, veremos algo así (ya tengo dos backups del mismo server):

Backups incrementales?

En este artículo hemos hablado sobre cómo «subir» a la nube de Mega un backup creado. En el script hemos utilizado varios comandos para crear el backup según nuestras necesidades… hemos usado particularmente tar para empaquetar y comprimir archivos, y mysqldump para crear backups de las bases de dato.

No es la finalidad de esta entrada adentrarnos en la gestión ni herramientas avanzadas de backup, pero si están interesados en crear backups incrementales con tar, pueden visitar esta otra entrada que he creado al efecto:

TAR y los backups incrementales en GNU/Linux

Conclusión

¡Hasta aquí llegamos!

Hemos aprendido a utilizar MegaFuse para montar una cuenta de Mega en nuestro Linux, y hemos repasado un breve script de backup que puede ser adaptable a las necesidades de cualquiera.

Cabe tener en cuenta un dato importante: el usuario que he utilizado para la conexión a la base de datos MySQL es un usuario creado específicamente para ello, y al que le he dado permiso de lectura y consulta en todas las bases de datos, pero no permisos de modificación y alteración de las tablas.

Es importante tener en cuenta que conectarse a la base de datos como usuario root no debería ser una opción, puesto que si se compromete el script de backup, cualquier usuario podría hacerse con la clave de root y causarnos dolores de cabeza.

¡Espero que les sea de utilidad!

¡Cualquier sugerencia, corrección del script o alternativas son bienvenidas! No tienen mas que comentar el artículo en el blog. Gracias!

Update 20190329

Quiero agregar en este apartado una variante del script original que en este caso ha adaptado el amigo Luis Urbina, y que tan gentilmente me ha compartido en los comentarios del artículo!

Gracias Luis por la mención y por el aporte! Dejo aquí el enlace a su repositorio en GitHub para que puedan visitarlo:

https://github.com/luisurbinanet/megafuse-backup-script