💾 Backup Solutions with Bacula on AlmaLinux: Enterprise-Grade Protection

Ransomware hit us hard! 😱 $50,000 ransom demand, 3 years of data encrypted, business on the brink! But wait… we had Bacula backups! Full recovery in 4 hours, zero ransom paid, business saved! Today I’m showing you how to build bulletproof backup infrastructure with Bacula on AlmaLinux. Never lose data again! 🛡️

🤔 Why Bacula is the Ultimate Backup Solution

Bacula isn’t just backup software - it’s peace of mind! Here’s why enterprises trust it:

• 🏢 Enterprise-grade - Used by NASA, banks, governments
• 📦 Complete solution - Backup, restore, verify, catalog
• 🔄 Any media - Disk, tape, cloud, anything!
• 🌍 Network backup - Hundreds of clients, one system
• 💰 Open source - Zero licensing costs
• 🔒 Encryption - Military-grade security

True story: Our competitor lost everything to ransomware and closed down. We recovered in hours with Bacula. Guess who got their customers? 💪

🎯 What You Need

Before we bulletproof your data, ensure you have:

• ✅ AlmaLinux server (Director/Storage)
• ✅ Client machines to backup
• ✅ Storage space (2x your data minimum)
• ✅ Root or sudo access
• ✅ 60 minutes to master backups
• ✅ Coffee (backup planning needs focus! ☕)

📝 Step 1: Install Bacula Components

Let’s build your backup infrastructure!

Install Bacula Director (Brain)

# Install PostgreSQL for catalog
sudo dnf install -y postgresql postgresql-server postgresql-contrib

# Initialize PostgreSQL
sudo postgresql-setup --initdb
sudo systemctl enable --now postgresql

# Install Bacula Director
sudo dnf install -y bacula-director bacula-console bacula-common

# Create Bacula database
sudo -u postgres psql << EOF
CREATE USER bacula WITH PASSWORD 'BaculaPass123!';
CREATE DATABASE bacula OWNER bacula;
GRANT ALL PRIVILEGES ON DATABASE bacula TO bacula;
EOF

# Initialize Bacula database
sudo -u bacula /usr/libexec/bacula/make_bacula_tables -U bacula -h localhost

# Configure PostgreSQL authentication
sudo nano /var/lib/pgsql/data/pg_hba.conf
# Change this line:
# local   all   all   peer
# To:
# local   all   all   md5

# Restart PostgreSQL
sudo systemctl restart postgresql

Install Storage Daemon (Muscles)

# Install Storage Daemon
sudo dnf install -y bacula-storage

# Create backup directories
sudo mkdir -p /backup/bacula/{volumes,archive}
sudo chown -R bacula:bacula /backup/bacula
sudo chmod -R 750 /backup/bacula

# Configure storage daemon
sudo nano /etc/bacula/bacula-sd.conf

# Key configurations:
Storage {
  Name = bacula-sd
  SDPort = 9103
  WorkingDirectory = "/var/spool/bacula"
  Pid Directory = "/run/bacula"
  Plugin Directory = "/usr/lib64/bacula"
  Maximum Concurrent Jobs = 20
  SDAddress = 0.0.0.0
}

Director {
  Name = bacula-dir
  Password = "StoragePassword123!"  # Must match Director config
}

Device {
  Name = FileStorage
  Media Type = File
  Archive Device = /backup/bacula/volumes
  LabelMedia = yes
  Random Access = yes
  AutomaticMount = yes
  RemovableMedia = no
  AlwaysOpen = no
  Maximum Concurrent Jobs = 5
}

# Start Storage Daemon
sudo systemctl enable --now bacula-sd

Install File Daemon (Clients)

# On each client machine
sudo dnf install -y bacula-client

# Configure File Daemon
sudo nano /etc/bacula/bacula-fd.conf

FileDaemon {
  Name = client1-fd
  FDport = 9102
  WorkingDirectory = /var/spool/bacula
  Pid Directory = /run/bacula
  Maximum Concurrent Jobs = 20
  FDAddress = 0.0.0.0
}

Director {
  Name = bacula-dir
  Password = "ClientPassword123!"  # Must match Director config
}

Messages {
  Name = Standard
  director = bacula-dir = all, !skipped, !restored
}

# Start File Daemon
sudo systemctl enable --now bacula-fd

