Applications et Guides

Rendu à distance de Blender avec Flamenco

Lorsque le rendu de scènes lourdes dans Blender commence à prendre trop de temps à votre équipe, vous avez deux options : soit mettre à niveau l'ordinateur de chaque membre de l'équipe, soit sous-traiter le rendu à une ferme dédiée. De nombreuses entreprises proposent des solutions de rendu prêtes à l'emploi, mais si vous avez besoin d'un contrôle total sur l'infrastructure, ces solutions peuvent ne pas être l'option la plus fiable.

Une autre approche pourrait consister à créer une infrastructure hybride. Dans ce cas, le stockage des données et la gestion de la ferme de rendu sont conservés dans votre infrastructure existante. Le seul élément qui serait situé à l'extérieur serait les serveurs GPU loués sur lesquels le rendu serait effectué.

En général, l'infrastructure de la ferme de rendu pour Blender ressemble à ceci :

Ici, nous avons un nœud central Manager qui organise tous les processus. Il reçoit les tâches de rendu des utilisateurs via une adresse spécifique Blender Add-on et déplace tous les fichiers nécessaires vers Shared Storage. Ensuite, Manager distribue les tâches à Worker nodes. Ils reçoivent un travail contenant toutes les informations sur l'endroit où le travailleur peut trouver les fichiers à rendre et sur ce qu'il doit faire avec les résultats obtenus. Pour mettre en œuvre ce schéma, vous pouvez utiliser une application entièrement libre et gratuite appelée Flamenco. Dans ce guide, nous montrons comment préparer tous les nœuds, en particulier les nœuds Manager et Worker.

Le nœud Storage n'a pas d'exigences particulières. Il peut être utilisé avec n'importe quel système d'exploitation prenant en charge les protocoles SMB/CIFS ou NFS. La seule exigence est que le répertoire de stockage soit monté et accessible par le système d'exploitation. Dans votre infrastructure, il peut s'agir de n'importe quel dossier partagé accessible à tous les nœuds.

Chaque nœud a des adresses IP différentes et le serveur Wireguard VPN sera un point central qui les réunira en un seul réseau L2. Ce serveur, situé sur le périmètre externe, vous permet de travailler sans modifier la politique NAT existante.

Pour cet exemple, nous créons la configuration mixte suivante :

10.0.0.1 - Wireguard VPN server (serveur virtuel par n'importe quel fournisseur d'infrastructure) avec une IP externe ;
10.0.0.2 - Worker node (serveur dédié de LeaderGPU) avec une IP externe ;
10.0.0.3 - Manager node (serveur virtuel dans le réseau du bureau) situé derrière le NAT ;
10.0.0.4 - Storage node (serveur virtuel dans le réseau de bureau) situé derrière NAT ;
10.0.0.5 - User node (ordinateur portable du consommateur dans le réseau du bureau) situé derrière NAT.

Étape 1. Wireguard

Serveur VPN

Vous pouvez installer et configurer Wireguard manuellement, en utilisant un guide officiel et des exemples. Cependant, il existe une alternative plus simple : un script non officiel réalisé par un ingénieur logiciel parisien (Stanislas aka angristan).

Téléchargez le script depuis GitHub :

wget https://raw.githubusercontent.com/angristan/wireguard-install/master/wireguard-install.sh

Rendez-le exécutable :

sudo chmod +x wireguard-install.sh

Exécuter :

sudo ./wireguard-install.sh

Suivez les instructions et définissez la plage d'adresses IP 10.0.0.1/24. Le système vous demandera de créer immédiatement un fichier de configuration pour le premier client. Selon le plan, ce client sera le nœud de travail avec le nom Worker et l'adresse 10.0.0.2. Lorsque le script est terminé, un fichier de configuration apparaît dans le répertoire racine : /root/wg0-client-Worker.conf.

Exécutez la commande suivante pour visualiser cette configuration :

cat /home/usergpu/wg0-client-Worker.conf

[Interface]
PrivateKey = [CLIENT_PRIVATE_KEY]
Address = 10.0.0.2/32,fd42:42:42::2/128
DNS = 1.1.1.1,1.0.0.1
[Peer]
PublicKey = [SERVER_PRIVATE_KEY]
PresharedKey = [SERVER_PRESHARED_KEY]
Endpoint = [IP_ADDRESS:PORT]
AllowedIPs = 10.0.0.0/24,::/0

