Renderizado en Blender

Renderizado 3D de Blender acelerado por GPU en Clore.ai

Renderiza escenas 3D y animaciones usando Blender en GPUs de CLORE.AI.

Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de CLORE.AI Marketplace.

Alquilar en CLORE.AI

1. Visita CLORE.AI Marketplace

2. Filtrar por tipo de GPU, VRAM y precio

3. Elegir Bajo demanda (tarifa fija) o Spot (precio de puja)

4. Configura tu pedido:

   • Selecciona imagen Docker

   • Establece puertos (TCP para SSH, HTTP para interfaces web)

   • Agrega variables de entorno si es necesario

   • Introduce el comando de inicio

5. Selecciona pago: CLORE, BTC, o USDT/USDC

6. Crea el pedido y espera el despliegue

Accede a tu servidor

• Encuentra los detalles de conexión en Mis Pedidos

• Interfaces web: Usa la URL del puerto HTTP

• SSH: ssh -p <port> root@<proxy-address>

¿Por qué alquilar GPUs para Blender?

• Renderiza escenas complejas 10-50x más rápido que la CPU

• Múltiples GPUs para renderizado aún más rápido

• No es necesario invertir en hardware caro

• Paga solo por el tiempo de renderizado

Requisitos

Complejidad de la escena	GPU recomendada	VRAM
Simple	RTX 3070	8GB
Medio	RTX 3090	24GB
Complejo	RTX 4090	24GB
Producción	A100	40-80GB

Despliegue rápido

Imagen Docker:

linuxserver/blender

O renderizado sin interfaz (headless):

nytimes/blender:3.6-gpu-ubuntu22.04

Puertos:

22/tcp
3000/http

Configuración de renderizado sin interfaz

Imagen:

nvidia/cuda:12.1.0-devel-ubuntu22.04

Comando:

apt-get update && \
apt-get install -y wget libxi6 libxxf86vm1 libxfixes3 libxrender1 libgl1 && \
wget https://download.blender.org/release/Blender4.0/blender-4.0.2-linux-x64.tar.xz && \
tar -xf blender-4.0.2-linux-x64.tar.xz && \
mv blender-4.0.2-linux-x64 /opt/blender

Accediendo a tu servicio

Después del despliegue, encuentra tu http_pub URL en Mis Pedidos:

1. Ir a Mis Pedidos página

2. Haz clic en tu pedido

3. Encuentra la http_pub URL (por ejemplo, abc123.clorecloud.net)

Usa https://TU_HTTP_PUB_URL en lugar de localhost en los ejemplos abajo.

Sube tu proyecto

Vía SCP

# Subir archivo .blend
scp -P <port> myproject.blend root@<proxy>:/workspace/

# Subir carpeta del proyecto
scp -P <port> -r ./project/ root@<proxy>:/workspace/

Vía rsync (proyectos grandes)

rsync -avz --progress -e "ssh -p <port>" ./project/ root@<proxy>:/workspace/project/

Comandos de renderizado

Fotograma único

/opt/blender/blender -b /workspace/myproject.blend -o /workspace/output/frame_### -f 1 -- --cycles-device CUDA

Animación (rango de fotogramas)

/opt/blender/blender -b /workspace/myproject.blend -o /workspace/output/frame_### -s 1 -e 250 -a -- --cycles-device CUDA

Fotogramas específicos

/opt/blender/blender -b /workspace/myproject.blend -o /workspace/output/frame_### -f 1,50,100,150,200 -- --cycles-device CUDA

Opciones de renderizado

Resolución

# Sobrescribir resolución
blender -b file.blend -o //output/frame_### -x 1920 -y 1080 -a -- --cycles-device CUDA

Usar script de Python

blender -b file.blend --python render_setup.py -a

render_setup.py:

import bpy

# Establecer motor de renderizado
bpy.context.scene.render.engine = 'CYCLES'

# Establecer dispositivo
bpy.context.preferences.addons['cycles'].preferences.compute_device_type = 'CUDA'

# Habilitar todas las GPUs
for device in bpy.context.preferences.addons['cycles'].preferences.devices:
    device.use = True

# Establecer muestras
bpy.context.scene.cycles.samples = 128

# Establecer resolución
bpy.context.scene.render.resolution_x = 1920
bpy.context.scene.render.resolution_y = 1080

# Configuración de salida
bpy.context.scene.render.image_settings.file_format = 'PNG'

Renderizado multi-GPU

Para servidores con múltiples GPUs:

import bpy

# Habilitar CUDA
prefs = bpy.context.preferences.addons['cycles'].preferences
prefs.compute_device_type = 'CUDA'

# Actualizar dispositivos
prefs.get_devices()

# Habilitar todas las GPUs
for device in prefs.devices:
    if device.type == 'CUDA':
        device.use = True
        print(f"Enabled: {device.name}")