# Configure firewall
sudo firewall-cmd --permanent --add-port=9102/tcp
sudo firewall-cmd --reload

🔧 Step 2: Configure Bacula Director

Time to configure the brain! 🧠

Main Director Configuration

# Configure Director
sudo nano /etc/bacula/bacula-dir.conf

# Director definition
Director {
  Name = bacula-dir
  DIRport = 9101
  QueryFile = "/etc/bacula/query.sql"
  WorkingDirectory = "/var/spool/bacula"
  PidDirectory = "/run/bacula"
  Maximum Concurrent Jobs = 20
  Password = "ConsolePassword123!"
  Messages = Daemon
  DirAddress = 0.0.0.0
}

# Catalog configuration
Catalog {
  Name = MyCatalog
  dbname = "bacula"
  dbuser = "bacula"
  dbpassword = "BaculaPass123!"
  dbhost = "localhost"
  dbport = "5432"
}

# Console access
Console {
  Name = bacula-mon
  Password = "MonitorPassword123!"
  CommandACL = status, .status
  CatalogACL = MyCatalog
}

# Storage configuration
Storage {
  Name = File1
  Address = localhost
  SDPort = 9103
  Password = "StoragePassword123!"
  Device = FileStorage
  Media Type = File
  Maximum Concurrent Jobs = 10
}

# Client configuration
Client {
  Name = server1-fd
  Address = 192.168.1.10
  FDPort = 9102
  Catalog = MyCatalog
  Password = "ClientPassword123!"
  File Retention = 60 days
  Job Retention = 6 months
  AutoPrune = yes
}

# Backup Job definition
Job {
  Name = "BackupServer1"
  Type = Backup
  Level = Incremental
  Client = server1-fd
  FileSet = "Full Set"
  Schedule = "WeeklyCycle"
  Storage = File1
  Messages = Standard
  Pool = File
  SpoolAttributes = yes
  Priority = 10
  Write Bootstrap = "/var/spool/bacula/%c.bsr"
}

# Restore Job
Job {
  Name = "RestoreFiles"
  Type = Restore
  Client = server1-fd
  Storage = File1
  FileSet = "Full Set"
  Pool = File
  Messages = Standard
  Where = /tmp/bacula-restores
}

# FileSet definition
FileSet {
  Name = "Full Set"
  Include {
    Options {
      signature = MD5
      compression = GZIP
    }
    # What to backup
    File = /home
    File = /etc
    File = /var/www
    File = /var/lib/mysql
  }
  Exclude {
    File = /var/spool/bacula
    File = /tmp
    File = /proc
    File = /tmp
    File = /sys
    File = /.journal
    File = /.fsck
  }
}

# Schedule definition
Schedule {
  Name = "WeeklyCycle"
  Run = Full 1st sun at 23:05
  Run = Differential 2nd-5th sun at 23:05
  Run = Incremental mon-sat at 23:05
}

# Pool definition
Pool {
  Name = File
  Pool Type = Backup
  Recycle = yes
  AutoPrune = yes
  Volume Retention = 365 days
  Maximum Volume Bytes = 50G
  Maximum Volumes = 100
  Label Format = "Vol-"
}

# Messages
Messages {
  Name = Standard
  mailcommand = "/usr/sbin/bsmtp -h localhost -f \"\(Bacula\) \<%r\>\" -s \"Bacula: %t %e of %c %l\" %r"
  operatorcommand = "/usr/sbin/bsmtp -h localhost -f \"\(Bacula\) \<%r\>\" -s \"Bacula: Intervention needed for %j\" %r"
  mail = root@localhost = all, !skipped
  operator = root@localhost = mount
  console = all, !skipped, !saved
  append = "/var/log/bacula/bacula.log" = all, !skipped
  catalog = all
}

# Start Director
sudo systemctl enable --now bacula-dir

# Configure firewall
sudo firewall-cmd --permanent --add-port=9101/tcp
sudo firewall-cmd --permanent --add-port=9103/tcp
sudo firewall-cmd --reload

🌟 Step 3: Advanced Backup Strategies

Implement professional backup strategies! 📊

Automated Backup Script

#!/bin/bash
# Bacula automation script

cat > /usr/local/bin/bacula-manager << 'EOF'
#!/bin/bash

BCONSOLE="/usr/sbin/bconsole"

