Comment on

NuXCOM_90Percent@lemmy.zip ⁨3⁩ ⁨weeks⁩ ago

• tal@olio.cafe ⁨3⁩ ⁨weeks⁩ ago

  I would generally argue that rsync is not a backup solution.

  Yeah, if you want to use rsync, you’re probably better-off using something like rdiff-backup, which makes use of rsync to generate backups and store them efficiently.

  rsync: one-way synchronization

  unison: bidirectional synchronization

  git: synchronization of text files with good interactive merging.

  rdiff-backup: rsync-based backups. I used to use this and moved to restic, as the backupninja target for rdiff-backup has kind of fallen into disrepair.

  source

  • melfie@lemy.lol ⁨3⁩ ⁨weeks⁩ ago

    Having a synced copy elsewhere is not an adequate backup and snapshots are pretty important. I recently had RAM go bad and my most recent backups had corrupt data, but having previous snapshots saved the day.

    source

    • melfie@lemy.lol ⁨3⁩ ⁨weeks⁩ ago

      Don’t understand the downvotes. This is the type of lesson people have learned from losing data and no sense in learning it the hard way yourself.

      source

      • tomenzgg@midwest.social ⁨2⁩ ⁨weeks⁩ ago

        How would you pin down something like this? If it happened to me, I expect I just wouldn’t understand what’s going on.

        source

        • -> View More Comments
  • koala@programming.dev ⁨3⁩ ⁨weeks⁩ ago

    Beware rdiff-backup. It certainly does turn rsync (not a backup program) into a backup program.

    However, I used rdiff-backup in the past and it can be a bit problematic. If I remember correctly, every “snapshot” you keep in rdiff-backup uses as many inodes as the thing you are backing up. (Because every “file” in the snapshot is either a file or a hard link to an identical version of that file in another snapshot.) So this can be a problem if you store many snapshots of many files.

    But it does make rsync a backup solution; a snapshot or a redundant copy is very useful, but it’s not a backup.

    (OTOH, rsync is still wonderful for large transfers.)

    source

    • tal@olio.cafe ⁨3⁩ ⁨weeks⁩ ago

      Because every “file” in the snapshot is either a file or a hard link to an identical version of that file in another snapshot.) So this can be a problem if you store many snapshots of many files.

      I think that you may be thinking of rsnapshot rather than rdiff-backup which has that behavior; both use rsync.

      But I’m not sure why you’d be concerned about this behavior.

      Are you worried about inode exhaustion on the destination filesystem?

      source

      • koala@programming.dev ⁨3⁩ ⁨weeks⁩ ago

        Huh, I think you’re right.

        Before discovering ZFS, my previous backup solution was rdiff-backup. I have memories of it being problematic for me, but I may be wrong in my remembering of why it caused problems.

        source
  • neidu3@sh.itjust.works ⁨3⁩ ⁨weeks⁩ ago

    +1 for rfiff-backup. Been usinit for 20 years or so, and I love it.

    source
• Colloidal@programming.dev ⁨3⁩ ⁨weeks⁩ ago

  Borg gang represent!

  source
• non_burglar@lemmy.world ⁨3⁩ ⁨weeks⁩ ago

  I use rsync and a pruning script in crontab on my NFS mounts. I’ve tested it numerous times breaking containers and restoring them from backup. It works great for me at home because I don’t need anything older than 4 monthly, 4 weekly, and 7 daily backups.

  However, in my job I prefer something like bacula. The extra features and granularity of restore options makes a world of difference when someone calls because they deleted prod files.

  source

  • tal@olio.cafe ⁨3⁩ ⁨weeks⁩ ago

    I don’t know if there’s a term for them, but Bacula (and I think AMANDA might fall into this camp, but I haven’t looked at it in ages) are oriented more towards…"institutional” backup. Like, there’s a dedicated backup server, maybe dedicated offline media like tapes, the backup server needs to drive the backup, etc).

    There are some things that rsnapshot, rdiff-backup, duplicity, and so forth won’t do.

    • At least some of them (rdiff-backup, for one) won’t dedup files with different names. If a file is unchanged, it won’t use extra storage, but it won’t identify different identical files at different locations. This usually isn’t all that important for a single host, other than maybe if you rename files, but if you’re backing up many different hosts, as in an institutional setting, they likely files in common. They aren’t intended to back up multiple hosts to a single, shared repository.

    • Pull-only. I think that it might be possible to run some of the above three in “pull” mode, where the backup server connects and gets the backup, but where they don’t have the ability to write to the backup server. This may be desirable if you’re concerned about a host being compromised, but not the backup server, since it means that an attacker can’t go dick with your backups. Think of those cybercriminals who encrypt data at a company and wipe other copies and then demand a ransom for an unlock key. But the “institutional” backup systems are going to be aimed at having the backup server drive all this, and have the backup server have access to log into the individual hosts and pull the backups over.

    • Dedup for non-identical files. Note that restic can do this. While files might not be identical, they might share some common elements, and one might want to try to take advantage of that in backup storage.

    • rdiff-backup and rsnapshot don’t do encryption (though duplicity does). If one intends to use storage not under one’s physical control (e.g. “cloud backup"), this might be a concern.

    • No “full” backups. Some backup programs follow a scheme where one periodically does a backup that stores a full copy of the data, and then stores “incremental” backups from the last full backup. All rsnapshot, rdiff-backup, and duplicity are always-incremental, and are aimed at storing their backups on a single destination filesystem. A split between “full” and “incremental” is probably something you want if you’re using, say, tape storage and having backups that span multiple tapes, since it controls how many pieces of media you have to dig up to perform a restore.

    • I don’t know how Bacula or AMANDA handle it, if at all, but if you have a DBMS like PostgreSQL or MySQL or the like, it’s may be constantly receiving writes. This means that you can’t get an atomic snapshot of the database, which is critical if you want to be reliably backing up the storage. I don’t know what the convention is here, but I’d guess either using filesystem-level atomic snapshot support (e.g. btrfs) or requiring the backup system to be aware of the DBMS and instructing it to suspend modification while it does the backup. rsnapshot, rdiff-backup, and duplicity aren’t going to do anything like that.

    I’d agree that using the more-heavyweight, “institutional” backup programs can make sense for some use cases, like if you’re backing up many workstations or something.

    source