Post

Jellyfin

Posté
Preview Image
Par Olivier 8 min lire

Avec la montée en puissance du streaming de contenu multimédia, de plus en plus de personnes recherchent des moyens de créer leur propre serveur média personnel pour gérer leur collection de films, de séries TV et de musique. Jellyfin est une solution open source populaire qui vous permet de faire exactement cela.

Jellyfin : Le logiciel libre Emby Media Server Fork est annoncé après qu’Emby soit devenu propriétaire.

Préambule

Ici, je considère les points suivants comme étant présent :

  • Proxmox PVE version 8 (minimum)
  • VM Debian 12
  • GPU Nvidia

Prérequis

Source: Jellyfin

La machine virtuelle utilisée pour cette stack dispose de 8 vCPUs et de 8 Go de RAM. Pensez à ajuster les ressources en conséquence en fonction des ressources de votre machine.

Si vous souhaitez bénéficier de l’accélération matérielle GPU sous Proxmox VE avec un GPU Nvidia c’est cet article qu’il faut lire.

Fichiers requis

Pensez à renseigner les vraies valeurs des variables comportant des ‘…’.

../_vm/common.yml

[Fichier]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

version: "3.0"

#
# updated: 2023-09-07
# stack:   x-common
#

services:

  x-common:

    extends:
      file: ./host.yml
      service: x-host

    init: true

    sysctls:
      net.core.somaxconn: 1024
      net.ipv4.tcp_syncookies: 0

../_vm/vm.yml

[Fichier]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

version: "3.0"

#
# updated: 2023-12-20
# stack:   x-vm
#

services:

  x-vm:

    logging:
      driver: loki
      options:
        loki-url: "http://${MASTER_HOST}:${VM_PORT_LOKI}/loki/api/v1/push"
        loki-retries: "8"
        loki-max-backoff: 800ms
        loki-timeout: 1s
        loki-batch-wait: 60s
        loki-batch-size: "400"
        no-file: "false"
        keep-file: "true"
        max-size: "32m"
        max-file: "8"

    #read_only: true

    restart: unless-stopped
    stop_grace_period: 5s
    stdin_open: true
    tty: true

    user: ${VM_USER}:${VM_GROUP}

    privileged: false

    security_opt:
      - no-new-privileges=true

    ipc: "private"

    cap_drop:
      - ALL

    cap_add:
      - KILL

    healthcheck:
      interval: 60s
      timeout: 10s
      retries: 5
      start_period: 60s

    environment:
      TZ: "Europe/Paris"
      PUID: 1000
      PGID: 1000
      DOCKER_HOST: "tcp://${VM_HOST}:${VM_PORT_DOCKERPROXY}"

    labels:
      com.centurylinklabs.watchtower.enable: true
      logging: "promtail"
      com.vm.versionning: "${VM_VERSIONNING}"
      com.stack.owner: "Olivier Le Bris"
      com.stack.owner.email: "tech@zogg.fr"
      com.stack.owner.url: "https://zogg.fr"
      com.stack.name: "common"
      com.stack.service.name: "common"
      traefik.docker.network: traefik

    ulimits:
      nproc: 65535
      nofile:
        soft: 20000
        hard: 40000

    deploy:
      resources:
        limits:
          cpus: "1.0"
          memory: 64M
          pids: 64

    tmpfs:
      - /tmp:rw,size=64M
      - /run:rw,exec,size=16M,mode=01777
      - /var/log:rw,size=64M,mode=01777
      - /var/cache:rw,size=64M,mode=01777

    volumes:
      - /etc/timezone:/etc/timezone:ro
      # - /etc/localtime:/etc/localtime:ro
      - /opt/docker/ssl:/ssl:ro
      - /proc/cgroups:/cgroup:rw
      #- /var/run/docker.sock:/var/run/docker.sock:rw

../_vm/host.yml

[Fichier]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

version: "3.0"

#
# updated: 2023-12-29
# stack:   host
#

services:

  x-host:

    extends:
      file: ./vm.yml
      service: x-vm

    dns:
      - 1.1.1.1
      - 8.8.8.8
      - 1.0.0.1
      - 8.8.4.4

    extra_hosts:
      - "vm.${VM_DOMAIN}:${VM_IP}"