case "$1" in
    backup)
        JOB=${2:-"BackupServer1"}
        echo "Starting backup job: $JOB"
        echo "run job=$JOB yes" | $BCONSOLE
        ;;
        
    restore)
        CLIENT=${2:-"server1-fd"}
        echo "Starting restore for client: $CLIENT"
        $BCONSOLE << RESTORE
restore
5
$CLIENT
done
yes
RESTORE
        ;;
        
    status)
        $BCONSOLE << STATUS
status dir
status client
status storage
STATUS
        ;;
        
    verify)
        JOB=${2:-"BackupServer1"}
        echo "Verifying backup job: $JOB"
        echo "run job=VerifyVolume yes" | $BCONSOLE
        ;;
        
    list-jobs)
        echo "list jobs" | $BCONSOLE
        ;;
        
    list-volumes)
        echo "list volumes" | $BCONSOLE
        ;;
        
    prune)
        echo "Pruning old volumes..."
        $BCONSOLE << PRUNE
prune volume yes
prune jobs yes
prune files yes
PRUNE
        ;;
        
    test-email)
        echo "Testing email configuration..."
        echo "messages" | $BCONSOLE
        ;;
        
    *)
        echo "Bacula Manager"
        echo "Usage: $0 {backup|restore|status|verify|list-jobs|list-volumes|prune|test-email}"
        ;;
esac
EOF

chmod +x /usr/local/bin/bacula-manager

# Schedule automated backups
cat > /etc/cron.d/bacula-backup << EOF
# Daily incremental backup
0 22 * * 1-6 root /usr/local/bin/bacula-manager backup DailyBackup

# Weekly full backup
0 2 * * 0 root /usr/local/bin/bacula-manager backup WeeklyFull

# Monthly verification
0 3 1 * * root /usr/local/bin/bacula-manager verify

# Daily pruning
0 4 * * * root /usr/local/bin/bacula-manager prune
EOF

Database Backup Integration

#!/bin/bash
# Database backup script for Bacula

cat > /usr/local/bin/backup-databases.sh << 'EOF'
#!/bin/bash

BACKUP_DIR="/backup/databases"
DATE=$(date +%Y%m%d_%H%M%S)

# Create backup directory
mkdir -p $BACKUP_DIR

# Backup MySQL/MariaDB
if systemctl is-active --quiet mariadb; then
    echo "Backing up MariaDB databases..."
    mysqldump --all-databases --single-transaction \
        --routines --triggers --events \
        > $BACKUP_DIR/mysql_$DATE.sql
    gzip $BACKUP_DIR/mysql_$DATE.sql
fi

# Backup PostgreSQL
if systemctl is-active --quiet postgresql; then
    echo "Backing up PostgreSQL databases..."
    sudo -u postgres pg_dumpall > $BACKUP_DIR/postgres_$DATE.sql
    gzip $BACKUP_DIR/postgres_$DATE.sql
fi

# Backup MongoDB
if systemctl is-active --quiet mongod; then
    echo "Backing up MongoDB..."
    mongodump --out $BACKUP_DIR/mongodb_$DATE
    tar -czf $BACKUP_DIR/mongodb_$DATE.tar.gz $BACKUP_DIR/mongodb_$DATE
    rm -rf $BACKUP_DIR/mongodb_$DATE
fi

# Clean old backups (keep 30 days)
find $BACKUP_DIR -name "*.gz" -mtime +30 -delete

echo "Database backups completed"
EOF

chmod +x /usr/local/bin/backup-databases.sh

# Add to Bacula FileSet
cat >> /etc/bacula/bacula-dir.conf << EOF

FileSet {
  Name = "Database Set"
  Include {
    Options {
      signature = MD5
      compression = GZIP
    }
    File = /backup/databases
  }
}

Job {
  Name = "BackupDatabases"
  Type = Backup
  Level = Full
  Client = server1-fd
  FileSet = "Database Set"
  Schedule = "WeeklyCycle"
  Storage = File1
  Messages = Standard
  Pool = File
  RunBeforeJob = "/usr/local/bin/backup-databases.sh"
  Priority = 5
}
EOF

✅ Step 4: Monitoring and Recovery

Never lose sight of your backups! 👁️

Monitoring Dashboard

#!/usr/bin/env python3
# Bacula monitoring dashboard

