Automatische Backups mit Linux

Daeccenverlust ist der Alptraum eines jeden Administrators. Das ist oft nicht nur ärgerlich, sondern kostet auch richtig Geld. Deswegen ist es nur allzu vernünftig, eine Backup-Strategie zu entwickeln.

Linux bringt alle benötigten Tools bereits mit. rsync, tar, ssh, find, cat und bash sind in nahezu jeder Distribution enhalten. Einzeln betrachtet sehen die Anwendungen auf den ersten Blick vielleicht etwas ungeeignet für ein professionelles Backup aus, doch gemeinsam und richtig eingesetzt, entwickelt sich aus ein paar Handgriffen eine gute und kostengünstige Lösung.

Dabei ist Verschlüsselung heutzutage wichtiger denn je - besonders dann, wenn Sie vertrauliche Daten sichern. Denn die Anzahl der einfach zu bedienenden Datenspionage-Tools nimmt stetig zu. Sicher darf man nicht in jedem Anwender einen potenziellen Hacker sehen, aber Vorsicht ist die Mutter der Porzellankiste.

Autorisierung über ssh

Kein Administrator hat Lust, nachts um drei Uhr ein Passwort einzugeben, damit die Sicherung anläuft. Deswegen verwenden wir eine Authentifizierungs-Methode über einen so genannten public_key. Das im Installationsstandard enthaltene Paket openssh stellt diese Option zur Verfügung.

Um den Workshop anschaulicher zu gestalten, legen wir folgendes Beispielszenario fest:

linux_a: Das ist der Rechner, der gesichert werden soll. Da normalerweise nur ein User alle Zugriffsrechte besitzt, stößt root das Backup-Script an. IP-Adresse 192.168.1.200.

linux_b: Aus Sicherheitsgründen ist ein remote login von root nicht erlaubt. Alle Backups nimmt der Benutzer backup an. IP-Adresse 192.168.1.100.

root von Rechner linux_a soll sich an Rechner linux_b verschlüsselt, aber nur mit den Rechten von User backup anmelden. Der Vorgang muss ohne Passwort-Eingabe ablaufen, sonst wäre das Backup nicht automatisierbar.

Schlüsselpaar erstellen

Der erste Schritt ist die Erstellung eines ssh-Schlüsselpaares für root auf linux_a. Folgender Befehl erledigt dies:

ssh-keygen -t rsa

Die drei nächsten Zeilen jeweils mit "Enter" bestätigen. Wichtig ist, keine Passphrase einzugeben. Wenn Sie hier ein Kennwort vergeben, verlangt die Anmeldung als User backup an linux_b nach einem Passwort. Und genau das wollen wir vermeiden. Im Verzeichnis /root/.ssh befindet sich nun unter anderem die Datei id_rsa.pub. Diese enthält den öffentlichen Schlüssel von root.

Benutzer einrichten

Der nächste Schritt führt uns auf den Rechner linux_b. Zunächst legen Sie als root mit dem Befehl

useradd -m backup

den Benutzer backup an. Dieser erhält kein Passwort. Damit ist weder lokal noch remote jemand in der Lage, sich als backup anzumelden. Das soll nur via public_key funktionieren. Mit

su - backup

wechseln wir zu dem gerade erzeugten User. Ist das Verzeichnis .ssh nicht vorhanden, legen Sie es bitte an und wechseln dorthin.

mkdir .ssh
cd .ssh

Damit der ssh-Daemon weiß, wer überhaupt als backup auf den Rechner darf, teilen wir ihm das in der Datei authorized_keys mit.

touch authorized_keys

legt eine zunächst leere Datei an. In diese Datei kopieren Sie nun den Inhalt der Datei /root/.ssh/id_rsa.pub.

Vorsicht: Auch wenn es nicht so aussieht - der Inhalt ist eine Zeile ohne Carriage Return. Um nicht über diesen Stein zu stolpern, kopieren Sie am besten die Datei id_rsa.pub auf linux_b und fügen den Schlüssel mit dem cat-Befehl

cat id_rsa.pub >> /home/backup/.ssh/authorized_keys

ein.

Test der Konfiguration

Nun sollte ein Einloggen von linux_a nach linux_b möglich sein. Als root auf linux_a probieren Sie das bitte aus.

ssh backup@192.168.1.100

Nur beim ersten Login-Versuch fragt Sie linux_a, ob Rechner linux_b in der Liste der bekannten Systeme aufgenommen werden soll. Sobald Sie das mit einem ausgeschriebenen "yes" bestätigt haben, ist die Konfiguration abgeschlossen. Probieren Sie das am besten mit den Befehlen

exit

(führt zurück auf linux_a)

ssh backup@192.168.1.100

aus. Diese Funktionalität ist die Grundlage für den weiteren Workshop.

Komplettes Backup mit rsync

Sollte rsync nicht auf Ihrem System installiert sein, so holen Sie das bitte nach.

Das Programm gehört zweifelsfrei zu den effizientesten und schnellsten Backup-Methoden. Dabei kopiert die Anwendung eigentlich nur Daten von Quelle nach Ziel. Allerdings verwendet rsync einen speziellen Algorithmus, der nur inkrementelle Abgleiche tätigt. Bei einer modifizierten Datei repliziert die Software somit nur die Änderungen und nicht das gesamte File. Gerade bei großen Dateien mit kleinen Änderungen verringert diese Vorgehensweise die Netzlast enorm. Es ist mit rsync auch möglich, Quelle und Ziel auf dem exakt gleichen Stand zu halten. Der grundsätzliche Aufruf ist

rsync [Optionen] Quelle Ziel

Die Ziele können zum Beispiel ein entfernter Rechner, eine lokale Festplatte oder ein USB-Stick sein.

Das Programm bringt eine Vielzahl an Optionen mit. Die Tabelle zeigt die wichtigsten Schalter im Überblick.

Die wichtigsten Schalter von rsync

Schalter	Funktion
-a	Archive-Modus, äquivalent zu -rlptgoD
-r	rekursiv, alle Unterverzeichnisse
-l	kopiert symbolische Links als symbolische Links und nicht als Datei
-p	bewahrt die Berechtigungen der Dateien
-t	bewahrt die Zeitstempel der Dateien
-g	bewahrt die Gruppenberechtigungen der Dateien
-o	bewahrt den Besitzer der Datei (nur root)
-D	bewahrt Devices
-v	mehr Ausgabetext auf dem Bildschirm
-q	weniger Ausgabetext auf dem Bildschirm
-u	nur Updates; überschreibt keine neueren Dateien
-W	kopiert die gesamte Datei, nicht nur das Delta
-n	Trockenlauf, zeigt nur an, was gemacht werden würde
-e	spezifiziert die remote shell (zum Beispiel ssh)
-z	Dateien komprimieren
-4	vorzugsweise IPv4 benutzen
-6	vorzugsweise IPv6 benutzen
--delete	alle Dateien, die im Ziel, aber nicht in der Quelle vorhanden sind, werden gelöscht
--exclude=<Ausdruck>	Ausschluss bestimmter Dateien
--exclude-from=<Datei>	Ausschluss bestimmter Dateien, die in Listenform in <Datei> stehen
-- =<Ausdruck>	Diese Dateien einbeziehen
--include-from=<Datei>	Dateien einbeziehen, die in Listenform in <Datei> stehen
--files-from=<Datei>	Eine exakte Liste von Dateien aus <Datei> wird kopiert

Ein Blick in die man-Page gibt einen Gesamtüberblick.

man rsync

Beispiel-Script

Für das Beispielszenario könnte ein Backup-Script so aussehen:

####### Configuration ########
REMOTE="192.168.1.100" # Rechner auf den gesichert wird
REMOTEUSER="backup" # User, auf den via ssh ohne Passwort zugegriffen wird
TARGET="/home/backup/" # Verzeichnis, wohin das Backup geschoben wird
SUBJECT="Backup_fehlgeschlagen!" # im Subject kein Leerzeichen!
MAILTO="./backup.mail" # Mailadressen, die im Error-Fall Mail erhalten
ERROR="./error.txt" # Text, der im Error-Fall versandt wird
INCLUDE="./backup.include" # Dateien, von denen ein Backup gemacht wird
EXCLUDE="./backup.exclude" # Dateien, von denen kein Backup gemacht wird

RSYNC=/usr/bin/rsync
RSYNC_OPTIONS="-rlpvu --delete-after --ignore-errors -e ssh"
CAT=/bin/cat
MAIL=/usr/bin/mail
CHECK_REMOTE=`ping -c1 $REMOTE | grep packet | awk '{print $4}'` # gibt 1 (online) oder 0 (offline) zurueck
SOURCE="/"
##############################


if [ $CHECK_REMOTE == 1 ]; then
$RSYNC $RSYNC_OPTIONS $SOURCE $REMOTEUSER\\@$REMOTE\\:$TARGET --files-from=$INCLUDE --exclude-from=$EXCLUDE
else
$CAT $MAILTO | while read line
do
$MAIL $line -s $SUBJECT < $ERROR
done
fi

Konfigurationsdateien

Wir benötigen noch zwei weitere Dateien. Mit backup.include legen Sie fest, welche Verzeichnisse berücksichtigt werden sollen, beispielsweise:

/var/
/usr/
/etc/
/boot/
/home/
/root/
/opt/
/bin/

Die Datei backup.exclude gibt an, welche Verzeichnisse nicht gesichert werden sollen, also beispielsweise:

.kde/*
.mozilla/*

Das Script backup.sh und die zugehörigen Dateien finden Sie auch auf der mitgelieferten CD im Verzeichnis.

Funktion

Das Script prüft zuerst die Erreichbarkeit von linux_b über einen ping. Ist dies der Fall, synchronisiert linux_a alles, was in "backup.include" angegeben ist, in das Verzeichnis /home/backup/ nach linux_b. Ausgenommen sind die Dateien und Verzeichnisse, die in "backup.exclude" stehen.

Der Schalter --delete-after bewirkt ein Löschen aller Dateien auf linux_b, die auf dem Rechner linux_a nicht mehr vorhanden sind. Dieses Bereinigen bezieht sich nur auf den Content der zur Synchronisation angegeben ist. Im Beispiel-Script sind alle Verzeichnisse ausgenommen, die mit .kde und .mozilla beginnen.

Gibt der ping zu linux_b eine 0 zurück, dann sendet das Script ein E-Mail mit dem Betreff "Backup_fehlgeschlagen!". Die Empfänger dieser Warnmeldung sind in der Datei backup.mail hinterlegt. Den Text für den Hinweis enthält error.txt. All diese Dateien müssen im selben Verzeichnis liegen, ansonsten sind die Pfade in den entsprechenden Parametern anzupassen.

Die Optionen --include/--include-from und --exclude/--exclude-from sind sehr intelligent. Enthält die Datei backup.include zum Beispiel den zusätzlichen Eintrag

/root/.kde/share/config/

wird dieses Verzeichnis trotzdem gesichert. Äquivalent funktioniert dies ebenfalls mit den exclude-Optionen. Statt eines Verzeichnisses können Sie auch einzelne Dateien angeben.

Im Parameter RSYNC_OPTIONS ist über den Schalter -e ssh angegeben, dass jeglicher Transfer zu linux_b verschlüsselt abläuft. Normalerweise fragt das Script das Passwort von Benutzer backup auf dem Computer linux_b ab. Wird es allerdings von root auf Rechner linux_a ausgeführt, erfolgt die Authentifizierung ohne Passwort über den public_key. Somit ist eine Automatisierung via cron sehr leicht einzurichten. Als root auf linux_a

crontab -e

ermöglicht den Eintrag eines neuen Jobs.

30 2 * * * /<Pfad-zu-Skript>/backup.sh

führt das rsync-Script jede Nacht um 2.30 Uhr aus.

Komplettes Backup mit tar

Da rsync Dateien abgleicht, befindet sich das Backup immer nur auf dem letzten Stand. Sollten Sie einen älteren Dateistand zurücksichern wollen, ist dieser logischerweise nicht mehr vorhanden. Es gibt jedoch die Möglichkeit, über die Schalter -b, --backup-dir und --suffix inkrementelle Backups zu realisieren. Allerdings zeigt die Erfahrung, dass dies mit dem Kommandozeilen-Programm tar wesentlich einfacher geht und besser zu steuern ist.

tar ist so etwas wie der Dinosaurier unter den Backup-Programmen. Nur ausgestorben ist es noch nicht. Der Name tar steht für Tape Archiver. Die Bezeichnung ist etwas irreführend, da historisch bedingt. Das Utility kann seinen Output auf alle beschreibbaren Geräte, in Dateien oder via pipes übergeben. Der grundsätzliche Aufruf ist:

tar [Optionen] <archiv> <Dateien/Verzeichnisse>

Die wichtigsten Schalter von tar

-c	create erzeugt eine neues Archiv
-f	Archive-Datei
-r	append hängt Dateien an vorhandenes Archiv an
-t	listet den Inhalt eines Archivs auf
-u	update hängt nur Dateien an, die neuer als die Kopie im Archiv sind
-x	extract packt Dateien aus dem Archiv aus
-j	Archiv durch bzip2 filtern
-Z	Archiv durch compress filtern
-z	Archiv durch gzip filtern
--exclude=<Datei>	Datei <Datei> ausschließen
-X, --exclude-from=<Datei>	Inhalt aus <Datei> ausschließen

Wie bei jedem Linux-Tool ergibt auch hier ein Blick in die man-Page einen Gesamtüberblick:

man tar

Beispiel-Script

Für unser Beispielszenario sieht ein Beispiel-Script so aus: User root auf linux_a triggert die Sicherung an. Die Datei backup.sh ist auf der Heft-CD im Verzeichnis /zusatzpakete/backup/tar_ssh/ hinterlegt.

########## Configuration ############
BACKUPFILES="/etc/ /home/ /usr/ /var/" # zu sichernde Verzeichnisse
REMOTE="192.168.1.100" # Rechner auf den gesichert wird
REMOTEUSER="backup" # User, auf den via ssh ohne Passwort zugegriffen wird
REMOTEDIR="/home/backup/" # Backup-Verzeichnis auf Remote-Rechner
SUBJECT="Backup_fehlgeschlagen!" # im Subject kein Leerzeichen!
ERROR="./error.txt" # Text, der im Error-Fall versandt wird
MAILTO="./backup.mail" # Mailadressen, die im Error-Fall Mail erhalten

DATE=`/bin/date +%Y%m%d` # Datum im Format YearMonthDay
HOST=`/bin/hostname`
TAR=/bin/tar
TAROPTIONS="c"
SSH=/usr/bin/ssh
CAT=/bin/cat
GZIP=/usr/bin/gzip
MAIL=/usr/bin/mail

REMOTEFILE="backup_$HOST".$DATE."tgz" # Dateiname der Backup-Datei
CHECK_REMOTE=`ping -c1 $REMOTE | grep packet | awk '{print $4}'` # gibt 1 (online) oder 0 (offline) zurueck
#####################################

if [ $CHECK_REMOTE == 1 ]; then
$TAR $TAROPTIONS $BACKUPFILES | $GZIP | $SSH $REMOTEUSER\\@$REMOTE "cat > $REMOTEDIR$REMOTEFILE"
else
$CAT $MAILTO | while read line
do
$MAIL $line -s $SUBJECT < $ERROR
done
fi

Funktion

Das Programm prüft, ob linux_b online ist. Ist dies der Fall, wird der Backup-Prozess angestoßen. Äquivalent zu dem rsync-Script sendet das Programm eine E-Mail bei Nichterreichbarkeit.

Der Parameter BACKUPFILES gibt die zu sichernden Dateien und Verzeichnise vor. Durch Leerzeichen getrennt und simpel hintereinander geschrieben wird die Variable gefüllt.

Um Platz zu sparen, schickt das Programm den Output des tar-Aufrufes zunächst durch gzip. Danach wird die Möglichkeit genutzt, über ssh ein Programm auf einem entfernten Rechner anzustoßen. Der cat-Befehl schreibt auf linux_b den Content in das Verzeichnis /home/backup und vergibt den Dateinamen im Format

backup_<Hostname von linux_a>.<Zeitstempel>.tgz

Der Vorteil hier ergibt sich aus den klar strukturierten Bezeichnungen der Backup-Archive. Allerdings möchten Sie aus Speicherplatzgründen vielleicht nicht jeden Tag ein Backup aller Dateien durchführen. Um das zu vermeiden, gibt es inkrementelle Sicherungen.

Inkrementelles Backup mit tar und find

In Standardinstallationen ist das Programm find enthalten. Der Schalter -mtime n ist für das Aufspüren von Dateien bestimmten Alters zuständig. Dabei wird im 24-Stunden-Takt gerechnet, also n*24.

-mtime -4 findet alles, was jünger als vier Tage ist.

-mtime 4 findet alles, was zwischen vier und fünf Tagen alt ist

-mtime +4 findet alles, was älter als fünf Tage ist.

Das Programm find kann noch viel mehr: Zum Beispiel findet der Schalter -mmin n alles, was n Minuten vorher verändert wurde. Ein Blick in die man-Page von find lohnt sich. Für das Beispiel-Script incremental.sh reichen uns aber die Schalter -mtime und -type. Mit -type geben wir lediglich den zu suchenden Dateityp an. Die Option f steht für reguläre Files.

Beispiel-Script

Die Datei incremental.sh ist auf der Heft-CD im Verzeichnis /zusatzpakete/backup/tar_ssh/ hinterlegt.

########## Configuration ############
BACKUPFILES="/etc/ /home/ /usr/ /var/" # zu sichernde Verzeichnisse
REMOTE="192.168.1.100" # Rechner auf den gesichert wird
REMOTEUSER="backup" # User, auf den via ssh ohne Passwort zugegriffen wird
REMOTEDIR="/home/backup/" # Backup-Verzeichnis auf Remote-Rechner
AGE="-1" # -1 = Nicht aelter als 24 Stunden, -2 = 48 ...
MAILTO="./backup.mail" # Mailadressen, die im Error-Fall Mail erhalten
SUBJECT="Backup_fehlgeschlagen!" # im Subject kein Leerzeichen!
ERROR="./error.txt" # Text, der im Error-Fall versandt wird

DATE=`/bin/date +%Y%m%d` # Datum im Format YearMonthDay
HOST=`/bin/hostname`

TAR=/bin/tar
FIND=/usr/bin/find
TAROPTIONS="c"
SSH=/usr/bin/ssh
CAT=/bin/cat
GZIP=/usr/bin/gzip
MAIL=/usr/bin/mail

REMOTEFILE="incremental_$HOST".$DATE."tgz" # Dateiname der Backup-Datei
CHECK_REMOTE=`ping -c1 $REMOTE | grep packet | awk '{print $4}'` # gibt 1 (online) oder 0 (offline) zurueck
#####################################

if [ $CHECK_REMOTE == 1 ]; then
$FIND $BACKUPFILES -mtime $AGE -type f -exec $TAR $TAROPTIONS {} \\; | $GZIP | $SSH $REMOTEUSER\\@$REMOTE "cat > $REMOTEDIR$REMOTEFILE"
else
$CAT $MAILTO | while read line
do
$MAIL $line -s $SUBJECT < $ERROR
done
fi

Funktion

Dieses Script arbeitet abgesehen von zwei Unterschieden wie das vorherige: Zum einen werden nur Dateien gesichert, die maximal 24 Stunden alt sind. Zum anderen stellen wir aus Gründen der Übersichtlichkeit dem Dateinamen ein incremental vor.

incremental__<Hostname von linux_a>.<Zeitstempel>.tgz

In einem cronjob sieht das Ganze wie folgt aus:

1. Sonntagnacht um 2.30 Uhr ein volles Backup

30 2 * * 7 /<Pfad-zu-Skript>/backup.sh

2. von Montag bis Freitag um 2.30 Uhr eine inkrementelle Sicherung

30 2 * * 1-6 /<Pfad-zu-Skript>/incremental.sh

Hier scheiden sich allerdings die Geister. Die einen halten es für sinnvoll nur einmal im Monat eine Gesamtsicherung zu machen. Andere wiederum ziehen ihre "Full Backup" alle 14 Tage. Bedenken Sie beim Festlegen Ihrer Backup-Strategie jedoch Folgendes:

Im Falle eines Desasters müssen Sie zuerst das volle Backup einspielen und dann jedes einzelne inkrementelle hinterherschieben. Nur so ist sichergestellt, dass der Stand der letzten Sicherung hundertprozentig stimmt.

Je kürzer die Abstände zwischen den "Full Backups" sind, desto geringer ist der Aufwand im "Worst Case", aber umso mehr Plattenplatz wird verbraucht.

Automatisches Löschen alter Backups

Jetzt stehen wir nur noch vor dem Problem, dass der Plattenplatz auf linux_b beschränkt ist. Wiederum ist hier das Programm find nützlich.

/usr/bin/find /home/backup/ -mtime +30 -type f -exec /bin/rm {} \;

löscht alles, was im Verzeichnis /home/backup/ älter als 30*24 Stunden alt ist.

Auch das können wir wieder mit einem cronjob automatisieren.

30 1 * * * /usr/bin/find /home/backup/ -mtime +30 -type f -exec /bin/rm {} \;

Dieser Eintrag kann nun sowohl in der crontab von root als auch von User backup stehen. Der Superuser darf ohnehin alles, und die Sicherungsarchive auf linux_b gehören dem Benutzer backup.

Vorsicht: Der Befehl löscht ohne Rückfrage.

Spielen Sie vorher einfach ein bisschen mit find, um ein Gefühl dafür zu bekommen, wie das Programm arbeitet. Zum Beispiel gibt

/usr/bin/find /etc/ -mtime +2 -type f -exec /bin/ls {} \;

alle Dateien aus dem Verzeichnis /etc/ mit allen Unterverzeichnissen auf dem Bildschirm aus, die älter als 2*24 Stunden sind.

Praxistipps

1. Das ganze Spiel funktioniert auch in die andere Richtung. Hierbei ist allerdings ein Sicherheitsaspekt zu bedenken. Wenn Rechner linux_b die Daten von linux_a holen soll, muss er sich als root anmelden. Sonst lassen sich wichtige Systemdaten nicht sichern, auf die nur der Superuser Zugriff hat. In der Regel soll aber ein direktes remote-Einloggen von root unterbunden sein.

2. Sie möchten einen Windows-Rechner sichern? Kein Problem. Mounten Sie via Samba am Anfang des Scripts einen Share des Windows-PCs ins Filesystem eines Linux-Rechners. Im Backup-Script binden Sie dieses Verzeichnis in die Sicherung mit ein. Jede Linux-Distribution liefert Samba mit. Sie legen zum Beispiel ein Verzeichnis /mnt/windowsrechner an.

mount -t smbfs -o username=<windowsuser>,passwd=<windowspasswort> //<ip-adresse-windows-rechner>/<share> /mnt/windowsrechner

lautet der Befehl, um eine Windows-Freigabe ins Linux-Filesystem einzubinden. Verwenden Sie als <share> C$, so ist die der Admin Share für die Windows-Partition C. Das heißt, Sie haben Zugriff auf das komplette Laufwerk C:\\. Ein

umount -l /mnt/windowsrechner

am Ende des Scripts löst die Verbindung wieder. Da bei dieser Lösung das Backup-Script ein Passwort im Klartext enthält, sollte es nur für root lesbar sein.

chmod 600 backup.sh

verhindert einen Zugriff anderer Benutzer auf diese Datei.

Vorsicht: Ist der Windows-Rechner offline, hat das in Verbindung mit dem rsync-Script fatale Folgen. Das Verzeichnis /mnt/windowsrechner ist leer, wenn der Sicherungsprozess beginnt. Die Funktion --delete bewirkt, dass alles auf dem Rechner linux_b gelöscht wird, was nicht auf linux_a vorhanden ist.

Sinnvoll ist es, die Windows-Rechner von linux_b aus zu sichern und vorher den ping-Check zu vollziehen. Ist der Rechner nicht erreichbar, passiert nichts außer einer gesendeten E-Mail. Oder Sie programmieren diese Eventualität in den Beispiel-Scripts nach, um das Ganze gefahrenfrei von linux_a aus laufen zu lassen.

Fazit

Bandsicherung schön und gut, aber wenn man die Kosten für Bänder und Plattenplatz gegenübergestellt, dann spricht das Ergebnis eher für einen Backupserver.

Wenn Sie diesen mit ausreichend Festplatten bestücken und mit einem RAID 5 relativ wasserdicht machen, dann ist das eine gute Lösung. Außerdem geht die Rücksicherung schneller als von Band.

Die Sicherheitsbewussten können ja trotzdem den Backup-Server noch mit einem Bandlaufwerk bestücken. "Backup ist zwar etwas für Feiglinge", aber wohl dem, der im Ernstfall eins hat. (jdo)