Exécutez à nouveau le script d'installation pour créer un autre client. Ajoutez tous les futurs clients de cette manière, et enfin, vous pouvez vérifier que tous les fichiers de configuration ont été créés :

cd ~/

ls -l | grep wg0

-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-Manager.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-Storage.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:59 wg0-client-User.conf
-rw-r--r-- 1 root    root      529 Jul 14 12:58 wg0-client-Worker.conf

Clients VPN

Les clients VPN comprennent tous les nœuds qui doivent être connectés à un réseau unique. Dans notre guide, il s'agit du nœud gestionnaire, du nœud de stockage, du nœud client (si vous utilisez Linux) et des nœuds de travail. Si le serveur VPN s'exécute sur un nœud de travail, il n'est pas nécessaire de le configurer en tant que client (cette étape peut être ignorée).

Mettez à jour le référentiel de cache des paquets, puis installez les paquets Wireguard et CIFS :

sudo apt update && sudo apt -y install wireguard cifs-utils

Élever les privilèges au niveau du superutilisateur :

sudo -i

Ouvrez le répertoire de configuration de Wireguard :

cd /etc/wireguard

Exécutez la commande umask afin que seul le superutilisateur ait accès aux fichiers de ce répertoire :

umask 077

Générer une clé privée et l'enregistrer dans un fichier :

wg genkey > private-key

Générer une clé publique à partir de la clé privée :

wg pubkey > public-key < private-key

Créer un fichier de configuration :

nano /etc/wireguard/wg0.conf

Collez votre propre configuration, créée pour ce client :

[Interface]
PrivateKey = [CLIENT_PRIVATE_KEY]
Address = 10.0.0.2/32,fd42:42:42::2/128
DNS = 1.1.1.1,1.0.0.1
[Peer]
PublicKey = [SERVER_PRIVATE_KEY]
PresharedKey = [SERVER_PRESHARED_KEY]
Endpoint = [SERVER_IP_ADDRESS:PORT]
AllowedIPs = 10.0.0.0/24,::/0
PersistentKeepalive = 1

N'oubliez pas d'ajouter l'option PersistentKeepalive = 1 (où 1 signifie 1 seconde) sur chaque nœud situé derrière un NAT. Vous pouvez choisir cette période de manière expérimentale. La valeur recommandée par les auteurs de Wireguard est de 25. Sauvegardez le fichier et quittez, en utilisant le raccourci CTRL + X et la touche Y pour confirmer.

Si vous voulez laisser passer le trafic internet, mettez AllowedIPs à 0.0.0.0/0,::/0

Déconnectez-vous ensuite du compte root :

exit

Démarrez la connexion à l'aide de systemctl :

sudo systemctl start wg-quick@wg0.service

Vérifiez que tout est en ordre et que le service a bien démarré :

sudo systemctl status wg-quick@wg0.service

● wg-quick@wg0.service - WireGuard via wg-quick(8) for wg0
Loaded: loaded (/lib/systemd/system/wg-quick@.service; enabled; vendor preset: enabled)
Active: active (exited) since Mon 2023-10-23 09:47:53 UTC; 1h 45min ago
  Docs: man:wg-quick(8)
        man:wg(8)
        https://www.wireguard.com/
        https://www.wireguard.com/quickstart/
        https://git.zx2c4.com/wireguard-tools/about/src/man/wg-quick.8
        https://git.zx2c4.com/wireguard-tools/about/src/man/wg.8
Process: 4128 ExecStart=/usr/bin/wg-quick up wg0 (code=exited, status=0/SUCCESS)
Main PID: 4128 (code=exited, status=0/SUCCESS)
  CPU: 76ms

Si vous rencontrez une erreur telle que "resolvconf : command not found" dans Ubuntu 22.04, créez simplement un lien symbolique :

sudo ln -s /usr/bin/resolvectl /usr/local/bin/resolvconf

Activez le nouveau service pour qu'il se connecte automatiquement pendant que le système d'exploitation démarre :

sudo systemctl enable wg-quick@wg0.service

Vous pouvez maintenant vérifier la connectivité en envoyant des paquets d'écho :

