Comment con­fi­gu­rer un serveur Jellyfin ?

Un serveur Jellyfin personnel est une solution pratique si vous souhaitez héberger vous-même vos films, séries, musiques ou photos de manière cen­tra­li­sée. Au lieu de confier vos médias à un service de streaming tiers, vous gardez un contrôle étendu sur vos fichiers, les comptes uti­li­sa­teurs et les accès, sur tous vos appareils.

Qu’est-ce que Jellyfin ?

Jellyfin est un serveur mul­ti­mé­dia open source qui vous permet d’organiser et de ca­ta­lo­guer votre propre col­lec­tion de médias, puis de la diffuser en streaming vers dif­fé­rents terminaux via un na­vi­ga­teur Web ou une ap­pli­ca­tion. Le logiciel prend en charge les bi­blio­thèques clas­siques, comme les films, les séries, la musique et les photos. Il propose également une gestion des uti­li­sa­teurs, des mé­ta­don­nées, des jaquettes et de la reprise de lecture, ainsi que du streaming sur le réseau.

Comme Jellyfin est au­to­hé­bergé, le service fonc­tionne in­dé­pen­dam­ment de tout four­nis­seur externe. Internet n’est né­ces­saire que pour certaines fonctions, comme la ré­cu­pé­ra­tion des mé­ta­don­nées, les mises à jour, certains plugins ou l’accès externe. Pour l’accès sur le réseau do­mes­tique, Jellyfin utilise par défaut le protocole HTTP sur le port 8096, sans qu’il soit né­ces­saire d’exposer ce port di­rec­te­ment sur Internet. De plus, il est possible d’utiliser HTTPS. Pour l’accès externe, la do­cu­men­ta­tion of­fi­cielle re­com­mande de passer par un reverse proxy et des cer­ti­fi­cats de confiance.

Quelles sont les con­di­tions préa­lables re­com­man­dées pour un serveur Jellyfin ?

Avant d’installer Jellyfin, vous devez d’abord choisir le type de serveur le plus adapté. Pour un serveur Jellyfin, il ne s’agit pas seulement de savoir combien de fichiers vous souhaitez stocker, mais surtout de dé­ter­mi­ner si vos appareils peuvent lire di­rec­te­ment les fichiers mul­ti­mé­dias ou si le serveur doit les convertir pendant la lecture. Cette con­ver­sion s’appelle le trans­co­dage et elle est par­ti­cu­liè­re­ment gourmande en res­sources. La 4K, le tone mapping HDR vers SDR et plusieurs flux si­mul­ta­nés peuvent notamment sol­li­ci­ter fortement le pro­ces­seur (CPU) ou le pro­ces­seur graphique (GPU).

La do­cu­men­ta­tion de Jellyfin re­com­mande, pour des dé­ploie­ments moyens, au moins 8 Go de mémoire vive (RAM) de manière générale. Pour un serveur Linux sans interface graphique, 4 Go peuvent suffire. Jellyfin préconise aussi, pour l’ac­cé­lé­ra­tion ma­té­rielle sur les systèmes non Apple, un GPU Intel, car la con­fi­gu­ra­tion et la qualité des encodeurs sont avan­ta­geuses en pratique.

Dans ce qui suit, nous vous pré­sen­tons, à l’aide de quelques scénarios, quel serveur Jellyfin est le plus adapté à votre cas d’usage.

Par­ti­cu­liers et familles

Si vous utilisez Jellyfin prin­ci­pa­le­ment seul ou avec deux ou trois personnes, et que vos fichiers existent déjà dans des formats vidéo courants comme le MP4 avec H.264, un bon serveur privé virtuel (VPS) suffit souvent. Dans ce scénario, le serveur doit gé­né­ra­le­ment seulement dis­tri­buer les fichiers, au lieu de les convertir à chaque lecture. À titre de base pratique, vous pouvez prévoir par exemple 4 vCores, 4 Go de RAM et environ 120 Go de stockage NVMe, à adapter selon la taille de votre mé­dia­thèque. Si vous souhaitez un peu plus de marge pour les mé­ta­don­nées, des bi­blio­thèques plus vo­lu­mi­neuses et des con­ver­sions oc­ca­sion­nelles, 6 vCores, 8 Go de RAM et 240 Go de stockage NVMe cons­ti­tuent une option plus con­for­table.

