Backup

Slide-urile prezentării

Idei

De ce avem nevoie de Backup și de Restore
Tipuri de backup și cum se pretează pe o anumită situație
Versionare
Rsync

Demo

În cadrul tutorialului veți lucra pe două mașini: pe serverul swarm.cs.pub.ro și pe containerul LXC
Swarm:
- Conectarea se face prin ssh:
```
ssh <user>@swarm.cs.pub.ro
```
- Atenție: atât în exemplul de mai sus, cât și în restul tutorialului <user> trebuie înlocuit cu userul de swarm aferent fiecărui student.
  - Dacă nu aveați cont creat pe swarm.cs.pub.ro, ați primit detalii legate de accesarea contului pe e-mail.
Container LXC:
- Conectarea se face prin ssh:
```
ssh -p <port> root@houdini.cs.pub.ro
```
- <port> este de forma 4<id_container>22
- Pentru a afla id-ul container-ului accesati pagina cu participanți

MySQL Backup

Conectați-vă prin SSH la containerul LXC și creați un director mysql.backup în home-ul utilizatorului vostru:
```
mkdir ~/mysql.backup
```
Pe serverul koala.cs.pub.ro este accesibilă următoarea bază de date (“accesibilă” înseamnă că puteți folosi un client MySQL pentru acces - vom folosi, în acest sens, comanda mysqldump – vedeți mai jos):
- Host: koala.cs.pub.ro
- User: workshop
- Parolă: w0rksh)P
- Baza de date: swarm_boboc

Backup
- Pe containerul LXC, folosiți utilitarul mysqldump pentru a face backup în container la baza de date de pe koala:
```
mysqldump -u workshop -p'w0rksh)P' -h koala.cs.pub.ro swarm_boboc > ~/mysql.backup/swarm_boboc.backup.sql
```
  - Puteți da copy-paste la comandă în terminal.
  - Daca nu va merge comanda de mai sus, instalati pachetul mysql-client: apt-get install mysql-client
  - Deschideți fișierul generat folosind vi sau nano și observați ce informații conține.

Backup local (rsync)

Pe sistemul local, (NU pe swarm.cs.pub.ro) creați, în home, directoarele workshop și backup:
```
mkdir ~/workshop
mkdir ~/backup
```

Backup-ul unui fișier
- Generați în directorul workshop/ un fișier de 100M:
```
dd if=/dev/urandom of=~/workshop/file100M bs=1K count=100K
```
- Faceți backup la fișierul din directorul workshop/ în directorul backup/:
```
rsync -v ~/workshop/file100M  ~/backup
```
  - Observați speedup-ul operației.
- Verificați dacă backup-ul s-a realizat cu succes:
```
ls -alh ~/backup
```
  - Rulați de mai multe ori și analizați output-ul fiecărei rulări.
  - Ce observați?
Backup-ul unui director
- Generați în directorul workshop/ un nou fișier de 10M și unul de 1M:
```
dd if=/dev/urandom of=~/workshop/file10M bs=1K count=10K
dd if=/dev/urandom of=~/workshop/file1M bs=1K count=1K
```
- Faceți backup la întregul director workshop/ în directorul backup/:
```
rsync -v ~/workshop/*  ~/backup
```
  - Afișați fișierele din directorul backup:
```
ls -alh ~/backup
```
  - Ce observați?
- Adăugați parametrul -d lui rsync:
```
rsync -dv ~/workshop/  ~/backup
```
  - Rulați de mai multe ori și analizați output-ul comenzilor.
  - Ce observați?
- Creați un subdirector în directorul workshop/:
```
mkdir ~/workshop/subdir
```
- Generați un nou fișier de 20M:
```
dd if=/dev/urandom of=~/workshop/subdir/file20M bs=1K count=20K
```
- Rulați din nou backup-ul.
- Afișați directorul backup/ și subdirectorul lui:
```
ls -alh ~/backup ~/backup/subdir
```
- Ce observați?
- Realizați backup-ul recursiv (parametrul -r):
```
rsync -rdv ~/workshop/  ~/backup
```
- Afișați din nou directoarele.
Backup diferențial
- Apelați rsync cu parametrul -a:
```
rsync -adv ~/workshop/  ~/backup
```
  - Parametrul -a trece rsync în modul de backup diferential.
  - Rulați din nou de mai multe ori.
  - Ce observați de data asta?
- Adăugați un nou fișier, de data asta de 2M:
```
dd if=/dev/urandom of=~/workshop/file2M bs=1K count=2K
```
- Realizați backup-ul. Ce observați?
- Adăugați 1K fișierului de 2M:
```
dd if=/dev/urandom of=~/workshop/file2M bs=1K count=1 conv=notrunc
```
- Faceți din nou backup. Ce observați?
  - Rulați din nou de mai multe ori.
Compresie
- Generați un nou fișier de 50M plin cu zerouri:
```
dd if=/dev/zero of=~/workshop/file50M bs=1K count=50K
```
- Faceți backup în directorul backup/.
- Rețineți speedup-ul.
- Modificați timpul de editare al fișierului ~/workshop/file50M:
```
touch ~/workshop/file50M
```
- Adăugați parametrul -z:
```
rsync -zav ~/workshop/  ~/backup
```
- Ce observați?
Sincronizare completă
- Afișați conținutul celor două directoare (~/workshop și ~/backup) și verificați că sunt identice:
```
ls -alh ~/backup/ ~/workshop
```
- Ștergeți din directorul workshop/ fișierul file1M:
```
rm -f ~/workshop/file1M
```
- Faceți din nou backup la folderul workshop.
  - Afișați din nou conținutul celor două directoare.
  - Ce observați?
- Adăugați parametrul –delete:
```
rsync -zadv --delete ~/workshop/  ~/backup
```
- Afișați acum conținutul celor două directoare.

