So baust du dein privates Netflix

Du willst Serien, Filme und Musik selbst hosten – ohne Abo, ohne Algorithmus, mit deiner eigenen Mediathek? Das geht. Dafür brauchst du im Kern vier Dinge: etwas, das sucht, etwas, das herunterlädt, etwas, das sortiert und etwas, das streamt. In diesem Beitrag erklären wir zuerst, was was ist und was es macht – und stellen dann Pirate Stack vor: einen fertigen Open-Source-Stack, der genau diese Bausteine für dich zusammenfügt.

Hinweis: Du bist selbst verantwortlich für die Einhaltung lokaler Gesetze und Nutzungsbedingungen. Der Stack ist für den Bildungs- und Privatgebrauch gedacht.

Was brauchst du für dein privates Netflix? – Die vier Bausteine

Bevor wir zum fertigen Stack kommen: Was macht eigentlich was?

1. Suchmaschinen für Releases: Indexer

Indexer sind Suchmaschinen für Serien, Filme und Musik-Releases. Sie listen, wo es eine neue Folge, einen Film oder ein Album zum Herunterladen gibt – entweder als Torrent (BitTorrent) oder als Usenet-Artikel. Du suchst nicht selbst auf Dutzenden Seiten; stattdessen fragt eine App die Indexer per API: „Gibt es Staffel 3 von XY in HD?“ und bekommt Links zurück. Ohne Indexer müsstest du jede Release manuell suchen und die passende Datei finden – mit Indexern übernimmt das die Automatik.

2. Die eigentlichen Downloads: Download-Clients

Ein Download-Client ist das Programm, das die Dateien wirklich herunterlädt. Bei Torrent ist das z. B. ein Torrent-Client (z. B. qBittorrent): Er verbindet sich mit dem Schwarm und lädt die Blöcke. Bei Usenet ist es ein Usenet-Client (z. B. SABnzbd): Er lädt die Teile von deinem Usenet-Provider und setzt sie zusammen. Die Such- und Sortier-Apps (*Arr) schicken dem Client nur den Auftrag („lade diese Datei“); der Client erledigt den Rest.

3. Suche, Auftrag und Einordnung: die *Arr-Apps

Die *Arr-Apps (Sonarr, Radarr, Lidarr) sind das Herzstück: Sie suchen über Indexer nach neuen Folgen/Filmen/Alben, lösen den Download beim Client aus und ordnen die fertigen Dateien in deine Mediathek ein – mit klaren Ordnern und Dateinamen. Jede App ist für einen Medientyp zuständig: Sonarr für Serien, Radarr für Filme, Lidarr für Musik. Du sagst einmal „ich will diese Serie“, und die App kümmert sich um den Rest: neue Folgen finden, herunterladen, in den richtigen Ordner legen. Prowlarr ist dabei der zentrale Indexer-Manager: Du richtest Indexer nur dort ein, und alle *Arr-Apps nutzen sie.

4. Dein „Netflix“: der Media-Server

Der Media-Server (z. B. Jellyfin) liest nur die fertige Mediathek. Er scannt die Ordner, lädt Metadaten (Titel, Beschreibung, Poster) und streamt die Inhalte an dich – auf dem Fernseher, Laptop oder Handy. Er sucht und lädt nichts; er zeigt an, was schon da ist. So entsteht dein „privates Netflix“: Du öffnest Jellyfin, siehst deine Serien und Filme, klickst drauf – und streamst.

Kurz: Indexer liefern die Links → *Arr-Apps nutzen die Links und steuern die Download-Clients → Download-Clients laden die Dateien → *Arr-Apps sortieren sie in die Mediathek → der Media-Server streamt sie. Pirate Stack packt genau diese Bausteine in einen fertigen Docker-Compose-Stack.

Was ist Pirate Stack?

