Die 15 besten Self-Hosted Dienste für dein Homelab (2026)

Warum Selfhosting? Weil deine Daten dir gehören sollten.

Jede Datei, die du bei Google Drive hochlädst, liegt auf einem Server in irgendeinem Rechenzentrum, dessen Betreiber sich vorbehält, die Nutzungsbedingungen jederzeit zu ändern. Deine Fotos bei iCloud? Apple kann sie scannen — für deine “Sicherheit” natürlich. Dein Passwort-Manager bei LastPass? Die wurden mehrfach gehackt, und deine verschlüsselten Vaults lagen in fremden Händen.

Selfhosting bedeutet: Du betreibst die gleichen Services auf deiner eigenen Hardware. Du entscheidest, wer Zugriff hat. Du entscheidest, wo die Daten liegen. Und du zahlst einmalig für Hardware statt monatlich für Abos.

Was dir Selfhosting konkret bringt

• 🔒 Echte Privatsphäre: Deine Daten verlassen nie dein Netzwerk, bis du es erlaubst. Kein Scan, kein Training von AI-Modellen mit deinen Familienfotos.
• 💰 Keine Abo-Falle: Statt 30€/Monat an Google, Apple und Co. zahlst du einmal ~250€ für Hardware und ~5€/Monat Strom. Nach einem Jahr bist du im Plus.
• 🎓 Linux-Skills, die sich bezahlt machen: Was du beim Homelab lernst — Networking, Docker, Backup-Strategien, Monitoring — ist genau das, was Arbeitgeber suchen. Dein Homelab ist dein lebendes Portfolio.
• 🔧 Volle Kontrolle: Feature fehlt? Es gibt ein Plugin. Bug nervt? Fix den Upstream-PR. Service stellt ein? Fork existiert. Du bist nicht abhängig von der Roadmap eines Produktmanagers bei Google.
• 🌍 Vendor-Lock-in? Nein danke.: Jeder dieser Services nutzt offene Standards und offene Formate. Du kannst jederzeit exportieren und woanders hinziehen.

Was du brauchst

• Einen Server (Proxmox-Homelab, NAS, oder ein alter Laptop — im Ernst, das reicht für den Anfang)
• Docker installiert
• Grundlegende Linux-Kenntnisse (cd, ls, nano — den Rest lernst du dabei)
• Optional: Eine eigene Domain, wenn du Services von unterwegs erreichen willst

Ein Wort zur Ehrlichkeit: Selfhosting ist kein Allheilmittel. Du bist selbst für Updates, Backups und Security verantwortlich. Wenn du das schleifen lässt, ist dein selbst gehostetes Nextcloud unsicherer als Google Drive. Das heißt nicht, dass du es lassen sollst — es heißt, dass du Backups machst und regelmäßig updatest. Das gilt für jeden Admin, ob Homelab oder Datacenter.

Die 15 besten Self-Hosted Dienste

Jeder Dienst in dieser Liste läuft bei mir produktiv. Keine theoretischen Empfehlungen — alles getestet, alles im Einsatz. Sortiert nach “brauchst du sofort” bis “nice to have”.

1. Nextcloud – Deine eigene Cloud ☁️

Ersetzt: Google Drive, Dropbox, iCloud Drive, Google Calendar, Google Contacts

Nextcloud ist das Flaggschiff der Selfhosting-Welt. Dateisync, Kalender, Kontakte, Office, Notizen, Talk (Video-Calls), Tasks — alles unter einem Dach. Ist es perfekt? Nein, PHP-basiert und bei sehr vielen Dateien nicht das Schnellste. Ist es die beste selbst gehostete Cloud? Ohne jeden Zweifel.

Warum Nextcloud und nicht Seafile/ownCloud?

• Seafile ist schneller bei reinem Filesync, hat aber kein Kalender/Kontakte/Office-Ökosystem. Wenn du nur Dateien brauchst, schau’s dir an. Für alles andere: Nextcloud.
• ownCloud ist der Vorgänger, die Community ist zu Nextcloud gewechselt, die Entwicklung dort schleppend. Kein Grund, damit noch anzufangen.

