# Rendu Blender

Rendre des scènes 3D et des animations avec Blender sur les GPU de CLORE.AI.

{% hint style="success" %}
Tous les exemples peuvent être exécutés sur des serveurs GPU loués via [CLORE.AI Marketplace](https://clore.ai/marketplace).
{% endhint %}

## Location sur CLORE.AI

1. Visitez [CLORE.AI Marketplace](https://clore.ai/marketplace)
2. Filtrer par type de GPU, VRAM et prix
3. Choisir **À la demande** (tarif fixe) ou **Spot** (prix d'enchère)
4. Configurez votre commande :
   * Sélectionnez l'image Docker
   * Définissez les ports (TCP pour SSH, HTTP pour les interfaces web)
   * Ajoutez des variables d'environnement si nécessaire
   * Entrez la commande de démarrage
5. Sélectionnez le paiement : **CLORE**, **BTC**, ou **USDT/USDC**
6. Créez la commande et attendez le déploiement

### Accédez à votre serveur

* Trouvez les détails de connexion dans **Mes commandes**
* Interfaces Web : utilisez l'URL du port HTTP
* SSH : `ssh -p <port> root@<adresse-proxy>`

## Pourquoi louer des GPU pour Blender ?

* Rendez des scènes complexes 10 à 50x plus rapidement que le CPU
* Plusieurs GPU pour un rendu encore plus rapide
* Pas besoin d'investir dans du matériel coûteux
* Ne payez que le temps de rendu

## Exigences

| Complexité de la scène | GPU recommandé | VRAM     |
| ---------------------- | -------------- | -------- |
| Simple                 | RTX 3070       | 8 Go     |
| Moyen                  | RTX 3090       | 24 Go    |
| Complexe               | RTX 4090       | 24 Go    |
| Production             | A100           | 40-80 Go |

## Déploiement rapide

**Image Docker :**

```
linuxserver/blender
```

Ou rendu en mode headless :

```
nytimes/blender:3.6-gpu-ubuntu22.04
```

**Ports :**

```
22/tcp
3000/http
```

## Configuration du rendu headless

**Image :**

```
nvidia/cuda:12.1.0-devel-ubuntu22.04
```

**Commande :**

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

## Accéder à votre service

Après le déploiement, trouvez votre `http_pub` URL dans **Mes commandes**:

1. Aller à la **Mes commandes** page
2. Cliquez sur votre commande
3. Trouvez l' `http_pub` URL (par ex., `abc123.clorecloud.net`)

Utilisez `https://VOTRE_HTTP_PUB_URL` au lieu de `localhost` dans les exemples ci-dessous.

## Téléversez votre projet

### Via SCP

```bash

# Téléverser le fichier .blend
scp -P <port> myproject.blend root@<proxy>:/workspace/

# Téléverser le dossier du projet
scp -P <port> -r ./project/ root@<proxy>:/workspace/
```

### Via rsync (projets volumineux)

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

## Commandes de rendu

### Image unique

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

### Animation (plage d'images)

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

### Images spécifiques

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

## Options de rendu

### Résolution

```bash

# Remplacer la résolution
blender -b file.blend -o //output/frame_### -x 1920 -y 1080 -a -- --cycles-device CUDA
```

### Utiliser un script Python

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

**render\_setup.py :**

```python
import bpy

# Définir le moteur de rendu
bpy.context.scene.render.engine = 'CYCLES'

# Définir le périphérique
bpy.context.preferences.addons['cycles'].preferences.compute_device_type = 'CUDA'

# Activer tous les GPU
for device in bpy.context.preferences.addons['cycles'].preferences.devices:
    device.use = True

# Définir les échantillons
bpy.context.scene.cycles.samples = 128

# Définir la résolution
bpy.context.scene.render.resolution_x = 1920
bpy.context.scene.render.resolution_y = 1080

# Paramètres de sortie
bpy.context.scene.render.image_settings.file_format = 'PNG'
```

## Rendu multi-GPU

Pour les serveurs avec plusieurs GPU :

```python
import bpy

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

# Actualiser les périphériques
prefs.get_devices()

# Activer tous les GPU
for device in prefs.devices:
    if device.type == 'CUDA':
        device.use = True
        print(f"Enabled: {device.name}")
```

## Style ferme de rendu (plusieurs serveurs)

Louez plusieurs serveurs et répartissez les images :

**Serveur 1 :**

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

**Serveur 2 :**

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

**Serveur 3 :**

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

Puis combinez les rendus localement.

## Rendu Eevee (plus rapide)

Pour une qualité temps réel :

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

## Prise en charge OptiX (GPU RTX)

Pour le traçage de rayons sur RTX :

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

## Script de rendu automatisé

**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 "Rendu terminé !"
ls -la $OUTPUT_DIR
```

Utilisation :

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

## Surveillance de la progression du rendu

### Surveiller le dossier de sortie

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

### Sortie Blender

Blender affiche la progression des images sur stdout :

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

## Télécharger les images rendues

```bash

# Télécharger toutes les images
scp -P <port> -r root@<proxy>:/workspace/output/ ./renders/

# Télécharger des images spécifiques
scp -P <port> root@<proxy>:/workspace/output/frame_001.png ./

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

## Encodage vidéo

Après le rendu des images, encodez en vidéo :

```bash

# Installer ffmpeg
apt-get install -y ffmpeg

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

# Encoder en ProRes (haute qualité)
ffmpeg -framerate 24 -i /workspace/output/frame_%03d.png -c:v prores_ks -profile:v 3 output.mov
```

## Conseils de performance

### Optimiser pour la vitesse

```python

# Réduire les échantillons pour l'aperçu
bpy.context.scene.cycles.samples = 64

# Utiliser l'échantillonnage adaptatif
bpy.context.scene.cycles.use_adaptive_sampling = True
bpy.context.scene.cycles.adaptive_threshold = 0.01

# Limiter les rebonds
bpy.context.scene.cycles.max_bounces = 8
```

### Optimisation de la mémoire

```python

# Utiliser le rendu en tuiles pour les hautes résolutions
bpy.context.scene.render.use_persistent_data = True

# Définir la taille des tuiles
bpy.context.scene.cycles.tile_size = 256  # Pour GPU
```

## Estimations du temps de rendu

| Scène      | GPU      | Résolution | Échantillons | Temps/image |
| ---------- | -------- | ---------- | ------------ | ----------- |
| Simple     | RTX 3090 | 1080p      | 128          | \~30s       |
| Moyen      | RTX 3090 | 1080p      | 256          | \~2min      |
| Complexe   | RTX 4090 | 4K         | 512          | \~10min     |
| Production | A100     | 4K         | 1024         | \~20min     |

## Calcul du coût

**Exemple : animation de 250 images**

```
GPU : RTX 4090
Temps par image : 2 minutes
Temps total de rendu : 500 minutes = 8,3 heures
Tarif horaire : 0,04 $
Coût total : ~0,33 $
```

## Dépannage

### "Périphérique CUDA introuvable"

```python

# Vérifier les périphériques 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" %}
**Mémoire insuffisante**
{% endhint %}

* Réduire la résolution des textures
* Utiliser une taille de tuile plus petite
* Activer "persistent data"
* Utiliser des shaders plus simples

### Rendu lent

* Vérifier que le GPU est utilisé (nvidia-smi)
* Optimiser la géométrie de la scène
* Utiliser le débruitage avec moins d'échantillons

## Prochaines étapes

* Exécuter Jupyter pour le post-traitement
* [Génération vidéo IA](/guides/guides_v2-fr/generation-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-fr/autres-charges-de-travail/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.