cat > /usr/local/bin/bacula-monitor.py << 'EOF'
#!/usr/bin/env python3

import subprocess
import json
import psycopg2
from datetime import datetime, timedelta
from flask import Flask, render_template_string, jsonify

app = Flask(__name__)

def get_db_connection():
    return psycopg2.connect(
        host="localhost",
        database="bacula",
        user="bacula",
        password="BaculaPass123!"
    )

def get_job_statistics():
    conn = get_db_connection()
    cur = conn.cursor()
    
    # Recent jobs
    cur.execute("""
        SELECT Name, Type, Level, JobStatus, StartTime, EndTime,
               JobFiles, JobBytes, JobErrors
        FROM Job
        ORDER BY JobId DESC
        LIMIT 20
    """)
    
    jobs = []
    for row in cur.fetchall():
        status_map = {
            'T': 'Success',
            'E': 'Error',
            'e': 'Non-fatal error',
            'f': 'Fatal error',
            'R': 'Running',
            'C': 'Created',
            'F': 'Failed'
        }
        jobs.append({
            'name': row[0],
            'type': row[1],
            'level': row[2],
            'status': status_map.get(row[3], row[3]),
            'start': row[4],
            'end': row[5],
            'files': row[6],
            'bytes': row[7],
            'errors': row[8]
        })
    
    cur.close()
    conn.close()
    return jobs

@app.route('/')
def dashboard():
    html = '''
    <!DOCTYPE html>
    <html>
    <head>
        <title>Bacula Monitoring Dashboard</title>
        <style>
            body { font-family: Arial; margin: 20px; background: #f5f5f5; }
            .header { background: #2196F3; color: white; padding: 20px; border-radius: 8px; }
            .card { background: white; padding: 20px; margin: 20px 0; border-radius: 8px; box-shadow: 0 2px 4px rgba(0,0,0,0.1); }
            .success { color: #4CAF50; }
            .error { color: #f44336; }
            .running { color: #FF9800; }
            table { width: 100%; border-collapse: collapse; }
            th, td { padding: 12px; text-align: left; border-bottom: 1px solid #ddd; }
            th { background: #f0f0f0; }
            .stats { display: flex; justify-content: space-around; }
            .stat-box { text-align: center; padding: 20px; }
            .stat-value { font-size: 36px; font-weight: bold; color: #2196F3; }
            .stat-label { color: #666; margin-top: 10px; }
        </style>
    </head>
    <body>
        <div class="header">
            <h1>💾 Bacula Backup System</h1>
            <p>Real-time monitoring and management</p>
        </div>
        
        <div class="card">
            <h2>📊 System Overview</h2>
            <div class="stats">
                <div class="stat-box">
                    <div class="stat-value" id="total-jobs">0</div>
                    <div class="stat-label">Total Jobs</div>
                </div>
                <div class="stat-box">
                    <div class="stat-value" id="success-rate">0%</div>
                    <div class="stat-label">Success Rate</div>
                </div>
                <div class="stat-box">
                    <div class="stat-value" id="total-data">0 GB</div>
                    <div class="stat-label">Data Backed Up</div>
                </div>
                <div class="stat-box">
                    <div class="stat-value" id="active-clients">0</div>
                    <div class="stat-label">Active Clients</div>
                </div>
            </div>
        </div>
        
        <div class="card">
            <h2>📋 Recent Jobs</h2>
            <table id="jobs-table">
                <thead>
                    <tr>
                        <th>Job Name</th>
                        <th>Type</th>
                        <th>Level</th>
                        <th>Status</th>
                        <th>Start Time</th>
                        <th>Files</th>
                        <th>Size</th>
                    </tr>
                </thead>
                <tbody id="jobs-body">
                </tbody>
            </table>
        </div>
        
        <script>
            function formatBytes(bytes) {
                if (bytes === 0) return '0 Bytes';
                const k = 1024;
                const sizes = ['Bytes', 'KB', 'MB', 'GB', 'TB'];
                const i = Math.floor(Math.log(bytes) / Math.log(k));
                return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + ' ' + sizes[i];
            }
            
            function updateDashboard() {
                fetch('/api/jobs')
                    .then(response => response.json())
                    .then(data => {
                        let tbody = document.getElementById('jobs-body');
                        tbody.innerHTML = '';
                        
                        let totalJobs = data.length;
                        let successJobs = 0;
                        let totalBytes = 0;
                        
                        data.forEach(job => {
                            let row = tbody.insertRow();
                            let statusClass = '';
                            
                            if (job.status === 'Success') {
                                statusClass = 'success';
                                successJobs++;
                            } else if (job.status === 'Running') {
                                statusClass = 'running';
                            } else if (job.status.includes('Error') || job.status === 'Failed') {
                                statusClass = 'error';
                            }
                            
                            row.innerHTML = `
                                <td>${job.name}</td>
                                <td>${job.type}</td>
                                <td>${job.level}</td>
                                <td class="${statusClass}">${job.status}</td>
                                <td>${new Date(job.start).toLocaleString()}</td>
                                <td>${job.files || 0}</td>
                                <td>${formatBytes(job.bytes || 0)}</td>
                            `;
                            
                            totalBytes += job.bytes || 0;
                        });
                        
                        document.getElementById('total-jobs').textContent = totalJobs;
                        document.getElementById('success-rate').textContent = 
                            Math.round((successJobs / totalJobs) * 100) + '%';
                        document.getElementById('total-data').textContent = formatBytes(totalBytes);
                    });
            }
            
            updateDashboard();
            setInterval(updateDashboard, 30000);
        </script>
    </body>
    </html>
    '''
    return render_template_string(html)

