Backup Configuration Files Using Git: A Practical Solution for Linux Server Administrators

As a developer, I’m quite familiar with Git and its many benefits for version control. When I encountered the need to back up configuration files for several Linux servers I’m administrating, I decided to leverage Git for this purpose. After all, Git is an excellent tool for tracking changes and ensuring that you have a reliable history of configuration file updates.

❓ Why Not Use etckeeper?

There are several ways to use Git for backing up configuration files, and one common approach is to use a Git repository directly in the /etc directory, like the tool etckeeper does. While this method is popular and convenient, it comes with some significant drawbacks:

• Full /etc Backup: The entire /etc directory is tracked, which means that files not relevant to configuration management will also be included in the repository.
• Not All Config Files Are in /etc: Many services store their configuration files in directories outside /etc (e.g., /opt or /usr/local).
• Risk of Overwriting: Running git pull from an upstream repository could potentially overwrite your live configuration files, introducing incorrect or outdated settings.

---

🔧 My Solution: A More Flexible Approach

To address these issues, I decided to create a custom script that allows me to back up only specific configuration files or directories. Instead of storing the entire /etc directory in a Git repository, I created a solution where I specify the files to back up in a separate configuration file. These files are then copied to a temporary directory that contains the Git repository, which is backed up independently.

This solution has several benefits:

• Selective Backups: Only the specified configuration files or directories are backed up, keeping the repository clean and focused on the relevant files.
• Flexibility: You can back up configuration files from any location on the file system, not just /etc.
• No Risk of Overwriting: Since git pull only affects files tracked in the Git repository, there is no risk of accidentally overwriting important configuration files.

---

⚙️ How It Works

To implement this solution, you’ll need a script and a configuration file (config_files.txt) that contains a list of the configuration files and directories to back up. The script will clean up the temporary backup directory, copy the relevant configuration files into it, and manage the Git repository.

Here’s the shell script to automate the process:

#!/bin/bash

# Clean up the temporary backup directory by removing any existing files
find . -maxdepth 1 -mindepth 1 ! -regex "./\(config_files.txt\|.git\|copy.sh\)" | xargs rm -r

# Copy the specified files and directories from config_files.txt into the backup folder
cat config_files.txt | xargs -I {} cp --parents -R {} .

---

📝 Step-by-Step Guide to Set Up Your Backup

To set up the backup system for your configuration files, follow these steps:

📂 1. Create the Temporary Backup Directory

First, create the directory where your configuration files will be stored:

$ mkdir -p /backup/conf

🖥️ 2. Initialize a Git Repository

Navigate to the newly created directory and initialize a Git repository. You’ll also need to set up a remote Git repository to push the backup.

$ cd /backup/conf
$ git init
$ git remote add origin <path-to-your-git-repository>

🗂️ 3. Create config_files.txt

Create a file named config_files.txt inside the /backup/conf directory. This file will list all the configuration files and directories you want to back up. Each path should be relative to the root of the file system. For example:

/etc/nginx/nginx.conf
/etc/nginx/conf.d/

This configuration file is where you specify all the files and directories to back up.

🏃‍♂️ 4. Run the Backup Script

Execute the copy_conf.sh script to copy the specified configuration files into the temporary backup directory:

$ /backup/conf $ ./copy_conf.sh

The script will clean up the temporary directory and copy all the relevant configuration files into the backup folder.

✔️ 5. Check for Changes

Before committing the changes, you can check the status of your Git repository to see if any files have been modified since your last commit:

$ git status
On branch master
Initial commit

Untracked files:
(use "git add <file>..." to include in what will be committed)

    config_files.txt
    etc/

nothing added to commit but untracked files present (use "git add" to track)

✅ 6. Commit and Push Your Backup

Once you’ve verified that the files have been copied correctly, you can commit the changes to the Git repository and push them to your remote server:

$ git add .
$ git commit -m "Backup configuration files"
$ git push

This will ensure that your backup is safely stored in your Git repository.

---

🔒 Additional Tips and Best Practices

• Automate the Backup Process: If you want to automate the backup process, consider setting up a cron job that runs the script at regular intervals. This way, your configuration files will be backed up automatically without manual intervention.

  Example cron job (backups every day at midnight):

  0 0 * * * /backup/conf/copy_conf.sh && cd /backup/conf && git add . && git commit -m "Daily config backup" && git push
  

• Use Git Branches: If you manage configurations for multiple servers or environments (e.g., production and staging), consider using Git branches to separate the configurations for each server. This can help avoid accidental overwrites and ensure that changes are tested before being deployed to production.

• Track Changes with Git: Git not only allows you to back up your configuration files but also provides powerful tools for tracking changes over time. You can use git diff to see what has changed between commits, git log to view the commit history, and git blame to see who made specific changes.

• Secure Your Backup Repository: Ensure that your Git repository, especially if it contains sensitive configuration data (e.g., passwords or API keys), is properly secured. Use private repositories, SSH keys for authentication, and ensure that only authorized personnel have access.

---

🧠 Final Thoughts

Using Git to back up your configuration files is a powerful and flexible approach to managing your Linux server configurations. By selectively backing up only the relevant files and directories, you reduce the risk of unnecessary data being stored, while still maintaining the benefits of version control. This approach also eliminates the potential issues that arise when using tools like etckeeper, such as accidental overwrites or pulling incorrect versions of configuration files.

With just a simple script and a few commands, you can ensure that your critical configuration files are regularly backed up and easily recoverable.