1
2
3
4

Sunday: Full Backup (100GB)
Monday: Incremental (5GB) - changes since Sunday
Tuesday: Incremental (3GB) - changes since Monday
Wednesday: Incremental (7GB) - changes since Tuesday

1
2
3
4

Sunday: Full Backup (100GB)
Monday: Differential (5GB) - changes since Sunday
Tuesday: Differential (8GB) - changes since Sunday
Wednesday: Differential (15GB) - changes since Sunday

1
2
3
4
5
6
7

# Acronis backup command example
acronis_backup create \
  --source /var/www/html \
  --destination /backup/web_backup \
  --compression high \
  --encryption AES256 \
  --schedule daily

1
2
3
4
5

Director: Central management daemon
Storage Daemon: Manages backup storage
File Daemon: Client backup agent
Catalog: Database for backup metadata
Console: Administrative interface

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Bacula Director configuration
Job {
  Name = "BackupClient1"
  Type = Backup
  Level = Incremental
  Client = client1-fd
  FileSet = "Full Set"
  Schedule = "WeeklyCycle"
  Storage = File
  Messages = Standard
  Pool = File
  Priority = 10
  Write Bootstrap = "/var/lib/bacula/%c.bsr"
}

1
2
3
4
5
6
7
8

# Ubuntu/Debian installation
apt-get update
apt-get install bacula-server bacula-client

# Configuration files
/etc/bacula/bacula-dir.conf    # Director configuration
/etc/bacula/bacula-sd.conf     # Storage daemon
/etc/bacula/bacula-fd.conf     # File daemon

1
2
3
4
5
6
7

# Duplicati command line
duplicati-cli backup \
  "s3://mybucket/backup?aws_access_key_id=KEY&aws_secret_access_key=SECRET" \
  /home/user/documents \
  --encryption-module=aes \
  --passphrase=mypassword \
  --compression-module=zip

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

{
  "BackupPlan": {
    "BackupPlanName": "DailyBackups",
    "Rules": [
      {
        "RuleName": "DailyRule",
        "TargetBackupVault": "default",
        "ScheduleExpression": "cron(0 2 ? * * *)",
        "Lifecycle": {
          "DeleteAfterDays": 30
        }
      }
    ]
  }
}

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# mysqldump - logical backup
mysqldump -u root -p \
  --single-transaction \
  --routines \
  --triggers \
  --all-databases > full_backup.sql

# Compressed backup
mysqldump -u root -p \
  --single-transaction \
  --all-databases | gzip > backup_$(date +%Y%m%d).sql.gz

# Incremental backup using binary logs
mysqlbinlog mysql-bin.000001 > incremental_backup.sql

1
2
3
4
5
6
7
8

# MySQL Enterprise Backup
mysqlbackup --user=root --password \
  --backup-dir=/backup/mysql \
  backup-and-apply-log

# Percona XtraBackup
xtrabackup --user=root --password=password \
  --backup --target-dir=/backup/mysql/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# pg_dump - single database
pg_dump -U postgres -h localhost \
  -f backup_$(date +%Y%m%d).sql database_name

# pg_dumpall - all databases
pg_dumpall -U postgres -h localhost \
  -f full_backup_$(date +%Y%m%d).sql

# Custom format backup
pg_dump -U postgres -Fc database_name > backup.dump

1
2
3
4
5
6
7
8

# Base backup
pg_basebackup -U postgres -D /backup/postgres \
  -Ft -z -P

# Continuous archiving
# postgresql.conf
archive_mode = on
archive_command = 'cp %p /backup/postgres/archive/%f'

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Full database backup
mongodump --host localhost:27017 \
  --out /backup/mongodb/$(date +%Y%m%d)

# Specific database backup
mongodump --host localhost:27017 \
  --db myapp --out /backup/mongodb/

# Compressed backup
mongodump --host localhost:27017 \
  --gzip --out /backup/mongodb/

1
2
3
4

# Backup from secondary
mongodump --host secondary.example.com:27017 \
  --readPreference=secondary \
  --out /backup/mongodb/

1
2
3
4
5
6
7
8
9

# Local backup
rsync -av --delete /source/ /backup/

# Remote backup
rsync -av --delete -e ssh /source/ user@backup-server:/backup/

# Incremental backup with hard links
rsync -av --delete --link-dest=/backup/previous \
  /source/ /backup/current/

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Backup script with rotation
#!/bin/bash
SOURCE="/var/www/html"
DEST="/backup/web"
DATE=$(date +%Y%m%d_%H%M%S)

