Bacula is sophisticated backup solution that can be used to back up servers over a network.  In this series, we will cover how to install and configure Bacula on Ubuntu 12.04 servers.  We will then demonstrate how to configure remote backups in order to set up a system to keep safe copies of any computer in your infrastructure.

How to Leverage Bacula to Back Up your Ubuntu 12.04 Servers

<div name="status-deprecated" data-unique="status-deprecated"></div><h2 id="status-deprecated">Status: Deprecated</h2>

This article covers a version of Ubuntu that is no longer supported. If you are currently operate a server running Ubuntu 12.04, we highly recommend upgrading or migrating to a supported version of Ubuntu:

<ul>
<li><a href="https://www.digitalocean.com/community/tutorials/how-to-upgrade-ubuntu-12-04-lts-to-ubuntu-14-04-lts">Upgrade to Ubuntu 14.04</a>.</li>
<li><a href="https://www.digitalocean.com/community/tutorials/how-to-upgrade-to-ubuntu-16-04-lts">Upgrade from Ubuntu 14.04 to Ubuntu 16.04</a></li>
<li><a href="https://www.digitalocean.com/community/tutorials/how-to-migrate-linux-servers-part-1-system-preparation">Migrate the server data to a supported version</a></li>
</ul>

Reason:
<a href="https://lists.ubuntu.com/archives/ubuntu-announce/2017-March/000218.html">Ubuntu 12.04 reached end of life (EOL) on April 28, 2017</a> and no longer receives security patches or updates. This guide is no longer maintained.

See Instead: 
This guide might still be useful as a reference, but may not work on other Ubuntu releases. If available, we strongly recommend using a guide written for the version of Ubuntu you are using. You can use the search functionality at the top of the page to find a more recent version. <h3>What the Red Means</h3>

The lines that the user needs to enter or customize will be in red in this tutorial! The rest should mostly be copy-and-pastable.

<h3>Introduction</h3>

Bacula is a sophisticated backup solution that can handle local and remote backups by leveraging a client-server model. It has very flexible configuration options that provide complete control over the backup environment.

In this guide, we will be backing up the entire root filesystem of our Ubuntu 12.04 VPS.

An updated version of this guide can be found here: <a href="https://www.digitalocean.com/community/tutorials/how-to-install-bacula-server-on-ubuntu-14-04">How To Install Bacula Server on Ubuntu 14.04</a>.

<h2>Installing MySQL</h2>

Bacula uses an SQL database to manage its information. We will be using MySQL for this tutorial.

For an Ubuntu 12.04 VPS, this setup must be installed in advance, or else the following error will occur during installation of the bacula suite:

<pre>An error occurred while installing the database:

ERROR 2002 (HY000): Can't connect to local MySQL server through socket '/var/run/mysqld/mysqld.sock' (2) </pre>

To avoid this situation, we can simply install MySQL prior to installing the bacula components:

<pre>sudo apt-get update
sudo apt-get install mysql-server</pre>

You will be prompted to provide and confirm a database administrator password. Enter a password to continue.

<h2>Installing Bacula</h2>

Next, we will install the bacula components:

<pre>sudo apt-get install bacula-server bacula-client</pre>

You will be prompted to set up a database for bacula. Select "yes" to allow dbconfig-common to automatically configure the database.

When prompted, enter the database administrator password that you selected when installing MySQL. It will then ask for an application password for bacula-director-mysql. Press "Enter" or "Return" to generate a random password.

<h2>Filesystem Configuration</h2>

Next, we need to create some directories to act as our backup and restore points.

Using the "-p" flag with the "mkdir" command creates any necessary parent directories along with the target directory:

<pre>sudo mkdir -p /bacula/backup /bacula/restore</pre>

We need to change the file permissions so that only the bacula process can access these locations.

<pre>sudo chown -R bacula:bacula /bacula
sudo chmod -R 700 /bacula</pre>

<h2>Configuring Bacula</h2>

Bacula has several components that must be configured independently in order to function correctly. The configuration files can all be found in the /etc/bacula/ directory.

<h3>Configuring bacula-dir.conf</h3>

Start by editing the bacula-dir.conf file:

<pre>sudo nano /etc/bacula/bacula-dir.conf</pre>

A few different sections must be modified for the backups that we will be performing in this guide.

First, search for the "Standard Restore template" section. Under the "Job" settings, change the Where parameter to point to the restore point we created:

<pre>Job {
 Name = "RestoreFiles"
 Type = Restore
 Client=Blank-fd
 FileSet="Full Set"
 Storage = File
 Pool = Default
 Messages = Standard
 Where = /bacula/restore
}</pre>

Next, search for the "List of files to be backed up" section. Under the "FileSet" settings, we will add an option to use gzip to compress our archives.

We will then specify exactly what we would like to backup with the "File =" parameter. You can have multiple "File =" declarations in this section, each with a different path.

For this guide, we will be backing up the entire root (/) file system. Change the parameters to reflect that:

<pre>Include {
 Options {
 signature = MD5
 compression = GZIP
 }
# 
# Put your list of files here, preceded by 'File =', one per line
# or include an external list with:
#
# File = file-name
#
# Note: / backs up everything on the root partition.
# if you have other partitions such as /usr or /home
# you will probably want to add them too.
#
# By default this is defined to point to the Bacula binary
# directory to give a reasonable FileSet to backup to
# disk storage during initial testing.
#
 File = /
 }</pre>

Finally, add file paths to be excluded from the backup. This is done in the Exclude section of the FileSet directory by using the same "File =" syntax that we used in the Include section.

The defaults are generally good here, but we need to change the path to the archive directory. We do not want to backup the backup folder. Change the second "File =" to reflect our root bacula file path:

<pre>Exclude {
 File = /var/lib/bacula
 File = /bacula
 File = /proc
 File = /tmp
 File = /.journal
 File = /.fsck
 }</pre>

Save and close the file.

<h3>Configuring bacula-sd.conf</h3>

The next file we need to edit is the bacula-sd.conf file. This will define the area where bacula stores its backups.

Open the bacula-sd.conf file with sudo privileges:

<pre>sudo nano /etc/bacula/bacula-sd.conf</pre>

Under the "Devices supported by this Storage daemon" section, in the "Device" configuration, change the Archive Device to reflect the backup location we set up earlier:

<pre>Device {
 Name = FileStorage
 Media Type = File
 Archive Device = /bacula/backup
 LabelMedia = yes; # lets Bacula label unlabeled media
 Random Access = Yes;
 AutomaticMount = yes; # when device opened, read it
 RemovableMedia = no;
 AlwaysOpen = no;
}</pre>

Save and close the file.

<h2>Checking Configuration Syntax</h2>

Before continuing, check that the configuration options that we used are recognized by bacula. We can use bacula's internal testing utilities to ensure that there are no syntax errors in the files we modified.

First, check the bacula director configuration:

<pre>sudo bacula-dir -tc /etc/bacula/bacula-dir.conf</pre>

If the command executes without returning any output, the configuration file is syntactically correct. Next, check the bacula storage configuration:

<pre>sudo bacula-sd -tc /etc/bacula/bacula-sd.conf</pre>

Again, no output signifies that our configuration file is valid.

At this time, restart the bacula services we modified to make the changes propagate:

<pre>sudo service bacula-sd restart
sudo service bacula-director restart</pre>

We are now ready to test our backups.

<h2>Testing the Backup</h2>

We will be interacting with bacula through its internal console. This can be accessed with the "bconsole" command:

<pre>sudo bconsole</pre>

You will be dropped into a bacula console with an asterisk (*) for a prompt. Begin by issuing the "label" command. You will be prompted to enter a name for the archive file that will be created:

<pre>label</pre>

<pre>Automatically selected Catalog: MyCatalog
Using Catalog "MyCatalog"
Automatically selected Storage: File
Enter new Volume name: MyArchiveName</pre>

Select the kind of storage "pool" for the backup. Since our backup will be stored as a file, select #2:

<pre>2: File</pre>

Bacula now knows how we want to write the data for our backup. We can now run our backup to test that it works correctly:

<pre>run</pre>

<pre>A job name must be specified.
The defined Job resources are:
 1: BackupClient1
 2: BackupCatalog
 3: RestoreFiles
Select Job resource (1-3):</pre>

Select #1 to choose the backup that we configured. 

<pre>1: BackupClient1</pre>

At the prompt, type "yes" to perform the backup:

<pre>yes</pre>

Bacula will tell you that you have messages. The messages will be the output generated by the backup. Check the messages for errors by typing:

<pre>messages</pre>

You will see some output lines. Check again until you see a summary showing the results of the backup. It might take a few minutes. It should say "Termination: Backup OK". Check that no errors were generated.