services:
  nextcloud:
    image: nextcloud:latest
    container_name: nextcloud
    restart: unless-stopped
    ports:
      - "8080:80"
    volumes:
      - ./html:/var/www/html
      - ./data:/var/www/html/data
    environment:
      - MYSQL_HOST=nextcloud-db
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
      - MYSQL_PASSWORD=SICHERES_PASSWORT_HIER
      - NEXTCLOUD_ADMIN_USER=admin
      - NEXTCLOUD_ADMIN_PASSWORD=ADMIN_PASSWORT_HIER
      - NEXTCLOUD_TRUSTED_DOMAINS=nextcloud.deine-domain.de
      - TZ=Europe/Berlin
    depends_on:
      - nextcloud-db

  nextcloud-db:
    image: mariadb:11
    container_name: nextcloud-db
    restart: unless-stopped
    volumes:
      - ./db:/var/lib/mysql
    environment:
      - MYSQL_ROOT_PASSWORD=ROOT_PASSWORT_HIER
      - MYSQL_DATABASE=nextcloud
      - MYSQL_USER=nextcloud
      - MYSQL_PASSWORD=SICHERES_PASSWORT_HIER
      - TZ=Europe/Berlin

Pflicht-Tuning: Installiere Redis als Memory-Cache und konfiguriere APCu für den PHP-OPcache. Ohne das fühlt sich Nextcloud an wie ein Fiat Punto bergauf. Mit Cache: wie ein GTI auf der Autobahn. Außerdem: occ maintenance:repair nach Updates nicht vergessen.

2. Vaultwarden – Passwort-Manager 🔐

Ersetzt: LastPass, 1Password, Dashlane

Vaultwarden ist eine Rust-basierte Reimplementierung des Bitwarden-Servers. Kompatibel mit allen offiziellen Bitwarden-Apps und Browser-Extensions — aber läuft auf 10 MB RAM statt 2 GB, weil es nicht den offiziellen .NET-Moloch braucht.

Warum nicht den offiziellen Bitwarden-Server? Weil der 2+ GB RAM frisst, Microsoft SQL Server braucht, und für ein Homelab absurd überdimensioniert ist. Vaultwarden macht exakt das Gleiche auf einem Bruchteil der Ressourcen. Rust > .NET, zumindest hier.

Warum nicht KeePass? Geht auch, aber kein Server-Sync. Du synchronisierst die Datenbank-Datei manuell oder über eine Cloud. Vaultwarden hat echten Client-Server-Sync, Sharing, Emergency Access, und einen Web-Vault. KeePass ist ein Offline-Tool, Vaultwarden eine Plattform.

services:
  vaultwarden:
    image: vaultwarden/server:latest
    container_name: vaultwarden
    restart: unless-stopped
    ports:
      - "8222:80"
    volumes:
      - ./data:/data
    environment:
      - DOMAIN=https://vault.deine-domain.de
      - SIGNUPS_ALLOWED=false
      - ADMIN_TOKEN=EIN_LANGER_ZUFAELLIGER_TOKEN
      - TZ=Europe/Berlin

Nicht verhandelbar: HTTPS Pflicht (sonst verweigern Browser-Extensions die Arbeit), und Backup ist hier wichtiger als bei jedem anderen Service. Verlierst du die Vaultwarden-Daten, stehst du vor 200+ Accounts ohne Passwort. Tägliches Backup, getestet, offsite-Kopie.

3. Pi-hole – Netzwerkweiter Werbeblocker 🛡️

Ersetzt: Browser-Adblocker (aber für ALLE Geräte)

Pi-hole blockiert Werbung und Tracking auf DNS-Ebene. Dein Smart TV, dein Handy, dein IoT-Thermometer — alles profitiert, ohne dass du auf jedem Gerät einen Adblocker installieren musst. Stell Pi-hole als DNS am Router ein, fertig.

