PostgreSQL Backup-Strategie: Automatische Backups einrichten

Wer einen PostgreSQL-Server auf einem VPS betreibt, kennt das mulmige Gefühl: Was passiert, wenn die Festplatte ausfällt, ein Update schiefgeht oder ein fehlerhaftes Script die Produktionsdatenbank zerstört? Die Antwort ist so simpel wie entscheidend – ein zuverlässiges, automatisches Backup. In diesem Artikel zeige ich dir Schritt für Schritt, wie du eine robuste PostgreSQL Backup-Strategie mit pg_dump, Cron-Jobs und einer sauberen Rotation auf deinem Linux-Server einrichtest.

Warum automatische PostgreSQL-Backups unverzichtbar sind

Manuelle Backups sind besser als gar keine – aber sie werden vergessen, verschoben oder inkonsistent ausgeführt. Eine automatische Backup-Strategie eliminiert den menschlichen Faktor und stellt sicher, dass du im Ernstfall auf einen aktuellen, funktionierenden Datenbestand zurückgreifen kannst.

Typische Szenarien, in denen Backups dich retten:

• Hardware-Ausfälle auf dem VPS (defekte SSDs, Speicherfehler)
• Fehlgeschlagene Migrationen oder Schema-Änderungen
• Versehentliches Löschen von Tabellen oder Datensätzen (DROP TABLE ohne WHERE ist schneller getippt als gedacht)
• Ransomware oder Sicherheitsvorfälle, bei denen Daten verschlüsselt oder manipuliert werden

Voraussetzungen

Bevor wir starten, stelle sicher, dass folgende Punkte erfüllt sind:

• Ein Linux-Server (Ubuntu/Debian oder CentOS/RHEL) mit Root- oder sudo-Zugang
• PostgreSQL ist installiert und läuft (Version 12 oder neuer empfohlen)
• pg_dump und pg_dumpall sind verfügbar (werden mit PostgreSQL mitgeliefert)
• cron ist aktiv (bei den meisten Distributionen standardmäßig der Fall)

Prüfe die PostgreSQL-Version und die Verfügbarkeit der Tools:

psql --version
pg_dump --version
systemctl status cron

Backup mit pg_dump erstellen

Das Standardwerkzeug für PostgreSQL-Backups ist pg_dump. Es erstellt einen konsistenten Snapshot einer einzelnen Datenbank, auch während laufender Transaktionen.

Einzelne Datenbank sichern

pg_dump -U postgres -h localhost -F c -b -v -f /var/backups/postgresql/meine_db.dump meine_db

Die wichtigsten Flags im Überblick:

Flag	Bedeutung
-U postgres	Datenbankbenutzer
-h localhost	Host
-F c	Custom-Format (komprimiert, flexibel beim Restore)
-b	Large Objects mit einschließen
-v	Verbose-Ausgabe
-f	Zieldatei

Alle Datenbanken sichern

Wenn du mehrere Datenbanken auf deinem Server betreibst, nutze pg_dumpall:

pg_dumpall -U postgres -h localhost | gzip > /var/backups/postgresql/all_databases_$(date +%Y%m%d_%H%M%S).sql.gz

Dieser Befehl sichert alle Datenbanken inklusive Rollen und Tablespaces in eine komprimierte SQL-Datei.

Passwortlose Authentifizierung einrichten

Damit das Backup-Script ohne manuelle Passworteingabe funktioniert, legst du eine .pgpass-Datei an:

touch ~/.pgpass
chmod 600 ~/.pgpass

Trage die Zugangsdaten im folgenden Format ein:

localhost:5432:*:postgres:dein_sicheres_passwort

Das Format ist hostname:port:database:username:password. Der Stern (*) steht für alle Datenbanken. Die Datei muss die Berechtigung 600 haben, sonst ignoriert PostgreSQL sie.

Das Backup-Script

Ein sauberes Shell-Script bündelt alle Schritte – Backup erstellen, komprimieren, alte Backups aufräumen und optional Fehler loggen.

Erstelle die Datei /usr/local/bin/pg_backup.sh:

#!/bin/bash

# ==============================
# PostgreSQL Backup Script
# ==============================

# Konfiguration
BACKUP_DIR="/var/backups/postgresql"
TIMESTAMP=$(date +%Y%m%d_%H%M%S)
PG_USER="postgres"
PG_HOST="localhost"
RETENTION_DAYS=14
LOG_FILE="/var/log/pg_backup.log"

# Backup-Verzeichnis erstellen, falls nicht vorhanden
mkdir -p "$BACKUP_DIR"

# Alle Datenbanken auflisten (System-DBs ausschließen)
DATABASES=$(psql -U "$PG_USER" -h "$PG_HOST" -t -c \
  "SELECT datname FROM pg_database WHERE datistemplate = false AND datname != 'postgres';" \
  | tr -d '[:space:]' | tr '\n' ' ')

# Jede Datenbank einzeln sichern
for DB in $DATABASES; do
  BACKUP_FILE="${BACKUP_DIR}/${DB}_${TIMESTAMP}.dump"
  
  echo "[$(date)] Starte Backup von Datenbank: $DB" >> "$LOG_FILE"
  
  pg_dump -U "$PG_USER" -h "$PG_HOST" -F c -b -f "$BACKUP_FILE" "$DB" 2>> "$LOG_FILE"
  
  if [ $? -eq 0 ]; then
    echo "[$(date)] Backup erfolgreich: $BACKUP_FILE" >> "$LOG_FILE"
  else
    echo "[$(date)] FEHLER beim Backup von: $DB" >> "$LOG_FILE"
  fi
done