# Create backup with hard links
rsync -av --delete --link-dest="$DEST/latest" \
  "$SOURCE/" "$DEST/$DATE/"

# Update latest symlink
rm -f "$DEST/latest"
ln -s "$DATE" "$DEST/latest"

# Keep only last 7 backups
cd "$DEST"
ls -t | tail -n +8 | xargs rm -rf

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# Full backup
tar -czf backup_$(date +%Y%m%d).tar.gz /var/www/html

# Incremental backup
tar -czf incremental_$(date +%Y%m%d).tar.gz \
  --newer-mtime="2025-12-19" /var/www/html

# Exclude files
tar -czf backup.tar.gz \
  --exclude='*.log' \
  --exclude='cache/*' \
  /var/www/html

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Create LVM snapshot
lvcreate -L 10G -s -n backup_snap /dev/vg0/data

# Mount snapshot
mkdir /mnt/backup_snap
mount /dev/vg0/backup_snap /mnt/backup_snap

# Backup from snapshot
tar -czf backup.tar.gz -C /mnt/backup_snap .

# Remove snapshot
umount /mnt/backup_snap
lvremove /dev/vg0/backup_snap

1
2
3
4
5
6
7
8
9

# Create ZFS snapshot
zfs snapshot tank/data@backup_$(date +%Y%m%d)

# List snapshots
zfs list -t snapshot

# Send snapshot to remote
zfs send tank/data@backup_20251220 | \
  ssh backup-server zfs receive backup/data

1
2
3
4
5
6
7
8
9

# /etc/cron.d/backup
# Daily database backup at 2 AM
0 2 * * * root /scripts/backup_database.sh

# Weekly full backup on Sunday at 1 AM
0 1 * * 0 root /scripts/backup_full.sh

# Hourly incremental backup
0 * * * * root /scripts/backup_incremental.sh

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29

#!/bin/bash
# backup_database.sh

# Configuration
DB_USER="backup_user"
DB_PASS="backup_password"
BACKUP_DIR="/backup/mysql"
DATE=$(date +%Y%m%d_%H%M%S)
RETENTION_DAYS=30

# Create backup directory
mkdir -p "$BACKUP_DIR"

# Database backup
mysqldump -u "$DB_USER" -p"$DB_PASS" \
  --single-transaction \
  --all-databases | gzip > "$BACKUP_DIR/backup_$DATE.sql.gz"

# Check backup success
if [ $? -eq 0 ]; then
    echo "Backup successful: backup_$DATE.sql.gz"
    
    # Remove old backups
    find "$BACKUP_DIR" -name "backup_*.sql.gz" \
      -mtime +$RETENTION_DAYS -delete
else
    echo "Backup failed!" >&2
    exit 1
fi

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# /etc/systemd/system/backup.service
[Unit]
Description=Database Backup Service
After=mysql.service

[Service]
Type=oneshot
ExecStart=/scripts/backup_database.sh
User=backup
Group=backup

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# /etc/systemd/system/backup.timer
[Unit]
Description=Run backup daily
Requires=backup.service

[Timer]
OnCalendar=daily
Persistent=true

[Install]
WantedBy=timers.target

1
2
3

systemctl enable backup.timer
systemctl start backup.timer
systemctl status backup.timer

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41

# backup-playbook.yml
---
- name: Automated Backup
  hosts: all
  become: yes
  vars:
    backup_dir: /backup
    retention_days: 30
  
  tasks:
    - name: Create backup directory
      file:
        path: "{{ backup_dir }}"
        state: directory
        mode: '0755'
    
    - name: Backup MySQL databases
      mysql_db:
        name: all
        state: dump
        target: "{{ backup_dir }}/mysql_{{ ansible_date_time.date }}.sql"
      when: mysql_service is defined
    
    - name: Backup web files
      archive:
        path: /var/www/html
        dest: "{{ backup_dir }}/web_{{ ansible_date_time.date }}.tar.gz"
        format: gz
    
    - name: Remove old backups
      find:
        paths: "{{ backup_dir }}"
        age: "{{ retention_days }}d"
        patterns: "*.sql,*.tar.gz"
      register: old_backups
    
    - name: Delete old backup files
      file:
        path: "{{ item.path }}"
        state: absent
      loop: "{{ old_backups.files }}"

