Back-up je Raspberry Pi (Ultieme handleiding)

In dit artikel

Als je veel met je Raspberry Pi werkt is het verstandig om regelmatig een back-up te maken. Een back-up is natuurlijk alleen handig als je hem ook daadwerkelijk terug kunt zetten.

In deze handleiding leg ik je verschillende manieren uit om back-ups te maken en deze te herstellen op je Pi.

De beste manier om een back-up van je Raspberry Pi te maken, is de tool rsync. Hiermee kopieer je bestanden naar een andere locatie in je netwerk. Het is ook mogelijk om een volledige kopie van je SD-kaart te maken, zodat alles veilig is.

Ook in dit proces zijn er vele manieren. Welke methode je gebruikt hangt af van hoe je netwerk is ingericht, hoe je je Pi gebruikt en bij welke methode jij je het prettigst voelt.

In deze handleiding zal ik de volgende manieren bespreken:

  • Maak alleen een back-up van de belangrijkste bestanden (configuratie, documenten en MySQL-database)
  • Maak een volledige back-up van je SD-kaart op een andere computer
  • Maak een volledige back-up van je Pi terwijl deze aan staat.

Heb je alleen interesse in een specifieke methode? Gebruik dan de inhoudsopgave hieronder om gelijk naar de gewenste methode te gaan.

Maak alleen een back-up van de belangrijkste bestanden

Heeft je Raspberry Pi een eenvoudige installatie, dan is het vaak al voldoende om alleen een back-up te maken van de belangrijkste bestanden.

Gebruik je bijvoorbeeld je Raspberry Pi als beveiligingscamera, dan is het voldoende om je configuratie-bestand te back-uppen, meer heb je niet nodig.

In de volgende stappen leg ik je uit hoe je:

  • een script maakt om dit te doen
  • hoe je de back-up kunt plannen
  • hoe je het bestand wegschrijft op een andere computer
  • hoe je bestanden kunt herstellen

Script

Voordat we het script kunnen maken dienen we eerst de bestanden te identificeren die we willen back-uppen.

In mijn script wil ik 2 bestanden back-uppen:

  • /home/pi/bestand1.conf
  • /home/pi/programma1

Laten we een map maken waarin we de back-up opslaan:

mkdir /home/pi/backup

Nu kunnen we het script maken. Ik gebruik nano om het script aan te maken:

nano /usr/local/bin/backup.sh

De eerste versie van het script ziet er als volgt uit:

#!/bin/bash
/bin/cp /home/pi/bestand1.conf /home/pi/backup
/bin/cp /home/pi/programma1 /home/pi/backup -r

Zoals je kunt zien is het een eenvoudig script, die telkens de vorige back-up zal overschrijven. Dit is niet wenselijk. Dus laten we het script gaan optimaliseren.

Maak gebruik van variabelen

De eerste optimalisatie die we kunnen doen is het toevoegen van variabelen.

Stel je voor dat je 200 bestanden back-upt naar /home/pi/backup, maar je besluit om ze te back-uppen naar een USB-stick /media/usb/. Dat zou betekenen dat je 200 regels na moet lopen en aan moet passen.

Een betere manier om dit te doen is een variabele toevoegen aan het begin van je script waar je de bestemmingsfolder inzet en deze variabele in elke regel gebruiken. Hetzelfde doe ik voor het “cp” commando. Mocht je in de toekomst gebruik willen maken van rsync of een ander commando dan hoef je maar 1 regel aan te passen.

Laten we kijken hoe ons script er uit ziet met de toegevoegde variabelen:

#!/bin/bash 
BACKUP_FOLDER = '/home/pi/backup/' 
BACKUP_CMD = '/bin/cp'

$BACKUP_CMD /home/pi/bestand1.conf $BACKUP_FOLDER 
$BACKUP_CMD /home/pi/programma1 $DBACKUP_FOLDER -r

In principe is het resultaat hetzelfde, maar het is veel gemakkelijker om bij te werken.

Comprimeer bestanden