# Globales Backup (Rollen, Tablespaces)
echo "[$(date)] Starte globales Backup (Rollen & Konfiguration)" >> "$LOG_FILE"
pg_dumpall -U "$PG_USER" -h "$PG_HOST" --globals-only | \
  gzip > "${BACKUP_DIR}/globals_${TIMESTAMP}.sql.gz" 2>> "$LOG_FILE"

# Alte Backups löschen (Rotation)
echo "[$(date)] Lösche Backups älter als ${RETENTION_DAYS} Tage" >> "$LOG_FILE"
find "$BACKUP_DIR" -type f -mtime +${RETENTION_DAYS} -delete

echo "[$(date)] Backup-Vorgang abgeschlossen" >> "$LOG_FILE"
echo "---" >> "$LOG_FILE"

Mache das Script ausführbar:

chmod +x /usr/local/bin/pg_backup.sh

Teste es einmal manuell:

sudo -u postgres /usr/local/bin/pg_backup.sh

Prüfe anschließend, ob die Dateien in /var/backups/postgresql/ erstellt wurden und das Log unter /var/log/pg_backup.log keine Fehler zeigt.

Cron-Job für automatische Ausführung

Jetzt automatisieren wir das Ganze mit einem Cron-Job. Öffne die Crontab des postgres-Benutzers:

sudo crontab -u postgres -e

Füge folgende Zeile hinzu, um das Backup täglich um 02:00 Uhr auszuführen:

0 2 * * * /usr/local/bin/pg_backup.sh

Für zweimal täglich (02:00 und 14:00 Uhr):

0 2,14 * * * /usr/local/bin/pg_backup.sh

Überprüfe, ob der Cron-Job korrekt eingetragen ist:

sudo crontab -u postgres -l

Backup-Rotation und Speichermanagement

Die im Script eingebaute Rotation mit find -mtime +14 -delete entfernt automatisch Backups, die älter als 14 Tage sind. Passe den Wert RETENTION_DAYS an deine Anforderungen an:

• Entwicklungsserver: 7 Tage reichen meist aus
• Produktionsserver: 14–30 Tage empfohlen
• Compliance-Anforderungen: Ggf. monatliche Backups zusätzlich langfristig aufbewahren

Für eine gestaffelte Aufbewahrung (täglich/wöchentlich/monatlich) kannst du das Script erweitern:

# Wöchentliches Backup am Sonntag in separaten Ordner kopieren
if [ "$(date +%u)" -eq 7 ]; then
  mkdir -p "${BACKUP_DIR}/weekly"
  cp "${BACKUP_DIR}"/*_${TIMESTAMP}.dump "${BACKUP_DIR}/weekly/"
fi

# Monatliches Backup am 1. des Monats
if [ "$(date +%d)" -eq 01 ]; then
  mkdir -p "${BACKUP_DIR}/monthly"
  cp "${BACKUP_DIR}"/*_${TIMESTAMP}.dump "${BACKUP_DIR}/monthly/"
fi

Backup verifizieren und wiederherstellen

Ein Backup, das sich nicht wiederherstellen lässt, ist wertlos. Teste den Restore-Vorgang regelmäßig:

Einzelne Datenbank wiederherstellen

pg_restore -U postgres -h localhost -d meine_db_test -v /var/backups/postgresql/meine_db_20250711_020000.dump

Backup-Integrität prüfen

pg_restore -l /var/backups/postgresql/meine_db_20250711_020000.dump > /dev/null 2>&1 && echo "OK" || echo "FEHLERHAFT"

Integriere diese Prüfung am besten direkt ins Backup-Script, sodass du im Log sofort siehst, ob das erstellte Backup lesbar ist.

Offsite-Backup: Sicherung außerhalb des Servers

Backups, die nur auf dem gleichen Server liegen, schützen nicht vor Hardware-Ausfällen. Schiebe deine Backups zusätzlich auf einen externen Speicher:

# Backup per rsync auf zweiten Server übertragen
rsync -avz -e "ssh -i /home/postgres/.ssh/backup_key" \
  /var/backups/postgresql/ \
  backupuser@storage-server:/backups/postgresql/

# Alternative: Upload zu S3-kompatiblem Storage
aws s3 sync /var/backups/postgresql/ s3://mein-bucket/postgresql-backups/ \
  --storage-class STANDARD_IA

Monitoring und Benachrichtigung

Ergänze das Backup-Script um eine E-Mail-Benachrichtigung bei Fehlern, damit du nicht erst im Ernstfall merkst, dass die Backups seit Wochen fehlschlagen:

# Am Ende des Scripts einfügen
ERRORS=$(grep -c "FEHLER" "$LOG_FILE")
if [ "$ERRORS" -gt 0 ]; then
  tail -20 "$LOG_FILE" | mail -s "⚠️ PostgreSQL Backup FEHLER auf $(hostname)" [email protected]
fi

Fazit

Eine automatische PostgreSQL Backup-Strategie ist kein Nice-to-have, sondern Pflicht für jeden, der Datenbanken im produktiven Einsatz betreibt. Mit dem hier vorgestellten Setup aus pg_dump, einem durchdachten Shell-Script, Cron-basierter Automatisierung und einer sauberen Rotation bist du für die wichtigsten Ausfallszenarien gewappnet.

Die wichtigsten Punkte zusammengefasst:

• pg_dump im Custom-Format liefert komprimierte, flexible Backups
• Eine .pgpass-Datei ermöglicht passwortlose Ausführung im Cron-Job
• Rotation verhindert, dass der Speicher vollläuft
• Regelmäßige Restore-Tests stellen sicher, dass deine Backups im Ernstfall funktionieren
• Offsite-Kopien schützen vor dem Totalverlust des Servers

Richte dir heute noch die Automatisierung ein und teste den Restore einmal durch. Dein zukünftiges Ich wird dir danken, wenn es darauf ankommt.