Bacula

De Wiki
Ir para: navegação, pesquisa

Bacula

Objetivo

Nosso objetivo é contruir um ambiente de backup onde todos os servidores irão realizar seus backups em um sistema centralizado.

Ambiente Proposto

Nós vamos ter o seguinte ambiente:

  • 1 servidor de backup chamado de backup.exemplo.com.br, com IP: 200.129.192.23.
  • 1 storage com capacidade de 2,5Tb em RAID5

Este servidor de backup possui 3 placas de rede, 2 ligadas ao storage e 1 ligada a rede, que será utilizada para que os clientes de backup realizem suas transferências. O método de comunicação do servidor com o storage será utilizando iSCSI. O diretório que irá armazenar os backup e estará vinculado ao storage será:

# mkdir /mnt/backup

e depois de instalar o Bacula, antes de começar a utilizá-lo, lembre-se de dar permissões ao seu usuário para escrever no diretório:

# chown -R bacula:bacula /mnt/backup

para montar automaticamente, não esqueça de definir no iSCSI o método automatic e nas configurações do /etc/fstab:

# vim /etc/fstab
...
/dev/sda1       /mnt/backup     ext4    _netdev         0       0

onde sda1 é o dispositivo do storage mapeado no sistema operacional.

Debian Squeeze 6.0

Instalando os Pacotes necessários

O Bacula pode utilizar diversos SGBDs para armazenar as informações de catálogo (SQLite3, MySQL ou PostgreSQL). Como nosso ambiente é mais Enterprise, vamos utilizar o PostgreSQL como banco de dados. Instale o banco e não esqueça de definir a senha para o usuário postgres, pois será necessário durante a instalação do Bacula utilizando o dbconfig-common.

Configurações Básicas

Agora que já temos o banco de dados instalado para gerenciamento do catálogo, vamos instalar o Bacula em si:

# apt-get install bacula  bacula-sd-pgsql bacula-director-pgsql

Ele possui 3 grandes módulos:

  • Bacula Director
  • Bacula Storage Daemon
  • Bacula File Daemon

Cada um destes módulos tem atividades específicas. O mais importante no servidor é o director ou dir e o storage daemon ou sd (a mesma abreviação vale para o file daemon que é fd).

Durante a instalação, você será questionado para configurar o pacote bacula-director-pgsql utilizando o dbconfig-common, como nós já instalamos e configuramos o PostgreSQL, basta dizer sim e informar os dados adicionais.

Para simplificar o entendimento, no servidor devemos ter configurado:

  • Bacula Director
  • Bacula Storage Daemon

e em cada cliente do backup devemos ter:

  • Bacula File Daemon

Vamos explicar depois o que será necessário fazer para incluir um servidor no backup.

Configurando o Diretor do Backup

O Director é o local onde todas as configurações deverão ser feitas, jobs de clientes, definições de jobs, agendamentos, ou seja, toda a administração de backup será feita ali. Como nosso servidor vai utilizar a rede, ele deve poder se comunicar através da rede, então primeiro vamos remover as entradas de comunicação somente local:

# cd /etc/bacula

primeiro do director:

# vim bacula-dir.conf
...
DirAddress = 127.0.0.1

comente esta linha. No sd:

# vim bacula-sd.conf
...
SDAddress = 127.0.0.1
 

e esta no fd:

# vim bacula-fd.conf
...
FDAddress = 127.0.0.1 

reinicie os serviços:

# /etc/init.d/bacula-director restart
# /etc/init.d/bacula-sd restart
# /etc/init.d/bacula-fd restart

Pronto, o primeiro passo foi concluído. Vamos começar o a configuração geral na seguinte ordem:

  1. Ajuste de configuração de onde vai ficar o backup (bacula-sd)
  2. Ajuste de configuração de quando/como vai acontecer o backup (bacula-director)
  3. Configuração do cliente que será gerenciado pelo director (bacula-fd)

Configurando o Bacula-SD

Vamos editar o arquivo de configuração do Bacula-SD:

# vim /etc/bacula/bacula-sd.conf
...
Device {
 Name = FileStorage
 Media Type = File
 Archive Device = /mnt/backup
 LabelMedia = yes;   
 Random Access = Yes;
 AutomaticMount = yes;
 RemovableMedia = no;
 AlwaysOpen = no;
}

A única configuração que vamos alterar aqui, é com relação ao Archive Device que deve ser direcionado para o diretório que está montado nosso storage (no caso, /mnt/backup). Neste arquivo poderiam ser definidas outras mídias, como fitas, DVDs, mas nosso caso é muito mais simples, por isso não foi necessário.

Configurando o Bacula-Director

Uma vez que já temos definido as configurações relacionadas ao armazenamento dos backups, devemos informar ao director como ele vai fazer isso:

# vim /etc/bacula/bacula-dir.conf
Director {                            # define myself
 Name = backup-dir
 DIRport = 9101                # where we listen for UA connections
 QueryFile = "/etc/bacula/scripts/query.sql"
 WorkingDirectory = "/var/lib/bacula"
 PidDirectory = "/var/run/bacula"
 Maximum Concurrent Jobs = 1
 Password = "Cv70F6pf1t6pBopT4vQOnigDrR0v3L"         # Console password
 Messages = Daemon
}

JobDefs {
  Name = "DefaultJob"
  Type = Backup
  Level = Incremental
  Client = backup-fd
  FileSet = "Full Set"
  Schedule = "WeeklyCycle"
  Storage = File
  Messages = Standard
  Pool = File
  Priority = 10
  Write Bootstrap = "/var/lib/bacula/%c.bsr"
}

Job {
  Name = "BackupCatalog"
  JobDefs = "DefaultJob"
  Level = Full
  FileSet="Catalog"
  Schedule = "WeeklyCycleAfterBackup"
  RunBeforeJob = "/etc/bacula/scripts/make_catalog_backup.pl MyCatalog"
  RunAfterJob  = "/etc/bacula/scripts/delete_catalog_backup"
  Write Bootstrap = "/var/lib/bacula/%n.bsr"
  Priority = 11                   # run after main backup
}

Job {
  Name = "RestoreFiles"
  Type = Restore
  Client=backup-fd
  FileSet="Full Set"
  Storage = File
  Pool = Default
  Messages = Standard
  Where = /nonexistant/path/to/file/archive/dir/bacula-restores
}

FileSet {
  Name = "Full Set"
  Include {
    Options {
      signature = SHA1
    }
    File = /usr/sbin
  }

  Exclude {
    File = /var/lib/bacula
    File = /nonexistant/path/to/file/archive/dir
    File = /proc
    File = /tmp
    File = /.journal
    File = /.fsck
  }
}

Schedule {
  Name = "WeeklyCycle"
  Run = Full 1st sun at 23:05
  Run = Differential 2nd-5th sun at 23:05
  Run = Incremental mon-sat at 23:05
}

Schedule {
  Name = "WeeklyCycleAfterBackup"
  Run = Full sun-sat at 23:10
}

FileSet {
  Name = "Catalog"
  Include {
    Options {
      signature = MD5
    }
    File = "/var/lib/bacula/bacula.sql"
  }
}

Storage {
  Name = File
  Address = backup.exemplo.com.br      # N.B. Use a fully qualified name here
  SDPort = 9103
  Password = "amO-PXw3egPJmyCDAx-rZnrkIQFyHP8ZK"
  Device = FileStorage
  Media Type = File
}

Catalog {
  Name = MyCatalog
  dbname = bacula; DB Address = ""; dbuser = "bacula"; dbpassword = "senha_gerada_dbconfig"
}

Messages {
  Name = Standard
  mailcommand = "/usr/lib/bacula/bsmtp -h localhost -f \"\(Bacula\) \<%r\>\" -s \"Bacula: %t %e of %c %l\" %r" operatorcommand = "/usr/lib/bacula/bsmtp -h localhost -f \"\(Bacula\) \<%r\>\" -s \"Bacula:  Intervention needed for %j\" %r"
  mail = root@localhost = all, !skipped
  operator = root@localhost = mount
  console = all, !skipped, !saved
  append = "/var/lib/bacula/log" = all, !skipped
  catalog = all
}