L’avantage d’un VPS réside surtout dans son rapport qualité-prix. Vous disposez de suf­fi­sam­ment de puissance pour un serveur Jellyfin personnel, sans devoir investir im­mé­dia­te­ment dans du matériel dédié. Cette option est par­ti­cu­liè­re­ment adaptée lorsque vos terminaux lisent déjà na­ti­ve­ment les formats modernes et que le trans­co­dage n’est né­ces­saire que rarement.

Uti­li­sa­teurs avancés

Si vous avez besoin de plus de marge, parce que votre bi­blio­thèque grandit ra­pi­de­ment, que vous souhaitez créer plusieurs comptes uti­li­sa­teurs ou adapter plus librement les res­sources du serveur, les serveurs Cloud ou les Cloud Cubes sont des options per­ti­nentes. Les serveurs et Cubes à partir de 4 vCPU, 8 Go de RAM et 240 Go de stockage peuvent être utilisés. Vous disposez ainsi de nettement plus de latitude pour les analyses en parallèle, les mé­ta­don­nées, les bi­blio­thèques et les trans­co­dages oc­ca­sion­nels.

Le grand avantage de cette variante est sa flexi­bi­lité. Les serveurs Cloud peuvent être fa­ci­le­ment adaptés à l’évolution de vos besoins. C’est pratique si vous commencez petit, mais souhaitez plus tard ajouter plusieurs bi­blio­thèques, davantage d’uti­li­sa­teurs ou des services sup­plé­men­taires comme un reverse proxy, du mo­ni­to­ring ou une sau­ve­garde. Pour les uti­li­sa­teurs privés avancés, les petites équipes ou les adeptes de « homelab » (en­vi­ron­ne­ment in­for­ma­tique personnel pour l’au­to­hé­ber­ge­ment), c’est souvent la solution de milieu de gamme la plus con­for­table.

Uti­li­sa­teurs intensifs et amateurs de 4K

Les uti­li­sa­teurs qui possèdent beaucoup de contenus 4K, sou­hai­tent diffuser du contenu HDR vers des appareils plus anciens ou effectuer plusieurs trans­co­dages si­mul­ta­nés at­teig­nent ra­pi­de­ment les limites d’un petit VPS. Jellyfin souligne ex­pli­ci­te­ment que le tone mapping HDR vers SDR en mode logiciel peut être ex­trê­me­ment gourmand en CPU. Pour de tels scénarios, un serveur dédié ou un serveur bare metal constitue un meilleur choix, car vous y utilisez du matériel dédié et ne partagez ni puissance de calcul, ni RAM, ni stockage avec d’autres charges de travail.

Vous devriez ici prévoir un CPU moderne, 16 à 32 Go de RAM, un stockage SSD ou NVMe rapide et, surtout, un GPU adapté au trans­co­dage matériel. L’idéal est de disposer en plus d’un GPU Intel ou NVIDIA adapté au trans­co­dage matériel.

Re­com­man­da­tion de système d’ex­ploi­ta­tion : Debian ou Ubuntu ?

Les deux dis­tri­bu­tions de serveurs Linux con­vien­nent à Jellyfin, mais Ubuntu Server 24.04 LTS est, selon notre ex­pé­rience, souvent plus pratique pour les débutants. Docker documente of­fi­ciel­le­ment Ubuntu 24.04, et de nombreux tutoriels se réfèrent di­rec­te­ment à Ubuntu. Debian est également très stable, mais Ubuntu vous évite quelques pièges lors de la mise en place.

