Wat je vooraf regelt

Een back-up die elke keer de volledige datamap opnieuw wegschrijft, kost je op een gemiddelde server meer schijfruimte dan de productiedata zelf. rsync lost dat op: het kopieert alleen wat werkelijk veranderd is, lokaal of over ssh.

Dit artikel zet een back-upschema op met rsync 3.2.x op Linux, met incrementele snapshots via hard links. Je hebt root of sudo nodig op de bron, ssh-toegang tot het doel, en rsync aan beide kanten. Op Debian 12 en Ubuntu 24.04 staat rsync 3.2.7 standaard in de repository; op RHEL 9 en afgeleiden is dat 3.2.2.

Controleer eerst je versie, want de beschikbare opties verschillen per release:

```bash rsync --version ```

Alles hieronder werkt op 3.1 en hoger. Gebruik je iets ouderdoms, dan ontbreken `--info` en de nieuwere `--outbuf`-opties, maar de kern blijft gelijk.

Wat je vooraf regelt

Een back-up is alleen iets waard als hij terug te zetten is. Dat klinkt als een open deur, tot je op zoek bent naar een bestand dat drie weken geleden is overschreven en ontdekt dat je schema alleen de laatste versie bewaart.

Daarom bouwen we een reeks datumgestempelde mappen die elk volledig lijken, maar onder water dezelfde data delen. Dat is het werk van `--link-dest`.

Maak eerst de doelstructuur aan. In dit voorbeeld staat de back-up op een aparte mount, niet op dezelfde schijf als de data die je beschermt. Een back-up op dezelfde disk is geen back-up, het is een gok.

```bash sudo mkdir -p /mnt/backup/rsync sudo chown root:root /mnt/backup/rsync sudo chmod 700 /mnt/backup/rsync ```

De rechten zijn bewust strak. Een back-upmap die voor iedereen leesbaar is, is een datalek met een nette mapnaam.

De stappen

1. Test je opdracht met een dry-run.

Nooit direct schrijven. `-n` laat rsync vertellen wat het zou doen, zonder één byte aan te raken. Dit is de belangrijkste veiligheidsklep in het hele verhaal: een verkeerd geplaatste slash of een omgekeerde bron en doel wist je data, en rsync vraagt niet om bevestiging.

```bash sudo rsync -avn --delete /srv/data/ /mnt/backup/rsync/current/ ```

Let op de trailing slash achter `/srv/data/`. Die betekent: de inhoud van deze map. Zonder slash kopieert rsync de map zelf als submap. Dit is de klassieke valkuil, en het verschil is één teken.

2. Voer de eerste, volledige synchronisatie uit.

De eerste run kopieert alles. Dat duurt lang en kost de volle schijfruimte van je dataset. Reken daarop voordat je dit op een productieserver loslaat tijdens kantooruren.

```bash sudo rsync -av --delete /srv/data/ /mnt/backup/rsync/current/ ```

`-a` staat voor archive mode en bewaart permissies, eigenaarschap, tijdstempels en symlinks. `-v` geeft uitvoer per bestand. `--delete` verwijdert bestanden op het doel die op de bron niet meer bestaan — precies wat je wilt bij een spiegel, gevaarlijk als je bron per ongeluk leeg is.

3. Bouw de incrementele snapshot met `--link-dest`.

Hier wordt het interessant. Elke nieuwe snapshot verwijst voor ongewijzigde bestanden naar de vorige via een hard link. Eén fysieke kopie, meerdere zichtbare versies. Een snapshot van een dataset van 500 GB waarin 2 GB is gewijzigd, kost je 2 GB extra.

```bash DAG=$(date +%Y-%m-%d) sudo rsync -av --delete \ --link-dest=/mnt/backup/rsync/current \ /srv/data/ /mnt/backup/rsync/$DAG/ ```

Het pad bij `--link-dest` moet absoluut zijn. Een relatief pad wordt stilzwijgend genegeerd en dan krijg je een volledige kopie in plaats van links. Je merkt het pas als de schijf vol zit.

4. Werk de `current`-pointer bij.

De volgende snapshot moet naar de zojuist gemaakte verwijzen. Een symlink doet dat zonder de data te verplaatsen.

```bash sudo rm -f /mnt/backup/rsync/current sudo ln -s /mnt/backup/rsync/$DAG /mnt/backup/rsync/current ```

Vergeet je deze stap, dan linkt elke snapshot naar dezelfde oude basis en groeit de schijfruimte alsnog. De fout is onzichtbaar tot je `du` draait.