Warum DNS-Level statt Browser-Adblocker? Ein uBlock Origin im Browser ist gut, aber es schützt nur den Browser. Dein Samsung TV schickt trotzdem Telemetrie. Dein Xiaomi-Staubsauger telefoniert trotzdem nach Hause. Pi-hole fängt das alles ab — weil es auf der Netzwerk-Ebene passiert, nicht im einzelnen Client.

Warum nicht AdGuard Home? AdGuard Home ist auch gut und hat eine modernere UI. Pi-hole hat die größere Community und mehr Blocklisten-Ökosystem. Beide funktionieren. Nimm das, dessen UI dir besser gefällt.

services:
  pihole:
    image: pihole/pihole:latest
    container_name: pihole
    restart: unless-stopped
    ports:
      - "53:53/tcp"
      - "53:53/udp"
      - "8053:80/tcp"
    volumes:
      - ./etc-pihole:/etc/pihole
      - ./etc-dnsmasq.d:/etc/dnsmasq.d
    environment:
      - WEBPASSWORD=DEIN_PASSWORT
      - TZ=Europe/Berlin
      - DNSMASQ_LISTENING=all
    cap_add:
      - NET_ADMIN

Level-Up: Kombiniere Pi-hole mit Unbound als rekursiver DNS-Resolver. Damit fragst du direkt die Root-DNS-Server statt Google (8.8.8.8) oder Cloudflare (1.1.1.1). Dein DNS-Traffic geht dadurch nicht mehr über einen Dritten. Setup dauert 15 Minuten, Guide gibt’s im Pi-hole Docs.

4. Immich – Google Photos, aber deins 📸

Ersetzt: Google Photos, iCloud Photos, Amazon Photos

Immich ist der Selfhosting-Durchbruch der letzten zwei Jahre. Die Oberfläche fühlt sich an wie Google Photos (schnell, modern, Timeline-View), aber alles läuft lokal. KI-basierte Gesichtserkennung, Objekterkennung, Volltextsuche in Fotos (“zeig mir alle Fotos mit Hund am Strand”) — ja, das funktioniert wirklich. Auf deinem eigenen Server.

Warum nicht PhotoPrism? PhotoPrism war der Vorreiter und ist solide. Immich hat es aber in Features, Speed und Mobile-App-Qualität mittlerweile klar überholt. Die Immich-App fühlt sich wie eine native Google-Photos-App an, nur dass die Daten bei dir bleiben. PhotoPrism fühlt sich eher wie ein Web-Tool an.

services:
  immich-server:
    image: ghcr.io/immich-app/immich-server:release
    container_name: immich-server
    restart: unless-stopped
    ports:
      - "2283:2283"
    volumes:
      - ./upload:/usr/src/app/upload
      - /etc/localtime:/etc/localtime:ro
    environment:
      - DB_HOSTNAME=immich-postgres
      - DB_USERNAME=postgres
      - DB_PASSWORD=POSTGRES_PASSWORT
      - DB_DATABASE_NAME=immich
      - REDIS_HOSTNAME=immich-redis
    depends_on:
      - immich-redis
      - immich-postgres

  immich-machine-learning:
    image: ghcr.io/immich-app/immich-machine-learning:release
    container_name: immich-ml
    restart: unless-stopped
    volumes:
      - ./model-cache:/cache

  immich-redis:
    image: redis:7-alpine
    container_name: immich-redis
    restart: unless-stopped

  immich-postgres:
    image: tensorchord/pgvecto-rs:pg16-v0.2.1
    container_name: immich-postgres
    restart: unless-stopped
    volumes:
      - ./postgres:/var/lib/postgresql/data
    environment:
      - POSTGRES_PASSWORD=POSTGRES_PASSWORT
      - POSTGRES_USER=postgres
      - POSTGRES_DB=immich
      - POSTGRES_INITDB_ARGS='--data-checksums'

