HomelabNerds

HOME LAB · SELFHOSTING · NETZWERK

Schlagwort: Docker

Immich Wartung im Alltag: Updates, Datenbank-Backup, Speicherhygiene
Schwierigkeit: Mittel · Dauer: 35–65 Min · Ziel: Immich Wartung im Alltag: Updates, Datenbank-Backup, Speicherhygiene

Kurzproblem und Zielbild
In vielen Homelabs funktioniert die Erstinstallation, aber der Dauerbetrieb wird schnell unübersichtlich. Dieses Tutorial zeigt einen reproduzierbaren Ablauf für Immich Wartung im Alltag mit Fokus auf Stabilität, klare Checks und einfache Fehlerbehebung.
Ziel ist ein Setup, das nicht nur heute läuft, sondern auch nach Updates und Änderungen beherrschbar bleibt.

Voraussetzungen
- Aktuelles Debian/Ubuntu oder kompatible Appliance
- Administrative Rechte und Wartungsfenster
- Backup- oder Snapshot-Möglichkeit vor Änderungen
Schnellstart (funktionierende Basis)
```
# Basisprüfung
hostnamectl
ip a
# Dienste prüfen
systemctl --failed
# Logs kurz prüfen
journalctl -p 3 -xb --no-pager | tail -n 30
```
Was macht das? Du prüfst erst den Grundzustand und vermeidest, dass Altfehler in neue Änderungen hineinwirken.

Schritt-für-Schritt Umsetzung

1) Ausgangszustand dokumentieren
```
date -Iseconds
uname -a
# versions/relevante configs sichern
```
Erklärung: Mit einer kurzen Bestandsaufnahme lassen sich spätere Fehler schneller eingrenzen.

2) Kernkonfiguration sauber setzen
```
# hier die zentrale Immich Wartung im Alltag-Konfiguration umsetzen
# Konfigdatei bearbeiten, nur notwendige Werte ändern
```
Erklärung: Ändere nur das Nötigste und halte die Konfiguration nachvollziehbar.

3) Dienst kontrolliert neu laden
```
sudo systemctl daemon-reload
sudo systemctl restart 
sudo systemctl status  --no-pager
```
4) Betriebsgrenzen testen
```
# Healthcheck/Endpoint prüfen
# Logs und Fehlerraten beobachten
```
Validierung / Checks
```
systemctl status  --no-pager
journalctl -u  -n 150 --no-pager
# funktionaler End-to-End Check
```
Troubleshooting
Konfiguration wird nicht übernommen
Ursache: Tippfehler oder veralteter Service-Reload.
```
sudo  --check
sudo systemctl daemon-reload
sudo systemctl restart 
```
Dienst läuft, Funktion aber fehlerhaft
Ursache: Abhängigkeit, DNS oder Routing nicht konsistent.
```
dig example.org
ip route
journalctl -u  -n 200 --no-pager
```
Fazit
Mit einem klaren Ablauf für Immich Wartung im Alltag reduzierst du Ausfälle und erhöhst die Wartbarkeit deutlich. Der wichtigste Hebel ist die Kombination aus kleiner Änderung, sofortigem Check und dokumentiertem Ergebnis.
Nächster Schritt: den Ablauf als monatliche Betriebsroutine einplanen und regelmäßig gegen echte Störfälle testen.

Quellen
16.02.2026
Home Assistant Backups verlässlich machen: Full/Partial, Restore-Drill
Schwierigkeit: Mittel · Dauer: 35–65 Min · Ziel: Home Assistant Backups verlässlich machen: Full/Partial, Restore-Drill

Kurzproblem und Zielbild
In vielen Homelabs funktioniert die Erstinstallation, aber der Dauerbetrieb wird schnell unübersichtlich. Dieses Tutorial zeigt einen reproduzierbaren Ablauf für Home Assistant Backups verlässlich machen mit Fokus auf Stabilität, klare Checks und einfache Fehlerbehebung.
Ziel ist ein Setup, das nicht nur heute läuft, sondern auch nach Updates und Änderungen beherrschbar bleibt.

Voraussetzungen
- Aktuelles Debian/Ubuntu oder kompatible Appliance
- Administrative Rechte und Wartungsfenster
- Backup- oder Snapshot-Möglichkeit vor Änderungen
Schnellstart (funktionierende Basis)
```
# Basisprüfung
hostnamectl
ip a
# Dienste prüfen
systemctl --failed
# Logs kurz prüfen
journalctl -p 3 -xb --no-pager | tail -n 30
```
Was macht das? Du prüfst erst den Grundzustand und vermeidest, dass Altfehler in neue Änderungen hineinwirken.

Schritt-für-Schritt Umsetzung

1) Ausgangszustand dokumentieren
```
date -Iseconds
uname -a
# versions/relevante configs sichern
```
Erklärung: Mit einer kurzen Bestandsaufnahme lassen sich spätere Fehler schneller eingrenzen.