<h2>Testing the Restore</h2>

Now that a backup has been created, it is important to check that it can be restored properly. In the bacula console, type:

<pre>restore all</pre>

A selection menu will appear with many different options. We would like to restore the most recent backup, so select Option 5:

<pre>5: Select the most recent backup for a client</pre>

This will drop you into a virtual file tree with the entire directory structure that you backed up. This interface allows for simple commands to mark and unmark files to be restored.

Because we specified that we wanted to "restore all", every backed up file is pre-selected for restoration.

If you would like to fine-tune your selection, you can navigate and list files with the "ls" and "cd" commands, mark files for restoration with "mark", and unmark files with "unmark". A full list of commands is available by typing "help" into the console.

<pre>help</pre>

When you are finished, exit the file selection by typing:

<pre>done</pre>

Confirm that you would like to restore:

<pre>yes</pre>

Again, check the messages for errors when the restoration is complete.

<pre>messages</pre>

The summary should have a line that reads "Termination: Restore OK". When you are finished, type "exit" to leave the bacula console:

<pre>exit</pre>

<h2>Checking the Filesystem</h2>

To check that the backup was completed as expected, list the contents of the backup directory. You will need to use sudo since the directory structure is owned by the "bacula" user:

<pre>sudo ls /bacula/backup</pre>

You should see a file with the archive name you chose.

Next, we should check our restore point. List the contents of the restore point directory:

<pre>sudo ls /bacula/restore</pre>

You should see a mirror of the root file structure, excluding the files and directories that were listed in the "Exclude" section of the bacula-dir.conf file.

You now have a basic bacula setup that can backup your local filesystem. Bacula is also a powerful solution for remote backups. Click here to learn <a href="https://www.digitalocean.com/community/articles/how-to-configure-remote-backups-using-bacula-in-an-ubuntu-12-04-vps">how to configure remote backups using bacula</a>.

<div class="author">By Justin Ellingwood</div>

In this article, we will install and configure Bacula on an Ubuntu 12.04 Virtual Private Server instance.  Bacula is a powerful backup solution that offers flexibility and scaleability by relying on a client-server model.

Installing and Configuring Bacula on an Ubuntu 12.04 VPS

<div name="status-deprecated" data-unique="status-deprecated"></div><h2 id="status-deprecated">Status: Deprecated</h2>

This article covers a version of Ubuntu that is no longer supported. If you are currently operate a server running Ubuntu 12.04, we highly recommend upgrading or migrating to a supported version of Ubuntu:

<ul>
<li><a href="https://www.digitalocean.com/community/tutorials/how-to-upgrade-ubuntu-12-04-lts-to-ubuntu-14-04-lts">Upgrade to Ubuntu 14.04</a>.</li>
<li><a href="https://www.digitalocean.com/community/tutorials/how-to-upgrade-to-ubuntu-16-04-lts">Upgrade from Ubuntu 14.04 to Ubuntu 16.04</a></li>
<li><a href="https://www.digitalocean.com/community/tutorials/how-to-migrate-linux-servers-part-1-system-preparation">Migrate the server data to a supported version</a></li>
</ul>

Reason:
<a href="https://lists.ubuntu.com/archives/ubuntu-announce/2017-March/000218.html">Ubuntu 12.04 reached end of life (EOL) on April 28, 2017</a> and no longer receives security patches or updates. This guide is no longer maintained.

See Instead: 
This guide might still be useful as a reference, but may not work on other Ubuntu releases. If available, we strongly recommend using a guide written for the version of Ubuntu you are using. You can use the search functionality at the top of the page to find a more recent version. <h3>What the Red Means</h3>

The lines that the user needs to enter or customize will be in red in this tutorial! The rest should mostly be copy-and-pastable.

<h3>Introduction</h3>

Bacula is a sophisticated backup solution that can handle local and remote backups by leveraging a client-server model. It has very flexible configuration options that provide complete control over the backup environment.

In this guide, we will be setting up a remote backup involving a backup cloud server and a client machine that will be completely backed up.

You will need two separate server instances. The first server must be set up according to the configuration outlined in the <a href="https://www.digitalocean.com/community/articles/installing-and-configuring-bacula-on-an-ubuntu-12-04-vps">Installing and Configuring Bacula on an Ubuntu 12.04 VPS</a> guide. The second server will be another Ubuntu 12.04 machine.

