> ## Content Index
> Fetch the complete content index at: https://sakis.tech/llms.txt
> Use this file to discover other available public pages before exploring further.

# Jellyfin Docker Compose: installieren und einrichten
- URL: https://sakis.tech/jellyfin-docker-compose-installieren/
- Published: 2026-09-19T23:46:20.000Z
- Updated: 2026-09-19T23:46:20.000Z
- Description: Jellyfin 12 per Docker Compose: eine Datei, ein Start, sechs Seiten Assistent. Der Container läuft als dein Benutzer, die Sammlung liegt unter /srv, und am Ende spielt der Fernseher aus deinem Regal, ohne Konto, Abo oder Cloud.
- Author: Sakis
- Tags: homelab, docker

„Your media, your server, your way.“ So stellt sich Jellyfin auf seiner Startseite vor, und für einmal muss man den Satz nicht übersetzen. Er meint genau das, was da steht: Deine Filme liegen auf deinem Rechner, dein Rechner spielt sie auf Fernseher, Handy und Laptop aus, und niemand außer dir bekommt mit, was du guckst. Kein Konto bei einem Anbieter, kein Abo, kein Server irgendwo, der deine Sammlung katalogisiert.

Jellyfin ist ein Medienserver, freie Software unter der GPL, ohne Premium-Stufe und ohne Telemetrie. Beides steht so auf jellyfin.org, und weil der Quellcode offen liegt, kann man es nachprüfen statt glauben. Seit dem 08-09-2026 gibt es Version 12.0\. Die installieren wir jetzt per Docker Compose, mit Ordnern, die du in einem Jahr noch verstehst, und mit einem Container, der nicht als root läuft.

**Kurz gesagt:** Am Ende läuft Jellyfin 12 als Container auf deinem Linux-Rechner, unter deinem Benutzerkonto statt als root, mit einem Admin-Konto, zwei Bibliotheken für Filme und Serien und einer Ordnerstruktur, die Jellyfin ohne Nachhilfe erkennt. Fernseher, Handy und Browser im Heimnetz spielen ab. Dauer: rund 20 Minuten, davon eine fürs Herunterladen des Images. Stufe: Standard, du kennst Docker und die Kommandozeile im Groben. Stand: Jellyfin 12.0 (Docker-Tag `12`), geprüft am 12-09-2026.