Estilo granja de render (múltiples servidores)

Alquila múltiples servidores y divide los fotogramas:

Servidor 1:

blender -b project.blend -o //output/frame_### -s 1 -e 100 -a

Servidor 2:

blender -b project.blend -o //output/frame_### -s 101 -e 200 -a

Servidor 3:

blender -b project.blend -o //output/frame_### -s 201 -e 300 -a

Luego combina los renders localmente.

Renderizado con Eevee (más rápido)

Para calidad en tiempo real:

blender -b file.blend -E BLENDER_EEVEE -o //output/frame_### -a

Soporte OptiX (GPUs RTX)

Para trazado de rayos en RTX:

import bpy
prefs = bpy.context.preferences.addons['cycles'].preferences
prefs.compute_device_type = 'OPTIX'  # En lugar de CUDA

Script de renderizado automatizado

render.sh:

#!/bin/bash
BLEND_FILE=$1
START_FRAME=$2
END_FRAME=$3
OUTPUT_DIR=/workspace/output

mkdir -p $OUTPUT_DIR

/opt/blender/blender -b $BLEND_FILE \
    -o ${OUTPUT_DIR}/frame_### \
    -s $START_FRAME \
    -e $END_FRAME \
    -a \
    -- --cycles-device CUDA

echo "¡Renderizado completo!"
ls -la $OUTPUT_DIR

Uso:

chmod +x render.sh
./render.sh /workspace/myproject.blend 1 250

Monitoreo del progreso de renderizado

Vigila la carpeta de salida

watch -n 5 'ls -la /workspace/output/ | tail -20'

Salida de Blender

Blender imprime el progreso de los fotogramas en stdout:

Fra:1 Mem:1234.56M (Pico 1500.00M) | Time:00:01.23 | Remaining:04:32.10 | Mem:567.89M, Peak:890.12M | Scene, View Layer | Sample 64/128

Descargar fotogramas renderizados

# Descargar todos los fotogramas
scp -P <port> -r root@<proxy>:/workspace/output/ ./renders/

# Descargar fotogramas específicos
scp -P <port> root@<proxy>:/workspace/output/frame_001.png ./

# Sincronizar con rsync
rsync -avz --progress -e "ssh -p <port>" root@<proxy>:/workspace/output/ ./renders/

Codificación de video

Después de renderizar los fotogramas, codifica a video:

# Instalar ffmpeg
apt-get install -y ffmpeg

# Codificar a MP4
ffmpeg -framerate 24 -i /workspace/output/frame_%03d.png -c:v libx264 -pix_fmt yuv420p output.mp4

# Codificar a ProRes (alta calidad)
ffmpeg -framerate 24 -i /workspace/output/frame_%03d.png -c:v prores_ks -profile:v 3 output.mov

Consejos de rendimiento

Optimizar para velocidad

# Reducir muestras para vista previa
bpy.context.scene.cycles.samples = 64

# Usar muestreo adaptativo
bpy.context.scene.cycles.use_adaptive_sampling = True
bpy.context.scene.cycles.adaptive_threshold = 0.01

# Limitar rebotes
bpy.context.scene.cycles.max_bounces = 8

Optimización de memoria

# Usar renderizado por tiles para alta resolución
bpy.context.scene.render.use_persistent_data = True

# Establecer tamaño de tile
bpy.context.scene.cycles.tile_size = 256  # Para GPU

Estimaciones de tiempo de renderizado

Escena	GPU	Resolución	Muestras	Tiempo/Frame
Simple	RTX 3090	1080p	128	~30s
Medio	RTX 3090	1080p	256	~2min
Complejo	RTX 4090	4K	512	~10min
Producción	A100	4K	1024	~20min

Cálculo de costo

Ejemplo: animación de 250 fotogramas

GPU: RTX 4090
Tiempo por fotograma: 2 minutos
Tiempo total de renderizado: 500 minutos = 8.3 horas
Tarifa por hora: $0.04
Costo total: ~$0.33

Solución de problemas

"Dispositivo CUDA no encontrado"

# Verificar dispositivos disponibles
import bpy
prefs = bpy.context.preferences.addons['cycles'].preferences
prefs.compute_device_type = 'CUDA'
prefs.get_devices()
for d in prefs.devices:
    print(d.name, d.type)

Fuera de memoria

• Reducir la resolución de las texturas

• Usar tamaño de tile más pequeño

• Habilitar "persistent data"

• Usar shaders más simples

Renderizado lento

• Verificar que la GPU esté siendo usada (nvidia-smi)

• Optimizar la geometría de la escena

• Usar denoising con menos muestras

Próximos pasos

• Ejecutar Jupyter para postprocesado

• Generación de video AI