Re: Backupstrategie

[Werner Holtfreter <Holtfreter@xxxxxx>]

Am Samstag, 12. Juli 2008 18:41:32 schrieb Werner Holtfreter:

> das Exkludieren funktioniert auch nicht

Nach einigen schlaflose Naechten nun Ergebnisse:

Der rsync-Paramter hinter  --exclude=   kann auch ein Pfad sein. Der 
Pfad darf aber nur so lang sein, wie er in Quelle und Ziel 
identisch ist!

   --exclude=/home/*/.local/share/Trash

schreibt man besser als

   --exclude=.local/share/Trash/

Abschliessendes / bezeichnet ein Directory, ohne / eine Datei oder 
ein Directory.

Aehnlich wie Markus habe ich folgende Scripte geschrieben und 
untersucht:

rsyback.cp       [1]
rsyback.linkdest [2]
rsyback.zykl     [3]
rsyback.splitt   [4]
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
rsyback.cp       [1] ist die klassische Variante. Funktioniert 
einwandfrei aber langsam.

rsyback.linkdest [2] verzichtet auf cp -al backup.0 backup.1
Aber: Bereits die Rechteaenderung vereitelt Hardlinks! Die
betreffende Datei wird zusaetzlich gespeichert. Werden die Rechte
aller Dateien geaendert, wird eine zusaetzliche Vollsicherung
gespeichert.
 Zeitersparnis mit meinen realen Daten schwankend um die 15 %.

rsyback.zykl     [3] verzichtet /nicht/ auf  cp -al
dafuer aber auf den separaten Loeschvorgang der aeltesten Backupebene, 
in dem sie rsync als Basis vorgelegt wird. Letztlich loescht also 
rsync die ueberfluessigen Dateien. In der Originalpublikation steht, 
dass die Methoden [2] und [3] nicht kombiniert werden sollen, weil 
so zahlreiche unveraenderte Dateien nicht hardverlinkt sondern 
separat gespeichert werden. Neu ist nun meine Erkenntnis, dass 
dieses Problem auch ohne diese Methodenkombination in rsyback.zykl 
auftritt!
 Was passiert da? Nehmen wir eine Datei, die sich zwischen frueheren 
Backups veraendert hat, nicht aber vor dem aktuell anstehenden 
Backup. In der aeltesten Backupebene, die als Basis fuer das neue 
Backup genommen wird befindet sich demnach eine abweichende 
Datei. Folglich gibt es keinen Hardlink!
 Bei einer einzelnen Dateiaenderung wird mit jedem Backupvorgang eine 
zusaetzliche Datei (identisch) gespeichert, bis alle Backupebenen 
je eine besitzen. Mit jedem weiteren Vorgang wird dann die Redundanz 
wieder schrittweise abgebaut.
 Die Zeitersparnis liegt um die 35 %.

rsyback.splitt   [4] basiert auf [1], nur wurde die Befehls-
Reihenfolge geaendert. Das Script wird bei mir waehrend des bootens 
gestartet, weil zu diesem Zeitpunkt alle Dateien konsistent sind. 
(Start in boot.local unter Suse.) Zu diesem Zeitpunkt muss aber nur 
rsync fertig werden, die zeitraubenden  cp -al  und  rm -rf
gehen in den Hintergrund. cp sollte fertig sein, bevor der Rechner 
wieder heruntergefahren wird (auf Konsole 1 ggf. nachschauen) aber 
beim rm ist sogar das unkritisch, sodass es ein  nice  mit auf den 
Weg bekommt.
 Die Zeitersparnis liegt um die 35 %, allerdings laeuft da der 
Hintergrundprozess noch.
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

Meine Wahl faellt klar auf [4]. Vielleicht kann sich mal jemand 
aeussern, ob der Hintergrundprozess in [4] besser in {} oder () 
eingeschlossen werden sollte. Funktioniert hat beides.

Es folgen alle diskutierten Scripte. (Die Anzahl der Backupsaetze i=4
ist ein Testwert. Ich werde ihn wahrscheinlich auf 730 setzen
(2 Jahre Tages-History.)

##################################### rsyback.cp       [1]:

#! /bin/bash
# rsync-backup
# ausfuehrbar abgelegt unter /home

# Anzahl der Backupsaetze 0...i:
i=4

echo -e "\a"
mount /dev/md0 /mnt
cd /mnt/backup

#ts_now=$(date +%s)
#ts_dir=$(date --reference=backup.0 +%s)
#age=$[ts_now-ts_dir] # in Sekunden
#if [ $age -lt 43200 ]; then
# echo "Backup uebersprungen. ##########################################"
# exit
#fi

echo $(date -I;date +%T) hoechste Backupdatei $i loeschen...
rm -rf backup.$i

echo $(date -I;date +%T) Backupdateien 1 bis $[i-1] um eins hochschieben...
while [ $i -ge 2 ] ; do
 mv backup.$[i-1] backup.$i
 i=$[i-1]
done

echo $(date -I;date +%T) Backupdatei 0 mit Befehl  cp -al  auf Backuptdatei 1 kopieren...
cp -al backup.0 backup.1

echo $(date -I;date +%T) /home mit  rsync  auf Backupdatei 0 kopieren...
rsync -a --delete-excluded           \
 --exclude=NOT_rsyback/              \
 --exclude=.local/share/Trash/       \
 --exclude=.kde/share/apps/ktorrent/ \
 --exclude=.beagle/                  \
 /home  backup.0
touch   backup.0
# exclude-Pfad darf nur soweit angegeben werden, wie er im ZIELvereichnis erscheint.
# Abschliessendes / bezeichnet ein Directory, ohne / Datei oder Directory.

mount -o remount,ro /mnt

echo $(date -I;date +%T) Backupmedium wurde ro gemountet. Ende

##################################### rsyback.linkdest [2]

#! /bin/bash
# rsync-backup
# ausfuehrbar abgelegt unter /home

# Anzahl der Backupsaetze 0...i:
i=4

echo -e "\a"
mount /dev/md0 /mnt
cd /mnt/backup

#ts_now=$(date +%s)
#ts_dir=$(date --reference=backup.0 +%s)
#age=$[ts_now-ts_dir] # in Sekunden
#if [ $age -lt 43200 ]; then
# echo "Backup uebersprungen. ##########################################"
# exit
#fi

echo $(date -I;date +%T) Start backup
rm -rf backup.$i
echo $(date -I;date +%T) hoechste Backupdatei $i geloescht
j=$i
while [ $i -ge 1 ] ; do
 mv backup.$[i-1] backup.$i
 i=$[i-1]
done
echo $(date -I;date +%T) Backupdateien 0 bis $[j-1] um eins hochgeschoben


# If --link-dest=DIR is a relative path, it is relative to the destination directory:

rsync -a --delete-excluded --link-dest=../backup.1 \
 --exclude=NOT_rsyback/              \
 --exclude=.local/share/Trash/       \
 --exclude=.kde/share/apps/ktorrent/ \
 --exclude=.beagle/                  \
           /home  backup.0

touch backup.0
echo $(date -I;date +%T) /home auf Backupdatei 0 kopiert mit rsync, Ende.

##################################### rsyback.zykl     [3]

#! /bin/bash
# rsync-backup (rsyback = rsyback.zykl)
# ausfuehrbar abgelegt unter /home

# Anzahl der Backupsaetze 0...i:
i=4

echo -e "\a"
mount /dev/md0 /mnt
cd /mnt/backup

#ts_now=$(date +%s)
#ts_dir=$(date --reference=backup.0 +%s)
#age=$[ts_now-ts_dir] # in Sekunden
#if [ $age -lt 43200 ]; then
# echo "Backup uebersprungen. ##########################################"
# exit
#fi

j=$i
echo $(date -I;date +%T) Backupdateien 0 bis $j um eins hochschieben...
while [ $i -ge 0 ] ; do
 mv backup.$i backup.$[i+1]
 i=$[i-1]
done

echo $(date -I;date +%T) Backupdatei $[j+1] auf Backupdate 0 schieben...
mv backup.$[j+1] backup.0

echo $(date -I;date +%T) Backupdatei 1 auf Backuptdatei 0 kopieren mit Befehl cp -al ...
cp -al backup.1/. backup.0

echo $(date -I;date +%T) /home auf Backupdatei 0 mit rsync kopieren...
rsync -a --delete-excluded           \
 --exclude=NOT_rsyback/              \
 --exclude=.local/share/Trash/       \
 --exclude=.kde/share/apps/ktorrent/ \
 --exclude=.beagle/                  \
 /home  backup.0
touch   backup.0
# exclude-Pfad darf nur soweit angegeben werden, wie er in ZIEL- und QUELL-Vereichnis
# uebereinstimmt. Abschliessendes / bezeichnet ein Directory, ohne / Datei oder Directory.


mount -o remount,ro /mnt

echo $(date -I;date +%T) Backupmedium wurde ro gemountet. Ende

##################################### rsyback.splitt   [4]

#! /bin/bash
# rsync-backup
# ausfuehrbar abgelegt unter /home

# Anzahl der Backupsaetze i:
i=4

echo -e "\a"
mount -o ro /dev/md0 /mnt
cd /mnt/backup

ts_now=$(date +%s)
ts_dir=$(date --reference=backup.0 +%s)
age=$[ts_now-ts_dir] # in Sekunden
if [ $age -lt 43200 ]; then
 echo "Backup uebersprungen. ##########################################"
 exit
fi

mount -o remount,rw /mnt

echo $(date -I;date +%T) /home mit  rsync  auf Backupdatei 0 kopieren...
rsync -a --delete-excluded           \
 --exclude=NOT_rsyback/              \
 --exclude=.local/share/Trash/       \
 --exclude=.kde/share/apps/ktorrent/ \
 --exclude=.beagle/                  \
 /home  backup.0
touch   backup.0
# exclude-Pfad darf nur soweit angegeben werden, wie er in ZIEL- und QUELL-Vereichnis
# uebereinstimmt. Abschliessendes / bezeichnet ein Directory, ohne / Datei oder Directory.

echo $(date -I;date +%T) hoechste Backupdatei $i in backup.delete schieben...
mv backup.$i backup.delete

echo $(date -I;date +%T) Backupdateien 1 bis $[i-1] um eins hochschieben...
while [ $i -ge 2 ] ; do
 mv backup.$[i-1] backup.$i
 i=$[i-1]
done

{ echo $(date -I;date +%T) Im Hintergrund: Backupdatei 0 mit Befehl  cp -al  auf Backupdatei 1 kopieren...
  cp -al backup.0 backup.1

  echo $(date -I;date +%T) Im Hintergrund: backup.delete loeschen...
  nice rm -rf backup.delete

  mount -o remount,ro /mnt
  echo $(date -I;date +%T) Im Hintergrund: Backupmedium wurde ro gemountet. Ende
} &

-- 
Viele Gruesse
Werner Holtfreter
--
http://mailman.uugrn.org/mailman/listinfo/uugrn
Wiki: http://wiki.uugrn.org/wiki/UUGRN:Mailingliste
Archiv: http://lists.uugrn.org/