DEV Community

Chandrashekhar Kachawa
Chandrashekhar Kachawa

Posted on • Originally published at ctrix.pro

A Practical Guide to Backing Up Your Linux Server: PostgreSQL, Jenkins, and More

#sql #backup #ubuntu #beginners

As developers and system administrators, we build and manage services that are critical to our applications. But what happens when disaster strikes? A hardware failure, a software bug, or even human error can lead to catastrophic data loss. This is where a robust backup strategy isn't just a good idea—it's a necessity.

This guide provides a practical, hands-on approach to backing up some of the most common and critical services running on a Linux server: PostgreSQL databases, Jenkins automation servers, and other essential system files.

1. Backing Up Your PostgreSQL Database

Your database is often the most critical component of your application stack. pg_dump is the standard, powerful utility for creating consistent backups of a PostgreSQL database.

On the Server: Creating the Backup

The pg_dump command connects to your database and writes its contents to a file. You can run this directly from your server's command line.

A basic command looks like this:

pg_dump -U your_user -d your_db -f backup.sql
Enter fullscreen mode Exit fullscreen mode
  • -U your_user: The PostgreSQL user to connect as.
  • -d your_db: The name of the database to back up.
  • -f backup.sql: The output file for the backup.

For more flexibility during restoration, it's highly recommended to use the custom format (-F c):

pg_dump -U your_user -d your_db -F c -f backup.dump
Enter fullscreen mode Exit fullscreen mode

This format is compressed and allows for more advanced restoration options with the pg_restore utility, such as reordering or restoring specific objects.

Downloading the Backup to Your Local PC

Once you have the backup file on your server, you need a secure way to download it to your local machine. The scp (Secure Copy) command is perfect for this, as it transfers files over an encrypted SSH connection.

scp user@your_server_ip:/path/to/backup.dump .
Enter fullscreen mode Exit fullscreen mode
  • user@your_server_ip: Your username and the IP address of your server.
  • /path/to/backup.dump: The full path to the backup file on the server.
  • .: The destination on your local machine (the current directory).

Pro Tip: Using a Specific SSH Key

If your server requires a specific SSH key for authentication, you can provide it using the -i (identity file) flag. Remember to ensure your key file has secure permissions (chmod 600 /path/to/key).

scp -i /path/to/your/private_key user@your_server_ip:/path/to/backup.dump .

For an even cleaner workflow, consider adding an entry to your SSH config file (~/.ssh/config):

Host my-prod-server
    HostName your_server_ip
    User user
    IdentityFile /path/to/your/private_key

With this config, your command simplifies to scp my-prod-server:/path/to/backup.dump ..

2. Backing Up Your Jenkins Server

Jenkins stores all its data—including job configurations, build history, plugins, and system settings—in a single directory known as JENKINS_HOME. Backing up Jenkins is as simple as creating an archive of this directory.

First, find your JENKINS_HOME directory. On most Linux systems, it's located at /var/lib/jenkins.

You can use the tar utility to create a compressed archive:

tar -czvf jenkins_backup_$(date +%F).tar.gz /var/lib/jenkins
Enter fullscreen mode Exit fullscreen mode
  • -c: Create a new archive.
  • -z: Compress the archive with gzip.
  • -v: Verbosely list the files processed.
  • -f: Specifies the output archive file.
  • $(date +%F): This handy command substitution appends the current date (YYYY-MM-DD) to the filename.

Just like with the database backup, you can use scp to download this jenkins_backup.tar.gz file to your local machine.

3. Backing Up Essential System Files

Beyond specific services, your server has other critical files, especially in /etc (system-wide configurations) and /home (user data). You can use tar to back these up as well.

tar -czvf system_backup_$(date +%F).tar.gz /etc /home /var/www
Enter fullscreen mode Exit fullscreen mode

This command archives the configuration directory, all user home directories, and a common web root directory (/var/www).

4. Automating Your Backups with Cron

Manual backups are better than no backups, but automated backups are what give you true peace of mind. On Linux, the cron daemon is the standard way to schedule recurring tasks.

First, create a simple shell script to perform the backups.

backup_script.sh

#!/bin/bash

# Set backup directory
BACKUP_DIR="/opt/backups"
mkdir -p $BACKUP_DIR

# Timestamp
TIMESTAMP=$(date +%F)

# Backup PostgreSQL
pg_dump -U your_user -d your_db -F c -f $BACKUP_DIR/db_backup_$TIMESTAMP.dump

# Backup Jenkins
tar -czf $BACKUP_DIR/jenkins_backup_$TIMESTAMP.tar.gz /var/lib/jenkins

# Backup system files
tar -czf $BACKUP_DIR/system_backup_$TIMESTAMP.tar.gz /etc /home
Enter fullscreen mode Exit fullscreen mode

Make the script executable: chmod +x backup_script.sh.

Now, open your crontab to edit it:

crontab -e
Enter fullscreen mode Exit fullscreen mode

Add a line to schedule the script. For example, to run it every day at 2:00 AM:

0 2 * * * /path/to/your/backup_script.sh
Enter fullscreen mode Exit fullscreen mode

Conclusion

Regularly backing up your services is one of the most important responsibilities of managing a server. With tools like pg_dump, tar, scp, and cron, you can create a powerful, automated, and secure backup strategy.

But remember the golden rule: a backup is worthless until you have successfully tested a restoration. Periodically practice restoring your backups to a staging environment to ensure they work when you need them most.

Top comments (0)