Off-Site Backups with Bacula

 

Bacula, the Open Source Network Backup Solution

Bacula is a great Backup Solution for any infrastructure out there, if you don’t know this tool, I really recommend reading about it. I’ve been using it for over 2 years now and when I thought I had learned everything there was to learn about it, I was asked to do one more thing with our backups: store them on a off-site location for security. After all, what’s the point in having data backups stored in your company if a flood or a fire will destroy everything, including your backups?

“What’s the problem?”, you may ask… “Just take your daily backups tapes to an off-site location!”, you might say… If only life was that simple…

I needed those daily backups tapes on-site, since our helpdesk team was constantly asking us to restore some files from the Samba Share server, because the user “swears the file just disappeared from the server”… Yeah, right…

So, how could I possibly have a secure off-site backup of my data and, at the same time, have them available to me to make daily restores in my company?

 

Bacula and Copy Jobs

Copy Jobs to the rescue! Man, what a great feature. If you’re familiar with Bacula (which I hope you are, since this posts expects you to), you know that every single backup that Bacula does is actually a Job to it.

Basically, a Copy Job is a special Job (like an Admin Job) that takes a list of JobId based on a criteria chosen by you (will see them further on) and makes a copy of those Jobs from their original Pool to a different Pool.

I think you’ll understand better with examples…

 

The Scenario

Currently, I have the basic three Pools for my Backups: one for my Full Backups (pool.full), one for my Differential Backups (pool.diff) and the last one for my Incremental Backups (pool.inc). Their configurations is as the following:

Pool {
    Name = pool.full
    Pool Type = Backup
    Storage = st.tpc
    Volume Use Duration = 6 months
    Volume Retention = 1 year
    Scratch Pool = scratch.tpc
    RecyclePool = scratch.tpc
    File Retention =  1 year
    Job Retention =  1 year
    Cleaning Prefix = "CLN"
}

Pool {
    Name = pool.diff
    Pool Type = Backup
    Storage = st.tpc
    Volume Use Duration = 1 week
    Volume Retention = 6 months
    Scratch Pool = scratch.tpc
    Recycle Pool = scratch.tpc
    File Retention =  1 year
    Job Retention =  1 year
    Cleaning Prefix = "CLN"
}

Pool {
    Name = pool.inc
    Pool Type = Backup
    Storage = st.tpa
    Volume Use Duration = 1 month
    Volume Retention = 3 months
    Scratch Pool = scratch.tpa
    RecyclePool = scratch.tpa
    File Retention =  1 year
    Job Retention =  1 year
    Cleaning Prefix = "CLN"
}

The details about my Backup Policy is not important, what you have to know is: I have 3 tape libraries named st.tpa, st.tpb and st.tpc. The first I’m using for my Incremental Backups and the last I’m using for my Differential and Full Backups. The second, st.tpb, I going to use for my Copy Jobs.

This is the first and possibly the most important note there is to know before starting using Copy Jobs: YOU MUST HAVE TWO DIFFERENT STORAGES IN ORDER TO USE COPY JOBS. For example: if you have a File Storage configured in your Bacula Storage Daemon where you send all your backups to, you can copy those jobs to an second File Storage or even to a Tape Storage, but you can’t copy your jobs to same storage location where you send your original jobs.

In my case, I had the Tape Storage st.tpb lying around with no use, so far.

I also had very simple Jobs and Schedules, which will execute a Full Backup twice a year, a Differential backup weekly and a Incremental Backup on a daily basis:

Schedule {
  Name = sch.default
  Run = Level=Full Pool=pool.full jan on 1st sat at 21:00
  Run = Level=Full Pool=pool.full jul on 1st sat at 21:00
  Run = Level=Differential Pool=pool.diff FullPool=pool.full on 1st sat at 21:00
  Run = Level=Incremental Pool=pool.inc FullPool=pool.full sun-fri at 21:00
}

Client {
  Name = client.test
  Address = test.example.dom
  Catalog = cat.default
  Password = "SeCrEt"
  File Retention = 1 year
  Job Retention = 1 year
}