Bij back-ups wordt vaak gebruik gemaakt van compressie. We verzamelen alle bestanden in een archiefbestand en comprimeren dat om het bestand zo klein mogelijk te maken.

In ons script gebruik ik tar om de bestanden in één bestand te archiveren en gzip om dit bestand te comprimeren.

Hier is de nieuwe versie van ons script:

#! / bin / bash 
BACKUP_FOLDER = '/home/pi/backup/'
BACKUP_FILE = 'backup.tar' 
BACKUP_CMD = '/bin/tar -rvf' 

/bin/rm $BACKUP_FOLDER/$BACKUP_FILE.gz
$BACKUP_CMD $BACKUP_FOLDER/$BACKUP_FILE /home/pi/bestand1.conf
$BACKUP_CMD $BACKUP_FOLDER/$BACKUP_FILE /home/pi/programma1
/bin/gzip $BACKUP_FOLDER/$BACKUP_FILE

Voeg een nieuwe variabele toe BACKUP_FILE om de bestandsnaam in op te slaan. Met tar -rvf kun je verschillende bestanden toevoegen aan één tar-bestand. Met gzip comprimeren we het bestand.

Overschrijf je vorige back-ups niet

Zoals ik net al aangaf, verwijdert dit script elke keer de vorige back-up. Dat is niet heel verstandig. Als er iets mis gaat met het back-uppen, ben je ook je vorige back-up kwijt.

Om dit te voorkomen, geven we de back-up de huidige datum en tijd mee:

#! / bin / bash 
BACKUP_FOLDER = '/home/pi/backup/'
BACKUP_FILE = 'backup-$(date +%F_%R).tar' 
BACKUP_CMD = '/bin/tar -rvf' 

/bin/rm $BACKUP_FOLDER/$BACKUP_FILE.gz
$BACKUP_CMD $BACKUP_FOLDER/$BACKUP_FILE /home/pi/bestand1.conf
$BACKUP_CMD $BACKUP_FOLDER/$BACKUP_FILE /home/pi/programma1
/bin/gzip $BACKUP_FOLDER/$BACKUP_FILE

Aan het script is verder niets veranderd, behalve dat we een datum aan de BACKUP_FILE variabele hebben toegevoegd, dit voorkomt dat de vorige back-up wordt overschreven.

Nu zal het script elke keer een nieuw bestand aanmaken en de vorige bestanden ongewijzigd laten.

Back-ups plannen

Nadat we ons script hebben gemaakt en de vorige stappen hebben gevolgd, is het meeste werk gedaan.

We hoeven ons script alleen nog in te plannen dat het elke dag automatisch uitgevoerd wordt.

Daarvoor maken we gebruik van crontab:

  • open de crontab:
    crontab -e
  • Plak deze regel aan het einde van het bestand:
    0 0 * * * /usr/local/backup.sh

De crontab zal het back-upscript elke dag om middernacht uitvoeren. Dit is natuurlijk aan te passen naar jouw wensen.

  • Sla het bestand op en sluit het af (CRTL+O, Enter, CTRL+X)

Wil je een backup maken van bestanden waar rechten voor nodig zijn, open dan de crontab met sudo.

Verwijder oude bestanden

Zoals we eerder al zagen, wordt er elke dag een nieuw bestand gemaakt en blijven de oudere bestanden bestaan. Dit gaat natuurlijk ten koste van de beschikbare schijfruimte.

Om te voorkomen dat de back-ups teveel ruimte in beslag nemen, kunnen we ze na bijvoorbeeld 8 dagen verwijderen.

Dit kunnen we instellen door deze regel aan het einde van ons script toe te voegen:

/usr/bin/find $BACKUP_FOLDER -mtime +8 -delete

Door deze regel zul je nooit meer dan 8 bestanden in je back-upmap hebben staan. Het aantal dagen is natuurlijk naar wens aan te passen.

Ik raad wel aan om back-ups van meerdere dagen oud te bewaren omdat fouten zich soms pas later voordoen.

Zet je back-up in je netwerk

