scp: SSH
Je typt `scp bestand.txt server:/tmp/` en het werkt. Geen configuratie, geen client om te installeren, geen nadenken. Dat is precies waarom het ding na bijna veertig jaar nog steeds in elke handleiding opduikt.
Maar er is iets veranderd dat veel mensen niet weten, en het bepaalt of je `scp` verstandig kunt blijven gebruiken of niet.
`scp` staat voor secure copy. Het kopieert bestanden tussen machines en doet dat over een SSH-verbinding, dus versleuteld en met dezelfde authenticatie die je al gewend bent: wachtwoorden of sleutels. Het zit in OpenSSH, wat betekent dat je het hebt als je SSH hebt. Op Linux, macOS en moderne Windows-versies via de ingebouwde OpenSSH-client.
De syntaxis lijkt op `cp`. Je geeft een bron en een doel, en als een van de twee een remote pad is, schrijf je dat als `gebruiker@host:pad`.
``` scp document.txt gebruiker@server:/home/gebruiker/ ```
De andere kant op werkt hetzelfde.
``` scp gebruiker@server:/home/gebruiker/foto.jpg ./ ```
Tot zover niets spannends. De interessante vraag is wat er onder de motorkap gebeurt, want daar is het nodige veranderd.
Het oorspronkelijke `scp`-protocol had een probleem dat je in de praktijk zelden merkte maar dat er wel was: het was nooit formeel gestandaardiseerd. Er is een IETF-draft geweest, `draft-ietf-secsh-scp-sftp-ssh-uri`, voor het eerst ingediend op 13 augustus 2003. De vierde versie kwam op 2 februari 2006. Daarna liep het dood op 25 augustus 2006. Nooit een RFC.
Dat betekende dat elke implementatie zijn eigen interpretatie had. Meestal ging het goed. Soms niet.
Sinds OpenSSH 9.0, uitgebracht in april 2022, gebruikt `scp` standaard SFTP voor de daadwerkelijke overdracht. Niet meer het eigen protocol. Dat is een grotere verandering dan het klinkt. SFTP is een goed gedefinieerd protocol dat deel uitmaakt van de SSH-standaard, met betere foutafhandeling en minder verrassingen tussen verschillende systemen.
Wat je hiervan merkt: meestal niets. Wat je ervan merkt als je oude scripts hebt die op specifiek gedrag van het oude protocol leunden: dan wel iets.
Wil je het oude gedrag terug, dan kan dat met `-O`.
``` scp -O document.txt gebruiker@server:/home/gebruiker/ ```
Dat is een vlag die je alleen gebruikt als je een reden hebt. Voor nieuwe dingen niet nodig.
Nu de opties die je echt tegenkomt. `-P` met een hoofdletter P voor een andere poort dan 22. Verwar dit niet met de kleine `p` van `cp`, die bestaat hier niet.
``` scp -P 2222 document.txt gebruiker@server:/home/gebruiker/ ```
`-i` voor een specifieke private key.
``` scp -i ~/.ssh/id_ed25519 document.txt gebruiker@server:/home/gebruiker/ ```
`-r` voor mappen, recursief.
``` scp -r ./project gebruiker@server:/home/gebruiker/ ```
`-v` als er iets niet werkt en je wilt zien waar het misgaat. De uitvoer is uitgebreid. Soms té uitgebreid, maar het vertelt je tenminste welke sleutel hij probeert en waar de verbinding hapert.
``` scp -v document.txt gebruiker@server:/home/gebruiker/ ```
En dan `-3`, voor als je bestanden tussen twee externe hosts wilt kopiëren en alles via jouw machine moet lopen. Zonder `-3` praat de ene server direct met de andere. Met `-3` gaat de data via jouw laptop. Dat is langzamer en het heeft alleen zin als de twee servers elkaar niet kunnen bereiken.
``` scp -3 gebruiker@server1:/pad/bestand.txt gebruiker@server2:/pad/ ```
Tot hier is het allemaal redelijk overzichtelijk. De echte keuze komt nu.
Want `scp` is niet het enige gereedschap, en voor veel taken ook niet het beste. `rsync` doet hetzelfde soort werk, maar slimmer. Het stuurt alleen de delen van een bestand die veranderd zijn, het kan een onderbroken overdracht hervatten, het comprimeert onderweg, en het laat voortgang zien.
``` rsync -avz --progress ./project/ gebruiker@server:/home/gebruiker/project/ ```
Dat is objectief meer dan `scp` kan. De prijs: `rsync` staat niet overal. Op een minimale container of een embedded systeem is het vaak afwezig, terwijl `scp` er is zodra SSH er is. En de syntaxis met die trailing slashes is een valkuil waar iedereen een keer in stapt.
Dus de afweging is simpel. Voor een eenmalig bestandje heen en weer: `scp`. Voor een back-up die elke nacht loopt, voor een map met duizenden bestanden waarvan er drie zijn gewijzigd, voor alles wat je opnieuw zult uitvoeren: `rsync`.
Er is nog een derde optie, en die is de eerlijkste om te noemen. Grafische SFTP-clients. FileZilla, WinSCP, Cyberduck. Of in Linux-omgevingen tools die SFTP en `scp` integreren in een bestandsbeheerder, zoals SSH Pilot. Je klikt, je sleept, het werkt. Geen syntaxis om te onthouden, geen trailing slashes om te vergeten.
De kosten daarvan zijn reëel: die tools moet je installeren, ze zijn lastiger te scripten, en op een server zonder grafische omgeving heb je er niets aan. Maar als je één keer per maand een bestand overhevelt en je vergeet elke keer of het nu `-P` of `-p` is, dan is een grafische client geen zwakte. Het is gewoon het juiste gereedschap.
Wat `scp` goed doet, doet het goed omdat het klein is. Het is een dun laagje over SSH dat bestanden verplaatst. Geen state, geen configuratiebestand, geen daemon. Je kunt het in een cronjob zetten, in een CI-pipeline, in een shellscript dat iemand anders later leest en meteen begrijpt.
Die eenvoud is ook de beperking. Geen hervatten, geen delta-overdracht, geen voortgangsbalk die je iets vertelt bij een bestand van vier gigabyte. Je ziet een tijdje niets en dan is het klaar, of niet.
En dan is er nog het punt dat je pas merkt als je het nodig hebt: `scp` vertelt je niet altijd even duidelijk wat er misging. Een verkeerde sleutel, een verkeerde poort, een firewall die stilzwijgend dropt. `-v` is dan je vriend, maar je leest mee in uitvoer die geschreven is voor mensen die SSH al begrijpen.
Voor de meeste dagelijkse dingen is dat geen probleem. Je kopieert een bestand, het lukt, klaar. De problemen komen pas als je iets doet dat net buiten het gewone valt. Een spatie in een bestandnaam op de remote kant, bijvoorbeeld. Of een pad met een `~` dat de remote shell anders interpreteert dan jij bedoelde.
Wat je kiest hangt af van hoe vaak je het doet en hoe voorspelbaar het moet zijn. Voor een handmatige overdracht af en toe is `scp` precies genoeg. Voor terugkerend werk waarbij je niet elke keer wilt nadenken, is `rsync` de betere investering in leertijd. En als je nooit een terminal opent tenzij je moet, dan is er geen schande in een client met een venster en een sleepbeweging.
Het gereedschap is nooit het punt. Het punt is dat het bestand aankomt waar je het wilt, en dat je er niet naar hoeft om te kijken.