Backup

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
  1. 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
  1. 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?
  2. 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.
  3. 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.
  4. 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?
  5. 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.
  1. 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.
  2. 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

  1. 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
  2. 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)

  1. 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?
  2. 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"
  3. 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
  4. 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
  5. 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
  6. 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

  1. 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
  2. Ștergeți un fișier din directorul ~/workshop creat în secțiunea Backup Local
  3. Configurați cron să ruleze scriptul de backup în fiecare duminică noaptea, la ora 3.

Resurse

sesiuni/sysadmin/backup.txt · Last modified: 2014/07/07 19:19 by razvan