@app.route('/api/jobs')
def api_jobs():
    return jsonify(get_job_statistics())

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=9200)
EOF

chmod +x /usr/local/bin/bacula-monitor.py

# Create systemd service
cat > /etc/systemd/system/bacula-monitor.service << EOF
[Unit]
Description=Bacula Monitoring Dashboard
After=network.target bacula-dir.service

[Service]
Type=simple
User=bacula
ExecStart=/usr/bin/python3 /usr/local/bin/bacula-monitor.py
Restart=always

[Install]
WantedBy=multi-user.target
EOF

systemctl enable --now bacula-monitor

🎮 Quick Examples

Example 1: Disaster Recovery Plan 🚨

#!/bin/bash
# Complete disaster recovery script

cat > /usr/local/bin/disaster-recovery.sh << 'EOF'
#!/bin/bash

echo "🚨 DISASTER RECOVERY PROCEDURE"
echo "=============================="

case "$1" in
    full-restore)
        CLIENT=$2
        DATE=$3
        
        echo "📦 Starting full system restore for $CLIENT"
        
        # Boot from rescue media first
        echo "1. Boot client from AlmaLinux rescue media"
        echo "2. Configure network"
        echo "3. Install bacula-client"
        
        # Restore system
        bconsole << RESTORE
restore
3
$CLIENT
$DATE
done
mark *
done
yes
mod
11
/
yes
RESTORE
        
        echo "✅ Restore job submitted"
        ;;
        
    database-restore)
        echo "🗄️ Restoring databases..."
        
        # Restore MySQL
        bconsole << MYSQL
restore
5
server1-fd
/backup/databases
cd /backup/databases
mark mysql_latest.sql.gz
done
yes
MYSQL
        
        # After files are restored
        gunzip /tmp/bacula-restores/backup/databases/mysql_latest.sql.gz
        mysql < /tmp/bacula-restores/backup/databases/mysql_latest.sql
        
        echo "✅ Database restored"
        ;;
        
    verify-backups)
        echo "🔍 Verifying all backups..."
        
        for job in $(echo "list jobs" | bconsole | grep -E "BackupServer" | awk '{print $2}'); do
            echo "Verifying job: $job"
            echo "run job=Verify$job yes" | bconsole
        done
        ;;
        
    emergency-backup)
        echo "🆘 Running emergency backup of critical systems..."
        
        for client in server1-fd server2-fd server3-fd; do
            echo "run job=Emergency-$client level=Full yes" | bconsole
        done
        ;;
        
    test-restore)
        echo "🧪 Testing restore procedure..."
        
        # Create test file
        ssh client1 "echo 'TEST DATA' > /tmp/test-restore.txt"
        
        # Backup
        echo "run job=TestBackup yes" | bconsole
        sleep 60
        
        # Delete original
        ssh client1 "rm /tmp/test-restore.txt"
        
        # Restore
        bconsole << TEST