Ehrliche Warnung: Immich ist noch nicht v1.0 und sagt selbst “not production ready”. In der Praxis läuft es bei mir seit über einem Jahr stabil, aber: Backup Pflicht, und vor Major-Updates die Release Notes lesen. Das initiale ML-Processing aller Fotos dauert Stunden und lastet die CPU voll aus.

5. Paperless-ngx – Nie wieder Papierchaos 📄

Ersetzt: Ordner voller Papier, Scanner-Apps, das verzweifelte Suchen nach der Nebenkostenabrechnung von 2023

Du scannst ein Dokument (oder lädst ein PDF hoch), Paperless erkennt den Text per OCR, kategorisiert das Dokument automatisch nach Korrespondent, Typ und Tags, und macht es durchsuchbar. Nach zwei Wochen Nutzung fragst du dich, wie du vorher gelebt hast.

Warum OCR statt einfach Dateien ablegen? Weil du dann “Haftpflicht 2024” in die Suche tippen und in 2 Sekunden das richtige Dokument hast, statt 20 Ordner durchzuklicken. Und Paperless lernt: Nach 50 Dokumenten kategorisiert es neue automatisch richtig.

services:
  paperless:
    image: ghcr.io/paperless-ngx/paperless-ngx:latest
    container_name: paperless
    restart: unless-stopped
    ports:
      - "8000:8000"
    volumes:
      - ./data:/usr/src/paperless/data
      - ./media:/usr/src/paperless/media
      - ./consume:/usr/src/paperless/consume
      - ./export:/usr/src/paperless/export
    environment:
      - PAPERLESS_REDIS=redis://paperless-redis:6379
      - PAPERLESS_DBHOST=paperless-db
      - PAPERLESS_OCR_LANGUAGE=deu+eng
      - PAPERLESS_TIME_ZONE=Europe/Berlin
      - PAPERLESS_ADMIN_USER=admin
      - PAPERLESS_ADMIN_PASSWORD=ADMIN_PASSWORT
      - PAPERLESS_URL=https://paperless.deine-domain.de
    depends_on:
      - paperless-db
      - paperless-redis

  paperless-db:
    image: postgres:16
    container_name: paperless-db
    restart: unless-stopped
    volumes:
      - ./pgdata:/var/lib/postgresql/data
    environment:
      - POSTGRES_DB=paperless
      - POSTGRES_USER=paperless
      - POSTGRES_PASSWORD=SICHERES_PASSWORT

  paperless-redis:
    image: redis:7-alpine
    container_name: paperless-redis
    restart: unless-stopped

6. Home Assistant – Smart Home ohne Cloud-Zwang 🏠

Ersetzt: Alexa-Routinen, Google Home, Apple HomeKit (teilweise), und den Glauben dass Smart Home nur mit Cloud funktioniert

Home Assistant ist die mächtigste Smart-Home-Plattform. Punkt. Über 2.000 Integrationen, lokale Steuerung ohne Internet, Automatisierungen die sich wie Scripting anfühlen (weil sie es sind). Der Unterschied zu Alexa: Wenn Amazon morgen den Stecker zieht, funktioniert dein Smart Home trotzdem.

Warum lokal statt Cloud? Weil deine Lampe auch ohne Internet angehen sollte. Weil die Latenz bei lokaler Steuerung ~10ms statt ~500ms beträgt. Und weil kein Cloud-Anbieter mitloggen muss, wann du ins Bett gehst.

services:
  homeassistant:
    image: homeassistant/home-assistant:stable
    container_name: homeassistant
    restart: unless-stopped
    network_mode: host
    volumes:
      - ./config:/config
      - /etc/localtime:/etc/localtime:ro
    environment:
      - TZ=Europe/Berlin
    privileged: true

Empfehlung: Home Assistant läuft am besten als eigene VM (HAOS — Home Assistant Operating System) oder auf dedizierter Hardware (Home Assistant Yellow/Green). Die Docker-Variante funktioniert, aber Add-ons und Supervisor fehlen. Für den vollen Funktionsumfang: VM mit HAOS.

