Gsyleric/GPU-AMD-Proxmox-LXC
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
2 Commits 1 Branch 0 Tags
main
Go to file
Clone
Open with VS Code Open with VSCodium Open with Intellij IDEA
Download ZIP Download TAR.GZ Download BUNDLE
Ssyleric 4bfc79ddf1 Update README.md
2025-11-29 14:44:48 +01:00
README.md
Update README.md
2025-11-29 14:44:48 +01:00

README.md

GPU AMD (VAAPI / ROCm) sur Proxmox VE pour LXC

Contexte & périmètre

Ce document résume la configuration du GPU AMD Radeon RX 6700 XT sur le serveur Proxmox VE et son exposition à plusieurs conteneurs LXC :

  • Ollama LXC (CT 21211434) – IA / LLM avec ROCm + Vulkan
  • Plex LXC (CT 20232400) – transcodage vidéo matériel via VAAPI
  • Jellyfin LXC (CT 20308096) – transcodage vidéo matériel via VAAPI
  • ComfyUI LXC (CT 21608188) – VAAPI fonctionnel (ROCm/PyTorch pour Stable Diff non couvert ici)

⚠️ Important

  • Ce README couvre l’exposition du GPU et les tests VAAPI/ROCm à l’intérieur des conteneurs.
  • La configuration applicative détaillée (UI Plex/Jellyfin/ComfyUI, modèles Ollama, workflows ComfyUI, etc.) n’est pas décrite ici.
  • Pour ComfyUI, seule la partie VAAPI est validée. La stack ROCm + PyTorch pour Stable Diff sera documentée séparément.

1. Prérequis côté Proxmox VE

1.1 Hôte Proxmox

  • Proxmox VE 8.x avec noyau :
uname -a
Linux pve 6.8.12-16-pve ...
  • GPU AMD visible :
lspci -nnk | grep -A2 'VGA compatible controller'
# ... AMD Radeon RX 6700 XT ...
# Kernel driver in use: amdgpu
  • Périphériques GPU sur l’hôte :
ls -l /dev/kfd /dev/dri
crw-rw---- 1 root render 234, 0 ... /dev/kfd
total 0
drwxr-xr-x 2 root root         80 ... by-path
crw-rw---- 1 root video  226,   0 ... card0
crw-rw---- 1 root render 226, 128 ... renderD128

1.2 Groupes importants sur l’hôte

grep -w 'video\|render' /etc/group
video:x:44:
render:x:993:

Ces GIDs sont réutilisés dans les configs LXC pour mapper correctement les droits sur les devices.

2. Règles générales LXC

Pour tous les conteneurs utilisant le GPU :

  1. **Ne pas utiliser pct restart**Toujours faire :

    pct stop <CTID>
pct start <CTID>

  2. LXC en mode unprivileged (unprivileged: 1) quand c’est supporté par le template (c’est le cas ici pour Ollama & ComfyUI).

  3. Exposition du GPU via devX: dans la conf LXC, en réutilisant les GID de l’hôte :

    • /dev/dri/renderD128 → GID 44 (groupe video)
    • /dev/kfd → GID 993 (groupe render sur l’hôte / kvm ou équivalent dans le LXC)

3. Ollama LXC – ROCm + Vulkan (CT 21211434)

3.1 Configuration LXC (/etc/pve/lxc/21211434.conf)

# ROCm / AMD GPU pour Ollama
arch: amd64
cmode: shell
cores: 8
memory: 32768
swap: 0
hostname: ollama-lxc
ostype: ubuntu
unprivileged: 1
nameserver: 192.168.1.3
searchdomain: z-server.me
net0: name=eth0,bridge=vmbr0,gw=192.168.1.1,hwaddr=BC:24:11:3D:C3:0A,ip=192.168.1.212/24,ip6=auto,type=veth
rootfs: vm-docker:vm-21211434-disk-0,size=200G
startup: order=15
tags: community-script;linux;lxc;marechal;remote;server;ssh;webserver

# GPU
dev0: /dev/kfd,gid=993,uid=0
dev1: /dev/dri/renderD128,gid=44

💡 Ici, on n’utilise pas de lxc.mount.entry pour /dev/dri, uniquement les lignes dev0/dev1.