Backup la distanță (rsync)

Pe containerul LXC instalați pachestul rsync (dacă nu este instalat):
```
apt-get install rsync
```
Pe sistemul local, în home, creați un director documents:
```
mkdir ~/documents
```
Adăugați câteva fișiere în director:
```
cd ~/documents
```
- Folosiți documente din documentația de SO.
  - Vă autentificați folosind contul de pe cs.curs.pub.ro.

Backup prin SSH
- Autentificați-vă pe containerul LXC (houdini.cs.pub.ro) și creați directorul ~/documents.backup:
```
mkdir ~/documents.backup
```
- Deconectati-va de pe containerul LXC.
- Pe sistemul local, faceți backup la fișierele locale din directorul ~/documents/:
```
rsync -zadv --delete --rsh='ssh -p<port>' ~/documents/ root@houdini.cs.pub.ro:~/documents.backup
```
  - <port> este de forma 4<id_container>22.
  - Implicit rsync remote funcționează prin SSH, pe portul 22.
  - Parametrul --rsh este folosit pentru a specifica comanda de transport a datelor și portul.
  - Introduceți parola utilizatorului de pe swarm.cs.pub.ro.
  - Verificați dacă backup-ul s-a realizat cu succes; conectați-vă prin SSH și verificați conținutul directorului.
Daemon
- Pe containerul LXC, creați fișierul de configurare al daemonului rsync, /etc/rsyncd.conf:
  /etc/rsyncd.conf
  [docs] uid = root gid = root read only = no path = /root/documents.backup
- Setați parametrul RSYNC_ENABLE din fișierul /etc/default/rsync pe true:
```
RSYNC_ENABLE=true
```
- Porniți daemonul de rsync:
```
/etc/init.d/rsync start
```
- Descărcați un nou fișier în directorul local ~/documents.
- De pe sistemul local actualizați backup-ul:
```
rsync -zadv --delete -e "ssh -p <port>" ~/documents/ root@houdini.cs.pub.ro::docs
```
- <port> este de forma 4<id_container>22
- Verificați dacă backup-ul s-a realizat cu succes.

Automatizare

Script

Creați un script care realizează sincronizarea prin rsync:

~/backup.sh

#!/bin/bash
 
SERVER=houdini.cs.pub.ro
PORT=<port>
PARAMS="-zadv --delete"
REMOTE_MODULE=docs
BACKUP_DIR=~/documents/
 
rsync $PARAMS -e "ssh -p $PORT" $BACKUP_DIR $SERVER::$REMOTE_MODULE

Rulați scriptul și verificați dacă funcționează corespunzător

Cron
- Editați fișierul /etc/crontab local, ca root:
```
sudo vim /etc/crontab
```
- Introduceți o nouă intrare:
```
0 0 * * * student /home/student/backup.sh
```
  - Job-ul de mai sus se rulează în fiecare zi la ora 00:00
  - student este utilizatorul cu care va rula scriptul
  - scriptul care realizează backup-ul
- Pentru mai multe informații despre cron urmăriți acest tutorial.

Versionare (git)

Crearea repository
- Creați în home-ul de pe swarm directoarele ~/git-repos și ~/git-repos/apache2.git:
```
mkdir -p ~/git-repos/apache2.git
```
- Inițializați repository-ul:
```
git --bare init ~/git-repos/apache2.git/
```
- Afișați fișierele din repo:
```
ls -alh ~/git-repos/apache2.git/
```
  - Ce observați?
Adăugarea configurării apache în repository
- Următoarele comenzi rulați-le în containerul lxc propriu
- Inițializați un repo în directorul de configurare al apache2:
```
git init /etc/apache2/
```
- Adăugați toate fișierele din /etc/apache2/ în repository:
```
cd /etc/apache2/
git add *
```
- Comiteți schimbările făcute:
```
git commit -m "Initial apache2 configuration"
```
Link-area repository-ului local cu unul remote
- Crearea link-ului:
```
git remote add origin <user>@swarm.cs.pub.ro:git-repos/apache2.git
```
  - <user> este numele vostru de utilizator de pe swarm.cs.pub.ro.
- Updatați repository-ul remote:
```
git push -u origin master
```
Backup
- Creați pe sistemul local, cu drept de root, directorul /etc/apache2:
```
sudo su
mkdir /etc/apache2
cd /etc/apache2
```
  - Dacă directorul există, ștergeți-l
- Clonați repository-ul remote în directorul nou creat:
```
git clone <user>@swarm.cs.pub.ro:git-repos/apache2.git .
```
  - <user> este numele vostru de utilizator de pe swarm.cs.pub.ro.
- Verificați că toate fișierele au fost aduse corect:
```
ls -alh
```
Editare fișiere
- Configurați în containerul lxc apache să asculte cereri HTTP și pe portul 80 și pe 443:
  - Editați fișierul /etc/apache2/ports.conf
- Verificați schimbările făcute:
```
git diff
```
- Adăugați fișierul în următorul commit:
```
cd /etc/apache2
git add ports.conf
```
- Comiteți schimbările:
```
git commit -m "Add port 443"
```
- Sincronizați repository-urile:
```
git push
```
Actualizați backup-ul
- În directorul local /etc/apache2/ aduceți fișierele modificate de pe repository.
```
git pull --rebase
```
- Verificați dacă fișierul ports.conf s-a actualizat

Extra

Instalați în containerul lxc un server de mysql și importați fișierul ~/mysql.backup/swarm_boboc.backup.sql obținut în secțiunea MySQL Backup
Ștergeți un fișier din directorul ~/workshop creat în secțiunea Backup Local
Configurați cron să ruleze scriptul de backup în fiecare duminică noaptea, la ora 3.