7. Jellyfin – Dein eigenes Netflix 🎬

Ersetzt: Plex (und dessen zunehmend nervige Monetarisierung)

Jellyfin ist ein vollständig Open-Source Media Server. Keine Accounts, keine Telemetrie, keine Premium-Paywall, keine Werbung die Plex dir neuerdings in die Sidebar drückt. Du hast Filme und Serien? Jellyfin streamt sie an alle Geräte.

Warum nicht Plex? Plex war jahrelang die Referenz, aber die Richtung stimmt nicht mehr: Pflicht-Account (deine Watchliste in Plex’ Cloud), Werbefinanzierte “Free TV”-Channels die keiner will, und ein Hardware-Transcoding das nur mit PlexPass (kostenpflichtig) funktioniert. Jellyfin macht das gleiche, komplett kostenlos und Open Source. Hardware-Transcoding mit Intel QuickSync oder VAAPI: eingebaut, kostenlos.

services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    restart: unless-stopped
    ports:
      - "8096:8096"
    volumes:
      - ./config:/config
      - ./cache:/cache
      - /mnt/media/filme:/data/movies
      - /mnt/media/serien:/data/tvshows
      - /mnt/media/musik:/data/music
    environment:
      - TZ=Europe/Berlin
    # Für Intel QuickSync HW-Transcoding:
    # devices:
    #   - /dev/dri:/dev/dri

8. Gitea / Forgejo – Dein privates GitHub 🐙

Ersetzt: GitHub (für private Repos), GitLab (ohne den RAM-Hunger)

Leichtgewichtiges Git-Hosting für Configs, Dotfiles, Dokumentation, private Projekte. GitLab Self-Hosted frisst 4+ GB RAM im Idle — Gitea macht das Gleiche auf ~150 MB. Forgejo ist der Community-Fork, nachdem Gitea ein Enterprise-Modell eingeführt hat (kennen wir das Muster?).

services:
  gitea:
    image: gitea/gitea:latest
    container_name: gitea
    restart: unless-stopped
    ports:
      - "3000:3000"
      - "222:22"
    volumes:
      - ./data:/data
      - /etc/timezone:/etc/timezone:ro
      - /etc/localtime:/etc/localtime:ro
    environment:
      - USER_UID=1000
      - USER_GID=1000
      - GITEA__database__DB_TYPE=sqlite3

9. Uptime Kuma – Überwachung mit Stil 📊

Ersetzt: UptimeRobot, Pingdom, StatusCake

Schönstes Monitoring-Dashboard der Selfhosting-Welt. HTTP, Ping, DNS, TCP, Docker-Container, Datenbank-Checks — alles abgedeckt. Benachrichtigung über 90+ Kanäle (Telegram, Discord, E-Mail, Slack, Gotify, …). Und eine öffentliche Status-Page, falls du eine brauchst.

Warum nicht Zabbix/Prometheus/Grafana? Die sind für Monitoring auf Infrastruktur-Level — CPU, RAM, Disk, Netzwerk. Uptime Kuma ist für “ist mein Service erreichbar: ja oder nein?” Beides hat seinen Platz. Uptime Kuma in 2 Minuten aufgesetzt, Zabbix-Stack in 2 Stunden. Beides sinnvoll, unterschiedliche Zielgruppen.

(Docker-Compose bereits im Docker-Guide gezeigt)

10. Wireguard – VPN ohne Kopfschmerzen 🔐

Ersetzt: NordVPN (für Homelab-Zugriff), OpenVPN (mit weniger Konfiguration)

Wireguard ist ein VPN-Protokoll das in den Linux-Kernel integriert ist — schneller, einfacher und sicherer als OpenVPN. Damit erreichst du dein Homelab von unterwegs, als wärst du im lokalen Netz.

