# Renderizado con Blender

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

{% hint style="success" %}
Todos los ejemplos se pueden ejecutar en servidores GPU alquilados a través de [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Alquilar en CLORE.AI

1. Visita [CLORE.AI Marketplace](https://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:**

```bash
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

```bash

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

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

## Comandos de renderizado

### Fotograma único

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

### Animación (rango de fotogramas)

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

### Fotogramas específicos

```bash
/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

```bash

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

### Usar script de Python

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

**render\_setup.py:**

```python
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:

```python
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:**

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

**Servidor 2:**

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

**Servidor 3:**

```bash
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:

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

## Soporte OptiX (GPUs RTX)

Para trazado de rayos en RTX:

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

## Script de renderizado automatizado

**render.sh:**

```bash
#!/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:

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

## Monitoreo del progreso de renderizado

### Vigila la carpeta de salida

```bash
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

```bash

# 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:

```bash

# 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

```python

# 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

```python

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

```python

# 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)
```

{% hint style="danger" %}
**Fuera de memoria**
{% endhint %}

* 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](/guides/guides_v2-es/generacion-de-video/ai-video-generation.md)


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-es/otras-cargas-de-trabajo/blender-rendering.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.