---
title: Jellyfin
description: Installer Jellyfin, un serveur multimédia libre et open source, pour diffuser vos films et séries depuis n'importe où sans abonnement payant.
---


:ellipsis{left=0px width=40rem top=10rem blur=140px zIndex=60}

![Jellyfin](/img/serveex/jellyfin.png)

[Jellyfin](https://jellyfin.org) est une alternative libre et open source à Plex et Emby. Contrairement à Plex, il n'a pas d'offre payante, pas de télémétrie, et n'exige pas de compte en ligne pour utiliser ou administrer votre serveur : tout tourne en local et reste chez vous.

Il couvre les mêmes bases : une médiathèque avec métadonnées et jaquettes, le transcodage (accélération matérielle comprise), et des applications pour TV, Android, iOS, Windows et macOS.

Comme toujours, nous utiliserons l'[image linuxserver.io](https://docs.linuxserver.io/images/docker-jellyfin).

::note{to="/serveex/core/wireguard"}

Contrairement à Plex, Jellyfin n'a pas de relais cloud : pour accéder à votre serveur en dehors de votre réseau local, vous devez l'exposer vous-même (voir plus bas), ou utiliser un VPN comme **Wireguard**.
::

## Installer Jellyfin

::file-tree
---
tree:
  /:
    - srv:
      - docker:
        - jellyfin:
          - compose.yaml
          - .env
          - config/
    - media:
      - tvseries/
      - movies/
      - library/
---
::

::steps{level="3"}
### Créer les dossiers média

Créez les dossiers `movies`, `tvseries` et `library` dans `/media` :

```bash [Terminal]
mkdir -p /media/movies /media/library /media/tvseries
```

### Déployer la stack

Ouvrez Dockge, cliquez sur `compose`, nommez la stack `jellyfin`, et ajoutez la configuration suivante :

```yaml [compose.yaml]
---
services:
  jellyfin:
    image: lscr.io/linuxserver/jellyfin:latest
    container_name: jellyfin
    environment:
      - PUID=${PUID}
      - PGID=${GUID}
      - TZ=Europe/Paris
    volumes:
      - /srv/docker/jellyfin/config:/config
      - /media:/media
    restart: unless-stopped
    devices:
      - /dev/dri:/dev/dri
    ports:
      - 8096:8096
```

::tip{icon=""}
✨ Ajoutez le label Watchtower pour automatiser les mises à jour :

```yaml [compose.yaml]
---
services:
  jellyfin:
    #...
    labels:
      - com.centurylinklabs.watchtower.enable=true
```
::

### Renseigner vos variables d'environnement

Trouvez vos PUID et GUID en lançant :

```bash [Terminal]
id utilisateur
```

Remplissez votre fichier `.env` avec les valeurs récupérées, par exemple :

```properties [.env]
PUID=1000
GUID=1000
```

Déployez la stack. L'interface locale est disponible sur `http://ipdevotreserveur:8096`.

::note{to="https://docs.linuxserver.io/images/docker-jellyfin/#hardware-acceleration"}

Le périphérique `/dev/dri` n'est nécessaire que pour le transcodage accéléré matériellement sur GPU Intel/AMD. Retirez-le si votre serveur n'en a pas, ou adaptez-le pour un GPU NVIDIA en suivant la **documentation de linuxserver.io**.
::

### Terminé !
::

## Configurer Jellyfin
À la première visite, Jellyfin vous guide dans un assistant de configuration :

- Choisissez une langue d'affichage et créez votre compte administrateur.
- Ajoutez une médiathèque, en pointant `/media/movies` pour les films et `/media/tvseries` pour les séries.

Et voilà ! Ajoutez vos médias dans `/media/movies` et `/media/tvseries` sur votre serveur. Voir plus bas pour commencer à regarder, à la maison ou à distance.

::note{to="/general/networking/samba"}

Si vos médias sont stockés sur un disque réseau (un NAS ou un disque dur externe accessible par le réseau), reportez-vous au **guide de montage Samba** pour que Jellyfin puisse y accéder.
::

## Transcodage matériel

Jellyfin réencode la vidéo à la volée dès qu'un client ne peut pas lire un fichier tel quel : la résolution de l'écran de l'appareil est inférieure à celle de la source, sa connexion réseau est trop lente pour le débit du fichier, ou il ne prend pas en charge le codec, le format HDR ou le type de sous-titres du fichier. C'est ce qu'on appelle le **transcodage**. Lorsque le transcodage est logiciel et éxecuté par le CPU, cela prend énormément de ressources et cela peut saturer un serveur modeste avec seulement un ou deux flux simultanés. Le **transcodage matériel** délègue ce travail au GPU intégré à votre processeur (Intel QuickSync, sur la plupart du matériel de homelab), qui s'en occupe bien plus vite et laisse le CPU libre pour tout le reste.

Le **tone mapping** est une fonction liée mais distincte : convertir une vidéo HDR (qui a besoin d'un écran HDR compatible pour rendre correctement) en SDR pour qu'elle s'affiche correctement sur un écran, une TV ou un client qui ne gère pas le HDR, au lieu de paraître délavée ou trop sombre.

::note{to="https://docs.linuxserver.io/images/docker-jellyfin/#hardware-acceleration"}
Cela ne concerne que les GPU intégrés Intel (et certains AMD) passés au conteneur avec `/dev/dri`, déjà présent dans le `compose.yaml` de ce tutoriel. Les GPU NVIDIA demandent une configuration entièrement différente, traitée dans la **documentation de linuxserver.io**. Si votre serveur n'a pas de GPU compatible, le transcodage fonctionne quand même, entièrement sur le CPU.
::

::steps{level="3"}
### Ajouter le mod OpenCL

Le tone mapping a spécifiquement besoin d'un runtime OpenCL Intel, que cette image n'embarque pas par défaut. Ajoutez le mod dédié à votre `compose.yaml` :

```yaml [compose.yaml]
services:
  jellyfin:
    environment:
      - DOCKER_MODS=linuxserver/mods:jellyfin-opencl-intel
```

::note
N'utilisez pas le mod générique `universal-package-install` avec `intel-opencl-icd` pour ça : il installe un runtime plus ancien issu des dépôts d'Ubuntu, connu pour causer des bugs de tone mapping. Le mod dédié en fournit un plus récent et prévu pour.
::

Redéployez la stack pour que le mod prenne effet.

### Activer l'accélération matérielle

Dans Jellyfin, allez dans _Tableau de bord > Lecture_ et réglez **Accélération matérielle** sur **Intel QuickSync (QSV)** (ou **VA-API**, si QSV n'est pas disponible pour votre génération de processeur).

Décochez ensuite tout codec que votre GPU ne sait pas décoder matériellement. La [page d'accélération matérielle Intel](https://jellyfin.org/docs/general/administration/hardware-acceleration/intel/) liste précisément les codecs pris en charge par chaque génération de processeur.

### Activer le tone mapping

Plus bas sur la même page, activez le **Tone mapping**. Il ne prend effet qu'une fois le mod OpenCL ci-dessus installé et la stack redéployée ; l'activer sans cette étape préalable fera échouer les transcodages HDR au lieu de simplement ignorer le tone mapping.

### Terminé !
::

## Regarder à la maison

Tant que vous êtes connecté à votre réseau domestique (Wi-Fi ou Ethernet, sur le même réseau local que votre serveur), aucune exposition ni VPN n'est nécessaire. Utilisez [Moonfin](https://github.com/Moonfin-Client/Moonfin-Core) partout où il est disponible (téléphones, tablettes, Android TV/Google TV, ordinateur, web) plutôt que l'application Jellyfin officielle : il a la même apparence et le même fonctionnement partout, et peut synchroniser vos réglages entre appareils via son propre plugin serveur. Connectez-vous sur `http://iplandevotreserveur:8096`.

Samsung Tizen et LG webOS ont droit à une [application Moonfin](https://github.com/Moonfin-Client/Smart-TV) séparée et dédiée (même nom, base de code différente), et l'Apple TV est mieux servie par [Neptune](https://apps.apple.com/us/app/neptune-media-player/id6756797773), un client tvOS dédié avec décodage natif HEVC/AV1/VP9 et passthrough Atmos complet. Là où aucun de ces clients n'existe (Fire TV, Roku, Kodi), voir le tableau ci-dessous :

| Plateforme | Application recommandée |
|----------|-----------------|
| Téléphone / Tablette (Android, iOS) | [Moonfin](https://github.com/Moonfin-Client/Moonfin-Core) (Play Store / App Store) |
| Android TV / Google TV | [Moonfin](https://github.com/Moonfin-Client/Moonfin-Core) (Play Store ou APK) |
| Apple TV | [Neptune](https://apps.apple.com/us/app/neptune-media-player/id6756797773) (App Store) |
| Samsung Tizen / LG webOS | [Moonfin](https://github.com/Moonfin-Client/Smart-TV) (sideloadé) ; les applications officielles existent mais sont en retard |
| Fire TV | Application Jellyfin officielle (Amazon Appstore) |
| Roku | Application Jellyfin officielle |
| Kodi | [Jellyfin pour Kodi](https://jellyfin.org/docs/general/clients/kodi/) (synchronise votre médiathèque dans Kodi), ou [JellyCon](https://github.com/jellyfin/jellycon) pour les boîtiers plus légers en streaming seul |

::caution

__Si ça ne marche pas :__ vérifiez les règles de votre pare-feu.
::

## Regarder en dehors de chez soi

::warning
Jellyfin ne sera pas exposé sur internet dans ce site, contrairement à la plupart des autres applications. Ses applications natives (téléphone, TV, Chromecast...) dialoguent directement avec son API plutôt qu'avec un navigateur, si bien qu'une couche de forward-auth comme [TinyAuth](/serveex/security/tinyauth) ou [Authentik](/serveex/advanced/authentik) ne peut pas se placer devant sans casser la connexion et la lecture sur ces clients, et Jellyfin lui-même n'a ni 2FA ni OIDC intégré pour compenser. Plutôt que de l'exposer, nous l'atteindrons donc via le [VPN WireGuard](/serveex/core/wireguard) déjà mis en place plus tôt dans ce guide.
::

Plutôt que de faire passer tout le trafic d'un appareil par le VPN, ou même tout le sous-réseau VPN `10.8.0.0/24`, nous utiliserons un **split tunnel** plus serré : chaque appareil distant ne route par le tunnel que le trafic destiné à l'adresse VPN de votre serveur. Tout le reste (navigation, autres applications) reste sur la connexion normale de l'appareil, et le VPN ne sert jamais qu'à joindre cette seule machine.

::note{to="/serveex/core/wireguard#client-server-setup"}

Ceci suppose que votre serveur Jellyfin fait déjà tourner son propre client WireGuard, le reliant à votre VPN comme décrit dans **Client Server Setup**. Notez l'adresse VPN que wg-easy lui a attribuée (par exemple `10.8.0.2`) ; c'est l'adresse que viseront tous les appareils ci-dessous.
::

::caution{to="#restreindre-un-pair-tiers-à-jellyfin-uniquement"}
Ce split tunnel est une convention côté client, pas une frontière de sécurité imposée par le serveur : `AllowedIPs` est un réglage de routage, et wg-easy n'ajoute aucune règle de pare-feu pour l'appuyer par défaut. Quiconque a accès à un appareil (ou à son fichier `.conf`) pourrait remettre `AllowedIPs` sur quelque chose de plus large et atteindre tout ce que votre serveur WireGuard sait router, y compris les autres pairs connectés. Si un pair est l'un de vos propres appareils, c'est en général un risque acceptable. Si vous confiez un pair à un tiers (un ami, un membre de la famille) qui ne doit jamais atteindre que Jellyfin, voir **Restreindre un pair tiers à Jellyfin uniquement** plus bas pour une façon de l'imposer réellement côté serveur.
::

::steps{level="3"}
### Créer un client dans wg-easy pour chaque appareil

En suivant [Récupérer les fichiers de configuration](/serveex/core/wireguard#retrieve-configuration-files), créez un client par appareil (téléphone, ordinateur, TV/boîtier multimédia) et téléchargez son fichier de configuration.

### Restreindre le tunnel au seul serveur

Ouvrez chaque fichier `.conf` téléchargé et remplacez sa ligne `AllowedIPs` pour qu'elle ne couvre que l'adresse VPN de votre serveur Jellyfin, en `/32` (une seule IP, pas une plage) :

```properties [wg0.conf]
AllowedIPs = 10.8.0.2/32
```

::note

Remplacez `10.8.0.2` par l'adresse que votre serveur a réellement obtenue. Laisser le `10.8.0.0/24` par défaut ici ferait passer par le tunnel le trafic de tous les pairs VPN, pas seulement de votre serveur.
::

### Importer la configuration sur chaque appareil

- **Téléphone :** installez l'application WireGuard, puis importez le fichier `.conf` modifié (ou scannez un QR code généré à partir de celui-ci).
- **Ordinateur :** installez le [client WireGuard](https://www.wireguard.com/install/) et importez le fichier.
- **TV :** si elle tourne sous Android TV ou Google TV, installez WireGuard depuis le Play Store. Copiez le fichier `.conf` sur une clé USB, branchez-la sur la TV ou le boîtier, puis utilisez l'option **Ajouter depuis un fichier** de l'application pour parcourir la clé et l'importer. La plupart des autres systèmes de TV (Tizen, webOS...) ne peuvent pas installer de client VPN directement, passez donc plutôt par un appareil qui a déjà le tunnel actif (un boîtier Android TV, ou du cast depuis un téléphone ou un ordinateur connecté).

::warning
Un fichier `.conf` est un identifiant, pas un simple fichier de réglages : quiconque le possède peut se connecter à votre VPN en tant que cet appareil. Une fois importé, supprimez-le de la clé USB (et de partout où vous l'avez copié, comme les dossiers Téléchargements), et ne le partagez jamais avec qui que ce soit.
::

### Terminé !
::

### Restreindre un pair tiers à Jellyfin uniquement

[wg-easy](/serveex/core/wireguard) (v15.3+) sait l'imposer lui-même, avec une vraie règle de pare-feu à l'intérieur de son propre conteneur plutôt qu'un réglage côté client. C'est la bonne approche quand le pair appartient à quelqu'un d'autre, et non à l'un de vos appareils.

::steps{level="4"}
#### Activer le pare-feu par client

Dans le panneau d'administration de [wg-easy](/serveex/core/wireguard), allez dans les réglages de l'interface et activez **Per-Client Firewall**. Il est marqué expérimental, mais fonctionne en générant une chaîne `iptables` dédiée dans le conteneur wg-easy.

#### Restreindre la destination autorisée du pair

Modifiez le client du tiers et réglez ses **Firewall Allowed IPs** sur l'adresse VPN de votre serveur Jellyfin, par exemple `10.8.0.2`, ou plus restrictif encore, `10.8.0.2:8096/tcp` pour restreindre aussi le port et le protocole.

::note

Laisser ce champ vide retombe sur les `AllowedIPs` du client, ce qui n'est pas restrictif : il doit être renseigné explicitement pour ce pair. Cela coupe aussi l'accès internet classique de ce pair à travers le tunnel, puisque seul le trafic vers Jellyfin est désormais autorisé, ce qui est bien l'effet recherché pour un pair invité.
::

#### Vérifier que la règle est appliquée

```bash [Terminal]
docker exec wg-easy iptables -L WG_CLIENTS -n -v
```

Vous devriez voir une ligne `ACCEPT` pour l'IP de ce pair pointant uniquement vers votre serveur Jellyfin, suivie d'un `DROP` fourre-tout.

#### Terminé !
::

Une fois connecté, ouvrez l'application Jellyfin ou `http://10.8.0.2:8096` (l'adresse VPN de votre serveur) depuis cet appareil. Seul le trafic vers cette adresse passe par le VPN, le reste de la connexion de l'appareil n'est pas touché.
