Bareos, un fork de Bacula

Hasta ahora he estado usando BackupPC para hacer las copias de seguridad, sobre todo de los servidores vps remotos. Pero creo que ha llegado la hora de probar Bacula.
En mis búsquedas en Internet para informarme sobre Bacula encontré otro proyecto llamado Bareos que es un fork de Bacula. Parece que el fork se produjo debido a que la empresa que está detrás de Bacula solamente incorporó las mejoras y parches aportados por la comunidad en la versión comercial de Bacula. Ante este hecho algunos de los principales desarrolladores de la comunidad decidieron hacer el fork. Puedes leer más sobre esta historia aquí.

Modulos de Bareos

Bareos se compone de una serie de módulos especializados:

Director

Este módulo es el que se encarga de toda la gestión de las copias de seguridad. Se comunica con el resto de modulos para ordenar una copia de seguridad o para hacer una restauración. Se ayuda de una base de datos para mantener las programaciones así como los catálogos de las copias de seguridad realizadas.

Console

Es una especie de terminal que permite interactuar con el director. Desde aquí se pueden lanzar trabajos y ver su estado.

Storage daemon

Este módulo es el encargado de gestionar los medios de almacenamiento, ya sean discos duros o dispositivos de cinta.

File daemon

También conocido como programa cliente. Es el responsable de interactuar con los archivos a respaldar o restaurar. Cada ordenador que se respalde tiene que tener este servicio instalado.

Web User Interface

Interfaz web para supervisar Bareos, aún no tiene demasiadas funcionalidades.

Aquí tienes el manual de Bareos para seguir leyendo: http://doc.bareos.org/master/html/bareos-manual-main-reference.html

Instalando Bareos en un servidor Ubuntu 14.04 LTS

En este documento el servidor usado para instalar Bareos es Ubuntu 14.04 LTS (64 bit).
La propia gente de Bareos mantienen un repositorio oficial de paquetes de Ubuntu, así que no tenemos problema, simplemente incluimos el repositorio y su clave:

# echo "deb http://download.bareos.org/bareos/release/latest/xUbuntu_14.04/ /" > /etc/apt/sources.list.d/bareos.list

Tuve algún problema con la URL del repositorio, de acuerdo con la documentación era diferente, probablemente cuando estés leyendo esto ya esté resuelto.
Para poder usar este nuevo repositorio bajamos su clave y la instalamos:

$ wget -q http://download.bareos.org/bareos/release/latest/xUbuntu_14.04/Release.key -O- | sudo apt-key add -

Ahora ya podemos instalar Bareos:

# apt-get update
# apt-get install bareos bareos-database-postgresql

Para instalar Bareos tienes que instalar el paquete bareos y el correspondiente a la base de datos que utilices, en mi caso al usar postgresql he instalado el paquete bareos-database-postgresql.

Configurando bareos director

Editar /etc/bareos/bareos-dir.conf para ajustar correctamente los correos electrónicos en las directivas Messages.

Instalando el cliente Bareos en un puesto de trabajo Ubuntu 14.10

Tienes que proceder de la misma forma que en el servidor para configurar el repositorio.
Una vez configurado el repositorio instalamos el cliente:

# apt-get update
# apt-get install bareos-client

Este metapaquete instala bareos-bconsole, bareos-client, bareos-common, bareos-filedaemon y bareos-traymonitor.
Ahora toca ajustar la configuración del filedaemon. Edita /etc/bareos/bareos-fd.conf poniendo los valores adecuados:

Director {
  Name = <bareos server director name>
  Password = "<client filedaemon password>"
}
Director {
  Name = <client bareos monitor name>
  Password = "<client tray monitor password>"
  Monitor = yes
}
FileDaemon { # this is me
  Name = <client filedaemon name>
  Maximum Concurrent Jobs = 20
}
Messages {
  Name = Standard
  director = <server director name> = all, !skipped, !restored
}

La contraseña que figura en la directiva Director -> Password será la contraseña que tiene que usar el servicio director para acceder al servicio filedaemon.
Después de editar hay que reiniciar el servicio filedaemon:

# service bareos-fd restart

Edita /etc/bareos/tray-monitor.conf y establece los valores apropiados:

Storage {
  Name = <server storage daemon name>
  Address = <bareos storage server dns name>
  SDPort = 9103
  Password = "<copy password from srvintranet-sd>"  # look at bareos-fd.conf in server
}

Director {
  Name = <server director name>
  DIRport = 9101
  address = <bareos director server dns name>
}

Messages {
  Name = Standard
  director = <director name> = all, !skipped, !restored
}

Instalando el cliente Bareos en un Ubuntu remoto para usar con un túnel ssh

Lo he extraído de esta guía.

Configurando OpenSSH en la parte del servidor

Hay que crear un directorio .ssh en el directorio home del usuario bareos para poder almacenar allí la pareja de claves ssh:

# mkdir -p /var/lib/bareos/.ssh
# chmod 700 /var/lib/bareos/.ssh
# chown bareos.bareos /var/lib/bareos/.ssh

Ahora creamos la pareja de claves ssh, pero tienes que asegurarte de no cifrar la clave privada con una frase ya que cuando se establezca la conexión el sistema preguntará por esta frase quedándose bloqueado hasta recibir respuesta y esto no es lo que queremos.

Entra como usuario bareos y crea las claves:

$ sudo -Hu bareos bash
$ cd .ssh
$ ssh-keygen -b 2048 -C "SSH Tunnel for bareos" -t rsa -f bareos_tunnel -N ""

Para no tener que usar opciones en el comando ssh creamos un archivo config en el directorio .ssh:

Host <yourclientFQDN>
  AddressFamily           inet
  ConnectionAttempts      10
  ForwardAgent            no
  ForwardX11              no
  ForwardX11Trusted       no
  GatewayPorts            yes
  HostBasedAuthentication no
  HostKeyAlias            <yourclientname>
  HostName                <yourclientFQDN>
  IdentityFile            ~/.ssh/bareos_tunnel
  PasswordAuthentication  no
  Protocol                2
  Compression             yes
  CompressionLevel        9
  ServerAliveCountMax     3
  ServerAliveInterval     15
  TCPKeepAlive            no
  User                    tunneluser

Si el servicio openssh estuviese escuchando en un puerto diferente al estándar 22 se puede añadir la siguiente línea al archivo config (puerto 12345 en este ejemplo):

 Port 12345

Y finalmente transfiere el archivo bacula_tunnel.pub a la maquina cliente.

Configurando OpenSSH en la parte del cliente

Creamos un usuario llamado tunneluser:

# adduser -m -s /bin/false tunneluser

Configuramos esta nueva cuenta de usuario:

# cd /home/tunneluser
# mkdir -p /home/tunneluser/.ssh
# touch /home/tunneluser/.ssh/authorized_keys
# # Asegúrate de usar la doble redirección >>, o destruirás cualquier clave autorizada previa.
# cat <donde_sea>/bacula_tunnel.pub >> /home/tunneluser/.ssh/authorized_keys
# chmod 700 /home/tunneluser/.ssh
# chmod 400 /home/tunneluser/.ssh/*
# chown -R tunneluser:tunneluser /home/tunneluser/.ssh

La primera vez hay que hacer la conexión manualmente para que se almacene la huella digital del host. Ejecuta en el servidor Bareos:

$ sudo -Hu bareos ssh <clientfqdm>

Recuerda que al crear el archivo ~/.ssh/config ya no nos hace falta usar opciones en el comando ssh ya que están configurados en el archivo config.

Instalando y configurando Bareos en la parte del cliente

Procede como antes para configurar el repositorio bareos e instala el filedaemon:

# apt-get install bareos-filedaemon

Edita el archivo de configuración del filedaemon:

Director {
  Name = <nombre director en el servidor bareos>
  Password = "..."
}

FileDaemon {
  Name = <nombre de lfile daemon>
  Maximum Concurrent Jobs = 20
  FDAddress = 127.0.0.1
  FDPort = 9102
}

Ahora aseguráte que el nombre dns del servidor que está corriendo el "storage daemon" no se resuelve desde el cliente, en caso contrario el sistema no funcionará. Crea una entrada en el archio /etc/hosts para que el nombre dns de este servidor resuelva a 127.0.0.1:

127.0.0.1    server-sd.local server-sd

Configuración bareos en la parte del servidor

Configura los recursos client y job en bareos de la forma habitual.

Modifica el recurso client de la siguiente forma:

Name=<yourclientFQDN-fd>
Address=localhost
FDPort=9112  # forward port

Si configuras varios clientes remotos tienes que variar el FDPort en cada uno de ellos.

En el recurso job añade la ejecución de un script antes de hacer el respaldo:

Run Before Job = "/usr/local/sbin/sshbacula <yourclientFQDN> <forward_port>"

El script para establecer el túnel ssh:

#!/bin/bash
# Establishes a self-killing SSH tunnel to the
# given SSH server, and forwards the correct
# ports for bacula usage.

# Bacula-dir runs as user bacula, but with root's
# environment. We need to trick it into running
# actually looking for the .ssh directory in
# the right place.
USER=bareos
HOME=$(grep "^$USER:" /etc/passwd | cut -d : -f 6)
CLIENT=$1
LOCAL=$(hostname -f)
SSH=/usr/bin/ssh
FORWARD_PORT=$2

echo "Starting SSH-tunnel to $CLIENT..."
# -f means: go into background
# -C means: use compression
# -2 means: only use SSH2
# -R 9101:$LOCAL:9101 means: when client connects to remote port 9101 (bacula-dir), it will be
#    forwarded to this machine.
# -R 9103:$LOCAL:9103 means: when client connects to remote port 9101 (bacula-sd), it will be
#    forwarded to this machine.
# -L 9112:localhost:9102 means: when bacula-dir connects to port 9112 (instead of the normal 9102),
#    it will be forwarded to the client's FD. The client will think the connection was to port
#    9102 as usual
# sleep 60 is a simple command that will execute on the server and does nothing for 60 seconds,
# then it exits. This keeps ssh running for 60 seconds. Once we connect to the FD, that
# connection will keep ssh running even beyond the 60 seconds.
# Using this approach, we do not need to tear down the tunnel later, it disconnects itself
# automagically.
# It is important to redirect stdout and stderr, or else bareos will not realize that the
# script has terminated.
$SSH -fC2 -R 9101:$LOCAL:9101 -R 9103:$LOCAL:9103 -L $FORWARD_PORT:localhost:9102 $CLIENT sleep 60 >/dev/null 2>/dev/null
# give ssh a little time to establish the connection.
sleep 10

A tener en cuenta

Cuando se lanza un trabajo la directiva "run before job" se encarga de establecer el tunel para comunicar con el cliente, pero cuando se quiere averiguar el estado del cliente no existe la posibilidad de lanzar previamente la creación del tunel. En este caso no nos queda otro remedio que crear el tunel a mano con el comando:

$ ssh -C2 -R 9101:server-director-ip:9101 -R 9103:server-director-ip:9103 -L 9112:localhost:9102 client-ip -N