linux800 | backups revisited

backups revisited

Een goede backup staat op een opslagmedium (harde schijf, tape, andere) die gedeconnecteerd van een systeem, opgeslagen wordt onder normale klimatologische omstandigheden: kamertemperatuur en relatieve luchtvochtigheid tussen 50 en 85%), op een andere locatie (d.i. een ander gebouwencomplex) zoals bvb een bankkluis. Backups moeten regelmatig getest worden om te zien of ze volledig zijn, en bovendien moet een terugplaatsprocedure op regelmatige tijdstippen (minstens één keer per jaar) plaatsvinden.

cp

Op je eigen machine, maar naar een andere schijf (bvb USB of eSATA) ... De schijf wordt na kopiëren afgekoppeld en elders opgeslagen.

mountpoint en mount commando:

$ sudo mkdir /home/backups
$ sudo mount /dev/mapper/ubuntu--vg-backups /home/backups/

eenvoudig backup commando met cp:

$ sudo mkdir -p /home/backup/webs-01/2016-10-25/
$ sudo cp -rvpdu /var/www /home/backup/webs-01/2016-10-25/
_{zoek zelf op waarvoor de opties dienen}
scp

Tussen twee machines. Er moet een procedure bestaan die op de doelmachine de backup loskoppelt van het systeem, en op een goede locatie opslaat. Dit is makkelijker dan met cp, want je kan de backup-doelmachine makkelijker stilleggen, om de backup af te koppelen.

Praktisch: moet eigenlijk als root, en bijgevolg hebben we keys nodig. Bovendien kunnen we als root geen gebruik maken van het commando ssh-copy-id, want in
/etc/ssh/sshd_config staat dat we als root niet met paswoorden mogen inloggen:
```
...
# Authentication:
LoginGraceTime 120
PermitRootLogin without-password
StrictModes yes
...
```
Bovendien, moeten we als we ooit een backup moeten terugplaatsen ook in omgekeerde richting met ssh kunnen werken. We gaan als volgt te werk:

als root op machine A (10.104.201.101)

# cd
# ssh-keygen
```
Generating public/private rsa key pair.
Enter file in which to save the key (/root/.ssh/id_rsa):   <ENTER>
Created directory '/root/.ssh'.
Enter passphrase (empty for no passphrase):  (leave this empty) <ENTER>
Enter same passphrase again:  (leave this empty) <ENTER>
Your identification has been saved in /root/.ssh/id_rsa.
Your public key has been saved in /root/.ssh/id_rsa.pub.
The key fingerprint is:
SHA256:puJVuDzkw7feFAW8OKi7BY+fZ+K+4vekFJ2Apcx93J8 root@clt-m18-nat10-104
The key's randomart image is:
+---[RSA 2048]----+
|      .  ..      |
|   o = . ...     |
|    = o.o....    |
|      .=o..o .   |
|    ..+ S.. E    |
|    .O *   .     |
|    o.& o .      |
|   .o*oBo+       |
|   .+*BB+ .      |
+----[SHA256]-----+
```
De passphrase is leeg, want we moeten indien nodig een scp-backup-script vrij kunnen laten runnen vanaf cron

We kijken nu even wat we hebben gecreëerd:
# cd .ssh
# ls -l
total 8
-rw------- 1 root root 1679 Nov 4 09:17 id_rsa
-rw-r--r-- 1 root root 404 Nov 4 09:17 id_rsa.pub

Vervolgens plaatsen we de public-key ook in authorized_keys:
# cat id_rsa.pub >> authorized_keys

Daarna creëren we een tar-bestand van de directory .ssh en copieren we dit naar de directory van de standaardgebruiker, in dit voorbeeld, bert ; we moeten misschien ook nog de eigendom aanpassen:
# cd $HOME
# tar -cv .ssh -f sshdirroot.tar
# mv sshdirroot.tar /home/bert
# chown bert:bert /home/bert/sshdirroot.tar

als gewone gebruiker bert op machine A

De gewone gebruiker bert kan wel gewoon ssh gebruiken met paswoorden, en bijgevolg een tar-bestand van A naar B (10.104.201.102) sturen:
$ scp sshdirroot2.tar 10.104.201.102:~/

als root op machine B

# mv sshdirroot.tar ~
# tar -xvf sshdirroot.tar

test van B naar A als root

# ssh 10.104.201.101

test van A naar B als root

# ssh 10.104.201.102

De eigenlijke backup, vanaf machine A als root

We maken eerst een backup-directory aan op B:
# ssh 10.104.201.102 'mkdir -p /home/backups/webs/$(date +%y-%m-%d)'

Tenslotte kopieren we de belangrijke inhoud van onze webserver naar de backup-machine B:
# scp -rp /var/www/ 10.104.201.102:/home/backups/webs/$(date +%y-%m-%d)

Vergeet niet te controlleren op machine B of het gelukt is ...
rsync

rsync verschilt niet zoveel van scp, behalve dan dat rsync incrementeel werkt en alleen aangepaste bestanden doorstuurt.

Met de keys uit de vorige oefening zou dit onmiddellijk moeten draaien van A naar B:
$ sudo rsync -av /var/www/ -e ssh 10.104.201.102:/home/backups
unison

Unison kan makkelijker geautomatiseerd worden als rsync of ssh. Principes zijn hetzelfde.

installeer unison op 2 machines:

sudo apt-get install unison

gebruik unison van de command line (let op de dubbele slash):

unison -auto -times -ignore 'Path .*' -ignore 'Name .*' /home/user/ ssh://10.104.201.102//home/user

gebruik unison met profielen(je kan ze plaatsen in $home/.unison

Het bovenstaande commando hernomen als profiel:
```
# Roots of the synchronization
/home/user/ 
ssh://10.104.201.102//home/user
# Parameters
ignore = Path .*
ignore = Name .*
times = true
auto = true
```
Een ander voorbeeld: a minimal profile: here is a very minimal profile file, such as might be found in .unison/default.prf:
```
# Roots of the synchronization
root = /home/bcpierce
root = ssh://saul//home/bcpierce

# Paths to synchronize 
path = current
path = common
path = .netscape/bookmarks.html
```
Meer profielen:
http://www.cis.upenn.edu/~bcpierce/unison/download/releases/stable/unison-manual.html#minimalprofile
RAID

RAID is geen backup. RAID zorgt voor redundancy, d.i. meervoudige onmiddellijke opslag. Als één harde schijf (of in RAID6 twee) het begeeft kan je nog verder werken. Maar als je filesystem de geest geeft gebeurt dit over de GANSE RAID en kun je niet terug. Een backup is iets waarnaar je kan teruggrijpen, een soort snapshot in de tijd.
DRBD

DRBD is GEEN BACKUP. DRBD is niet zo heel veel verschillend van RAID, behalve dan dat er filesystems op verschillende plaatsen op verschillende computers gelijktijdig worden geüpdate. Het probleem van corrupte data is gelijkaardig als bij RAID.
snapshots

Een SNAPSHOT is GEEN BACKUP. Sommige filesystems laten toe snapshots te maken in de tijd. Het zijn dan zogenaamde incrementele filesystems. Als het filesystem breekt, breekt echter ook de snapshot. Filesystem en virtual-machine snapshots zijn GEEN BACKUP
oefeningen: ALLE OEFENINGEN OP EEN LINUX MINT
- cp testem met rvpdu --> en backup terugzetten op derde medium
- SCP ALS GEWONE USER EEERST DAARNA ALS NE ROOT MET KEYS
- rsync TRY IT
- unison KAN JE OOK PROBEREN ALS ROOT MET DEZELFDE KEYS