Dando vueltas a una sincronización.
#1
Hola

Voy a describir como he configurado una sincronización entre dos nas, en la que una de ellas (la local) le "indica" a la otra (la remota) que puede lanzar su sincronización.



Como buenas normas de seguridad, debemos de tener al menos dos copias de seguridad de datos (algunos os dirán que tres copias).
Recordad que usar un RAID 1, 5 o superiores no es tener una copia de respaldo. Eso es tener los datos mas seguros frente al fallo de un disco.
Una de las copias puede ser en local por temas de rapidez en la restauración , pero una segunda debería estar en el exterior en prevención de desastres en la sede de la nas local.


La historia
Por necesidades del trabajo y limitaciones del ancho de banda, necesitamos sacar al exterior la última copia de seguridad. Esta copia se encuentra en una carpeta "SQL" y previamente ha sido comprimida zip (haremos un script para ello).
Luego para externalizar la copia comprimida, usaremos una segunda Nas de Qnap ubicada en otro lugar.
Evidentemente han de tener conexión a internet (o estar en una red remota)
La peticion de sincronización es lanzada desde la nas destino. Esto se hace para que en caso de desconexiones de red o apagados de la nas destino, la nas origen  no esté 
reintentando el trabajo nos sature con avisos de error.

Lo primero es configurar la nas origen como servidor OpenVPN. Luego configuramos la nas destino como cliente OpenVPN con reconexión automática. Con esto tendremos la conexión entre ellas de forma segura y automática. Si la red es local y está bajo vuestro control, podéis evitar usar VPN.

NAS Local

En hybrid Backup activamos RTRR en la nas origen, tomando nota de la clave ya que habremos de usarla en la nas destino.

   

Podemos hilar mas fino, permitiendo sólo conexiones desde el rango de clientes OpenVPN que en nuestro caso sería 10.0.0.*

El tamaño del archivo a enviar sería de mas de 30GB (es un  archivo de copia de seguridad SQL guardado por un servidor en esa ubicación),
lo cual hace poco interesante enviarlo tal cual porque el proceso se eterniza (aún permitiendo la compresión al vuelo durante la sincronización).
Prefiero hacer una compresión offline que tarde lo que tenga que tardar.
Por ello creo un script en bash que comprime el archivo de copia de seguridad, reduciendolo de los 30GB iniciales a un tamaño de unos 9GB.
Si estáis pensando en películas o fotos, olvidar la compresión porque ya son formatos comprimidos.
El script se encarga de eliminar el archivo original, también deja en la carpeta los "n" últimos archivos comprimidos.
Si por algún motivo hubiese mas de una copia sin comprimir, las comprimiría todas en archivos separados.
Los archivos de las copias originales contienen en su nombre la fecha de la copia. Son nombres del tipo "nombre_db_201812311530.BAK" año 2018, mes 12, día 31, hora 15 y minuto 30. 
Se decide trabajar con las fechas de los nombres y no con las fechas de creación de los archivos. Así que tocará trabajar con cadenas.
Esto se hace para evitar borrados automáticos en el caso de que el servidor SQL deje de hacer copias y permanezcan los "n" últimos.

Tras la realización de la compresión, se crea un archivo de nombre "flag.bik" que será usado por otro script programado en el crontab.

