Serverausfall - Neue Boardsoftware - Bitte lesen

#!/bin/bash




# Dieses Script dient dazu ein Backup meiner Website zu erzeugen.
# Da auf meinem Server kein rsync vorhanden ist, musste ich mir was
# einfallen lassen. Die Lösung lautet sshfs.
#
# Das Script erstellt ein MySQL-Dump auf dem Remote-Server via ssh,
# hängt das Filesystem via sshfs ein und erzeugt mittels rsync ein
# Snapshot des eingehängten Filesystems. Dabei erzeugt rsync jeweils
# ein neues Verzeichnis welches nur die veränderten Dateien enthält.
# Unveränderte Dateien werden in diesen neuen Ordner nur mittels
# Hardlinks verknüpft. Jeder Backupordner enthält somit ein
# vollständiges Backup, jede unveränderte Datei kostet aber nur einmal
# Speicherplatz (plus ein Inode :-) )







#####################################################################
#### DIES IST EIN BEISPIEL, EINIGE VARIABLEN MÜSSEN ANGEPASST WERDEN
echo "Bitte Konfiguration erst anpassen"
exit
#### DANACH KÖNNEN DIESE ZEILEN ENTFERNT WERDEN
#####################################################################




# Vollständiger Pfad zu diesem Script
MYSCRIPT=$(readlink -f $0)




# Pfad zu diesem Script
MYSCRIPTPATH=$(dirname ${MYSCRIPT})




# Wo werden die Backupverzeichnisse abgelegt?
BACKUPPATH=/path/to/backups




# DNS-Name des Servers?
SSHHOST=www.example.de




# Root-Pfad des Servers?
SSHPATH=/




# SSH-Benutzername des Servers?
SSHUSER=MyUserName




# SSH-Keyfile des Benutzers?
SSHKEYFILE=${MYSCRIPTPATH}/ssh_keyfile




# Wo befindet sich die Datei mit den rsync Filtern?
FILTERS=${MYSCRIPTPATH}/rsync-filters.conf




# zu sichernder MySQL-Datenbankname
MYSQLDBNAME=MySQLdatabase




# MySQL-Benutzername
MYSQLUSERNAME=MySQLusername




# MySQL-Passwort (Sonderzeichen müssen mit \ escaped werden)
MYSQLPASSWORD='MySecretPassword\$'




# MySQL Kommando zum sichern der Datenbank (sichert Datenbank auf dem Server selbst, alternative siehe weiter unten)
MYSQLDUMPCMD='mysqldump -u '${MYSQLUSERNAME}' --password='${MYSQLPASSWORD}' '${MYSQLDBNAME}' > /home/database_dump.sql'




# Zeitstempel erfassen (für Datei und Ordnernamen)
TIMESTAMP=$(date +"%Y-%m-%d_%H-%M-%S")




# Hier wird der Root-Pfad des Servers via sshfs eingehängt
MNTPOINT=${MYSCRIPTPATH}/tmp/server_mountpoint




# Dies ist der temporäre Speicherort für das aktuelle Backup
TARGETPATH=${BACKUPPATH}/daily.0




# Dies ist der temporäre Dateiname (und Pfad) des aktuellen Logfiles
RSYNC_LOGFILE=${BACKUPPATH}/daily.0.log




# In dieser Datei wird der Pfad zum letzten Backup abgelegt
LASTBACKUPFILE=${BACKUPPATH}/.lastbackup.conf




# Standardoptionen für rsync festlegen
RSO_MAIN="-az --numeric-ids -v --stats --delete "




# Logformat für rsync festlegen
RSO_LOGFORMAT="--log-format=%i %n%L"







# Wenn eine Filter-Datei vorhanden, dann entsprechende Optionen für rsync festlegen
if [ -e "${FILTERS}" ] ; then
        RSO_EXCLUDE1="--delete-excluded"
        RSO_EXCLUDE2="--filter=. ${FILTERS}"
fi




# Wenn die Datei mit dem letzten Backup existiert
# und der darin enthaltende Pfad ebenfalls existiert, 
# dann entsprechende Option für rsync festlegen
if [ -e "${LASTBACKUPFILE}" ] ; then
        LASTBACKUP=$(< "${LASTBACKUPFILE}")
        if [ -d "${LASTBACKUP}"  ] ; then
                RSO_LINK_DEST="--link-dest=${LASTBACKUP}"
        fi
fi




# SSH-Verbindung zum Server aufbauen und ein mysqldump auf dem remote Server speichern
echo "Dumping mysql database to remote path '/home/database_dump.sql'"
ssh -i "${SSHKEYFILE}" ${SSHUSER}@${SSHHOST} ${MYSQLDUMPCMD} || { echo "Error while dumping the mysql database." ; exit 1 ; }
### Alternative für mysqldump
# SSH-Verbindung aufbauen und ein mysqldump starten, die Ausgabe wird hier lokal gespeichert.
# DBBACKUPFILE=${BACKUPPATH}/nadobnik.de/${TIMESTAMP}.sql
# ssh -i "${SSHKEYFILE}" ${SSHUSER}@${SSHHOST} ${MYSQLDUMPCMD} > "${DBBACKUPFILE}" || { echo "Error while dumping the mysql database." ; exit 1 ; }
echo