Pirate Stack ist ein Open-Source-Projekt auf GitLab (MIT-Lizenz), das genau diese vier Bausteine in einer fertigen Docker-Compose-Konfiguration bündelt: Indexer-Management (Prowlarr), Such- und Sortier-Apps (Sonarr, Radarr, Lidarr), Download-Clients (qBittorrent, SABnzbd) und Media-Server (Jellyfin). Statt viele Einzel-Container selbst zu verknüpfen, liefert das Repository eine abgestimmte Konfiguration: gleiche Netzwerk- und Volume-Struktur, vorkonfigurierte Umgebungsvariablen und die Annahme, dass Traefik als Reverse-Proxy bereits läuft. Ziel ist ein stabiler, transparenter Betrieb mit klarer Ordnerstruktur, wenig manueller Arbeit und sauberer Trennung von Konfiguration, Downloads und Mediathek.

Netzwerk: Alle Container laufen in einem gemeinsamen Docker-Netzwerk namens pirate und sprechen sich intern über ihre Container-Namen an (z. B. http://sonarr:8989, http://qbittorrent:8080). So müssen Sonarr, Radarr und Lidarr keine Host-IPs kennen – sie nutzen einfach die Dienste im gleichen Netz. Für den Zugriff von außen (Browser, Mobilgeräte) ist Traefik vorgesehen: Der Stack hängt sich in ein externes Netzwerk traefik ein und erwartet einen Zertifikats-Resolver letsencrypt. Das Pazdzewicz Traefik-Setup auf GitLab erfüllt diese Anforderungen und kann Subdomains (z. B. sonarr.example.com, jellyfin.example.com) mit HTTPS bereitstellen.

Architektur und Komponenten

Der Stack setzt sich aus bewährten Open-Source-Tools zusammen:

Datenfluss (vereinfacht):

• Prowlarr liefert Indexer an Sonarr, Radarr und Lidarr.
• Die *Arr-Apps steuern qBittorrent und SABnzbd für Downloads.
• Downloads werden in die Mediathek verschoben oder per Hardlink verknüpft.
• Jellyfin liest die Mediathek schreibgeschützt und streamt.

Die Container basieren auf den gut gepflegten LinuxServer.io Images.

Torrent und Usenet – was ist das?

Der Pirate Stack unterstützt zwei klassische Wege, um Dateien herunterzuladen: BitTorrent (Torrent) und Usenet. Beide funktionieren technisch unterschiedlich; im Stack übernehmen qBittorrent die Torrent-Downloads und SABnzbd die Usenet-Downloads.

BitTorrent (Torrent)

BitTorrent ist ein dezentrales Peer-to-Peer-Protokoll: Es gibt keine zentrale Datei-Quelle. Stattdessen beschreibt eine kleine .torrent-Datei (oder ein Magnet-Link), aus welchen Datenblöcken eine Datei besteht und wo man sie finden kann. Ein Torrent-Client (im Stack: qBittorrent) verbindet sich mit vielen anderen Rechnern („Peers“), die dieselbe Datei anbieten oder herunterladen, und lädt die Blöcke von ihnen. Gleichzeitig stellt dein Client bereits empfangene Blöcke anderen Peers zur Verfügung – man lädt also in einem Schwarm und teilt die Last.

• Vorteile: Kein einzelner Server muss alles ausliefern; bei populären Releases sind oft viele Peers verfügbar.
• Nachteile: Geschwindigkeit und Verfügbarkeit hängen davon ab, ob genug Peers online sind; bei älteren oder seltenen Inhalten kann der Schwarm klein sein oder fehlen.

Usenet

Usenet ist ein älteres, diskussionsorientiertes Netzwerk (Newsgroups), das heute oft für den Austausch von Dateien genutzt wird: Inhalte werden in viele kleine Teile zerlegt, mit Fehlerkorrektur (Parität) versehen und auf Usenet-Servern gespeichert. Du brauchst einen Zugang bei einem Usenet-Provider (kostenpflichtig oder mit Limit) und eine NZB-Datei – das ist im Grunde ein Index, der angibt, welche Teile auf welchen Servern liegen. Ein Usenet-Client (im Stack: SABnzbd) lädt diese Teile vom Provider-Server herunter und setzt sie wieder zusammen.

• Vorteile: Download läuft in der Regel schnell und stabil vom Provider; ältere Artikel bleiben oft lange verfügbar (Retention).
• Nachteile: Usenet-Zugang kostet Geld oder ist begrenzt; ohne gültigen Provider-Account und NZB bringt SABnzbd nichts.

Im Pirate Stack

Die *Arr-Apps (Sonarr, Radarr, Lidarr) suchen über Indexer nach Releases: Torrent-Indexer liefern .torrent-Dateien bzw. Magnet-Links für qBittorrent, Usenet-Indexer liefern NZB-Dateien für SABnzbd. Du kannst nur Torrent, nur Usenet oder beide parallel nutzen – je nachdem, welche Indexer und Zugänge du in Prowlarr und in den Download-Clients einrichtest.

Was macht welcher *Arr-Service?

Die *Arr-Apps sind das Herzstück der Automatisierung: Jede übernimmt einen Medientyp und kümmert sich um Suche, Download-Auslösung und Einordnung in die Mediathek. Gemeinsam nutzen sie Prowlarr als zentrale Stelle für Indexer und die beiden Download-Clients qBittorrent und SABnzbd.

Prowlarr – Indexer zentral verwalten

Prowlarr ist kein Medientyp-spezifisches Tool, sondern der Indexer-Manager für den gesamten Stack. Indexer sind Suchmaschinen für Releases: Torrent-Indexer listen .torrent-Dateien, Usenet-Indexer NZB-Dateien. In Prowlarr richtest du einmal alle genutzten Indexer ein (API-Key, Kategorien usw.). Prowlarr synchronisiert diese Indexer automatisch an Sonarr, Radarr und Lidarr – jede *Arr-App bekommt die gleiche Liste, ohne dass du sie in jeder App einzeln pflegen musst. Änderst du einen Indexer in Prowlarr, wird die Änderung an alle verbundenen Apps weitergegeben.

Zusätzlich verbindest du in Prowlarr unter Settings → Apps die drei Medientyp-Apps (Sonarr, Radarr, Lidarr) mit ihren jeweiligen URLs (z. B. http://sonarr:8989) und API-Keys. Unter Settings → Download Clients trägst du qBittorrent und SABnzbd ein (Host qbittorrent bzw. sabnzbd, Port wie im Stack). So haben alle *Arr-Apps dieselben Indexer und dieselben Download-Wege – konfiguriert an einer Stelle.

Sonarr – Serien und TV-Shows

Sonarr ist für Serien zuständig. Du fügst Serien hinzu (einzeln oder über Import), legst Qualitätsprofile fest (z. B. nur HD, bevorzugt FHD, Sprache Deutsch/Englisch) und optional einen Zeitplan für automatische Suche (z. B. täglich). Sonarr überwacht dann, ob neue Folgen oder Staffeln verfügbar sind, sucht über die von Prowlarr bereitgestellten Indexer nach passenden Releases und sendet gefundene Torrents bzw. NZBs an qBittorrent oder SABnzbd. Wichtig: In Sonarr konfigurierst du unter Settings → Download Clients qBittorrent und SABnzbd (z. B. http://qbittorrent:8080, http://sabnzbd:8080) und vergibst pro Client eine Kategorie (z. B. sonarr) – dieselbe Kategorie muss in qBittorrent/SABnzbd existieren, damit Sonarr „seine“ Downloads wiedererkennt. Als Root Folder legst du einen Pfad fest, der im Container auf die Serien-Mediathek zeigt (im Pirate Stack z. B. /tv → ${ROOT}/library/shows). Nach dem Download verschiebt oder verlinkt Sonarr die Dateien dorthin („Completed Download Handling“). So bleibt deine Serien-Sammlung aktuell, ohne jede Folge manuell zu suchen.

Radarr – Filme

Radarr funktioniert wie Sonarr, nur für Spielfilme. Du legst Filme an (einzeln, per Suche oder über Wunschlisten), definierst Qualitätsprofile (Auflösung, Format, Sprache) und optional automatische Suche. Radarr nutzt die gleichen Indexer (von Prowlarr) und die gleichen Download-Clients. Auch hier: Kategorien (z. B. radarr) in Radarr und in qBittorrent/SABnzbd abgleichen, Root Folder auf die Film-Mediathek setzen (z. B. /movies → ${ROOT}/library/movies). Nach dem Download sortiert Radarr die Dateien in die Mediathek – entweder durch Verschieben oder per Hardlink, wenn Downloads und Mediathek auf demselben Dateisystem liegen (Platz sparend).

Lidarr – Musik

Lidarr übernimmt dasselbe Prinzip für Musik: Du verwaltest Künstler und Alben, legst Qualitätsprofile und Kategorien fest. Lidarr sucht über die gemeinsamen Indexer nach Releases, schickt Downloads an qBittorrent/SABnzbd (Kategorie z. B. lidarr) und legt die fertigen Dateien in deine Musik-Mediathek (z. B. /music → ${ROOT}/library/music). So kannst du deine Musik-Bibliothek automatisch ergänzen und aktuell halten.

Download-Clients: qBittorrent und SABnzbd

qBittorrent und SABnzbd sind die ausführenden Instanzen: Die *Arr-Apps senden ihnen Download-Aufträge (Torrent-Dateien bzw. NZB-Links). qBittorrent bedient BitTorrent, SABnzbd Usenet. Im Pirate Stack sind beide per .env vorkonfiguriert – inkl. Web-UI-Zugang, Download-Pfad im Container (/downloads) und Kategorien. Die Kategorien (z. B. sonarr, radarr, lidarr) müssen in den *Arr-Apps unter Download Clients exakt so eingetragen werden; nur so kann jede App ihre eigenen Downloads wiederfinden und nach dem Abschluss in die richtige Mediathek einordnen. SABnzbd-Kategorien werden über die Umgebungsvariable SABNZBD_CATEGORIES gesetzt (kommasepariert); nach Änderung Container neu bauen/starten. Der physische Download liegt unter ${ROOT}/downloads, die Mediathek unter ${ROOT}/library – wenn beide auf demselben Dateisystem liegen, nutzen die *Arr-Apps Hardlinks (kein doppelter Speicherplatz).

Jellyfin – Media-Server zum Streamen

Jellyfin liest ausschließlich die fertige Mediathek: Unter Dashboard → Bibliotheken bindest du die Ordner für Filme, Serien und Musik ein (im Container z. B. /media/movies, /media/shows, /media/music, gemappt auf ${ROOT}/library/...). Jellyfin scannt die Dateien, lädt Metadaten (Titel, Beschreibung, Poster) und stellt sie zum Streamen bereit – lokal im Netz oder über Traefik/VPN. Optional kannst du Hardware-Transcoding aktivieren (Intel Quick Sync, NVIDIA NVENC, AMD VAAPI), damit Geräte, die ein Format nicht nativ abspielen können, eine transkodierte Version erhalten, ohne die CPU zu überlasten. Die Geräte-Zuweisung und Treiber-Konfiguration sind in der README auf GitLab beschrieben.

Features im Überblick

• Automatisierte Mediensuche – Prowlarr liefert Indexer an Sonarr, Radarr und Lidarr; jede App sucht nach neuen Folgen, Filmen oder Alben und löst Downloads aus, ohne dass du jede Release manuell suchen musst.
• Torrent- und Usenet-Workflows – qBittorrent für BitTorrent und SABnzbd für Usenet; beide sind per Kategorien mit den *Arr-Apps verknüpft, sodass Serien, Filme und Musik sauber getrennt und der Mediathek zugeordnet werden.
• Klare Verzeichnisstruktur – ein gemeinsames ROOT mit config/, downloads/ und library/; durchdachte Volume-Mounts und optionale LVM/fstab-Setups für schnellen Config-Speicher und große Mediathek-Laufwerke.
• Jellyfin für lokales Streaming – Metadaten, Fächer, Fortschritt; optional Hardware-Transcoding (Intel Quick Sync, NVIDIA, AMD VAAPI) für Geräte, die ein Format nicht nativ abspielen.
• Traefik-Integration – Subdomains pro Dienst, Let’s Encrypt-Zertifikate, einheitlicher Zugang über HTTPS.
• IP-Whitelists – getrennt für Download-Clients/Admin-Oberflächen und für Jellyfin; so kannst du Admin-Zugang streng beschränken und Streaming gezielt freigeben.
• CI/CD und Container Registry – Pipelines auf GitLab bauen und validieren das Setup; Images werden im GitLab Container Registry bereitgestellt für reproduzierbare Deployments.

Verzeichnisstruktur und Speicher

Der Stack erwartet ein Wurzelverzeichnis, das du über die Umgebungsvariable ROOT angibst (z. B. /srv/storage/media). Darunter legt das Setup automatisch bzw. per Volume folgende Struktur an:

• config/ – Konfiguration und Datenbanken aller Dienste (Sonarr, Radarr, qBittorrent, Jellyfin usw.). Empfehlung: auf schnellem Speicher (SSD/NVMe) ablegen, damit die Apps flott starten und Metadaten schnell gelesen werden.
• downloads/ – laufende und abgeschlossene Downloads von qBittorrent und SABnzbd.
• library/ – die fertige Mediathek mit Unterordnern movies, shows, music, in die die *Arr-Apps die Dateien nach dem Download verschieben oder per Hardlink verknüpfen.

Hardlinks: Wenn downloads/ und library/ auf dem gleichen Dateisystem liegen (z. B. eine große HDD unter /srv/storage/media), können die *Arr-Apps Hardlinks nutzen: Die Datei bleibt physisch nur einmal vorhanden, erscheint aber sowohl im Download-Ordner als auch in der Mediathek – kein doppelter Speicherbedarf. Liegen Downloads und Mediathek auf verschiedenen Laufwerken, wird kopiert bzw. verschoben; dann brauchst du mehr Platz. In der README findest du Beispiele für fstab-Mounts und LVM-Setups (z. B. NVMe für config/, HDD für downloads und library).

Voraussetzungen

• Docker und Docker Compose v2 – auf einem Linux-Host installiert (WSL2 wird unterstützt).
• Ausreichend Speicher – für Downloads und Mediathek; bei getrennter Nutzung von Torrent und Usenet und vielen Titeln schnell mehrere Hundert GB bis TB.
• Traefik – erforderlich. Der Stack ist für den Betrieb hinter Traefik ausgelegt: externes Docker-Netzwerk traefik und ein Zertifikats-Resolver namens letsencrypt. Ohne Traefik müsstest du die Router-Labels in der docker-compose.yml anpassen oder die Dienste nur über lokale Ports ansprechen.

Quick Start – Schritte im Überblick

1. DNS: Für deine Domain A-Records (oder CNAME) so setzen, dass die gewünschten Subdomains (z. B. sonarr.example.com, jellyfin.example.com) auf die IP des Rechners zeigen, auf dem Traefik und Pirate Stack laufen. Ohne korrektes DNS funktionieren Traefik-Routen und Let’s Encrypt nicht zuverlässig.

2. Repository klonen:
   sudo mkdir -p /opt && sudo git clone https://gitlab.com/pazdzewicz_apps/pirate-stack.git /opt/pirate-stack
   Danach: cd /opt/pirate-stack.

3. Traefik separat einrichten (siehe Traefik auf GitLab). Nach dem Setup müssen das Netzwerk traefik und der Resolver letsencrypt existieren. Pirate Stack hängt sich nur in dieses Netzwerk ein.

4. .env anlegen: Aus .env.template eine Datei .env erstellen und mindestens anpassen: ROOT (z. B. /srv/storage/media), WEB_HOST (z. B. example.com für Subdomains wie qbittorrent.example.com), PUID/PGID (Benutzer/Gruppe auf dem Host, z. B. id -u / id -g), TZ (Zeitzone, z. B. Europe/Berlin), und bei Bedarf die Ports (QBIT_PORT, SABNZBD_PORT, PROWLARR_PORT, SONARR_PORT, RADARR_PORT, LIDARR_PORT, JELLYFIN_PORT), falls sie bereits belegt sind.

5. Container starten:
   docker compose pull und danach docker compose up -d.

6. Einmalige Konfiguration der Web-UIs:
   qBittorrent und SABnzbd sind bereits per .env vorkonfiguriert (Zugangsdaten, Download-Pfad, Kategorien). Prowlarr, Sonarr, Radarr, Lidarr und Jellyfin musst du einmal über die Web-Oberfläche (per Traefik-URL oder http://localhost:<PORT>) öffnen: In Prowlarr Indexer anlegen und unter Apps Sonarr, Radarr, Lidarr verbinden sowie unter Download Clients qBittorrent und SABnzbd eintragen. In Sonarr/Radarr/Lidarr jeweils Download-Clients (mit passender Kategorie) und Root Folder setzen sowie „Completed Download Handling“ aktivieren. In Jellyfin Bibliotheken für Filme, Serien und Musik anlegen (Pfade wie /media/movies, /media/shows, /media/music). Danach läuft die Automatisierung.

Ausführliche Schritte, alle Umgebungsvariablen, Storage-Optionen (inkl. LVM/fstab), Backups und Best Practices stehen in der README auf GitLab (englisch und deutsch).

Traefik, Zugriff und Sicherheit

Der Stack bindet alle Web-UIs über Traefik-Router ein; die genauen Hostnamen (z. B. qbittorrent.example.com) kommen aus den .env-Variablen (QBIT_HOST, JELLYFIN_HOST usw., Standard: qbittorrent.${WEB_HOST}). Über DOWNLOAD_CLIENTS_IP_WHITELIST kannst du den Zugriff auf die Oberflächen von qBittorrent, SABnzbd, Prowlarr, Sonarr, Radarr und Lidarr auf bestimmte IP-Bereiche (CIDR) beschränken – nur diese erhalten dann Zugriff; alle anderen bekommen 403. Jellyfin hat eine eigene Whitelist: JELLYFIN_IP_WHITELIST. So kannst du die Admin- und Download-Oberflächen streng schützen und Jellyfin (Streaming) z. B. für einen größeren Kreis freigeben. Empfehlung: Dienste nicht ungeschützt ins Internet legen; Zugriff über VPN (z. B. Tailscale) oder Traefik mit Auth ist in der README beschrieben.

Backups und Wartung

Die Konfiguration aller Apps liegt unter ${ROOT}/config/. Dieses Verzeichnis solltest du regelmäßig sichern (z. B. mit Restic, rsync oder deinem bestehenden Backup-System). Die Mediathek unter library/ und die laufenden Downloads unter downloads/ können je nach Größe separat oder in Ruhephasen gesichert werden. Updates: docker compose pull und docker compose up -d; optional docker image prune -f zum Aufräumen alter Images. Die CI-Pipelines auf GitLab bauen und prüfen das Setup; Images werden im GitLab Container Registry bereitgestellt.

Wo findest du Pirate Stack?

• GitLab: gitlab.com/pazdzewicz_apps/pirate-stack – Repository mit docker-compose.yml, .env.template, CI-Konfiguration und allen beschriebenen Optionen.
• Wiki: Projekt-Wiki auf GitLab – weitere Anleitungen, Tipps und Dokumentation rund um den Stack.
• Lizenz: MIT – Nutzung, Anpassung und Weitergabe sind erlaubt.
• Mitwirken: CONTRIBUTING.md beschreibt, wie du Beiträge einreichen kannst; CHANGELOG und weitere Infos liegen direkt im Repository. Die README gibt es auf Englisch (README.EN.md) und auf Deutsch (README.DE.md).

Pirate Stack passt thematisch zu unserer Docker-Projektseite, auf der wir weitere Open-Source-Docker-Projekte vorstellen – darunter auch das Traefik-Setup für den sicheren Zugriff auf alle Web-Oberflächen. Wer den Stack einmal laufen hat, hat mit Prowlarr, Sonarr, Radarr, Lidarr und Jellyfin eine vollständige Self-Hosting-Lösung für Serien, Filme und Musik – von der Suche über den Download bis zum Stream.