Linux commando: rsync

Vroeg of laat moet je als Linux-gebruiker veel bestanden van de ene plek naar de andere kopieren: een website naar een server, een home-map naar een backupschijf, een project tussen twee machines. Je kunt het met cp of scp doen, maar zodra je diezelfde kopie een tweede keer draait, voel je de verspilling, want ze kopieren elke keer alles opnieuw. rsync is precies daarvoor gemaakt. Het kijkt naar wat er al op de bestemming staat en verstuurt alleen de delen die veranderd zijn, wat het de stille ruggengraat maakt van backups, deployments en servermigraties over de hele wereld.

2. Waar komt de naam vandaan?

De naam rsync is een samentrekking van remote (op afstand) en sync (kort voor synchronise, synchroniseren). Het werd vanaf het begin ontworpen om bestanden gesynchroniseerd te houden tussen een lokale en een externe machine, en de naam zegt precies dat.

rsync  =  Remote SYNC

Het verving een ouder, dommer gereedschap genaamd rcp ("remote copy"), dat hele bestanden over het netwerk kopieerde zonder enige slimheid. De extra letters in rsync zijn een kleine belofte: dit is niet zomaar een kopie op afstand, het is een synchronisatie op afstand die let op wat er al is. De naam is bijna dertig jaar blijven hangen omdat hij het gereedschap nog steeds perfect beschrijft.

4. Eenvoudige toepassingen

4.1 De eenvoudigst mogelijke synchronisatie

Geef rsync een bron, een bestemming en de optie -a, en het kopieert de bron naar de bestemming. In de voorbeelden hieronder is de regel die met $ begint wat je typt; de regels eronder zijn wat rsync teruggeeft.

$ rsync -a project/ /backup/project/

Er wordt niets afgedrukt, wat de normale Unix-manier is om "het is gelukt" te zeggen. De optie -a (kort voor archive, archief) is de optie die je bijna elke keer zult gebruiken. Het betekent "kopieer recursief en houd alles zoals het is": submappen, rechten, tijdstempels en symbolische links. Behandel rsync -a voorlopig als het dagelijkse startpunt; sectie 5 opent het verder.

4.2 De regel van de afsluitende schuine streep

Dit is de ene regel over rsync die iedereen moet leren, want hij verandert stilletjes waar je bestanden terechtkomen. Een afsluitende schuine streep op de bron betekent "de inhoud van deze map". Geen afsluitende schuine streep betekent "deze map zelf".

$ rsync -a src/ dst/     # copies the CONTENTS of src into dst
$ rsync -a src  dst/     # copies the DIRECTORY src, giving dst/src

Je kunt het jezelf in een paar seconden bewijzen:

$ rsync -a src/ dst1/
$ ls dst1
a.txt  b.txt  sub

$ rsync -a src dst2/
$ ls dst2
src

Het eerste commando vult dst1 met de bestanden die in src zaten. Het tweede plaatst src als een submap in dst2. Wanneer een backupscript op mysterieuze wijze backup/project/project oplevert, is een ontbrekende of extra schuine streep bijna altijd de reden. De schuine streep op de bestemming maakt niet op dezelfde manier uit; het is de schuine streep op de bron die de indeling bepaalt.

Hier is een valkuil waar ik zelf in trapte, toen ik mijn eigen home-map naar een externe schijf backupte, en hij kan een backup stilletjes ruineren. Het is verleidelijk om naar een jokerteken te grijpen in plaats van een afsluitende schuine streep, en dat is precies wat ik deed:

$ rsync -av /home/peter/* /media/peter/writable/    # looks right, is not

Het probleem is dat de * wordt uitgevouwen door de shell, voordat rsync ook maar draait, en een kale * matcht geen namen die met een punt beginnen. Dus elk verborgen bestand en elke verborgen map in de home-map (.bashrc, .ssh, .config, .gnupg) wordt stilletjes weggelaten. Je kunt het zien gebeuren met echo:

$ echo /home/peter/*
/home/peter/Documents /home/peter/notes.txt     # notice: no .bashrc, no .ssh

Wat dit gevaarlijk maakt, is dat het lijkt alsof het gelukt is. De zichtbare bestanden en mappen komen prima over, en verborgen bestanden binnen die mappen gaan ook mee, want rsync daalt af in elke map die de shell wel heeft doorgegeven. Alleen de verborgen bestanden op het bovenste niveau verdwijnen, en dat zijn precies de bestanden met je instellingen, sleutels en inloggegevens. In mijn geval eindigde de externe schijf met al mijn documenten maar geen enkele van mijn configuratiebestanden, en ik merkte het pas later. De oplossing is de vorm met afsluitende schuine streep, die de map zelf aan rsync doorgeeft en het de hele boom laat doorlopen, verborgen bestanden en al:

$ rsync -av /home/peter/  /media/peter/writable/   # copies EVERYTHING, dotfiles included

Wanneer je "een hele map" kopieert, geef dan de voorkeur aan source/ boven source/*. De afsluitende schuine streep vraagt rsync om de bestanden te kiezen; het jokerteken vraagt de shell, en de shell verbergt je verborgen bestanden.

4.3 Kijken voor je springt: -v en -n

Omdat rsync kan verwijderen en overschrijven, is het de moeite waard om te zien wat het gaat doen voordat het het doet. Twee opties maken het spraakzaam en voorzichtig.

De optie -v (kort voor verbose, uitgebreid) somt elk bestand op terwijl het wordt overgedragen:

$ rsync -av src/ dst/
sending incremental file list
./
a.txt
b.txt
sub/
sub/c.txt

sent 308 bytes  received 88 bytes  792.00 bytes/sec
total size is 17  speedup is 0.04

De optie -n (kort voor dry-run, proefdraai) is het vangnet. Het toont precies wat er zou gebeuren, maar verandert niets. Combineer het met -v en je krijgt een voorvertoning:

$ rsync -avn src/ dst/
sending incremental file list
a.txt
b.txt
sub/c.txt

sent 163 bytes  received 32 bytes  390.00 bytes/sec
total size is 17  speedup is 0.09 (DRY RUN)

Let op de markering (DRY RUN) aan het einde. Maak er een gewoonte van om elk nieuw of riskant rsync-commando eerst met -avn te draaien, de lijst te lezen, en pas dan de n weg te halen. Deze ene gewoonte voorkomt de meeste rsync-ongelukken.

4.4 Leesbare groottes: -h

Ruwe byte-aantallen in de samenvatting zijn lastig te lezen. De optie -h (kort voor human-readable, mensleesbaar) verandert ze in K, M en G:

$ rsync -ah --stats bigfolder/ /backup/bigfolder/
...
Total file size: 1.42G bytes
Total transferred file size: 12.043M bytes

Dat tweede getal is het punt van rsync in een regel: de map is 1,42 GB, maar er is maar 12 MB echt veranderd, dus er is maar 12 MB verstuurd.

6. Gevorderde toepassingen

6.1 Dingen weglaten: --exclude

Echte projecten bevatten dingen die je niet wilt kopieren: caches, logs, mappen met afhankelijkheden, tijdelijke bestanden. De optie --exclude slaat alles over wat op een patroon matcht, en je kunt het meer dan eens opgeven.

$ rsync -a --exclude '*.log' --exclude 'cache/' src/ dst/

Voor een lange lijst houd je de patronen in een bestand en lees je ze met --exclude-from:

$ rsync -a --exclude-from='ignore.txt' src/ dst/

De patronen werken veel als .gitignore-regels: een afsluitende schuine streep betekent "een map", een schuine streep aan het begin verankert het patroon aan de top van de overdracht, en * matcht binnen een padniveau. Er is een bijpassende --include voor het zeldzamere geval waarin je bijna alles wilt uitsluiten maar een paar dingen wilt behouden.

6.2 Extra metadata: -A, -X en -H

De archief-optie -a behoudt de alledaagse metadata, maar drie belangrijke dingen worden bewust weggelaten omdat ze extra werk kosten.

Wanneer je een heel systeem backupt of een server migreert en wilt dat de kopie echt getrouw is, is het gebruikelijke recept rsync -aAXH. Voor een gewone map met documenten is een kale -a genoeg.

6.3 Vergelijken op inhoud, niet op klok: -c

Standaard beslist rsync dat een bestand ongewijzigd is wanneer zowel de grootte als de wijzigingstijd overeenkomen. Dat is snel, maar het kan voor de gek gehouden worden: een bestand dat is bewerkt en binnen dezelfde seconde met dezelfde grootte is opgeslagen, of een bestand waarvan de tijdstempel is teruggezet, kan erdoorheen glippen. De optie -c (kort voor checksum, controlegetal) laat rsync in plaats daarvan elk bestand aan beide kanten lezen en een sterke checksum vergelijken.

$ rsync -avc src/ dst/     # compare by checksum, ignore size and time

Dit is trager, omdat het alle gegevens moet lezen, maar het is de eerlijke manier om de vraag "zijn deze twee mappen echt identiek?" te beantwoorden. Het is goed om te kennen voor verificatieruns, al is het niets voor dagelijkse synchronisaties.

6.4 De itemized-uitvoer lezen: -i

De optie -i (kort voor itemize-changes, wijzigingen opsommen) drukt naast elk bestand een compacte code af die je precies vertelt waarom het is overgedragen. Het ziet er eerst cryptisch uit, maar een minuut studie betaalt zich terug.

$ rsync -ain src/ dst/
>f+++++++++ newfile.txt
>f..t...... changed.txt
.d..t...... sub/

Lees de reeks van links naar rechts. Het eerste teken is de actie: > betekent dat een bestand wordt ontvangen (naar de bestemming gestuurd), en . betekent dat het item zelf niet wordt bijgewerkt, alleen een attribuut. Het tweede teken is het type: f voor een bestand (file), d voor een map (directory). De rest zijn de redenen: c checksum, s grootte (size), t tijd (time), p rechten (permissions), o eigenaar (owner), g groep (group). Een rij van +++++++++ betekent dat het bestand splinternieuw is. Dus >f..t...... lees je als "stuur dit bestand omdat de tijd verschilt", en >f+++++++++ lees je als "dit bestand is nieuw".

6.5 Een goede buur zijn: --bwlimit en --stats

Een rsync op volle snelheid kan een netwerkverbinding verzadigen en al het andere vertragen. De optie --bwlimit begrenst de overdrachtssnelheid, wat beleefd is op een gedeelde of productieverbinding.

$ rsync -az --bwlimit=5m site/ Dit e-mailadres wordt beveiligd tegen spambots. JavaScript dient ingeschakeld te zijn om het te bekijken.:/var/www/site/  # cap at 5 MB/s

De optie --stats drukt aan het einde een gedetailleerd rapport af, wat handig is in scripts en logs om te zien hoeveel er echt is verplaatst:

$ rsync -a --stats src/ dst/
Number of files: 5 (reg: 3, dir: 2)
Number of regular files transferred: 3
Total file size: 25 bytes
Total transferred file size: 25 bytes
...

6.6 Ter plekke schrijven en sparse-bestanden: --inplace en -S

Standaard schrijft rsync elk bijgewerkt bestand naar een tijdelijke kopie en hernoemt het dan over het oude heen. Dat is veilig, want een onderbroken overdracht laat nooit een half geschreven bestand achter, maar het heeft ruimte nodig voor beide versies en het breekt eventuele hard links die naar het origineel wijzen. De optie --inplace schrijft de wijzigingen in plaats daarvan direct in het bestaande bestand. Het bespaart ruimte, houdt hard links intact, en werkt goed samen met het delta-algoritme voor grote bestanden die maar een beetje veranderen, zoals database-dumps, VM-images en logs waar alleen aan wordt toegevoegd.

$ rsync -a --inplace bigdb.sql Dit e-mailadres wordt beveiligd tegen spambots. JavaScript dient ingeschakeld te zijn om het te bekijken.:/backups/

De afweging is veiligheid: als de overdracht wordt onderbroken, blijft het bestemmingsbestand gedeeltelijk bijgewerkt achter, dus gebruik --inplace alleen waar dat risico aanvaardbaar is.

De optie -S (kort voor sparse, ijl) behandelt bestanden die lange reeksen nulbytes bevatten, zoals schijf-images en sommige databasebestanden. Het schrijft die reeksen als echte "gaten" in het bestandssysteem in plaats van als blokken nullen, zodat de kopie veel minder ruimte kan innemen dan de schijnbare grootte van het bestand. (Oudere rsync-versies, van voor 3.1.3, weigerden -S met --inplace te combineren; huidige versies staan het toe.)

6.7 Verder dan SSH: de rsync-daemon

SSH is de gebruikelijke manier om een andere machine te bereiken, maar rsync kan ook praten met een speciale rsync-daemon die aan de andere kant draait. Dit is de modus die de grote openbare mirrors gebruiken om Linux-distributies aan duizenden mensen tegelijk uit te delen. Je herkent het aan een dubbele dubbele punt (of een rsync://-URL) en een modulenaam in plaats van een pad in het bestandssysteem:

$ rsync -av rsync://mirror.example/debian/ /srv/mirror/debian/
$ rsync -av mirror.example::debian/ /srv/mirror/debian/   # same thing

Een enkele dubbele punt (host:pad) betekent "verbind via SSH"; een dubbele dubbele punt (host::module) betekent "verbind met de rsync-daemon". De daemon luistert op poort 873 en wordt geconfigureerd in /etc/rsyncd.conf, waar elke module een naam koppelt aan een map en de toegangsregels ervan. De daemon kan sneller zijn dan SSH omdat het de versleutelings-overhead overslaat, maar dat betekent ook dat het verkeer onversleuteld is, dus het past veel beter bij openbare, alleen-lezen mirrors dan bij privebackups. Voor alles wat gevoelig is, blijf bij SSH.

8. Best practices

• Bekijk het eerst met -avn. Draai elk nieuw of riskant commando, vooral met --delete, eerst als een proefrun, lees de lijst, en haal pas dan de n weg.
• Beheers de afsluitende schuine streep. src/ betekent "de inhoud", src betekent "de map zelf". Deze ene regel bepaalt waar elk bestand terechtkomt.
• Gebruik -a als je standaard, en voeg -z toe voor overdrachten op afstand, -P voor grote, en -AXH wanneer je een echt getrouwe systeemkopie nodig hebt.
• Wees voorzichtig met --delete. Het laat de bestemming precies overeenkomen met de bron, inclusief het verwijderen van bestanden. Een verkeerd pad kan echte gegevens wissen, dus draai het elke keer als proefrun.
• Behoud tijdstempels. Behoud altijd de wijzigingstijden (onderdeel van -a), anders verstuurt rsync de volgende keer alles opnieuw en verliest het zijn hele voordeel.
• Grijp zonder aarzelen naar de handleiding. De rsync-handleiding is lang omdat het gereedschap diep is. man rsync typen zodra er een vraag opkomt is de gewoonte die beginners van professionals scheidt.

$ man rsync            # the full manual page (long, and worth it)
$ rsync --help         # a quick flag summary

10. Samenvatting

Het commando rsync lijkt op een chiquere cp, maar het is eigenlijk een kleine synchronisatiemotor die toevallig op een commandoregel past.

• rsync betekent "remote sync". Het laat een bestemming overeenkomen met een bron en verstuurt alleen wat is veranderd, en daarom zijn herhaalde synchronisaties snel.
• Het stamt uit 1996 en draagt een verschil-algoritme en een netwerkprotocol in een enkel gereedschap.
• Het laatste argument is de bestemming. Een afsluitende schuine streep op de bron (src/) kopieert de inhoud; geen streep (src) kopieert de map zelf. Geef de voorkeur aan src/ boven src/*, anders laat de shell je verborgen bestanden vallen.
• -a (archive) is de alledaagse optie: het betekent -rlptgoD, dus het kopieert recursief en behoudt links, rechten, tijden en eigenaarschap.
• Voeg -z toe om overdrachten op afstand te comprimeren, -P om te hervatten en voortgang te tonen, en -e "ssh ..." om de SSH-verbinding te sturen.
• --delete maakt van een kopie een echte spiegel door bestanden te verwijderen die niet langer op de bron bestaan. Bekijk het elke keer met -avn.
• --exclude slaat ongewenste bestanden over; -A, -X en -H voegen ACL's, uitgebreide attributen en hard links toe voor een getrouwe systeemkopie.
• Het delta-transfer-algoritme verstuurt alleen de veranderde stukken van een bestand over het netwerk, en --link-dest bouwt ruimtebesparende snapshot-backups met hard links.
• Verder dan SSH kan rsync praten met een daemon (host::module, poort 873) voor openbare mirrors, en --inplace met -S werkt grote of sparse-bestanden efficient bij.
• Weet waar rsync stopt: cp en scp voor eenmalige kopieen, tar voor archieven, git voor geschiedenis, dd voor hele schijven, en borg, rclone of Syncthing voor gededupliceerde, cloud- of tweerichtingssynchronisatie.
• Bij twijfel, typ man rsync.

Dit is de snelle referentie die het bewaren waard is:

rsync -a src/ dst/              sync contents of src into dst
rsync -a src  dst/             copy the folder src into dst (dst/src)
rsync -avn src/ dst/           dry run: show what would change
rsync -aP big.iso host:/data/  resume-friendly copy with progress
rsync -a --info=progress2 s/ d/  one overall progress bar for the whole job
rsync -az src/ user@host:/dst/ compressed copy over SSH
rsync -a --delete src/ dst/    mirror: also remove extra files in dst
rsync -a --exclude '*.log' s/ d/   skip files matching a pattern
rsync -aAXH src/ dst/          faithful copy with ACLs, xattrs, hard links
rsync -a --link-dest=/prev src/ /new/   space-saving snapshot backup

Kleine commando's zoals rsync houden stilletjes serieuze infrastructuur overeind: de backups die elke nacht draaien, de deployments die een website live zetten, de migratie die een bedrijf naar een nieuwe server verhuist. Als je servers ertoe doen en je wilt ze laten backuppen, uitrollen en onderhouden door iemand die begrijpt wat er echt onder de motorkap gebeurt, dan is dat precies het soort werk waar ik graag bij help.