Messages {
  Name = Daemon
  mailcommand = "/usr/lib/bacula/bsmtp -h localhost -f \"\(Bacula\) \<%r\>\" -s \"Bacula  daemon message\" %r"
  mail = root@localhost = all, !skipped
  console = all, !skipped, !saved
  append = "/var/lib/bacula/log" = all, !skipped
}

Pool {
  Name = Default
  Pool Type = Backup
  Recycle = yes                       # Bacula can automatically recycle Volumes
  AutoPrune = yes                     # Prune expired volumes
  Volume Retention = 365 days         # one year
}

Pool {
  Name = File
  Pool Type = Backup
  Recycle = yes                       # Bacula can automatically recycle Volumes
  AutoPrune = yes                     # Prune expired volumes
  Volume Retention = 365 days         # one year
  Maximum Volume Bytes = 50G          # Limit Volume size to something reasonable
  Maximum Volumes = 100               # Limit number of Volumes in Pool
  LabelFormat = "Vol"
}

Pool {
  Name = Scratch
  Pool Type = Backup
}

Console {
  Name = backup-mon
  Password = "Im1xp_SUSQfReeW-u_7pr5i5ijHYGy9Fu"
  CommandACL = status, .status
}

Você deve tomar cuidado com relação as senhas informadas em cada configuração, por exemplo, a senha do director definida no sd deve ser a mesma definida no Storage do director, e o mesmo vale para as senhas entre o director e o fd em cada cliente.

O sistema já vem praticamente pronto para uso, sendo o servidor o próprio cliente para o backup, mas para um melhor entendimento de como as coisas funcionam, vamos alterar apenas a entrada do sd (cláusula Pool com nome File), e adicionar a entrada de formato do Label e também o tamanho dos volumes em relação ao nosso ambiente:

# vim /etc/bacula/bacula-dir.conf
...
Pool {
  Name = File
  Pool Type = Backup
  Recycle = yes                       # Bacula can automatically recycle Volumes
  AutoPrune = yes                     # Prune expired volumes
  Volume Retention = 365 days         # one year
  Maximum Volume Bytes = 50G          # Limit Volume size to something reasonable
  Maximum Volumes = 40               # Limit number of Volumes in Pool
  LabelFormat = "Vol"
}
...

Nós definimos o Label para Vol e o Bacula vai incrementar valores de 1-N, de acordo com a numeração do volume. O outro detalhe importante aqui é com relação a definição do tamanho de cada arquivo de volume e o máximo de volumes permitido (o produto: Maximum Volume Bytes x Maximum Volumes deve ser o tamanho máximo disponível no storage).

Agora devemos configurar um cliente, e esta configuração também é feita no director:

# vim /etc/bacula/bacula-dir.conf
...
Job {
  Name = "BackupClient1"
  JobDefs = "DefaultJob"
}

JobDefs {
  Name = "DefaultJob"
  Type = Backup
  Level = Incremental
  Client = backup-fd
  FileSet = "Full Set"
  Schedule = "WeeklyCycle"
  Storage = File
  Messages = Standard
  Pool = File
  Priority = 10
  Write Bootstrap = "/var/lib/bacula/%c.bsr"
}

FileSet {
  Name = "Full Set"
  Include {
    Options {
      signature = SHA1
    }
    File = /usr/sbin
  }

  Exclude {
    File = /var/lib/bacula
    File = /nonexistant/path/to/file/archive/dir
    File = /proc
    File = /tmp
    File = /.journal
    File = /.fsck
  }
}

Client {
  Name = backup-fd
  Address = localhost
  FDPort = 9102
  Catalog = MyCatalog
  Password = "YW4YNyE_G0c6NuGyxZCMJ-ZTHuN0yCJYt"          # password for FileDaemon
  File Retention = 30 days            # 30 days
  Job Retention = 6 months            # six months
  AutoPrune = yes                     # Prune expired Jobs/Files
}