docker-compose.yml

Pour cet article, j’ai utilisé l’accélération GPU NVidia.

[Fichier]

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119

version: "3.0"

#
# updated: 2024-01-07
# stack:   jellyfin
#

#
# Test NVIDIA usage
#   sudo docker exec -it jellyfin nvidia-smi
#

networks:
  jellyfin:
    name: jellyfin
    driver: bridge
    enable_ipv6: false
  dockerproxy:
    external: true

volumes:
  nas-videos:
    driver_opts:
      type: "cifs"
      o: username=${SAMBA_USERNAME},password=${SAMBA_PASSWORD},uid=911,gid=911,vers=3.1.1,rw
      device: "//xxx.xxx.xxx.xxx/video"

x-hwaccel: &x-hwaccel
  devices:
    - /dev/nvidia-modeset:/dev/nvidia-modeset
    - /dev/nvidia-caps:/dev/nvidia-caps
    - /dev/nvidia-uvm:/dev/nvidia-uvm
    - /dev/nvidia-uvm-tools:/dev/nvidia-uvm-tools
    - /dev/nvidiactl:/dev/nvidiactl
    - /dev/nvidia0:/dev/nvidia0
  environment:
    NVIDIA_VISIBLE_DEVICES: "all"
    NVIDIA_DRIVER_CAPABILITIES: "all"
  deploy:
    resources:
      reservations:
        devices:
          - driver: nvidia
            count: 1
            capabilities: [gpu,video,compute]
  runtime: nvidia
  group_add:
    - '109' # render
    - '44'  # video

services:

  jellyfin:
    extends:
      file: ../_common/host.yml
      service: x-host
    <<: *x-hwaccel
    user: 0:0
    cap_add:
      - DAC_OVERRIDE
      - SETUID
      - SETGID
      - CHOWN
      - SYS_ADMIN
      - AUDIT_CONTROL
      - AUDIT_READ
      - AUDIT_WRITE
      - FOWNER
      - NET_ADMIN
      - MKNOD
    security_opt:
      - "seccomp:unconfined"
      - "apparmor:unconfined"
    container_name: jellyfin
    hostname: jellyfin
    image: lscr.io/linuxserver/jellyfin:latest
    restart: "no"
    ports:
      - "${VM_PORT_JELLYFIN}:8096"  # HTTP
      - "8920:8920"                 # HTTPS
      - "7359:7359/udp"             # auto-discovery
      - "1900:1900/udp"             # auto-discovery
    expose:
      - "8096"
      - "8920"
      - "7359"
      - "1900"
    networks:
      - jellyfin
      - dockerproxy
    healthcheck:
      test: curl --fail http://0.0.0.0:8096/ || exit 1
    environment:
      PUID: 911
      PGID: 911
      JELLYFIN_PublishedServerUrl: "${VM_IP}"
    labels:
      com.stack.name: "jellyfin"
      com.stack.service.name: "jellyfin"
    tmpfs:
      - /tmp:rw,noexec,nosuid,size=4G
      - /config/log:rw,uid=911,gid=911,size=1G
      - /config/data/transcodes:rw,uid=911,gid=911,size=4G
    deploy:
      resources:
        limits:
          cpus: "8.0"
          memory: 6G
          pids: 8192
    volumes:
      - ./conf/jellyfin:/config:rw
      - ./conf/scripts:/scripts:ro
      - nas-videos:/data/movies:rw
      - nas-videos:/data/tvshows:rw
      - nas-videos:/data/musicals:rw
      - nas-videos:/data/musics:rw
    sysctls:
      net.core.somaxconn: 8192
      net.ipv4.tcp_syncookies: 0

Vous pouvez spécifiez d’autres partages pour les bibliothèques tvshows/musicals/musics.

L’utilisateur utilisé pour les partages Samba a le couple uid/gid 911:911. Pensez à l’ajuster selon vos besoins.

Précisions

Il est possible d’utiliser Jellyfin sans accélération matérielle mais celà nécessite un CPU très puissant.

Dans cet article, j’utlise des volumes de stockages Samba déportés permettant de découpler la partie logicielle de la partie stockage des données.

Rien ne vous empêche de les ajouter afin de former un ensemble complet et indépendant.

