Datenbank-Backup automatisieren mit Cronjobs

Ein Backup, das du manuell machst, machst du irgendwann nicht mehr. Punkt. Wer seine Datenbank ernsthaft schützen will, automatisiert den Prozess. Ich zeig dir vier bewährte Methoden — vom einfachen Cronjob mit mysqldump bis zum MySQLDumper-Perl-Script, das auch auf Shared Hosting funktioniert.

Methode 1: MySQLDumper Cronjob (Perl-Script)

MySQLDumper bringt ein eigenes Perl-Script mit, das speziell für Shared Hosting entwickelt wurde. Der Vorteil: Es umgeht das PHP-Timeout, weil es direkt als CGI läuft.

Einrichtung

1. Öffne die Datei perl/perlconfig.cgi in einem Texteditor
2. Trage deine Datenbank-Zugangsdaten ein:

   $dbhost = "localhost";
   $dbname = "meine_datenbank";
   $dbuser = "mein_benutzer";
   $dbpass = "mein_passwort";
   $dbport = "3306";

3. Lade die Perl-Dateien per FTP hoch und setze die Rechte:

   chmod 755 perl/*.cgi
   chmod 755 perl/*.pl

Cronjob beim Hoster einrichten

Die meisten Hoster bieten ein Web-Interface für Cronjobs. Trage dort folgende URL ein:

https://deine-domain.de/mysqldumper/perl/crondump.pl

Alternativ als System-Cronjob:

# Tägliches Backup um 3:00 Uhr
0 3 * * * /usr/bin/perl /var/www/html/mysqldumper/perl/crondump.pl

Bei Hostern wie all-inkl oder Hetzner kannst du den Cronjob auch per wget aufrufen:

0 3 * * * wget -q -O /dev/null "https://deine-domain.de/mysqldumper/perl/crondump.pl?config=1"

Konfiguration in MySQLDumper

In der MySQLDumper-Oberfläche unter „Cron“ kannst du festlegen:

• Welche Datenbank gesichert wird
• Ob die Backup-Datei komprimiert werden soll (GZip)
• Ob alte Backups automatisch gelöscht werden
• E-Mail-Benachrichtigung nach erfolgreichem Backup

Methode 2: crontab + mysqldump

Die klassische Methode für alle, die SSH-Zugang haben. Simpel, zuverlässig, kein Schnickschnack.

Einfaches Backup-Script

Erstelle eine Datei /home/user/backup_db.sh:

#!/bin/bash

# Konfiguration
DB_USER="backup_user"
DB_PASS="sicheres_passwort"
DB_NAME="meine_datenbank"
BACKUP_DIR="/home/user/backups"
DATE=$(date +%Y-%m-%d_%H-%M)

# Verzeichnis erstellen falls nötig
mkdir -p $BACKUP_DIR

# Backup erstellen und komprimieren
mysqldump -u $DB_USER -p$DB_PASS $DB_NAME | gzip > $BACKUP_DIR/${DB_NAME}_${DATE}.sql.gz

# Backups älter als 30 Tage löschen
find $BACKUP_DIR -name "*.sql.gz" -mtime +30 -delete

# Optional: Erfolgsmeldung
echo "Backup $DB_NAME erstellt: ${DB_NAME}_${DATE}.sql.gz"

Rechte setzen und Cronjob einrichten:

chmod 700 /home/user/backup_db.sh

# Crontab bearbeiten
crontab -e

# Zeile hinzufügen (täglich um 2:30 Uhr):
30 2 * * * /home/user/backup_db.sh >> /home/user/backup.log 2>&1

Sicherheitshinweis: Passwort nicht im Script

Besser als das Passwort im Script zu haben ist eine .my.cnf im Home-Verzeichnis:

# ~/.my.cnf
[mysqldump]
user=backup_user
password=sicheres_passwort

chmod 600 ~/.my.cnf

Dann kann das Script ohne -u und -p Optionen arbeiten:

mysqldump $DB_NAME | gzip > $BACKUP_DIR/${DB_NAME}_${DATE}.sql.gz

Mehrere Datenbanken sichern

#!/bin/bash

BACKUP_DIR="/home/user/backups"
DATE=$(date +%Y-%m-%d_%H-%M)
DATABASES="db_wordpress db_shop db_forum"

mkdir -p $BACKUP_DIR

for DB in $DATABASES; do
  mysqldump $DB | gzip > $BACKUP_DIR/${DB}_${DATE}.sql.gz
done

find $BACKUP_DIR -name "*.sql.gz" -mtime +30 -delete

Methode 3: Perl-Script (ohne MySQLDumper)

Falls du Perl auf dem Server hast, aber kein MySQLDumper installieren willst, geht es auch mit einem einfachen Perl-Script:

#!/usr/bin/perl
use strict;
use warnings;
use POSIX qw(strftime);

my $db_user = "backup_user";
my $db_name = "meine_datenbank";
my $backup_dir = "/home/user/backups";
my $date = strftime("%Y-%m-%d_%H-%M", localtime);
my $filename = "${db_name}_${date}.sql.gz";

system("mysqldump -u $db_user $db_name | gzip > $backup_dir/$filename");

# Alte Backups aufräumen (30 Tage)
opendir(my $dh, $backup_dir);
while (my $file = readdir($dh)) {
  next unless $file =~ /\.sql\.gz$/;
  my $filepath = "$backup_dir/$file";
  if (-M $filepath > 30) {
    unlink $filepath;
  }
}
closedir($dh);

print "Backup erstellt: $filename\n";

Methode 4: FTP-Backup (Offsite-Sicherung)

Ein Backup auf demselben Server ist besser als keins — aber nicht viel. Für echte Sicherheit brauchst du eine Offsite-Kopie. Hier ein Script, das das Backup automatisch per FTP auf einen zweiten Server überträgt:

#!/bin/bash

# Lokales Backup erstellen
DB_NAME="meine_datenbank"
BACKUP_DIR="/home/user/backups"
DATE=$(date +%Y-%m-%d_%H-%M)
FILE="${DB_NAME}_${DATE}.sql.gz"

mysqldump $DB_NAME | gzip > $BACKUP_DIR/$FILE

# Per FTP hochladen
ftp -inv <<EOF
open backup-server.de
user ftp_benutzer ftp_passwort
binary
cd /backups
put $BACKUP_DIR/$FILE
bye
EOF

echo "Backup $FILE lokal und remote gesichert."

Besser als FTP ist natürlich SFTP oder SCP:

# Per SCP auf Remote-Server kopieren (SSH-Key nötig)
scp $BACKUP_DIR/$FILE [email protected]:/backups/

Oder mit rclone direkt in die Cloud (S3, Google Drive, etc.):

rclone copy $BACKUP_DIR/$FILE remote:backups/mysql/

Restore — Backup wiederherstellen

Das beste Backup ist nutzlos, wenn du nicht weißt, wie du es wiederherstellst. Hier die Methoden für die verschiedenen Backup-Formate.

Unkomprimiertes SQL-Backup

mysql -u root -p meine_datenbank < backup.sql

GZip-komprimiertes Backup

gunzip < backup.sql.gz | mysql -u root -p meine_datenbank

Oder in zwei Schritten:

gunzip backup.sql.gz
mysql -u root -p meine_datenbank < backup.sql

Restore über MySQLDumper

1. MySQLDumper im Browser öffnen
2. „Wiederherstellung" im Menü wählen
3. Backup-Datei aus der Liste auswählen (oder hochladen)
4. Ziel-Datenbank wählen und „Start" klicken

MySQLDumper macht den Restore ebenfalls in Chunks — damit klappt auch die Wiederherstellung großer Datenbanken ohne Timeout.

Nur bestimmte Tabellen wiederherstellen

Falls du nur einzelne Tabellen brauchst:

# Tabelle aus Dump extrahieren (mit sed)
sed -n '/^-- Table structure for table `users`/,/^-- Table structure for table/p' backup.sql > users_only.sql

# Oder direkt bei mysqldump nur eine Tabelle sichern
mysqldump meine_datenbank users > users_backup.sql

Cron-Zeitformate — Kurzreferenz

Weil ich das selbst jedes Mal nachschlage:

Fazit

Welche Methode du wählst, hängt von deiner Hosting-Situation ab:

• Shared Hosting ohne SSH: MySQLDumper Perl-Script (Methode 1)
• Root-Server / VPS: crontab + mysqldump (Methode 2)
• Maximale Sicherheit: Lokales Backup + Offsite-Kopie (Methode 2 + 4)

Egal welche Variante — teste den Restore regelmäßig. Ein Backup, das sich nicht wiederherstellen lässt, ist kein Backup. Ich mache einmal im Quartal einen Test-Restore auf einer leeren Datenbank. Kostet 10 Minuten, spart im Ernstfall Tage.