Esta configuração é relacionada ao cliente e algumas coisas devem estar definidas:

  1. FileSet: são as definições do que deve ser feito backup, é interessante criar alguns modelos para cada tipo de servidor.
  2. Schedule: é a frequência que cada backup deve ser feito, o padrão já é bem interessante (backups full, incrementais e diferenciais).

O Job pode ser o nome dado ao cliente ou alguma atividade (como por exempo, recuperação de dados) que terá seu backup feito, o JobDefs as definições de comunicação com o cliente e quais

arquivos (FileSet) serão feitos backup e com qual frequência (Schedule). A configuração do cliente está relacionado com o Bacula-FD e a senha no director deve ser a mesma do fd.

Como exemplo, vamos criar um outro FileSet para servidores WEB por exemplo:

# vim /etc/bacula/bacula-dir.conf
...
JobDefs {
  Name = "MailJob"
  Type = Backup
  Level = Incremental
  Client = backup-email
  FileSet = "Mail Set"
  Schedule = "WeeklyCycle"
  Storage = File
  Messages = Standard
  Pool = File
  Priority = 10
  Write Bootstrap = "/var/lib/bacula/%c.bsr"
}

FileSet {
  Name = "Mail Set"
  Include {
    Options {
      compression = GZIP
      signature = SHA1
    }
    File = /etc
    File = /var/www
    File = /home
  }

  Exclude {
    File = /var/lib/bacula
    File = /nonexistant/path/to/file/archive/dir
    File = /proc
    File = /tmp
    File = /.journal
    File = /.fsck
  }
}

Client {
  Name = backup-mail
  Address = IP_DO_SERVIDOR_MAIL
  FDPort = 9102
  Catalog = MyCatalog
  Password = "LALLAssYW4YNyE_GCMJ-ZTHuN0yCJYt"          # password for FileDaemon
  File Retention = 30 days            # 30 days
  Job Retention = 6 months            # six months
  AutoPrune = yes                     # Prune expired Jobs/Files
}

Pronto, o que temos aqui? Um cliente configurado no servidor de e-mail que vai fazer backup do etc, www e home, comprimindo os dados com gzip. O agendamento foi o padrão com definições semanais de backup. Revisando, para configurar um cliente de backup novo, você deve:

  1. Job
  2. JobDefs
  3. Client
  4. Restore

Utilizando as outras configurações para Schedule e File para armazenamento.

Instalando o Bweb para gerenciar o Bacula

Instale as dependências que serão necessárias

Como o Bweb é feito em Perl e nosso banco de dados está usando PostgreSQL, devemos instalar as dependências necessárias corretamente:

# apt-get install libdbd-pgsql libgd-graph-perl libhtml-template-perl libexpect-perl libdbd-pg-perl libdbi-perl libdate-calc-perl libtime-modules-perl ttf-dejavu 

Agora baixe o pacote do Bacula-gui para a versão que você está usando do Bacula, no nosso caso a 5.0.2.

# wget http://sourceforge.net/projects/bacula/files/bacula/5.0.2/bacula-gui-5.0.2.tar.gz/download 

descompacte:

# tar zxf download

entre no diretório do bweb:

# cd bacula-gui-5.0.2/bweb

Devemos copiar as bibliotecas Bweb Perl para a o caminho do perl5, através dos comandos:

# perl Makefile.PL
# make install

Devem ser copiados os arquivos do programa Bweb para a pasta cgi-bin do servidor web. Não esqueça de instalar um servidor web com suporte a CGI, como o Apache2.2, rapidamente:

# apt-get install apache2

Copie os arquivos do Bweb para o diretório:

# cd ..
# mkdir -m 755 /usr/lib/cgi-bin/bweb
# install -m 755 -o root -g root bweb/cgi/*.pl /usr/lib/cgi-bin/bweb 

Agora vamos criar o arquivo de configuração, atribuindo em seguida o usuário web do Apache2.2 como proprietário do arquivo:

# echo '$VAR1 = { template_dir => "/usr/share/bweb/tpl" };' > /etc/bacula/bweb.conf
# chown www-data /etc/bacula/bweb.conf 

