Learn Rsync - Ecosystem, Alternatives & Final Reflection

#Introduction

This is the final episode of our 23-episode journey. Before closing, we need to answer the most honest question: is rsync always the right choice? No. The synchronization and backup ecosystem has several strong candidates, each with a different philosophy — and choosing the wrong one means paying unnecessary costs.

In episode 22 we compare rsync with scp/rcp, rclone, restic, borg, and lsyncd, map out when to choose each, then summarize the whole series in a production checklist you can turn into a working document.

#Ecosystem Comparison

#scp/rcp

• Philosophy: simple file copying between machines — no synchronization.
• Strengths: familiar, available everywhere, enough for a one-off copy.
• Trade-offs: always sends whole files, no delta-transfer, no good resume. For repeated synchronization, rsync always wins.

#rsync

• Philosophy: one-way synchronization based on delta-transfer — mirror, backup, migration.
• Strengths: bandwidth efficient, safe resume, flag flexibility, output is an ordinary directory.
• Trade-offs: one-way, no built-in dedup/at-rest encryption, no live sync.

#rclone

• Philosophy: "rsync for the cloud" — synchronization to object storage (S3, B2, GCS, etc.).
• Strengths: broad cloud provider support, encrypt remotes, built-in hash checksums.
• Trade-offs: not a managed backup (no snapshot management), targets limited to cloud/remote.

#restic

• Philosophy: managed backup with client-side dedup + authenticated encryption.
• Strengths: deduplicated repository, encryption, snapshot management, easy restore.
• Trade-offs: snapshots can't be read directly without the tool; requires a managed repository.

#borg

• Philosophy: managed backup with chunk-level dedup + integrated compression.
• Strengths: best space ratio, built-in rotation (borg prune), zstd/lz4 compression.
• Trade-offs: one host-one repository (less suited for many-to-one across machines), and like restic — can't be read directly.

#lsyncd

• Philosophy: live sync — watches filesystem changes and runs rsync in real-time.
• Strengths: the destination directory stays synced almost instantly, using rsync underneath.
• Trade-offs: not a backup — if the source is deleted, the destination is deleted too; needs a continuously running daemon.

Live sync           Synchronization          Managed backup
lsyncd     rsync   rclone        restic   borg
 <-- real-time --> <-- delta/mirror --> <-- dedup+enc -->

#When to Choose Which

#Choose rsync If...

• You need simple synchronization & mirroring whose output is an ordinary directory.
• Daily backups with --link-dest rotation (episodes 8-9) — cheap, proven, monitored.
• Server migration (episode 11) and one-way deployment.

#Choose rclone If...

• Your target is cloud object storage (S3, B2, GCS).
• You need built-in encrypt remotes or cross-provider hash checksums.

#Choose restic/borg If...

• You need dedup + authenticated encryption and tool-managed snapshots.
• Sensitive data that must be safe at rest and in the cloud.
• restic for many-to-one across machines; borg for the best space ratio on a single host.

#Choose lsyncd If...

• The need is live sync between servers (e.g. web assets), not backup.
• You accept that source deletions replicate to the destination too.

#Recap of Episodes 0-21

Our journey in short:

• Phase 1 (0-2): Prerequisites, history, architecture — why and how rsync works.
• Phase 2 (3-7): Local syntax, remote mode, core flags, filters, batch & partial — basic operations.
• Phase 3 (8-12): Incremental/snapshot backups, rotation, cron, migration, throttle — data operations.
• Phase 4 (13-16): CVEs & security, SSH hardening, ACL/xattr/SELinux, dry-run & verification — reliability.
• Phase 5 (17-20): 3.4.x, performance tuning, alternatives, monitoring — quality and production.
• Phase 6 (21-22): Roadmap & community, comparison & reflection — context beyond the code.

#The Production Checklist

You can use this document directly before an rsync backup goes into production:

• Version ≥3.4.4: rsync --version; the distro changelog backports all CVEs (episodes 13, 17).
• Dry-run first: rsync -avhn -i before every important operation; review the output (episode 16).
• --link-dest snapshots: daily/weekly/monthly rotation running, consistent --delete/--delete-excluded (episodes 8-9).
• Cron + logs: crontab schedule, >> /var/log/rsync.log 2>&1, flock against overlaps (episode 10).
• SSH hardening: ed25519 key, BatchMode=yes, restrict, rsync-only account (episode 14).
• Daemon security: if using rsyncd — firewall, chroot, secrets file 600, or an SSH tunnel (episodes 13-14).
• Exit code monitoring: 0 = OK, 23/24 = partial; alerts wired to Prometheus/Zabbix (episode 20).
• Fidelity: -A, -X, -H, --numeric-ids for migration; restorecon if SELinux (episodes 11, 15).
• Throttle: --bwlimit + nice/ionice so production isn't disturbed (episode 12).
• Restore drill: periodically test restoring one file from a snapshot — a backup without a tested restore is worthless (episode 20).

#Official Learning Resources

• rsync.samba.org: the man page and official documentation.
• download.samba.org/pub/rsync/NEWS: changelog, CVEs, and releases.
• git.samba.org/rsync.git & the GitHub mirror: source code.
• The rsync mailing list: questions and answers with users & developers.
• Continue with the next series: learn-restic (encrypted deduplicated backup), learn-borg-backup (borg), learn-cronjob (automation), learn-nas/learn-linuxfs (storage), and learn-proxmox-backup-server (enterprise backup).

#Closing

Key takeaways:

• scp/rcp for one-off copies; rsync for synchronization & mirroring; rclone for the cloud; restic/borg for managed backups; lsyncd for live sync.
• Choose based on workload needs, not hype.
• 23 episodes built the foundation: prerequisites → architecture → operations → data → security → production.
• The production checklist is the bridge from "can run it" to "production ready".

Congratulations, you've completed Learn Rsync! From prerequisites and basic syntax to rotating snapshots and the production checklist, you now have what it takes to make rsync part of your infrastructure. Technology will keep evolving — keep your version patched, test restores regularly, and monitor exit codes every night. The 23-episode journey is complete, but your rsync adventure has only just begun!