Update README.md

This commit is contained in:
Ssyleric
2025-11-21 15:47:08 +01:00
committed by GitHub
parent 2fe0719424
commit f85b5f48c6

379
README.md
View File

@@ -1 +1,378 @@
# GPU-AMD-VAAPI-For-Plex-Jellyfin---LXC-Proxmox
# 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 lencodage matériel est disponible.
---
## 6. Configuration dans Plex
Dans linterface 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 linterface 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 lURL par un fichier 4K réel (film de test, démo 4K, etc.)
> Limportant : 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 nest 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.