--- title: "How to Set Up a Bacula Backup Server on Ubuntu 24.04" description: "Install Bacula on Ubuntu 24.04 with a PostgreSQL catalog, set up disk storage, pools and schedules, back up the server and a remote client, and restore files." category: "Storage and Backup Advanced" language: en source: https://cubepath.com/docs/storage-and-backup-advanced/bacula-enterprise-backup-configuration updated: 2026-09-25 --- # How to Set Up a Bacula Backup Server on Ubuntu 24.04 Bacula is a network backup system built from separate daemons: a Director that schedules jobs and keeps a catalog database, a Storage Daemon that writes backup volumes, and a File Daemon on every machine you back up. In this tutorial you will install the open-source Bacula packages from Ubuntu 24.04 with a PostgreSQL catalog, store backups on local disk, back up the server itself and one remote client on a nightly schedule, and restore files with `bconsole`. ## Prerequisites To follow this guide you need: - A server running Ubuntu 24.04 LTS for the backup server, for example a CubePath VPS, with at least 2 GB of RAM. Ideally give it a separate disk or volume for backup data, mounted at `/srv/bacula`. - A second Ubuntu 24.04 server to back up as a remote client (optional, used in Step 7). - A non-root user with `sudo` privileges on both. - A private network between them. The examples use `10.0.0.10` for the backup server and `10.0.0.21` for the client `web1`. ## Understanding the Bacula components | Component | Package | Port | Runs on | |-----------|---------|------|---------| | Director (`bacula-dir`) | `bacula-director-pgsql` | 9101 | Backup server | | Storage Daemon (`bacula-sd`) | `bacula-sd` | 9103 | Backup server | | File Daemon (`bacula-fd`) | `bacula-fd` | 9102 | Every machine you back up | | Console (`bconsole`) | `bacula-console` | - | Wherever you administer from | | Catalog | PostgreSQL | 5432 (local) | Backup server | During a backup, the Director connects to the File Daemon and tells it which Storage Daemon to use. The File Daemon then connects to the Storage Daemon directly and streams the data. Each connection is authenticated with a shared password, so the passwords in the different configuration files must match. Keep this in mind: most Bacula errors are a name or password that does not match between two files. ## Step 1 - Installing PostgreSQL and Bacula Install PostgreSQL first, so the Bacula package can create its catalog database during installation: ```bash sudo apt update sudo apt install postgresql ``` Now install the Director with PostgreSQL support, the Storage Daemon, the File Daemon and the console: ```bash sudo apt install bacula-director-pgsql bacula-sd bacula-fd bacula-console ``` The installer asks **Configure database for bacula-director-pgsql with dbconfig-common?** Answer **Yes**, then press Enter to accept a randomly generated password for the database user. The package creates the `bacula` database and its tables for you. Check that the catalog exists and that the three daemons are running: ```bash sudo -u postgres psql -lqt | cut -d '|' -f 1 | grep -w bacula systemctl is-active bacula-director bacula-sd bacula-fd ``` ```output bacula active active active ``` Open the console to confirm it can reach the Director: ```bash echo "status director" | sudo bconsole ``` The output starts with `Connecting to Director localhost:9101` and shows the Director version and `No Jobs running.` ## Step 2 - Collecting names and passwords The package generates random passwords in each configuration file. You will reuse them, so print them now. The Director's own name, which the other daemons use to recognize it: ```bash sudo grep -A 2 "^Director {" /etc/bacula/bacula-dir.conf ``` ```output Director { # define myself Name = backup-dir DIRport = 9101 # where we listen for UA connections ``` The password the Director must use with the Storage Daemon (first `Director` block in `bacula-sd.conf`): ```bash sudo grep -A 2 "^Director {" /etc/bacula/bacula-sd.conf ``` ```output Director { Name = backup-dir Password = "Xk8pR2...generated..." ``` And the password the Director must use with the local File Daemon: ```bash sudo grep -A 2 "^Director {" /etc/bacula/bacula-fd.conf ``` Note the three values. The examples below use `backup-dir` as the Director name, `your_sd_password` and `your_local_fd_password`. The files also contain a second `Director` block with `Monitor = yes`; ignore it. ## Step 3 - Configuring disk storage Create the directory where the Storage Daemon writes backup volumes. On Ubuntu the daemon runs as user `bacula` and group `tape`: ```bash sudo mkdir -p /srv/bacula/volumes sudo chown bacula:tape /srv/bacula/volumes sudo chmod 750 /srv/bacula/volumes ``` Open the Storage Daemon configuration: ```bash sudo nano /etc/bacula/bacula-sd.conf ``` In the `Storage { ... }` block at the top, look for `SDAddress`. Ubuntu sets it to `127.0.0.1`, which only works for local clients. Remote File Daemons connect to the Storage Daemon directly, so change it to the server's private IP: ```text SDAddress = 10.0.0.10 ``` Then add a new `Device` resource at the end of the file: ```text Device { Name = LocalDisk Media Type = LocalDisk Archive Device = /srv/bacula/volumes LabelMedia = yes Random Access = yes AutomaticMount = yes RemovableMedia = no AlwaysOpen = no Maximum Concurrent Jobs = 5 } ``` `LabelMedia = yes` lets Bacula create and label new volume files automatically, so you never have to label disk volumes by hand. Test the syntax and restart the daemon: ```bash sudo bacula-sd -t -c /etc/bacula/bacula-sd.conf sudo systemctl restart bacula-sd sudo ss -tlnp | grep 9103 ``` ```output LISTEN 0 50 10.0.0.10:9103 0.0.0.0:* users:(("bacula-sd",pid=4211,fd=3)) ``` The `-t` test prints nothing when the file is valid. ## Step 4 - Defining storage, pool, schedule and fileset in the Director Rather than editing the long default Director file, keep your resources in a separate file and include it. Add this line at the very end of `/etc/bacula/bacula-dir.conf`: ```bash sudo nano /etc/bacula/bacula-dir.conf ``` ```text @/etc/bacula/conf.d/local.conf ``` Create the included file with the same ownership as the other configuration files, so the Director (running as `bacula`) can read it: ```bash sudo mkdir -p /etc/bacula/conf.d sudo install -m 640 -o root -g bacula /dev/null /etc/bacula/conf.d/local.conf sudo nano /etc/bacula/conf.d/local.conf ``` Add the following resources. Replace `your_sd_password` and `your_local_fd_password` with the values from Step 2: ```text Storage { Name = LocalDisk Address = 10.0.0.10 SDPort = 9103 Password = "your_sd_password" Device = LocalDisk Media Type = LocalDisk Maximum Concurrent Jobs = 5 } Pool { Name = DiskPool Pool Type = Backup Recycle = yes AutoPrune = yes Volume Retention = 35 days Maximum Volume Bytes = 10G Maximum Volumes = 50 Label Format = "Vol-" } Schedule { Name = "NightlyCycle" Run = Full 1st sun at 01:05 Run = Differential 2nd-5th sun at 01:05 Run = Incremental mon-sat at 01:05 } FileSet { Name = "ServerFiles" Include { Options { signature = SHA1 compression = GZIP } File = /etc File = /home File = /var/www } Exclude { File = /var/lib/bacula File = /tmp } } JobDefs { Name = "NightlyJob" Type = Backup Level = Incremental FileSet = "ServerFiles" Schedule = "NightlyCycle" Storage = LocalDisk Pool = DiskPool Messages = Standard Priority = 10 Write Bootstrap = "/var/lib/bacula/%c.bsr" } Client { Name = local-fd Address = 127.0.0.1 FDPort = 9102 Catalog = MyCatalog Password = "your_local_fd_password" File Retention = 35 days Job Retention = 6 months AutoPrune = yes } Job { Name = "backup-local" JobDefs = "NightlyJob" Client = local-fd } ``` What these resources do: - **Storage** tells the Director how to reach the Storage Daemon and which device to use. The address must be reachable by every client, which is why it is the private IP and not `127.0.0.1`. - **Pool** groups volumes. Each volume file holds up to 10 GB; after 35 days a volume can be recycled, so disk usage stays bounded at about 50 x 10 GB. - **Schedule** runs a full backup on the first Sunday of the month, differentials on other Sundays and incrementals the rest of the week. - **FileSet** lists what to back up. Add the directory where you keep database dumps, since Bacula should copy dumps rather than live database files. - **JobDefs** holds defaults shared by jobs, and each **Job** only adds its client. `MyCatalog` and `Standard` are defined in the default Director configuration. Also keep the volume retention (35 days) at least as long as a full backup cycle, otherwise a volume holding the last full backup could be recycled before the next one runs. Test the configuration and restart the Director: ```bash sudo bacula-dir -t -c /etc/bacula/bacula-dir.conf sudo systemctl restart bacula-director ``` > Note: The default configuration also contains example jobs such as `BackupClient1`, which run on their own schedule to the default storage. Once your own job works, comment out the example `Job` blocks you do not use to keep the job list clean. ## Step 5 - Running the first backup Start the console: ```bash sudo bconsole ``` At the `*` prompt, start a full backup of the local server and wait for it to finish: ```text run job=backup-local level=Full yes wait messages ``` The `messages` output ends with a job report. The important lines are: ```output Job: backup-local.2026-09-25_10.42.18_03 Backup Level: Full FileSet: "ServerFiles" 2026-09-25 10:42:18 Pool: "DiskPool" (From Job resource) Storage: "LocalDisk" (From Job resource) Volume name(s): Vol-0001 SD Files Written: 3,214 Termination: Backup OK ``` `Termination: Backup OK` is what you are looking for. Bacula created and labeled `Vol-0001` automatically. Check the job list and the volumes: ```text list jobs list volumes pool=DiskPool ``` Type `exit` to leave the console. On disk, the volume is a regular file: ```bash sudo ls -lh /srv/bacula/volumes ``` ```output -rw-r----- 1 bacula tape 58M Sep 25 10:42 Vol-0001 ``` ## Step 6 - Restoring files Test a restore right away. Restores go to a separate directory by default, so nothing live is overwritten. In `bconsole`, run: ```text restore client=local-fd fileset=ServerFiles where=/tmp/bacula-restores select current all done yes wait messages ``` This selects the most recent backup of `local-fd`, marks all files, and runs the default `RestoreFiles` job. The report should end with `Termination: Restore OK`. Compare the restored copy with the original: ```bash sudo diff -r /etc/ssh /tmp/bacula-restores/etc/ssh && echo "Restore matches" ``` ```output Restore matches ``` To restore only some files, run `restore` without arguments. Choose option **5** (*Select the most recent backup for a client*), pick the client, and Bacula opens a file browser where you use `cd`, `ls`, `mark ` and finally `done`. Before confirming, type `mod` to change the restore location (`Where`) if needed. Clean up the test restore: ```bash sudo rm -rf /tmp/bacula-restores ``` ## Step 7 - Adding a remote client On the **client** (`web1`), install only the File Daemon: ```bash sudo apt update sudo apt install bacula-fd ``` Generate a password for this client: ```bash openssl rand -base64 33 ``` Edit the File Daemon configuration: ```bash sudo nano /etc/bacula/bacula-fd.conf ``` In the first `Director` block, set `Name` to your Director's name from Step 2 and `Password` to the new password: ```text Director { Name = backup-dir Password = "your_web1_fd_password" } ``` In the `FileDaemon` block, change `FDAddress` from `127.0.0.1` to the client's private IP, so the Director can reach it over the private network: ```text FDAddress = 10.0.0.21 ``` Leave the other directives in the file as they are. Test, restart and allow the Director to connect: ```bash sudo bacula-fd -t -c /etc/bacula/bacula-fd.conf sudo systemctl restart bacula-fd sudo ufw allow from 10.0.0.10 to any port 9102 proto tcp ``` On the **backup server**, allow the client to reach the Storage Daemon: ```bash sudo ufw allow from 10.0.0.21 to any port 9103 proto tcp ``` Then add the client and its job to `/etc/bacula/conf.d/local.conf`: ```text Client { Name = web1-fd Address = 10.0.0.21 FDPort = 9102 Catalog = MyCatalog Password = "your_web1_fd_password" File Retention = 35 days Job Retention = 6 months AutoPrune = yes } Job { Name = "backup-web1" JobDefs = "NightlyJob" Client = web1-fd } ``` Test and reload the Director: ```bash sudo bacula-dir -t -c /etc/bacula/bacula-dir.conf sudo systemctl restart bacula-director ``` In `bconsole`, check that the Director can talk to the client, then run a first backup: ```text status client=web1-fd run job=backup-web1 level=Full yes wait messages ``` `status client` prints the client's version and `No Jobs running`. The backup report should again end with `Termination: Backup OK`. ## Step 8 - Checking scheduled jobs Both jobs now run every night at 01:05. See what is planned for the next days: ```text status director ``` The `Scheduled Jobs` section lists `backup-local` and `backup-web1` with their next level and time. The default configuration also includes a `BackupCatalog` job that dumps the catalog database after the nightly jobs; keep it, because without the catalog restores are far more work. Review past jobs any time with `list jobs` or, for failures only, `list jobs jobstatus=f`. ## Troubleshooting **`Authorization key rejected` or `Director authorization problem`.** A name or password does not match. The Director name in each daemon's `Director` block must equal the `Name` in `bacula-dir.conf`, and each password in `conf.d/local.conf` must equal the one in that daemon's `Director` block. **`Could not connect to Storage daemon on 10.0.0.10:9103`.** The client cannot reach the Storage Daemon. Check `SDAddress` in `bacula-sd.conf`, that `bacula-sd` listens on the private IP (`sudo ss -tlnp | grep 9103`) and the UFW rule for the client. **The job waits with `Cannot find any appendable volumes`.** The pool is full: all volumes are in use and none has passed its retention. Increase `Maximum Volumes`, or lower the retention. After changing a Pool resource, run `update pool=DiskPool` in `bconsole` so existing catalog records pick up the new values. Director messages are also written to `/var/log/bacula/bacula.log`, and each daemon logs to the journal (`sudo journalctl -u bacula-director`). ## Conclusion You now have a Bacula backup server on Ubuntu 24.04 with a PostgreSQL catalog, disk-based volumes that are labeled and recycled automatically, nightly full, differential and incremental backups of the server and a remote client, and a tested restore. As next steps, copy the volumes off site with a `Copy` job to a second Storage Daemon or object storage, enable TLS between the daemons, and add a client for each remaining server with its own `Client` and `Job` resources.