Comment installer Jellyfin avec Docker sur Ubuntu Server ?

Dans l’exemple suivant, nous montrons comment installer Jellyfin sur Ubuntu Server 24.04 LTS avec Docker Engine et le plugin Docker Compose. Cette variante est une bonne solution, en par­ti­cu­lier pour les débutants, car Docker isole pro­pre­ment l’ap­pli­ca­tion et simplifie les mises à jour ul­té­rieures.

Étape 1 : mettre à jour le serveur Ubuntu

Connectez-vous à votre serveur via SSH et commencez par mettre à jour les sources de paquets et les paquets installés :

sudo apt update
sudo apt upgrade -y

Vous pouvez ensuite re­dé­mar­rer le serveur si né­ces­saire (après un re­dé­mar­rage, une nouvelle connexion est requise) :

sudo reboot

Cette étape est im­por­tante pour commencer avec des paquets à jour, les cor­rec­tifs de sécurité récents et un système propre. En par­ti­cu­lier pour un serveur Ubuntu fraî­che­ment déployé, c’est la toute première action à effectuer.

Étape 2 : installer Docker sur Ubuntu 24.04

Dans l’étape suivante, vous devez installer Docker sous Ubuntu 24.04. Pour cela, Docker re­com­mande de con­fi­gu­rer le re­po­si­tory APT officiel. Commencez par supprimer les paquets plus anciens ou sus­cep­tibles d’entrer en conflit :

sudo apt remove docker.io docker-compose docker-compose-v2 docker-doc podman-docker containerd runc docker-ce-rootless-extras -y

Con­fi­gu­rez main­te­nant le re­po­si­tory Docker officiel :

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

Installez ensuite Docker Engine, Buildx et le plugin Compose avec la commande suivante dans le terminal :

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

Vérifiez ensuite si Docker est en cours d’exécution :

sudo systemctl status docker

Le statut doit ap­pa­raître comme active (running) :

Close

Il est ensuite judicieux de tester l’ins­tal­la­tion avec le conteneur de test officiel.

sudo docker run hello-world

La sortie devrait res­sem­bler à ceci :

Close

Étape 3 : utiliser Docker sans sudo

Par défaut, les commandes Docker doivent souvent être exécutées avec sudo. Si vous le souhaitez, vous pouvez ajouter votre uti­li­sa­teur au groupe docker :

sudo usermod -aG docker $USER
newgrp docker

Étape 4 : créer la structure de ré­per­toires pour Jellyfin

Après les pré­pa­ra­tifs, créez la structure de ré­per­toires du serveur Jellyfin afin de préparer l’ins­tal­la­tion. Pour que la con­fi­gu­ra­tion, le cache et les médias soient clai­re­ment séparés, créez des dossiers ap­pro­priés sur le système hôte. Nous utilisons la structure de dossiers suivante (mais vous pouvez organiser les dossiers autrement) :

mkdir -p ~/jellyfin/config
mkdir -p ~/jellyfin/cache
mkdir -p ~/medias/films
mkdir -p ~/medias/series
mkdir -p ~/medias/musique
mkdir -p ~/medias/photos

config con­tien­dra ul­té­rieu­re­ment la con­fi­gu­ra­tion du serveur, les uti­li­sa­teurs et la base de données. cache est destiné aux données tem­po­raires. Les vé­ri­tables fichiers mul­ti­mé­dias se trouvent dans les dossiers de bi­blio­thèque séparés.

Étape 5 : dé­ter­mi­ner l’UID et le GID de l’uti­li­sa­teur

Jellyfin peut s’exécuter dans le conteneur avec l’ID uti­li­sa­teur et l’ID de groupe de votre uti­li­sa­teur Linux. Cela facilite la gestion des droits sur les fichiers. Commencez donc par dé­ter­mi­ner ces deux valeurs avec :

id

Vous aurez bientôt besoin des nombres affichés dans le fichier Compose, il est donc re­com­mandé de les noter.