L’accélération matérielle GPU est plus que conseillée :

Source: Jellyfin

Variables d’environnement

Les variables suivantes sont à renseigner soit dans un .env situé dans le même répertoire que le docker-compose.yml, soit dans un fichier d’environnement:

  • SAMBA_USERNAME : le nom d’utilisateur de votre partage Samba
  • SAMBA_PASSWORD : le mot de passe du partage
  • VM_IP : l’adresse IP complète de la VM
1
2

    env_file:
     - ./conf/jellyfin/env/jellyfin.env

Utilisation

Après avoir créé le conteneur Jellyfin, vous pouvez accéder à son interface Web en ouvrant un navigateur et en saisissant l’adresse suivante :

1

http://votreadresseip:8096

Remplacez votreadresseip par l’adresse IP de votre serveur.

La première fois que vous accédez à l’interface Web, Jellyfin vous guidera à travers le processus de configuration, y compris la création d’un compte administrateur et la configuration de votre bibliothèque multimédia. Suivez les instructions à l’écran pour terminer la configuration.

Tips

Il éxiste un patch, sous Linux, pour supprime la restriction sur le nombre maximum de sessions simultanées d’encodage vidéo NVENC imposée par Nvidia aux GPU grand public :

NVENC and NvFBC patches for Nvidia drivers

Son utilisation est relativement simple :

1
2

git clone https://github.com/keylase/nvidia-patch
sudo bash ./patch.sh

Et pour annuler les modifications apportées:

1

sudo bash ./patch.sh -r

On peut difficilement faire plus simple !

TV Samsung

Si vous disposez d’une TV de marque Samsung, il est possible d’installer une application cliente native.

Il faut disposer d’un compte Samsung.

Source: Jellyfin for Tizen

Bien que cela dépasse le cadre de cet article, voici les étapes à suivre:

  1. Installer Git
  2. Installer Node.js
  3. Installer Samsung Tizen Studio
  4. Lancer Samsung Packages Manager puis installer
  5. Main SDK : Tizen SDK Tools
  6. Extension SDK : TV Extensions, Samsung Certificate Extension, TV Extension Tools
  7. Utiliser Certificate Manager afin de créer un certificat pour l’installation sur le TV
  8. Cloner Jellyfin Web
  9. Cloner Jellyfin Tizen
  10. Constuire Jellyfin Web
    1
2
3

    cd jellyfin-web
npm ci --no-audit
npm run build:production
  11. Constuire Jellyfin Tizen
    1
2
3

    cd jellyfin-tizen
$env:JELLYFIN_WEB_DIR='../jellyfin-web/dist'
npm ci --no-audit
  12. Constuire le paquet Tizen (wgt)
    1
2

    tizen build-web -e ".*" -e gulpfile.js -e README.md -e "node_modules/*" -e "package*.json" -e "yarn.lock"
tizen package -t wgt -o . -- .buildResult
  13. Activer le mode développeur sur la TV
  14. Authoriser l’installation d’applications sur la TV depuis Device Manager from Tizen Studio
  15. Installer l’application
    1

    tizen install -n Jellyfin.wgt -t NAME_OF_TV_IN_DEVICE_MANAGER

Sources:

Applications

Conclusion

L’installation de Jellyfin sous Docker est un moyen efficace de mettre en place un serveur média personnel. En utilisant des conteneurs Docker, vous pouvez gérer facilement les dépendances de l’application et bénéficier de la flexibilité et de la portabilité. Avec Jellyfin, vous pouvez organiser et diffuser votre contenu multimédia en toute simplicité, offrant ainsi une expérience de streaming de haute qualité à partir de votre propre serveur. Profitez de votre bibliothèque multimédia avec Jellyfin et Docker !

Changelog

2024-01-07

  • Mise à jour des composes hérités
  • Mise à jour du docker-compose.yml
  • Mise à jour de la partie accélération Nvidia
  • Mise à jour de la partie samba (version Samba pour les partages)
  • Ajout du patch NVENC & NvFBC pour Nvidia
homelab, multimedia
docker compose amd64 stack jellyfin samsung
Cet article est sous licence CC BY 4.0 par l'auteur.

© 2022- Olivier. Certains droits réservés.

Propulsé par τζ avec le thème Χ