Set Up Restic + S3-Compatible Storage for Secure, Automated Linux Backups

Why Restic Is a Smart Backup Choice in 2026

Backups are easy to postpone until the day you need them. Restic is a modern backup tool that helps you avoid that trap by making backups fast, encrypted by default, and storage-efficient through deduplication. It works especially well with S3-compatible object storage (such as MinIO, Wasabi, Backblaze B2 S3, Cloudflare R2 via S3 API, and many NAS appliances), giving you an offsite backup that is both resilient and scalable.

In this tutorial, you will install Restic on Linux, connect it to an S3-compatible bucket, create a secure backup policy, automate it with systemd, and verify that restores work. The steps focus on a practical, production-friendly setup you can run on a server or workstation.

Prerequisites

Before you start, you need: a Linux machine (Debian/Ubuntu, RHEL/Rocky/Alma, or similar), credentials for an S3-compatible bucket (access key, secret key, endpoint URL, and bucket name), and enough permissions to read the directories you want to back up. If you are backing up system paths like /etc and /var, you will likely run Restic as root.

Step 1: Install Restic

On Ubuntu/Debian, you can install Restic from the package manager:

sudo apt update && sudo apt install -y restic

On RHEL/Rocky/Alma, Restic is often available via EPEL:

sudo dnf install -y epel-release && sudo dnf install -y restic

After installation, confirm the version:

restic version

Step 2: Define Environment Variables for S3 Storage

Restic reads S3 credentials from environment variables. Create a root-only environment file so secrets are not exposed in shell history:

sudo install -m 0600 /dev/null /etc/restic.env

Edit the file:

sudo nano /etc/restic.env

Add the following (adjust values for your provider):

AWS_ACCESS_KEY_ID=YOUR_ACCESS_KEY

AWS_SECRET_ACCESS_KEY=YOUR_SECRET_KEY

AWS_DEFAULT_REGION=us-east-1

RESTIC_REPOSITORY=s3:https://s3.example.com/my-restic-bucket

RESTIC_PASSWORD=Use-A-Long-Unique-Passphrase

If you are using a custom endpoint (common with MinIO and many S3-compatible services), the repository URL format is important: s3:https://ENDPOINT/BUCKET. Keep the password strong; it encrypts your data, and there is no recovery if you lose it.

Step 3: Initialize the Restic Repository

Load the environment and initialize the repository:

sudo -E bash -c 'set -a; source /etc/restic.env; set +a; restic init'

This creates the repository structure in your bucket. If initialization fails, double-check your endpoint URL, bucket name, and credentials. Also ensure the bucket exists and the credentials have permission to list, put, and delete objects.

Step 4: Run Your First Backup

Start with a clear, high-value set of directories. For example, backing up system configuration and user data:

sudo -E bash -c 'set -a; source /etc/restic.env; set +a; restic backup /etc /home --exclude /home/*/.cache'

Restic will scan files, upload only new chunks, and output a snapshot ID. The next backups are usually much faster thanks to deduplication.

Step 5: Verify Snapshots and Test a Restore

List snapshots to confirm your backup history:

sudo -E bash -c 'set -a; source /etc/restic.env; set +a; restic snapshots'

To restore safely, do a test restore to a temporary directory:

sudo mkdir -p /restore-test

sudo -E bash -c 'set -a; source /etc/restic.env; set +a; restic restore latest --target /restore-test'

Open a few restored files and confirm permissions and content. A backup you never tested is not a backup; it is a guess.

Step 6: Add Retention and Repository Maintenance

Without retention rules, storage can grow quietly. A common policy keeps daily backups for a week, weekly backups for a month, and monthly backups for a year:

sudo -E bash -c 'set -a; source /etc/restic.env; set +a; restic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune'

Also schedule an integrity check occasionally (weekly or monthly):

sudo -E bash -c 'set -a; source /etc/restic.env; set +a; restic check'

Step 7: Automate Backups with systemd

Create a service unit that loads the environment file. Save this as /etc/systemd/system/restic-backup.service:

[Unit]

Description=Restic Backup

Wants=network-online.target

After=network-online.target

[Service]

Type=oneshot

EnvironmentFile=/etc/restic.env

ExecStart=/usr/bin/restic backup /etc /home --exclude /home/*/.cache

ExecStartPost=/usr/bin/restic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune

[Install]

WantedBy=multi-user.target

Now create a timer at /etc/systemd/system/restic-backup.timer:

[Unit]

Description=Run Restic Backup Daily

[Timer]

OnCalendar=daily

Persistent=true

[Install]

WantedBy=timers.target

Enable and start the timer:

sudo systemctl daemon-reload

sudo systemctl enable --now restic-backup.timer

To confirm it will run, check timers and the last run logs:

systemctl list-timers --all | grep restic

journalctl -u restic-backup.service --no-pager -n 100

Common Troubleshooting Tips

If you see authentication errors, re-check the environment file permissions and values, and confirm your storage provider’s S3 endpoint URL. If backups are slow, review exclusions (caches and build directories can explode in size) and consider backing up database dumps instead of live database directories. If you are backing up a server over a flaky connection, Restic’s incremental design helps, but you should still schedule backups during quieter hours.

With Restic plus S3-compatible storage, you get encrypted offsite backups, predictable automation, and a restore process that is straightforward. Once your daily job is stable, the next best improvement is to document a full recovery runbook and test it quarterly.

Set Up Incremental Backups on Linux with Restic and S3-Compatible Storage (Ransomware-Resistant)

Why Restic + S3-Compatible Storage Is a Modern Backup Strategy

If you are still copying folders to an external drive or relying on a single NAS, you are one accident, hardware failure, or ransomware event away from a bad day. A current, practical approach is to use incremental, encrypted backups pushed to S3-compatible object storage (such as MinIO, Backblaze B2 S3, Wasabi, or many private cloud providers). This tutorial walks you through implementing that setup on Linux using Restic, a fast backup tool that deduplicates data, encrypts everything, and supports snapshots you can restore from in minutes.

What You Will Build

By the end of this guide, your Linux server or workstation will automatically create incremental backups to an S3 bucket, keep only a sensible number of snapshots, and run on a schedule using systemd. The result is a backup workflow that is efficient (deduplication), secure (client-side encryption), and resilient (object storage with versioning and immutability options, depending on provider).

Prerequisites

You need a Linux machine with sudo access, an S3-compatible endpoint (provider URL, access key, secret key), and a bucket you can write to. Make sure the system clock is correct (NTP enabled) because snapshot timestamps matter for troubleshooting. If you can, enable bucket-level features like versioning or object lock on the storage side for extra protection.

Step 1: Install Restic

On Debian/Ubuntu, you can install from the repository, although it may not always be the newest version:

sudo apt update && sudo apt install -y restic

On RHEL/CentOS/Fedora systems, check your distro packages or download a current release from Restic’s official GitHub releases. The key point is to use a recent version to benefit from performance and compatibility improvements.

Step 2: Set Environment Variables Securely

Restic reads credentials from environment variables. Create a root-only file to store them. This keeps secrets out of shell history and scripts.

sudo mkdir -p /etc/restic
sudo nano /etc/restic/restic-env

Add values like these (adjust for your provider):

export AWS_ACCESS_KEY_ID="YOUR_ACCESS_KEY"
export AWS_SECRET_ACCESS_KEY="YOUR_SECRET_KEY"
export RESTIC_REPOSITORY="s3:https://s3.example.com/my-linux-backups"
export RESTIC_PASSWORD="Use-A-Long-Unique-Passphrase"

Lock the permissions down:

sudo chmod 600 /etc/restic/restic-env

Step 3: Initialize the Backup Repository

Load the environment file and initialize the repository. This creates the encrypted Restic structure in your bucket.

sudo -i
source /etc/restic/restic-env
restic init

If you get TLS or endpoint errors, verify the S3 URL format and whether your provider requires a region setting. For some S3-compatible services, you may also need to export AWS_DEFAULT_REGION, even if it is a placeholder value.

Step 4: Create an Exclude File (Recommended)

Backups get faster and cleaner when you avoid caches and temporary files. Create an exclude file:

nano /etc/restic/excludes.txt

Example entries:

/proc
/sys
/dev
/run
/tmp
/var/tmp
**/.cache

Step 5: Run Your First Backup

Start with important directories such as /etc, home folders, and application data. For servers, you might also include /var/lib for databases or container volumes (with proper application-aware procedures).

source /etc/restic/restic-env
restic backup /etc /home --exclude-file /etc/restic/excludes.txt

Then confirm a snapshot was created:

restic snapshots

Step 6: Set a Smart Retention Policy

Incremental backups are only useful if you keep enough history without growing storage forever. A common policy is to keep daily snapshots for a week, weekly for a month, and monthly for a year.

restic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune

The --prune flag removes unneeded data chunks after snapshots are forgotten, keeping storage usage under control.

Step 7: Automate Backups with systemd

Create a service that runs one backup job. Save this as /etc/systemd/system/restic-backup.service:

[Unit]
Description=Restic Backup to S3
After=network-online.target
Wants=network-online.target

[Service]
Type=oneshot
EnvironmentFile=/etc/restic/restic-env
ExecStart=/usr/bin/restic backup /etc /home --exclude-file /etc/restic/excludes.txt
ExecStartPost=/usr/bin/restic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune

[Install]
WantedBy=multi-user.target

Now create a timer at /etc/systemd/system/restic-backup.timer:

[Unit]
Description=Nightly Restic Backup

[Timer]
OnCalendar=*-*-* 02:00:00
Persistent=true

[Install]
WantedBy=timers.target

Enable and start the timer:

sudo systemctl daemon-reload
sudo systemctl enable --now restic-backup.timer
systemctl list-timers | grep restic

Step 8: Test Restores (Do Not Skip This)

A backup is only proven when you restore from it. To restore a single file, first browse snapshots:

source /etc/restic/restic-env
restic snapshots
restic ls latest

Restore a directory to a safe location:

mkdir -p /tmp/restic-restore
restic restore latest --target /tmp/restic-restore --include /etc

For quick checks, you can also run integrity verification occasionally:

restic check

Practical Security Notes

Treat the Restic password like a master key. Store it in a password manager, not only in a file. If your S3 provider supports object lock (WORM) or immutable retention, consider enabling it for the backup bucket to reduce the risk of backup deletion during an attack. Finally, keep at least one additional backup copy or bucket replication in a different region or account for true defense in depth.

Popular Posts

Install Ollama and Open WebUI on Ubuntu 24.04 with NVIDIA GPU Acceleration (Step-by-Step)

Install Ollama + Open WebUI on Ubuntu 24.04 with NVIDIA GPU Acceleration (Step-by-Step)

Install a Local AI Chatbot on Ubuntu 24.04 with Ollama and Open WebUI (Step-by-Step)

Trending Now

Recovering from Btrfs Boot Failures Using GUI Tools on Fedora

By the end of this guide the reader will be able to identify a Btrfs‑based Fedora installation, boot from a live USB, list and restore snapshots using the graphical utilities btrfs‑assistant and snapper, and verify that the system returns to a functional state without resorting to the command line. Understanding the Btrfs Layout Used by Fedora Fedora Workstation and Fedora KDE install the root filesystem as a single Btrfs partition that contains two default sub‑volumes. One sub‑volume holds the traditional “/” hierarchy, while the second is dedicated to /var/lib/machines . The latter exists to keep container images out of snapshot operations; it remains empty on systems that do not run virtual machines. Because Btrfs stores data in sub‑volumes rather than separate partitions, a snapshot captures the state of an entire sub‑volume at a point in time. The installer (Anaconda) automatically registers these sub‑volumes with the snapper service. Snapper maintains a series of read‑only ...