Aplicaciones y Guías

Renderizado remoto en Blender con Flamenco

Cuando el renderizado de escenas pesadas en Blender empieza a consumir demasiado tiempo de su equipo, tiene dos opciones: actualizar el ordenador de cada miembro del equipo o subcontratar el renderizado a una granja dedicada. Muchas empresas ofrecen soluciones de renderizado ya preparadas, pero si necesita un control total sobre la infraestructura, estas soluciones pueden no ser la opción más fiable.

Un enfoque alternativo podría consistir en crear una infraestructura híbrida. En esta configuración, mantendría el almacenamiento de datos y la gestión de la granja de renderizado dentro de su infraestructura existente. El único elemento que se ubicaría fuera serían los servidores GPU alquilados en los que se realizaría el renderizado.

En general, la infraestructura de la granja de renderizado para Blender tiene este aspecto:

Aquí tenemos un nodo central Manager que organiza todos los procesos. Recibe las tareas de renderizado de los usuarios a través de un Blender Add-on específico y mueve todos los archivos necesarios a Shared Storage. Luego, el Manager distribuye las tareas a Worker nodes. Ellos reciben un trabajo que contiene toda la información acerca de dónde el Trabajador puede encontrar los archivos para renderizar y qué hacer con los resultados obtenidos. Para implementar este esquema, puedes utilizar una aplicación completamente gratuita y de código abierto llamada Flamenco. En esta guía, mostramos cómo preparar todos los nodos, especialmente los Manager y Worker.

El nodo Storage no tiene requisitos específicos. Puede utilizarse con cualquier sistema operativo que soporte los protocolos SMB/CIFS o NFS. El único requisito es que el directorio de almacenamiento debe estar montado y accesible por el sistema operativo. En tu infraestructura, puede ser cualquier carpeta compartida accesible a todos los nodos.

Cada nodo tiene direcciones IP diferentes, y el servidor Wireguard VPN será un punto central que los una en una red L2. Este servidor, situado en el perímetro externo, te permite trabajar sin realizar cambios en la política NAT existente.

Para este ejemplo, creamos la siguiente configuración mixta:

10.0.0.1 - Wireguard VPN server (servidor virtual por cualquier proveedor de infraestructura) con una IP externa;
10.0.0.2 - Worker node (servidor dedicado por LeaderGPU) con una IP externa;
10.0.0.3 - Manager node (servidor virtual en la red de la oficina) situado detrás de NAT;
10.0.0.4 - Storage node (servidor virtual en la red de la oficina) situado detrás de NAT;
10.0.0.5 - User node (ordenador portátil del consumidor en la red de la oficina) situado detrás de NAT.

Primer paso Wireguard

Servidor VPN

Puedes instalar y configurar Wireguard manualmente, usando una guía oficial y ejemplos. Sin embargo, hay una alternativa más fácil: script no oficial por el ingeniero de software de París (Stanislas aka angristan).

Descarga el script desde GitHub:

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

Hazlo ejecutable:

sudo chmod +x wireguard-install.sh

Ejecutar:

sudo ./wireguard-install.sh

Siga las instrucciones y configure el rango de direcciones IP 10.0.0.1/24. El sistema te pedirá que crees inmediatamente un fichero de configuración para el primer cliente. Según el plan, este cliente será el nodo trabajador con nombre Worker y dirección 10.0.0.2. Cuando finalice el script, aparecerá un archivo de configuración en el directorio raíz: /root/wg0-client-Worker.conf.

Ejecuta el siguiente comando para ver esta configuración:

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

Ejecute de nuevo el script de instalación para crear otro cliente. Añada todos los clientes futuros de esta forma y, finalmente, podrá comprobar que se han creado todos los archivos de configuración:

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

Clientes VPN

Los clientes VPN incluyen todos los nodos que necesitan estar conectados a una única red. En nuestra guía, esto se refiere al nodo gestor, el nodo de almacenamiento, el nodo cliente (si se utiliza Linux) y los nodos trabajadores. Si el servidor VPN se ejecuta en un nodo trabajador, no es necesario configurarlo como cliente (este paso puede omitirse).

Actualice el repositorio de caché de paquetes y, a continuación, instale los paquetes de soporte de Wireguard y CIFS:

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

Eleve los privilegios a superusuario:

sudo -i

Abra el directorio de configuración de Wireguard:

cd /etc/wireguard

Ejecute el comando umask para que sólo el superusuario tenga acceso a los archivos de este directorio:

umask 077

Genera una clave privada y guárdala en un archivo:

wg genkey > private-key

Generar una clave pública utilizando la clave privada:

wg pubkey > public-key < private-key

Crear un archivo de configuración:

nano /etc/wireguard/wg0.conf

Pega tu propia configuración, creada para este cliente:

[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

No olvides añadir la opción PersistentKeepalive = 1 (donde 1 significa 1 segundo) en cada nodo situado detrás de NAT. Puedes elegir este periodo experimentalmente. El valor recomendado por los autores de Wireguard es 25. Guarda el archivo y sal, usando el atajo de teclado CTRL + X y la tecla Y para confirmar.

Si quieres pasar el trafico de internet configura AllowedIPs a 0.0.0.0/0,::/0

A continuación, cierra la sesión desde la cuenta raíz:

exit

Inicie la conexión usando systemctl:

sudo systemctl start wg-quick@wg0.service

Comprueba que todo va bien y que el servicio se ha iniciado correctamente:

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 encuentra un error como "resolvconf: command not found" en Ubuntu 22.04 simplemente cree un enlace de símbolo:

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

Habilite el nuevo servicio para que se conecte automáticamente mientras el sistema operativo está arrancando:

sudo systemctl enable wg-quick@wg0.service

Ahora, puedes comprobar la conectividad enviando paquetes eco:

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

Paso 2. Nodo NAS

Conéctese al servidor VPN siguiendo la guía del paso 1. A continuación, instale los paquetes Samba de servidor y cliente:

sudo apt install samba samba-client

Haga una copia de seguridad de su configuración por defecto:

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

Cree un directorio que se utilizará como recurso compartido:

sudo mkdir /mnt/share

Cree un nuevo grupo de usuarios que tendrá acceso al nuevo recurso compartido:

sudo groupadd smbusers

Añade un usuario existente al grupo creado:

sudo usermod -aG smbusers user

Establezca una contraseña para este usuario. Este paso es necesario porque la contraseña del sistema y la contraseña de Samba son entidades diferentes:

sudo smbpasswd -a $USER

Elimine la configuración por defecto:

sudo rm /etc/samba/smb.conf

Y crea una nueva:

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

Guarda el archivo y prueba los nuevos parámetros:

testparm -s

Reinicie ambos servicios Samba:

sudo service smbd restart

sudo service nmbd restart

Por último, dé permiso para compartir la carpeta:

sudo chown user:smbusers /mnt/share

Paso 3. Conexión del cliente Samba

Todos los nodos de Flamenco utilizan un directorio compartido ubicado en /mnt/flamenco. Debe montar este directorio en cada nodo antes de ejecutar los scripts flamenco-client o flamenco-manager. En este ejemplo, utilizamos un nodo trabajador alojado en LeaderGPU con el nombre de usuario usergpu. Por favor, sustituye estos datos por los tuyos si difieren.

Crea un archivo oculto donde puedas almacenar las credenciales del recurso compartido SMB:

nano /home/usergpu/.smbcredentials

Escriba estas dos cadenas:

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

Guarda este archivo y sal. Luego, asegure este archivo cambiando los permisos de acceso:

sudo chmod 600 /home/usergpu/.smbcredentials

Cree un nuevo directorio que pueda utilizarse como punto de montaje para adjuntar el almacenamiento remoto:

sudo mkdir /mnt/flamenco

Y haz al usuario propietario de este directorio:

sudo chown usergpu:users /mnt/flamenco

Lo único que falta es que el directorio de red se monte automáticamente:

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

Añade dos líneas a tu configuración VPN en la sección [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
…

Reinicie el servidor:

sudo shutdown -r now

Compruebe que los servicios se han cargado y que el directorio compartido se ha montado correctamente:

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

Paso 4. Nodo gestor

Configure una conexión VPN siguiendo la guía del Paso 1. Detenga el servicio VPN antes de continuar:

sudo systemctl stop wg-quick@wg0.service

Preparémonos. El montaje automático requiere utilidades para el protocolo CIFS:

sudo apt -y install cifs-utils

El siguiente paso importante es instalar Blender. Puede hacerlo utilizando el gestor de paquetes estándar de APT, pero lo más probable es que instale una de las versiones más antiguas (inferior a la v3.6.4). Utilicemos Snap para instalar la última versión:

sudo snap install blender --classic

Compruebe la versión instalada usando el siguiente 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
…

Si recibe un mensaje de error indicando que faltan bibliotecas, simplemente instálelas. Todas estas bibliotecas están incluidas en el paquete XOrg:

sudo apt -y install xorg

Descargue la aplicación:

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

Descomprime el archivo descargado:

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

Vaya al directorio creado:

cd flamenco-3.7-linux-amd64/

E inicie Flamenco por primera vez:

./flamenco-manager

Abra la siguiente dirección en su navegador: http://10.0.0.3:8080/. Haga clic en el botón Let's go. Escriba /mnt/flamenco en el campo correspondiente y, a continuación, haga clic en Next:

Flamenco intentará localizar el archivo ejecutable de Blender. Si ha instalado Blender desde Snap, la ruta será /snap/bin/blender. Compruebe este punto y haga clic en Next:

Compruebe el resumen y haga clic en Confirm:

Vuelva a la sesión SSH y utilice el atajo de teclado Ctrl + C para interrumpir la aplicación. El primer lanzamiento genera el archivo de configuración flamenco-manager.yaml. Vamos a añadir algunas opciones a las secciones variables y 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

El primer bloque adicional describe variables Two-way adicionales, necesarias para granjas multiplataforma. Esto resuelve el principal problema con las barras oblicuas y las rutas. En Linux, utilizamos el símbolo de la barra oblicua (/) como separador, pero en Windows, utilizamos el símbolo de la barra invertida (\). Aquí, creamos la regla de sustitución para todas las alternativas disponibles: Linux, Windows y macOS (Darwin).

Cuando se monta un recurso compartido de red en Windows, es necesario elegir una letra de unidad. Por ejemplo, nuestro Storage se monta con la letra Z:. La regla de sustitución indica al sistema que para la plataforma Windows, la ruta /mnt/flamenco se ubicará en Z:\. Para macOS, esta ruta será /Volumes/shared/flamenco.

Mire el segundo bloque añadido. Esto instruye a Blender a usar el motor de renderizado Cycles y llama a un simple script Python, gpurender.py, cuando Blender se ejecuta. Este es un simple truco para seleccionar la GPU en lugar de la CPU. No hay una opción estándar para hacer esto directamente. No puedes invocar blender --use-gpu o algo similar. Sin embargo, puedes invocar cualquier script externo de Python usando la opción -P. Este comando ordena a Worker que busque un script en el directorio local y lo ejecute cuando el trabajo asignado invoque al ejecutable de Blender.

Ahora, podemos delegar el control de la aplicación al subsistema systemd init. Informemos al sistema sobre la ubicación del directorio de trabajo, el archivo ejecutable y los privilegios de usuario necesarios para el lanzamiento. Crea un nuevo archivo:

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

Llénalo con las siguientes cadenas:

[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

Guarde el archivo y salga del editor de texto 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

Habilite el inicio automático al arrancar el sistema:

sudo systemctl enable flamenco-manager.service

Paso 5. Nodo trabajador

Conéctese al servidor VPN utilizando la guía del Paso 1 y monte el recurso compartido del Paso 3. Detenga el servicio VPN antes de continuar:

sudo snap install blender --classic

Los archivos *.blend modernos se comprimen con el algoritmo Zstandard. Para evitar errores, es esencial incorporar soporte para este algoritmo:

sudo apt -y install python3-zstd

Descargue la aplicación:

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

Descomprime el archivo descargado:

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

Navegue hasta el directorio creado:

cd flamenco-3.7-linux-amd64/

Cree un script adicional que habilite el renderizado GPU cuando se ejecuten trabajos de 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")

Guarde el archivo y salga. A continuación, cree un servicio independiente para ejecutar Flamenco desde 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

Recarga la configuración e inicia el nuevo servicio:

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

Activar el inicio automático al arrancar el sistema:

sudo systemctl enable flamenco-worker.service

Paso 6. Nodo de usuario

El nodo de usuario se puede gestionar con cualquier sistema operativo. Para esta guía, mostramos cómo configurar un nodo con Windows 11 y 4 componentes necesarios:

Conexión VPN
Directorio remoto montado
Blender instalado
Complemento Flamenco

Descargue e instale Wireguard desde el sitio web oficial. Crea un nuevo archivo de texto y pega la configuración, generada para el cliente en el Paso 1. Cambie el nombre del archivo a flamenco.conf y añádalo en Wireguard utilizando el botón Add tunnel:

Conéctese a su servidor pulsando el botón Activate:

Vamos a montar un directorio remoto. Haz clic con el botón derecho en This PC y selecciona Map network drive…

Elige Z: como letra de unidad, escribe la dirección del recurso compartido Samba \\10.0.0.4\private y no olvides marcar Connect using different credentials. A continuación, haz clic en Finish. El sistema te pedirá que introduzcas un nombre de usuario y una contraseña para el recurso compartido. A continuación, el directorio de red se montará como unidad Z:.

Descarga e instala Blender desde el sitio web oficial. A continuación, abra la URL http://10.0.0.3:8080/flamenco3-addon.zip e instale el complemento Flamenco. Actívalo en preferencias: Edit > Preferences > Add-ons. Marque System: Flamenco 3, introduzca la URL del Gestor http://10.0.0.3:8080, y pulse el botón actualizar. El sistema se conectará al nodo gestor y cargará la configuración de almacenamiento automáticamente:

Abra el archivo que necesita renderizar. En la pestaña Scene, seleccione Cycles de la lista desplegable Renderizar Engine. No olvides guardar el archivo, ya que estos ajustes se almacenan directamente en el archivo *.blend:

Desplázate hacia abajo y encuentra la sección Flamenco 3. Haz clic en Fetch job types para obtener una lista de los tipos disponibles. Selecciona Simple Blender Render en la lista desplegable y configura otras opciones, como el número de fotogramas, el tamaño de los trozos y la carpeta de salida. Por último, haz clic en Submit to Flamenco:

El complemento Flamenco crea un nuevo trabajo y carga un archivo de mezcla en el almacenamiento compartido. El sistema enviará el trabajo a un trabajador disponible e iniciará el proceso de renderizado:

Si compruebas la carga de la GPU con nvtop o utilidades similares, mostrará que todas las GPUs tienen tareas de computación:

Encontrarás el resultado en el directorio que hayas seleccionado en el paso anterior. Ejemplo aquí (Ripple Dreams por James Redmond)

Véase también:

Actualizado: 12.08.2025

Publicado: 21.01.2025