Déployer Jellyfin avec Docker en 2026 : tutoriel complet (transcodage matériel, HTTPS, reverse proxy)

Vous voulez votre propre Netflix maison, sans abonnement, sans pubs et sans limite sur ce que vous diffusez ? Jellyfin est le serveur média libre par excellence : entièrement open source, sans compte cloud obligatoire, sans fonctionnalités payantes verrouillées. Il indexe vos films, séries, musiques et photos, récupère automatiquement les jaquettes et les métadonnées, et les diffuse vers tous vos appareils — TV, téléphone, navigateur, console.

Le point technique qui fait toute la différence sur un serveur média, c’est le transcodage matériel : la capacité à convertir un flux vidéo à la volée en utilisant le GPU plutôt que le processeur. Sans lui, un seul flux 4K peut saturer un VPS. Dans ce tutoriel, on déploie Jellyfin via Docker, avec le transcodage matériel Intel QuickSync ou NVIDIA, derrière un reverse proxy Caddy qui gère le HTTPS et Let’s Encrypt automatiquement.

Prérequis

Un serveur ou un mini-PC sous Ubuntu 24.04 (ou Debian 12). Pour le transcodage matériel, un iGPU Intel (QuickSync) ou un GPU NVIDIA est fortement recommandé : c’est pour cela que beaucoup hébergent Jellyfin sur une machine maison plutôt qu’un VPS, qui n’expose généralement pas de GPU. Un VPS chez Hetzner ou OVHcloud convient pour du transcodage logiciel léger ou du direct play.
Beaucoup d’espace disque pour votre médiathèque.
Docker et Docker Compose installés (commande à l’étape 1).
Un nom de domaine dont vous contrôlez le DNS. On utilisera media.exemple.fr.
Les ports 80 et 443 ouverts pour Let’s Encrypt et le trafic HTTPS.

Étape 1 : Installer Docker et Docker Compose

Si Docker n’est pas présent, installez-le depuis le dépôt officiel :

sudo apt update
sudo apt install -y ca-certificates curl
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
echo "deb [arch=$(dpkg --print-architecture) signed-by=/etc/apt/keyrings/docker.asc] https://download.docker.com/linux/ubuntu $(. /etc/os-release && echo "$VERSION_CODENAME") stable" | sudo tee /etc/apt/sources.list.d/docker.list > /dev/null
sudo apt update
sudo apt install -y docker-ce docker-ce-cli containerd.io docker-buildx-plugin docker-compose-plugin
sudo usermod -aG docker $USER

Déconnectez-vous/reconnectez-vous, puis vérifiez :

docker --version && docker compose version

Étape 2 : Configurer le DNS

Chez votre fournisseur DNS, créez un enregistrement A (et AAAA si IPv6) pointant vers l’IP publique de votre serveur :

Type	Nom	Valeur
A	`media.exemple.fr`	`203.0.113.10`

Vérifiez la propagation :

dig +short media.exemple.fr

Étape 3 : Préparer l’arborescence des médias

Jellyfin attend des dossiers bien rangés. Créez votre structure :

mkdir -p ~/jellyfin/{config,cache}
mkdir -p /srv/media/{films,series,musique}

Organisez vos fichiers selon les conventions de nommage Jellyfin pour que les métadonnées soient trouvées automatiquement, par exemple : Films/Inception (2010)/Inception (2010).mkv et Series/Le Bureau/Saison 01/Le Bureau S01E01.mkv.

Étape 4 : Créer le réseau Docker partagé

Pour que Caddy joigne le conteneur Jellyfin par son nom :

docker network create web

Si vous suivez déjà notre tutoriel reverse proxy Caddy, ce réseau existe peut-être déjà : ignorez l’erreur éventuelle.

Étape 5 : Le docker-compose.yml de Jellyfin

Créez le fichier de composition :

cd ~/jellyfin
nano docker-compose.yml

services:
  jellyfin:
    image: jellyfin/jellyfin:latest
    container_name: jellyfin
    restart: unless-stopped
    environment:
      TZ: "Europe/Paris"
      # URL publique (utile pour les liens et la découverte)
      JELLYFIN_PublishedServerUrl: "https://media.exemple.fr"
    volumes:
      - ./config:/config
      - ./cache:/cache
      - /srv/media:/media:ro
    # Transcodage matériel Intel QuickSync / VAAPI : on expose le périphérique GPU
    devices:
      - /dev/dri:/dev/dri
    networks:
      - web

