Deze Linux-functie is de reden waarom ik niet meer bang ben voor updates (en Windows zou dit moeten kopiëren)
Er was vroeger altijd een klein moment van aarzeling elke keer dat ik op de updateknop klikte. Je kent het moment wel: de cursor zweeft. Je brein voert een snelle risicoanalyse uit. Wil ik hier vandaag echt mee omgaan? Updates zouden je systeem moeten verbeteren, maar iedereen die lang genoeg met computers heeft gewerkt, weet dat ze af en toe verrassingen met zich meebrengen. Stuurprogramma's stoppen met samenwerken, of iets dat gisteren perfect werkte, weigert plotseling te functioneren. Windows-gebruikers kennen dit gevoel bijzonder goed.
Windows-updates hebben een lange en kleurrijke geschiedenis van af en toe misgaan. Soms installeert het systeem ze op het slechtst mogelijke moment. Soms faalt een driver. Soms werkt een functie plotseling niet meer en weet je niet eens waarom. Herstelinstrumenten bestaan, maar ze voelen vaak traag, onduidelijk en een beetje onvoorspelbaar aan. Linux daarentegen heeft dit probleem jaren geleden stil opgelost. Het trucje heet bestandsysteem-snapshots, en zodra je ze gaat gebruiken, voelen updates helemaal niet meer risicovol.
Updates voelden vroeger als een gok
Het universele 'alsjeblieft, breek niets' moment
Jarenlang droegen updates altijd een klein element van onzekerheid met zich mee. Je drukt op update, en je sluit in feite een deal met je computer. Misschien verbetert alles, misschien verandert er niets, of misschien verdwijnt je geluidsapparaat in de schemerdimensie. De meeste updates verlopen natuurlijk goed. Maar de mogelijkheid van problemen is voldoende om ervaren gebruikers voorzichtig te maken. Als je ooit een update hebt uitgesteld omdat je je computer die dag echt nodig had om goed te functioneren, gefeliciteerd. Je bent niet alleen. Die aarzeling verdwijnt zodra je systeem een betrouwbare manier heeft om zichzelf terug te draaien. De functie die alles voor mij veranderde, is filesystem-snapshots. In plaats van te hopen dat een update perfect werkt, kan Linux het hele systeem bevriezen voordat er iets verandert: elk bestand, geïnstalleerd pakket en configuratie.
Die bevroren staat wordt een momentopname van je systeem op dat exacte moment. Dan wordt de update uitgevoerd. Als alles werkt, geweldig. Je blijft je computer gebruiken. Als er iets misgaat, ga je gewoon terug naar de momentopname die voor de update is gemaakt. Er is geen speurwerk, geen drivers opnieuw installeren, en geen doorzoeken van forumposts uit 2014 om iets mysterieus ongedaan te maken. Je systeem gaat gewoon terug naar hoe het was. Windows probeert iets soortgelijks met Systeemherstel, maar het voelt zelden zo transparant. Herstelpunten verschijnen onvoorspelbaar, en teruggaan kan meerdere herstarts en lange wachttijden met zich meebrengen. Momentopnamen nemen een eenvoudigere benadering: als er iets kapotgaat, ga je gewoon terug naar wanneer het niet kapot was.
Hoe Linux de tijd in seconden kan bevriezen
Moderne bestandssystemen maken snapshots bijna onmiddellijk
Deze mogelijkheid komt van moderne bestandssystemen zoals Btrfs. Traditionele bestandssystemen zouden enorme hoeveelheden data moeten dupliceren om een back-up te maken. Btrfs gebruikt een techniek genaamd copy-on-write, waarmee het systeem de huidige staat van het bestandssysteem kan vastleggen zonder elk bestand te kopiëren.
Wanneer iets later verandert, worden alleen de verschillen opgeslagen. Dat betekent dat snapshots bijna onmiddellijk kunnen worden gemaakt en verrassend weinig ruimte innemen. Hulpmiddelen zoals Snapper automatiseren het hele proces. Voordat het systeem updates installeert, maakt Snapper stilletjes een snapshot op de achtergrond. Je klikt op bijwerken, en het systeem slaat eerst stilletjes een snapshot op. Daarna wordt de update uitgevoerd. Dat kleine ontwerpbesluit verandert volledig hoe updates aanvoelen.
Het moment waarop Linux-updates niet meer eng aanvoelen
Het opstartmenu wordt je vangnet
De echte magie gebeurt de eerste keer dat snapshots in je opstartmenu verschijnen. Veel Linux-systemen gebruiken de bootloader GRUB, en sommige distributies integreren snapshots rechtstreeks daarin. In plaats van één opstartoptie, zou je iets als dit kunnen zien:
- Boot huidig systeem
- Momentopname vóór systeembediening
- Momentopname van drie dagen geleden
Als een update problemen veroorzaakt, selecteert u gewoon de eerdere snapshot. Seconden later start uw computer precies op zoals hij was voordat de update werd uitgevoerd, zonder herstelhulpprogramma's, zonder lange probleemoplossingssessies en zonder mysterieuze schermen met 'systeem proberen te herstellen'.
Je bent gewoon terug. Vanaf daar duurt het herstellen van die snapshot als het actieve systeem maar één commando:
sudo snapper rollbackDe kapotte update verdwijnt effectief uit de geschiedenis. Niet gaan liegen, de eerste keer dat je dit doet, voelt het een beetje alsof je bedriegt.
Wanneer updates daadwerkelijk iets kapot maken
Een snel scenario uit de echte wereld
Stel je voor dat je een update van het grafische stuurprogramma installeert waardoor je bureaublad plotseling... vreemd aanvoelt. Animaties haperen, vensters gaan met vertraging open en technisch werkt alles, maar het systeem voelt nu alsof het met zichzelf in discussie is. Normaal gesproken begint hier het oplossen van problemen: je begint op forums te zoeken, probeert pakketten terug te draaien en stelt verschillende recente levenskeuzes in vraag. Met snapshots is het proces aanzienlijk korter: opnieuw opstarten, de snapshot van vóór de update selecteren en verder werken. De kapotte update wordt een probleem voor morgenochtend in plaats van een noodgeval vandaag.
Sommige Linux-distributies doen dit al automatisch
Snapshotgedreven updates worden steeds gebruikelijker
Verschillende Linux-distributies beschouwen snapshots al als een kernonderdeel van het updateproces. Bijvoorbeeld, openSUSE Tumbleweed maakt automatisch Btrfs-snapshots voordat elke systeemupdate wordt uitgevoerd. Als er iets misgaat, kunt u de vorige snapshot rechtstreeks opstarten vanuit het GRUB-menu en het systeem terugzetten.
Distributies zoals Garuda Linux vertrouwen ook sterk op snapshots om updates veel veiliger te maken. Zelfs distributies die standaard geen Btrfs gebruiken, bieden vaak vergelijkbare bescherming via tools zoals Timeshift, die herstelpunten maken waar je naar terug kunt gaan als er iets misgaat.
De filosofie hierachter is eenvoudig: updates zouden je nooit in een defect systeem moeten vasthouden.
Waarom Windows dit idee absoluut zou moeten stelen
Windows bevat inderdaad herstelhulpmiddelen zoals Systeemherstel en terugrollen van updates. Maar ze voelen vaak meer als noodhulpmiddelen dan als dagelijkse vangnetten. Wanneer een Windows-update mislukt, eindigen gebruikers typisch met het navigeren door herstelschermen, wachten ze meerdere herstarts af, en hopen ze dat het systeem uiteindelijk zichzelf repareert. Momentopnames keren dat hele proces om. In plaats van te proberen een kapot systeem te repareren, laat Linux je simpelweg een systeem opstarten dat niet kapot is. Het is sneller, duidelijker, en vermindert de stress rondom updates aanzienlijk.
De meeste moderne besturingssystemen worden voortdurend bijgewerkt. Beveiligingsupdates komen regelmatig binnen. Stuurprogramma's ontwikkelen zich. Software verandert sneller dan ooit.
In die omgeving wordt het vermogen om wijzigingen onmiddellijk ongedaan te maken ongelooflijk waardevol. Linux doet niet alsof updates altijd perfect zullen verlopen. In plaats daarvan biedt het een vangnet. Druk op bijwerken, laat het uitvoeren en start opnieuw op indien nodig. Als alles werkt, geweldig. Als er iets kapot gaat, start opnieuw op en kies in plaats daarvan het systeem van gisteren. Windows behandelt updates als iets waarvan je hoopt dat het werkt.
Linux behandelt ze als iets dat je ongedaan kunt maken.