Warum nicht OpenVPN? OpenVPN funktioniert, aber die Config ist ein Roman. Wireguard hat ~4.000 Zeilen Code (vs. OpenVPN ~100.000), ist kryptographisch moderner (ChaCha20, Curve25519), und hat spürbar weniger Latenz. Der einzige Grund für OpenVPN: wenn du TCP Port 443 als Fallback brauchst, weil restriktive Firewalls UDP 51820 blocken. Für alles andere: Wireguard.

services:
  wireguard:
    image: lscr.io/linuxserver/wireguard:latest
    container_name: wireguard
    restart: unless-stopped
    cap_add:
      - NET_ADMIN
      - SYS_MODULE
    ports:
      - "51820:51820/udp"
    volumes:
      - ./config:/config
      - /lib/modules:/lib/modules
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=Europe/Berlin
      - SERVERURL=vpn.deine-domain.de
      - PEERS=handy,laptop,tablet
      - PEERDNS=auto
      - INTERNAL_SUBNET=10.13.13.0
    sysctls:
      - net.ipv4.conf.all.src_valid_mark=1

11. Mealie – Rezepte die dir gehören 🍳

Ersetzt: Chefkoch-App (plus deren penetrante Werbung), Papier-Rezeptsammlung, Screenshots im Handy

URL einfügen → Mealie scraped das Rezept → fertig. Meal Planning, Einkaufslisten, Nährwerte. Und kein einziges Cookie-Banner.

services:
  mealie:
    image: ghcr.io/mealie-recipes/mealie:latest
    container_name: mealie
    restart: unless-stopped
    ports:
      - "9925:9000"
    volumes:
      - ./data:/app/data
    environment:
      - ALLOW_SIGNUP=false
      - TZ=Europe/Berlin
      - BASE_URL=https://mealie.deine-domain.de

12. FreshRSS – News ohne Algorithmus 📰

Ersetzt: Google News, Feedly, Social Media als Nachrichtenquelle

RSS ist nicht tot — RSS ist die letzte Bastion gegen algorithmische Manipulation. Du entscheidest welche Quellen du liest, in welcher Reihenfolge, ohne dass ein Algorithmus dir Rage-Bait nach oben spült. FreshRSS ist schnell, leichtgewichtig, und hat mobile Apps via Fever/Google Reader API.

13. Actual Budget – Finanzen ohne Cloud 💰

Ersetzt: YNAB (das von 7$/Monat auf 15$ erhöht hat — danke Abo-Wirtschaft), Finanzguru

Envelope-Budgeting komplett lokal. Deine Finanzdaten auf deinem Server statt in der Cloud. Weil Bankdaten nun wirklich das Letzte sind, was in fremde Hände gehört.

14. IT-Tools – Die Werkzeugkiste 🛠️

Ersetzt: 50 verschiedene Webseiten die du für Base64, JWT-Decode, Hash-Generierung, CIDR-Rechner, etc. benutzt

Eine Web-Oberfläche mit dutzenden Entwickler- und Admin-Tools. Lokal gehostet, ohne Werbung, ohne Tracking, sofort einsatzbereit. Einmal installiert, nutzt du es täglich.

services:
  it-tools:
    image: corentinth/it-tools:latest
    container_name: it-tools
    restart: unless-stopped
    ports:
      - "8070:80"

15. Changedetection.io – Stalking für Profis 👁️

Ersetzt: Visualping, Distill.io

Überwacht beliebige Webseiten auf Änderungen und benachrichtigt dich. Preisüberwachung für Hardware? Check. Verfügbarkeits-Check für die ausverkaufte GPU? Check. Changelog einer Software die keine RSS-Feeds anbietet? Check.

services:
  changedetection:
    image: ghcr.io/dgtlmoon/changedetection.io:latest
    container_name: changedetection
    restart: unless-stopped
    ports:
      - "5000:5000"
    volumes:
      - ./data:/datastore
    environment:
      - TZ=Europe/Berlin