1
2
3
4
5
6
7
8

# Create checksums during backup
find /source -type f -exec md5sum {} \; > backup_checksums.md5

# Verify backup integrity
cd /backup && md5sum -c backup_checksums.md5

# SHA256 checksums
find /source -type f -exec sha256sum {} \; > backup_checksums.sha256

1
2
3
4
5
6
7

# MySQL backup verification
mysql -u root -p < backup.sql
mysqldump -u root -p --all-databases | diff - backup.sql

# PostgreSQL backup verification
psql -U postgres -f backup.sql
pg_dumpall -U postgres | diff - backup.sql

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

#!/bin/bash
# restore_test.sh

# Test environment
TEST_DB="test_restore_$(date +%s)"
BACKUP_FILE="/backup/latest.sql"

# Create test database
mysql -u root -p -e "CREATE DATABASE $TEST_DB;"

# Restore backup to test database
mysql -u root -p "$TEST_DB" < "$BACKUP_FILE"

# Verify restore
if mysql -u root -p -e "USE $TEST_DB; SHOW TABLES;" > /dev/null 2>&1; then
    echo "Restore test successful"
    # Cleanup
    mysql -u root -p -e "DROP DATABASE $TEST_DB;"
    exit 0
else
    echo "Restore test failed"
    exit 1
fi

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#!/bin/bash
# rto_test.sh

START_TIME=$(date +%s)

# Simulate disaster
systemctl stop mysql
rm -rf /var/lib/mysql/*

# Start recovery
echo "Starting recovery at $(date)"
systemctl start mysql
mysql -u root -p < /backup/latest.sql

END_TIME=$(date +%s)
RTO=$((END_TIME - START_TIME))

echo "Recovery Time Objective (RTO): $RTO seconds"

# Verify data integrity
mysql -u root -p -e "SELECT COUNT(*) FROM myapp.users;"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

Priority 1 (Critical): 
- Database servers
- Web applications
- Email systems
- RTO: < 1 hour, RPO: < 15 minutes

Priority 2 (Important):
- File servers
- Development systems
- RTO: < 4 hours, RPO: < 1 hour

Priority 3 (Normal):
- Archive systems
- Test environments
- RTO: < 24 hours, RPO: < 4 hours

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

#!/bin/bash
# database_recovery.sh

# Stop application services
systemctl stop apache2 nginx

# Restore database from backup
mysql -u root -p < /backup/latest_full.sql

# Apply incremental backups
for backup in /backup/incremental_*.sql; do
    mysql -u root -p < "$backup"
done

# Verify database integrity
mysql -u root -p -e "CHECK TABLE myapp.users;"

# Start application services
systemctl start apache2 nginx

echo "Database recovery completed"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

#!/bin/bash
# filesystem_recovery.sh

# Mount backup volume
mount /dev/backup_disk /mnt/backup

# Restore files
rsync -av /mnt/backup/latest/ /var/www/html/

# Set permissions
chown -R www-data:www-data /var/www/html
chmod -R 755 /var/www/html

# Restart web services
systemctl restart apache2

echo "File system recovery completed"

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

1. Incident Detection
   - Monitoring alerts
   - User reports
   - System checks

2. Initial Response
   - Assess impact
   - Activate DR team
   - Communicate to stakeholders

3. Recovery Execution
   - Execute recovery procedures
   - Monitor progress
   - Update stakeholders

4. Service Restoration
   - Verify system functionality
   - Resume normal operations
   - Conduct post-incident review

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

# GPG encryption
tar -czf - /var/www/html | gpg --cipher-algo AES256 \
  --compress-algo 1 --symmetric \
  --output backup_encrypted.tar.gz.gpg

# OpenSSL encryption
tar -czf - /var/www/html | openssl enc -aes-256-cbc \
  -salt -out backup_encrypted.tar.gz

# Decrypt backup
gpg --decrypt backup_encrypted.tar.gz.gpg | tar -xzf -
openssl enc -aes-256-cbc -d -in backup_encrypted.tar.gz | tar -xzf -

 1
 2
 3
 4
 5
 6
 7
 8
 9
10

# Create backup user
useradd -r -s /bin/false backup_user

# Set backup directory permissions
chown backup_user:backup_group /backup
chmod 750 /backup

# Secure backup scripts
chmod 700 /scripts/backup.sh
chown root:root /scripts/backup.sh

1
2
3
4
5
6
7
8
9

# Object lock on S3
aws s3api put-object-legal-hold \
  --bucket backup-bucket \
  --key backup.tar.gz \
  --legal-hold Status=ON

# Immutable snapshots
zfs snapshot -r tank/data@immutable_$(date +%Y%m%d)
zfs hold keep tank/data@immutable_$(date +%Y%m%d)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

#!/bin/bash
# backup_monitor.sh

BACKUP_DIR="/backup"
MAX_AGE=86400  # 24 hours in seconds

# Check latest backup age
LATEST_BACKUP=$(find "$BACKUP_DIR" -name "*.sql.gz" -type f -printf '%T@ %p\n' | sort -n | tail -1)
BACKUP_TIME=$(echo "$LATEST_BACKUP" | cut -d' ' -f1 | cut -d'.' -f1)
CURRENT_TIME=$(date +%s)
AGE=$((CURRENT_TIME - BACKUP_TIME))

if [ $AGE -gt $MAX_AGE ]; then
    echo "CRITICAL: Backup is $((AGE/3600)) hours old"
    # Send alert
    echo "Backup alert: Last backup is too old" | \
      mail -s "Backup Alert" [email protected]
    exit 2
else
    echo "OK: Backup is current"
    exit 0
fi

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

# /usr/local/nagios/libexec/check_backup_age
#!/bin/bash

BACKUP_FILE="/backup/latest.sql.gz"
WARNING_HOURS=25
CRITICAL_HOURS=49

if [ ! -f "$BACKUP_FILE" ]; then
    echo "CRITICAL: Backup file not found"
    exit 2
fi

AGE_HOURS=$(( ($(date +%s) - $(stat -c %Y "$BACKUP_FILE")) / 3600 ))

if [ $AGE_HOURS -gt $CRITICAL_HOURS ]; then
    echo "CRITICAL: Backup is $AGE_HOURS hours old"
    exit 2
elif [ $AGE_HOURS -gt $WARNING_HOURS ]; then
    echo "WARNING: Backup is $AGE_HOURS hours old"
    exit 1
else
    echo "OK: Backup is $AGE_HOURS hours old"
    exit 0
fi

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33

# backup_exporter.py
from prometheus_client import start_http_server, Gauge, Counter
import time
import os
import glob

# Metrics
backup_age_seconds = Gauge('backup_age_seconds', 'Age of latest backup in seconds')
backup_size_bytes = Gauge('backup_size_bytes', 'Size of latest backup in bytes')
backup_success_total = Counter('backup_success_total', 'Total successful backups')
backup_failure_total = Counter('backup_failure_total', 'Total failed backups')

def collect_backup_metrics():
    backup_dir = "/backup"
    pattern = os.path.join(backup_dir, "*.sql.gz")
    backups = glob.glob(pattern)
    
    if backups:
        latest_backup = max(backups, key=os.path.getctime)
        
        # Age metric
        age = time.time() - os.path.getctime(latest_backup)
        backup_age_seconds.set(age)
        
        # Size metric
        size = os.path.getsize(latest_backup)
        backup_size_bytes.set(size)

if __name__ == '__main__':
    start_http_server(8000)
    while True:
        collect_backup_metrics()
        time.sleep(60)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26

# AWS S3 lifecycle policy
{
  "Rules": [
    {
      "ID": "BackupLifecycle",
      "Status": "Enabled",
      "Transitions": [
        {
          "Days": 30,
          "StorageClass": "STANDARD_IA"
        },
        {
          "Days": 90,
          "StorageClass": "GLACIER"
        },
        {
          "Days": 365,
          "StorageClass": "DEEP_ARCHIVE"
        }
      ],
      "Expiration": {
        "Days": 2555  # 7 years
      }
    }
  ]
}

1
2
3
4
5

# Using fdupes to find duplicates
fdupes -r /backup > duplicates.txt

# Using rdfind for deduplication
rdfind -makehardlinks true /backup

1
2
3
4
5

# ZFS deduplication
zfs set dedup=on tank/backup

# Check dedup ratio
zfs get dedupratio tank/backup

1
2
3
4
5
6
7

# Different compression algorithms
tar -czf backup.tar.gz /data          # gzip
tar -cjf backup.tar.bz2 /data         # bzip2
tar -cJf backup.tar.xz /data          # xz

# Compression comparison
ls -lh backup.tar.*