Borg Backup + Vorta: Efficient Homelab Backups

Master efficient, encrypted, and deduplicated backups with BorgBackup and its user-friendly Vorta GUI. This comprehensive guide shows you how to implement production-grade backup strategies with minimal storage overhead.

Difficulty: Intermediate Estimated Time: 50 minutes Last Updated: December 2025 Target Audience: Homelab enthusiasts, Linux administrators, privacy-conscious users

What You’ll Learn

Install and configure BorgBackup for efficient deduplication
Deploy Vorta GUI for easy backup management
Set up local and remote Borg repositories
Implement automated backup schedules
Configure pruning strategies for optimal storage
Perform encrypted backups with compression
Execute efficient restore operations
Monitor backup health and statistics
Integrate with systemd for automation

Prerequisites

Required Knowledge

Linux command-line fundamentals
Basic understanding of SSH and SFTP
File system and permissions concepts
Cron or systemd timer experience (helpful)

Required Infrastructure

Linux desktop or server (Ubuntu 22.04+, Debian 11+, Fedora 38+)
Minimum: 1 GB RAM, 2 CPU cores
Recommended: 4+ GB RAM, adequate backup storage
Backup destination (local disk, NAS, or remote server)
SSH access to remote backup servers (if using remote repos)

Pre-Deployment Checklist

Backup storage location identified
Encryption passphrase generated
SSH keys configured (for remote backups)
Data to backup identified
Retention policy planned

1. Understanding BorgBackup

What is BorgBackup?

BorgBackup (short “Borg”) is a deduplicating backup program with compression and authenticated encryption. It’s designed to efficiently backup data with minimal storage requirements through content-defined chunking and deduplication.

Key Features:

Deduplication: Chunk-level deduplication across all backups
Compression: Multiple algorithms (lz4, zstd, zlib, lzma)
Encryption: Authenticated encryption (AES-256-OCB or BLAKE2b)
Space Efficiency: Only stores unique data chunks once
Fast Backups: Incremental backups complete in seconds
Mountable Archives: Mount any backup as a filesystem
Portable: Python-based, works across platforms
Mature: Stable, battle-tested in production environments

What is Vorta?

Vorta is a desktop backup client for BorgBackup, providing a graphical interface for managing repositories, scheduling backups, and browsing archives.

Key Features:

GUI Interface: Native desktop application (Qt-based)
Backup Profiles: Multiple backup configurations
Scheduling: Automated backups with flexible timing
Archive Browser: Visual file restoration
Repository Management: Create and manage Borg repos
Notifications: Desktop alerts for backup events
Cross-Platform: Linux, macOS, Windows support

BorgBackup vs. Other Solutions

Feature	BorgBackup	Restic	rsync
Deduplication	Chunk-level	Chunk-level	File-level
Encryption	Built-in	Built-in	Via encfs/gocryptfs
Compression	Multiple algorithms	Limited	None built-in
Mounting	Yes (FUSE)	Yes (FUSE)	N/A
Repository Format	Single append-only	Object store	Mirror copy
Maturity	Very mature (2010+)	Mature (2014+)	Ancient (1996+)
Storage Efficiency	Excellent	Excellent	Good

How Borg Deduplication Works

Content-Defined Chunking:

File: large-video.mp4 (1 GB)
    ↓
Split into chunks (variable size, ~2 MB average)
    ↓
Chunk 1: hash_abc123 (2.1 MB)
Chunk 2: hash_def456 (1.9 MB)
Chunk 3: hash_abc123 (2.1 MB) ← Duplicate of Chunk 1!
    ↓
Store only unique chunks:
  - hash_abc123: 2.1 MB (stored once)
  - hash_def456: 1.9 MB
    ↓
Total stored: 4.0 MB (not 6.1 MB)
Savings: 34%

Real-world example:

Backup 1: Full system (50 GB) → 50 GB stored
Backup 2: After updates (50 GB, 2 GB changed) → +2 GB (total: 52 GB)
Backup 3: After updates (50 GB, 1 GB changed) → +1 GB (total: 53 GB)

Traditional backups: 150 GB
Borg: 53 GB
Savings: 65%

With compression:

Borg with lz4 compression:
50 GB data → 35 GB after dedup → 25 GB after compression
Total savings: 50% (compared to uncompressed traditional backups)

2. Installing BorgBackup and Vorta

Installing BorgBackup

Ubuntu/Debian:

# Install from official repos (may be older version)
sudo apt update
sudo apt install borgbackup

# Or install latest from backports (recommended)
echo "deb http://deb.debian.org/debian bookworm-backports main" |   sudo tee /etc/apt/sources.list.d/backports.list
sudo apt update
sudo apt install -t bookworm-backports borgbackup

# Verify installation
borg --version

Fedora/RHEL:

# Install from official repos
sudo dnf install borgbackup

# Verify
borg --version

Install from pip (latest version):

# Install dependencies
sudo apt install python3-pip python3-dev libssl-dev libacl1-dev   libxxhash-dev liblz4-dev libzstd-dev build-essential pkg-config

# Install Borg via pip
sudo pip3 install borgbackup

# Verify
borg --version

Binary installation (no dependencies):

# Download standalone binary
wget https://github.com/borgbackup/borg/releases/download/1.2.7/borg-linux64
chmod +x borg-linux64
sudo mv borg-linux64 /usr/local/bin/borg

# Verify
borg --version

Installing Vorta GUI

Ubuntu/Debian (via PPA):

# Add Vorta PPA
sudo add-apt-repository ppa:borgbackup/borgbackup
sudo apt update

# Install Vorta
sudo apt install vorta

# Launch Vorta
vorta &

Fedora:

# Install from repos
sudo dnf install vorta

# Launch
vorta &

Via Flatpak (universal):

# Install Flatpak (if not installed)
sudo apt install flatpak

# Add Flathub repository
flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo

# Install Vorta
flatpak install flathub com.borgbase.Vorta

# Launch
flatpak run com.borgbase.Vorta

From source:

# Install dependencies
sudo apt install python3-pyqt5 python3-pyqt5.qtsvg python3-secretstorage

# Clone repository
git clone https://github.com/borgbase/vorta.git
cd vorta

# Install
pip3 install -e .

# Launch
vorta

3. Creating Your First Repository

Local Repository Setup

Via Command Line:

# Create repository directory
mkdir -p /mnt/backup-drive/borg-repo

# Initialize repository with encryption
borg init --encryption=repokey /mnt/backup-drive/borg-repo

# You'll be prompted for:
# 1. Repository passphrase (store securely!)
# 2. Confirmation of passphrase

# The passphrase is CRITICAL - if lost, backups are unrecoverable!

Encryption modes:

# repokey (recommended for local repos)
# - Encryption key stored in repository
# - Passphrase protects the key
borg init --encryption=repokey /path/to/repo

# keyfile (recommended for remote repos)
# - Encryption key stored locally (~/.config/borg/keys/)
# - More secure for untrusted remote storage
borg init --encryption=keyfile /path/to/repo

# none (not recommended)
# - No encryption
# - Only use for already-encrypted destinations
borg init --encryption=none /path/to/repo

Via Vorta GUI:

Launch Vorta
Click Initialize Repository
Choose Repository Location: Local path or remote URL
Set Encryption: repokey or keyfile
Enter Repository Password (twice)
Click Initialize

Save your encryption key:

# Export repository key (critical backup!)
borg key export /mnt/backup-drive/borg-repo borg-key-backup.txt

# Store this file in multiple secure locations:
# - Password manager
# - Encrypted USB drive
# - Secure cloud storage
# - Physical safe

Remote Repository Setup (SSH/SFTP)

On remote backup server:

# Create dedicated backup user
sudo useradd -m -s /bin/bash borgbackup

# Create repository directory
sudo mkdir -p /srv/borg-backups/laptop
sudo chown borgbackup:borgbackup /srv/borg-backups/laptop

On local machine:

# Generate SSH key (if not exists)
ssh-keygen -t ed25519 -C "borg-backup-key"

# Copy public key to backup server
ssh-copy-id [email protected]

# Test connection
ssh [email protected]

# Initialize remote repository
borg init --encryption=keyfile   ssh://[email protected]/srv/borg-backups/laptop

# Verify
borg info ssh://[email protected]/srv/borg-backups/laptop

In Vorta:

Repository tab → Initialize Repository
Choose Remote
Enter URL: ssh://[email protected]/srv/borg-backups/laptop
Set encryption mode
Enter passphrase
Initialize

4. Creating Backups

First Backup via Command Line

# Set environment variables (recommended)
export BORG_REPO="/mnt/backup-drive/borg-repo"
export BORG_PASSPHRASE="your-secure-passphrase"

# Create first backup archive
borg create   --verbose   --stats   --compression lz4   --exclude-caches   ::{hostname}-{now:%Y-%m-%d_%H:%M:%S}   /home/user/Documents   /home/user/Pictures   /etc

# Explanation:
# --verbose: Show progress
# --stats: Display statistics after backup
# --compression lz4: Fast compression (or zstd, zlib, lzma)
# --exclude-caches: Skip directories with CACHEDIR.TAG
# ::{hostname}-{now}: Archive name with hostname and timestamp
# Followed by paths to backup

Output:

------------------------------------------------------------------------------
Archive name: myserver-2025-12-16_14:30:00
Archive fingerprint: abc123def456...
Time (start): Mon, 2025-12-16 14:30:00
Time (end):   Mon, 2025-12-16 14:32:15
Duration: 2 minutes 15 seconds
Number of files: 15432
------------------------------------------------------------------------------
                       Original size      Compressed size    Deduplicated size
This archive:               10.5 GB              7.2 GB              7.2 GB
All archives:               10.5 GB              7.2 GB              7.2 GB

                       Unique chunks         Total chunks
Chunk index:                   14532                14532
------------------------------------------------------------------------------

Subsequent backup (incremental):

# Second backup (only changed data stored)
borg create   --stats   --compression lz4   ::{hostname}-{now:%Y-%m-%d_%H:%M:%S}   /home/user/Documents   /home/user/Pictures   /etc

Output:

------------------------------------------------------------------------------
                       Original size      Compressed size    Deduplicated size
This archive:               10.6 GB              7.3 GB             125 MB ← Only 125 MB new!
All archives:               21.1 GB             14.5 GB              7.3 GB
------------------------------------------------------------------------------

Backups via Vorta

Create a backup profile:

Open Vorta
Go to Backup tab
Click Add Repository
Select your initialized repository
Enter repository password

Configure backup sources:

Source Folders → Click Add

Select directories to backup:

/home/user/Documents
/home/user/Pictures
/home/user/Projects
/etc (for system config)

Click Save

Configure exclusions:

Go to Exclude tab
Add exclusion patterns:

# Exclude patterns (Vorta UI)
*/.cache
*/cache
*/__pycache__
*.tmp
*.log
node_modules/
.git/
.DS_Store
Thumbs.db

Advanced exclusions:

# Exclude by size
--exclude 'sh:*.iso'  # Skip all .iso files
--exclude 'sh:*.mp4'  # Skip video files

# Exclude if larger than
--exclude-if-present .nobackup  # Skip dirs with .nobackup file

# Pattern matching
home/*/.cache  # All user cache directories
**/temp/       # All temp folders anywhere

Run first backup:

Click Start Backup button
Monitor progress in the UI
View statistics when complete

Automated Scheduling

Via Vorta (GUI):

Go to Schedule tab
Enable Backup Schedule
Set frequency:
- Hourly
- Daily at specific time
- Weekly on specific days
- Custom interval

Example:

Backup every 6 hours
or
Backup daily at 02:00
or
Backup on Monday, Wednesday, Friday at 02:00

Save settings

Vorta will run in the background and execute backups automatically.

Via systemd timer (for servers without GUI):

Create systemd service:

sudo nano /etc/systemd/system/borg-backup.service

Add:

[Unit]
Description=Borg Backup
After=network.target

[Service]
Type=oneshot
User=root
Environment="BORG_REPO=/mnt/backup-drive/borg-repo"
Environment="BORG_PASSPHRASE=your-passphrase"
ExecStart=/usr/bin/borg create 
  --verbose   --stats   --compression lz4   --exclude-caches   --exclude '/var/cache'   --exclude '/tmp'   ::{hostname}-{now:%%Y-%%m-%%d_%%H:%%M:%%S}   /home   /etc   /var

[Install]
WantedBy=multi-user.target

Create systemd timer:

sudo nano /etc/systemd/system/borg-backup.timer

Add:

[Unit]
Description=Borg Backup Timer
Requires=borg-backup.service

[Timer]
OnCalendar=daily
OnCalendar=02:00
Persistent=true

[Install]
WantedBy=timers.target

Enable and start:

# Enable timer
sudo systemctl daemon-reload
sudo systemctl enable borg-backup.timer
sudo systemctl start borg-backup.timer

# Check status
sudo systemctl status borg-backup.timer

# List all timers
systemctl list-timers

# Manual run
sudo systemctl start borg-backup.service

5. Pruning and Retention Policies

Understanding Pruning

Pruning removes old archives according to retention rules, freeing up storage.

Retention policy examples:

Conservative (keep more):

borg prune   --keep-hourly=24   --keep-daily=7   --keep-weekly=4   --keep-monthly=12   --keep-yearly=3

Balanced (recommended for homelabs):

borg prune   --keep-daily=7   --keep-weekly=4   --keep-monthly=6   --keep-yearly=2

Minimal (space-constrained):

borg prune   --keep-last=3   --keep-weekly=4   --keep-monthly=3

Execute pruning:

# Set environment
export BORG_REPO="/mnt/backup-drive/borg-repo"
export BORG_PASSPHRASE="your-passphrase"

# Prune old archives
borg prune   --verbose   --stats   --list   --keep-daily=7   --keep-weekly=4   --keep-monthly=12

# Show what would be pruned (dry-run)
borg prune   --dry-run   --list   --keep-daily=7   --keep-weekly=4   --keep-monthly=12

Via Vorta:

Go to Archives tab
Click Prune Archives

Configure retention:

Keep hourly: 24
Keep daily: 7
Keep weekly: 4
Keep monthly: 12
Keep yearly: 3

Click Save
Enable Automatic Pruning to run after each backup

Compact (Reclaim Space)

After pruning, run compact to actually reclaim disk space:

# Compact repository (free up space)
borg compact --verbose

# This operation:
# - Removes deleted data chunks
# - Rebuilds repository index
# - Frees disk space

In Vorta:

Compact runs automatically after pruning if enabled in settings.

6. Restoring Backups

List Available Archives

# List all archives
borg list

# Output:
myserver-2025-12-16_02:00:00    Mon, 2025-12-16 02:00:01
myserver-2025-12-15_02:00:00    Sun, 2025-12-15 02:00:01
myserver-2025-12-14_02:00:00    Sat, 2025-12-14 02:00:01

List archive contents:

# List files in specific archive
borg list ::myserver-2025-12-16_02:00:00

# Search for specific file
borg list ::myserver-2025-12-16_02:00:00 | grep important-file.txt

Restore Files via Command Line

Full restore:

# Extract entire archive to /mnt/restore
borg extract   --verbose   ::myserver-2025-12-16_02:00:00   --target /mnt/restore

# Files restored to: /mnt/restore/home/user/...

Restore specific files:

# Restore specific path
borg extract   ::myserver-2025-12-16_02:00:00   home/user/Documents/important-file.txt

# Multiple paths
borg extract   ::myserver-2025-12-16_02:00:00   home/user/Documents   home/user/Pictures/vacation

Restore to original location:

# Extract directly to original paths
cd /
borg extract ::myserver-2025-12-16_02:00:00

# WARNING: This overwrites existing files!
# Safer to extract to temp location first

Restore via Vorta

Go to Archives tab
Select archive to restore from
Click Mount Archive
Browse files in file manager
Copy needed files to desired location
Click Unmount when done

Or use Extract:

Select archive
Click Extract
Choose destination folder
Select files/folders to extract
Click Extract

Mount Archive as Filesystem

Very useful for browsing and selective restore:

# Create mount point
mkdir -p /mnt/borg-mount

# Mount latest archive
borg mount ::myserver-2025-12-16_02:00:00 /mnt/borg-mount

# Browse files
cd /mnt/borg-mount
ls -la

# Mount ALL archives (browse by archive name)
borg mount /mnt/backup-drive/borg-repo /mnt/borg-mount

# Browse
cd /mnt/borg-mount
ls  # Shows all archives as directories
cd myserver-2025-12-16_02:00:00
# Now browse files in this archive

# Copy specific files
cp /mnt/borg-mount/myserver-2025-12-16_02:00:00/home/user/Documents/file.txt ~/restored/

# Unmount when done
fusermount -u /mnt/borg-mount
# Or: umount /mnt/borg-mount

7. Compression and Encryption

Compression Algorithms

Borg supports multiple compression algorithms with speed/ratio tradeoffs.

Comparison:

Algorithm	Speed	Compression Ratio	CPU Usage	Use Case
none	Fastest	None	Minimal	Pre-compressed data
lz4	Very Fast	Good	Low	General purpose, fast
zstd,3	Fast	Better	Moderate	Balanced (recommended)
zlib,6	Moderate	Good	Moderate	Default compression
lzma,6	Slow	Best	High	Maximum compression

Usage:

# No compression
borg create --compression none ::archive-name /data

# LZ4 (fast, good compression)
borg create --compression lz4 ::archive-name /data

# zstd level 3 (balanced, recommended)
borg create --compression zstd,3 ::archive-name /data

# zlib level 6 (default)
borg create --compression zlib,6 ::archive-name /data

# LZMA level 6 (best compression, slow)
borg create --compression lzma,6 ::archive-name /data

# Auto (Borg decides based on file type)
borg create --compression auto,zstd,3 ::archive-name /data

In Vorta:

Archives → Settings → Compression: zstd,3 or auto,lz4

Encryption Details

Encryption modes:

repokey mode:

Encryption key stored in repository config
Passphrase protects the key
Good for local repositories
If repository is copied, key goes with it

keyfile mode:

Encryption key stored in ~/.config/borg/keys/
Passphrase protects the key
Better for remote/untrusted storage
Must backup keyfile separately

Encryption algorithm:

Borg uses AES-256-CTR with HMAC-SHA256 for authenticated encryption.

Key management:

# Export key (critical backup!)
borg key export /path/to/repo key-backup.txt

# Import key (disaster recovery)
borg key import /path/to/repo key-backup.txt

# Change repository passphrase
borg key change-passphrase

8. Advanced Features

Repository Checking

Verify repository integrity:

# Quick check (repository structure)
borg check

# Full check (including archive metadata)
borg check --verify-data

# Repair repository (use with caution!)
borg check --repair

# Verify last N archives
borg check --last 5

Schedule regular checks:

# Monthly check via cron
0 3 1 * * borg check --repository /mnt/backup-drive/borg-repo

Repository Information

# Repository statistics
borg info

# Output:
Repository ID: 1a2b3c4d...
Location: /mnt/backup-drive/borg-repo
Encrypted: Yes (repokey)
Cache: /home/user/.cache/borg/1a2b3c4d
Security dir: /home/user/.config/borg/security/1a2b3c4d

                       Original size      Compressed size    Deduplicated size
All archives:              150.3 GB             95.2 GB             32.1 GB

                       Unique chunks         Total chunks
Chunk index:                  156234               423156

# Specific archive info
borg info ::myserver-2025-12-16_02:00:00

Append-Only Mode

Protect against ransomware by making repository append-only:

# Set repository to append-only
borg config /path/to/repo append_only 1

# Now:
# - Can create new archives
# - Cannot delete archives
# - Cannot modify existing archives

# Useful for automated backups to untrusted locations

Restricted SSH key:

On backup server, restrict key to append-only:

# In ~/.ssh/authorized_keys
command="borg serve --append-only --restrict-to-path /srv/borg-backups/laptop" ssh-ed25519 AAAA...

9. Performance Optimization

Tuning for Speed

Increase parallelism:

Borg uses threads for compression and chunking:

# Use more CPU cores (default: auto)
borg create --checkpoint-interval 1800 ::archive /data

# Tune threads via environment
export BORG_WORKERCOUNT=4  # Use 4 worker threads

Checkpoint interval:

For very large backups, save progress periodically:

# Create checkpoint every 30 minutes
borg create --checkpoint-interval 1800 ::archive /data

# If interrupted, resume from last checkpoint

Repository location:

Use SSD for repository (much faster than HDD)
Use local storage for best performance
Remote repos limited by network speed

Reducing Backup Size

Exclude unnecessary files:

borg create   --exclude '**/.cache'   --exclude '**/node_modules'   --exclude '**/__pycache__'   --exclude '**/venv'   --exclude '*.iso'   --exclude '*.dmg'   --exclude 'Downloads/'   ::archive /home

Exclude caches automatically:

# Honor CACHEDIR.TAG files
borg create --exclude-caches ::archive /data

# Create CACHEDIR.TAG in directories to exclude:
echo -e "Signature: 8a477f597d28d172789f06886806bc55\n# This is a cache directory" > /path/to/cache/CACHEDIR.TAG

Use compression:

# zstd,3 offers good balance
borg create --compression zstd,3 ::archive /data

Network Optimization (Remote Repos)

For slow connections:

# Limit upload bandwidth (in KiB/s)
borg create --remote-ratelimit 1024 ::archive /data  # 1 MB/s limit

Use SSH compression:

# Enable SSH compression for remote repos
borg create --rsh "ssh -C" ::archive /data

SSH multiplexing:

# In ~/.ssh/config
Host backup-server.example.com
    ControlMaster auto
    ControlPath ~/.ssh/control-%r@%h:%p
    ControlPersist 10m
    Compression yes

This keeps SSH connection open between Borg operations, reducing overhead.

10. Monitoring and Maintenance

Borgmatic for Automation

Borgmatic is a wrapper for Borg that adds scheduling and monitoring.

Install:

sudo apt install borgmatic
# Or: pip3 install borgmatic

Generate config:

# Generate sample config
borgmatic config generate

# Config location: /etc/borgmatic/config.yaml

Example config:

# /etc/borgmatic/config.yaml
location:
    source_directories:
        - /home
        - /etc
        - /var/log
    repositories:
        - /mnt/backup-drive/borg-repo
    exclude_patterns:
        - '**/.cache'
        - '**/node_modules'
        - '**/__pycache__'

retention:
    keep_daily: 7
    keep_weekly: 4
    keep_monthly: 12
    keep_yearly: 3

storage:
    compression: zstd,3
    encryption_passphrase: "your-secure-passphrase"

hooks:
    before_backup:
        - echo "Starting backup at $(date)"
    after_backup:
        - echo "Backup completed at $(date)"
    on_error:
        - echo "Backup failed!" | mail -s "Backup Error" [email protected]

Run borgmatic:

# Run backup
borgmatic

# Run with verbosity
borgmatic -v

# Run specific actions
borgmatic prune
borgmatic check

Schedule with systemd:

# Enable borgmatic timer
sudo systemctl enable --now borgmatic.timer

# Check status
sudo systemctl status borgmatic.timer

Health Monitoring

Check script:

#!/bin/bash
# /opt/scripts/borg-health-check.sh

export BORG_REPO="/mnt/backup-drive/borg-repo"
export BORG_PASSPHRASE="your-passphrase"

# Get last backup age
LAST_BACKUP=$(borg list --last 1 --format '{time}' 2>/dev/null)
LAST_BACKUP_EPOCH=$(date -d "$LAST_BACKUP" +%s)
NOW=$(date +%s)
AGE_HOURS=$(( (NOW - LAST_BACKUP_EPOCH) / 3600 ))

if [ $AGE_HOURS -gt 48 ]; then
    echo "WARNING: Last backup is $AGE_HOURS hours old!"
    # Send alert
    echo "Borg backup overdue: $AGE_HOURS hours" | mail -s "Backup Alert" [email protected]
    exit 1
else
    echo "OK: Last backup was $AGE_HOURS hours ago"
fi

# Check repository health
if borg check --last 1 2>&1 | grep -q "ERROR"; then
    echo "ERROR: Repository health check failed!"
    exit 1
fi

echo "All checks passed"
exit 0

Schedule health checks:

# Daily at 9 AM
0 9 * * * /opt/scripts/borg-health-check.sh

Conclusion

You now have a comprehensive understanding of BorgBackup + Vorta for efficient homelab backups.

Key Takeaways:

Efficiency: Deduplication saves 50-80% storage on typical data
Security: Strong encryption protects data at rest and in transit
Flexibility: Local, remote, or cloud storage backends
Reliability: Mature, battle-tested backup solution
Usability: Vorta makes Borg accessible via GUI

Your Next Steps:

Test restore procedures regularly
Set up off-site backups (3-2-1 rule)
Monitor backup success/failures
Document your backup strategy
Create disaster recovery runbook
Export and store encryption keys securely

Related Guides:

Restic + Backrest: Modern Backup Strategy for Homelabs
Syncthing: Peer-to-Peer File Synchronization
MinIO: Self-Hosted S3-Compatible Object Storage

Your data is now protected with enterprise-grade deduplicating backups!

Guide Version: 1.0 Last Updated: December 2025 Estimated Read Time: 35-45 minutes Estimated Implementation Time: 50 minutes

Created for homelabbing.io - AI-Forward Homelab Resource Platform