Kosten-Vergleich: Dein Geld, deine Entscheidung

Monatliche Cloud-Kosten eines typischen Users

*Jellyfin ersetzt nicht den Content — nur die Plattform. Deine Medien musst du haben.

Einmalige Hardware-Kosten

Break-Even: 8-12 Monate. Danach sparst du ~300€/Jahr — und hast volle Kontrolle über deine Daten. Die Hardware läuft 5-10 Jahre. Rechne selbst.

Der eigentliche Wert ist nicht das gesparte Geld. Es ist: Unabhängigkeit von Unternehmen, die ihre Preise jederzeit erhöhen können (hallo YNAB, hallo Netflix, hallo 1Password). Es ist: Daten, die nicht analysiert werden. Es ist: Skills, die dich auf dem Arbeitsmarkt wertvoller machen. Die Kostenersparnis ist nur der Bonus.

Sicherheit: Die unbequeme Wahrheit

Selfhosting ohne Security ist wie ein Tresor ohne Schloss. Diese Maßnahmen sind nicht optional:

Pflicht (nicht verhandelbar)

1. Reverse Proxy mit HTTPS: Nginx Proxy Manager oder Traefik. Let’s Encrypt-Zertifikate kosten nichts, es gibt keine Ausrede für HTTP.
2. Starke Passwörter + 2FA: Überall wo möglich. Deshalb hast du Vaultwarden.
3. Updates: Mindestens monatlich. docker compose pull && docker compose up -d dauert 30 Sekunden pro Service.
4. Backups nach 3-2-1: 3 Kopien, 2 Medien, 1 offsite. Kein Backup = kein Homelab.
5. Firewall: Nur die Ports offen, die offen sein müssen. Kein “für Debugging mal Port 8080 nach außen” und dann vergessen.
6. VPN statt Port-Forwarding: Zugriff von unterwegs per Wireguard, nicht per offenen Port für jeden Bot-Scanner.
7. Fail2ban: Für SSH und jeden Service, der von außen erreichbar ist.

Nice-to-Have (aber empfohlen)

• Crowdsec: Community-basierte IP-Blocklisten — wenn 1.000 andere Admins eine IP als bösartig melden, blockst du sie auch.
• Authelia oder Authentik: SSO-Gateway vor allen Services mit 2FA. Ein Login für alles, eine Stelle zum Absichern.
• VLAN-Segmentierung: IoT-Geräte in eigenes Netzwerk. Dein gehackter Smart-Plug sollte nicht an dein NAS kommen.

Wo anfangen? Der Fahrplan.

Phase 1: Die Grundlage (Woche 1)

1. Pi-hole → Sofortiger Nutzen für alle Geräte, 10 Minuten Setup
2. Vaultwarden → Passwörter endlich richtig verwalten
3. Uptime Kuma → Wissen ob alles läuft

Phase 2: Cloud-Ersatz (Woche 2-3)

4. Nextcloud → Raus aus Google Drive/Dropbox. CalDAV/CardDAV für Kalender und Kontakte gleich mit.
5. Paperless-ngx → Papierchaos ein für alle Mal beseitigen
6. Mealie → Falls du kochst (und selbst wenn nicht — Einkaufslisten sind Gold)

Phase 3: Medien & Fortgeschritten (Woche 4+)

7. Immich → Fotos von Google/Apple lösen
8. Jellyfin → Eigener Streaming-Server
9. Home Assistant → Smart Home richtig machen
10. Wireguard → Dein Homelab von überall erreichen

Jeder dieser Dienste bringt dir echten Mehrwert. Und einmal eingerichtet laufen sie monatelang ohne Eingriff. Das ist der Charme von Docker + Selfhosting: docker compose up -d und vergessen.

Fang heute an. Dein zukünftiges Ich trinkt derweil Kaffee, während Google mal wieder die Preise erhöht. 🚀

Zuletzt aktualisiert: Februar 2026 | Alle Docker-Compose-Beispiele getestet