Applicazioni e Guide

Rendering remoto di Blender con Flamenco

Quando il rendering di scene pesanti in Blender inizia a consumare troppo tempo del vostro team, avete due opzioni: aggiornare il computer di ogni membro del team o esternalizzare il rendering a una farm dedicata. Molte aziende offrono soluzioni di rendering già pronte, ma se avete bisogno di un controllo completo sull'infrastruttura, queste soluzioni potrebbero non essere l'opzione più affidabile.

Un approccio alternativo potrebbe essere la creazione di un'infrastruttura ibrida. In questa configurazione, l'archiviazione dei dati e la gestione della farm di rendering rimarrebbero all'interno dell'infrastruttura esistente. L'unico elemento che verrebbe collocato all'esterno sarebbero i server GPU a noleggio sui quali verrebbe eseguito il rendering.

In generale, l'infrastruttura della farm di rendering per Blender si presenta come segue:

Qui abbiamo un nodo centrale Manager che organizza tutti i processi. Riceve i compiti di rendering dagli utenti tramite uno specifico Blender Add-on e sposta tutti i file necessari su Shared Storage. Quindi, Manager distribuisce i compiti a Worker nodes. Questi ricevono un lavoro contenente tutte le informazioni su dove il Worker può trovare i file da renderizzare e cosa fare con i risultati ottenuti. Per implementare questo schema, è possibile utilizzare un'applicazione completamente gratuita e open-source chiamata Flamenco. In questa guida viene mostrato come preparare tutti i nodi, in particolare Manager e Worker.

Il nodo Storage non ha requisiti specifici. Può essere utilizzato con qualsiasi sistema operativo che supporti i protocolli SMB/CIFS o NFS. L'unico requisito è che la directory di archiviazione deve essere montata e accessibile dal sistema operativo. Nella vostra infrastruttura, questa può essere una qualsiasi cartella condivisa accessibile a tutti i nodi.

Ogni nodo ha indirizzi IP diversi e il server Wireguard VPN sarà un punto centrale che li unisce in un'unica rete L2. Questo server, situato sul perimetro esterno, consente di lavorare senza apportare modifiche alla politica NAT esistente.

Per questo esempio, creiamo la seguente configurazione mista:

10.0.0.1 - Wireguard VPN server (server virtuale di qualsiasi fornitore di infrastrutture) con un IP esterno;
10.0.0.2 - Worker node (server dedicato di LeaderGPU) con un IP esterno;
10.0.0.3 - Manager node (server virtuale nella rete dell'ufficio) situato dietro NAT;
10.0.0.4 - Storage node (server virtuale nella rete dell'ufficio) situato dietro NAT;
10.0.0.5 - User node (laptop consumer nella rete dell'ufficio) situato dietro NAT.

Passo 1. Wireguard

Server VPN

È possibile installare e configurare Wireguard manualmente, utilizzando una guida ufficiale e degli esempi. Tuttavia, esiste un'alternativa più semplice: uno script non ufficiale realizzato da un ingegnere informatico di Parigi (Stanislas aka angristan).

Scaricate lo script da GitHub:

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

Rendetelo eseguibile:

sudo chmod +x wireguard-install.sh

Eseguire:

sudo ./wireguard-install.sh

Seguire le istruzioni e impostare l'intervallo di indirizzi IP 10.0.0.1/24. Il sistema chiederà di creare immediatamente un file di configurazione per il primo client. Secondo il piano, questo client sarà il nodo worker con nome Worker e indirizzo 10.0.0.2. Al termine dello script, nella directory principale apparirà un file di configurazione: /root/wg0-client-Worker.conf.

Eseguire il seguente comando per visualizzare la configurazione:

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

Eseguire nuovamente lo script di installazione per creare un altro client. Aggiungere tutti i client futuri in questo modo e infine verificare che tutti i file di configurazione siano stati creati:

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

Clienti VPN

I client VPN comprendono tutti i nodi che devono essere collegati a una singola rete. Nella nostra guida, si tratta del nodo manager, del nodo di archiviazione, del nodo client (se si utilizza Linux) e dei nodi worker. Se il server VPN è in esecuzione su un nodo worker, non è necessario configurarlo come client (questo passaggio può essere saltato).

Aggiornare il repository della cache dei pacchetti, quindi installare i pacchetti Wireguard e CIFS:

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

Elevare i privilegi a superuser:

sudo -i

Aprire la directory di configurazione di Wireguard:

cd /etc/wireguard

Eseguire il comando umask in modo che solo il superutente abbia accesso ai file di questa directory:

umask 077

Generare una chiave privata e salvarla in un file:

wg genkey > private-key

Generare una chiave pubblica utilizzando la chiave privata:

wg pubkey > public-key < private-key

Creare un file di configurazione:

nano /etc/wireguard/wg0.conf

Incollare la propria configurazione, creata per questo 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

Non dimenticare di aggiungere l'opzione PersistentKeepalive = 1 (dove 1 significa 1 secondo) su ogni nodo situato dietro NAT. È possibile scegliere questo periodo in via sperimentale. Il valore consigliato dagli autori di Wireguard è 25. Salvare il file e uscire, usando la scorciatoia CTRL + X e il tasto Y per confermare.

Se si desidera passare il traffico Internet, impostare AllowedIPs su 0.0.0.0/0,::/0

Quindi, effettuare il logout dall'account root:

exit

Avviare la connessione utilizzando systemctl:

sudo systemctl start wg-quick@wg0.service

Verificare che tutto sia a posto e che il servizio sia stato avviato correttamente:

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

Se si verifica un errore del tipo "resolvconf: comando non trovato" in Ubuntu 22.04, è sufficiente creare un collegamento di simbolo:

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

Abilitate il nuovo servizio a connettersi automaticamente durante l'avvio del sistema operativo:

sudo systemctl enable wg-quick@wg0.service

Ora è possibile verificare la connettività inviando pacchetti echo:

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

Passo 2. Nodo NAS

Connettersi al server VPN utilizzando la guida del punto 1. Quindi, installare i pacchetti Samba del server e del client:

sudo apt install samba samba-client

Eseguire il backup della configurazione predefinita:

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

Creare una directory che verrà utilizzata come condivisione:

sudo mkdir /mnt/share

Creare un nuovo gruppo di utenti che avrà accesso alla nuova condivisione:

sudo groupadd smbusers

Aggiungere un utente esistente al gruppo creato:

sudo usermod -aG smbusers user

Impostare una password per questo utente. Questo è un passo necessario perché la password di sistema e la password di Samba sono entità diverse:

sudo smbpasswd -a $USER

Rimuovere la configurazione predefinita:

sudo rm /etc/samba/smb.conf

e crearne una nuova:

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

Salvare il file e testare i nuovi parametri:

testparm -s

Riavviare entrambi i servizi Samba:

sudo service smbd restart

sudo service nmbd restart

Infine, dare il permesso di condividere la cartella:

sudo chown user:smbusers /mnt/share

Passo 3. Connessione del client Samba

Tutti i nodi di Flamenco utilizzano una directory condivisa situata in /mnt/flamenco. È necessario montare questa directory su ogni nodo prima di eseguire gli script flamenco-client o flamenco-manager. In questo esempio, utilizziamo un nodo worker ospitato su LeaderGPU con il nome utente usergpu. Si prega di sostituire questi dati con i propri se differiscono.

Creare un file nascosto in cui memorizzare le credenziali della condivisione SMB:

nano /home/usergpu/.smbcredentials

Digitare queste due stringhe:

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

Salvare il file e uscire. Quindi, proteggete il file modificando i permessi di accesso:

sudo chmod 600 /home/usergpu/.smbcredentials

Creare una nuova directory che possa essere usata come punto di montaggio per collegare lo storage remoto:

sudo mkdir /mnt/flamenco

E rendere l'utente proprietario di questa directory:

sudo chown usergpu:users /mnt/flamenco

L'unica cosa che rimane è che la directory di rete venga montata automaticamente:

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

Aggiungete due righe alla vostra configurazione VPN nella sezione [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
…

Riavviare il server:

sudo shutdown -r now

Verificare che i servizi siano caricati e che la directory condivisa sia montata correttamente:

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

Passo 4. Nodo manager

Impostare una connessione VPN seguendo la guida del passaggio 1. Arrestare il servizio VPN prima di continuare:

sudo systemctl stop wg-quick@wg0.service

Prepariamoci. Il montaggio automatico richiede utility per il protocollo CIFS:

sudo apt -y install cifs-utils

Il prossimo passo importante è l'installazione di Blender. È possibile farlo utilizzando il gestore di pacchetti APT standard, ma molto probabilmente verrà installata una delle versioni più vecchie (meno della v3.6.4). Utilizziamo Snap per installare l'ultima versione:

sudo snap install blender --classic

Controllare la versione installata usando il seguente comando:

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
…

Se si riceve un messaggio di errore che indica la mancanza di librerie, è sufficiente installarle. Tutte queste librerie sono incluse nel pacchetto XOrg:

sudo apt -y install xorg

Scaricare l'applicazione:

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

Decomprimere l'archivio scaricato:

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

Andare alla directory creata:

cd flamenco-3.7-linux-amd64/

E avviare Flamenco per la prima volta:

./flamenco-manager

Aprite il seguente indirizzo nel vostro browser web: http://10.0.0.3:8080/. Fate clic sul pulsante Let's go. Digitare /mnt/flamenco nel campo richiesto, quindi fare clic su Next:

Flamenco cercherà di individuare il file eseguibile di Blender. Se avete installato Blender da Snap, il percorso sarà /snap/bin/blender. Controllate questo punto e fate clic su Next:

Controllate il riepilogo e fate clic su Confirm:

Tornare alla sessione SSH e usare la scorciatoia da tastiera Ctrl + C per interrompere l'applicazione. Il primo avvio genera il file di configurazione flamenco-manager.yaml. Aggiungiamo alcune opzioni alle sezioni variables e 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

Il primo blocco aggiuntivo descrive ulteriori variabili bidirezionali, necessarie per le farm multipiattaforma. Questo risolve il problema principale degli slash e dei percorsi. In Linux si usa il simbolo della barra in avanti (/) come separatore, mentre in Windows si usa il simbolo del backslash (\). In questo caso, creiamo la regola di sostituzione per tutte le alternative disponibili: Linux, Windows e macOS (Darwin).

Quando si monta una condivisione di rete in Windows, è necessario scegliere una lettera di unità. Ad esempio, il nostro Storage è montato con la lettera Z:. La regola di sostituzione indica al sistema che, per la piattaforma Windows, il percorso /mnt/flamenco sarà situato in Z:\. Per macOS, questo percorso sarà /Volumes/shared/flamenco.

Osservate il secondo blocco aggiunto. Questo indica a Blender di usare il motore di rendering Cycles e chiama un semplice script Python, gpurender.py, quando Blender viene eseguito. Si tratta di un semplice trucco per selezionare la GPU invece della CPU. Non esiste un'opzione standard per farlo direttamente. Non è possibile invocare blender --use-gpu o qualcosa di simile. Tuttavia, è possibile invocare qualsiasi script Python esterno usando l'opzione -P. Questo comando indica a Worker di trovare uno script nella directory locale e di eseguirlo quando il lavoro assegnato richiama l'eseguibile di Blender.

Ora possiamo delegare il controllo dell'applicazione al sottosistema systemd init. Informiamo il sistema sulla posizione della directory di lavoro, sul file eseguibile e sui privilegi dell'utente necessari per il lancio. Creare un nuovo file:

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

Compilatelo con le seguenti stringhe:

[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

Salvare il file e uscire dall'editor di testo 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

Abilitare l'avvio automatico all'avvio del sistema:

sudo systemctl enable flamenco-manager.service

Passo 5. Nodo lavoratore

Connettersi al server VPN utilizzando la guida del passaggio 1 e montare la condivisione del passaggio 3. Arrestare il servizio VPN prima di continuare:

sudo snap install blender --classic

I moderni file *.blend sono compressi con l'algoritmo Zstandard. Per evitare errori, è essenziale incorporare il supporto per questo algoritmo:

sudo apt -y install python3-zstd

Scaricare l'applicazione:

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

Decomprimere l'archivio scaricato:

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

Navigare nella directory creata:

cd flamenco-3.7-linux-amd64/

Creare uno script aggiuntivo che abiliti il rendering GPU durante l'esecuzione di Flamenco jobs:

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")

Salvare il file e uscire. Quindi, creare un servizio separato per eseguire Flamenco da 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

Ricaricare la configurazione e avviare il nuovo servizio:

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

Attivare l'avvio automatico all'avvio del sistema:

sudo systemctl enable flamenco-worker.service

Passo 6. Nodo utente

Il nodo utente può essere gestito con qualsiasi sistema operativo. In questa guida mostriamo come configurare un nodo con Windows 11 e i 4 componenti necessari:

connessione VPN
Directory remota montata
Blender installato
Componente aggiuntivo Flamenco

Scaricare e installare Wireguard dal sito ufficiale. Creare un nuovo file di testo e incollarvi la configurazione generata per il client al punto 1. Rinominate il file in flamenco.conf e aggiungetelo a Wireguard utilizzando il pulsante Add tunnel:

Collegarsi al server premendo il pulsante Activate:

Montiamo una directory remota. Fare clic con il tasto destro del mouse su This PC e selezionare Map network drive…

Scegliere Z: come lettera di unità, digitare l'indirizzo della condivisione Samba \\10.0.0.4\private e non dimenticare di spuntare Connect using different credentials. Quindi fare clic su Finish. Il sistema chiederà di inserire un nome utente e una password per la condivisione. Successivamente, la directory di rete verrà montata come unità Z:.

Scaricare e installare Blender dal sito ufficiale. Quindi, aprire l'URL http://10.0.0.3:8080/flamenco3-addon.zip e installare il componente aggiuntivo Flamenco. Attivarlo nelle preferenze: Edit > Preferences > Add-ons. Spuntare System: Flamenco 3, inserire l'URL del manager http://10.0.0.3:8080 e fare clic sul pulsante di aggiornamento. Il sistema si collegherà al nodo manager e caricherà automaticamente le impostazioni di archiviazione:

Aprire il file da renderizzare. Nella scheda Scene, scegliere Cycles dall'elenco a discesa Render Engine. Non dimenticate di salvare il file, perché queste impostazioni sono memorizzate direttamente nel file *.blend:

Scorrere verso il basso e trovare la sezione Flamenco 3. Fare clic su Fetch job types per ottenere un elenco dei tipi disponibili. Selezionare Simple Blender Render dall'elenco a discesa e impostare altre opzioni, come il numero di fotogrammi, la dimensione dei pezzi e la cartella di output. Infine, fare clic su Submit to Flamenco:

Il componente aggiuntivo Flamenco crea un nuovo lavoro e carica un file blend sull'archivio condiviso. Il sistema invia il lavoro a un worker disponibile e avvia il processo di rendering:

Se si controlla il carico della GPU con nvtop o utility simili, si vede che tutte le GPU hanno compiti di calcolo:

Il risultato si trova in una directory selezionata nel passaggio precedente. Esempio qui (Ripple Dreams di James Redmond)

Vedere anche:

Aggiornato: 12.08.2025

Pubblicato: 21.01.2025