diff --git a/README.md b/README.md index 3641f5d..f2b46d1 100644 --- a/README.md +++ b/README.md @@ -1 +1,378 @@ -# GPU-AMD-VAAPI-For-Plex-Jellyfin---LXC-Proxmox \ No newline at end of file +# GPU AMD (VAAPI) pour Plex & Jellyfin en LXC Proxmox + +Ce document décrit la configuration de la RX 6700 XT pour **Plex** (CT `20232400`) et **Jellyfin** (CT `20308096`) sous **Proxmox VE 8**, en conteneurs LXC **unprivileged**, avec transcodage matériel **VAAPI**. + +--- + +## 1. Contexte + +- **Host Proxmox** + + - Kernel : `6.8.12-16-pve` + - GPU : **AMD Radeon RX 6700 XT (Navi 22)**, driver `amdgpu` + - Devices exposés sur le host : + ```bash + ls -l /dev/dri + # card0 -> GPU AMD + # renderD128 -> node de rendu (VAAPI, ROCm, etc.) + ``` +- **Conteneurs concernés** + + - Plex : CT **`20232400`**, hostname `plex` + - Jellyfin : CT **`20308096`**, hostname `jellyfin` + - Les deux sont des LXC **unprivileged** créés via les **community-scripts** (Helper-Scripts). + +Objectif : + +> Donner accès au GPU via **/dev/dri** dans les deux LXC et activer le transcodage matériel VAAPI dans Plex & Jellyfin. + +--- + +## 2. Configuration LXC côté Proxmox + +### 2.1 Plex (CT 20232400) – `/etc/pve/lxc/20232400.conf` + +Configuration **finale** (partie importante) : + +```ini +# Plex LXC (Helper-Scripts) +arch: amd64 +cmode: shell +cores: 12 +features: keyctl=1,nesting=1 +hostname: plex +memory: 4096 +mp0: /mnt/pve/movie,mp=/movie +mp1: /mnt/pve/music,mp=/music +mp2: /mnt/pve/anime,mp=/anime +mp3: /mnt/pve/serie,mp=/serie +nameserver: 192.168.1.3 +net0: name=eth0,bridge=vmbr0,gw=192.168.1.1,hwaddr=BC:24:11:2C:BF:A3,ip=192.168.1.202/24,type=veth +onboot: 1 +ostype: ubuntu +rootfs: vm-docker:vm-20232400-disk-0,size=300G +searchdomain: z-server.me +startup: order=4 +swap: 2048 +tags: community-script;linux;lxc;marechal;media;server;share;ssh;webserver + +# 🔹 Accès au GPU via /dev/dri +lxc.cgroup2.devices.allow: c 226:* rwm +lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir +``` + +> ⚠️ Important : +> **AUCUNE** ligne `dev0:` ou `dev1:` ne doit être présente. +> Le **bind-mount complet de `/dev/dri`** via `lxc.mount.entry` + la règle `c 226:*` suffisent. + +Après modification : + +```bash +pct stop 20232400 +pct start 20232400 +``` + +--- + +### 2.2 Jellyfin (CT 20308096) – `/etc/pve/lxc/20308096.conf` + +Configuration **finale** (partie importante) : + +```ini +# Jellyfin LXC (Helper-Scripts) +arch: amd64 +cmode: shell +cores: 12 +features: keyctl=1,nesting=1 +hostname: jellyfin +memory: 6144 +mp0: /mnt/pve/movie,mp=/movie +mp1: /mnt/pve/music,mp=/music +mp2: /mnt/pve/anime,mp=/anime +mp3: /mnt/pve/serie,mp=/serie +nameserver: 192.168.1.3 +net0: name=eth0,bridge=vmbr0,gw=192.168.1.1,hwaddr=BC:24:11:E7:9C:CC,ip=192.168.1.203/24,type=veth +onboot: 1 +ostype: ubuntu +rootfs: vm-docker:vm-20308096-disk-0,size=100G +searchdomain: z-server.me +startup: order=5 +swap: 2048 +tags: community-script;linux;lxc;marechal;media;server;share;ssh;webserver + +# 🔹 Accès au GPU via /dev/dri +lxc.cgroup2.devices.allow: c 226:* rwm +lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir +``` + +Redémarrer : + +```bash +pct stop 20308096 +pct start 20308096 +``` + +--- + +## 3. Vérifications dans les conteneurs + +### 3.1 Plex – devices GPU visibles dans le LXC + +Sur le **host** : + +```bash +pct stop 20232400 +pct start 20232400 +pct console 20232400 +# (Ctrl+a q pour quitter la console) +``` + +Dans le conteneur Plex : + +```bash +ls -l /dev/dri +``` + +On doit voir quelque chose comme : + +```text +crw-rw---- 1 root video 226, 0 ... card0 +crw-rw---- 1 root render 226, 128 ... renderD128 +``` + +### 3.2 Jellyfin – devices GPU visibles + +Sur le host : + +```bash +pct stop 20308096 +pct start 20308096 +pct console 20308096 +``` + +Dans le conteneur Jellyfin : + +```bash +ls -l /dev/dri +``` + +Sortie attendue similaire avec `card0` et `renderD128`. + +--- + +## 4. Groupes `video` / `render` pour Plex & Jellyfin + +Les applications doivent tourner avec un utilisateur membre des groupes `video` et `render`. + +### 4.1 Plex + +Dans le conteneur Plex : + +```bash +grep -w 'video\|render' /etc/group +``` + +Tu avais : + +```text +video:x:44:plex +render:x:118: +``` + +On ajoute donc `plex` dans `render` : + +```bash +usermod -aG video,render plex +id plex +``` + +Vérifier que la sortie contient bien `video` et `render`. + +Redémarrer Plex : + +```bash +systemctl restart plexmediaserver 2>/dev/null || systemctl restart plex 2>/dev/null +``` + +--- + +### 4.2 Jellyfin + +Dans le conteneur Jellyfin : + +```bash +grep -w 'video\|render' /etc/group +``` + +Tu avais : + +```text +video:x:44:jellyfin +render:x:104:jellyfin +``` + +Donc `jellyfin` est déjà dans les bons groupes. +Au besoin : + +```bash +usermod -aG video,render jellyfin +id jellyfin +systemctl restart jellyfin +``` + +--- + +## 5. Validation VAAPI avec `vainfo` + +Tu peux tester rapidement le support VAAPI dans un des conteneurs (Plex ou Jellyfin). + +Installation (exemple Plex, Ubuntu 22.04) : + +```bash +apt update +apt install -y vainfo mesa-va-drivers +vainfo +``` + +Exemple de sortie (résumé) : + +```text +libva info: VA-API version 1.14.0 +libva info: Trying to open /usr/lib/x86_64-linux-gnu/dri/radeonsi_drv_video.so +libva info: va_openDriver() returns 0 +vainfo: VA-API version: 1.14 (libva 2.12.0) +vainfo: Driver version: Mesa Gallium driver ... for AMD Radeon RX 6700 XT +... +VAProfileH264Main : VAEntrypointVLD +VAProfileH264Main : VAEntrypointEncSlice +VAProfileHEVCMain : VAEntrypointVLD +VAProfileHEVCMain10 : VAEntrypointVLD +VAProfileHEVCMain10 : VAEntrypointEncSlice +... +``` + +Les lignes `VAProfile...` / `VAEntrypointEncSlice` confirment que l’encodage matériel est disponible. + +--- + +## 6. Configuration dans Plex + +Dans l’interface web Plex : + +1. Aller dans :**Settings → Server → Transcoder** +2. Activer : + - ✅ **Use hardware acceleration when available** +3. Garder le mode **automatique / VAAPI** (Plex utilisera `/dev/dri`). + +Pour forcer un transcodage : + +- Lire un film 4K (ou au moins 1080p) +- Sur le client, réduire la qualité (ex. 720p 4 Mbps) pour obliger le transcodage. + +Optionnel : vérifier dans les stats de lecture Plex que le codec porte la mention “(hw)” ou que le transcode utilise VAAPI. + +--- + +## 7. Configuration dans Jellyfin + +Dans l’interface Jellyfin : + +1. Aller dans :**Dashboard → Playback → Transcoding** +2. Section **Hardware acceleration** : + - Choisir **VAAPI** + - Device : `/dev/dri/renderD128` (ou laisser Automatic si Jellyfin le détecte) +3. Cocher : + - Hardware decoding + - Hardware encoding (si proposé) +4. Sauvegarder. + +Pour tester : + +- Lire une vidéo 4K ou 1080p haute qualité. +- Baisser la résolution / le bitrate côté client pour forcer le transcodage. +- Vérifier dans **Dashboard → Active sessions** que le codec utilise VAAPI. + +--- + +## 8. Stress-test GPU 4K avec `ffmpeg` + +Pour mettre **la RX 6700 XT dans le rouge**, on peut utiliser un fichier 4K de test dans le LXC Plex (ou Jellyfin) et transcoder via VAAPI. + +### 8.1 Exemple de fichier 4K de test (dans Plex) + +Dans le conteneur Plex : + +```bash +cd /movie +mkdir -p test4k +cd test4k + +# Exemple : fichier 4K téléchargé manuellement (démo 4K, film de test, etc.) +# wget "https://.../mon_fichier_4k.mp4" -O 4k-test.mp4 +``` + +> Remplacer l’URL par un fichier 4K réel (film de test, démo 4K, etc.) +> L’important : résolution 3840x2160 et bitrate élevé pour bien charger le GPU. + +### 8.2 Transcodage 4K → H.264 via VAAPI + +Toujours dans Plex LXC, dans `/movie/test4k` : + +```bash +ffmpeg -hwaccel vaapi -vaapi_device /dev/dri/renderD128 \ + -i 4k-test.mp4 \ + -vf 'format=nv12,hwupload' \ + -c:v h264_vaapi -b:v 20M \ + -f null - +``` + +Explications : + +- `-hwaccel vaapi -vaapi_device /dev/dri/renderD128` : décodage matériel via VAAPI. +- `format=nv12,hwupload` : format adapté au pipeline VAAPI. +- `-c:v h264_vaapi` : encodage H.264 sur le GPU. +- `-f null -` : la sortie vidéo n’est pas écrite sur disque (pure charge GPU). + +Tu peux lancer **plusieurs ffmpeg en parallèle** (deux shells) pour encore plus de charge. + +--- + +## 9. Supervision de la charge GPU sur le host + +Sur le **host Proxmox**, pendant un transcodage (Plex, Jellyfin ou ffmpeg), tu peux surveiller la charge de la RX 6700 XT. + +Installation de `radeontop` (si pas déjà fait) : + +```bash +apt update +apt install -y radeontop +radeontop +``` + +Sinon, méthode texte simple (selon ce que le noyau expose) : + +```bash +watch -n1 "cat /sys/kernel/debug/dri/0/amdgpu_pm_info | egrep 'GPU load|GPU freq|Memory freq' || echo 'no debug info'" +``` + +Tu devrais voir la charge GPU augmenter dès que : + +- un transcodage Plex est en cours, +- un transcodage Jellyfin est en cours, +- ou un `ffmpeg` VAAPI tourne dans un LXC. + +--- + +## 10. Résumé rapide + +- Le **GPU AMD** est exposé dans les LXC via : + - `lxc.cgroup2.devices.allow: c 226:* rwm` + - `lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir` +- Aucun `dev0:` / `dev1:` dans les confs LXC : pas besoin, et ça casse `autodev`. +- Les utilisateurs `plex` et `jellyfin` sont dans les groupes : + - `video` + - `render` +- Plex & Jellyfin sont configurés en **VAAPI**. +- Les tests 4K + `ffmpeg` permettent de confirmer que la RX 6700 XT est bien utilisée. + +Ce README est la référence pour la configuration GPU/VAAPI de Plex & Jellyfin sur ce cluster Proxmox.