Blender-Rendering

GPU-beschleunigtes Blender-3D-Rendering auf Clore.ai

Rendern Sie 3D-Szenen und Animationen mit Blender auf CLORE.AI-GPUs.

Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über CLORE.AI-Marktplatz.

Mieten auf CLORE.AI

1. Besuchen CLORE.AI-Marktplatz

2. Filtern nach GPU-Typ, VRAM und Preis

3. Wähle On-Demand (Festpreis) oder Spot (Gebotspreis)

4. Konfiguriere deine Bestellung:

   • Docker-Image auswählen

   • Ports festlegen (TCP für SSH, HTTP für Web-UIs)

   • Bei Bedarf Umgebungsvariablen hinzufügen

   • Startbefehl eingeben

5. Zahlung auswählen: CLORE, BTC, oder USDT/USDC

6. Bestellung erstellen und auf die Bereitstellung warten

Greife auf deinen Server zu

• Verbindungsdetails finden in Meine Bestellungen

• Web-Oberflächen: Verwende die HTTP-Port-URL

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

Warum GPUs für Blender mieten?

• Komplexe Szenen 10-50x schneller rendern als mit der CPU

• Mehrere GPUs für noch schnelleres Rendern

• Keine Investition in teure Hardware nötig

• Nur für die Renderzeit zahlen

Anforderungen

Szenenkomplexität	Empfohlene GPU	VRAM
Einfach	RTX 3070	8 GB
Mittel	RTX 3090	24 GB
Komplex	RTX 4090	24 GB
Produktion	A100	40-80GB

Schnell bereitstellen

Docker-Image:

linuxserver/blender

Oder Headless-Rendering:

nytimes/blender:3.6-gpu-ubuntu22.04

Ports:

22/tcp
3000/http

Einrichtung für Headless-Rendering

Image:

nvidia/cuda:12.8.1-devel-ubuntu22.04

Befehl:

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

Auf deinen Dienst zugreifen

Nach der Bereitstellung findest du deine http_pub URL in Meine Bestellungen:

1. Gehe zu Meine Bestellungen Seite

2. Klicke auf deine Bestellung

3. Finde die http_pub URL (z. B. abc123.clorecloud.net)

Verwende https://YOUR_HTTP_PUB_URL anstelle von localhost in den folgenden Beispielen.

Ihr Projekt hochladen

Per SCP

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

# Projektordner hochladen
scp -P <port> -r ./project/ root@<proxy>:/workspace/

Per rsync (große Projekte)

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

Render-Befehle

Einzelbild

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

Animation (Frame-Bereich)

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

Bestimmte Frames

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

Render-Optionen

Auflösung

# Auflösung überschreiben
blender -b file.blend -o //output/frame_### -x 1920 -y 1080 -a -- --cycles-device CUDA

Python-Skript verwenden

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

render_setup.py:

import bpy

# Render-Engine festlegen
bpy.context.scene.render.engine = 'CYCLES'

# Gerät festlegen
bpy.context.preferences.addons['cycles'].preferences.compute_device_type = 'CUDA'

# Alle GPUs aktivieren
for device in bpy.context.preferences.addons['cycles'].preferences.devices:
    device.use = True

# Samples festlegen
bpy.context.scene.cycles.samples = 128

# Auflösung festlegen
bpy.context.scene.render.resolution_x = 1920
bpy.context.scene.render.resolution_y = 1080

# Ausgabeeinstellungen
bpy.context.scene.render.image_settings.file_format = 'PNG'

Multi-GPU-Rendering

Für Server mit mehreren GPUs:

import bpy

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

# Geräte aktualisieren
prefs.get_devices()

# Alle GPUs aktivieren
for device in prefs.devices:
    if device.type == 'CUDA':
        device.use = True
        print(f"Aktiviert: {device.name}")

Renderfarm-Stil (mehrere Server)

Mieten Sie mehrere Server und teilen Sie die Frames auf:

Server 1:

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

Server 2:

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

Server 3:

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

Dann die Renderings lokal zusammenführen.

Eevee-Rendering (schneller)

Für Echtzeitqualität:

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

OptiX-Unterstützung (RTX-GPUs)

Für RTX-Raytracing:

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

Automatisiertes Render-Skript

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 "Rendering abgeschlossen!"
ls -la $OUTPUT_DIR

Verwendung:

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

Render-Fortschritt überwachen

Ausgabeordner überwachen

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

Blender-Ausgabe

Blender gibt den Frame-Fortschritt auf stdout aus:

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

Gerenderte Frames herunterladen

# Alle Frames herunterladen
scp -P <port> -r root@<proxy>:/workspace/output/ ./renders/

# Bestimmte Frames herunterladen
scp -P <port> root@<proxy>:/workspace/output/frame_001.png ./

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

Video-Kodierung

Nach dem Rendern der Frames in Video kodieren:

# ffmpeg installieren
apt-get install -y ffmpeg

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

# In ProRes kodieren (hohe Qualität)
ffmpeg -framerate 24 -i /workspace/output/frame_%03d.png -c:v prores_ks -profile:v 3 output.mov

Leistungstipps

Für Geschwindigkeit optimieren

# Samples für die Vorschau reduzieren
bpy.context.scene.cycles.samples = 64

# Adaptives Sampling verwenden
bpy.context.scene.cycles.use_adaptive_sampling = True
bpy.context.scene.cycles.adaptive_threshold = 0.01

# Bounces begrenzen
bpy.context.scene.cycles.max_bounces = 8

Speicheroptimierung

# Für hohe Auflösung gekacheltes Rendering verwenden
bpy.context.scene.render.use_persistent_data = True

# Kachelgröße festlegen
bpy.context.scene.cycles.tile_size = 256  # Für GPU

Schätzungen der Renderzeit

Szene	GPU	Auflösung	Samples	Zeit/Frame
Einfach	RTX 3090	1080p	128	~30s
Mittel	RTX 3090	1080p	256	~2min
Komplex	RTX 4090	4K	512	~10min
Produktion	A100	4K	1024	~20min

Kostenberechnung

Beispiel: Animation mit 250 Frames

GPU: RTX 4090
Zeit pro Frame: 2 Minuten
Gesamte Renderzeit: 500 Minuten = 8,3 Stunden
Stundensatz: $0.04
Gesamtkosten: ~ $0.33

Fehlerbehebung

"CUDA-Gerät nicht gefunden"

# Verfügbare Geräte prüfen
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)

Speicher voll

• Texturauflösung reduzieren

• Kleinere Kachelgröße verwenden

• "persistent data" aktivieren

• Einfachere Shader verwenden

Langsames Rendern

• Prüfen, ob die GPU verwendet wird (nvidia-smi)

• Szenengeometrie optimieren

• Denoising mit weniger Samples verwenden

Nächste Schritte

• Jupyter für die Nachbearbeitung ausführen

• KI-Videogenerierung