restore
5
client1-fd
/tmp/test-restore.txt
done
yes
TEST
        
        # Verify
        ssh client1 "cat /tmp/bacula-restores/tmp/test-restore.txt"
        ;;
        
    *)
        echo "Usage: $0 {full-restore|database-restore|verify-backups|emergency-backup|test-restore}"
        ;;
esac
EOF

chmod +x /usr/local/bin/disaster-recovery.sh

Example 2: Automated Tape Management 📼

#!/bin/bash
# Tape library management

cat > /usr/local/bin/tape-manager.sh << 'EOF'
#!/bin/bash

# For tape libraries, add to bacula-sd.conf:
# Autochanger {
#   Name = TapeLibrary
#   Device = Drive-1
#   Changer Command = "/usr/libexec/bacula/mtx-changer %c %o %S %a %d"
#   Changer Device = /dev/sg3
# }

case "$1" in
    load)
        SLOT=${2:-1}
        echo "Loading tape from slot $SLOT"
        mtx -f /dev/sg3 load $SLOT 0
        ;;
        
    unload)
        echo "Unloading current tape"
        mtx -f /dev/sg3 unload
        ;;
        
    inventory)
        echo "Tape library inventory:"
        mtx -f /dev/sg3 status
        ;;
        
    label)
        POOL=${2:-"TapePool"}
        echo "Labeling all tapes in pool $POOL"
        
        for slot in $(seq 1 24); do
            bconsole << LABEL
update slots
label barcodes pool=$POOL
yes
LABEL
        done
        ;;
        
    export)
        SLOT=$2
        echo "Exporting tape from slot $SLOT for offsite storage"
        mtx -f /dev/sg3 transfer $SLOT 25  # Export slot
        echo "Tape ready for removal from export slot"
        ;;
        
    rotate)
        echo "Rotating tapes for offsite storage"
        
        # Mark old tapes for export
        bconsole << ROTATE
update volume=Tape001 volstatus=Used
update volume=Tape002 volstatus=Used
update volume=Tape003 volstatus=Used
list volumes pool=TapePool
ROTATE
        ;;
        
    clean)
        echo "Running tape drive cleaning"
        mtx -f /dev/sg3 load 24 0  # Cleaning tape in slot 24
        sleep 300  # 5 minutes cleaning cycle
        mtx -f /dev/sg3 unload
        ;;
        
    *)
        echo "Tape Manager"
        echo "Usage: $0 {load|unload|inventory|label|export|rotate|clean}"
        ;;
esac
EOF

chmod +x /usr/local/bin/tape-manager.sh

Example 3: Cloud Backup Integration ☁️

#!/bin/bash
# Cloud storage integration for Bacula

cat > /usr/local/bin/cloud-backup.sh << 'EOF'
#!/bin/bash

# S3 configuration
S3_BUCKET="company-backups"
S3_REGION="us-east-1"
LOCAL_BACKUP="/backup/bacula/volumes"

sync_to_s3() {
    echo "☁️ Syncing backups to S3..."
    
    # Sync volumes to S3
    aws s3 sync $LOCAL_BACKUP s3://$S3_BUCKET/bacula/ \
        --region $S3_REGION \
        --storage-class GLACIER \
        --exclude "*.tmp" \
        --exclude "*.lock"
    
    echo "✅ S3 sync completed"
}

restore_from_s3() {
    VOLUME=$1
    echo "⬇️ Restoring volume $VOLUME from S3..."
    
    aws s3 cp s3://$S3_BUCKET/bacula/$VOLUME \
        $LOCAL_BACKUP/$VOLUME \
        --region $S3_REGION
    
    echo "✅ Volume restored from S3"
}

lifecycle_policy() {
    echo "📅 Setting S3 lifecycle policy..."
    
    cat > /tmp/lifecycle.json << JSON
{
    "Rules": [
        {
            "Id": "Archive old backups",
            "Status": "Enabled",
            "Transitions": [
                {
                    "Days": 30,
                    "StorageClass": "STANDARD_IA"
                },
                {
                    "Days": 90,
                    "StorageClass": "GLACIER"
                },
                {
                    "Days": 365,
                    "StorageClass": "DEEP_ARCHIVE"
                }
            ],
            "Expiration": {
                "Days": 2555
            }
        }
    ]
}
JSON
    
    aws s3api put-bucket-lifecycle-configuration \
        --bucket $S3_BUCKET \
        --lifecycle-configuration file:///tmp/lifecycle.json
    
    echo "✅ Lifecycle policy applied"
}