networks:
  web:
    external: true

Notez l’absence de section ports: : Jellyfin n’est pas exposé directement, tout passe par Caddy via le réseau interne web. Le dossier média est monté en lecture seule (:ro) : Jellyfin n’a aucune raison de modifier vos fichiers.

Variante pour un GPU NVIDIA

Si vous avez une carte NVIDIA et le NVIDIA Container Toolkit installé, remplacez le bloc devices: par une demande de ressources GPU :

    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

Pour Intel, l’utilisateur du conteneur doit appartenir au groupe render du système hôte afin d’accéder à /dev/dri. Vérifiez l’identifiant du groupe avec getent group render et, si besoin, ajoutez group_add: ["NUMERO_DU_GROUPE_RENDER"] au service.

Étape 6 : Le Caddyfile pour le HTTPS automatique

Si vous avez déjà un Caddy, ajoutez le bloc de site. Sinon, créez un dossier Caddy :

mkdir -p ~/caddy && cd ~/caddy
nano Caddyfile

{
    email admin@exemple.fr
}

media.exemple.fr {
    encode gzip zstd

    header {
        Strict-Transport-Security "max-age=31536000; includeSubDomains; preload"
        X-Content-Type-Options "nosniff"
        Referrer-Policy "strict-origin-when-cross-origin"
        -Server
    }

    # Jellyfin utilise WebSockets pour le contrôle distant et la synchro
    reverse_proxy jellyfin:8096
}

Le port interne de Jellyfin est 8096. Caddy gère nativement la mise à niveau WebSocket, rien à configurer de plus.

Puis le docker-compose.yml de Caddy :

nano docker-compose.yml

services:
  caddy:
    image: caddy:2-alpine
    container_name: caddy
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
      - "443:443/udp"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile:ro
      - caddy_data:/data
      - caddy_config:/config
    networks:
      - web

volumes:
  caddy_data:
  caddy_config:

networks:
  web:
    external: true

Étape 7 : Lancer les services

cd ~/jellyfin && docker compose up -d
cd ~/caddy && docker compose up -d

Suivez les logs de Caddy pour voir l’émission du certificat :

docker compose logs -f caddy

Quand vous voyez certificate obtained successfully pour media.exemple.fr, visitez https://media.exemple.fr. L’assistant de configuration de Jellyfin s’affiche.

Étape 8 : Configuration initiale et bibliothèques

Suivez l’assistant :

Choisissez la langue, créez le compte administrateur avec un mot de passe solide.
Ajoutez vos bibliothèques : « Films » pointant vers /media/films, « Séries » vers /media/series, etc. Jellyfin lance alors un scan et récupère les jaquettes et synopsis.
Laissez les paramètres d’accès distant par défaut : c’est Caddy qui gère l’exposition publique, pas Jellyfin lui-même.

Installez ensuite les applications Jellyfin sur vos appareils (Android, iOS, Android TV, navigateur web, et clients tiers comme Findroid ou Streamyfin) et pointez-les vers https://media.exemple.fr.

Étape 9 : Activer et vérifier le transcodage matériel

Le transcodage matériel décharge le CPU et permet plusieurs flux simultanés. Dans Tableau de bord → Lecture → Transcodage :

Sélectionnez l’accélération matérielle : Intel QuickSync (QSV) ou VAAPI pour un iGPU Intel, NVIDIA NVENC pour une carte NVIDIA.
Cochez les codecs à décoder/encoder en matériel (H.264, HEVC, et idéalement le décodage HEVC 10 bits).
Enregistrez.

Pour vérifier que ça marche, lancez une lecture qui force le transcodage (par exemple en limitant la qualité dans le client), puis sur l’hôte :

# Pour Intel, surveille l'utilisation du GPU pendant la lecture
sudo intel_gpu_top

Vous devez voir l’activité du moteur « Video » grimper. Dans le tableau de bord Jellyfin, l’onglet « Activité » indique aussi si la session est en transcodage matériel ou logiciel.

Étape 10 : Vérification finale

# Le conteneur tourne
docker ps --filter "name=jellyfin"

# Le HTTP redirige vers HTTPS (code 308)
curl -sI http://media.exemple.fr | head -1

# Le HTTPS répond
curl -sI https://media.exemple.fr | head -1