ping 10.0.0.1

PING 10.0.0.1 (10.0.0.1) 56(84) bytes of data.
64 bytes from 10.0.0.1: icmp_seq=1 ttl=64 time=145 ms
64 bytes from 10.0.0.1: icmp_seq=2 ttl=64 time=72.0 ms
64 bytes from 10.0.0.1: icmp_seq=3 ttl=64 time=72.0 ms
64 bytes from 10.0.0.1: icmp_seq=4 ttl=64 time=72.2 ms
--- 10.0.0.1 ping statistics ---
4 packets transmitted, 4 received, 0% packet loss, time 3004ms
rtt min/avg/max/mdev = 71.981/90.230/144.750/31.476 ms

Étape 2. Nœud NAS

Connectez-vous au serveur VPN en utilisant le guide de l'étape 1. Ensuite, installez les paquets Samba serveur et client :

sudo apt install samba samba-client

Sauvegardez votre configuration par défaut :

sudo cp /etc/samba/smb.conf /etc/samba/smb.conf.bak

Créez un répertoire qui sera utilisé comme partage :

sudo mkdir /mnt/share

Créer un nouveau groupe d'utilisateurs qui aura accès au nouveau partage :

sudo groupadd smbusers

Ajouter un utilisateur existant au groupe créé :

sudo usermod -aG smbusers user

Définir un mot de passe pour cet utilisateur. Cette étape est nécessaire car le mot de passe du système et le mot de passe Samba sont des entités différentes :

sudo smbpasswd -a $USER

Supprimer la configuration par défaut :

sudo rm /etc/samba/smb.conf

et en créer une nouvelle :

sudo nano /etc/samba/smb.conf

[global]
workgroup = WORKGROUP
security = user
map to guest = bad user
wins support = no
dns proxy = no
[private]
path = /mnt/share
valid users = @smbusers
guest ok = no
browsable = yes
writable = yes

Sauvegardez le fichier et testez les nouveaux paramètres :

testparm -s

Redémarrez les deux services Samba :

sudo service smbd restart

sudo service nmbd restart

Enfin, donnez l'autorisation de partager le dossier :

sudo chown user:smbusers /mnt/share

Étape 3. Connexion du client Samba

Tous les nœuds de Flamenco utilisent un répertoire partagé situé dans /mnt/flamenco. Vous devez monter ce répertoire sur chaque noeud avant d'exécuter les scripts flamenco-client ou flamenco-manager. Dans cet exemple, nous utilisons un nœud de travail hébergé sur LeaderGPU avec le nom d'utilisateur usergpu. Veuillez remplacer ces détails par les vôtres s'ils diffèrent.

Créez un fichier caché dans lequel vous pouvez stocker les informations d'identification du partage SMB :

nano /home/usergpu/.smbcredentials

Tapez ces deux chaînes de caractères :

username=user # your Samba username
password=password # your Samba password

Enregistrez ce fichier et quittez. Ensuite, sécurisez ce fichier en modifiant les autorisations d'accès :

sudo chmod 600 /home/usergpu/.smbcredentials

Créez un nouveau répertoire qui peut être utilisé comme point de montage pour attacher le stockage distant :

sudo mkdir /mnt/flamenco

Et faire de l'utilisateur le propriétaire de ce répertoire :

sudo chown usergpu:users /mnt/flamenco

Il ne reste plus qu'à faire en sorte que le répertoire réseau soit monté automatiquement :

sudo nano /etc/systemd/system/mnt-flamenco.mount

[Unit]
Description=Mount Remote Storage
[Mount]
What=//10.0.0.4/private
Where=/mnt/flamenco
Type=cifs
Options=mfsymlinks,credentials=/home/usergpu/.smbcredentials,uid=usergpu,gid=users
[Install]
WantedBy=multi-user.target

Ajoutez deux lignes à votre configuration VPN dans la section [Interface]:

sudo -i

nano /etc/wireguard/wg0.conf

…
PostUp = ping 10.0.0.4 -c 4 && systemctl start mnt-flamenco.mount
PostDown = systemctl stop mnt-flamenco.mount
…

Redémarrez le serveur :

sudo shutdown -r now

Vérifiez que les services sont chargés et que le répertoire partagé est monté avec succès :

df -h