![Schaubild: Jellyfin in drei Schritten: Ordner unter /srv und compose.yaml anlegen, docker compose up -d mit Erfolgskontrolle über /health, Einrichtungsassistent auf Port 8096 mit Benutzer und Bibliotheken](https://sakis.tech/content/images/2026/09/grafik-16-1.png)

Der ganze Weg auf einen Blick: Ordner und Rezept, Container starten, Assistent im Browser.

## Was Jellyfin macht und was dafür laufen muss

Ein Medienserver nimmt deine Videodateien, erkennt am Dateinamen, welcher Film oder welche Folge das ist, holt Cover und Beschreibung dazu und schickt das Video an das Gerät, das gerade danach fragt. Passt das Format zum Gerät, reicht er die Datei unverändert durch. Passt es nicht, rechnet er sie unterwegs um. Das Zweite heißt Transcoding, und es ist der Grund, warum ein Medienserver mal gar nichts und mal die ganze CPU braucht.

**Direct Play und Transcoding?** Direct Play heißt: Die Datei geht so, wie sie ist, zum Fernseher; der Server reicht sie nur durch, das kostet fast nichts. Transcoding heißt: Der Fernseher kann das Format nicht, also übersetzt der Server das Video in Echtzeit in eines, das er versteht. Ein Dolmetscher, den man nur braucht, wenn zwei nicht dieselbe Sprache sprechen.

Abspielen kann so ziemlich alles, was einen Bildschirm hat. Jellyfin hat eigene Apps für Android TV und Fire TV, LG webOS, Samsung Tizen, Roku und Xbox, für Android und iOS, einen Desktop-Player und ein Kodi-Add-on. Jeder Browser geht sowieso. Der Weg ist immer derselbe:

App auf dem Fernseher→ Port 8096 →Jellyfin-Container→ liest /media →/srv/medien auf deiner Platte

Warum Docker und nicht das Debian-Paket? Weil die ganze Installation dann aus einer Datei besteht und ein Update aus zwei Befehlen. Und weil das Image seinen eigenen ffmpeg mitbringt: Die Jellyfin-Doku empfiehlt ausdrücklich jellyfin-ffmpeg und warnt, dass ein fremdes ffmpeg nur teilweise beschleunigt. Im offiziellen Image `jellyfin/jellyfin` steckt der richtige schon drin.

## Was du brauchst

- Einen Linux-Rechner mit Docker und Docker Compose v2\. Das Image gibt es für amd64 und arm64; ein Raspberry Pi 4 oder 5 reicht, solange die Geräte die Dateien direkt abspielen, beim Transcoding geht ihm die Luft aus. Wer Docker noch nicht hat: [Bei Paperless-ngx](https://sakis.tech/paperless-ngx-mit-docker-installieren-schritt-fur-schritt/) steht der Weg.
- Platz für die Sammlung, auf dem Rechner selbst oder auf einer dort eingehängten Platte. Wo genau, legen wir gleich fest.
- Port 8096 frei.
- Ein Gerät im selben Netz, auf dem du am Ende etwas abspielst, und sei es der Browser auf dem Laptop.

**So liest du diese Anleitung:** Alles, was du selbst tun sollst, steht in einem farbigen Kasten. **\[ per klick \]** heißt: Das erledigst du mit der Maus in einer Web-Oberfläche, hier der Einrichtungsassistent und die Weboberfläche von Jellyfin im Browser. **\[ über die shell \]** heißt: Den Befehl kopieren, ins Terminal einfügen, Enter. Stehen beide Kästen direkt untereinander, führen sie zum selben Ergebnis. Du gehst EINEN davon, nicht beide.

Die prüfbaren Punkte klärst du auf dem Server. Zuerst Docker:

```bash
docker --version
docker compose version
```

Beide Zeilen liefern eine Versionsnummer. Fehlt die zweite, oder kennt dein Rechner nur `docker-compose` mit Bindestrich, ist das die alte Version 1; die Anleitung setzt v2 voraus.

Dann deine Benutzerkennung. Jellyfin soll gleich als dein Benutzer laufen, und dafür brauchst du zwei Zahlen:

```bash
id -u
id -g
```

```text
1000
1000
```

Auf den meisten Rechnern kommt zweimal `1000`, weil das der erste Benutzer ist, der bei der Installation angelegt wurde. Steht bei dir etwas anderes, merk es dir: Die Zahl kommt unten an zwei Stellen vor.

Und der Port:

```bash
sudo ss -tulpn | grep ':8096 ' || echo "Port 8096 ist frei"
```

```text
Port 8096 ist frei
```

Steht statt der Meldung eine Zeile mit einem Programmnamen, sitzt dort schon jemand. [Wie du ihn findest](https://sakis.tech/port-belegt-so-findest-du-den-schuldigen-und-gibst-ihn-frei/), steht in einem eigenen Beitrag.

Alle Befehle rechnen mit denselben Beispielwerten. Wo sie unten auftauchen, setzt du deine ein:

- IP-Adresse des Docker-Rechners: `192.168.178.20`
- Benutzer- und Gruppenkennung auf dem Server: `1000` und `1000`
- Ordner für die Compose-Datei: `~/jellyfin`
- Ordner für Jellyfins eigene Daten: `/srv/jellyfin`, darin `config` und `cache`
- Ordner für die Sammlung: `/srv/medien`, darin `Filme` und `Serien`
- Port der Weboberfläche: `8096`
- Erster Benutzer in Jellyfin: `sakis`
- Sein Passwort: `Regal-Kino-2026` als Platzhalter; du nimmst ein eigenes, langes

## Schritt 1: Ordner anlegen und dir selbst übergeben

Jellyfin braucht drei Orte: `config` für Datenbank, Benutzer, Einstellungen und die heruntergeladenen Cover, `cache` für Vorschaubilder und Zwischendateien beim Transcoding, und die Sammlung selbst. Die ersten beiden kommen unter `/srv/jellyfin`, die Sammlung unter `/srv/medien`, getrennt nach Filmen und Serien. `/srv` statt Home-Verzeichnis, weil die Sammlung nicht an deinem Benutzerkonto hängen soll: Kommt später ein zweiter Dienst dazu, etwa Immich für die Fotos, findet er seinen Platz daneben.

```bash
sudo mkdir -p /srv/jellyfin/config /srv/jellyfin/cache /srv/medien/Filme /srv/medien/Serien
sudo chown -R 1000:1000 /srv/jellyfin /srv/medien
ls -ln /srv
```

Unter `/srv` darf nur root Ordner anlegen, deshalb `sudo`. Der zweite Befehl übergibt sie deinem Benutzer, mit den beiden Zahlen aus `id`. Der dritte zeigt das Ergebnis: In der dritten und vierten Spalte steht jeweils `1000`, bei `jellyfin` wie bei `medien`. Stünde dort `0`, gehörten die Ordner noch root, und Jellyfin dürfte gleich nicht hineinschreiben.

Liegt deine Sammlung schon woanders, etwa auf einer Platte unter `/mnt/daten/Filme`, lässt du `/srv/medien` weg und trägst in der Compose-Datei deinen Pfad ein. Der Container muss die Dateien lesen dürfen, mehr nicht.

Dazu ein Ordner für die Compose-Datei, im Home-Verzeichnis, wie bei allen Diensten hier:

```bash
mkdir -p ~/jellyfin
cd ~/jellyfin
```

## Schritt 2: Die Compose-Datei

Grundlage ist die Compose-Datei aus der Jellyfin-Doku zur Container-Installation. Ich habe sie auf das gekürzt, was ein Heimnetz braucht, und die Pfade aus Schritt 1 eingesetzt. Was jede Zeile tut, steht unter der Datei.

Datei anlegen:

```bash
nano compose.yaml
```

Inhalt einfügen, mit Strg+O und Enter speichern, mit Strg+X schließen:

```yaml
services:
  jellyfin:
    image: jellyfin/jellyfin:12
    container_name: jellyfin
    user: 1000:1000
    ports:
      - "8096:8096/tcp"
      - "7359:7359/udp"
    volumes:
      - /srv/jellyfin/config:/config
      - /srv/jellyfin/cache:/cache
      - /srv/medien/Filme:/media/Filme
      - /srv/medien/Serien:/media/Serien
    restart: unless-stopped
```

Ob Compose die Datei versteht, zeigt eine Probe ohne Start:

```bash
docker compose config --quiet && echo OK
```

```text
OK
```

Kommt eine Fehlermeldung mit Zeilennummer statt `OK`, ist an dieser Stelle fast immer ein Leerzeichen zu viel oder zu wenig; YAML zählt die Einrückung.

`**image: jellyfin/jellyfin:12**` Das offizielle Image, festgenagelt auf die Hauptversion. Der Tag `12` bekommt alle 12.x-Updates, springt aber nie von selbst auf 13\. Heute zeigen `12`, `12.0` und `latest` auf dasselbe Image, die Prüfsummen auf Docker Hub sind identisch. Der Unterschied kommt später: Für den Sprung auf 12 hat Jellyfin ein vollständiges Backup dringend nahegelegt, weil die Datenbankänderungen keinen Weg zurück lassen. So einen Sprung will man bewusst machen, nicht bei einem beiläufigen `pull`. Was das Update auf 12 konkret bedeutet, steht im [Beitrag zum Release](https://sakis.tech/jellyfin-12-0-release/).

`**user: 1000:1000**` Der Container läuft als dein Benutzer, nicht als root. In der Doku ist die Zeile als optional markiert; für mich ist es die wichtigste in der Datei. Alles, was Jellyfin schreibt, gehört damit dir, und du kommst ohne `sudo` an deine Daten. Der Preis ist Schritt 1: Die Ordner müssen dir gehören, sonst startet Jellyfin nicht.

`**ports**` 8096 ist die Weboberfläche und zugleich die Schnittstelle für alle Apps, per HTTP. 7359 per UDP ist die Erkennung: Darüber finden die Apps im Heimnetz den Server von selbst, ohne dass du eine Adresse eintippst. Den HTTPS-Port 8920 lassen wir weg, die Doku rät, HTTPS einem Reverse Proxy zu überlassen. Und `network_mode: host`, das die Doku als Alternative zeigt, brauchst du laut derselben Doku nur für DLNA, und DLNA ist in Jellyfin ein Plugin.

`**volumes**` Links steht der Ordner, wie ihn dein Rechner kennt, rechts der Name, unter dem der Container ihn sieht. Für Jellyfin heißt deine Filmsammlung `/media/Filme`, und genau so trägst du sie gleich im Assistenten ein. Die beiden Medienordner hänge ich einzeln ein statt `/srv/medien` als Ganzes: So sieht Jellyfin nur Filme und Serien, und ein Ordner `Fotos` oder `Backup` daneben bleibt unsichtbar.

**`restart: unless-stopped`** Nach einem Neustart des Rechners kommt der Container von selbst wieder hoch, außer du hast ihn vorher bewusst angehalten.

## Schritt 3: Starten

```bash
docker compose up -d
```

Beim ersten Mal lädt Docker das Image; an einer normalen Leitung ist das in unter einer Minute erledigt, an einer langsamen dauert es ein paar. Danach:

```bash
docker compose ps
```

In der Spalte `STATUS` muss `Up` stehen, nach spätestens einer Minute ergänzt um `(healthy)`. Das Image bringt einen eigenen Gesundheitstest mit: Alle 30 Sekunden fragt es sich selbst unter `/health`, ob Webserver und Datenbank antworten. Dieselbe Frage kannst du stellen:

```bash
curl -s http://127.0.0.1:8096/health; echo
```

```text
Healthy
```

Ein Wort, und es ist das richtige. Das ist die Stelle, die ich bei jedem Dienst kurz auskoste: Der Container hat in `/srv/jellyfin/config` seine Datenbank angelegt, unter deinem Benutzer, und meldet sich gesund. Fehlt `curl` auf dem Rechner, holt `sudo apt install curl` es nach; oder du gehst gleich in den Browser, das ist ohnehin der nächste Schritt.

## Schritt 4: Der Einrichtungsassistent

Alles Weitere passiert im Browser. Der Assistent hat laut Doku sechs Seiten, in dieser Reihenfolge: Sprache, Admin-Konto, Bibliotheken, Metadaten-Sprache, Fernzugriff, fertig.

Im Browser `http://192.168.178.20:8096` öffnen. Die erste Seite heißt **Willkommen bei Jellyfin!** und hat zwei Felder: **Servername** ist mit dem Namen deines Rechners vorbelegt und kann so bleiben; bei **Bevorzugte Anzeigesprache** wählst du **Deutsch**, falls dort noch Englisch steht. Unten **Nächstes**. Die zweite Seite heißt **Erzähl uns etwas über dich**: bei **Benutzername** `sakis` eintragen, bei **Passwort** und **Passwort (bestätigen)** ein neues, langes Passwort (in den Beispielwerten steht ein Platzhalter). Wieder **Nächstes**. Stand Jellyfin 12.0.

![Die Willkommensseite des Jellyfin-Assistenten mit der Anzeigesprache Deutsch und dem Knopf Nächstes.](https://sakis.tech/content/images/2026/09/labor-jellyfin-docker-compose-installieren-01-2026-09-20-1.png)

(1) Deutsch wählen; (2) Hier klicken

![Die zweite Seite des Assistenten mit dem Benutzernamen sakis und den beiden ausgefüllten Passwortfeldern.](https://sakis.tech/content/images/2026/09/labor-jellyfin-docker-compose-installieren-02-2026-09-20-1.png)

(1) sakis; (2) Neues, langes Passwort; (3) Hier klicken

Das ist das Admin-Konto dieses Servers. Die Doku bittet um ein starkes Passwort, und ich würde es direkt in den Passwort-Manager legen, bevor der Browser es sich merkt und du es in einem Jahr am Fernseher brauchst.

Die dritte Seite heißt **Medienbibliotheken einrichten**. Auf **Medienbibliothek hinzufügen**. Im Dialog bei **Inhaltstyp** **Filme** wählen und bei **Anzeigename** `Filme` eintragen. Bei **Verzeichnisse** auf das Plus; im Fenster **Verzeichnis wählen** in das Feld **Ordner** den Pfad `/media/Filme` tippen und **OK**. Alle anderen Einstellungen bleiben auf der Vorgabe; unten im Dialog **OK**. Dasselbe noch einmal für die Serien: **Medienbibliothek hinzufügen**, **Inhaltstyp** **Serien**, **Anzeigename** `Serien`, Ordner `/media/Serien`. Dann **Nächstes**. Stand Jellyfin 12.0.

![Das Fenster Verzeichnis wählen mit dem Pfad /media/Filme im Feld Ordner und dem Knopf OK.](https://sakis.tech/content/images/2026/09/labor-jellyfin-docker-compose-installieren-03-2026-09-20-1.png)

(1) /media/Filme; (2) Hier klicken

![Der Dialog Medienbibliothek hinzufügen mit Inhaltstyp Filme, Anzeigename Filme und dem eingetragenen Verzeichnis /media/Filme.](https://sakis.tech/content/images/2026/09/labor-jellyfin-docker-compose-installieren-04-2026-09-20-1.png)

(1) Filme wählen; (2) Filme; (3) Plus für den Ordner

![Die Seite Medienbibliotheken einrichten mit den Kacheln Filme und Serien und dem Knopf Nächstes.](https://sakis.tech/content/images/2026/09/labor-jellyfin-docker-compose-installieren-05-2026-09-20-1.png)

(1) Filme; (2) Serien; (3) Hier klicken

Der Pfad ist der aus Sicht des Containers, also `/media/Filme` und nicht `/srv/medien/Filme`. Das ist die Stelle, an der bei Docker-Diensten die meisten stolpern, deshalb steht es hier zum zweiten Mal. Die Doku merkt zum Ordnerdialog an: Taucht ein Ordner dort nicht auf, ist es meist ein Rechteproblem, und das heißt hier fast immer, dass Schritt 1 übersprungen wurde.

Die vierte Seite heißt **Bevorzugte Metadaten-Sprache**: bei **Sprache** **German** wählen, bei **Land/Region** **Germany** (die beiden Listen sind englisch beschriftet). **Nächstes**. Die fünfte Seite heißt **Fernzugriff konfigurieren**: Der Haken **Externe Verbindungen zu diesem Server zulassen** bleibt gesetzt; einen zweiten Haken gibt es auf dieser Seite nicht. **Nächstes**. Auf der letzten Seite, **Du bist fertig!**, auf **Fertig**. Jellyfin zeigt danach die Anmeldeseite: dein Benutzer **sakis**, das Passwort von eben, **Einloggen**. Stand Jellyfin 12.0.

![Die Seite Bevorzugte Metadaten-Sprache mit Sprache German und Land/Region Germany.](https://sakis.tech/content/images/2026/09/labor-jellyfin-docker-compose-installieren-06-2026-09-20-1.png)

(1) German wählen; (2) Germany wählen; (3) Hier klicken

![Die Seite Fernzugriff konfigurieren mit dem gesetzten Haken Externe Verbindungen zu diesem Server zulassen.](https://sakis.tech/content/images/2026/09/labor-jellyfin-docker-compose-installieren-07-2026-09-20-1.png)

(1) Haken bleibt gesetzt; (2) Hier klicken

![Die Anmeldeseite von Jellyfin mit dem Benutzer sakis, dem ausgefüllten Passwort und dem Knopf Einloggen.](https://sakis.tech/content/images/2026/09/labor-jellyfin-docker-compose-installieren-08-2026-09-20-1.png)

(1) sakis; (2) Das Passwort von eben; (3) Hier klicken

Die Metadaten-Sprache ist laut Doku die Vorgabe für den ganzen Server: In dieser Sprache holt Jellyfin Titel und Beschreibungen, und wo es keine deutsche gibt, nimmt es die nächste. Der Haken für externe Verbindungen klingt nach mehr, als er ist. Er erlaubt Jellyfin, Anfragen von außerhalb deines Netzes anzunehmen; erreichbar von außen wird der Server damit nicht, dafür müsste dein Router einen Port weiterleiten, und das tut er nicht. Die Doku empfiehlt, den Haken zu lassen, und ich sehe es genauso, denn ohne ihn sperrt Jellyfin später auch Verbindungen aus einem VPN aus, solange dessen Adressen nicht als Heimnetz eingetragen sind. Die automatische Portzuordnung dagegen würde deinen Router per UPnP bitten, genau so eine Weiterleitung einzurichten. Die Doku rät davon ab, und der Assistent in Jellyfin 12 bietet den Haken gar nicht erst an.

## Schritt 5: Filme und Serien einsortieren

Jetzt der Teil, mit dem Jellyfin steht und fällt: die Dateinamen. Jellyfin erkennt Filme und Folgen an Ordner und Dateiname. Stimmt die Form, holt es Cover, Beschreibung und Besetzung von selbst; stimmt sie nicht, siehst du Dateinamen statt Filme. Die Doku beschreibt das Schema so, hier mit deutschen Beispielnamen:

```text
Filme
├── Der Name des Films (2019)
│   └── Der Name des Films (2019).mkv
└── Noch ein Film (2021)
    └── Noch ein Film (2021).mp4

Serien
└── Name der Serie (2010)
    ├── Season 01
    │   ├── Name der Serie S01E01.mkv
    │   └── Name der Serie S01E02.mkv
    └── Season 02
        └── Name der Serie S02E01.mkv
```

Jeder Film bekommt einen eigenen Ordner, die Jahreszahl in Klammern ist laut Doku optional, aber sie macht die Zuordnung eindeutig. Bei Serien heißen die Staffelordner wörtlich `Season 01`, `Season 02` und so weiter, und die Doku ist da unmissverständlich: „Do not abbreviate the Season name to S01 or SE01.“ Specials kommen in `Season 00`. Die Folgen tragen Seriennamen plus `S01E01`. Wer es ganz sicher haben will, hängt die Kennung der Datenbank an, etwa `[imdbid-tt0000000]`; auch das steht in der Doku.

Die Dateien kopierst du mit dem Werkzeug deiner Wahl in die Ordner, per `scp`, per Netzwerkfreigabe oder mit einem Dateimanager. Hauptsache, sie landen unter `/srv/medien/Filme` beziehungsweise `/srv/medien/Serien`. Danach sagst du Jellyfin Bescheid:

Oben rechts auf dein Profilbild, im Menü **Übersicht**. Links im Menü der Übersicht auf **Bibliotheken**, im aufgeklappten Untermenü noch einmal auf **Bibliotheken**, dort auf **Alle Bibliotheken scannen**; derselbe Knopf steht auch schon direkt auf der Übersicht. Zurück auf der Startseite, über das Jellyfin-Logo oben links, erscheinen die Filme mit Cover. Stand Jellyfin 12.0.

![Die Startseite von Jellyfin mit dem über das Profilbild geöffneten Benutzermenü und dem Eintrag Übersicht.](https://sakis.tech/content/images/2026/09/labor-jellyfin-docker-compose-installieren-09-2026-09-20-1.png)

Hier klicken

![Die Seite Bibliotheken in der Übersicht mit dem Knopf Alle Bibliotheken scannen.](https://sakis.tech/content/images/2026/09/labor-jellyfin-docker-compose-installieren-10-2026-09-20.png)

(1) Bibliotheken; (2) Hier klicken

Der erste Scan holt für jeden Titel Bilder und Texte aus dem Netz, bei ein paar hundert Filmen dauert das Minuten. Was Jellyfin nicht erkennt, lässt es als Dateinamen stehen; dann ist es fast immer der Ordner oder die Staffel-Schreibweise, siehe unten bei „Wo es klemmt“.

## Was am Ende eingestellt ist

Jellyfin läuft, der Fernseher spielt. Fünf Dinge würde ich jetzt noch klären, bevor die Sammlung wächst.

**1\. Der Container läuft als du.** Alles unter `/srv/jellyfin` gehört deinem Benutzer; ein Blick mit `ls -ln` zeigt `1000`, kein `0`. Das heißt auch: Dateien, die du als root in die Sammlung kopierst, kann Jellyfin trotzdem lesen, solange sie für alle lesbar sind, was bei `cp` und `scp` die Regel ist. Wer sicher sein will, dass Jellyfin in der Sammlung nie etwas anfasst, hängt die Medienordner mit `:ro` am Ende ein, also `/srv/medien/Filme:/media/Filme:ro`; die offizielle Compose-Datei zeigt dieselbe Idee mit `read_only: true`.

**2\. Nur im Heimnetz, und per HTTP.** Port 8096 spricht unverschlüsselt. Im Router gibt es keine Weiterleitung dafür, und so bleibt es, auch wenn die Apps den Server nach der ersten Reise nicht mehr finden. Wer die Sammlung unterwegs will, nimmt ein VPN oder einen [Reverse Proxy](https://sakis.tech/was-ist-ein-reverse-proxy-einfach-erklart-furs-homelab/) mit HTTPS davor; die Doku sagt dazu, dass der Zugriff über einen Reverse Proxy nur funktioniert, wenn Jellyfin ihn unter Known Proxies kennt, denn sonst sieht es von jedem Besucher nur die Adresse des Proxys. Das ist ein eigener Beitrag.

**3\. Updates kommen von dir.** Jellyfin aktualisiert sich nicht selbst. Neue 12.x-Versionen holst du wie bei jedem Container:

```bash
cd ~/jellyfin
docker compose pull && docker compose up -d
```

Gibt es nichts Neues, passiert nichts, und der Container bleibt, wie er ist. Steht eines Tages eine 13 vor der Tür, änderst du den Tag in der Compose-Datei von Hand, und zwar erst nach einem Backup, so wie es beim Sprung auf 12 auch nötig war.

**4\. Das Backup ist ein Ordner.** Alles, was Jellyfin über dich weiß, liegt in `/srv/jellyfin/config`: Benutzer, Bibliotheken, Sehstand, Einstellungen, die Datenbank. `cache` kann jederzeit weg, Jellyfin baut ihn neu. Die Sammlung selbst ist der größte Posten und das eigene Thema. Der Config-Ordner ist klein und gehört in jedes Backup, das du hast; ja, ich fange schon wieder davon an, aber ein Jellyfin ohne diesen Ordner ist ein Jellyfin, das nichts mehr über dich weiß.

**5\. Transcoding rechnet die CPU.** Solange ein Gerät die Datei direkt abspielt, passiert nichts. Kann es das Format nicht, rechnet der Prozessor, und ein schwacher Prozessor rechnet zu langsam für ein flüssiges Bild. Die Abhilfe heißt Hardware-Beschleunigung: Die Doku hat dafür eine eigene Seite mit Intel Quick Sync, VA-API, NVIDIA und AMD, und unter Docker muss der Container dafür die Grafikeinheit sehen, mit `--device /dev/dri/:/dev/dri/`. Das ist bewusst nicht in dieser Compose-Datei, weil es je nach Rechner anders geht, und es bekommt seinen eigenen Beitrag.

## Wo es klemmt

**Der Container startet immer wieder neu, und im Log steht „Access to the path '/config/…' is denied“.** Die Ordner gehören root, nicht dir. Das passiert, wenn Schritt 1 fehlt oder wenn Docker die Ordner beim ersten Start selbst angelegt hat. In den Issues bei Jellyfin beschreibt genau das Issue #9925: mit `user: uid:gid` in der Compose-Datei und Ordnern, die root gehören, verweigert Jellyfin den Start. Nachsehen und beheben:

```bash
docker compose logs --tail 30 jellyfin
sudo chown -R 1000:1000 /srv/jellyfin
docker compose restart
```

**Die Bibliothek bleibt leer, oder Folgen landen im falschen Fach.** Erst der Pfad: Im Assistenten muss `/media/Filme` stehen, nicht der Pfad deines Rechners. Was der Container wirklich sieht, verrät ein Blick hinein:

```bash
docker compose exec jellyfin ls /media/Filme
```

Steht hier nichts, obwohl auf dem Rechner Dateien liegen, zeigt die Compose-Datei auf den falschen Ordner. Steht hier alles, ist es die Schreibweise: ein Staffelordner `S01` statt `Season 01`, eine Folge ohne `S01E01`, ein Film ohne eigenen Ordner. Das Schema aus Schritt 5 ist die Sprache, die Jellyfin versteht; als Empfehlung sollte man es nicht lesen.

**Die App auf dem Fernseher findet den Server nicht.** Die automatische Suche läuft über Port 7359 per UDP, und manche Netze, vor allem ein Gastnetz oder ein WLAN mit Client-Isolation, lassen das nicht durch. Dann trägst du die Adresse von Hand ein, `http://192.168.178.20:8096`, mit Port. Das funktioniert immer, solange Fernseher und Server im selben Netz hängen.

**Port 8096 ist belegt.** Ein anderer Dienst war schneller. Entweder er weicht, oder Jellyfin: In der Compose-Datei die Zeile zu `"8097:8096/tcp"` ändern, dann lauscht Jellyfin außen auf 8097 und innen weiter auf 8096, und im Browser heißt es `http://192.168.178.20:8097`.

Ein Container, eine Datei, sechs Seiten Assistent, und der Fernseher spielt aus deinem Regal. Was mir daran gefällt, ist nicht die Technik, es ist der Satz vom Anfang, der jetzt stimmt: dein Server, deine Filme, dein Weg. Niemand nimmt einen Film aus dem Programm, weil ein Lizenzvertrag ausläuft.

Welches Gerät hängt bei dir am Ende dran, und läuft es durchreichend oder muss der Server rechnen? Schreib's in die Kommentare, gern samt Prozessor. Das ist genau die Zahl, die andere vor dem Kauf suchen und in keinem Datenblatt finden.

Und wenn die Sammlung eines Tages mit in den Urlaub soll: Der Weg dahin beginnt mit dem [Reverse Proxy](https://sakis.tech/was-ist-ein-reverse-proxy-einfach-erklart-furs-homelab/), und den gibt es hier schon erklärt.

sakis@homelab:\~$ echo "bleib neugierig — und mach backups" 

## Quellen

- [Jellyfin-Doku: Container Installation (offizielle Compose-Datei, user uid:gid, Ports 8096 und 7359, host-Netzwerk nur für DLNA, /dev/dri für Hardware-Beschleunigung)](https://jellyfin.org/docs/general/installation/container/?ref=sakis.tech)
- [Jellyfin-Doku: Setup Wizard (die sechs Seiten, starkes Passwort, Rechtehinweis im Ordnerdialog, Metadaten-Sprache als Server-Vorgabe, Fernzugriff und Portzuordnung)](https://jellyfin.org/docs/general/post-install/setup-wizard?ref=sakis.tech)
- [Jellyfin-Doku: Networking (8096 HTTP, 8920 HTTPS, 7359 Client Discovery, Known Proxies, HTTPS am Reverse Proxy)](https://jellyfin.org/docs/general/post-install/networking/?ref=sakis.tech)
- [Jellyfin-Doku: Monitoring (der Endpunkt /health)](https://jellyfin.org/docs/general/post-install/networking/advanced/monitoring/?ref=sakis.tech)
- [Jellyfin-Doku: Movies (Ordner pro Film, Jahr in Klammern, imdbid)](https://jellyfin.org/docs/general/server/media/movies/?ref=sakis.tech)
- [Jellyfin-Doku: Shows (Season 01, Season 00, S01E01, „Do not abbreviate“)](https://jellyfin.org/docs/general/server/media/shows/?ref=sakis.tech)
- [Jellyfin-Doku: Hardware Acceleration (Verfahren, jellyfin-ffmpeg)](https://jellyfin.org/docs/general/post-install/transcoding/hardware-acceleration/?ref=sakis.tech)
- [jellyfin.org: Startseite („Your media, your server, your way“, freie Software, kein Tracking, keine Kosten)](https://jellyfin.org/?ref=sakis.tech)
- [jellyfin.org: Clients (Android TV, Fire TV, webOS, Tizen, Roku, Xbox, Android, iOS, Desktop, Kodi)](https://jellyfin.org/downloads/clients/?ref=sakis.tech)
- [Jellyfin: Release 12.0 (08-09-2026, Backup-Pflicht vor dem Update, Breaking Changes)](https://github.com/jellyfin/jellyfin/releases/latest?ref=sakis.tech)
- [Docker Hub: Tags jellyfin/jellyfin (12, 12.0, latest mit identischem Digest, 08-09-2026, amd64 und arm64)](https://hub.docker.com/v2/repositories/jellyfin/jellyfin/tags?page%5Fsize=50&name=12&ref=sakis.tech)
- [Jellyfin: Dockerfile (kein USER, /config und /cache, Healthcheck alle 30 s auf /health)](https://github.com/jellyfin/jellyfin-packaging/blob/master/docker/Dockerfile?ref=sakis.tech)
- [Jellyfin-Web: deutsche Oberflächentexte (Beschriftungen des Assistenten)](https://github.com/jellyfin/jellyfin-web/blob/master/src/strings/de.json?ref=sakis.tech)
- [Jellyfin: Issue #9925, Wrong files permission with docker-compose (root-Ordner und user uid:gid)](https://github.com/jellyfin/jellyfin/issues/9925?ref=sakis.tech)