Rendu Blender

Rendu 3D Blender accéléré par GPU sur Clore.ai

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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via CLORE.AI Marketplace.

Location sur CLORE.AI

1. Visitez 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 :

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

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

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

Commandes de rendu

Image unique

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

Animation (plage d'images)

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

Images spécifiques

/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

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

Utiliser un script Python

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

render_setup.py :

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 :

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 :

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

Serveur 2 :

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

Serveur 3 :

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 :

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 :

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

Script de rendu automatisé

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

Utilisation :

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

Surveillance de la progression du rendu

Surveiller le dossier de sortie

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

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

# 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

# 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

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

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

Mémoire insuffisante

• 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