Em seguida deve ser criada a pasta para os templates da aplicação e copiados os arquivos correspondentes:

# mkdir -p /usr/share/bweb/tpl/en
# install -m 644 -o root -g root bweb/lang/en/tpl/*.tpl /usr/share/bweb/tpl/en 

Para finalizar, copia-se os elementos gráficos da aplicação dentro da pasta Bweb (que deve ser criada), no document root do servidor web.

# mkdir /var/www/bweb
# install -m 644 -o root -g root bweb/html/*.{js,png,css,gif,ico,html} /var/www/bweb 

Agora é necessário atualizar o banco de dados do Bacula para suportar o Bweb:

# psql -U bacula -W bacula < script/bweb-postgresql.sql

se der um erro de criação da linguagem plpgsql, crie ela como usuário postgress:

# su - postgres
# psql bacula
psql (8.4.7)
Digite "help" para ajuda.

bacula=# CREATE LANGUAGE 'plpgsql';
CREATE LANGUAGE

Agora basta executar novamente o script de inserção de dados.

Configurando o Bweb

Acessando: http://backup.empresa.com.br/bweb/, você será redirecionado para configurar a conexão com o banco de dados.

Config-bweb.png

Após configurar utlizando o seu brower, o conteúdo do arquivo bweb.conf deve ser algo como:

# cat /etc/bacula/bweb.conf
$VAR1 = bless( {
                'enable_security' => 0,
                'graph_font' => '/usr/share/fonts/truetype/ttf-dejavu/DejaVuSerif.ttf',
                'config_file' => '/etc/bacula/bweb.conf',
                'password' => 'senha_do_banco',
                'dbi' => 'dbi:Pg:dbname=bacula',
                'user' => 'bacula',
                'error' => ,
                'debug' => 0,
                'stat_job_table' => 'Job',
                'display_log_time' => 0,
                'lang' => 'en',
                'wiki_url' => ,
                'name' => undef,
                'bconsole' => '/usr/bin/bconsole -n -c /etc/bacula/bconsole.conf',
                'fv_write_path' => '/var/spool/bweb',
                'template_dir' => '/usr/share/bweb/tpl',
                'enable_security_acl' => 0,
                'email_media' => 'gerente@exemplo.com.br',
                'default_age' => '7d'
              }, 'Bweb::Config' );

Ajustando as configurações do Apache2.2

Edite o arquivo default:

# vim /etc/apache2/sites-enabled/000-default
<VirtualHost *:80>
       ...
       ScriptAlias /cgi-bin/bweb /usr/lib/cgi-bin/bweb
       <Directory /usr/lib/cgi-bin/bweb>
               Options ExecCGI -MultiViews +SymLinksIfOwnerMatch
               AuthType Basic
               AuthName BaculaWeb
               AuthUserFile /etc/apache2/htpasswd
               AllowOverride None
               Require valid-user
       </Directory>

       Alias /bweb/fv /var/spool/bweb
       <Directory "/var/spool/bweb">
               Options None
               AllowOverride AuthConfig
               Order allow,deny
               Allow from all
       </Directory>
       ...
</VirtualHost>

Crie um usuário para acessar o Bweb:

# htpasswd -c /etc/apache2/htpasswd usuario
New password: 
Re-type new password: 
Adding password for user usuario

Você poderia utilizar usuários do OpenLDAP, ou qualquer outro método. Recarregue o Apache para que ele de suporte as modificações.

Configurando um Cliente (Bacula-FD)

Debian Squeeze 6.0

Nós já inserimos a configuração de um cliente no director, mas precisamos instalar o Bacula também no cliente:

# apt-get install bacula-fd

e edite o arquivo de configuração do Bacula-FD:

# vim /etc/bacula/bacula-fd.conf
Director {
 Name = backup-dir
 Password = "LALLAssYW4YNyE_GCMJ-ZTHuN0yCJYt"
}

Director {
  Name = backup-mon
  Password = "E4LSasq00M0PosQJl6cy5O32WIKtRIp3Qw9Ay"
  Monitor = yes
}

