# Persönlichen Jellyfin-Server einrichten: So geht es mit Ubuntu und Docker

Ein persönlicher Jellyfin-Server ist eine praktische Lösung, wenn Sie Filme, Serien, Musik oder Fotos zentral speichern und selbst hosten möchten. Statt Ihre Medien bei einem fremden Streamingdienst abzulegen, behalten Sie auf allen Geräten die volle Kontrolle über Dateien, Benutzerkonten und den Zugriff.

## Was ist Jellyfin?

Jellyfin ist ein [Open-Source](https://www.ionos.de/digitalguide/server/knowhow/was-ist-open-source/)-Medienserver, mit dem Sie Ihre eigene **Mediensammlung organisieren, katalogisieren** und per Webbrowser oder App auf verschiedene Endgeräte streamen können. Die Software unterstützt typische Bibliotheken wie Filme, Serien, Musik und Fotos, bietet Benutzerverwaltung, Metadaten, Cover, Wiedergabefortschritt sowie Streaming über das Netzwerk.

Weil Jellyfin selbst gehostet wird, läuft der Dienst **unabhängig von einem externen Anbieter**. Das Internet wird nur für Dinge wie Metadatenabruf oder externen Zugriff benötigt. Für den Zugriff im Heimnetz nutzt Jellyfin standardmäßig HTTP auf Port 8096. Optional kann auch [HTTPS](https://www.ionos.de/digitalguide/hosting/hosting-technik/was-ist-https/) eingesetzt werden, wobei die offizielle Dokumentation für externen Zugriff einen Reverse Proxy und vertrauenswürdige Zertifikate empfiehlt.

## Welche Server-Voraussetzungen sind sinnvoll?

Bevor Sie installieren, sollten Sie zuerst den passenden Server-Typ auswählen. Für Jellyfin ist nicht nur entscheidend, wie viele Dateien Sie speichern möchten, sondern vor allem, ob Ihre Geräte die Mediendateien direkt abspielen können oder ob der Server sie während der Wiedergabe umwandeln muss. Diese Umwandlung heißt **Transkodierung** und ist besonders ressourcenintensiv. Besonders 4K, HDR-zu-SDR-Tonemapping und mehrere gleichzeitige Streams können [CPU](https://www.ionos.de/digitalguide/server/knowhow/cpu/) oder GPU stark belasten.

Die Jellyfin-Dokumentation nennt für **durchschnittliche Installationen** mindestens 8 GB [RAM](https://www.ionos.de/digitalguide/server/knowhow/was-ist-ein-arbeitsspeicher/) als allgemeine Empfehlung. Für einen Linux-Server ohne grafische Oberfläche können 4 GB genügen. Außerdem empfiehlt Jellyfin bei Hardwarebeschleunigung auf Nicht-Apple-Systemen Intel-Grafik, weil Einrichtung und Encoder-Qualität in der Praxis günstig ausfallen.

Im Folgenden zeigen wir anhand einiger Szenarien, welcher Server sich für Sie und Ihren individuellen Anwendungsfall am besten eignet.

### Privatanwendende und Familien

Wenn Sie Jellyfin hauptsächlich allein oder mit zwei bis drei Personen nutzen und Ihre Dateien schon in gängigen [Videoformaten](https://www.ionos.de/digitalguide/websites/webdesign/videoformate/) wie **MP4 mit H.264** vorliegen, reicht oft ein guter [VPS](https://www.ionos.de/server/vps "VPS günstig mieten bei IONOS"). In diesem Szenario muss der Server meist nur Dateien ausliefern, statt sie bei jeder Wiedergabe neu zu berechnen. Dafür ist ein Linux-VPS ein sinnvoller Einstieg, wobei mindestens 4 vCores, 4 GB RAM und etwa 120 GB NVMe-Speicher vorhanden sein sollten. Wenn Sie etwas mehr Luft für Metadaten, größere Bibliotheken und gelegentliche Umwandlungen möchten, sind 6 vCores, 8 GB RAM und 240 GB NVMe die bequemere Wahl.

Der Vorteil eines VPS liegt vor allem im **Preis-Leistungs-Verhältnis**. Sie erhalten genug Leistung für einen persönlichen Medienserver, ohne sofort in dedizierte Hardware investieren zu müssen. Diese Variante ist vor allem dann passend, wenn Ihre Endgeräte moderne Formate bereits nativ wiedergeben und Transkodierung nur selten nötig ist.

### Fortgeschrittene Nutzerinnen und Nutzer

Wenn Sie etwas mehr Spielraum brauchen, weil Ihre Bibliothek schneller wächst, Sie mehrere Benutzerkonten anlegen oder die Server-Ressourcen flexibler anpassen möchten, sind [Cloud Server](https://www.ionos.de/digitalguide/server/knowhow/was-ist-ein-cloud-server/) beziehungsweise sogenannte [Cloud Cubes](https://cloud.ionos.de/compute/cloud-cubes "IONOS Cloud Cubes") sinnvoll. Server und Cubes ab 4 vCPU, 8 GB RAM und 240 GB Storage können genutzt werden. Sie haben damit deutlich mehr Luft für parallele Scans, Metadaten, Bibliotheken und gelegentliche Transkodierungen.

Der große Vorteil dieser Variante ist die **Flexibilität**. Cloud-Server lassen sich sehr gut an veränderte Anforderungen anpassen. Das ist praktisch, wenn Sie klein anfangen, aber später mehrere Bibliotheken, mehr Nutzerinnen und Nutzer oder zusätzliche Dienste wie [Reverse Proxy](https://www.ionos.de/digitalguide/server/knowhow/was-ist-ein-reverse-proxy/), Monitoring oder [Backup](https://www.ionos.de/digitalguide/server/sicherheit/was-ist-ein-backup/) ergänzen möchten. Für fortgeschrittene Privatnutzende, kleine Teams oder Homelab-affine User ist das oft die angenehmste Mittelklasse.

### Power-User und 4K-Liebhaberinnen und -Liebhaber

Nutzerinnen und Nutzer, die viele 4K-Inhalte besitzen, HDR-Material an ältere Geräte ausliefern möchten oder mehrere User gleichzeitig transkodieren, kommen mit einem kleinen VPS schnell an ihre Grenzen. Jellyfin weist ausdrücklich darauf hin, dass **softwarebasiertes HDR-zu-SDR-Tonemapping extrem CPU-lastig** sein kann. Für solche Szenarien ist ein [Dedicated Server](https://www.ionos.de/server/dedicated-server "Dedicated Server von IONOS") beziehungsweise [Bare Metal Server](https://www.ionos.de/server/bare-metal-server "Bare Metal Server von IONOS") die bessere Wahl, weil Sie dort dedizierte Hardware nutzen und Rechenleistung, RAM und Speicher **nicht mit anderen Workloads teilen**.

Hierbei sollten Sie an mindestens 8 CPU-Kerne, 16 bis 32 GB RAM und schnellen SSD- oder NVMe-Speicher denken. Ideal ist zusätzlich eine für Hardwaretranskodierung geeignete Intel- oder NVIDIA-GPU.

### Betriebssystem-Empfehlung: Debian oder Ubuntu?

Beide [Linux-Server-Distributionen](https://www.ionos.de/digitalguide/server/konfiguration/linux-server-distributionen/) sind für Jellyfin geeignet, aber Ubuntu Server 24.04 LTS ist für die meisten Einsteigerinnen und Einsteiger die praktischere Wahl. Docker dokumentiert [Ubuntu](https://www.ionos.de/digitalguide/server/knowhow/ubuntu-das-linux-system-fuer-jedermann/) 24.04 offiziell und viele Anleitungen beziehen sich direkt auf Ubuntu. [Debian](https://www.ionos.de/digitalguide/server/knowhow/debian-die-universelle-system-software/) ist ebenfalls sehr stabil, Ubuntu nimmt Ihnen jedoch ein paar Stolperfallen ab.

Tipp Wenn Ihre Mediensammlung sehr schnell wächst, kann externer Speicher sinnvoll werden. Für Anfängerinnen und Anfänger sind lokale [SSD](https://www.ionos.de/digitalguide/server/knowhow/was-ist-ssd/)- oder NVMe-Speicher auf dem Server ideal. Externer Speicher wie ein zusätzlicher [Object Storage](https://www.ionos.de/digitalguide/server/knowhow/was-ist-object-storage/) lässt sich ebenfalls nutzen, muss dafür jedoch zunächst auf dem Server als Dateisystem eingebunden werden, beispielsweise über ein entsprechendes Mount-Tool. Jellyfin greift nämlich direkt auf Dateien im Dateisystem zu und unterstützt Object Storage nicht direkt als native Speicherquelle. Alternativ kann Object Storage auch als Archivspeicher für ältere Medien genutzt werden, die nicht ständig verfügbar sein müssen.

## Schritt-für-Schritt: Jellyfin mit Docker auf Ubuntu Server installieren

Im folgenden Beispiel zeigen wir die Installation von Jellyfin auf Ubuntu Server 24.04 LTS mit Docker Engine und [Docker Compose](https://www.ionos.de/digitalguide/server/konfiguration/docker-compose-tutorial/) Plugin. Diese Variante ist vor allem für Anfängerinnen und Anfänger eine gute Lösung, weil Docker die Anwendung sauber kapselt und spätere Updates vereinfacht.

### Schritt 1: Ubuntu-Server aktualisieren

Melden Sie sich per [SSH](https://www.ionos.de/digitalguide/server/tools/secure-shell-ssh/) auf Ihrem Server an und bringen Sie zunächst die Paketquellen und installierten Pakete auf den aktuellen Stand:

```bash
sudo apt update
sudo apt upgrade -y
```

Danach können Sie den Server bei Bedarf neu starten (nach einem Neustart ist eine neue Anmeldung erforderlich):

```bash
sudo reboot
```

Dieser Schritt ist wichtig, damit Sie mit aktuellen Paketen, Sicherheitsupdates und einem sauberen System beginnen. Gerade bei einem frisch bereitgestellten Ubuntu-Server ist das der richtige erste Handgriff.

### Schritt 2: Docker auf Ubuntu 24.04 installieren

In einem nächsten Schritt müssen Sie Docker unter Ubuntu 24.04 installieren. Hierzu empfiehlt der Dienst die Einrichtung des offiziellen APT-[Repositories](https://www.ionos.de/digitalguide/server/knowhow/repository/). Zuerst entfernen Sie dazu ältere oder potenziell konfliktträchtige Pakete:

```bash
sudo apt remove docker.io docker-compose docker-compose-v2 docker-doc podman-docker containerd runc -y
```

Nun richten Sie das offizielle Docker-Repository ein:

```bash
sudo apt update
sudo apt install ca-certificates curl -y
sudo install -m 0755 -d /etc/apt/keyrings
sudo curl -fsSL https://download.docker.com/linux/ubuntu/gpg -o /etc/apt/keyrings/docker.asc
sudo chmod a+r /etc/apt/keyrings/docker.asc
sudo tee /etc/apt/sources.list.d/docker.sources <<EOF
Types: deb
URIs: https://download.docker.com/linux/ubuntu
Suites: $(. /etc/os-release && echo "${UBUNTU_CODENAME:-$VERSION_CODENAME}")
Components: stable
Signed-By: /etc/apt/keyrings/docker.asc
EOF
sudo apt update
```

Danach installieren Sie mit folgendem Terminalbefehl Docker Engine, Buildx und das Compose-Plugin:

```bash
sudo apt install docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin -y
```

Prüfen Sie anschließend, ob Docker läuft:

```bash
sudo systemctl status docker
```

Der Status sollte als active (running) angezeigt werden:

[![Bild: Statusanzeige von Docker](https://www.ionos.de/digitalguide/fileadmin/_processed_/b/9/csm_jellyfin-docker-active_ed36b0ce76.webp "Statusanzeige von Docker")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/jellyfin-docker-active.jpg) Die Anzeige „active“ bestätigt, dass Docker läuft. Es lohnt sich, die Installation abschließend mit dem offiziellen Testcontainer zu testen.

```bash
sudo docker run hello-world
```

Die Ausgabe sollte folgendermaßen aussehen:

[![Bild: Hello World von Docker](https://www.ionos.de/digitalguide/fileadmin/_processed_/2/a/csm_jellyfin-docker-hello-world_0a0da78b63.webp "Hello World von Docker")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/jellyfin-docker-hello-world.jpg) Sobald Sie die Hello-World-Nachricht sehen, können Sie sicher sein, dass Docker nicht nur installiert ist, sondern auch wie gewünscht funktioniert. ### Schritt 3: Docker ohne sudo nutzen

Standardmäßig müssen Docker-Befehle oft mit `sudo` ausgeführt werden. Wenn Sie möchten, können Sie Ihren User der Gruppe `docker` hinzufügen:

```bash
sudo usermod -aG docker $USER
newgrp docker
```

Hinweis Die Docker-Dokumentation weist darauf hin, dass Mitglieder der Gruppe docker root-ähnliche Rechte erhalten. Für einen persönlichen Server ist das üblich, aber Sie sollten wissen, dass das in Anwendungen, in denen auch fremde User Zugriff auf Ihren Server erhalten, **sicherheitstechnisch problematisch** sein kann.

### Schritt 4: Verzeichnisstruktur für Jellyfin anlegen

Nachdem die Vorbereitungen abgeschlossen wurden, starten wir mit der Verzeichnisstruktur für den Jellyfin-Server, um so den Jellyfin-Install vorzubereiten. Damit Konfiguration, [Cache](https://www.ionos.de/digitalguide/hosting/hosting-technik/was-ist-ein-cache/) und Medien sauber getrennt sind, legen Sie auf dem Hostsystem passende Ordner an. Wir nutzen folgende Ordnerstruktur (Sie können die Ordner aber auch anders organisieren):

```bash
mkdir -p ~/jellyfin/config
mkdir -p ~/jellyfin/cache
mkdir -p ~/media/filme
mkdir -p ~/media/serien
mkdir -p ~/media/musik
mkdir -p ~/media/fotos
```

config enthält später die Serverkonfiguration, User und Datenbank. cache dient temporären Daten. Die eigentlichen Mediendateien liegen in den getrennten Bibliotheksordnern.

### Schritt 5: UID und GID des Users ermitteln

Jellyfin kann im Container mit der User- und Gruppen-ID Ihres Linux-Users laufen. Das hilft beim Umgang mit den Dateirechten. Ermitteln Sie daher zuerst beide Werte mit:

```bash
id
```

Die ausgegebenen Zahlen benötigen Sie gleich in der Compose-Datei, weshalb Sie sich diese notieren sollten.

### Schritt 6: Docker-Compose-Datei für Jellyfin erstellen

Wechseln Sie in das Arbeitsverzeichnis und erstellen Sie eine Datei namens `docker-compose.yml`. Wir nutzen für die Erstellung den Texteditor nano; Sie können die Datei aber auf jedem beliebigen Weg erstellen.

```bash
mkdir -p ~/jellyfin
cd ~/jellyfin
nano docker-compose.yml
```

Fügen Sie in die soeben erstellte Datei den folgenden Inhalt ein:

```yaml
services:
    jellyfin:
        image: jellyfin/jellyfin
        container_name: jellyfin
        user: "1000:1000"
        ports:
            - "8096:8096/tcp"
            - "7359:7359/udp"
        volumes:
            - ./config:/config
            - ./cache:/cache
            - type: bind
                source: /home/IHRBENUTZER/media/filme
                target: /media/filme
                read_only: true
            - type: bind
                source: /home/IHRBENUTZER/media/serien
                target: /media/serien
                read_only: true
            - type: bind
                source: /home/IHRBENUTZER/media/musik
                target: /media/musik
                read_only: true
            - type: bind
                source: /home/IHRBENUTZER/media/fotos
                target: /media/fotos
                read_only: true
        environment:
            - JELLYFIN_PublishedServerUrl=http://IHRE-SERVER-IP:8096
        restart: unless-stopped
```

Ersetzen Sie in der Datei anschließend:

- den Wert `1000:1000` durch Ihre echte UID:GID, die Sie sich im vorherigen Schritt notiert haben
- `IHRBENUTZER` durch Ihren Linux-Usernamen
- `IHRE-SERVER-IP` durch die [IP-Adresse](https://www.ionos.de/digitalguide/server/knowhow/was-ist-eine-ip-adresse/) Ihres Servers

Tipp Die Medienordner sind hier als read_only: true eingebunden. Das bedeutet, Jellyfin darf die Dateien lesen, aber nicht verändern. Das ist für einen persönlichen Medienserver sinnvoller und sicherer.

### Schritt 7: Jellyfin-Container starten

Nun können Sie den erstellten Container mit Docker Compose im Hintergrund starten:

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

Prüfen Sie danach, ob der Container läuft:

```bash
Sudo docker compose ps
```

[![Bild: Anzeige nach Docker compose](https://www.ionos.de/digitalguide/fileadmin/_processed_/f/4/csm_jellyfin-docker-compose_555ea97a3a.webp "Anzeige nach Docker compose")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/jellyfin-docker-compose.jpg) Die Terminalausgabe bestätigt Ihnen, dass der Jellyfin-Install erfolgreich war und der Container mit Jellyfin läuft. ### Schritt 8: Jellyfin im Browser aufrufen

Rufen Sie nun im Browser die Adresse Ihres Servers mit dem Standard-Jellyfin-Port auf:

```none
http://SERVER-IP:8096
```

Nun startet der Einrichtungsassistent im Browser.

Hinweis Wenn Sie einen IONOS-Server mieten, müssen Sie im Cloud-Panel zuvor die [Firewall](https://www.ionos.de/digitalguide/server/sicherheit/was-ist-eine-firewall/) so konfigurieren, dass [TCP](https://www.ionos.de/digitalguide/server/knowhow/tcp-vorgestellt/)-Verbindungen über Port 8096 erlaubt werden.

### Schritt 9: Ersteinrichtung im Jellyfin-Assistenten

Im Browser führt Sie Jellyfin durch die **Grundkonfiguration**. Legen Sie zunächst die Sprache fest und erstellen Sie dann ein Administratorkonto mit sicherem Passwort. Anschließend richten Sie Ihre Bibliotheken ein. Wählen Sie zum Beispiel „Filme“, „Serien“, „Musik“ oder „Fotos“ und geben Sie jeweils die Verzeichnisse an, die im Container eingebunden sind, also in unserem Beispiel `/media/filme` oder `/media/serien`. Danach lädt Jellyfin Metadaten, Cover und weitere Informationen, sofern Ihr Server Internetzugang hat.

[![Bild: Screenshot von Jellyfin im Browser](https://www.ionos.de/digitalguide/fileadmin/_processed_/8/2/csm_jellyfin-server-einrichtung_b654101b56.webp "Screenshot von Jellyfin im Browser")](https://www.ionos.de/digitalguide/fileadmin/DigitalGuide/Screenshots_2026/jellyfin-server-einrichtung.jpg) Wenn Sie Jellyfin im Browser aufrufen, führt Sie der Assistent durch die Einrichtung. ### Schritt 10: Medien sauber strukturieren

Damit Jellyfin Ihre Dateien korrekt erkennt, sollten die Medien ordentlich benannt und sortiert sein. Für Filme ist ein eigenes Verzeichnis pro Titel hilfreich, für Serien eine Unterteilung nach Staffel. Musik profitiert vor allem von sauber gepflegten Tags. Je sauberer die Ordnerstruktur, desto weniger Handarbeit brauchen Sie später bei Metadaten und Zuordnung. Das ist kein harter technischer Zwang, aber macht in der Praxis einen merkbaren Unterschied.

Beachten Sie folgende **Sicherheitshinweise für Ihren Jellyfin-Server**:

- **HTTPS verwenden**: Wenn Sie Jellyfin über das Internet erreichbar machen, sollten Sie den Zugriff unbedingt über HTTPS absichern. Am einfachsten gelingt dies über einen Reverse Proxy mit einem kostenlosen TLS-Zertifikat.
- **Direkten Internetzugriff vermeiden**: Öffnen Sie den Jellyfin-Port möglichst nicht direkt im Router. Stattdessen empfiehlt sich der Zugriff über einen Reverse Proxy oder ein [VPN](https://www.ionos.de/digitalguide/server/knowhow/was-ist-ein-vpn-virtual-private-network/).
- **Starke Passwörter verwenden**: Legen Sie für das Administratorkonto ein [sicheres Passwort](https://www.ionos.de/digitalguide/server/sicherheit/sensible-daten-durch-ein-sicheres-passwort-schuetzen/) fest und erstellen Sie für weitere User separate Benutzerkonten.
- **System regelmäßig aktualisieren**: Halten Sie sowohl Ihr Ubuntu-System als auch Docker und das Jellyfin-Image durch regelmäßige Updates auf dem neuesten Stand.
- **Medienverzeichnisse schreibgeschützt einbinden**: Wenn Sie Jellyfin in Docker betreiben, empfiehlt es sich, die Medienordner nur lesend (`read_only`) einzubinden, um versehentliche Änderungen an Ihren Dateien zu vermeiden.

## Jellyfin mit einer Domain verbinden

Für den Zugriff über eine Domain wie `jellyfin.ihredomain.de` brauchen Sie drei Dinge:

- [Domain](https://www.ionos.de/digitalguide/domains/domaintipps/was-ist-eine-domain/) oder Subdomain
- [DNS](https://www.ionos.de/digitalguide/server/knowhow/domain-name-system/)-Eintrag, der auf die öffentliche IP Ihres Servers zeigt
- Reverse Proxy mit HTTPS, wobei Jellyfin besonders Caddy empfiehlt

### Schritt 1: DNS-Eintrag für die Subdomain setzen

Legen Sie bei Ihrem Domain-Anbieter einen [A-Record](https://www.ionos.de/digitalguide/hosting/hosting-technik/a-record/) an, zum Beispiel:

```none
jellyfin.ihredomain.de -> IHRE-ÖFFENTLICHE-IP
```

Wenn IPv6 genutzt wird, setzen Sie zusätzlich einen AAAA-Record. Für automatisches HTTPS mit Caddy muss der DNS-Eintrag bereits korrekt auf Ihren Server zeigen.

Hinweis Damit Ihre Jellyfin-Instanz später über HTTPS erreichbar ist, müssen auf dem Server beziehungsweise in der Firewall die Ports **80 (HTTP)** und **443 (HTTPS)** erreichbar sein. Diese Ports benötigt der Reverse Proxy, um Webanfragen entgegenzunehmen und TLS-Zertifikate auszustellen.

### Schritt 2: Caddy installieren

Jellyfin empfiehlt Caddy wegen der einfachen HTTPS-Einrichtung. Installieren Sie Caddy auf Ubuntu mit dem offiziellen Paketweg und somit folgenden Terminalbefehlen:

```bash
sudo apt install -y debian-keyring debian-archive-keyring apt-transport-https curl
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/gpg.key' | sudo gpg --dearmor -o /usr/share/keyrings/caddy-stable-archive-keyring.gpg
curl -1sLf 'https://dl.cloudsmith.io/public/caddy/stable/debian.deb.txt' | sudo tee /etc/apt/sources.list.d/caddy-stable.list
sudo chmod o+r /usr/share/keyrings/caddy-stable-archive-keyring.gpg
sudo chmod o+r /etc/apt/sources.list.d/caddy-stable.list
sudo apt update
sudo apt install caddy -y
```

Nach der Installation startet Caddy automatisch als Systemdienst.

### Schritt 3: Caddy konfigurieren

Bearbeiten Sie in einem nächsten Schritt die Caddy-Konfiguration. Wir nutzen erneut nano, aber jeder andere Texteditor funktioniert ebenfalls:

```bash
sudo nano /etc/caddy/Caddyfile
```

Fügen Sie Folgendes ein:

```none
jellyfin.ihredomain.de {
reverse_proxy 127.0.0.1:8096
}
```

Speichern Sie die Datei und prüfen Sie die Konfiguration:

```bash
sudo caddy validate --config /etc/caddy/Caddyfile
```

Wenn alles passt, laden Sie Caddy mit folgendem Befehl neu:

```bash
sudo systemctl reload caddy
```

### Schritt 4: Jellyfin nur noch lokal an Caddy binden

Wenn die Domain funktioniert, sollten Sie die Compose-Datei anpassen, sodass Jellyfin **nicht mehr öffentlich auf Port 8096 lauscht**. Öffnen Sie dazu erneut `~/jellyfin/docker-compose.yml` und ersetzen Sie den Port-Eintrag:

```yaml
ports:
    - "127.0.0.1:8096:8096/tcp"
    - "7359:7359/udp"
```

Danach starten Sie den Container neu:

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

Jetzt ist die Weboberfläche nur noch lokal gebunden, während Caddy die sichere öffentliche Verbindung übernimmt. Abschließend sollten Sie in den Jellyfin-Netzwerkeinstellungen den Proxy als **Known Proxy** eintragen. Dadurch kann Jellyfin korrekt mit den vom Proxy gesetzten Headern umgehen. Die Einstellung finden Sie in der Weboberfläche unter „Dashboard“ → „Networking“ → „Known Proxies“.


This is a markdown version of: [https://www.ionos.de/digitalguide/server/konfiguration/jellyfin-server/](https://www.ionos.de/digitalguide/server/konfiguration/jellyfin-server/) for AI/LLM consumption.