For the purposes of this guide, the backup VPS has a hostname of BackupServer and the client machine's host name is ClientMachine. Change these values to reflect the server names of the machines you are using.


<h3>Table of Contents</h3>

<ol>
<li><a href="#client-installation">Client Installation</a></li>
<li><a href="#client-machine-configuration">Client Machine Configuration</a></li>
<li><a href="#backup-server-configuration">Backup Server Configuration</a>

<ul><li><a href="#job-config">Job Configuration</a></li>
<li><a href="#client-config">Client Configuration</a></li>
<li><a href="#storage-config">Storage Configuration</a></li>
<li><a href="#pool-config">Pool Configuration</a></li>
<li><A href="#bacula-sd-config">Editing bacula-sd.conf</a></li></ul>

</li>
<li><a href="#checking-configuration">Checking the Configuration and Restarting Services</a></li>
<li><a href="#testing-backups">Testing Remote Backups</a></li>
<li><a href="#testing-restores">Testing Remote Restore</a></li>
<li><a href="#checking-filesystem">Checking the Filesystem</a></li>
</ol>


<h2 id="client-installation">Client Installation</h2>

No local backups will be stored on the remote client machine, so not all of the bacula components need to be installed.

Install the the bacula-fd (file-daemon) and the bconsole (bacula console) on this machine with apt-get using the bacula-client metapackage:

<pre>sudo apt-get update
sudo apt-get install bacula-client</pre>

The necessary components are now installed and ready to be configured.

<h2 id="client-machine-configuration">Client Machine Configuration</h2>

The configuration of the client environment is relatively straightforward. We will only be editing the bacula file daemon configuration file. Open the file with root privileges with the following command:

<pre>sudo nano /etc/bacula/bacula-fd.conf</pre>

We need to change a few items and save some information that we will need for our server configuration. Begin by finding the Director section.

The bacula director is located on the backup VPS. Change the "Name" parameter to the hostname of your backup server followed by "-dir".

You also need to copy the password that bacula generated for your client file daemon to some place that you'll have available when you are configuring your backup server settings:

<pre>Director {
 Name = BackupServer-dir
 Password = "u2LK-yBrQzfiEsc6NWftHEhymmdPWsklN" # Copy this password for later reference!
}</pre>

Next, we need to adjust one parameter in the FileDaemon section. We will change the "FDAddress" parameter to match the IP address or domain name of our client machine. The "Name" parameter should already be populated correctly with the client file daemon name:

<pre>FileDaemon { # this is me
 Name = ClientMachine-fd
 FDport = 9102 # where we listen for the director
 WorkingDirectory = /var/lib/bacula
 Pid Directory = /var/run/bacula
 Maximum Concurrent Jobs = 20
 FDAddress = ClientMachine.DomainName.com
}</pre>

We also need to configure this daemon to pass its log messages to the backup cloud server. Find the Messages section and change the "director" parameter to match your backup cloud server's name.

<pre>Messages {
 Name = Standard
 director = BackupServer-dir = all, !skipped, !restored
}</pre>

Save the file and exit.

Check that your configuration file has the correct syntax with the following command:

<pre>sudo bacula-fd /etc/bacula/bacula-fd.conf</pre>

If the command returns no output, the configuration file has valid syntax. Restart the file daemon to use the new settings:

<pre>sudo service bacula-fd restart</pre>

The client machine is now correctly configured.

In this example, we would like to restore to a folder on this same machine. Create the file structure and lock down the permissions and ownership for security with the following commands:

<pre>sudo mkdir -p /bacula/restore
sudo chown -R bacula:bacula /bacula
sudo chmod -R 700 /bacula</pre>

The client machine is now configured correctly. Next, we will configure the backup cloud server to pull the file data from the client.

<h2 id="backup-server-configuration">Backup Server Configuration</h2>

Log into the backup cloud server to complete this stage of the configuration.

The bulk of the configuration is actually done on the backup server. That is because the bacula "director" manages all other bacula processes and must be able to communicate correctly with a number of different components.

To start, open the "bacula-dir.conf" file with administrator privileges:

<pre>sudo nano /etc/bacula/bacula-dir.conf</pre>

<h3 id="job-config">Job Configuration</h3>

Begin by finding the Job Section. The current configuration is named "BackupClient1" and is used for the backup server's local backup. We need to change the name to reflect this:

<pre>Job {
 Name = "LocalBackup"
 JobDefs = "DefaultJob"
}</pre>