FileDaemon {                          # this is me
  Name = backup-mail
  FDport = 9102                  # where we listen for the director
  WorkingDirectory = /var/lib/bacula
  Pid Directory = /var/run/bacula
  Maximum Concurrent Jobs = 20
  FDAddress = IP_DO_SERVIDOR_MAIL
}

Messages {
  Name = Standard
  director = backup-dir = all, !skipped, !restored
}

Onde:

  • O nome do diretor (backup-dir) deve ser o mesmo definido no director no servidor de backup
  • O nome do FileDaemon também deve ser o mesmo nos 2 arquivos (no cliente e no director remoto)
  • E principalmente, a senha (LALLAssYW4YNyE_GCMJ-ZTHuN0yCJYt) deve ser a mesma nos 2 servidores.

FreeBSD 8.1

Windows 2008 R2

Erros comuns

O principal erro que encontramos, foi o problema de envio de emails de relatório. O servidor de backup deve ter um MTA configurado localmente (tentamos usar o ssmtp para envio externo, mas não deu certo), podemos usar o Exim4 ou Postfix, por exemplo.

# apt-get install exim4

pronto, seu ambiente de email deve estar corrigido.

Operações Básicas

Com o Bacula instalado e configurado, precisamos conhecer algumas funcionalidades dele:

  • Realizar um backup
  • Restaurando um backup

Vamos primeiro aprender a iniciar um backup, para isso vamos utilizar o poderoso console do Bacula, o bconsole:

# bconsole
Connecting to Director localhost:9101
1000 OK: backup-dir Version: 5.0.2 (28 April 2010)
Enter a period to cancel a command.
*

Você pode digitar help a qualquer momento para ver um descritivo geral dos comandos da ferramenta. Lembrando que esta ferramenta foi instalada no servidor de backup e não no cliente.

Status de Erros

Abaixo esta a lista geral dos jobstatus:

    jobstatus |          jobstatuslong
   -----------+---------------------------------
    C         | Created, not yet running
    R         | Running
    B         | Blocked
    T         | Completed successfully
    E         | Terminated with errors
    e         | Non-fatal error
    f         | Fatal error
    D         | Verify found differences
    A         | Canceled by user
    F         | Waiting for Client
    S         | Waiting for Storage daemon
    m         | Waiting for new media
    M         | Waiting for media mount
    s         | Waiting for storage resource
    j         | Waiting for job resource
    c         | Waiting for client resource
    d         | Waiting on maximum jobs
    t         | Waiting on start time
    p         | Waiting on higher priority jobs

Realizando um Backup

Primero é necessário que o Job do cliente esteja configurado no diretor.

* run client=backup-mail level=Differential/Full/Incremental

onde o backup pode ser Differential, Full ou Incremental (apenas um deles por vez). Para ver a lista de Jobs já executados:

* list jobs
Automatically selected Catalog: MyCatalog
Using Catalog "MyCatalog"
+-------+-----------------------+---------------------+------+-------+----------+----------+-----------+
| jobid | name                  | starttime           | type | level | jobfiles | jobbytes | jobstatus |
+-------+-----------------------+---------------------+------+-------+----------+----------+-----------+
|     1 | backup.exemplo.com.br | 2011-02-21 14:39:59 | B    | F     |        0 |        0 | f         |
|     2 | backup.exemplo.com.br | 2011-02-21 15:01:46 | B    | F     |        0 |        0 | R         |
+-------+-----------------------+---------------------+------+-------+----------+----------+-----------+

onde o primeiro teve jobstatus=f (que significa fail ou falha), e o segundo ainda está R (running).

Restaurando um Backup

Para restaurar um backup, você deve ter configurado corretamente o Job de restauração para o cliente, lembrando que ao restaurar, o backup não vai para o servidor, e sim, será restaurado diretamente no cliente.

* restore
Automatically selected Catalog: MyCatalog
Using Catalog "MyCatalog"

