init at home

2026-03-27 12:41:00 +01:00
commit 352c352056
58 changed files with 13083 additions and 0 deletions
@@ -0,0 +1,472 @@
+Alles klar – ich gebe dir eine ausführliche Übersicht über **Dateisynchronisation und Backups unter Linux**, gegliedert nach typischen Anwendungsfällen (1-way Backup, 2-way Sync, Spezialfälle). Dazu zeige ich dir jeweils **interessante Funktionen**, **geeignete Tools** und **Code-Beispiele**, die du direkt ausprobieren kannst.
+
+---
+
+# 🔧 Dateisynchronisation und Backup unter Linux
+
+## 1. Grundsätzliche Anwendungsfälle
+
+1. **Backup (1-way Synchronisation)**
+    
+    - Ziel: Sicherung von Daten von Quelle → Ziel.
+        
+    - Änderungen im Quellordner werden ins Ziel kopiert.
+        
+    - Änderungen im Ziel haben keine Wirkung zurück.
+        
+    - Typisch für:
+        
+        - Regelmäßige Datensicherungen (lokal oder auf Server/NAS)
+            
+        - Snapshots und inkrementelle Backups
+            
+2. **Zwei-Wege-Synchronisation (2-way)**
+    
+    - Ziel: Quell- und Zielordner sind identisch.
+        
+    - Änderungen in beiden Richtungen werden abgeglichen.
+        
+    - Typisch für:
+        
+        - Zusammenarbeit zwischen Geräten
+            
+        - Synchronisation von Arbeitsordnern mit Netzwerkfreigaben oder Cloud
+            
+3. **Weitere Anwendungsbeispiele**
+    
+    - **Offsite-Backup** (z. B. automatisches Backup auf einen entfernten Server via SSH)
+        
+    - **Versionierte Backups** (Aufbewahrung älterer Stände)
+        
+    - **On-the-fly Synchronisation** (z. B. Watcher, der beim Speichern sofort sync’ed)
+        
+    - **Mobile Synchronisation** (z. B. Laptop ↔ NAS, USB-Stick ↔ Rechner)
+        
+
+---
+
+## 2. Tools für 1-way Backups
+
+### a) **rsync** (Klassiker)
+
+Das meistgenutzte Werkzeug, effizient und flexibel.
+
+**Einfaches Backup:**
+
+```bash
+rsync -avh /home/user/Dokumente/ /media/backup/Dokumente/
+```
+
+- `-a` = Archivmodus (erhält Rechte, Zeiten, Links)
+    
+- `-v` = verbose
+    
+- `-h` = menschenlesbare Größen
+    
+
+**Mit Löschen (Spiegelung):**
+
+```bash
+rsync -avh --delete /home/user/Dokumente/ /media/backup/Dokumente/
+```
+
+→ Dateien, die in Quelle gelöscht wurden, werden auch im Ziel gelöscht.
+
+**Über SSH (z. B. auf NAS oder Server):**
+
+```bash
+rsync -avz /home/user/Dokumente/ user@server:/backup/Dokumente/
+```
+
+- `-z` = Kompression
+    
+
+**Interessante Funktionen:**
+
+- `--exclude "*.tmp"` → bestimmte Dateien ignorieren
+    
+- `--progress` → Fortschrittsanzeige
+    
+- `--link-dest` → inkrementelle Backups mit Hardlinks (ähnlich Time Machine)
+    
+
+---
+
+### b) **borgbackup** (für versionierte, komprimierte, verschlüsselte Backups)
+
+Ideal für langfristige Backups mit Versionierung.
+
+```bash
+borg init --encryption=repokey /media/backup/repo
+borg create --progress /media/backup/repo::2025-09-26 /home/user/Dokumente
+```
+
+Später kannst du ältere Versionen wiederherstellen.
+
+---
+
+## 3. Tools für 2-way Synchronisation
+
+### a) **unison**
+
+Ein Klassiker für bidirektionale Synchronisation.
+
+**Einfacher Start:**
+
+```bash
+unison /home/user/Dokumente ssh://user@server//home/user/Dokumente
+```
+
+- Erkennt Änderungen auf beiden Seiten
+    
+- Fragt bei Konflikten nach
+    
+- Arbeitet ähnlich wie `rsync`, aber **beidseitig**
+    
+
+**Dauerhafte Konfiguration:**  
+In `~/.unison/default.prf`:
+
+```
+root = /home/user/Dokumente
+root = ssh://user@server//home/user/Dokumente
+auto = true
+batch = true
+```
+
+Dann reicht:
+
+```bash
+unison
+```
+
+---
+
+### b) **Syncthing** (komfortabel mit Weboberfläche)
+
+- Peer-to-Peer Synchronisation (Ende-zu-Ende verschlüsselt)
+    
+- Cross-Platform (Linux, Windows, Android, macOS)
+    
+- Ideal für nahtlose Syncs ohne manuellen Eingriff
+    
+
+Installation:
+
+```bash
+sudo apt install syncthing
+syncthing
+```
+
+→ Startet Weboberfläche auf [http://127.0.0.1:8384](http://127.0.0.1:8384)
+
+---
+
+## 4. Automatisierung
+
+### a) Cron-Jobs für regelmäßige Backups
+
+Beispiel: Täglich um 3 Uhr ein rsync-Backup:
+
+```bash
+0 3 * * * rsync -avh --delete /home/user/Dokumente/ /media/backup/Dokumente/
+```
+
+(`crontab -e`)
+
+### b) systemd Timer (moderner als Cron)
+
+Service-Unit (`/etc/systemd/system/backup.service`):
+
+```ini
+[Unit]
+Description=Backup Dokumente
+
+[Service]
+ExecStart=/usr/bin/rsync -avh --delete /home/user/Dokumente/ /media/backup/Dokumente/
+```
+
+Timer (`/etc/systemd/system/backup.timer`):
+
+```ini
+[Unit]
+Description=Backup Timer
+
+[Timer]
+OnCalendar=daily
+Persistent=true
+
+[Install]
+WantedBy=timers.target
+```
+
+Aktivieren:
+
+```bash
+sudo systemctl enable --now backup.timer
+```
+
+---
+
+## 5. Zusammenfassung der interessantesten Funktionen
+
+- **rsync** → universell, effizient, für Backups und Spiegelungen
+    
+- **borgbackup** → versioniert, verschlüsselt, platzsparend
+    
+- **unison** → 2-way Sync mit Konfliktlösung
+    
+- **syncthing** → benutzerfreundlich, kontinuierliche Synchronisation
+    
+
+---
+
+👉 Tipp:  
+Wenn du **nur Backups** brauchst → `rsync` oder `borg`.  
+Wenn du **aktive Ordner synchron halten willst** → `unison` oder `syncthing`.
+
+---
+
+Soll ich dir zum Einstieg ein **komplettes Setup-Skript für ein automatisches tägliches Backup mit rsync** schreiben, das du direkt verwenden kannst?
+Sehr gute Fragen 👍 — ich gehe das mit dir systematisch durch.
+
+---
+
+# 🔄 Unison: Verhalten, Hintergrundbetrieb & Performance
+
+## 1. Läuft Unison permanent im Hintergrund?
+
+Unison an sich ist **kein permanenter Daemon** wie etwa Syncthing.  
+Es funktioniert normalerweise so:
+
+- Du startest Unison → es vergleicht Quelle und Ziel → synchronisiert → beendet sich.
+    
+- Du kannst es per Cron, systemd-Timer oder manuell regelmäßig ausführen.
+    
+- Es gibt aber einen **"Unison-GUI/Repeat-Modus"**, bei dem es in einer Schleife läuft und z. B. alle 10 Sekunden die Verzeichnisse prüft.
+    
+
+Beispiel für wiederholte Synchronisation:
+
+```bash
+unison default -repeat watch
+```
+
+- `-repeat watch` = Unison nutzt OS-Funktionalitäten (inotify auf Linux), um Änderungen sofort zu erkennen.
+    
+- `-repeat 10` = alternativ: Polling alle 10 Sekunden.
+    
+
+Damit verhält sich Unison _fast_ wie Syncthing, aber ist weniger komfortabel, weil es keinen richtigen Daemon hat.
+
+---
+
+## 2. Start bei Systemstart
+
+Damit Unison automatisch startet, kannst du es mit **systemd** einrichten.
+
+### Beispiel: systemd Service-Datei
+
+`~/.config/systemd/user/unison.service`
+
+```ini
+[Unit]
+Description=Unison sync service
+After=network.target
+
+[Service]
+ExecStart=/usr/bin/unison default -repeat watch
+Restart=always
+RestartSec=5
+
+[Install]
+WantedBy=default.target
+```
+
+Dann aktivieren:
+
+```bash
+systemctl --user enable --now unison.service
+```
+
+→ Jetzt läuft Unison beim Login des Users automatisch und überwacht die definierten Profile.
+
+---
+
+## 3. Performance Impact
+
+Die Performance hängt von der Betriebsart ab:
+
+- **Einmalige Ausführung (Standard)**
+    
+    - Minimaler Impact, nur während der Synchronisation.
+        
+    - Nutzt Hashing/Datei-Checksummen, um Änderungen effizient zu erkennen.
+        
+    - Bei großen Verzeichnissen ist der **erste Lauf** teuer (voller Indexaufbau), danach werden nur Änderungen geprüft.
+        
+- **Dauerbetrieb mit `-repeat watch`**
+    
+    - Nutzt `inotify` → kaum CPU-Last, da nur Änderungen getriggert werden.
+        
+    - Speicherbedarf: wenige Dutzend MB RAM.
+        
+    - CPU-Last: fast 0, außer wenn aktiv synchronisiert wird.
+        
+- **Dauerbetrieb mit `-repeat 10` (Polling)**
+    
+    - Alle 10 Sekunden kompletter Scan → deutlich mehr I/O bei vielen Dateien.
+        
+    - Sollte nur verwendet werden, wenn `inotify` nicht funktioniert (z. B. bei Netzwerk-Dateisystemen).
+        
+
+**Kurz:**
+
+- Lokale Ordner: `-repeat watch` → sehr effizient
+    
+- Netzwerk-Mounts (NFS, SMB): oft kein inotify → Polling nötig, etwas schwerer
+    
+
+---
+
+## 4. Fazit
+
+- Unison ist **keine Always-on-Synchronisation wie Syncthing**, aber mit `-repeat watch` + systemd lässt es sich quasi gleichwertig nutzen.
+    
+- Performance-Impact ist sehr gering, solange du `watch` nutzt.
+    
+- Für **regelmäßige Backups** → Cron oder systemd Timer reicht.
+    
+- Für **nahezu Echtzeit-Sync** → `-repeat watch` + systemd Service ist die beste Lösung.
+    
+
+---
+
+
+## 1. Voraussetzung: Config-Datei
+
+Ja, korrekt ✅  
+Der Aufruf
+
+```bash
+unison default -repeat watch
+```
+
+setzt voraus, dass du eine Konfigurationsdatei `~/.unison/default.prf` hast.  
+Dort definierst du z. B.:
+
+```txt
+root = /home/user/Dokumente
+root = ssh://user@server//home/user/Dokumente
+
+auto = true
+batch = true
+```
+
+- **`auto = true`** → versucht, Konflikte automatisch zu lösen (kein Nachfragen bei eindeutigen Fällen).
+    
+- **`batch = true`** → führt ohne Interaktion aus.
+    
+    - Falls Konflikte auftreten, entscheidet er nach den Regeln oder verweigert Sync.
+        
+    - Ohne `batch` würdest du wieder Fragen im Terminal sehen.
+        
+
+👉 Empfehlung: Für systemd immer `auto = true` und `batch = true` setzen, sonst blockiert der Prozess.
+
+---
+
+## 2. Rückfragen vermeiden (Default-Verhalten)
+
+Wie du beobachtet hast, fragt Unison bei `unison [quelle] [ziel]` ohne Konfig bei **Konflikten** („Welche Version behalten?“).
+
+- Mit **Konfig + batch + auto** → keine Rückfragen.
+    
+- Du kannst zusätzlich Regeln setzen, z. B.:
+    
+
+```txt
+prefer = newer       # Immer die neuere Version behalten
+prefer = /home/user  # Lokale Version gewinnt
+```
+
+Das ist wichtig für den systemd-Einsatz, weil ein Dienst nicht sinnvoll auf Eingaben warten kann.
+
+---
+
+## 3. Logging
+
+### a) Standardmäßig
+
+Unison schreibt **keine dauerhaften Logs** von sich aus.  
+Die Ausgaben gehen in `stdout/stderr` → wenn du es manuell startest, siehst du es im Terminal.
+
+### b) Mit systemd
+
+systemd fängt alles auf → mit
+
+```bash
+journalctl --user -u unison.service
+```
+
+siehst du die Logs.  
+Wenn dir das reicht, brauchst du nichts extra.
+
+### c) Eigene Logdateien
+
+Du kannst in der `.prf`-Datei angeben:
+
+```txt
+log = /var/log/unison/unison.log
+```
+
+oder direkt beim Start per `ExecStart`:
+
+```ini
+ExecStart=/usr/bin/unison default -repeat watch -logfile /var/log/unison/unison.log
+```
+
+### d) Alte Logs automatisch löschen
+
+Unison selbst rotiert keine Logs, aber systemd oder `logrotate` kann das übernehmen.  
+Beispiel `logrotate`-Konfig (`/etc/logrotate.d/unison`):
+
+```
+/var/log/unison/unison.log {
+    daily
+    rotate 30
+    compress
+    missingok
+    notifempty
+    create 640 user user
+}
+```
+
+→ Hält 30 Tage Logs, dann werden sie komprimiert/gelöscht.
+
+Wenn du lieber pro Sitzung in `/tmp` loggen willst:
+
+```ini
+ExecStart=/usr/bin/unison default -repeat watch -logfile /tmp/unison-%u.log
+```
+
+und ein Cronjob/systemd-Timer löscht alte Dateien:
+
+```bash
+find /tmp -name 'unison-*.log' -mtime +30 -delete
+```
+
+---
+
+## 4. Fazit
+
+- **Ja**, Config-Datei nötig → dort Batch/Auto einstellen.
+    
+- **Default-Verhalten einstellen** mit `prefer`-Regeln, sonst blockieren Konflikte.
+    
+- **Logs**: systemd-Journal reicht oft, alternativ eigene Logdatei + logrotate.
+    
+
+---
+
+👉 Soll ich dir eine **komplette Beispielkonfig `default.prf` + passende systemd-Service-Datei** basteln, die direkt „Headless-Sync im Hintergrund“ macht inkl. Log-Rotation?