btrfs Featured

Comprehensive Guide to Snapper: Local and Remote Btrfs Snapshot Management Backup

Luigi

• 12 min read
Comprehensive Guide to Snapper: Local and Remote Btrfs Snapshot Management Backup

In the world of Linux filesystem management, Snapper stands out as a powerful tool originally created by openSUSE's Arvin Schnell for managing Btrfs snapshots. Whether you're running a desktop workstation or a production server, understanding how to configure Snapper for both local and remote backup retention is crucial for maintaining system stability and data recovery capabilities.

What is Snapper and How Does It Work?

Snapper is a command-line utility that manages snapshots of Btrfs subvolumes, thin-provisioned LVM volumes, and experimentally Bcachefs subvolumes. At its core, Snapper leverages Btrfs's copy-on-write (CoW) functionality to create read-only snapshots that capture the filesystem state at specific points in time.

Key Concepts

Snapshots vs Traditional Backups: Unlike traditional file-based backups, Btrfs snapshots are lightweight references to the original data. They only store the differences (changed blocks), making them incredibly space-efficient and fast to create.

Three Types of Snapper Snapshots:

  • Pre snapshots: Created before a system change (like package installation)
  • Post snapshots: Created after a change to complete the pre/post pair
  • Single snapshots: Standalone snapshots for timeline backup purposes

Setting Up Snapper for Local Snapshots

Installation Across Major Distributions

# Ubuntu/Debian
sudo apt update && sudo apt install snapper

# Arch Linux
sudo pacman -S snapper

# Fedora/RHEL
sudo dnf install snapper

# openSUSE
# Usually pre-installed

Creating Your First Configuration

# Create a configuration for root filesystem
sudo snapper -c root create-config /

# Create a configuration for home directory
sudo snapper -c home create-config /home

This creates:

  • Configuration file: /etc/snapper/configs/root
  • Snapshot directory: /.snapshots/
  • Systemd service setup

Understanding Snapper Retention Mechanisms

Snapper offers three primary cleanup algorithms that work together to manage snapshot storage:

1. Timeline Cleanup (Time-Based Retention)

Timeline cleanup manages snapshots based on time periods and is perfect for automated backup strategies.

Configuration Parameters:

# /etc/snapper/configs/root
TIMELINE_CREATE="yes"               # Enable automatic hourly snapshots
TIMELINE_CLEANUP="yes"              # Enable timeline-based cleanup

# Retention limits for different time periods
TIMELINE_LIMIT_HOURLY="10"          # Keep last 10 hourly snapshots
TIMELINE_LIMIT_DAILY="10"           # Keep first daily snapshot for 10 days
TIMELINE_LIMIT_WEEKLY="4"           # Keep first weekly snapshot for 4 weeks
TIMELINE_LIMIT_MONTHLY="12"         # Keep first monthly snapshot for 12 months
TIMELINE_LIMIT_YEARLY="5"           # Keep first yearly snapshot for 5 years

# Age restrictions
TIMELINE_MIN_AGE="1800"             # Minimum 30 minutes before cleanup

How Timeline Cleanup Works:

  • First snapshot selection: For daily/weekly/monthly/yearly, Snapper keeps the first snapshot created in each time period
  • Hourly retention: Keeps the last N hourly snapshots (most recent)
  • Minimum age: Snapshots must be at least TIMELINE_MIN_AGE seconds old before being considered for cleanup

2. Number Cleanup (Count-Based Retention)

Number cleanup is simpler - it just keeps the most recent N snapshots regardless of when they were created.

Configuration Parameters:

NUMBER_CLEANUP="yes"                # Enable number-based cleanup
NUMBER_MIN_AGE="1800"               # Minimum age: 30 minutes
NUMBER_LIMIT="50"                   # Keep last 50 snapshots
NUMBER_LIMIT_IMPORTANT="10"         # Keep last 10 important snapshots separately

Advanced Range Configuration:

# Dynamic range based on available space
NUMBER_LIMIT="30-50"                # Keep 30-50 snapshots
TIMELINE_LIMIT_DAILY="7-10"         # Keep 7-10 daily snapshots

3. Space-Based Cleanup (Btrfs Quotas Only)

Space-based cleanup is perfect for systems with limited storage capacity.

Configuration Parameters:

# Fraction of filesystem space
SPACE_LIMIT="0.5"                   # Snapshots can use max 50% of filesystem
FREE_LIMIT="0.2"                    # Keep at least 20% free space

# Absolute sizes
SPACE_LIMIT="100GB"                 # Use max 100GB for snapshots
FREE_LIMIT="20GB"                   # Keep at least 20GB free

Prerequisites for Space-Based Cleanup:

# Setup Btrfs quotas (required for space-based cleanup)
sudo snapper setup-quota

Remote Backup Configuration with snbk

The snbk tool (snapper-backup) extends Snapper's capabilities to remote systems using Btrfs send/receive over SSH. This is where the real power lies - efficient incremental backups to remote storage.

Understanding snbk Architecture

snbk works by:

  1. Using Btrfs send: Creates incremental streams of snapshot differences
  2. SSH transport: Securely transfers data to remote Btrfs filesystem
  3. Btrfs receive: Applies the snapshot on the remote system
  4. Automatic cleanup: Manages obsolete snapshots on both source and target

Setting Up Remote Backup

1. Create Backup Configuration

Create a JSON configuration file in /etc/snapper/backup-configs/:

{
  "config": "root",
  "target-mode": "ssh-push",
  "automatic": true,
  "source-path": "/",
  "target-path": "/backups/server-root",
  "ssh-host": "backup.example.com",
  "ssh-user": "snapper-backup",
  "ssh-port": 22,
  "ssh-identity": "/etc/snapper/certs/id_ecdsa"
}

2. SSH Key Setup

# Generate SSH key pair for automated backups
sudo ssh-keygen -t ecdsa -b 521 -f /etc/snapper/certs/id_ecdsa

# Copy public key to backup server
ssh-copy-id -i /etc/snapper/certs/id_ecdsa.pub snapper-backup@backup.example.com

# Test connection
sudo -u snapper-backup ssh -i /etc/snapper/certs/id_ecdsa backup.example.com "btrfs subvolume list /"

3. Remote Server Preparation

On your backup server:

# Create Btrfs filesystem for backups
sudo mkfs.btrfs /dev/sdX1
sudo mkdir -p /backups
sudo mount /dev/sdX1 /backups
sudo chown snapper-backup:snapper-backup /backups

# Create target directory
sudo -u snapper-backup mkdir -p /backups/server-root

snbk Remote Backup Commands

# List available backup configurations
snbk list-configs

# List snapshots and their transfer status
snbk list

# Manually transfer snapshots
snbk transfer

# Transfer and cleanup obsolete snapshots
snbk transfer-and-delete

# Delete obsolete snapshots from remote target only
snbk delete

Retention Policy Integration: Local + Remote

How Retention Works with snbk

The key insight is that snbk respects the source Snapper's retention policies. Here's the workflow:

  1. Local Cleanup: Snapper deletes old snapshots based on your retention configuration
  2. Automatic Transfer: snbk transfers new snapshots to remote location
  3. Remote Cleanup: When source snapshots are deleted, they become "obsolete" on the target
  4. Cleanup Propagation: snbk delete removes obsolete snapshots from backup server

Best Practice Configuration

Workstation Configuration:

# /etc/snapper/configs/root
TIMELINE_CREATE="yes"
TIMELINE_CLEANUP="yes"
TIMELINE_MIN_AGE="1800"
TIMELINE_LIMIT_HOURLY="6"           # Keep 6 hours of snapshots
TIMELINE_LIMIT_DAILY="7"            # Keep one per day for a week
TIMELINE_LIMIT_WEEKLY="4"           # Keep one per week for a month
TIMELINE_LIMIT_MONTHLY="6"          # Keep one per month for 6 months
TIMELINE_LIMIT_YEARLY="2"           # Keep one per year for 2 years

# Space limits
SPACE_LIMIT="0.3"                   # Max 30% for snapshots
FREE_LIMIT="0.1"                    # Keep 10% free

{
  "config": "root",
  "target-mode": "ssh-push",
  "automatic": true,
  "source-path": "/",
  "target-path": "/backups/workstation/root",
  "ssh-host": "nas.home.local",
  "ssh-user": "backup",
  "ssh-identity": "/etc/snapper/certs/id_ecdsa"
}

Server Configuration:

# /etc/snapper/configs/root
TIMELINE_CREATE="yes"
TIMELINE_CLEANUP="yes"
TIMELINE_MIN_AGE="3600"             # 1 hour minimum
TIMELINE_LIMIT_HOURLY="24"          # Keep 24 hours of snapshots
TIMELINE_LIMIT_DAILY="14"           # Keep 2 weeks of daily snapshots
TIMELINE_LIMIT_WEEKLY="8"           # Keep 2 months of weekly snapshots
TIMELINE_LIMIT_MONTHLY="12"         # Keep one per month for a year
TIMELINE_LIMIT_YEARLY="3"           # Keep one per year for 3 years

NUMBER_CLEANUP="yes"
NUMBER_LIMIT="100-200"              # Keep 100-200 snapshots based on space
NUMBER_LIMIT_IMPORTANT="20-50"      # Keep 20-50 important snapshots

Automation with Systemd

Enable Automatic Services

# Enable timeline snapshots
sudo systemctl enable --now snapper-timeline.timer

# Enable cleanup
sudo systemctl enable --now snapper-cleanup.timer

# Enable remote backup
sudo systemctl enable --now snbk-root.timer

Custom Timer Configuration

For more control, you can override default timer frequencies:

# Edit snapper cleanup timer
sudo systemctl edit snapper-cleanup.timer

# Example: Run cleanup every 6 hours instead of daily
[Timer]
OnCalendar=*:0/6:00
Persistent=true

Package Management Integration with snap-pac

The snap-pac tool provides automatic pre/post snapshot creation during package management operations on Arch Linux and its derivatives. This integration ensures you always have a rollback point before and after system updates.

Installing snap-pac

# Arch Linux / EndeavourOS / Manjaro
sudo pacman -S snap-pac

# For AUR helpers (yay/paru)
yay -S snap-pac

How snap-pac Works

snap-pac integrates directly with pacman through ALPM hooks:

  1. Pre-transaction snapshot: Created before any packages are installed/removed
  2. Post-transaction snapshot: Created after successful package operations
  3. Automatic cleanup: Failed transactions only keep the pre-snapshot

snap-pac Configuration

snap-pac creates its own Snapper configuration file:

# /etc/snapper/configs/pacman
# Automatically created by snap-pac
TIMELINE_CREATE="no"                # Disable automatic timeline snapshots
TIMELINE_CLEANUP="no"               # Disable timeline cleanup
NUMBER_CLEANUP="yes"                # Enable number-based cleanup
NUMBER_LIMIT="10"                    # Keep last 10 package snapshots
NUMBER_MIN_AGE="1800"                # 30 minutes minimum age
NUMBER_LIMIT_IMPORTANT="5"           # Keep last 5 important package snapshots

Customizing snap-pac Behavior

You can override default snap-pac settings by creating a custom configuration:

# Create custom pacman configuration
sudo snapper -c pacman create-config /
sudo cp /etc/snapper/configs/default /etc/snapper/configs/pacman

# Edit the pacman-specific configuration
sudo nano /etc/snapper/configs/pacman

# Example pacman configuration:
SUBVOLUME="/"
TIMELINE_CREATE="no"
TIMELINE_CLEANUP="no"
NUMBER_CLEANUP="yes"
NUMBER_LIMIT="15"                    # Keep more package snapshots
NUMBER_MIN_AGE="3600"                # 1 hour minimum age
NUMBER_LIMIT_IMPORTANT="10"          # Keep more important snapshots
ALLOW_USERS=""                       # No regular users needed
SYNC_ACL="no"                        # No ACL sync needed

Managing Package Snapshots

# List package-specific snapshots
sudo snapper -c pacman list

# Show details of package snapshots
sudo snapper -c pacman list -a

# Manually create a package snapshot
sudo snapper -c pacman create --description "Before system upgrade"

# Rollback to a specific package snapshot
sudo snapper -c pacman rollback <snapshot-number>

# Cleanup old package snapshots
sudo snapper -c pacman cleanup number

Integration with Other Tools

Combining with Timeline Snapshots

You can run both timeline and package snapshots simultaneously:

# Timeline configuration (for root)
# /etc/snapper/configs/root
TIMELINE_CREATE="yes"
TIMELINE_CLEANUP="yes"
TIMELINE_LIMIT_HOURLY="6"
TIMELINE_LIMIT_DAILY="7"
TIMELINE_LIMIT_WEEKLY="4"

# Package configuration (pacman/snap-pac)
# /etc/snapper/configs/pacman  
NUMBER_CLEANUP="yes"
NUMBER_LIMIT="15"

GRUB Integration

For booting into package snapshots, install grub-btrfs:

# Install GRUB Btrfs support
sudo pacman -S grub-btrfs

# This automatically detects all Snapper snapshots
# and adds them to the GRUB boot menu

# Re-generate GRUB configuration
sudo grub-mkconfig -o /boot/grub/grub.cfg

Advanced snap-pac Usage

Selective Package Snapshots

Not all package changes need snapshots. Control this with pacman hooks:

# Edit /etc/pacman.d/hooks/90-snap-pac-pre.hook
[Trigger]
Operation = Install
Operation = Upgrade
Operation = Remove
Type = Package
# Exclude certain packages from creating snapshots
# Target = !linux*
# Target = !nvidia*

[Action]
Description = Creating pre snapshot for %p...
When = PreTransaction
Exec = /usr/bin/snapper --no-dbus -c pacman create --description="Pre %p"

Custom Snapshot Descriptions

snap-pac automatically creates descriptive snapshot names:

# Example snapshot descriptions:
"Pre Upgrade 2024-01-15 14:30"
"Post Upgrade 2024-01-15 14:35" 
"Pre Install firefox 125.0.1-1"
"Post Install firefox 125.0.1-1"
"Pre Remove old-software 2.0.0-1"
"Post Remove old-software 2.0.0-1"

Troubleshooting snap-pac

# Check if snap-pac hooks are active
sudo pacman -Ql snap-pac | grep hook

# Test hook functionality
sudo snapper -c pacman create --description="Test snapshot"

# Check hook logs
journalctl -u pacman | grep snap-pac

# Verify snapshot creation after package operation
sudo snapper -c pacman list | tail -5

Alternative: timeshift-autosnap

If you prefer Timeshift over Snapper for package snapshots:

# Install timeshift-autosnap from AUR
yay -S timeshift-autosnap

# This integrates with pacman similar to snap-pac
# but uses Timeshift instead of Snapper

Best Practices

  1. Separate Configurations: Keep timeline and package snapshots in separate configurations
  2. Conservative Limits: Package snapshots should have lower limits than timeline snapshots
  3. Regular Cleanup: Package snapshots accumulate quickly, ensure cleanup runs frequently
  4. Testing: Always test rollback procedures before relying on them in production
  5. Documentation: Document your snapshot strategy for system recovery scenarios

snap-pac Workflow Example

# 1. System update with automatic snapshots
sudo pacman -Syu
# snap-pac automatically creates pre and post snapshots

# 2. Check what was done
sudo snapper -c pacman list
# Shows: "Pre Upgrade" and "Post Upgrade" snapshots

# 3. Something went wrong - rollback
sudo snapper -c pacman rollback 42
# Rolls back to snapshot 42 (pre-upgrade state)

# 4. Verify system works, then cleanup
sudo snapper -c pacman cleanup number
# Removes old package snapshots

Monitoring Btrfs Space Usage

Proper monitoring is essential for maintaining healthy snapshot management. Here are the essential commands to track your Btrfs filesystem and snapshot space usage.

Essential Space Monitoring Commands

1. Filesystem Disk Usage (Most Important)

# Show space usage by category (metadata, data, system)
sudo btrfs filesystem df /

# Example output:
# Data, single: total=100.00GB, used=50.00GB
# Data, DUP: total=2.00GB, used=1.00GB
# Metadata, single: total=1.00GB, used=500.00MB
# Metadata, DUP: total=2.00GB, used=1.00GB
# System, DUP: total=32.00KB, used=16.00KB
# Unallocated: total=50.00GB

The btrfs filesystem df command is your primary tool for understanding space allocation:

  • Data: Actual file content (single copy or duplicated)
  • Metadata: File system structure (automatically duplicated for safety)
  • System: Internal Btrfs structures
  • Unallocated: Free space available for use

2. Detailed Filesystem Usage

# Show comprehensive usage information
sudo btrfs filesystem usage /

# This includes:
# - Overall space usage
# - Fragmentation levels
# - Memory usage
# - Copy-on-write statistics

3. Quota Group Information

# Show quota groups (requires quota setup)
sudo btrfs qgroup show /

# Example output:
# qgroupid         references     rfer         excl
# --------         -----------    ----         ----
# 0/5              1.00GB         50.00GB      1.00GB
# 0/256            500.00MB       10.00GB      500.00MB

Quota groups help track space used by specific subvolumes, including snapshots.

4. List All Subvolumes

# List all subvolumes including snapshots
sudo btrfs subvolume list /

# Show only snapshot subvolumes
sudo btrfs subvolume list -s /

# List with snapshot IDs
sudo btrfs subvolume list -t /

5. Snapshot-Specific Space Usage

# Show which subvolumes consume the most space
sudo btrfs qgroup show -p / --sort= -rfer

# Check individual snapshot sizes
sudo btrfs qgroup query -p <qgroupid> /

Monitoring Snapper-Specific Space Usage

List Snapshots with Space Information

# List all snapshots with their details
sudo snapper list

# Check specific configuration
sudo snapper -c root list

# Show snapshot status including space estimates
sudo snapper status

Check Configuration Limits

# View current Snapper configuration
sudo snapper get-config

# Key values to monitor:
# - TIMELINE_LIMIT_* settings
# - NUMBER_LIMIT settings
# - SPACE_LIMIT values

Creating a Monitoring Script

Create a comprehensive monitoring script to track snapshot space usage:

#!/bin/bash
# /usr/local/bin/snapper-monitor

SNAPPER_CONFIG="root"
MOUNT_POINT="/"

echo "=== Btrfs Filesystem Space Usage ==="
btrfs filesystem df $MOUNT_POINT | grep -E "^(Data|Metadata|System)"

echo ""
echo "=== Overall Filesystem Usage ==="
btrfs filesystem usage $MOUNT_POINT | grep -E "(Total device|Used space|Free space|Allocated)"

echo ""
echo "=== Snapper Snapshot Count ==="
snapper -c $SNAPPER_CONFIG list | tail -n +2 | wc -l

echo ""
echo "=== Recent Snapshots ==="
snapper -c $SNAPPER_CONFIG list | tail -n 5

echo ""
echo "=== Quota Groups (Top 10 by exclusive usage) ==="
btrfs qgroup show $MOUNT_POINT 2>/dev/null | head -n 15

echo ""
echo "=== Subvolume Summary ==="
echo "Total subvolumes:"
btrfs subvolume list $MOUNT_POINT | wc -l
echo "Snapshot subvolumes:"
btrfs subvolume list -s $MOUNT_POINT | wc -l

Save this script and make it executable:

sudo chmod +x /usr/local/bin/snapper-monitor

Space Alert Script

Create a script to alert when snapshot space usage exceeds thresholds:

#!/bin/bash
# /usr/local/bin/snapper-space-alert

THRESHOLD=80  # Alert at 80% usage
MOUNT_POINT="/"

# Get current usage percentage
USAGE=$(btrfs filesystem usage $MOUNT_POINT | grep "Used space" | awk '{print $3}' | sed 's/%//')
TOTAL=$(btrfs filesystem usage $MOUNT_POINT | grep "Total device" | awk '{print $4}')
USED=$(btrfs filesystem usage $MOUNT_POINT | grep "Used space" | awk '{print $3}')

# Calculate percentage
PERCENTAGE=$((USED * 100 / TOTAL))

if [ $PERCENTAGE -ge $THRESHOLD ]; then
    echo "WARNING: Btrfs usage at ${PERCENTAGE}% (${USED} used of ${TOTAL})"
    
    # Get snapshot count
    SNAPSHOT_COUNT=$(snapper list | tail -n +2 | wc -l)
    echo "Current snapshot count: $SNAPSHOT_COUNT"
    
    # Check cleanup algorithms
    echo ""
    echo "Cleanup configuration check:"
    snapper get-config | grep -E "(CLEANUP|LIMIT)"
    
    # Suggest action
    echo ""
    echo "Recommended actions:"
    echo "1. Run manual cleanup: sudo snapper cleanup timeline"
    echo "2. Review retention settings in /etc/snapper/configs/"
    echo "3. Consider reducing TIMELINE_LIMIT values"
else
    echo "OK: Btrfs usage at ${PERCENTAGE}% (${USED} used of ${TOTAL})"
fi

Automated Monitoring with Cron

Add monitoring to your crontab for regular checks:

# Add to /etc/cron.daily/snapper-monitor
#!/bin/bash
/usr/local/bin/snapper-monitor >> /var/log/snapper-usage.log 2>&1

# Add weekly space check
# In /etc/cron.weekly/snapper-space-check
0 2 * * 0 /usr/local/bin/snapper-space-alert

Health and Integrity Monitoring

Scrub Status

# Check last scrub status (data integrity check)
sudo btrfs scrub status /

# Start a scrub (read-only integrity check)
sudo btrfs scrub start /

# Scrub with statistics
sudo btrfs scrub start -B /

Balance Status

# Check if balance is running
sudo btrfs balance status /

# Start balance (only if needed for space optimization)
sudo btrfs balance start -dusage=50 /

Advanced Configuration and Troubleshooting

Monitoring and Status

# Check current configuration
snapper get-config

# List all snapshots with details
snapper list -c root -a

# Check backup status
snbk list-configs
snbk list

# Monitor space usage
df -h /
snapper status

# Check snapshot differences
snapper diff -c root 50 51

Common Issues and Solutions

Issue: Timeline cleanup not running

Symptoms: Snapshot count keeps growing despite cleanup enabled
Solution:

# Check if timer is active
systemctl status snapper-cleanup.timer

# Run cleanup manually to test
sudo snapper cleanup timeline

# Check logs
journalctl -u snapper-cleanup

Issue: Remote backup failing

Symptoms: snbk transfer shows connection or permission errors
Solutions:

# Test SSH connection manually
sudo -u snapper-backup ssh -i /etc/snapper/certs/id_ecdsa backup.server "echo 'Connection successful'"

# Check remote Btrfs permissions
sudo -u snapper-backup ssh backup.server "btrfs subvolume list /backups"

# Enable verbose mode for debugging
snbk -v transfer-and-delete

Issue: Space limits not respected

Symptoms: Snapshots exceed configured space limits
Solution:

# Ensure quotas are enabled
sudo snapper setup-quota

# Check quota status
sudo btrfs qgroup show /

# Use range syntax for dynamic cleanup
NUMBER_LIMIT="50-100"

Security Best Practices

SSH Security

# Use dedicated backup user with limited privileges
sudo useradd -r -s /bin/bash snapper-backup

# Restrict SSH access
# In /etc/ssh/sshd_config
AllowUsers snapper-backup
PasswordAuthentication no
PubkeyAuthentication yes

# Use specific SSH key for backups
ssh-keygen -t ed25519 -a 100 -f /etc/snapper/certs/backup_key

Filesystem Permissions

# Set proper ownership on backup server
sudo chown -R snapper-backup:snapper-backup /backups

# Use restrictive permissions
chmod 700 /backups
chmod 755 /backups/server-root

Performance Optimization

Btrfs Settings for Snapshot Performance

# Enable compression for better space efficiency
sudo btrfs property set / compression zstd

# Enable autoclean for better SSD performance
sudo fstrim -av /

# Optimize mount options
# In /etc/fstab
defaults,ssd,compress=zstd,space_cache=v2

Network Optimization for Remote Backups

# Use SSH multiplexing for multiple connections
# In ~/.ssh/config
Host backup.server
  ControlMaster auto
  ControlPath ~/.ssh/cm-%r@%h:%p

# Enable compression in SSH
Host backup.server
  Compression yes

Quick Reference: Essential Commands

Daily Monitoring Commands

# Quick space check
df -h /

# Detailed Btrfs space usage
btrfs filesystem df /

# Snapshot count
snapper list | wc -l

# Recent snapshots
snapper list | tail -5

Weekly Maintenance Commands

# Run cleanup manually
snapper cleanup timeline
snapper cleanup number

# Check backup status
snbk list

# Scrub for integrity
btrfs scrub start -B /

Monthly Review Commands

# Detailed space analysis
btrfs filesystem usage /

# Quota group breakdown
btrfs qgroup show /

# Review retention configuration
snapper get-config

Conclusion

Snapper combined with snbk and snap-pac provides a robust, enterprise-grade solution for Btrfs snapshot management both locally and remotely. By properly configuring retention policies and implementing comprehensive monitoring, you can maintain:

  • Efficient local rollback capabilities for quick system recovery
  • Automated remote backups for disaster recovery
  • Package-level snapshot protection with snap-pac integration
  • Space-optimized storage through intelligent cleanup algorithms
  • Secure incremental transfers minimizing bandwidth usage

The key to success is understanding how the three cleanup algorithms (timeline, number, space-based) work together and configuring them appropriately for your specific use case—whether that's a development workstation needing frequent rollbacks or a production server requiring long-term archival.

Start with conservative retention settings and monitor your system's behavior over time using the monitoring commands provided. The beauty of Snapper is its flexibility—you can always adjust retention policies as your needs evolve, ensuring your snapshot strategy remains both effective and sustainable.

Key Monitoring Takeaways:

  • Use btrfs filesystem df / as your primary space monitoring tool
  • Set up automated monitoring scripts to track snapshot growth
  • Configure alerts for when space usage exceeds thresholds
  • Regular scrubbing ensures data integrity across snapshots
  • Monitor both local and remote backup status consistently
  • Package snapshots with snap-pac provide essential system update protection

Further Reading and Resources:

This comprehensive setup ensures you'll never lose important system states while maintaining efficient storage usage both locally and remotely through proper monitoring and retention configuration, with the added protection of automatic package management snapshots.