- Was muss eigentlich gesichert werden?
- Docker Volumes mit tar sichern
- docker commit vs. docker save – Container-State sichern
- Docker Compose Stacks richtig sichern
- Datenbank-Backups – mysqldump & pg_dump
- Automatisiertes Backup-Script mit Cron
- Restore-Szenarien: Vom einzelnen Container bis zum kompletten Host
- Offsite-Backups mit rsync und borg
- Troubleshooting: Häufige Probleme beim Backup/Restore
- Checkliste: Deine Docker-Backup-Routine
- Weiterführende Quellen
- Fazit
Korrigiert am 24.10.2026: Nach einem Leserhinweis haben wir die Backup- und Restore-Scripts repariert — beim Veröffentlichen waren die geschweiften Klammern der Variablen verloren gegangen, die Scripts sicherten dadurch nichts. Außerdem nutzen sie jetzt
docker compose(v2).
Nachtrag 31.10.2026: Ein weiterer Leserhinweis deckte eine Lücke auf: Die Scripts sicherten nur benannte Volumes, keine Bind-Mounts. Die fehlten damit bei einem Host-Verlust komplett. Beide Scripts lesen die Pfade jetzt über
docker inspectaus den Containern und bringen den passenden Restore mit. Danke an Fred für beide Hinweise.
Wer sein Homelab mit Docker betreibt, kennt das Problem: Nach Stunden der Konfiguration läuft endlich alles perfekt – doch was passiert bei einem Hardware-Defekt, versehentlichem docker compose down -v oder beim Umzug auf einen neuen Host? Ohne vernünftiges Backup-Konzept beginnt die Arbeit von vorn.
In diesem Guide zeige ich dir, wie du deine Docker-Container, Volumes und Compose-Stacks professionell sicherst und im Ernstfall schnell wiederherstellst – von manuellen Backups über automatisierte Scripts bis hin zu Offsite-Strategien mit rsync und borg.
Was muss eigentlich gesichert werden?#
Docker-Umgebungen bestehen aus mehreren Komponenten, die unterschiedliche Backup-Strategien erfordern:
Docker Images vs. Container vs. Volumes#
Docker Images sind die Vorlagen, aus denen Container entstehen. In den meisten Fällen musst du Images nicht sichern – sie lassen sich jederzeit aus Docker Hub oder deiner Registry neu laden. Anders sieht es bei selbst gebauten Images aus, hier ist ein Backup der Dockerfiles (idealerweise in Git) wichtiger als das Image selbst.
Container sind laufende Instanzen von Images. Ihren Status zu sichern macht nur in Ausnahmefällen Sinn (z. B. bei langwierigen Konfigurationen im Container selbst). Die bessere Strategie: Container als ephemer betrachten und stattdessen Konfiguration und Daten extern halten.
Volumes sind dein wichtigstes Backup-Ziel. Hier liegen die persistenten Daten deiner Anwendungen: Datenbanken, Uploads, Konfigurationsdateien. Volumes müssen regelmäßig gesichert werden.
Was gehört ins Backup?#
Für ein vollständiges Docker-Backup brauchst du:
- Docker Volumes – die persistenten Daten
- docker-compose.yml und zugehörige
.env-Dateien - Bind Mounts – Verzeichnisse auf dem Host, die in Container gemountet werden
- Netzwerk-Konfigurationen (bei komplexen Setups)
- Custom Images und Dockerfiles (bei selbst gebauten Images)
Für einen typischen Homelab-Stack reicht in 90 % der Fälle: Volumes sichern + Compose-Dateien versionieren.
Docker Volumes mit tar sichern#
Die einfachste und zuverlässigste Methode für Volume-Backups ist die Verwendung eines temporären Containers mit tar. So gehst du vor:
Volume-Backup erstellen#
# Volume mit tar in ein Backup-Archiv packen
docker run --rm \
-v mein-volume:/data \
-v /backup:/backup \
alpine tar czf /backup/mein-volume-$(date +%Y%m%d).tar.gz -C /data .
Was passiert hier?
- Ein Alpine-Container wird gestartet (klein und schnell)
- Das Volume
mein-volumewird nach/datagemountet - Ein Backup-Verzeichnis auf dem Host wird nach
/backupgemountet tar czferstellt ein komprimiertes Archiv--rmräumt den Container nach dem Backup auf
Volume-Backup wiederherstellen#
# Neues Volume erstellen
docker volume create mein-volume-restored
# Backup ins Volume entpacken
docker run --rm \
-v mein-volume-restored:/data \
-v /backup:/backup \
alpine tar xzf /backup/mein-volume-20260208.tar.gz -C /data
Praxis-Tipp: Container vorher stoppen#
Bei Datenbanken und anderen Anwendungen mit aktivem Schreibzugriff solltest du den Container vorher stoppen:
docker compose stop mariadb
docker run --rm -v projektname_db_data:/data -v /backup:/backup \
alpine tar czf /backup/mariadb-backup-$(date +%Y%m%d).tar.gz -C /data .
docker compose start mariadb
Alternativ: Verwende die Backup-Mechanismen der Anwendung selbst (siehe Abschnitt Datenbank-Backups).
docker commit vs. docker save – Container-State sichern#
Manchmal möchtest du nicht nur Daten, sondern den kompletten Container-Zustand sichern. Docker bietet dafür zwei Befehle:
docker commit – Container als Image sichern#
docker commit erstellt aus einem laufenden oder gestoppten Container ein neues Image:
# Container pausieren und als Image committen
docker commit -p mysql-nextcloud mysql-nextcloud_backup_08.02.2026
# Image als tar-Datei exportieren
docker save -o ~/mysql_nextcloud_backup.tar mysql-nextcloud_backup_08.02.2026
Wann nützlich?
- Nach manueller Konfiguration im Container
- Vor größeren Updates als Fallback
- Beim Umzug auf einen anderen Host
Wichtig: -p pausiert den Container während des Commits, um Datenkonsistenz zu gewährleisten.
docker save vs. docker export#
docker savesichert ein Image mit History und Layersdocker exportexportiert nur das Dateisystem eines Containers (keine Metadaten, keine Layers)
Für Backups ist docker save die bessere Wahl, da du das Image inkl. aller Informationen später mit docker load wiederherstellen kannst:
# Image wiederherstellen
docker load -i ~/mysql_nextcloud_backup.tar
Warum commit nicht die beste Lösung ist#
Container-Commits verstoßen gegen das Infrastructure-as-Code-Prinzip. Besser: Konfiguration in Dockerfiles und docker-compose.yml pflegen, nur Daten (Volumes) sichern. Commits sind ein Notfall-Werkzeug, keine langfristige Strategie.
Docker Compose Stacks richtig sichern#
Wenn du mit Docker Compose arbeitest (und das solltest du!), wird das Backup deutlich einfacher. Ein Compose-Stack besteht aus:
docker-compose.yml– die Stack-Definition.env– Umgebungsvariablen (Passwörter, Ports, etc.)- Volumes – die persistenten Daten
- Optional: Custom Dockerfiles, Konfigurationsdateien
Compose-Stack komplett sichern#
Ein Stack hat zwei Sorten persistenter Daten. Named Volumes (nextcloud_app) liegen bei Docker unter /var/lib/docker/volumes/ und lassen sich nur über einen Hilfscontainer lesen. Bind-Mounts (./config:/config) sind ganz normale Verzeichnisse auf dem Host — docker volume ls kennt sie nicht. Wer nur die Volumes sichert, verliert bei einem Host-Verlust die Bind-Mounts. Das Script liest deshalb beide über docker inspect aus den Containern des Stacks aus:
#!/bin/bash
STACK_NAME="nextcloud"
BACKUP_DIR="/backup/docker-stacks"
DATE=$(date +%Y%m%d-%H%M)
mkdir -p "$BACKUP_DIR/$STACK_NAME/$DATE"
# 1. Compose-Dateien sichern
cd /opt/docker/$STACK_NAME
cp docker-compose.yml .env "$BACKUP_DIR/$STACK_NAME/$DATE/"
# 2. Alle Volumes des Stacks sichern (Compose v2 markiert sie mit dem Projekt-Label)
for volume in $(docker volume ls -q --filter "label=com.docker.compose.project=${STACK_NAME}"); do
docker run --rm \
-v "${volume}:/data:ro" \
-v "${BACKUP_DIR}/${STACK_NAME}/${DATE}:/backup" \
alpine tar czf "/backup/${volume}.tar.gz" -C /data .
done
# 3. Bind-Mounts sichern: Host-Verzeichnisse, die der Container direkt einbindet.
# Welche Pfade das sind, liest man aus den Mounts der Container — nicht raten.
mapfile -t BIND_PATHS < <(
for cid in $(docker ps -aq --filter "label=com.docker.compose.project=${STACK_NAME}"); do
docker inspect "$cid" \
--format '{{range .Mounts}}{{if eq .Type "bind"}}{{.Source}}{{"\n"}}{{end}}{{end}}'
done | awk 'NF' | sort -u # awk NF: Container ohne Bind-Mount liefern eine Leerzeile
)
if [ ${#BIND_PATHS[@]} -gt 0 ]; then
# -P: absolute Pfade ins Archiv schreiben, damit der Restore sie exakt zurückschreiben kann
tar czf "$BACKUP_DIR/$STACK_NAME/$DATE/bind-mounts.tar.gz" -P "${BIND_PATHS[@]}"
fi
echo "Backup abgeschlossen: $BACKUP_DIR/$STACK_NAME/$DATE"
Compose-Stack wiederherstellen#
#!/bin/bash
STACK_NAME="nextcloud"
BACKUP_DIR="/backup/docker-stacks/nextcloud/20260208-1400"
# 1. Compose-Dateien zurückkopieren
mkdir -p /opt/docker/$STACK_NAME
cd /opt/docker/$STACK_NAME
cp "$BACKUP_DIR/docker-compose.yml" "$BACKUP_DIR/.env" .
# 2. Container und Volumes anlegen, ohne zu starten
docker compose up --no-start
# 3. Volumes wiederherstellen (Archivname = voller Volume-Name)
for backup in "$BACKUP_DIR"/*.tar.gz; do
volume=$(basename "$backup" .tar.gz)
[ "$volume" = "bind-mounts" ] && continue # kein Docker-Volume, kommt in Schritt 4
docker run --rm \
-v "${volume}:/data" \
-v "${BACKUP_DIR}:/backup" \
alpine tar xzf "/backup/${volume}.tar.gz" -C /data
done
# 4. Bind-Mounts zurückschreiben (absolute Pfade, überschreibt die Host-Verzeichnisse)
if [ -f "$BACKUP_DIR/bind-mounts.tar.gz" ]; then
tar xzf "$BACKUP_DIR/bind-mounts.tar.gz" -P -C /
fi
# 5. Stack starten
docker compose up -d
Datenbank-Backups – mysqldump & pg_dump#
Bei Datenbank-Containern ist ein Volume-Backup zwar möglich, aber nicht ideal. Besser: Die Datenbank-Tools verwenden.
MySQL/MariaDB Backup#
# Backup mit mysqldump
docker exec mariadb-container \
mysqldump -u root -p'deinPasswort' --all-databases \
| gzip > /backup/mysql-all-$(date +%Y%m%d).sql.gz
# Einzelne Datenbank
docker exec mariadb-container \
mysqldump -u wordpress -p'dbpass' wordpress \
| gzip > /backup/wordpress-$(date +%Y%m%d).sql.gz
MySQL Restore#
# Restore aus Backup
gunzip < /backup/wordpress-20260208.sql.gz | \
docker exec -i mariadb-container mysql -u wordpress -p'dbpass' wordpress
PostgreSQL Backup#
# Postgres-Backup
docker exec postgres-container \
pg_dumpall -U postgres | gzip > /backup/postgres-$(date +%Y%m%d).sql.gz
# Restore
gunzip < /backup/postgres-20260208.sql.gz | \
docker exec -i postgres-container psql -U postgres
Wichtig: Für produktive Datenbanken solltest du zusätzlich Point-in-Time-Recovery (PITR) mit WAL-Archivierung einrichten.
Automatisiertes Backup-Script mit Cron#
Manuelle Backups sind fehleranfällig. Automatisiere sie mit einem zentralen Backup-Script:
#!/bin/bash
# /opt/scripts/docker-backup.sh
set -euo pipefail
BACKUP_BASE="/backup/docker"
DATE=$(date +%Y%m%d-%H%M)
RETENTION_DAYS=30
mkdir -p "$BACKUP_BASE/$DATE"
# Funktion: Volume sichern
backup_volume() {
local volume=$1
echo "Backing up volume: $volume"
docker run --rm \
-v "${volume}:/data:ro" \
-v "${BACKUP_BASE}/${DATE}:/backup" \
alpine tar czf "/backup/${volume}.tar.gz" -C /data .
}
# Funktion: Bind-Mounts eines Stacks sichern (Host-Verzeichnisse, keine Docker-Volumes)
backup_bind_mounts() {
local project=$1
local dest=$2
local -a paths
mapfile -t paths < <(
for cid in $(docker ps -aq --filter "label=com.docker.compose.project=${project}"); do
docker inspect "$cid" \
--format '{{range .Mounts}}{{if eq .Type "bind"}}{{.Source}}{{"\n"}}{{end}}{{end}}'
done | awk 'NF' | sort -u # awk NF: Container ohne Bind-Mount liefern eine Leerzeile
)
if [ ${#paths[@]} -eq 0 ]; then
echo "Keine Bind-Mounts in $project"
return 0
fi
printf 'Bind-Mount: %s\n' "${paths[@]}"
# --exclude: falls das Backup-Ziel selbst unter einem Bind-Mount liegt (Endlosschleife)
tar czf "$dest" -P --exclude="$BACKUP_BASE" "${paths[@]}"
}
# Funktion: Compose-Stack sichern
backup_stack() {
local stack_dir=$1
local project
# Projektname so, wie Compose ihn vergeben hat (berücksichtigt auch "name:" in der compose-Datei)
project=$(docker ps -a --filter "label=com.docker.compose.project.working_dir=${stack_dir}" \
--format '{{.Label "com.docker.compose.project"}}' | head -n1)
[ -n "$project" ] || project=$(basename "$stack_dir" | tr '[:upper:]' '[:lower:]')
echo "Backing up stack: $project"
mkdir -p "$BACKUP_BASE/$DATE/$project"
cp "$stack_dir"/docker-compose.yml "$stack_dir"/compose.yaml "$stack_dir"/.env \
"$BACKUP_BASE/$DATE/$project/" 2>/dev/null || true
# Volumes des Stacks über das Compose-Label finden
for vol in $(docker volume ls -q --filter "label=com.docker.compose.project=${project}"); do
backup_volume "$vol"
done
# Bind-Mounts des Stacks sichern
backup_bind_mounts "$project" "$BACKUP_BASE/$DATE/$project/bind-mounts.tar.gz"
}
# Alle Stacks in /opt/docker durchgehen
for stack in /opt/docker/*; do
if [ -f "$stack/docker-compose.yml" ] || [ -f "$stack/compose.yaml" ]; then
backup_stack "$stack"
fi
done
# Alte Backups löschen
find "$BACKUP_BASE" -mindepth 1 -maxdepth 1 -type d -mtime +"$RETENTION_DAYS" -exec rm -rf {} +
# Optional: Datenbank-Dump. Containername anpassen (Compose v2 heißt ihn sonst z. B. "stack-mariadb-1");
# Cron kennt deine Shell-Variablen nicht -> Passwort hier oder in der Crontab setzen.
DB_CONTAINER="mariadb"
if docker ps --format '{{.Names}}' | grep -qx "$DB_CONTAINER"; then
if [ -n "${MYSQL_ROOT_PASSWORD:-}" ]; then
echo "Creating database dump..."
docker exec "$DB_CONTAINER" mysqldump -u root -p"$MYSQL_ROOT_PASSWORD" --all-databases \
| gzip > "$BACKUP_BASE/$DATE/mysql-all.sql.gz"
else
echo "WARNUNG: MYSQL_ROOT_PASSWORD nicht gesetzt - DB-Dump übersprungen" >&2
fi
fi
echo "Backup completed: $BACKUP_BASE/$DATE"
Cron-Job einrichten#
# Crontab bearbeiten
crontab -e
# Täglich um 2 Uhr nachts
0 2 * * * /opt/scripts/docker-backup.sh >> /var/log/docker-backup.log 2>&1
# Wöchentlich sonntags um 3 Uhr
0 3 * * 0 /opt/scripts/docker-backup.sh >> /var/log/docker-backup.log 2>&1
Monitoring: Verwende Healthchecks.io oder Uptime Kuma, um dich bei fehlgeschlagenen Backups benachrichtigen zu lassen.
Wohin mit den Backup-Archiven?#
BACKUP_BASE="/backup/docker" ist im Script nur ein Verzeichnis auf dem Docker-Host – noch kein Backup. Für die 3-2-1-Regel brauchst du mindestens zwei getrennte Ziele: eine Platte direkt am Host und eine Kopie außerhalb des Hosts.
🛒 Backup-Ziele:
- 💾 Externe USB-Festplatte (4 TB) — lokales Ziel für die täglichen Volume-Archive; hängt am Docker-Host und liegt nicht auf derselben System-SSD.
- 💾 Synology DS224+ — NAS als zentrales Ziel, wenn mehrere Hosts ihre Backups an einem Ort sammeln sollen.
- 💾 WD Red Plus 4TB — NAS-Platte für Dauerbetrieb; für eine Spiegelung brauchst du zwei davon.
Ein NAS im selben Raum ist noch keine Offsite-Kopie – die dritte Kopie gehört an einen anderen Ort (siehe Offsite-Backups).
Restore-Szenarien: Vom einzelnen Container bis zum kompletten Host#
Szenario 1: Einzelner Container crasht#
# Container neu erstellen
cd /opt/docker/nextcloud
docker compose up -d nextcloud
# Falls Daten beschädigt: Volume restore
docker compose stop nextcloud
docker run --rm \
-v nextcloud_app:/data \
-v /backup/docker/20260208-0200:/backup \
alpine tar xzf /backup/nextcloud_app.tar.gz -C /data
docker compose start nextcloud
Szenario 2: Kompletter Stack muss wiederhergestellt werden#
# Stack-Verzeichnis neu anlegen
mkdir -p /opt/docker/nextcloud
cd /opt/docker/nextcloud
# Compose-Dateien wiederherstellen
cp /backup/docker/20260208-0200/nextcloud/docker-compose.yml .
cp /backup/docker/20260208-0200/nextcloud/.env .
# Container erstellen (ohne zu starten)
docker compose up --no-start
# Alle Volumes wiederherstellen
for backup in /backup/docker/20260208-0200/nextcloud_*.tar.gz; do
volume=$(basename "$backup" .tar.gz)
docker run --rm \
-v "$volume:/data" \
-v /backup/docker/20260208-0200:/backup \
alpine tar xzf "/backup/$(basename $backup)" -C /data
done
# Bind-Mounts zurückschreiben (Archiv liegt im Projekt-Unterordner, absolute Pfade)
if [ -f /backup/docker/20260208-0200/nextcloud/bind-mounts.tar.gz ]; then
tar xzf /backup/docker/20260208-0200/nextcloud/bind-mounts.tar.gz -P -C /
fi
# Stack starten
docker compose up -d
Szenario 3: Neuer Host (Migration)#
# Auf dem alten Host: Backup erstellen
/opt/scripts/docker-backup.sh
# Backup auf neuen Host kopieren
rsync -avz /backup/docker/ neuer-host:/backup/docker/
# Auf neuem Host: Docker installieren (falls noch nicht vorhanden)
# Siehe: /tutorials/docker-auf-proxmox-einrichten/
# Stack-Struktur wiederherstellen
mkdir -p /opt/docker
cd /opt/docker
# Für jeden Stack
for stack_dir in /backup/docker/20260208-0200/*/docker-compose.yml; do
stack_name=$(basename $(dirname "$stack_dir"))
mkdir -p "$stack_name"
cp "/backup/docker/20260208-0200/$stack_name/docker-compose.yml" "$stack_name/"
cp "/backup/docker/20260208-0200/$stack_name/.env" "$stack_name/" 2>/dev/null || true
done
# Volumes wiederherstellen und Container starten (siehe Szenario 2)
# Bind-Mounts nicht vergessen: tar xzf /backup/docker/<Datum>/<stack>/bind-mounts.tar.gz -P -C /
Szenario 4: Versehentliches docker compose down -v#
Wichtig: -v löscht die Volumes! Ohne Backup sind die Daten verloren.
# Panik nicht! Volumes erst mal checken
docker volume ls
# Falls Volume noch da: Container einfach neu starten
docker compose up -d
# Falls Volume weg: Restore aus Backup (siehe Szenario 1)
Tipp: Erstelle einen Alias, der dich vor -v warnt:
# In ~/.bashrc
alias compose-down-safe='echo "⚠️ WARNUNG: Verwende --volumes nicht ohne Backup!"; docker compose down'
Offsite-Backups mit rsync und borg#
Lokale Backups schützen vor Bedienfehlern, aber nicht vor Hardware-Versagen oder Feuer. Für echte Datensicherheit brauchst du Offsite-Backups.
Rsync zu Remote-Host#
#!/bin/bash
# /opt/scripts/docker-backup-offsite.sh
BACKUP_SOURCE="/backup/docker"
REMOTE_HOST="backup-server.example.com"
REMOTE_USER="backup"
REMOTE_PATH="/mnt/backups/docker-homelab"
# Inkrementelles Backup mit rsync
rsync -avz --delete \
-e "ssh -i /root/.ssh/backup_key" \
"$BACKUP_SOURCE/" \
"$REMOTE_USER@$REMOTE_HOST:$REMOTE_PATH/"
# SSH-Key ohne Passwort vorher erstellen:
# ssh-keygen -t ed25519 -f /root/.ssh/backup_key
# ssh-copy-id -i /root/.ssh/backup_key backup@backup-server.example.com
Borg Backup für Deduplizierung#
Borg ist perfekt für Docker-Backups, da es dedupliziert und verschlüsselt:
# Borg installieren
apt install borgbackup
# Repo initialisieren
export BORG_REPO="ssh://backup@backup-server.example.com/mnt/backups/docker-homelab"
borg init --encryption=repokey
# Backup erstellen
borg create \
--compression lz4 \
--stats \
::docker-backup-{now:%Y-%m-%d_%H%M} \
/backup/docker
# Alte Backups aufräumen (7 tägliche, 4 wöchentliche, 6 monatliche behalten)
borg prune \
--keep-daily=7 \
--keep-weekly=4 \
--keep-monthly=6
Automatisierung mit Cron:
# Täglich um 4 Uhr Offsite-Backup
0 4 * * * /opt/scripts/docker-backup-offsite.sh >> /var/log/offsite-backup.log 2>&1
Mehr Details zu Backup-Strategien findest du in unserem Guide: Backup-Strategie für dein Homelab
Troubleshooting: Häufige Probleme beim Backup/Restore#
Problem: “No space left on device” beim Backup#
# Speicherplatz prüfen
df -h /backup
# Alte Backups manuell löschen
rm -rf /backup/docker/202601*
# Docker-Images aufräumen
docker image prune -a
# Volumes die nicht mehr verwendet werden
docker volume prune
Problem: Volume-Restore funktioniert nicht#
# Überprüfe, ob Volume existiert
docker volume ls | grep mein-volume
# Überprüfe Volume-Inhalt
docker run --rm -v mein-volume:/data alpine ls -lah /data
# Neu erstellen und erneut versuchen
docker volume rm mein-volume
docker volume create mein-volume
Problem: Datenbank startet nach Restore nicht#
# Logs prüfen
docker compose logs mariadb
# Häufige Ursache: Permissions
docker exec -it mariadb bash
chown -R mysql:mysql /var/lib/mysql
# Oder Volume-Restore mit korrekten Permissions
docker run --rm -v nextcloud_db:/data alpine chown -R 999:999 /data
Problem: Container findet nach Restore sein Volume nicht#
Überprüfe die Volume-Namen in docker-compose.yml:
volumes:
db_data:
external: true
name: nextcloud_db # Expliziter Name statt automatisch generiertem
Problem: Backup bricht bei großen Volumes ab#
Nutze --exclude für temporäre Dateien:
docker run --rm -v mein-volume:/data -v /backup:/backup \
alpine tar czf /backup/mein-volume.tar.gz \
--exclude='cache/*' \
--exclude='tmp/*' \
-C /data .
Checkliste: Deine Docker-Backup-Routine#
✅ Täglich:
- Automatisches Volume-Backup aller Compose-Stacks
- Datenbank-Dumps (mysqldump/pg_dump)
- Logs auf Fehler prüfen
✅ Wöchentlich:
- Offsite-Backup mit rsync/borg
- Restore-Test auf Staging-System
- Alte Backups aufräumen
✅ Monatlich:
- Vollständigen Restore-Test durchführen
- Backup-Script auf Fehler prüfen
- Speicherplatz-Planung überprüfen
✅ Bei Änderungen:
docker-compose.ymlund.envin Git committen- Dokumentation aktualisieren
- Backup-Script anpassen (neue Stacks hinzufügen)
Weiterführende Quellen#
Fertige Compose-Dateien für Homelab-Dienste, inklusive Backup-Setups: Selfhosted Apps (Compose-Beispiele)
Hetzner Cloud
Docker in der Cloud betreiben? Hetzner Cloud VPS mit Snapshots und Backups ab 4 €/Monat. Hetzner ausprobieren →
Fazit#
Ein durchdachtes Backup-Konzept ist die Lebensversicherung deines Homelabs. Mit den hier gezeigten Methoden bist du für alle Szenarien gewappnet:
- Volume-Backups mit tar für schnelle, unkomplizierte Sicherungen
- Datenbank-Dumps für konsistente DB-Backups
- Compose-Stack-Backups für reproduzierbare Deployments
- Automatisierte Scripts für zuverlässige tägliche Backups
- Offsite-Backups für echte Datensicherheit
Investiere die Zeit jetzt – dein zukünftiges Ich wird es dir danken, wenn du nach einem Ausfall in 10 Minuten statt 10 Stunden wieder online bist.
Wenn du Docker noch nicht installiert hast, schau dir unseren Guide an: Docker auf Proxmox einrichten
Hast du Fragen oder weitere Backup-Strategien? Schreib mir gerne!
Einige Links auf dieser Seite sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision – für dich ändert sich am Preis nichts. So unterstützt du diesen Blog und ermöglichst weitere kostenlose Tutorials. Danke! 🙏
[« Vorherige]
BorgBackup im Homelab: Einrichtung, Automatisierung und Cheat Sheet