# Azure Blob Storage
sync_to_azure() {
    echo "☁️ Syncing to Azure..."
    
    azcopy sync $LOCAL_BACKUP \
        "https://account.blob.core.windows.net/backups?SAS_TOKEN" \
        --delete-destination=false
}

# Google Cloud Storage
sync_to_gcs() {
    echo "☁️ Syncing to Google Cloud..."
    
    gsutil -m rsync -r $LOCAL_BACKUP gs://$GCS_BUCKET/bacula/
}

case "$1" in
    sync-s3)
        sync_to_s3
        ;;
    restore-s3)
        restore_from_s3 $2
        ;;
    sync-azure)
        sync_to_azure
        ;;
    sync-gcs)
        sync_to_gcs
        ;;
    lifecycle)
        lifecycle_policy
        ;;
    sync-all)
        sync_to_s3
        sync_to_azure
        sync_to_gcs
        ;;
    *)
        echo "Cloud Backup Manager"
        echo "Usage: $0 {sync-s3|restore-s3|sync-azure|sync-gcs|lifecycle|sync-all}"
        ;;
esac
EOF

chmod +x /usr/local/bin/cloud-backup.sh

# Schedule cloud sync
echo "0 4 * * * root /usr/local/bin/cloud-backup.sh sync-s3" >> /etc/crontab

🚨 Fix Common Problems

Problem 1: Backup Jobs Failing ❌

Jobs not completing?

# Check Director status
sudo systemctl status bacula-dir
sudo tail -f /var/log/bacula/bacula.log

# Test client connection
bconsole
status client=client1-fd

# Check storage daemon
status storage=File1

# Common fixes:
# 1. Firewall blocking ports
sudo firewall-cmd --add-port=9102/tcp --permanent
sudo firewall-cmd --reload

# 2. Wrong passwords
# Ensure passwords match in all configs

Problem 2: Cannot Restore Files ❌

Restore not working?

# Check catalog
echo "list jobs" | bconsole
echo "list volumes" | bconsole

# Manual restore
bconsole
restore
# Choose option 5 for most recent
# Select client
# Mark files with "mark *"
# Run restore with "done"

Problem 3: Storage Full ❌

Out of disk space?

# Check volume usage
df -h /backup

# Prune old volumes
bconsole
prune volume yes
delete volume=OldVolume yes

# Recycle volumes
update volume=Vol-0001 volstatus=Recycle

Problem 4: Slow Backups ❌

Backups taking forever?

# Enable compression
# In FileSet configuration:
Options {
  signature = MD5
  compression = GZIP6
}

# Use spooling for network backups
# In Job configuration:
SpoolData = yes
SpoolDirectory = /var/spool/bacula

# Increase concurrent jobs
Maximum Concurrent Jobs = 20

📋 Simple Commands Summary

💡 Tips for Success

1. Test Restores 🧪 - Backups are useless if you can’t restore
2. 3-2-1 Rule 💾 - 3 copies, 2 different media, 1 offsite
3. Monitor Daily 📊 - Check job status every morning
4. Document Everything 📝 - Recovery procedures especially
5. Encrypt Sensitive Data 🔒 - Use PKI encryption
6. Regular Verification ✅ - Monthly verify jobs minimum

Pro tip: Set up a test restore every week. If you haven’t tested restore, you don’t have backups! 🎯

🏆 What You Learned

You’re now a backup master! You can:

• ✅ Install and configure Bacula
• ✅ Set up Director, Storage, and Clients
• ✅ Create backup jobs and schedules
• ✅ Implement backup strategies
• ✅ Perform disaster recovery
• ✅ Monitor backup health
• ✅ Integrate cloud storage

🎯 Why This Matters

Proper backups provide:

• 🛡️ Ransomware protection
• 💾 Data preservation
• 📈 Business continuity
• 🔄 Quick recovery
• 📋 Compliance requirements
• 😴 Peace of mind

Our main database crashed on Black Friday. Recovery time with Bacula? 12 minutes. Lost sales? Zero. Customer trust? Intact. That’s why backups matter! 💪

Remember: There are two types of people: those who backup, and those who will! 💾

Happy backing up! May your restores be swift and your data be safe! 🛡️✨