Bacula es un conjunto de programas Open Source, listos para la empresa, que permiten administrar los backups, restauración y verificación de datos en una red heterogénea.
Bacula es relativamente fácil de usar y eficiente, a la vez que ofrece muchas funcionalidades avanzadas para la administración de los datos almacenados, lo cual facilita hallar y recuperar archivos perdidos o dañados. En términos técnicos, Bacula es un sistema de backups Open Source, orientado a la red y listo para la empresa.
Se basa en una arquitectura Cliente-servidor que resulta eficaz y fácil de manejar, dada la amplia gama de funciones y características que brinda; copiar y restaurar ficheros dañados o perdidos.
Considere los siguiente al leer este manual:
- La version de bacula que se instala es la 5.2
- Se usara la version de postgresql 9.2
- Algunos comandos que se muestran necesitaran de privilegios de super-usuario, considere usar
sudoó ejecutar el comando como super-usuario
Componentes
Los componentes de Bacula son:
Bacula-director
Es el servicio (bacula-dir) que gestiona la lógica de los procesos de respaldo y administra los demás servicios que componen Bacula. El servicio bacula-dir hace uso de un servicio de base de datos donde guarda informacion importante del servicio (Trabajos, Listas de archivos respaldados, etc. Conocido como catalogo) y esta debe estar accesible a bacula-dir.
En el archivo de configuración de este servicio se especifica dónde y cómo acceder al resto de los servicios.
Bacula-storage
Este servicio (bacula-sd) es el encargado de manejar los dispositivos de almacenamiento fisicos que se usaran para resguardar los respaldos, tales como: discos locales, grabadoras de CD o DVD, unidades de cinta, volúmenes NAS o SAN, etc.
Su fichero de configuración define los dispositivos de almacenamiento disponibles y los directores (bacula-dir) que pueden utilizarlo.
Bacula-file
Mediante este servicio (bacula-fd) Bacula obtiene los ficheros que necesita respaldar, éste es el componente que hay que instalar en las máquinas que necesiten respaldo. Realiza la función de agente cliente.
Bacula-console
Este es el cliente de administracion que se conecta al bacula-director. En el podemos realizar trabajos de restauracion o ejecucion de respaldos manuales, monitorear el estatus de los servicios que componen Bacula.
Instalación
En esta ejemplo de instalacion manejaremos la siguiente arquitectura.
Base de datos
Todo el conjunto de elementos que forman Bacula trabaja en sincronía y es totalmente compatible con bases de datos como MySQL, SQLite y PostgreSQL.
Usaremos el gestor de base de datos PostgreSQL 9.2 en donde se guardara el catalogo de archivos que se respaldan y otras variables importantes para Bacula.
Instalación del servicio
$ yum install postgresql-server
Inicio automático del servicio
$ systemctl enable postgresql.service
Iniciar las bases de datos y el servicio
$ postgresql-setup initdb
$ systemctl start postgresql.service
Configuracion del servicio
$ vim /var/lib/pgsql/data/postgresql.conf
listen_addresses = 'localhost'
port = 5432
max_connections = 100
client_min_messages = notice
log_min_messages = notice
log_min_error_statement = error
log_connections = on
log_line_prefix = '%t %u %d'
Configuraciones de acceso
$ vim /var/lib/pgsql/data/pg_hba.conf
# TYPE DATABASE USER CIDR-ADDRESS METHOD
# "local" is for Unix domain socket connections only
local all all peer
# IPv4 local connections:
host all all 127.0.0.1/32 md5
# IPv6 local connections:
host all all ::1/128 md5
Aplicar los cambios
$ systemctl restart postgresql.service
Instalación de los componentes
Instalamos los paquetes de bacula que necesitamos en el servidor
$ yum install bacula-console bacula-director bacula-storage
Configuración de la base de datos bacula
Bacula nos ofrece scripts para configurar la base de datos para el catalogo. Estos comandos son para configurar la base de datos de bacula en Postgresql
$ su postgres -c "/usr/libexec/bacula/create_bacula_database postgresql"
$ su postgres -c "/usr/libexec/bacula/make_bacula_tables postgresql"
$ su postgres -c "/usr/libexec/bacula/grant_bacula_privileges postgresql"
Asignamos una contraseña al usuario bacula de postgresql
$ su postgres -c "psql"
postgres=# ALTER USER bacula WITH LOGIN ENCRYPTED PASSWORD 'MiContraseña';
Otras configuraciones
$ gpasswd -a bacula postgres
Configuración de los componentes
Los archivos de configuracion se encuentran en el directorio /etc/bacula
Bacula-sd
Primero empezamos con la configuración del storage daemmon, este servicio se encarga de administrar los medios de almacenamiento fisicos, el archivo de configuracion encuentra nombrado generalmente como bacula-sd.conf.
En la sección Storage definimos opciones como el puerto del servicio, directorios donde se alojaran el PID de servicio, cola de tareas, etc. También definimos cuantos trabajos máximos ejecutara el Storage.
Storage {
Name = bacula-sd
SDPort = 9103
WorkingDirectory = "/var/spool/bacula"
Pid Directory = "/var/run"
Maximum Concurrent Jobs = 50 # Ajustar el máximo de trabajos
}
En esta parte definimos la contraseña con la cual bacula-dir se conectara con nuestro servicio bacula-sd.
Director {
Name = bacula-dir
Password = "PasswordSuperSecretoSD" # Contraseña de bacula-sd
}
Comentamos la siguiente seccion.
#Director {
# Name = bacula-mon
# Password = "dsd"
# Monitor = yes
#}
En esta sección definimos las características de nuestro medio de almacenamiento. Configuramos el Device con el nombre de DiscoNFS, sera un medio de almacenamiento de tipo File (este tipo pueden ser medios externos de almacenamiento montados en el sistema).
Device {
Name = DiscoNFS # Nombre de nuestro dispositivo
Media Type = File # Tipo de medio
Archive Device = /mnt/backups # Punto de montaje
LabelMedia = yes;
Random Access = Yes;
AutomaticMount = no;
RemovableMedia = no;
AlwaysOpen = no;
}
Punto de montaje NFS
Como parte de la arquitectura de configuracion de ejemplo montaremos un recurso compartido NFS (previamente configurado) en /mnt/backups que nos servira para guardar los backups.
Considere esto un paso opcional, usted puede solo usar un directorio valido de su sistema para alojar los respaldos. Bacula recomienda instalar el servicio bacula-sd en un servidor standalone.
$ yum -y install nfs-utils
Iniciamos los servicios
systemctl restart rpcbind
systemctl start nfs-lock
systemctl start nfs-idmap
systemctl start nfs-mountd
Habilitamos los servicios
$ systemctl enable rpcbind
$ systemctl enable nfs-lock
$ systemctl enable nfs-idmap
$ systemctl enable nfs-mountd
Montando la carpeta NFS
sudo mount -v -t nfs -o sec=sys,proto=tcp 192.168.x.x:/volume/backups /mnt/backups
Si no tenemos ningun problema procedemos a editar el archivo fstab para que el sistema monte la carpeta al iniciar.
$ vim /etc/fstab
192.168.x.x:/volume1/backups /mnt/backups nfs timeo=14,intr,_netdev 0 0
Bacula-dir
Ahora empezaremos la configuración del Bacula director, este se encuentra nombrado como bacula-dir.conf, en este archivo encontraremos las siguientes opciones para configurar.
En la sección Director dentro del archivo de configuración, configuramos el maximo de trabajos concurrentes y la contraseña para bacula-dir (Esta contraseña se usa para conectarse desde la consola de administracion, bconsole).
Director {
Name = bacula-dir
DIRport = 9101
QueryFile = "/etc/bacula/query.sql"
WorkingDirectory = "/var/spool/bacula"
PidDirectory = "/var/run"
Maximum Concurrent Jobs = 1 # Numero maximo de trabajos concurrentes
Password = "MiSuperPaswordBaculaDIR" # Contraseña de bacula-dir
Messages = Daemon
}
La seccion FileSet es donde se define los archivos y directorios que se respaldaran, así como los que serán excluidos, se puede declarar mas de un FileSet.
FileSet es requerido en la definicion Job.
Vamos a declarar un FileSet con el nombre Linux Set, este tendra un cifrado de tipo SHA1 e ira comprimido con GZIP.
FileSet {
Name = "Linux Set" # Nombre
Include {
Options {
signature = SHA1 # Tipo de cifrado
compression = GZIP # Tipo de compresión
}
File = / # Archivos que se respaldaran
File = /boot
}
Exclude { # Archivos que no se respaldaran
File = /tmp
File = /proc
File = /dev
File = /sys
File = /net
File = /misc
File = /lost+found
}
}
En la seccion Schedule, se especifica el tipo, fecha y hora en que se realizara los trabajos de respaldo. En la variable Run definimos primero el tipo de respaldo (completo, diferencial o incremental) y despues su ciclo de ejecucion (definido tipo crontab).
Schedule es requerido en la definicion Job.
Definamos un schedule con el nombre CicloServidores que ejecurata un tipo de respaldo completo (Full) todos los primer domingo de cada mes, ejecutara un respaldo direfencial (Differential) apartir del segundo al quinto domingo de cada mes y un respaldo incremental de lunes a sabado (Incremental); todos las tareas se ejecutan a las 23 horas.
Schedule {
Name = "CicloServidores" # Nombre
Run = Full 1st sun at 23:00 # Full – Mensual
Run = Differential 2nd-5th sun at 23:00 # Diferencial – Semanal
Run = Incremental mon-sat at 23:00 # Incremental – Diario
}
En la seccion Storage se configura las credenciales del servicio de almacenamiento (bacula-sd). También se define el dispositivo (device) donde se realizará el respaldo.
Configuramos el Storage con el nombre LocalStorage, configuramos las credenciales de acceso, direccion de red y el dispositivo que configuramos en bacula-sd.
Storage {
Name = LocalStorage # Nombre
Address = 192.168.x.x # No usar localhost
SDPort = 9103
Password = "PasswordSuperSecretoSD" # Contraseña de bacula-sd
Device = DiscoNFS # Nombre del dispositivo
Media Type = File # Tipo de medio
}
En la directiva Address es importante no usar localhost o la ip 127.0.0.1, si tienes corriendo el servicio bacula-sd en el mismo servidor del bacula-dir (como es nuestro caso) usa la IP LAN o nombre de dominio asignado al servidor.
En la seccion Catalog definimos la base de datos que previamente configuramos en PostgreSQL.
Le asigamos el nombre MiCatalogo y configuramos los accesos.
Catalog {
Name = MiCatalogo # Nombre del catalogo
dbname = "bacula"; dbuser = "bacula"; dbpassword = "PasswordSuperSecretoDB"
}
El recurso Pool define el conjunto de volúmenes asociados a un trabajo (Job), es decir es una agrupacion de volúmenes de respaldo que se asocian a un trabajo.
Como buena practica podemos crear un Pool por cliente.
Creamos un Pool con el nombre PoolCliente01 y configuramos de la siguiente forma.
Pool {
Name = PoolCliente01 # Nombre
Pool Type = Backup # Tipo backup
Recycle = yes # Bacula reutilizara volumenes expirados.
AutoPrune = yes # Borra los trabajos en volumenes expirados
Action On Purge = Truncate # Trunca los datos cuando se ejecuta purge
Volume Retention = 2 months # Expiracion de datos
Maximum Volume Bytes = 10G # Maxima capacidad por volumen
Maximum Volumes = 5 # Numero de volumenes en el pool
Label Format = "VolCliente01-" # Formato para autonombrar los volumenes
}
Ahora en la seccion Client se define al cliente (bacula-fd), aquí se especifica las credenciales que se utilizara para conectarse, también se define la política de retención de datos y procesos/trabajos.
Client {
Name = cliente01 # Nombre
Address = cliente01.example.com # IP ó dominio
FDPort = 9102
Catalog = MiCatalogo # Catalogo definido
Password = "PasswordSuperSecretoFD" # Contraseña de acceso del cliente
File Retention = 2 months # Días de retencion
Job Retention = 3 months # Expira un trabajo
}
Y por ultimo (y no menos importante) el recurso Job, aqui se define un trabajo de respaldo ó restauracion y se definen otros atributos como bajo que cliente se realizará el respaldo (Client), el conjunto de datos a respaldar (FileSet), el esquema de agrupacion de los volumenes (Pool), los horarios de ejecucion (Schedule) y donde se almacenaran los datos fisicamente (Storage).
Para cada cliente debemos generar dos tipos de Job:
- Backup. Respaldo
- Restore. Restauracion
También existe el seccion JobDefs que nos sirve como una plantilla para usar en los Job, esto es util porque aveces entre los Job pueden compartir ciertos parámetros y no seria necesario declararlos en todos.
# Plantillas para los Job
JobDefs {
Name = "BackupServerLinux" # Nombre
Type = Backup # Tipo de trabajo
Level = Incremental # Nivel
Schedule = "CicloServidores" # Ciclo de ejecución
Storage = LocalStorage # Donde se guarda el respaldo
Messages = Standard # Tipo de notificación
FileSet = "Linux Set" # Archivos que respaldara
Priority = 10 # Prioridad
Write Bootstrap = "/var/spool/bacula/%c_server.bsr" # Log del trabajo
}
JobDefs {
Name = "RestoreServerLinux" # Nombre
Type = Restore # Tipo de trabajo
Storage = LocalStorage
FileSet = "Linux Set"
Messages = Standard
Where = /tmp/bacula-restores # Directorio de restauración
}
#
# Definicion de trabajos
#
Job {
Name = "BackupCliente01" # Nombre
JobDefs = "BackupServerLinux" # Plantilla de Job
Client = cliente01 # Cliente que lo usara
Pool = PoolCliente01 # Pool de volumenes que usara
}
Job {
Name = "RestoreCliente01"
JobDefs = "RestoreServerLinux"
Client = cliente01
Pool = PoolCliente01
}
En la variable Where del JobDefs“RestoreServerLinux” es donde señalamos en que directorio del cliente se va restaurar los archivos.
Firewall
Tenemos que abrir los puertos de los servicios bacula-dir (9101) y bacula-sd (9103) en protocolo TCP.
Iptables:
$ vim /etc/sysconfig/iptables
-A INPUT -m state --state NEW -m tcp -p tcp --dport 9101 -j ACCEPT
-A INPUT -m state --state NEW -m tcp -p tcp --dport 9103 -j ACCEPT
$ service iptables restart
Firewalld:
$ firewall-cmd --zone=public --add-service=bacula --permanent
$ firewall-cmd --reload
Bacula-fd (Cliente)
Una vez terminado con la configuración del director y haber declarado los clientes que se conectaran para ser respaldados procedemos a instalar en los clientes (bacula-fd).
Instalación
La instalación de Bacula-fd es diferente entre el centos 6.x y 5.x, esta radica en que en CentOS 5.x no se encuentra en los repositorios conocidos y se tiene que instalar desde las fuentes.
En Centos 6.x, 7
En centos 6.x y 7 podemos encontrar bacula-fd desde los repositorios base, esto hace mas rapida la instalación y configuraciones del cliente.
Instalación del servicio
$ yum -y install bacula-client
En Centos 5.x
Como se menciono anteriormente en CentOS 5.x realizaremos la instalacion desde la fuente de binarios. Haremos los siguiente:
Instalación de compiladores al sistema.
$ yum install gcc gcc-c++ autoconf automake
Descargamos las fuentes de Bacula y descomprimimos la fuente.
$ wget http://sourceforge.net/projects/bacula/files/bacula/5.0.2/bacula-5.0.2.tar.gz/download
$ tar -zxf bacula-5.0.2.tar.gz
Nos cambiamos al directorio donde descomprimimos las fuentes, creamos una variable de sistema CFLAGS que nos servirá en la compilación y después procedemos a configurar la instalación y compilar.
$ cd bacula-5.0.2
$ CFLAGS="-g -Wall"
$ ./configure --sbindir=/usr/sbin --sysconfdir=/etc/bacula --with-pid-dir=/var/run --with-subsys-dir=/usr/libexec/bacula --with-working-dir=/var/spool/bacula --enable-client-only
$ make
$ make install
Configuraciones de arranque del servicio bacula-fd.
Agregar la siguiente linea:
# chkconfig: - 87 26en el archivo /etc/init.d/bacula-fd
$ cp /usr/sbin/bacula-fd /etc/init.d/
$ vim /etc/init.d/bacula-fd
#! /bin/sh
# chkconfig: - 87 26
#
# bacula This shell script takes care of starting and stopping
# the bacula daemons.
.......
Configuracion
La configuracion estan en bacula-fd.conf. Aqui definimos una clave de acceso para el cliente. Agregamos la contraseña que definimos en la seccion Client del bacula-dir.
Director {
Name = bacula-dir
Password = "PasswordSuperSecretoFD" # Contraseña del cliente
}
Se comenta esta sección.
#Director {
# Name = bacula-mon
# Password = "vMN"
# Monitor = yes
#}
Activando el servicio.
En CentOS 7
$ systemctl enable bacula-fd
$ systemctl start bacula-fd
En CentOS 6.x y 5.x
$ chkconfig bacula-fd on
$ service bacula-fd start
#####Firewall
Configuraciones de firewall, abrimos el puerto 9102.
Iptables
$ vim /etc/sysconfig/iptables
-A INPUT -m state --state NEW -m tcp -p tcp --dport 9102 -j ACCEPT
$ service iptables restart
Firewalld
$ firewall-cmd --permanent --zone=public --add-port=9102/tcp
Bacula-console (Consola)
Existen varias opciones para administrar Bacula, una de ellas es por medio de bconsole, donde por medio de lineas de comando interactuamos con bacula-dir.
Este programa la tenemos que instalar desde el host donde tengamos pensado realizar las tareas de administrador, no necesariamente se tiene que alojar en el servidor.
Instalación desde repositorios. (RHEL, CentOS, Fedora)
$ yum install bacula-console
En su archivo de configuracion agregamos la contraseña de acceso de bacula-dir que definimos anteriormente.
Director {
Name = bacula-dir
DIRport = 9101
address = 192.168.x.x # IP ó dominio
Password = "MiSuperPaswordBaculaDIR" # Contraseña de bacula-dir
}
Administración básica
Generar un respaldo manualmente
$ bconsole
* run # Ejecutamos un Job de respaldo (backup)
Select Job resource (1-3): 1 # Seleccionamos el Job de backup del cliente
OK to run? (yes/mod/no): yes # Ejecutamos la tarea
Job queued. JobId=1
* exit
Las tareas de respaldo se irán generando automáticamente de acuerdo a las tareas que se definieron en la configuraciones del Director Daemon.
Generar una restauración
Las restauraciones se pueden realizar desde varios puntos o imágenes de archivos que se hayan generado.
$ bconsole
* restore # Ejecutamos una tarea de restauración
To select the JobIds, you have the following choices:
1: List last 20 Jobs run
..
5: Select the most recent backup for a client
..
13: Cancel
Select item: (1-13): 5 # Seleccionamos el 5 para generar el mas reciente.
Defined Clients:
1: cliente01
Select the Client (1-11): 1 # Seleccionamos al cliente
$ ls # Listamos los archivos respaldados
home/
$ mark home # Marcamos los que deseemos restaurar
5 files marked.
$ done # Terminamos de seleccionar
OK to run? (yes/mod/no): yes # Ejecutamos la tarea configurada
Job queued. JobId=2
* exit