Gefeliciteerd. Je hebt je eerste back-ups op je SD-kaart gemaakt. Maar wat nu als je SD-kaart het begeeft? Dan ben je alsnog je back-ups kwijt.

Tijd om je back-ups op een andere locatie dan je SD-kaart te zetten.

Back-up naar Linux of NAS

Heb je een andere computer die draait op Linux, of een NAS. Dan kun je je back-up bestanden daarnaar wegschrijven om ze veilig te stellen. Deze methode werkt ook voor macOS.

Handmatig

Als je bestanden niet of niet vaak veranderen is het aan te raden om dit proces wekelijks of maandelijks te doen.

Om de bestanden over te zetten maken we gebruik van de tool rsync. Installeer deze tool op beide apparaten:

sudo apt-get install rsync

Maak op je computer een map waar je de back-up wilt opslaan:

mkdir /home/[GEBRUIKER]/backups_pi

Er zijn 2 manieren om de bestanden over te zetten:

  • Vanaf je computer:
    rsync -auzr [email protected][RASPBERRY_IP]:/home/pi/backup/* 
    /home/[GEBRUIKER]/backups_pi/
  • Vanaf je Raspberry Pi
    rsync -auzr /home/pi/backup/* 
    [GEBRUIKER]@[COMPUTER_IP]:/home/[GEBRUIKER]/backups_pi

Vergeet niet om de variabelen te vervangen door jouw IP-adres en gebruikersnaam.

Automatisch

Net zoals bij het back-uppen op de Pi, wil je dit proces natuurlijk automatiseren. Er is alleen één probleem.

Om de overdracht te starten is een wachtwoord nodig. Om dit op te lossen, moeten we beide machines SSH-sleutels uit laten wisselen. Op die manier geven ze elkaar toestemming om de bestanden uit te wisselen.

Laten we er even vanuit gaan dat je computer om de uitwisseling vraagt. Wil je liever dat je Pi de uitwisseling aanvraagt, doe dit proces dan andersom.

Sleutel uitwisseling

  • Laten we beginnen om een sleutel te maken op je computer:\
    ssh-keygen -t rsa

    Druk op Enter na elke vraag, sla het wachtwoord-gedeelte over.

  • Zet de publieke sleutel over naar je Pi:
    rsync ~/.ssh/id_rsa.pub [email protected][RASPBERRY_IP]:/home/pi/

    Vul je wachtwoord in.

  • Nu moeten we de publieke sleutel toevoegen aan de toegestane sleutels op je Raspberry Pi:
    cat ~/id_rsa.pub >> ~/.ssh/authorized_keys
  • Probeer verbinding te maken via SSH. Als het goed is wordt er niet om een wachtwoord gevraagd.
    ssh [email protected][RASPBERRY_IP

Terug naar het script

Heb je de vorige stappen goed uitgevoerd, dan kun je nu rsync toevoegen aan je script zonder dat er om een wachtwoord gevraagd wordt.

Je script ziet er dan als volgt uit:

#!/bin/bash
rsync -auzr [email protected][RASPBERRY_IP]:/home/pi/backup/* /home/[GEBRUIKER]/backups_pi/
find /home/[GEBRUIKER]/backups_pi -mtime -8 -delete

Vervolgens plan je het script zoals je net hebt geleerd door middel van crontab.

Back-up naar Windows

Draait je computer op Windows, dan kun je je back-up ook overzetten. Zowel handmatig als automatisch.

Handmatig

De makkelijkste manier om bestanden over te zetten naar een Windows-machine is om WinSCP te installeren. WinSCP is gratis en kan bestanden verzenden via SSH.

  • Installeer WinSCP
  • Voeg een nieuwe site toe en gebruik de gegevens van je Pi:
    winscp
  • Klik op Opslaan en maak verbinding
  • Rechts zie je de bestanden op je Raspberry Pi en links de bestanden van je computer. Door bestanden te slepen kun je ze overzetten. Ga naar /home/pi/backup op je Pi en download de bestanden naar je computer. Daarna kun je alle oude bestanden verwijderen om ruimte te besparen op je Pi
Automatisch

Helaas beschikt WinSCP niet over een planningstool. Het is dus niet mogelijk om een bepaalde handeling op een bepaalde tijd te doen. Daarnaast is het lastig om SSH te installeren op Windows. We moeten dus een andere oplossing vinden.

Ik raad je aan om een map op Windows te delen met je Pi.

Map delen

Volg deze stappen om een folder te delen:

  • Maak een map aan waarin je de back-ups wilt bewaren
  • Klik met je rechtermuisknop op de map en kies voor Eigenschappen
  • Ga naar het tabblad Delen en klik op de knop Delen…
    map delen
  • Standaard heeft de gebruiker van je computer toegang tot de map, je kan een ander account toevoegen als je dat wilt. Je hebt hiervoor een gebruiker nodig met een wachtwoord.
    Heeft de hoofdgebruiker geen wachtwoord, maak deze dan aan.
  • Klik op OK als je het juiste account hebt toegevoegd.
  • Je deelt nu de map op je lokale netwerk. Sla het netwerkpad op, deze hebben we straks nodig op de Pi. Voor mij is dat: //KRIJN-LAPTOP/backups
Mount de gedeelde map op je Raspberry Pi

Je hebt op Windows de map gedeeld, nu moeten we hem koppelen op je Pi. Volg onderstaande stappen:

  • Maak een nieuwe map om de gedeelde map aan te koppelen:
    sudo mkdir /media/share/
  • Wijzig het /etc/fstab bestand:
    sudo nano /etc/fstab
  • Voeg deze regel toe:
    //KRIJN-LAPTOP/backups /media/share cifs username=[GEBRUIKERSNAAM],password=[WACHTWOORD],iocharset=utf8 0 0

    Vervang de variabeen voor jouw waardes. Let ook op dat je de juiste foldernaam gebruikt.

  • Sla het bestand op en sluit het af (CRTL+O, Enter, CTRL+X)
  • Mount de gedeelde map:
    sudo mount /media/share

Je gedeelde map is nu toegankelijk in /media/share, zodra je hier een bestand aanmaakt is deze ook toegankelijk op je Windows computer:

sudo touch /media/share/test
Het script

Nu we toegang hebben tot de gedeelde map, kunnen we een script maken om de back-ups automatisch in deze map te plaatsen:

#!/bin/bash
cp /home/pi/backups/* /media/share/
find /media/share -mtime +8 -delete

Herstellen

Het voordeel van deze manier van back-uppen is dat het het makkelijkst is om te herstellen. Je hoeft alleen het archiefbestand uit te pakken en deze in de juiste map te plaatsen.

Back-up herstellen op Linux

Op Linux kun je gebruik maken van de standaard archiefsoftware. Op Ubuntu dubbelklik je op het archiefbestand om het te openen. Nu zie je alle bestanden in de archiefmap. Klik op Uitpakken om alle bestanden uit te pakken.

Als je alle bestanden hebt, kun je de bestanden op je Raspberry Pi zetten met rsync (zie de stappen hierboven).

Back-up herstellen op Windows

Windows kan standaard geen .tar bestanden uitpakken, daarom raad ik je aan om 7-Zip te downloaden. Installeer 7-zip en open het archiefbestand.

Pak alle bestanden uit en zet ze over naar je Pi door middel van WinSCP.

Testen

Het is verstandig om deze procedure een keer te doen om te kijken of alles op de juiste manier terug gezet wordt en of alles dan nog werkt. Je kunt dit het beste testen als alles naar behoren werkt. Het zou vervelend zijn als je Pi crashed en je kunt je back-up niet terugzetten omdat er iets is mis gegaan.

Controleren

Soms is het wenselijk om te checken of je back-up gelukt is. Je kunt een script maken dat de meeste recente bestanden in je back-upfolder checkt:

#!/bin/bash

if [[ $(find /home/pi/backups -type f -mtime -1) ]]; then
echo "Backup OK"
//DO NOTHING
else
echo "Backup KO"
//DO SOMETHING (MAIL ?)
fi

MySQL data exporteren

Voor het back-uppen van MySQL-databases volgen we andere stappen dan hierboven.

Back-up

De beste manier voor MySQL data is het exporteren van de database en daarna de export op te slaan.

Exporteer je database met dit commando:

mysqldump -uroot -p[WACHTWOORD] [DATABASE-NAAM] > export-[DATABASE-NAAM].sql

Dit commando maakt een bestand aan met alle SQL-queries die nodig zijn om de database op te bouwen.

Ook hier kun je bovenstaande stappen gebruiken om:

  • een script te maken
  • de back-up te plannen
  • de bestanden op een andere computer op te slaan

Heb je meerdere databases, kopieer de lijn dan in je script en pas het aan naar de verschillende databases.

Herstellen

Om een database te herstellen volg je dezelfde stappen als bij het back-uppen van bestanden.

Zodra de bestanden op je Pi staan, gebruik je dit commando om de data in een nieuwe database te importeren:

mysql -uroot -p[WACHTWOORD] [DATABASE-NAAM] < [BACKUPBESTAND].sql

Let op dat je een lege database gebruikt om de import te doen. Er zijn 2 manieren om een database te herstellen:

  • Importeer de back-up in een database met een andere naam (kopieer alleen wat je nodig hebt)
  • Hernoem de corrupte database, maak hem opnieuw aan (leeg) en importeer het backupbestand.

Net zoals bij het backuppen van je bestanden, raad ik je aan om dit proces te testen. Zo weet je zeker dat het werkt als je het echt nodig hebt.

Maak een image van je SD-kaart

In de vorige hoofdstukken heb ik je laten zien hoe je een back-up maakt van een aantal bestanden. Ideaal voor een kleine installatie met weinig wijzigingen. Maar wat nu als je een complexe installatie hebt, met meerdere software installaties?

Back-up

Dit is persoonlijk mijn favoriete methode. Door een image te maken van je complete installatie, kun je deze snel naar een andere SD-kaart flashen. Zo kun je heel snel een installatie op een nieuwe Pi zetten.

Linux

Op Linux maken we gebruik van het commando “dd” om een image te maken.

  • Schakel je Raspberry Pi uit en haal de SD-kaart eruit
  • Plaats de SD-kaart in je computer
  • Zoek de apparaatnaam met:
    sudo fdisk -l

    Dit commando laat je alle opslagapparaten op je computer zien. Als het goed is zie je je harde schijf en onderaan de lijst vindt je je SD-kaart. Sla de naam op, die hebben we straks weer nodig.

  • Maak de image:
    sudo dd bs=4M if=/dev/mmcblk0 of=backup.img

    Vervang de apparaatnaam voor de naam die je net genoteerd hebt.

Na een paar minuten heb je de volledige back-up in een .img bestand.

Windows

Zelf maak ik gebruik van Windows. Voor Windows is een handige tool beschikbaar genaamd Win32 Disk Imager.

  • Download het programma en installeer het
  • Open Win32 Disk Imager
    win32diskimager
  • Voer de bestemmingsmap en bestandsnaam in voor je image (.img)
  • Selecteer je SD-kaart bij Doelapparaat
  • Klik op Lezen
  • Er wordt nu een image gemaakt in de map die je zojuist hebt geselecteerd

Herstellen

De makkelijkste manier om de back-up te herstellen is door het te flashen naar een nieuwe SD-kaart. Dit doen we met de tool Etcher.

  • Download Etcher en installeer het
  • Open Etcher
  • Kies links je img-bestand
  • Kies vervolgens je SD-kaart
  • Klik op “Flash”

Je hebt nu een SD-kaart met exact dezelfde installatie als je vorige SD-kaart. Als je net je Raspberry Pi hebt geinstalleerd, is het slim om gelijk een backup te maken. Zo heb je alle instellingen al geconfigureerd voor een nieuwe installatie. Scheelt een hoop tijd!

Op Linux kun je ook het commando “dd” gebruiken om de SD-kaart te flashen.

sudo dd bs=4M if=backup.img of=/dev/mmcblk0

Ook hier geldt, test het voordat je in de situatie komt dat je het echt nodig hebt. Pak een lege SD-kaart en doorloop de procedure om te kijken of alles werkt. Dit is ook een goede oefening, zodat je tijdens een echte crash sneller weer online bent.

Back-up een draaiende Raspberry Pi

Deze methode is grotendeels gelijk aan de vorige methode. Het enige verschil is dat we nu de Raspberry Pi niet uitschakelen maar laten draaien. Deze methode gebruik ik voor de Raspberry Pi waar mijn automatisering opdraait. Omdat die Pi het brein van mijn huis is, wil ik die niet uitschakelen. Om diezelfde reden wil ik natuurlijk wel een back-up mocht hij het begeven.

Benodigdheden

Deze methode kun je op 2 manieren uitvoeren, in de desktop versie met een tool of in de lite versie door middel van commando’s. In beide gevallen heb je een tweede SD-kaart nodig.

Mocht je er nog geen hebben, dan raad ik je aan om een goedkope USB adapter te kopen, zoals deze op Bol.com.

Ik raad een adapter aan met een korte kabel, je hebt niet heel veel ruimte bij je USB-slots op je Pi. Het zou zonde zijn als je de andere slots niet meer kunt gebruiken omdat ze geblokkeerd worden door je SD-reader.

PiClone (Desktop versie)

Draait je Pi op de desktop versie van Raspberry Pi OS, dan is de tool PiClone jouw redding. Je kan hem vinden in het hoofdmenu onder Hulpmiddelen –> SD Card Copier.

De werking van de tool kan niet eenvoudiger:
sd card copier

  • Selecteer bij “Copy From Device” je hoofd SD-kaart (waar je Pi nu op draait)
  • Selecteer bij “Copy To Device” je back-up SD-kaart
  • Klik op Start
  • Wacht tot het proces klaar is en verwijder de back-up SD-kaart

Ik kan het niet vaak genoeg herhalen, maar test of je back-up SD-kaart werkt, door hem in een andere Pi te stoppen. Geloof me, het scheelt een hoop frustratie als je van te voren het back-upproces getest hebt.

Script (Lite versie)

Draait jouw Pi op de Lite versie, dan is er een script beschikbaar om dit proces te doorlopen. Ik zal de basis met je doornemen. Wil je meer info? Check dan de GitHub pagina.

  • Installeer Git op je Pi:
    sudo apt-get install git
  • Download en installeer het script:
    cd ~/Downloads
    git clone https://github.com/billw2/rpi-clone.git
    cd rpi-clone
    sudo cp rpi-clone rpi-clone-setup /usr/local/sbin
  • Gebruik fdisk om de naam van de back-up SD-kaart te krijgen:
    sudo fdisk -l

    Je huidige SD-kaart wordt vaak aangeduid met sda of mmcblk0.
    Je backup SD-kaart wordt dan: sdb of mmcblk1

  • Gebruik vervolgens rpi-clone:
    sudo rpi-clone sdb -v

    Vervang sdb voor de naam van jouw back-up SD-kaart

Samenvatting

Dat was het dan! Een heel boekwerk, maar in mijn ogen een zeer belangrijk proces wat je een hoop tijd gaat besparen.

Ik ga het toch nog een keer herhalen: Test de procedure. Doorloop de stappen en test of je back-up werkt. Dit gaat je zoveel tijd en frustratie besparen als je Raspberry Pi echt crashed.

Vond je dit artikel waardevol? Check dan ook eens de 25 tips voor Raspberry Pi beginners.

Geef een antwoord

Het e-mailadres wordt niet gepubliceerd. Vereiste velden zijn gemarkeerd met *

Beginnen met Raspberry Pi?

Start in 5 stappen jouw Raspberry Pi avontuur.