3.2 Installation ROCm (dans le LXC)

Ollama LXC est basé sur Ubuntu 24.04, avec ROCm 6.2.4 :

# Dans le CT 21211434
rocminfo | grep -i gfx | head
# Name: gfx1030
# amdgcn-amd-amdhsa--gfx1030

Variables globales pour le GPU :

cat <<'EOF' >> /etc/environment
HSA_OVERRIDE_GFX_VERSION=10.3.0
ROCR_VISIBLE_DEVICES=0
EOF

Puis installation d’Ollama via le script officiel :

curl -fsSL https://ollama.com/install.sh | sh

3.3 Activation de Vulkan et ROCm pour Ollama

Override systemd :

mkdir -p /etc/systemd/system/ollama.service.d

cat <<'EOF' >/etc/systemd/system/ollama.service.d/override.conf
[Service]
Environment="OLLAMA_VULKAN=1"
Environment="HSA_OVERRIDE_GFX_VERSION=10.3.0"
Environment="ROCR_VISIBLE_DEVICES=0"
EOF

systemctl daemon-reload
systemctl restart ollama

3.4 Vérifications

  • GPU détecté par ROCm :
rocminfo | grep -i gfx | head
# gfx1030 ...
  • Journal Ollama, détection ROCm :
journalctl -u ollama -n 40 --no-pager | grep -E 'inference compute|ROCm0'
# inference compute id=0 library=ROCm compute=gfx1030 name=ROCm0 description="AMD Radeon RX 6700 XT" ...

Ollama utilise alors le GPU via ROCm/Vulkan.

4. Plex LXC – VAAPI (CT 20232400)

4.1 Configuration LXC (/etc/pve/lxc/20232400.conf)

# Plex LXC – GPU AMD pour VAAPI
arch: amd64
cmode: shell
cores: 12
memory: 4096
swap: 2048
hostname: plex
ostype: ubuntu
unprivileged: 1
nameserver: 192.168.1.3
searchdomain: z-server.me
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
rootfs: vm-docker:vm-20232400-disk-0,size=300G
startup: order=4
tags: community-script;linux;lxc;marechal;media;server;share;ssh;webserver

# GPU VAAPI
dev0: /dev/dri/renderD128,gid=44
lxc.cgroup2.devices.allow: c 226:* rwm
lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir

4.2 Groupes dans le conteneur

grep -w 'video\|render' /etc/group
# video:x:44:plex
# render:x:118:plex

Vérifier que l’utilisateur plex est bien dans video et render.

4.3 Paquets VAAPI + test FFmpeg

apt update
apt install -y vainfo mesa-va-drivers ffmpeg
export LIBVA_DRIVER_NAME=radeonsi

vainfo | egrep 'Driver version|VAProfile'
# Driver version: Mesa Gallium ... for AMD Radeon RX 6700 XT ...
# VAProfileH264* / HEVC* / VP9* / AV1* ...

Test d’encodage matériel :

ffmpeg -v verbose \
  -init_hw_device vaapi=va:/dev/dri/renderD128 \
  -filter_hw_device va \
  -f lavfi -i testsrc2=size=1920x1080:rate=30 \
  -t 5 \
  -vf 'format=nv12,hwupload' \
  -c:v h264_vaapi \
  -f null -

Si le test passe, VAAPI est fonctionnel pour Plex (à activer ensuite dans l’UI Plex).

5. Jellyfin LXC – VAAPI (CT 20308096)

5.1 Configuration LXC (/etc/pve/lxc/20308096.conf)

# Jellyfin LXC – GPU AMD pour VAAPI
arch: amd64
cmode: shell
cores: 12
memory: 6144
swap: 2048
hostname: jellyfin
ostype: ubuntu
unprivileged: 1
nameserver: 192.168.1.3
searchdomain: z-server.me
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
rootfs: vm-docker:vm-20308096-disk-0,size=100G
startup: order=5
tags: community-script;linux;lxc;marechal;media;server;share;ssh;webserver

# GPU VAAPI
lxc.cgroup2.devices.allow: c 226:* rwm
lxc.mount.entry: /dev/dri dev/dri none bind,optional,create=dir