Jobs {
  Name = job.test
  Type = Backup
  Client = client.test
  Write Bootstrap = "/var/spool/bacula/jobs/bootstrap.%c.%n.bsr"
  FileSet = fs.default
  Messages = msg.default
  Pool = pool.full
  Schedule = sch.default
  Max Start Delay = 72h
  Spool Data = yes
  Allow Duplicate Jobs = no
  Cancel Lower Level Duplicates = yes
}

You can see that the Schedule is what defines which pool to use for each level of backup (Inc, Diff and Full). So, here what we’ve got so far:

  1. Full Backups go to Pool pool.full, residing on Storage st.tpc (Tape Library);
  2. Diff Backups go to Pool pool.diff, also residing on Storage st.tpc (Tape Library);
  3. Inc Backups go to Pool pool.inc, residing on Storage st.tpa (Tape Library);

 

The Backup of the Backups

Let’s start making Copy Jobs of my Full Backups, you’ll see that applying to the rest of the backups is very trivial. First, we need to create a Pool to throw the Copy Jobs, and here it is:

Pool {
    Name = pool.offsite
    Pool Type = Backup
    Storage = st.tpb
    Volume Use Duration = 1 day
    Volume Retention = 6 months
    Scratch Pool = scratch.tpb
    RecyclePool = scratch.tpb
    File Retention =  1 year
    Job Retention =  1 year
    Cleaning Prefix = "CLN"
}

It is a regular Pool just like any other, with just a few notes: first, I’m using the “st.tpb” Storage for this Pool, remember that I have to use a different Storage for the Copy Jobs.

Second, the “Volume Use Duration” is 1 day because I’ll run the Copy Job once a week and, every week, it will start to use a different tape, because the one from the week before will be mark as “Used”. That’s specifically important to me because I’ll remove the tapes from this Storage to take them to an off-site location and, without this option, I would end up with “mount volume” error messages because Bacula would try to use the Tape that removed the week before on this week’s Copy Job.

How do you tell Bacula to Copy it’s Full Backups to this Pool? First, you must tell the Full Pool where to put the Copy Jobs, by adding the line “Next Pool” to it:

Pool {
    Name = pool.full
    Pool Type = Backup
    Storage = st.tpc
    Volume Use Duration = 6 months
    Volume Retention = 1 year
    Scratch Pool = scratch.tpc
    RecyclePool = scratch.tpc
    File Retention =  1 year
    Job Retention =  1 year
    Cleaning Prefix = "CLN"
    Next Pool = pool.offsite
}

Second, you must create a special Copy Job:

Job {
    Name = job.copyjob.full
    Type = Copy
    Pool = pool.full
    Selection Type = PoolUncopiedJobs

    Messages = msg.default
    Schedule = sch.none
    Client = client.none    
    FileSet = fs.none    
}

For a Copy Job, the parameters “Client” and “FileSet” really don’t matter at all. They are just there because the “Job” entry requires them. That’s it.

What matter is:

  1. Type: use the special keyword “Copy”;
  2. Pool: which Pool the Jobs will be copied FROM (the Pool it self tells where they will be copied TO, with the “Next Pool” directive);
  3. Selection Type: the option “PoolUncopiedJobs” basically tells Bacula to Copy all Jobs on this Pool that yet has not been copied before;

There are other ways of telling Bacula which Jobs it should make a Copy, but for me, making a Copy of every single Job of the Pool was just perfect. But if you like, you can even make a SQL Query to select which Jobs Bacula should make a Copy of.

 

Running the Bastard!

After configuring all that, since I’m using a fake Schedule directive for my Copy Job, I have to run it manually. I recommend doing this for the first few times just to see if everything goes fine. Dan Langille said this on his blog: walk first, run later.

So, to finally run your Copy Job, just execute on “bconsole”:

*run job=job.copyjob.full
Run Copy job
JobName:       job.copyjob.full
Bootstrap:     *None*
Client:        client.none
FileSet:       fs.none
Pool:          pool.full (From Job resource)
Read Storage:  st.tpc (From Pool resource)
Write Storage: st.tpb (From Storage from Pool's NextPool resource)
JobId:         *None*
When:          
Catalog:       cat.default
Priority:      10
OK to run? (yes/mod/no):

On this output, notice the “JobId”? It’s blank because it will select the JobId’s to make the Copy of at run time. Fantastic, huh? Since I’m using the directive “PoolUncopiedJobs”, this single Job will create a Copy Job for every Full Backup Job that is stored on the the Pool “pool.full”.

Another thing to notice: “Read Storage” and “Write Storage”. Once again, THEY MUST BE DIFFERENT!

Once you strike “yes”, the madness begins! You’ll see something similar to this on your log:

JobId 30: The following 2 JobIds were chosen to be copied: 12,13
JobId 30: Job queued. JobId=31
JobId 30: Copying JobId 31 started.
JobId 30: Job queued. JobId=33
JobId 30: Copying JobId 33 started.

By the time I ran this Copy Job, I had two Full Backup on my Pool “pool.full” and, guess what? Their JobId’s were consecutively 12 and 13! Like I said before, Bacula creates a different Copy Job for every Job that needs to be copied. Since I had two Full Backups, it creates two Copy Jobs with JobId 31 and 33.

And that’s it! Now just wait for your Copy Jobs to finish and keep checking your logs for any errors. In my case, I remove the Tapes used for Copy Jobs from the st.tpb Tape Library and take them to the off-site location, and replace them with new ones. Just remember that, every time you replace your Tapes, you must label them with “label barcodes” (or simply “label”, if your Tape Library doesn’t support barcodes) and always, ALWAYS, do an “update slots”, to tell Bacula that those tapes have been replaced on your Tape Library.

What about the Differentials and Incremental backups? They will work exactly the same way as the Full Backups, just add an “Next Pool” directive on their Pool. You can even use the same Pool you’re using for copying the Full Backups, like this:

Pool {
    Name = pool.diff
    Pool Type = Backup
    Storage = st.tpc
    Volume Use Duration = 1 week
    Volume Retention = 6 months
    Scratch Pool = scratch.tpc
    Recycle Pool = scratch.tpc
    File Retention =  1 year
    Job Retention =  1 year
    Cleaning Prefix = "CLN"
    Next Pool = pool.offsite
}

Pool {
    Name = pool.inc
    Pool Type = Backup
    Storage = st.tpa
    Volume Use Duration = 1 month
    Volume Retention = 3 months
    Scratch Pool = scratch.tpa
    RecyclePool = scratch.tpa
    File Retention =  1 year
    Job Retention =  1 year
    Cleaning Prefix = "CLN"
    Next Pool = pool.offsite
}

Meaning that even your Differential and Incremental Backups stored on the pool.diff and the pool.inc would be copied to the pool.offsite Pool. You just need to create a Copy Job for each one:

Job {
    Name = job.copyjob.inc
    Type = Copy
    Pool = pool.inc
    Selection Type = PoolUncopiedJobs

    Messages = msg.default
    Schedule = sch.none
    Client = client.none    
    FileSet = fs.none    
}

Job {
    Name = job.copyjob.diff
    Type = Copy
    Pool = pool.diff
    Selection Type = PoolUncopiedJobs

    Messages = msg.default
    Schedule = sch.none
    Client = client.none    
    FileSet = fs.none    
}

And run them manually like we did with the “job.copyjob.full” before. Off course, you can create a “real” Schedule resource to automatically run you Copy Jobs daily, for example. I’m just being extra careful, testing if everything is going alright before letting them run in the wild.

 

Now What?

Now, in case of a disaster and you loose your original Backup Tapes, how do you recover your data from the Copy Jobs Tapes? I’m still figuring it out, but very soon I’ll make a new post talking about it.

That’s it for now! Good luck!

EDIT: I’ve created a post explaining how to restore data from the Copy Jobs, check it out here.

About these ads

Tags: , , , ,

8 responses to “Off-Site Backups with Bacula”

  1. Florin says :

    Hello,

    trying to implement this in an environment…
    however the problem is that we have ~60 clients each with it’s own disk storage device (actually folders on a disk but configured as separate storage devices in bacula) and all go to one pool.
    how can i get the copy job to copy from multiple disk storage devices to one tape library device?

    thanks

    • rodrigorenie says :

      Unfortunately, that’s a Bacula limitation. You CAN’T Migrate or Copy your Jobs from one Storage Daemon to another. Check this link, specifically the “Important Migration Consideration” section, the last item.

  2. John L says :

    I just read elsewhere that if you purge your original tapes from the catalog that your copy was made up with, then Bacula will upgrade the copied tapes to recover from. Does this sound accurate?
    (http://www.backupcentral.com/phpBB2/two-way-mirrors-of-external-mailing-lists-3/bacula-25/restore-knock-on-wood-from-copy-jobs-110864/)

    • rodrigorenie says :

      Yes, that is accurate, BUT there is a better way that I’ve discovered recently: at the command line, pass the parameter “copies” to the restore command line that Bacula will use the Copy Tapes instead of the original ones. So, the command would look like this:

      restore client=YourClientName copies

      It works great…

  3. Nelson says :

    Hei,

    trying to implement this in an environment…

    But I´m getting the following ERROR:
    bacula-dir: ERRRO TEMRINATION at parce_conf.c:479
    Could not find config Resource client.none referenced on line 189: client.none

    • rodrigorenie says :

      Hi there.

      It seems like you forgot to declare a Client Resource with the name “client.none”, or you misspelled it somewhere.

      Send you bacula-dir.conf if you like some help.

      Good luck!

      • Nelson says :

        Dear Rodrigo Reina, thanks for your answer.

        I have fix that situation and now I’m stuck on the following Fatal error:
        …………………………………………………………………………………………………..
        22-Mar 14:46 maria-dir JobId 357: The following 1 JobId was chosen to be copied: 353
        22-Mar 14:46 maria-dir JobId 357: Copying using JobId=353 Job=BackupDirector.2014-03-22_14.35.59_24
        22-Mar 14:46 maria-dir JobId 357: Bootstrap records written to /var/lib/bacula/maria-dir.restore.2.bsr
        22-Mar 14:46 maria-dir JobId 357: Start Copying JobId 357, Job=job.copyjob.2014-03-22_14.46.53_08

        22-Mar 14:44 TSTSERVER-sd JobId 357: Fatal error: Device reservation failed for JobId=357:
        22-Mar 14:46 maria-dir JobId 357: Fatal error:
        Storage daemon didn’t accept Device “FileStorage” because:
        3924 Device “FileStorage” not in SD Device resources.
        …………………………………………………………………………………………………..

        ———————————————————————-
        Note1: I can comunicate with my “remote bacula-sd”
        ———————————————————————-

        Select daemon type for status (1-4): 2
        The defined Storage resources are:
        1: File
        2: TSTFile
        Select Storage resource (1-2): 2
        Connecting to Storage daemon TSTFile at TSTSERVER:9103
        TSTSERVER-sd Version: 5.0.0 (26 January 2010) x86_64-unknown-linux-gnu ubuntu 12.10
        Daemon started 22-Mar-14 14:44, 1 Job run since started.
        Heap: heap=135,168 smbytes=16,818 max_bytes=78,549 bufs=72 max_bufs=88
        Sizes: boffset_t=8 size_t=8 int32_t=4 int64_t=8
        Running Jobs:
        No Jobs running.
        ====
        Jobs waiting to reserve a drive:
        ====
        Terminated Jobs:
        JobId Level Files Bytes Status Finished Name
        ===================================================================
        338 Full 0 0 Error 22-Mar-14 14:03 job.copyjob
        337 Full 0 0 Error 22-Mar-14 14:03 job.copyjob
        342 Full 0 0 Error 22-Mar-14 14:03 job.copyjob
        341 Full 0 0 Error 22-Mar-14 14:03 job.copyjob
        346 Full 0 0 Error 22-Mar-14 14:30 job.copyjob
        345 Full 0 0 Error 22-Mar-14 14:30 job.copyjob
        350 Full 0 0 Error 22-Mar-14 14:31 job.copyjob
        349 Full 0 0 Error 22-Mar-14 14:31 job.copyjob
        355 Full 0 0 Error 22-Mar-14 14:35 job.copyjob
        357 Full 0 0 Error 22-Mar-14 14:44 job.copyjob
        ====

        Device status:
        Device “FileStorage2″ (/backup_bacula_test_maria) is not open.
        ====
        Used Volume status:
        ====

        ————————————————————————-
        Note2: I and performance local backup/restores without problems.
        ————————————————————————-

        /***********************************************************************************************************++
        /* ———– CONFIG FILES ——————
        /***********************************************************************************************************++

        ————————————————————————-
        Bacula-sd (REMOTE STORAGE)
        ————————————————————————-
        #
        # Default Bacula Storage Daemon Configuration file
        #
        # For Bacula release 5.2.6 (21 February 2012) — ubuntu 12.10
        #
        # You may need to change the name of your tape drive
        # on the “Archive Device” directive in the Device
        # resource. If you change the Name and/or the
        # “Media Type” in the Device resource, please ensure
        # that dird.conf has corresponding changes.

        Storage { # definition of myself
        Name = TSTSERVER-sd
        SDPort = 9103 # Director’s port
        WorkingDirectory = “/var/lib/bacula”
        Pid Directory = “/run/bacula”
        Maximum Concurrent Jobs = 20
        }

        #
        # List Directors who are permitted to contact Storage daemon
        #
        Director {
        Name = maria-dir
        Password = “TwdfrcyxrD7FU9yDS0Gk2kphDpSSxCUw9kSyJHvtR0Cr”
        }

        #
        # Restricted Director, used by tray-monitor to get the
        # status of the storage daemon
        #
        Director {
        Name = maria-mon
        Password = “O7UjKLymJJrjiiz3f611G1oyeUAz0fObxIGCuRC5698U”
        Monitor = yes
        }

        #
        # Devices supported by this Storage daemon
        # To connect, the Director’s bacula-dir.conf must have the
        # same Name and MediaType.
        #

        Device {
        Name = FileStorage2 # This was what exist previously 20140322
        Media Type = File
        Archive Device = /backup_bacula_test_maria
        LabelMedia = yes; # lets Bacula label unlabeled media
        Random Access = Yes;
        AutomaticMount = yes; # when device opened, read it
        RemovableMedia = no;
        AlwaysOpen = no;
        #Maximum Network Buffer Size = 128000
        #Maximum block size = 128000
        }

        #
        # Send all messages to the Director,
        # mount messages also are sent to the email address
        #
        Messages {
        Name = Standard
        director = maria-dir = all
        }

        Note: On /backup_bacula_test_maria permitions are 777:
        drwxrwxrwx 2 bacula tape 4096 Mar 20 19:56 backup_bacula_test_maria

        ————————————————————————-
        Bacula-dir
        ————————————————————————-
        #
        # Default Bacula Director Configuration file
        #
        # The only thing that MUST be changed is to add one or more
        # file or directory names in the Include directive of the
        # FileSet resource.
        #
        # For Bacula release 5.2.5 (26 January 2012) — ubuntu 12.04
        #
        # You might also want to change the default email address
        # from root to your address. See the “mail” and “operator”
        # directives in the Messages resource.
        #

        Director { # define myself
        Name = maria-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 = 10 # Change from 1 to 10 due to the error is waiting on max Storage jobs
        # that happen when running a copy job.
        Password = “vOchjaYxGgFnKdbE5me5a3Tp5vs763FyoIhXdqUF733A” # Console password
        Messages = Daemon
        #DirAddress = 127.0.0.1 #Evitar que o director apenas aceite ligacoes na interface loopback permitindo assim ligacoes dos nossos clientes
        }

        # Definicoes de Clientes e Jobs
        @/etc/bacula/bacula-dir-clients-and-jobs.conf

        # Definicoes de arquivos para backup
        @/etc/bacula/bacula-dir-filesets.conf # Filesets pois podemos ter mais do que 1 fileset

        Schedule {
        Name = “WeeklyCycle”
        Run = Full 1st sun at 23:05
        Run = Differential 2nd-5th sun at 23:05 # Todos os domingos excepto o 1 de cada mes
        Run = Incremental mon-sat at 23:05
        }

        #step 7
        Schedule {
        Name = “TSTWeeklyCycle”
        Run = Incremental sat at 20:05 # Ao sabado corre
        }

        # Agendamento dos backups do catalogo. Feito sempre depois dos backups
        Schedule {
        Name = “WeeklyCycleAfterBackup”
        Run = Full sun-sat at 23:10
        }

        # Dispositivo de armazenamento
        Storage {
        Name = File
        # Do not use “localhost” here
        Address = backups.scma.pt # N.B. Use a fully qualified name here
        SDPort = 9103
        Password = “iibe_Uioa5dvFyVURE53p5KP4SuUpxnqW”
        Device = FileStorage
        Media Type = File
        }

        # Adding remote TSTServer to the maria director. This is made to test adding a storage a remote storage.
        # check mywiki documentation
        # step 2 (step3 is adding TSTSERVER on the maria hosts)
        Storage {
        Name = TSTFile
        Address = TSTSERVER
        SDPort = 9103
        Password = “TwdfrcyxrD7FU9yDS0Gk2kphDpSSxCUw9kSyJHvtR0Cr”
        Device = FileStorage2
        Media Type = File
        }

        # Generic catalog service
        Catalog {
        Name = MyCatalog
        # Uncomment the following line if you want the dbi driver
        # dbdriver = “dbi:sqlite3″; dbaddress = 127.0.0.1; dbport =
        dbname = “bacula”; DB Address = “”; dbuser = “bacula”; dbpassword = “y5R0T3q4HzZq”
        }

        # Reasonable message delivery — send most everything to email address
        # and to the console
        Messages {
        Name = Standard
        #
        # NOTE! If you send to two email or more email addresses, you will need
        # to replace the %r in the from field (-f part) with a single valid
        # email address in both the mailcommand and the operatorcommand.
        # What this does is, it sets the email address that emails would display
        # in the FROM field, which is by default the same email as they’re being
        # sent to. However, if you send email to more than one address, then
        # you’ll have to set the FROM address manually, to a single address.
        # for example, a ‘no-reply@mydomain.com’, is better since that tends to
        # tell (most) people that its coming from an automated source.

        #
        mailcommand = “/usr/lib/bacula/bsmtp -h localhost -f \”\(Bacula\) \\” -s \”Bacula: %t %e of %c %l\” %r”
        operatorcommand = “/usr/lib/bacula/bsmtp -h localhost -f \”\(Bacula\) \\” -s \”Bacula: Intervention needed for %j\” %r”
        mail = root@localhost = all, !skipped
        operator = root@localhost = mount
        console = all, !skipped, !saved
        #
        # WARNING! the following will create a file that you must cycle from
        # time to time as it will grow indefinitely. However, it will
        # also keep all your messages if they scroll off the console.
        #
        append = “/var/lib/bacula/log” = all, !skipped
        catalog = all
        }

        #
        # Message delivery for daemon messages (no job).
        Messages {
        Name = Daemon
        mailcommand = “/usr/lib/bacula/bsmtp -h localhost -f \”\(Bacula\) \\” -s \”Bacula daemon message\” %r”
        mail = root@localhost = all, !skipped
        console = all, !skipped, !saved
        append = “/var/lib/bacula/log” = all, !skipped
        }

        # Default pool definition
        Pool {
        Name = File_tst # O Job de backup por padrao aponta para o file
        Pool Type = Backup
        Recycle = yes # Bacula can automatically recycle Volumes
        AutoPrune = yes # Prune expired volumes
        Volume Retention = 1 month # 1 mes
        Volume Use Duration = 23 hours # duracao de uma volume aberto
        Maximum Volume Bytes = 100Mb # Tamanho maximo de um volume
        Maximum Volumes = 9 # Volume Bytes (100Mb) * Volumes (9) <= tamanho maximo do disco (no nosso caso é de 905M)
        # Assim temos 100Mb*9=900MB <= 905MB disponiveis no nosso sdb1 (mnt/backups)
        LabelFormat = "vol" # Este label é muito importante pois permite ao nosso bacula colocar nomes auto nos volumes
        # Vai criando vol0001 ; vol00002 ……

        Next Pool = TstFile # Step 4 of adding a remote pool TSTFILE
        }

        # step 1
        Pool {
        Name = TstFile
        Pool Type = Backup
        Storage = TSTFile
        Volume Use Duration = 1 day
        Volume Retention = 6 months
        # Scratch Pool = scratch.TSTFile # Tenho de avaliar melhor esta questão:w
        # RecyclePool = scratch.TSTFile
        File Retention = 1 year
        Job Retention = 1 year
        Cleaning Prefix = "CLN"
        }

        # Adding remote TSTServer to the maria director. This is made to test adding a storage a remote storage.
        # check mywiki documentation
        # step 5
        #For a Copy Job, the parameters “Client” and “FileSet” really don’t matter at all. They are just there because the “Job” entry requires them. That’s it.
        #What matter is:
        #Type: use the special keyword “Copy”;
        #Pool: which Pool the Jobs will be copied FROM (the Pool it self tells where they will be copied TO, with the “Next Pool” directive);
        #Selection Type: the option “PoolUncopiedJobs” basically tells Bacula to Copy all Jobs on this Pool that yet has not been copied before;
        #
        Job {
        Name = job.copyjob
        Type = Copy
        Pool = File_tst # which Pool the Jobs will be copied FROM. Our Case the pool file have the backup files
        Selection Type = PoolUncopiedJobs

        # Messages = msg.default
        Messages = Standard
        Schedule = "TSTWeeklyCycle" #sch.none
        #Client = client.none
        Client = TSTFile-fd
        #FileSet = fs.none
        FileSet = "Full Set TST"
        #Storage = TSTFile
        Storage = File
        }
        Client {
        Name = TSTFile-fd
        Address = TSTSERVER
        Password = "0LH28Guy00xHTBVtI8RQXacAFTJywDZH0Qn1/NBmfoy/"
        @/etc/bacula/basic-client.conf
        }
        FileSet {
        Name = "Full Set TST"
        Include {
        Options {
        signature = MD5
        compression = GZIP9
        IgnoreCase = yes
        }
        # Plugin = "C:\\Program Files\\Bacula\\Plugins"
        # File = "C:\\path_under_backup"
        }
        }

        #Step 6 – Change Storage on the TSTServer (add this info to the mywiki pag )
        # Scratch pool definition
        Pool {
        Name = Scratch
        Pool Type = Backup
        }

        #
        # Restricted console used by tray-monitor to get the status of the director
        #
        Console {
        Name = maria-mon
        Password = "k55_ecdHfYmiX_da–YREGpoWyeOiv3-N"
        CommandACL = status, .status
        }

  4. Nelson says :

    Dear Rodrigo Reina, thanks for your help. My problem was previously answered by you “You CAN’T Migrate or Copy your Jobs from one Storage Daemon to another” and I have not process well that information :(. So I was use nfs (http://en.wikipedia.org/wiki/Network_File_System) to be able to have a remote copy.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Follow

Get every new post delivered to your Inbox.

Join 144 other followers

%d bloggers like this: