Hetzner - DokuWiki

Backup2l

Inhaltsverzeichnis

Vorwort

Diese Lösung ist bestimmt nicht die Beste, deshalb Verbesserung bitte einarbeiten :)
Ich lehne jede Verantwortung / Haftung für entstandene Schäden hiermit ab! Am besten ist es, die beschriebenen Sachen auch zu verstehen! Diese Anleitung sollte Distributionsunabhängig sein. Bei mir läuft ein Debian 3.1. Die Anweisungen sollten sich jedoch auch auf andere Distributionen ummünzen lassen.

Anleitung

backup2l Installieren

Bei den meisten Distributionen als Paket dabei, ansonsten erhältlich unter http://backup2l.sourceforge.net

Unter Debian bekommt man es etwa mit

$> apt-get install backup2l

Dokumentation lesen

Keine Angst, die Doku ist nicht lang, aber sehr wichtig um die Funktionsweise zu verstehen und um einen restore durchführen zu können. Wir öffnen sie mit dem man Kommando.

$> man backup2l

backup2l konfigurieren

Jetzt wollen wir das im zweiten Schritt erworbene Wissen anwenden und backup2l konfigurieren. Dafür öffnen wir /etc/backup2l, die Konfigurationsdatei von backup2l. Zum Beispiel mit pico:

$> pico /etc/backup2l.conf

Hier ergibt Step 2 Sinn, da man sonst die Parameter der Konfigurationsdatei nicht versteht. Alle Parameter sind auch in der Konfigurationsdatei gut erklärt und wie ein Editor funktioniert sollte ein root-Besitzer wohl wissen. Jedoch hier einige Parameter und warum ich sie so gewählt habe:

SRCLIST=(/etc /root /home /var/backup.d/premilinary /var/www/domains)

Ich sichere die Konfiguration in /etc, die Benutzerdatein in /home und /root. Außerdem sichere ich noch /var/backup.d/preliminary. In diesem Verzeichnis erstelle ich die "Hotcopies" von meinen MySQL und PostgreSQL Datenbanken sowie meiner SVN Repositories. Wir werden weiter unten sehen, wie wir diese erstellen könnnen.

SKIPCOND=(-path "/var/www/domains/*/logs/*")

Da der Platz auf dem Backup-Ziel meist begrenzt ist sollte man hier grosse Verzeichnisse und Dateien, die nicht unbedingt gesichert werden müssen ausschliessen. Bei mir sind das etwa die Apache Log-Dateien.

BACKUP_DIR="/var/backup.d/final"

Ich lasse das Backup in diesem Verzeichnis erstellen. Die Dateien hier werden dann später auf den Backupserver übertragen. Gegebenenfalls kann man die Dateien hier auch noch verschlüsseln lassen.

MAX_LEVEL=1
MAX_PER_LEVEL=9
MAX_FULL=1
GENERATIONS=1
CREATE_CHECK_FILE=1

Diese Einstellungen sind für mich sinnvoll. Ich habe damit immer ein volles Backup und neun inkrementelle. Wer jeden Woche ein neues inkrementelles Backup erstellen will, der sollte max_per_level auf 6 setzen. Für eine Wiederherstellung benötigt man immer ein Vollbackup und dann die Inkrementellen.

PRE_BACKUP ()
{
    echo "start pre backup scripts"

    cd /root/backup

    sh hotcopy-mysql.sh
    sh hotcopy-svn.sh
    sh hotcopy-cyrus.sh
    sh hotcopy-postfix.sh
    sh hotcopy-postgresql.sh

    sh dump-dpkg-selections.sh

    chmod -R u=rw,go-rwx /var/backup.d/preliminary/*

    echo "pre backup scripts completed"
}
  
POST_BACKUP ()
{
    echo "Executing post backup actions."

    cd /root/backup
    chown -R root:backup /var/backup.d/final
    chmod -R u=rw,g=r /var/backup.d/final/*

    echo "The backup has been completed."
    echo "----------------------------------------------"

    sh sendemail.sh
}

Diese Kommandos werden vor bzw. nach dem Erstellen der Sicherungen ausgeführt. Wir betrachten sie unten genauer.

Zu guter Letzt in diesem Schritt erstellen wir noch das Verzeichnis /var/backup.d/final, in dem unsere Backups erstellt werden sollen.

Hotcopies erstellen

Einige Dateien lassen sich nicht einfach durch kopieren sichern, da auf sie ständig zugegriffen wird. Zu diesen Dateien gehören etwa Subversion Repositories, MySQL und PostgreSQL Datenbanken, Cyrus IMAP Verzeichnisse und der Mail-Spool von Postfix in /var/spool/. Wir müssen diese Dateien gesondert behandlen.

Wir werden entweder die mitgelieferten Werkzeuge zum erzeugen sogenannter Hotcopies - also Datensicherungen während die Programme laufen - benutzen, oder ein wenig rumtricksen. Weil die Befehle, die wir hierfür benötigen nicht ganz trivial sind und wir unsere Konfigurationsdatei mit ihnen nicht überfüllen wollen, lagern wir die einzelnen Schritte in weitere Shellscripte aus. Diese speichern wir in /root/backup.

Gucken wir uns diese Skripten kurz an.

MySQL Hotcopies

Wir benutzen hier einfach das mysqldump Programm, um Datensicherungen unserer MySQL Datenbanken durchzuführen.

  
#!/bin/sh

# This script creates a hot copy of the mysql data files.
echo "creating mysql dump"

echo "   removing old dumps and creating directory"
mkdir -p /var/backup.d/preliminary/mysql
rm /var/backup.d/preliminary/mysql/all.dump

echo "   executing mysqldump"
mysqldump -A --add-locks -u root --password=miro4711 > /var/backup.d/preliminary/mysql/all.dump

echo "mysql dump created"

PostgreSQL Hotcopies

Auch hier benutzen wir wieder ein mit dem Datenbankserver mitgeliefertes Werkzeug: pg_dumpall. In der letzten Zeile führen wir pg_dumpall als Benutzer postgres aus, da dieser bei Standardinstallationen vollen Zugriff auf alle Datenbanken hat und root nicht.

  
#!/bin/sh

USER=postgres
COMMAND="pg_dumpall --clean --column-inserts"
TARGET_DIR=/var/backup.d/preliminary/postgres
TARGET_FILE=pg_dumpall.sql

echo "creating PostgreSQL backup"

if [ ! -d $TARGET_DIR ]
  echo "  create $TARGET_DIR"
  then mkdir $TARGET_DIR
fi

echo "  executing pg_dumpall"
sudo -u postgres pg_dumpall > ${TARGET_DIR}/${TARGET_FILE}

Subversion Hotcopies

Auch Subversion bringt wieder ein Programm zum Erstellen von Sicherungen mit. Wir rufen svnadmin mit dem Kommando hotcopy auf.

  
#!/bin/sh

# This script creates a hot copy of a all subversion repositories in
# /var/svn.

echo "creating Subversion repository hotcopies"

echo "   removing old subversion hotcopies"
rm -rf /var/backup.d/preliminary/svn
mkdir -p /var/backup.d/preliminary/svn

pushd /var/svn > /dev/null

for repository in `ls`
do
    if [ -d $repository ]
    then
        echo "   creating hotcopy of ${repository}"
        svnadmin hotcopy $repository "/var/backup.d/preliminary/svn/${repository}"
    fi
done

popd > /dev/null

Cyrus Sicherung

Cyrus bringt meines Wissens kein Hotcopy Werkzeug mit. Die Cyrus Entwickler empfehlen Backups auf Dateisystemebene zu machen, also über LVM oder mit rsync. Wir werden hier letzteren Weg gehen. Wir erstellen erst mit rsync Kopien der Cyrus-Daten. Dann halten wir den Server an und kopieren die Daten noch einmal mit rsync. rsync kopiert dabei nur die Veränderung an den Dateien. Danach starten wir den Server wieder. Dies minimiert die Zeit, in denen der Server nicht erreichbar ist.

 
#!/bin/sh

# This script creates a hot copy of the cyrus data files.

# We use a trick from the cyrus wiki. First, we use rsync to copy the spool
# and the cyrus dbs to the preliminary backup directory. Then, we shut down
# cyrus, rsync again and start cyrus again. This way, we reduce cyrus' downtime
# to a minimum.

echo "creating Cyrus backup"

echo "   creating directories"
rm -rf /var/backup.d/preliminary/cyrus
rm -rf /var/backup.d/preliminary/sieve
mkdir -p /var/backup.d/preliminary/cyrus/lib
mkdir -p /var/backup.d/preliminary/cyrus/spool
mkdir -p /var/backup.d/preliminary/sieve/spool

echo "   first rsync pass"

rsync -r /var/lib/cyrus /var/backup.d/preliminary/cyrus/lib
rsync -r /var/spool/cyrus /var/backup.d/preliminary/cyrus/spool
rsync -r /var/spool/sieve /var/backup.d/preliminary/sieve/spool

echo "   halting cyrus"
/etc/init.d/cyrus21 stop

echo "   second rsync pass"
rsync -r /var/lib/cyrus /var/backup.d/preliminary/cyrus/lib
rsync -r /var/spool/cyrus /var/backup.d/preliminary/cyrus/spool
rsync -r /var/spool/sieve /var/backup.d/preliminary/sieve/spool

echo "   starting cyrus again"
/etc/init.d/cyrus21 start

Postfix Sicherung

Hier greifen wir zu einem ähnlichen Trick wie bei der Sicherung von Cyrus-Dateien.

  
#!/bin/sh

# We use the same trick as with cyrus here: rsync, shutdown, rsync again and
# hopefully our backup is clean then.

echo "creating Postfix backup"

echo "   creating backup directories"
rm -rf /var/backup.d/preliminary/postfix
mkdir -p /var/backup.d/preliminary/postfix

echo "   first rsync pass"
rsync /var/spool/postfix /var/backup.d/preliminary/postfix

#echo "   stop postfix"
postfix stop

#echo "   second rsync pass"
rsync /var/spool/postfix /var/backup.d/preliminary/postfix

#echo "   start postfix again"
postfix start

Cronjob Einrichten

Wir richten einen Cronjob ein. Dafür erstellen wir die Datei /etc/cron.daily/zz-backup2l mit folgendem Inhalt (es kann sein, dass diese Datei schon bei der Installation von backup2l erstellt worden ist).

  
#!/bin/bash

# The following command invokes 'backup2l' with the default configuration
# file (/etc/backup2l.conf).
#
# (Re)move it or this entire script if you do not want automatic backups.
#
# Redirect its output if you do not want automatic e-mails after each backup.

! which backup2l > /dev/null || nice -n 19 backup2l -b

Das Übertragen der Dateien

Es gibt prinzipiell zwei Möglichkeiten, die Dateien auf den Backup-Server (möglichst auf ein RAID, etwa einer der Backup-Server von Hetzner) zu bekommen. Die erste und zunächst einleuchtende ist es, von dem Server, auf dem das Backup erstellt wurde, aus auf den Zielserver (Backup-Server) zu kopieren: Push Data. Dies könnte z.B. mit scp geschehen. Die zweite Möglichkeit ist, die Daten vom Backup-Server, etwa wieder mit scp: Pull Data. Letzteres ist meiner Meinung nach empfehleswert, da dann ein Hacker nicht einfach an die Backups kommt, wenn er schon auf unserem Server eingebrochen ist.

Ich empfehle für beide Möglichkeiten scp, da man auf dem Backup-Server wahrscheinlich sowieso einen SSH Login hat und Performance bei einmaligem nächtlichen kopieren nicht so ins Gewicht fallen sollte. Außerdem hat man dann die Übertragung noch verschlüsselt. Alternativ kann man natürlich auch einen FTP-Client (etwa ncftp) oder rsync verwenden.

Optional kann man die Dateien auch noch mit gpg verschlüsseln und nur verschlüsselt übertragen. Dann sind die Daten auf dem Backup-Server auch vor dem Auslesen durch Unbefugte geschützt. Den Schlüssel zum Entschlüsseln sollte man natürlich auf keinem Server belassen sondern lokal auf einen Wechseldatenträger - etwa einen USB Stick - kopieren.

Push Data

Wir umreißen hier das Vorgehen nur kurz: Erstelle einen SSH Schlüssel und hänge ihn auf dem Backup-Server an ~/.ssh/authorized_keys an. Lösche dann den geheimen Schlüssel auf dem Server:

$> ssh-keygen -t rsa
# Jetzt ~/.ssh/id_rsa.pub auf dem Backup-Server an ~/.ssh/authorized_keys
# anhängen.
# Den geheimen Schlüssel löschen - wir benötigen ihn nicht mehr.
$> rm ~/.ssh/id_rsa

Dann erstellen wir ein kleines Backup-Skript in /root/backup und rufen es in POST_BACKUP() (s.o.) auf. Etwas wie folgendes sollte ganz gut funktionieren:

  
#!/bin/bash

SOURCE_DIRECTORY=/var/backup.d/final
TARGET_USER=backup_user
TARGET_DIRECTORY=/home/user/backup
TARGET_SERVER=backupXYZ.your-server.de

scp ${SOURCE_DIRECTORY}/* ${TARGET_USER}@${TARGET_SERVER}:${TARGET_DIRECTORY}

Alternativen Zu Backup2l

Alternativ ist auch rdiff-backup zu empfehlen.

Es kann nahezu alles, was backup2l auch kann, arbeitet aber mit einem verbesserten rsync Algorithmus und hat ein flexibleres Lebensdauer-Management als backup2l.

Mehr Informationen gibt es hier:



© 2016. Hetzner Online GmbH. Alle Rechte vorbehalten.