# Wenn Zielpfad des Backups nicht existiert, dann anlegen, sonst ist vorher schon mal was schief gegangen, dann exit.
[ ! -e "${TARGETPATH}" ] && mkdir -p "${TARGETPATH}" || { echo "TARGETPATH '${TARGETPATH}' already exists." ; exit 1 ; }




## Wenn Pfad zum Mountpunkt nicht existiert, dann erzeugen
[ ! -e "${MNTPOINT}" ] && mkdir -p "${MNTPOINT}"




# Wenn Pfad bereits gemountet, dann Meldung ausgeben, sonst mounten
if mount | grep fuse.sshfs | grep "${MNTPOINT}" > /dev/null 2>&1 ; then
        echo "SSH filesystem is already mounted at mount point '${MNTPOINT}'"
else
        echo "Mounting '${SSHHOST}' to mount point '${MNTPOINT}'"
        sshfs -o idmap=user -o IdentityFile="${SSHKEYFILE}" ${SSHUSER}@${SSHHOST}:${SSHPATH} "${MNTPOINT}" || { echo "Error while  mounting the sshfs." ; exit 1 ; }
fi
echo




# Starte rsync
echo "starting rsync..."
rsync   ${RSO_MAIN}             \
        ${RSO_EXCLUDE1}         \
        "${RSO_EXCLUDE2}"       \
        ${RSO_LINK_DEST}        \
        "${RSO_LOGFORMAT}"      \
        "${MNTPOINT}/"          \
        "${TARGETPATH}" > "${RSYNC_LOGFILE}"
STATUS=$?




# Rueckgabewert prüfen.
# 0 = fehlerfrei, 
# 24 ist harmlos; tritt auf, wenn während der Laufzeit
# von rsync noch (/tmp?) Dateien verändert oder gelöscht wurden.
# Alles andere ist fatal -- siehe man (1) rsync
if ! [ $STATUS = 24 -o $STATUS = 0 ] ; then
        echo "Fatal: rsync finished '${SERVER}' with error '$STATUS' !"




        # Verzeichnis löschen
        if [ -d ${TARGET_PATH} ] ; then
                echo "removing target path '${TARGETPATH}'"
                rm -rf ${TARGETPATH}
        else
                echo "Error: target path '${TARGETPATH}' doesn't exists"
                exit ${EXIT_ERROR}
        fi




        # Logfile löschen
        if [ -f ${RSYNC_LOGFILE} ] ; then
                echo "removing rsync logfile '${RSYNC_LOGFILE}'"
                rm -f ${RSYNC_LOGFILE}
        else
                echo "Error: rsync logfile '${RSYNC_LOGFILE}' doesn't exists"
                exit ${EXIT_ERROR}
        fi




        exit ${STATUS}
fi
echo




# Verzeichnis anfassen, um Backup-Datum zu speichern
echo "touch '${TARGETPATH}' to save backup time"
touch "${TARGETPATH}"
echo




# Pfad des neuen Backups und des logfiles
NEWBACKUPPATH=${BACKUPPATH}/${TIMESTAMP}
NEWBACKUPLOGFILE=${NEWBACKUPPATH}.log




# Logfile umbenennen
echo "moving '${RSYNC_LOGFILE}' to '${NEWBACKUPLOGFILE}'"
mv "${RSYNC_LOGFILE}" "${NEWBACKUPLOGFILE}"
if [ ! $? ] ; then
        echo "error while moving '${RSYNC_LOGFILE}' to '${NEWBACKUPLOGFILE}'"
        exit ${EXIT_ERROR}
fi
echo




# Zielordner umbenennen
echo "moving '${TARGETPATH}' to '${NEWBACKUPPATH}'"
mv "${TARGETPATH}" "${NEWBACKUPPATH}"
if [ ! $? ] ; then
        echo "error while moving '${TARGETPATH}' to '${NEWBACKUPPATH}'"
        exit ${EXIT_ERROR}
fi
echo




# Diesen Pfad in Conf-File speichern
echo "writing path '${NEWBACKUPPATH}' into '${LASTBACKUPFILE}'"
echo "${NEWBACKUPPATH}" > "${LASTBACKUPFILE}"
echo




# Filesysteme syncen
sync




# Noch ein bisschen warten vor dem aushängen des Filesystems
sleep 10




# Aushängen des sshfs und bei erfolg Mountpunkt löschen
echo "unmounting sshfs '${MNTPOINT}' and removing mount point '${MNTPOINT}'"
fusermount -u "${MNTPOINT}" && rm -rf "${MNTPOINT}"