Étape 6 : créer le fichier Docker Compose pour Jellyfin

Passez dans le ré­per­toire de travail et créez un fichier nommé docker-compose.yml. Nous utilisons l’éditeur de texte nano pour la création, mais vous pouvez créer le fichier de n’importe quelle autre manière.

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

Insérez le contenu suivant dans le fichier que vous venez de créer :

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/VOTRE_UTILISATEUR/medias/films
                target: /medias/films
                read_only: true
            - type: bind
                source: /home/VOTRE_UTILISATEUR/medias/series
                target: /medias/series
                read_only: true
            - type: bind
                source: /home/VOTRE_UTILISATEUR/medias/musique
                target: /medias/musique
                read_only: true
            - type: bind
                source: /home/VOTRE_UTILISATEUR/medias/photos
                target: /medias/photos
                read_only: true
        environment:
            - JELLYFIN_PublishedServerUrl=http://VOTRE-IP-SERVEUR:8096
        restart: unless-stopped

Remplacez ensuite dans le fichier :

• la valeur 1000:1000 par votre véritable UID:GID, que vous avez notée à l’étape pré­cé­dente
• VOTRE_UTILISATEUR par votre nom d’uti­li­sa­teur Linux
• VOTRE-IP-SERVEUR par l’adresse IP de votre serveur

Étape 7 : démarrer le conteneur Jellyfin

Vous pouvez main­te­nant démarrer le conteneur créé avec Docker Compose en arrière-plan :

sudo docker compose up -d

Vérifiez ensuite si le conteneur est en cours d’exécution :

sudo docker compose ps

Close

Étape 8 : ouvrir Jellyfin dans le na­vi­ga­teur

Saisissez main­te­nant dans votre na­vi­ga­teur l’adresse de votre serveur avec le port Jellyfin par défaut :

http://VOTRE-IP-SERVEUR:8096

L’assistant de con­fi­gu­ra­tion démarre alors dans le na­vi­ga­teur.

Étape 9 : première con­fi­gu­ra­tion dans l’assistant Jellyfin

Dans le na­vi­ga­teur, Jellyfin vous guide à travers la con­fi­gu­ra­tion de base. Dé­fi­nis­sez d’abord la langue, puis créez un compte ad­mi­nis­tra­teur avec un mot de passe sécurisé. Con­fi­gu­rez ensuite vos bi­blio­thèques. Sé­lec­tion­nez par exemple « Films », « Séries », « Musique » ou « Photos », puis indiquez pour chacune les ré­per­toires montés dans le conteneur, dans notre exemple /medias/films ou /medias/series. Jellyfin té­lé­charge ensuite les mé­ta­don­nées, les jaquettes et d’autres in­for­ma­tions, à condition que votre serveur dispose d’un accès Internet.

Close

Étape 10 : struc­tu­rer pro­pre­ment vos médias

Pour que Jellyfin re­con­naisse cor­rec­te­ment vos fichiers, vos médias doivent être bien nommés et bien rangés. Pour les films, un ré­per­toire dédié par titre est utile ; pour les séries, une sub­di­vi­sion par saison est re­com­man­dée. La musique bénéficie surtout de mé­ta­don­nées soig­neu­se­ment ren­seig­nées. Plus votre ar­bo­res­cence est claire, moins vous aurez ensuite de cor­rec­tions manuelles à effectuer pour les mé­ta­don­nées et l’at­tri­bu­tion des contenus. Ce n’est pas une con­trainte technique stricte, mais cela fait une vraie dif­fé­rence en pratique.

Veuillez respecter les consignes de sécurité suivantes pour votre serveur Jellyfin :