El código del script "compresion_gg.sh" es el siguiente:
#! /bin/bash
#defino rutas
ruta="/share/MD0_DATA/SQL/Backup_GG"
lruta=${#ruta}
ruta1="/share/MD0_DATA/SQL"
inicio=$(date)

# Obtener los archivos de la última copia y saco fecha de ultimo comprimido
ls -At -1 $ruta/*.zip> $ruta1/listaSQLzip2.txt
nocomprimidos=$(wc -l $ruta1"/listaSQLzip2.txt" | awk '{print $1}')
ciclos=$((nocomprimidos))
inicial=1
fechamax="20000101"
for (( c=$inicial; c<=$ciclos; c++ ))
do
    read line
    #calculo la longitud total de la ruta con nombre y extension
    largocompleto=${#line}
    fechafic=${line:$((largonombre-16)):8}
    if [ $fechafic -gt $fechamax ] ; then
        fechamax=$fechafic
    fi
done< $ruta1/listaSQLzip2.txt
#echo "fecha maxima $fechamax"

#ahora lo convierto en fecha y le resto los dias a mantener (copias+1)
copias=6
anyofic=${fechamax:0:4}
mesfic=${fechamax:4:2}
diafic=${fechamax:6:2}
anyo=$(date +%Y)
mes=$(date +%m)
dia=$(date +%d)
fecha1=$(date -d "$fecha1" +$((anyofic))$((mesfic))$((diafic)))
fecha1=$((fecha1-copias))

#ahora borro los comprimidos mas viejos para tener la n copias ultimas
for (( c=$inicial; c<=$ciclos; c++ ))
do
    read line
    largocompleto=${#line}
    fechafic=${line:$((largonombre-16)):8}
    #echo "fechafic=$fechafic y fecha1=$fecha1 "
    if [ $fecha1 -gt $fechafic ] ; then
        rm -f $line
        #echo "borrado fechafic=$fechafic y fecha1=$fecha1 "
    fi
done< $ruta1/listaSQLzip2.txt


#inicio la compresion de los archivos BAK
#echo "hora inicio BBDD "$inicio
ls -At -1 $ruta/*.BAK> $ruta1/listaSQLzip.txt
nocomprimidos=$(wc -l "/share/MD0_DATA/SQL/listaSQLzip.txt" | awk '{print $1}')
ciclos=$((nocomprimidos))
#echo " inicio buble de $nocomprimidos ciclos"
inicio=1
i=1
for (( c=$inicio; c<=$ciclos; c++ ))
do
   read line
        #calculo la longitud total de la ruta con nombre y extension
        largocompleto=${#line}
        #calculo la longitud total del nombre archivo con extension
        largonombre=$((largocompleto-lruta))
        #calculo la longitud del path al archivo
        base=$((largocompleto-largonombre))
        #calculo la longitud del nombre del archivo sin fecha, ni extension
        nombrecorto=${line:$((base)):$((base-16))}
        largonombrecorto=${#nombrecorto}
        largonombrecorto=$((largonombrecorto))
        #echo "ciclo=$i linea $largocompleto, nombre $largonombre, abreviado $largonombrecorto y base $base"
        ((i = i + 1))
        #echo "Proceso /share/MD0_DATA/SQL/Backup_GG${line:$((base)):$((largonombre-4))}"
        # comprimo el archivo a ZIP
        zip /share/MD0_DATA/SQL/Backup_GG${line:$((base)):$((largonombre-4))} $line
        # creo el archivo flag3.bik para saber que he creado un nuevo .zip
        touch /share/MD0_DATA/SQL/flag/flag3.bik
        #echo compruebo si existe el comprimido zip y borro el original
        if [ -f /share/MD0_DATA/SQL/Backup_GG${line:$((base)):$((largonombre-4))}.zip ] ; then
             #echo ""
             rm -f /share/MD0_DATA/SQL/Backup_GG${line:$((base)):$((largonombre-4))}.BAK
        fi
done < $ruta1/listaSQLzip.txt


Si analizamos el script, nos apoyamos en unos archivos temporales para sacar la lista de archivos *.BAK, otro para obtener los archivos *.zip. Se podian haber evitado usando arrays, pero prefiero los archivos ya que en caso de problemas puedo analizar su contenido porque quedan anotados los archivos que se procesaron durante la ejecución del script.
  • "listaSQLzip.txt" va a contener la lista de los archivos con extensión .BAK existentes en la carpeta
  • "listaSQLzip2.txt" va a contener la lista de los archivos con extensión .ZIP existentes en la carpeta

En al Nas origen creamos una tarea de sincronización SIN programación, yo la tengo hecha en formato RTRR, pero puede ser Rsync.
Lo que hace es sincronizar la carpeta "FLAG" donde dejo el arhivo "flag.bik" con una carpeta "FLAG" de la Nas destino.
Esta tarea es casi inmediata en su ejecución, ya que el contenido a transferir es mínimo.

   
En este caso lo hacemos por RTRR, pero podria ser por Rsync. elegimos las carpetas a sincronizar

   
No habilitamos la programación.
La sección de políticas, opciones y eventos las dejamos con valores por defecto.

   
En filtro activamos los tipos de archivo *.bik (flag.bik, flag1.bik....) y limitamos por tamaño ya que son sólo creados, no tienen contenido y su tamaño es cero.

La secciones de políticas, opciones y eventos las dejamos con valores por defecto.

La cronología del proceso en la Nas origen podría ser así:

9:00 se lanza desde el servidor de SQL la copia en una carpeta de la Nas de Qnap, a las 9:30 termina de crear el archivo .BAK. Esto es ajeno a la Nas.

Por tarea crontab 10:30 se lanza el script de compresión de los archivos BAK de la carpeta "compresion_gg.sh". Quedarán en la carpeta los "n" últimos comprimidos y creando el archivo "flag.bik" que nos indica que ha comprimido algo. La duración de esta tarea es muy variable y no sabemos la duración, ya que se ve influenciada por el número de archivos a comprimir, de la carga de trabajo de la Nas y del modelo de procesador de la Nas.

Hay una tarea programada "comprobarflag.sh" crontab que se ejecuta cada 30 minutos que lanza un script que comprueba si hay algún archivo del tipo "flag.bik" en la carpeta local "FLAG". Si los hay lanza una tarea de Hybrid Backup que sincroniza los "flag.bik" hacia la Nas destino. Y luego el script elimina de la carpeta local "FLAG" los archivos "flag.bik". Si no hacemos esta eliminacón, la tarea volvería a lanzarse cada 30 minutos.

El contenido del script "comprobarflag.sh" es el siguiente:
#! /bin/bash
ruta1="/share/MD0_DATA/SQL/flag"
#Compruebo si existe el archivo flag1.bik
if [ -f $ruta1/flag1.bik ]; then
    #lanzo el trabajo de Hybrid Backup para copiarlos a la otra NAS
    qsync -j:Job1 -c:/etc/config/qsync/qsync.conf
    #elimino los *.bik tras la sincronización.
    rm -f $ruta1/flag*.bik
fi


En el anterior script hay una línea que lanza la tarea Job1 del Hybrid Backup. Esto se ha comentado en el hilo siguiente el como saber que Job es el adecuado.

En el crontab de la nas tendriamos que agrega los trabajos de copia y el periódico de comprobación de flags. Las líneas serían:
30 10 * * * /share/MD0_DATA/SQL/compresion_gg.sh
*/30 * * * * /share/MD0_DATA/SQL/comprobarflag.sh



NAS Remota

Hay una tarea programada crontab que se ejecuta cada 30 minutos que lanza un script. Se comprueba si hay algún archivo del tipo "flag.bik" en la carpeta local "FLAG". Si los hay, lanza una tarea de Hybrid Backup que sincroniza RTRR los archivos "*.zip" de la carpeta.


Dentro de Hybrid Backup creamos un perfil de la conexión RTRR con los datos de la nas origen
   
No hace falta activar la SSL, ya que estamos conectados dentro de un túnel VPN.


La tarea Hybrid Backup es la siguiente
   

Aquí configuramos el servidor RTRR (la nas remota que hace de servidor), los pares de carpetas a sincronizar

   

Es importante que no haya programación.
   

Marco eliminar archivos extras para que sólo queden los últimos archivos recibidos
   

Aquí activamos la extensión de los archivos (para evitar traer otros) y los modificados desde hace 1 día

En el apartado opciones no toco nada y queda como está.

   

 Activo el envío de correo informativos en caso de fallo. Aunque algo similar se hace y en los scripts.
Hay una tarea programada "comprobarflag.sh" crontab que se ejecuta cada 30 minutos que lanza un script que comprueba si hay algún archivo del tipo "flag.bik" en la carpeta local "FLAG". Si los hay lanza una tarea de Hybrid Backup que sincroniza los "*.bak" desde la Nas origen. Y luego el script elimina de la carpeta local "FLAG" los archivos "flag.bik". Si no hacemos esta eliminacón, la tarea volvería a lanzarse cada 30 minutos.


El contenido del script "comprobarflag.sh"  es:
#! /bin/bash
ruta="/share/MD0_DATA/Datos/MSSQL"
ruta1="/share/MD0_DATA/Datos/MSSQL/flag"
#Compruebo si existe el archivo flag1.bik para lanzar la tarea Hybrid Backup
if [ -f $ruta1/flag1.bik ] ; then
    #lanzo el trabajo de Hybrid Backup para copiarlos a la otra NAS
    qsync -j:Job1 -c:/etc/config/qsync/qsync.conf
    #elimino los *.bik
    rm -f $ruta1/flag*.bik
fi


Nuevamente tenemos una línea que lanza una tarea Job del Hybrid Backup. Para saber el porqué echa una ojeada al hilo siguiente

Ahora sólo nos quedaría agregar este script en el crontab de la nas para que se ejecute cada 30 minutos

*/30 * * * * /share/MD0_DATA/Datos/SQL/comprobarflag.sh



Para la conservación de las tareas agregadas al crontab tras el reinicio de las Nas, se ha creado un "qpkg" ficticio que las agrega y aplica.
Se cuenta algo en el hilo siguiente en la respuesta 7, aunque en ese caso se aplica en un autoarranque, pero está explicado que líneas hay que agregar al autoinicio.

Seguramente no será el proceso mas optimizado, pero  basándonos en tareas mas o menos sencillas he conseguido lo que buscaba. Se han usado tareas Crontab, scripts bash, tareas de Hybrid Backup y servidores RTRR.

En resumen los que se hace es:

1-NAS_1: Comprimo los archivos y creo un Flag
2-NAS_1: Hay una tarea periódica que comprueba si existe el Flag anterior.
    2.1- NAS_1: Si existe el flag, lo copia a la otra nas por una tarea Hybrid Backup.
3-NAS_2: Hay una tarea periódica que comprueba si existe el Flag
    3.1- NAS_2: Si existe el flag, ejecuto tarea RTRR para traer los comprimidos de hace un día.

Como siempre, si veis errores o erratas me lo comunicáis por privado y lo corrijo.
Un saludo

Agur eta ondo ibili

Mon (TS-469Pro y TVS-673)
 Responder
#2
Una pasada de post Ganekogorta, muchas gracias!
TS-251A-4G  2 x Seagate ST4000VN000 4TB
 Responder
#3
(25-12-2017, 08:06 AM)Qnapero escribió: Una pasada de post Ganekogorta, muchas gracias!

Gracias, lo único que pretendía es que se vea que podemos hacer mas cosas que lo que permite el entorno gráfico.

Por cierto, he visto un fallo en la tarea del Hybrid Backup y es que aunque pongo un día de antigüedad, me conserva las DOS últimas copias dependiendo de cuando se realiza la tarea. En mi caso real la cosa se complica un poco más porque hago tres tareas de compresión diferenciadas a distintas horas y a distintas BBDDs. Como la tarea de chequeo es cada 30min está se encarga de sincronizar las tres compresiones si fuese necesario y se encarga de eliminar esa segunda copia.

Pero aún así gano espacio en la Qnap destino al tenerlo comprimido y tiempo en la transferencia diaria.
Un saludo

Agur eta ondo ibili

Mon (TS-469Pro y TVS-673)
 Responder


Usuarios navegando en este tema: 1 invitado(s)


Powered By MyBB 1.8.6, © 2002-2018 MyBB Group
Hora: 16-01-2018, 08:17 PM