Rendu Blender

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

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

Tous les exemples peuvent être exécutés sur des serveurs GPU loués via la place de marché CLORE.AI.

Louer sur CLORE.AI

1. Visitez la place de marché CLORE.AI

2. Filtrez par type de GPU, VRAM et prix

3. Choisissez À 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@<proxy-address>

Pourquoi louer des GPU pour Blender ?

• Rendez des scènes complexes 10 à 50 fois plus vite qu'avec le CPU

• Plusieurs GPU pour un rendu encore plus rapide

• Pas besoin d'investir dans du matériel coûteux

• Payez uniquement le temps de rendu

Exigences

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

Déploiement rapide

Image Docker :

linuxserver/blender

Ou rendu sans interface graphique :

nytimes/blender:3.6-gpu-ubuntu22.04

Ports :

22/tcp
3000/http

Configuration du rendu sans interface graphique

Image :

nvidia/cuda:12.8.1-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. Accédez à Mes commandes la page

2. Cliquez sur votre commande

3. Trouvez le http_pub URL (par ex., abc123.clorecloud.net)

Utilisez https://YOUR_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 (grands projets)

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 le nombre d'é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"Activé : {device.name}")

Rendu en ferme (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é en temps réel :

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

Prise en charge d'OptiX (GPU RTX)

Pour le ray tracing 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

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 de Blender

Blender affiche la progression des images sur stdout :

Fra:1 Mem:1234.56M (Pic 1500.00M) | Temps:00:01.23 | Restant:04:32.10 | Mem:567.89M, Pic:890.12M | Scène, Couche de vue | Échantillon 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-les 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 le nombre d'é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 par tuiles pour la haute résolution
bpy.context.scene.render.use_persistent_data = True

# Définir la taille des tuiles
bpy.context.scene.cycles.tile_size = 256  # Pour le 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	~2 min
Complexe	RTX 4090	4K	512	~10 min
Production	A100	4K	1024	~20 min

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 les « données persistantes »

• 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

Étapes suivantes

• Exécuter Jupyter pour le post-traitement

• Génération vidéo par IA