• Utiliser HTTPS : si vous rendez Jellyfin ac­ces­sible via Internet, vous devez ab­so­lu­ment sécuriser l’accès avec HTTPS. Le plus simple est de passer par un reverse proxy avec un cer­ti­fi­cat TLS gratuit, par exemple via Let’s Encrypt ou l’ACME au­to­ma­tique de Caddy.
• Éviter l’accès direct depuis Internet : si possible, n’ouvrez pas di­rec­te­ment le port Jellyfin sur votre routeur. Il est pré­fé­rable de passer par un reverse proxy ou un VPN.
• Utiliser des mots de passe robustes : dé­fi­nis­sez un mot de passe sécurisé pour le compte ad­mi­nis­tra­teur et créez des comptes uti­li­sa­teurs séparés pour les autres personnes.
• Mettre ré­gu­liè­re­ment le système à jour : gardez votre système Ubuntu, Docker et l’image Jellyfin à jour grâce à des mises à jour ré­gu­lières.
• Monter les ré­per­toires médias en lecture seule : si vous exécutez Jellyfin dans Docker, il est re­com­mandé de monter les dossiers médias en lecture seule (read_only) afin d’éviter toute mo­di­fi­ca­tion ac­ci­den­telle de vos fichiers.

Comment connecter Jellyfin à un domaine ?

Pour accéder à Jellyfin via un domaine comme jellyfin.votredomaine.fr, vous avez besoin de trois éléments :

• Un domaine ou un sous-domaine
• Une entrée DNS qui pointe vers l’adresse IP publique de votre serveur
• Un reverse proxy avec HTTPS, Caddy étant une option simple grâce à sa gestion au­to­ma­tique des cer­ti­fi­cats

Étape 1 : créer l’entrée DNS pour le sous-domaine

Créez un en­re­gis­tre­ment A chez votre four­nis­seur de domaine, par exemple :

jellyfin.votredomaine.fr -> VOTRE-IP-PUBLIQUE

Si vous utilisez IPv6, dé­fi­nis­sez également un en­re­gis­tre­ment AAAA. Pour que le HTTPS au­to­ma­tique avec Caddy fonc­tionne, l’entrée DNS doit déjà pointer cor­rec­te­ment vers votre serveur.

Étape 2 : installer Caddy

Caddy est un choix courant pour Jellyfin en raison de sa con­fi­gu­ra­tion HTTPS simple et de sa gestion au­to­ma­tique des cer­ti­fi­cats. Installez Caddy sur Ubuntu via le dépôt officiel, en utilisant les commandes suivantes dans le terminal :

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

Après l’ins­tal­la­tion, Caddy démarre au­to­ma­ti­que­ment en tant que service système.

Étape 3 : con­fi­gu­rer Caddy

Modifiez ensuite la con­fi­gu­ra­tion de Caddy. Nous utilisons de nouveau nano, mais tout autre éditeur de texte fonc­tionne :

sudo nano /etc/caddy/Caddyfile

Insérez le contenu suivant :

jellyfin.votredomaine.fr {
    reverse_proxy 127.0.0.1:8096
}

En­re­gis­trez le fichier et vérifiez la con­fi­gu­ra­tion :

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

Si tout est correct, rechargez Caddy avec la commande suivante :

sudo systemctl reload caddy

Étape 4 : lier Jellyfin lo­ca­le­ment à Caddy uni­que­ment

Si le fonc­tion­ne­ment du domaine est correct, vous devez adapter le fichier Compose afin que Jellyfin n’écoute plus pu­bli­que­ment sur le port 8096. Pour cela, rouvrez ~/jellyfin/docker-compose.yml et remplacez l’entrée de port :

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

Ensuite, re­dé­mar­rez le conteneur :

sudo docker compose up -d

L’interface Web est main­te­nant uni­que­ment liée à l’en­vi­ron­ne­ment local, tandis que Caddy prend en charge la connexion publique sécurisée. Enfin, vous devez ajouter le proxy comme Known Proxy dans les pa­ra­mètres réseau de Jellyfin. Jellyfin pourra ainsi gérer cor­rec­te­ment les en-têtes définis par le proxy. Vous trouverez ce réglage dans l’interface Web sous « Dashboard > Net­wor­king > Known Proxies ».