Now that we have identified the first job as backing up on the local machine, we want to create a similar job for backup up our remote client. To do this, copy and paste the job definition below the one you just modified.

Change the name to reflect the fact that this is a remote backup scenario. The "Client" parameter identifies our remote client file daemon as the target for our backup. The Pool parameter allows bacula to store its remote backups separate from our local backups. We will define the pool we're referencing later in the file:

<pre>Job {
 Name = "RemoteBackup"
 JobDefs = "DefaultJob"
 Client = ClientMachine-fd
 Pool = RemoteFile
}</pre>

Next, define a place for the remote backups to restore. We will use the directory that we created on the client machine to restore remote backups.

Find the "RestoreFiles" job definition. Copy the current entry and paste it below. We will then modify some entries to label it accurately and work with client machine:

<pre>Job {
 Name = "RestoreRemote"
 Type = Restore
 Client=ClientMachine-fd
 FileSet="Full Set"
 Storage = File 
 Pool = Default
 Messages = Standard
 Where = /bacula/restore
}</pre>

<h3 id="client-config">Client Configuration</h3>

Find the Client definition. We will change the "Address" parameter to reflect our actual backup cloud server IP address instead of using localhost. The password should already be set correctly for the local machine.

<pre>Client {
 Name = BackupServer-fd
 Address = BackupServer.DomainName.com
 FDPort = 9102
 Catalog = MyCatalog
 Password = "CRQF7PW-mJumFtENX2lqGvJ6gixPTyRQp" # password for Local FileDaemon
 File Retention = 30 days # 30 days
 Job Retention = 6 months # six months
 AutoPrune = yes # Prune expired Jobs/Files
}</pre>

The next step is to actually define the client machine that we've been referencing in our configuration. Copy the Client entry we just modified paste it below the current definition. This new definition will be for the remote machine that we are backing up.

Match the name to your client machine's hostname followed by "-fd". The "Address" line needs to match the client machine's IP address or domain name as well.

Finally, this is where you enter the password that you copied from the remote client's file daemon configuration file. Make sure that you modify this password value, or else bacula will not function correctly.

<pre>Client {
 Name = ClientMachine-fd
 Address = ClientMachine.DomainName.com
 FDPort = 9102 
 Catalog = MyCatalog
 Password = "u2LK-yBrQzfiEsc6NWftHEhymmdPWsklN" # password for Remote FileDaemon
 File Retention = 30 days # 30 days
 Job Retention = 6 months # six months
 AutoPrune = yes # Prune expired Jobs/Files
}</pre>

<h3 id="storage-config">Storage Configuration</h3>

Next, change the "Address" parameter in the Storage section with the IP address or domain name of the backup VPS. Once again, the password should already be correct here:

<pre>Storage {
 Name = File
# Do not use "localhost" here 
 Address = BackupServer.DomainName.com # N.B. Use a fully qualified name here
 SDPort = 9103
 Password = "097dnj3jw1Yynpz2AC38luKjy5QTnGoxS"
 Device = FileStorage
 Media Type = File
}</pre>



<h3 id="pool-config">Pool Configuration</h3>

Find the Pool definitions section. We will first add a parameter to the "File" pool definition. Add the "Label Format" parameter to the definition and choose a prefix to name local file backups. For this guide, local backups will have "Local-" as a prefix.

<pre>Pool {
 Name = File
 Pool Type = Backup
 Recycle = yes # Bacula can automatically recycle Volumes
 Label Format = Local-
 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
}</pre>

Next, we need to copy the section we just modified and paste it below the current entry. This will be set up for remote backup storage.

Change the name of the new pool to reflect its job of storing remote backups. Also, change the prefix by adjusting the "Label Format" parameter to be "Remote-"

<pre>Pool { 
 Name = RemoteFile
 Pool Type = Backup
 Recycle = yes # Bacula can automatically recycle Volumes
 Label Format = Remote-
 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
}</pre>

Save and close the file. 

<h3 id="bacula-sd-config">Editing bacula-sd.conf</h3>

Next, open the "bacula-sd.conf" file with root privileges:

<pre>sudo nano /etc/bacula/bacula-sd.conf</pre>

Change the "SDAddress" parameter to reflect the backup server's IP address or domain name:

<pre>Storage { # definition of myself
 Name = BackupServer-sd
 SDPort = 9103 # Director's port
 WorkingDirectory = "/var/lib/bacula"
 Pid Directory = "/var/run/bacula"
 Maximum Concurrent Jobs = 20
 SDAddress = BackupServer.DomainName.com
}</pre>

Save and close the file.

<h2 id="checking-configuration">Checking the Configuration and Restarting Services</h2>

Check the configuration with the following commands:

<pre>sudo bacula-dir /etc/bacula/bacula-dir.conf
sudo bacula-sd /etc/bacula/bacula-sd.conf</pre>

If no output is returned, the configuration files have valid syntax. If this is the case, restart the daemons to use the new settings:

<pre>sudo service bacula-director restart
sudo service bacula-sd restart</pre>

<h2 id="testing-backups">Testing Remote Backups</h2>

Log into the bacula console to test the backup functionality.

<pre>sudo bconsole</pre>

Test that the bacula director can connect to the remote machine by typing the following:

<pre>status</pre>
<pre>Status available for:
 1: Director
 2: Storage
 3: Client
 4: All
Select daemon type for status (1-4): </pre>

Choose #3 to check on the client connection and then select the remote machine:

<pre>3: Client</pre>
<pre>2: ClientMachine-fd</pre>

It should return a summary with some statistics, confirming that we can connect to the remote file daemon.

Run a test backup of the remote system by typing the following command:

<pre>run</pre>
<pre>Automatically selected Catalog: MyCatalog
Using Catalog "MyCatalog"
A job name must be specified.
The defined Job resources are:
 1: LocalBackup
 2: RemoteBackup
 3: BackupCatalog
 4: RestoreFiles
 5: RestoreRemote
Select Job resource (1-5): </pre>

Select the "RemoteBackup" option to run a backup of the remote machine. Type "yes" to begin the backup:

<pre>2: RemoteBackup</pre>

The director will send the backup task to the remote file daemon and which will pass its information to the backup server's storage daemon. You can check the status of the job using the "status" command as we did above. You should also check the messages using the "messages" command.

<pre>messages</pre>

If you continue to check messages, eventually you will receive a summary of the backup operation. It should contain the line "Termination: Backup OK" if everything went as expected.

<h2 id="testing-restores">Testing Remote Restore</h2>

Now, test the restore functionality:

<pre>restore all</pre>

Choose the "Select the most recent backup for a client" option. Select the remote client that we have just backed up:

<pre>5: Select the most recent backup for a client</pre>
<pre>2: ClientMachine-fd</pre>

You will be dropped into a file tree where you are able to select the files you would like to restore with the "mark" and "unmark" commands.

We have chosen to restore everything, so we can just type "done" to move on. Select the job that we defined for remote restoration and type "yes" to run the restoration:

<pre>done</pre>
<pre>2: RestoreRemote</pre>

Again, you can check the restoration with the "status" and "messages" commands. You should eventually get a summary in the messages that contains the line "Termination: Restore OK". This means the restoration was successful. Type "exit" to leave the bacula console.

<pre>exit</pre>

<h2 id="checking-filesystem">Checking the Filesystem</h2>

We can check that our remote backup file has the correct file format with the following command:

<pre>sudo ls /bacula/backup</pre>
<pre>LocalBackup Remote-0002</pre>

As you can see, our backup file for the remote system has adapted the naming conventions we supplied. The local backup is not named according to our convention because it is from before our changes.

If we log into our remote client machine, we can check our restore with the following line:

<pre>sudo ls /bacula/restore</pre>
<pre>bin dev home lib	 media opt	run selinux sys var
boot etc initrd.img lost+found mnt	 root	sbin srv usr vmlinuz</pre>

As you can see, we have restored the filesystem to this folder correctly.

<div class="author">By Justin Ellingwood</div>

In this article, we will discuss how to configure Bacula to perform remote backups.  Bacula is a sophisticated backup system which can be scaled easily due to the client-server relationship of its components.

How to Configure Remote Backups Using Bacula in an Ubuntu 12.04 VPS

Sign up for Infrastructure as a Newsletter.

Working on improving health and education, reducing inequality, and spurring economic growth? DigitalOcean would like to help.

Working on improving health and education, reducing inequality, and spurring economic growth? We'd like to help.

Get paid to write technical tutorials and select a tech-focused charity to receive a matching donation.

You get paid; we donate to tech nonprofits.

DigitalOcean makes it simple to launch in the cloud and scale up as you grow – whether you’re running one virtual machine or ten thousand.