5. Zet het geheel in een script.

Handmatig draaien werkt één keer. Een script met logging werkt jaren. Zet dit in `/usr/local/bin/rsync-backup.sh`:

```bash #!/bin/bash set -euo pipefail

BRON="/srv/data/" DOEL="/mnt/backup/rsync" DAG=$(date +%Y-%m-%d) LOG="/var/log/rsync-backup.log"

mkdir -p "$DOEL/$DAG"

rsync -av --delete \ --link-dest="$DOEL/current" \ --exclude='*.tmp' \ --exclude='.cache/' \ "$BRON" "$DOEL/$DAG/" >> "$LOG" 2>&1

rm -f "$DOEL/current" ln -s "$DOEL/$DAG" "$DOEL/current"

echo "$(date '+%Y-%m-%d %H:%M:%S') back-up voltooid: $DAG" >> "$LOG" ```

`set -euo pipefail` stopt het script bij de eerste fout in plaats van vrolijk door te gaan met een halfvoltooide back-up. De `--exclude`-regels schelen je op een drukke server al snel tientallen gigabytes aan tijdelijke rommel die je toch nooit terugzet.

```bash sudo chmod +x /usr/local/bin/rsync-backup.sh ```

6. Plan het script met cron.

Dagelijkse back-up om 02:30, wanneer de server het rustigst is.

```bash sudo crontab -e ```

Voeg toe:

``` 30 2 * /usr/local/bin/rsync-backup.sh ```

Wil je `--backup` en `--backup-dir` gebruiken om overschreven bestanden apart te bewaren in plaats van via snapshots, dan kan dat:

```bash rsync -av --delete \ --backup --backup-dir="/mnt/backup/rsync/overschreven/$(date +%Y-%m-%d)" \ /srv/data/ /mnt/backup/rsync/current/ ```

Dit is eenvoudiger dan snapshots, maar je krijgt geen volledige point-in-time-versie van de hele map. Kies op basis van wat je terug moet kunnen halen, niet op basis van wat het minste werk is om op te zetten.

7. Beperk de bewaartermijn.

Snapshots groeien door. Ruim oude mappen op, anders loopt de mount vol en faalt de volgende back-up zonder dat iemand het merkt.

```bash find /mnt/backup/rsync -maxdepth 1 -type d -name '20*' -mtime +30 -exec rm -rf {} \; ```

Dertig dagen is een redelijke start. Wat je hier opgeeft, is de mogelijkheid om iets van twee maanden terug te vinden. Voor sommige data is dat prima, voor andere niet.

8. Test het herstel.

Een back-up die nooit is teruggezet, is een aanname. Pak een bestand uit een oude snapshot en vergelijk het met de bron.

```bash sudo rsync -avn /mnt/backup/rsync/2024-04-05/srv/data/ /tmp/herstel-test/ ```

Draai het daarna zonder `-n` en open het bestand. Doe dit één keer per kwartaal, niet één keer bij het opzetten.

Verificatie

Controleer of de snapshots inderdaad hard links delen en niet allemaal losse kopieën zijn:

```bash du -sh /mnt/backup/rsync/*/ df -h /mnt/backup ```

Zie je bij drie snapshots van een dataset van 100 GB slechts kleine onderlinge verschillen, dan werken de links. Wijzen alle mappen naar ongeveer dezelfde grootte als de bron, dan is `--link-dest` niet aangekomen en heb je drie volledige kopieën.

Controleer de laatste run in het log:

```bash tail -n 20 /var/log/rsync-backup.log ```

Veelgestelde problemen

`rsync: failed to set times on ... Operation not permitted` Je draait rsync zonder root, of het doelbestandssysteem ondersteunt geen tijdstempels. Draai met sudo, of voeg `--no-times` toe als het doel dat echt niet kan.

Schijf vol ondanks `--link-dest` Meestal een relatief pad bij `--link-dest`, of de `current`-symlink is niet bijgewerkt. Controleer met `ls -la /mnt/backup/rsync/current` waar hij naartoe wijst.

`--delete` gooit bestanden weg die je wilde houden Dat is wat `--delete` doet. Wil je dat niet, gebruik dan `--backup --backup-dir` zodat overschreven bestanden ergens belanden. Of laat `--delete` helemaal weg en accepteer dat verwijderde bestanden in je back-up blijven staan.

Een back-upschema dat je nooit test, is een abonnement op een verrassing. De rekening komt op het moment dat je hem het minst kunt gebruiken.