Filesystem          Size  Used Avail Use% Mounted on
tmpfs                35G  3.3M   35G   1% /run
/dev/sda2            99G   18G   77G  19% /
tmpfs               174G     0  174G   0% /dev/shm
tmpfs               5.0M     0  5.0M   0% /run/lock
tmpfs                35G  8.0K   35G   1% /run/user/1000
//10.0.0.4/private   40G  9.0G   31G  23% /mnt/flamenco

Étape 4. Nœud du gestionnaire

Établissez une connexion VPN en utilisant le guide de l'étape 1. Arrêtez le service VPN avant de continuer :

sudo systemctl stop wg-quick@wg0.service

Préparons-nous. Le montage automatique nécessite des utilitaires pour le protocole CIFS :

sudo apt -y install cifs-utils

La prochaine étape importante est l'installation de Blender. Vous pouvez le faire en utilisant le gestionnaire de paquets APT standard, mais cela installera probablement l'une des anciennes versions (inférieure à v3.6.4). Utilisons Snap pour installer la dernière version :

sudo snap install blender --classic

Vérifiez la version installée à l'aide de la commande suivante :

blender --version

Blender 4.4.3
build date: 2025-04-29
build time: 15:12:13
build commit date: 2025-04-29
build commit time: 14:09
build hash: 802179c51ccc
build branch: blender-v4.4-release
build platform: Linux
build type: Release
…

Si vous recevez un message d'erreur indiquant qu'il manque des bibliothèques, installez-les simplement. Toutes ces bibliothèques sont incluses dans le paquetage XOrg :

sudo apt -y install xorg

Télécharger l'application :

wget https://flamenco.blender.org/downloads/flamenco-3.7-linux-amd64.tar.gz

Décompressez l'archive téléchargée :

tar xvfz flamenco-3.7-linux-amd64.tar.gz

Allez dans le répertoire créé :

cd flamenco-3.7-linux-amd64/

Et démarrez Flamenco pour la première fois :

./flamenco-manager

Ouvrez l'adresse suivante dans votre navigateur web: http://10.0.0.3:8080/. Cliquez sur le bouton Let's go. Tapez /mnt/flamenco dans le champ requis, puis cliquez sur Next:

Flamenco tentera de localiser le fichier exécutable de Blender. Si vous avez installé Blender à partir de Snap, le chemin sera /snap/bin/blender. Vérifiez ce point et cliquez sur Next:

Vérifiez le résumé et cliquez sur Confirm:

Retournez dans la session SSH et utilisez le raccourci clavier Ctrl + C pour interrompre l'application. Le premier lancement génère le fichier de configuration flamenco-manager.yaml. Ajoutons quelques options aux sections variables et blenderArgs:

nano flamenco-manager.yaml

# Configuration file for Flamenco.
# For an explanation of the fields, refer to flamenco-manager-example.yaml
#
# NOTE: this file will be overwritten by Flamenco Manager's web-based configuration system.
#
# This file was written on 2023-10-17 12:41:28 +00:00 by Flamenco 3.7
_meta:
  version: 3
manager_name: Flamenco Manager
database: flamenco-manager.sqlite
listen: :8080
autodiscoverable: true
local_manager_storage_path: ./flamenco-manager-storage
shared_storage_path: /mnt/flamenco
shaman:
  enabled: true
  garbageCollect:
    period: 24h0m0s
    maxAge: 744h0m0s
    extraCheckoutPaths: []
task_timeout: 10m0s
worker_timeout: 1m0s
blocklist_threshold: 3
task_fail_after_softfail_count: 3
variables:
  blender:
    values:
    - platform: linux
      value: blender
    - platform: windows
      value: blender
    - platform: darwin
      value: blender
  storage:
    values:
    is_twoway: true
    values:
    - platform: linux
      value: /mnt/flamenco
    - platform: windows
      value: Z:\
    - platform: darwin
      value: /Volumes/shared/flamenco
  blenderArgs:
    values:
    - platform: all
      value: -b -y -E CYCLES -P gpurender.py

Le premier bloc additionnel décrit des variables bidirectionnelles supplémentaires, qui sont nécessaires pour les fermes multiplateformes. Cela résout le principal problème lié aux barres obliques et aux chemins d'accès. Sous Linux, nous utilisons le symbole de la barre oblique (/) comme séparateur, mais sous Windows, nous utilisons le symbole de la barre oblique inverse (\). Ici, nous créons la règle de remplacement pour toutes les alternatives disponibles : Linux, Windows et macOS (Darwin).

Lorsque vous montez un partage réseau sous Windows, vous devez choisir une lettre de lecteur. Par exemple, notre Storage est monté avec la lettre Z:. La règle de remplacement indique au système que pour la plateforme Windows, le chemin /mnt/flamenco sera situé à Z:\. Pour macOS, ce chemin sera /Volumes/shared/flamenco.

Regardez le deuxième bloc ajouté. Il indique à Blender d'utiliser le moteur de rendu Cycles et appelle un simple script Python, gpurender.py, lorsque Blender s'exécute. Il s'agit d'une astuce simple pour sélectionner le GPU au lieu du CPU. Il n'y a pas d'option standard pour faire cela directement. Vous ne pouvez pas invoquer blender --use-gpu ou quelque chose de similaire. Cependant, vous pouvez invoquer n'importe quel script Python externe en utilisant l'option -P. Cette commande demande à Worker de trouver un script dans le répertoire local et de l'exécuter lorsque la tâche assignée invoque l'exécutable de Blender.

Maintenant, nous pouvons déléguer le contrôle de l'application au sous-système init de systemd. Informons le système de l'emplacement du répertoire de travail, du fichier exécutable et des privilèges de l'utilisateur requis pour le lancement. Créez un nouveau fichier :

sudo nano /etc/systemd/system/flamenco-manager.service

Remplissez-le avec les chaînes suivantes :

[Unit]
Description=Flamenco Manager service
[Service]
User=user
WorkingDirectory=/home/user/flamenco-3.7-linux-amd64
ExecStart=/home/user/flamenco-3.7-linux-amd64/flamenco-manager
Restart=always
[Install]
WantedBy=multi-user.target

Enregistrez le fichier et quittez l'éditeur de texte nano.

sudo systemctl daemon-reload

sudo systemctl start flamenco-manager.service

sudo systemctl status flamenco-manager.service

● flamenco-manager.service - Flamenco Manager service
Loaded: loaded (/etc/systemd/system/flamenco-manager.service; disabled; vendor preset: enabled)
Active: active (running) since Tue 2023-10-17 11:03:50 UTC; 7s ago
Main PID: 3059 (flamenco-manage)
 Tasks: 7 (limit: 4558)
  Memory: 28.6M
     CPU: 240ms
CGroup: /system.slice/flamenco-manager.service
        └─3059 /home/user/flamenco-3.7-linux-amd64/flamenco-manager

Activer le démarrage automatique lorsque le système démarre :

sudo systemctl enable flamenco-manager.service

Étape 5. Nœud de travail

Connectez-vous au serveur VPN en utilisant le guide de l'étape 1 et montez le partage de l'étape 3. Arrêtez le service VPN avant de continuer :

sudo snap install blender --classic

Les fichiers *.blend modernes sont compressés avec l'algorithme Zstandard. Pour éviter les erreurs, il est essentiel d'intégrer la prise en charge de cet algorithme :

sudo apt -y install python3-zstd

Télécharger l'application :

wget https://flamenco.blender.org/downloads/flamenco-3.7-linux-amd64.tar.gz

Décompressez l'archive téléchargée :

tar xvfz flamenco-3.7-linux-amd64.tar.gz

Naviguez jusqu'au répertoire créé :

cd flamenco-3.7-linux-amd64/

Créer un script supplémentaire qui active le rendu GPU lors de l'exécution des jobs Flamenco :

nano gpurender.py

import bpy
def enable_gpus(device_type, use_cpus=False):
    preferences = bpy.context.preferences
    cycles_preferences = preferences.addons["cycles"].preferences
    cycles_preferences.refresh_devices()
    devices = cycles_preferences.devices
    if not devices:
        raise RuntimeError("Unsupported device type")
    activated_gpus = []
    for device in devices:
        if device.type == "CPU":
            device.use = use_cpus
        else:
            device.use = True
            activated_gpus.append(device.name)
            print('activated gpu', device.name)
    cycles_preferences.compute_device_type = device_type
    bpy.context.scene.cycles.device = "GPU"
    return activated_gpus
enable_gpus("CUDA")

Sauvegardez le fichier et quittez. Ensuite, créez un service séparé pour exécuter Flamenco à partir de systemd :

sudo nano /etc/systemd/system/flamenco-worker.service

[Unit]
Description=Flamenco Worker service
[Service]
User=usergpu
WorkingDirectory=/home/usergpu/flamenco-3.7-linux-amd64
ExecStart=/home/usergpu/flamenco-3.7-linux-amd64/flamenco-worker
Restart=always
[Install]
WantedBy=multi-user.target

Rechargez la configuration et démarrez le nouveau service :

sudo systemctl daemon-reload

sudo systemctl start flamenco-worker.service

sudo systemctl status flamenco-worker.service

● flamenco-worker.service - Flamenco Worker service
Loaded: loaded (/etc/systemd/system/flamenco-worker.service; enabled; preset: enabled)
Active: active (running) since Tue 2023-10-17 13:56:18 EEST; 47s ago
Main PID: 636 (flamenco-worker)
 Tasks: 5 (limit: 23678)
Memory: 173.9M
   CPU: 302ms
CGroup: /system.slice/flamenco-worker.service
        └─636 /home/user/flamenco-3.7-linux-amd64/flamenco-worker

Activer le démarrage automatique lorsque le système démarre :

sudo systemctl enable flamenco-worker.service

Étape 6. Nœud utilisateur

Le nœud utilisateur peut être géré avec n'importe quel système d'exploitation. Dans ce guide, nous montrons comment configurer un nœud avec Windows 11 et les 4 composants nécessaires :

Connexion VPN
Répertoire distant monté
Blender installé
Module complémentaire Flamenco

Téléchargez et installez Wireguard depuis le site officiel. Créez un nouveau fichier texte et collez la configuration générée pour le client à l'étape 1. Renommez le fichier en flamenco.conf et ajoutez-le dans Wireguard en utilisant le bouton Add tunnel:

Connectez-vous à votre serveur en appuyant sur le bouton Activate:

Montons un répertoire distant. Cliquez avec le bouton droit de la souris sur This PC et sélectionnez Map network drive…

Choisissez Z: comme lettre de lecteur, tapez l'adresse du partage Samba \\10.0.0.4\private et n'oubliez pas de cocher Connect using different credentials. Cliquez ensuite sur Finish. Le système vous demandera d'entrer un nom d'utilisateur et un mot de passe pour le partage. Après cela, le répertoire réseau sera monté en tant que lecteur Z :.

Téléchargez et installez Blender à partir du site officiel. Ensuite, ouvrez l'URL http://10.0.0.3:8080/flamenco3-addon.zip et installez le module complémentaire Flamenco. Activez-le dans les préférences : Edit > Preferences > Add-ons. Cochez System: Flamenco 3, entrez l'URL du gestionnaire http://10.0.0.3:8080, et cliquez sur le bouton d'actualisation. Le système se connectera au nœud du gestionnaire et chargera automatiquement les paramètres de stockage :

Ouvrez le fichier à rendre. Dans l'onglet Scene, choisissez Cycles dans la liste déroulante Render Engine. N'oubliez pas d'enregistrer le fichier, car ces paramètres sont stockés directement dans le fichier *.blend :

Faites défiler la page vers le bas et trouvez la section Flamenco 3. Cliquez sur Fetch job types pour obtenir une liste des types disponibles. Sélectionnez Simple Blender Render dans la liste déroulante et définissez d'autres options, telles que le nombre d'images, la taille des blocs et le dossier de sortie. Enfin, cliquez sur Submit to Flamenco:

Le module complémentaire Flamenco crée une nouvelle tâche et télécharge un fichier blend vers le stockage partagé. Le système soumettra la tâche à un travailleur disponible et lancera le processus de rendu :

Si vous vérifiez la charge du GPU avec nvtop ou des utilitaires similaires, vous verrez que tous les GPU ont des tâches de calcul :

Vous trouverez le résultat dans un répertoire que vous avez sélectionné à l'étape précédente. Exemple ici (Ripple Dreams par James Redmond)

Voir aussi :

Mis à jour: 12.08.2025

Publié: 21.01.2025