# Le périphérique GPU est bien présent dans le conteneur (Intel)
docker exec jellyfin ls -l /dev/dri

Sécurité, durcissement et sauvegarde

Pare-feu UFW strict. N’ouvrez que 80, 443 et SSH. Le port 8096 de Jellyfin ne doit jamais être exposé directement.
Comptes utilisateurs séparés. Créez un compte par personne plutôt que de partager l’admin ; limitez les bibliothèques accessibles par utilisateur.
Médias en lecture seule. Le montage :ro empêche tout conteneur compromis d’altérer vos fichiers.
Mises à jour. docker compose pull && docker compose up -d régulièrement. Jellyfin est stable mais les correctifs de sécurité comptent.
Sauvegarde du config. Vos bibliothèques, comptes, métadonnées et progressions de visionnage vivent dans ~/jellyfin/config. Sauvegardez ce dossier (les fichiers médias, eux, restent votre source à part). Notre guide sauvegarde automatique avec Restic et Backblaze montre comment automatiser une copie hors-site chiffrée.

Pour durcir le serveur exposé, voir installer et sécuriser un VPS Ubuntu.

Pièges courants et dépannage

Le transcodage reste en logiciel (CPU à 100 %). Le GPU n’est pas accessible au conteneur. Vérifiez que /dev/dri est bien monté (Intel) et que l’utilisateur appartient au groupe render. Pour NVIDIA, vérifiez l’installation du NVIDIA Container Toolkit avec docker run --rm --gpus all nvidia/cuda:12.4.0-base-ubuntu24.04 nvidia-smi.
« Lecture impossible » sur certains formats. Le client ne supporte pas le codec et le serveur ne transcode pas. Activez le transcodage matériel (étape 9) ou utilisez un client plus complet.
Jaquettes manquantes. Mauvais nommage des fichiers. Respectez la convention Titre (Année) et relancez un scan de bibliothèque.
Buffering en accès distant. La bande passante montante de votre connexion limite le flux. Réduisez le débit maximum autorisé dans le client, ou transcodez vers une qualité plus basse.

FAQ

Jellyfin est-il vraiment 100 % gratuit, contrairement à Plex ?

Oui. Jellyfin est entièrement open source et n’a aucune fonctionnalité payante : pas de « Pass » à acheter pour débloquer le transcodage matériel, les applications mobiles ou la synchronisation. Tout ce qui est dans le serveur est utilisable librement. C’est sa principale différence philosophique avec Plex et Emby.

Ai-je obligatoirement besoin d’un GPU ?

Non, mais c’est fortement recommandé. Sans GPU, le transcodage se fait sur le CPU : un seul flux 4K HEVC peut saturer un serveur modeste. Si tous vos clients lisent les fichiers en « direct play » (sans conversion), le CPU suffit. Mais dès qu’un appareil ne supporte pas un codec ou que vous limitez la qualité à distance, le transcodage matériel devient déterminant.

Quelle différence entre Intel QuickSync et NVIDIA NVENC ?

Les deux font de l’excellent transcodage matériel. QuickSync (iGPU Intel) est imbattable en rapport performance/consommation et idéal sur un mini-PC silencieux. NVENC (NVIDIA) gère davantage de flux simultanés et convient aux serveurs plus puissants. Pour un homelab familial, un iGPU Intel récent est souvent le meilleur compromis.

Puis-je accéder à Jellyfin en dehors de chez moi ?

Oui, c’est tout l’intérêt du reverse proxy HTTPS de ce tutoriel : votre médiathèque est accessible depuis n’importe où via https://media.exemple.fr. Pour plus de discrétion, vous pouvez aussi la garder privée et y accéder via un VPN comme WireGuard, sans rien exposer publiquement.

Jellyfin, Plex ou Emby : lequel choisir ?

Jellyfin pour le 100 % libre et gratuit, Plex pour l’écosystème le plus poli et la découverte de contenu, Emby pour un entre-deux commercial. Si la souveraineté et l’absence de coût priment, Jellyfin gagne. Notre comparatif Jellyfin vs Plex vs Emby détaille chaque cas d’usage.

Comment gérer plusieurs utilisateurs avec des accès différents ?

Dans Tableau de bord → Utilisateurs, créez un compte par personne. Pour chacun, vous définissez les bibliothèques accessibles, les autorisations de téléchargement et le contrôle parental (restriction par classification d’âge). C’est plus propre et plus sûr que de partager un compte unique.