(Ici on n’utilise que /dev/dri pour VAAPI, pas /dev/kfd.)

5.2 Groupes dans le conteneur

grep -w 'video\|render' /etc/group
# video:x:44:jellyfin
# render:x:104:jellyfin

5.3 Paquets VAAPI + test FFmpeg

Même principe que Plex :

apt update
apt install -y vainfo mesa-va-drivers ffmpeg
export LIBVA_DRIVER_NAME=radeonsi

vainfo | egrep 'Driver version|VAProfile'
ffmpeg -v verbose \
  -init_hw_device vaapi=va:/dev/dri/renderD128 \
  -filter_hw_device va \
  -f lavfi -i testsrc2=size=1920x1080:rate=30 \
  -t 5 \
  -vf 'format=nv12,hwupload' \
  -c:v h264_vaapi \
  -f null -

Une fois validé, on active VAAPI dans l’UI Jellyfin (section Lecture / Transcodage).

6. ComfyUI LXC – VAAPI (CT 21608188)

6.1 Configuration LXC (/etc/pve/lxc/21608188.conf)

# ComfyUI LXC – GPU AMD (VAAPI)
arch: amd64
cmode: shell
cores: 4
memory: 32768
swap: 512
hostname: comfyui
ostype: debian
unprivileged: 1
nameserver: 192.168.1.3
searchdomain: z-server.me
net0: name=eth0,bridge=vmbr0,gw=192.168.1.1,hwaddr=BC:24:11:40:40:37,ip=192.168.1.216/24,type=veth
rootfs: vm-docker:vm-21608188-disk-0,size=100G
startup: order=15
tags: ai;community-script

# GPU
dev0: /dev/kfd,gid=993,uid=0
dev1: /dev/dri/renderD128,gid=44

On réplique ici le même principe que pour Ollama (ROCm possible plus tard), mais on valide surtout VAAPI.

6.2 Groupes & devices dans le LXC

ls -l /dev/kfd /dev/dri/renderD128
# /dev/dri/renderD128 → root video
# /dev/kfd          → root kvm (ou groupe équivalent)

grep -w 'video\|render' /etc/group
# video:x:44:root
# render:x:992:root

6.3 Paquets VAAPI + test FFmpeg

apt update
apt install -y vainfo mesa-va-drivers mesa-vulkan-drivers ffmpeg
export LIBVA_DRIVER_NAME=radeonsi

vainfo --display drm --device /dev/dri/renderD128 \
  | egrep 'Driver version|VAProfile'
# Driver version: Mesa Gallium driver 25.0.7-2 for AMD Radeon RX 6700 XT ...

Test encode :

ffmpeg -v verbose \
  -init_hw_device vaapi=va:/dev/dri/renderD128 \
  -filter_hw_device va \
  -f lavfi -i testsrc2=size=1920x1080:rate=30 \
  -t 5 \
  -vf 'format=nv12,hwupload' \
  -c:v h264_vaapi \
  -f null -

Si ce test passe, l’accélération VAAPI fonctionne et ComfyUI peut en tirer parti pour certaines opérations vidéo (selon les nodes utilisés).

7. Récapitulatif rapide

CT Service OS GPU exposé Usage principal Test de validation
21211434 Ollama Ubuntu /dev/kfd + renderD128 LLM via ROCm/Vulkan rocminfo, journalctl -u ollama
20232400 Plex Ubuntu /dev/dri (VAAPI) Transcodage vidéo vainfo + ffmpeg h264_vaapi
20308096 Jellyfin Ubuntu /dev/dri (VAAPI) Transcodage vidéo vainfo + ffmpeg h264_vaapi
21608188 ComfyUI Debian /dev/kfd + renderD128 IA / vidéo (VAAPI ok) vainfo + ffmpeg h264_vaapi

Ce README sert de référence unique pour l’exposition du GPU AMD RX 6700 XT aux conteneurs LXC sur Proxmox VE. Toute nouvelle LXC GPU (autre service) pourra se baser sur ces modèles de configuration.

Reference in New Issue View Git Blame Copy Permalink
Description
No description provided
Readme 66 KiB