2) Kernkonfiguration sauber setzen
```
# hier die zentrale Home Assistant Backups verlässlich machen-Konfiguration umsetzen
# Konfigdatei bearbeiten, nur notwendige Werte ändern
```
Erklärung: Ändere nur das Nötigste und halte die Konfiguration nachvollziehbar.

3) Dienst kontrolliert neu laden
```
sudo systemctl daemon-reload
sudo systemctl restart 
sudo systemctl status  --no-pager
```
4) Betriebsgrenzen testen
```
# Healthcheck/Endpoint prüfen
# Logs und Fehlerraten beobachten
```
Validierung / Checks
```
systemctl status  --no-pager
journalctl -u  -n 150 --no-pager
# funktionaler End-to-End Check
```
Troubleshooting
Konfiguration wird nicht übernommen
Ursache: Tippfehler oder veralteter Service-Reload.
```
sudo  --check
sudo systemctl daemon-reload
sudo systemctl restart 
```
Dienst läuft, Funktion aber fehlerhaft
Ursache: Abhängigkeit, DNS oder Routing nicht konsistent.
```
dig example.org
ip route
journalctl -u  -n 200 --no-pager
```
Fazit
Mit einem klaren Ablauf für Home Assistant Backups verlässlich machen reduzierst du Ausfälle und erhöhst die Wartbarkeit deutlich. Der wichtigste Hebel ist die Kombination aus kleiner Änderung, sofortigem Check und dokumentiertem Ergebnis.
Nächster Schritt: den Ablauf als monatliche Betriebsroutine einplanen und regelmäßig gegen echte Störfälle testen.

Quellen
16.02.2026
Docker Logs unter Kontrolle: Rotation, Retention und schnelle Analyse
Schwierigkeit: Mittel · Dauer: 35–65 Min · Ziel: Docker Logs unter Kontrolle: Rotation, Retention und schnelle Analyse

Kurzproblem und Zielbild
In vielen Homelabs funktioniert die Erstinstallation, aber der Dauerbetrieb wird schnell unübersichtlich. Dieses Tutorial zeigt einen reproduzierbaren Ablauf für Docker Logs unter Kontrolle mit Fokus auf Stabilität, klare Checks und einfache Fehlerbehebung.
Ziel ist ein Setup, das nicht nur heute läuft, sondern auch nach Updates und Änderungen beherrschbar bleibt.

Voraussetzungen
- Aktuelles Debian/Ubuntu oder kompatible Appliance
- Administrative Rechte und Wartungsfenster
- Backup- oder Snapshot-Möglichkeit vor Änderungen
Schnellstart (funktionierende Basis)
```
# Basisprüfung
hostnamectl
ip a
# Dienste prüfen
systemctl --failed
# Logs kurz prüfen
journalctl -p 3 -xb --no-pager | tail -n 30
```
Was macht das? Du prüfst erst den Grundzustand und vermeidest, dass Altfehler in neue Änderungen hineinwirken.

Schritt-für-Schritt Umsetzung

1) Ausgangszustand dokumentieren
```
date -Iseconds
uname -a
# versions/relevante configs sichern
```
Erklärung: Mit einer kurzen Bestandsaufnahme lassen sich spätere Fehler schneller eingrenzen.

2) Kernkonfiguration sauber setzen
```
# hier die zentrale Docker Logs unter Kontrolle-Konfiguration umsetzen
# Konfigdatei bearbeiten, nur notwendige Werte ändern
```
Erklärung: Ändere nur das Nötigste und halte die Konfiguration nachvollziehbar.

3) Dienst kontrolliert neu laden
```
sudo systemctl daemon-reload
sudo systemctl restart 
sudo systemctl status  --no-pager
```
4) Betriebsgrenzen testen
```
# Healthcheck/Endpoint prüfen
# Logs und Fehlerraten beobachten
```
Validierung / Checks
```
systemctl status  --no-pager
journalctl -u  -n 150 --no-pager
# funktionaler End-to-End Check
```
Troubleshooting
Konfiguration wird nicht übernommen
Ursache: Tippfehler oder veralteter Service-Reload.
```
sudo  --check
sudo systemctl daemon-reload
sudo systemctl restart 
```
Dienst läuft, Funktion aber fehlerhaft
Ursache: Abhängigkeit, DNS oder Routing nicht konsistent.
```
dig example.org
ip route
journalctl -u  -n 200 --no-pager
```
Fazit
Mit einem klaren Ablauf für Docker Logs unter Kontrolle reduzierst du Ausfälle und erhöhst die Wartbarkeit deutlich. Der wichtigste Hebel ist die Kombination aus kleiner Änderung, sofortigem Check und dokumentiertem Ergebnis.
Nächster Schritt: den Ablauf als monatliche Betriebsroutine einplanen und regelmäßig gegen echte Störfälle testen.