To select the JobIds, you have the following choices:
     1: List last 20 Jobs run
     2: List Jobs where a given File is saved
     3: Enter list of comma separated JobIds to select
     4: Enter SQL list command
     5: Select the most recent backup for a client
     6: Select backup for a client before a specified time
     7: Enter a list of files to restore
     8: Enter a list of files to restore before a specified time
     9: Find the JobIds of the most recent backup for a client 
    10: Find the JobIds for a backup for a client before a specified time
    11: Enter a list of directories to restore for found JobIds
    12: Select full restore to a specified Job date
    13: Cancel
Select item:  (1-13):5

selecionando o item 5, vamos entrar no modo de restauração do backup mais recente de um dos clientes, se você tiver mais de um cliente, pode aparecer algo como:

Defined Clients:
    1: backup-fd
    2: backup-legacymail
    3: backup-mail
Select the Client (1-3): 3

feito isso vamos entrar em modo de recuperação:

Automatically selected FileSet: Full Set
+-------+-------+----------+-----------+---------------------+------------+
| jobid | level | jobfiles | jobbytes  | starttime           | volumename |
+-------+-------+----------+-----------+---------------------+------------+
|     3 | F     |    1,182 | 7,583,404 | 2011-02-21 15:10:54 | Vol0001    |
+-------+-------+----------+-----------+---------------------+------------+
You have selected the following JobId:3

Building directory tree for JobId(s) 3 ...  ++++++++++++++++++++++++++++++++++++++++++++
1,063 files inserted into the tree. 

cwd is: /
$

neste prompt você deve usar o comando mark para cada arquivo que deseja marcar para restaução ou unmark para desmarcar. Também é possível usar coringas como o * para marcar todos os itens de um diretório (digitando help, você verá a lista de comandos disponíveis para navegação):

$ mark *
975 files marked.

para finalizar o processo, basta entrar com o comando done:

$ done
Bootstrap records written to /var/lib/bacula/backup-dir.restore.1.bsr
The job will require the following
   Volume(s)                 Storage(s)                SD Device(s)
===========================================================================
   Vol0001                   File                      FileStorage
Volumes marked with "*" are online.

1 file selected to be restored.

The defined Restore Job resources are:
     1: RestoreSrvBackup
     2: RestoreMail
     3: RestoreLegacyMail
Select Restore Job (1-3): 2

vai aparecer a lista de Jobs para restauração que criamos no director, selecione a de restauração do email e vai aparecer o pedido de criação de um Job de restauração:

Run Restore job
JobName:         RestoreSrvBackup
Bootstrap:       /var/lib/bacula/backup-dir.restore.1.bsr
Where:           /tmp/backup-restore
Replace:         always
FileSet:         Full Set
Backup Client:   backup-fd
Restore Client:  backup-fd
Storage:         File
When:            2011-02-21 15:18:58
Catalog:         MyCatalog
Priority:        10
Plugin Options:  *None*
OK to run? (yes/mod/no): yes

se a restauração foi agendada, você vai ver algo como:

Job queued. JobId=4

e depois listando os Jobs:

* list jobs
+-------+-------------------------+---------------------+------+-------+----------+-----------+-----------+
| jobid | name                    | starttime           | type | level | jobfiles | jobbytes  | jobstatus |
+-------+-------------------------+---------------------+------+-------+----------+-----------+-----------+
|     1 | backup.exemplo.com.br   | 2011-02-21 14:39:59 | B    | F     |        0 |         0 | f         |
|     2 | backup.exemplo.com.br   | 2011-02-21 15:01:46 | B    | F     |        0 |         0 | f         |
|     3 | backup.exemplo.com.br   | 2011-02-21 15:10:54 | B    | F     |    1,182 | 7,583,404 | T         |
|     4 | RestoreSrvBackup        | 2011-02-21 15:20:29 | R    | F     |        1 |         0 | T         |
+-------+-------------------------+---------------------+------+-------+----------+-----------+-----------+

Vemos que a operação aconteceu com sucesso, e no diretório do servidor remoto vai estar o backup restaurado.


--Brivaldo 14h57min de 21 de fevereiro de 2011 (AMT)