Quellen
16.02.2026
Home Assistant Updates ohne Ausfallstress: Compose-Workflow mit Rollback
Schwierigkeit: Mittel · Dauer: 35–60 Min · Ziel: Home-Assistant-Updates reproduzierbar ausrollen und bei Problemen schnell zurückrollen.

Kurzproblem und Zielbild
Home Assistant wächst schnell mit Integrationen. Unkontrollierte Updates führen oft zu Ausfällen oder kaputten Add-ons. Ziel ist ein klarer Update-Workflow mit Backup, Check und Rollback.

Voraussetzungen
- Home Assistant via Docker Compose
- Persistente Config unter ./config
- Backup-Möglichkeit vor Update
Schnellstart (funktionierende Basis)
```
cd ~/stacks/homeassistant
tar -czf backup-ha-$(date +%F-%H%M).tar.gz ./config
docker compose pull
docker compose up -d
```
Schritt-für-Schritt Umsetzung
1) Pre-Update Snapshot
```
tar -czf backup-ha-$(date +%F-%H%M).tar.gz ./config
cp compose.yml backup-compose-$(date +%F-%H%M).yml
```
2) Update kontrolliert ausrollen
```
docker compose pull
docker compose up -d --remove-orphans
docker compose ps
```
3) Kernfunktionen prüfen
```
docker compose logs --tail=180 homeassistant
# Login/UI, Automationen, Integrationen testen
```
4) Rollback bei Fehlern
```
docker compose down
cp backup-compose-YYYY-MM-DD-HHMM.yml compose.yml
# ggf. config-backup zurückspielen
docker compose up -d
```
Validierung / Checks
```
docker compose ps
docker compose logs --tail=200 homeassistant
curl -I http://localhost:8123
```
Troubleshooting
Container startet, UI bleibt unzuverlässig
```
docker compose logs homeassistant --tail=250
# fehlerhafte custom components prüfen
```
Integrationen nach Update fehlerhaft
```
# letzte stabile Version pinnen und erneut deployen
```
Fazit
Mit klarer Update-Routine wird Home Assistant deutlich berechenbarer. Nächster Schritt: festen Wartungstermin + Checkliste pro Update einführen.

Quellen
16.02.2026
Docker Compose Deployments robust machen: Struktur, Healthchecks, Rollback
Schwierigkeit: Mittel · Dauer: 45–60 Min · Ziel: Docker-Compose-Stacks reproduzierbar deployen, validieren und sicher zurückrollen.

Kurzproblem und Zielbild
Viele Compose-Setups funktionieren initial, brechen aber bei Updates oder Neustarts durch fehlende Checks und unsaubere Struktur. Ziel ist ein Ablauf, der auch unter Last stabil bleibt und im Fehlerfall schnell zurückgerollt werden kann.

Voraussetzungen
- Debian/Ubuntu Host mit Docker + Compose Plugin
- Sudo-Zugriff
- Freie Volumes/Backups vor Änderungen
Schnellstart (funktionierende Basis)
```
mkdir -p ~/stacks/app && cd ~/stacks/app
nano compose.yml
docker compose pull
docker compose up -d
docker compose ps
```
Was macht das? Erzeugt einen reproduzierbaren Stack-Ordner, zieht Images und startet den Stack kontrolliert.

Schritt-für-Schritt Umsetzung

1) Struktur und Variablen trennen
```
mkdir -p ~/stacks/app/{config,data,backup}
cp compose.yml compose.yml.bak
nano .env
```
Erklärung: Trennung reduziert Fehler bei Upgrades und vereinfacht Restore.

2) Healthchecks definieren
```
services:
  app:
    healthcheck:
      test: ["CMD", "curl", "-f", "http://localhost:8080/health"]
      interval: 30s
      timeout: 5s
      retries: 5
```
3) Update-Fenster mit Validierung
```
docker compose pull
docker compose up -d --remove-orphans
docker compose ps
docker compose logs --tail=120
```
4) Rollback vorbereiten
```
cp compose.yml backup/compose-$(date +%F-%H%M).yml
# im Fehlerfall:
cp backup/compose-YYYY-MM-DD-HHMM.yml compose.yml
docker compose up -d
```
Validierung / Checks
```
docker compose ps
curl -fsS http://localhost:8080/health
journalctl -u docker -n 120 --no-pager
```
Troubleshooting
Healthcheck bleibt „unhealthy“
Ursache: Falscher Endpoint oder Startdauer zu kurz.
```
docker compose logs app --tail=200
# retries/timeout erhöhen
```
Update startet, Service nicht erreichbar
Ursache: Inkompatibles Image/Config.
```
docker compose down
cp backup/compose-*.yml compose.yml
docker compose up -d
```
Fazit
Mit sauberer Struktur, Healthchecks und Rollback-Plan werden Compose-Deployments deutlich robuster. Nächster Schritt: Monitoring für Containerzustände ergänzen.

Quellen
16.02.2026