> For the complete documentation index, see [llms.txt](https://docs.clore.ai/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.clore.ai/guides/guides_v2-de/andere-workloads/blender-rendering.md).

# Blender-Rendering

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

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

{% hint style="success" %}
Alle Beispiele können auf GPU-Servern ausgeführt werden, die gemietet wurden über [CLORE.AI-Marktplatz](https://clore.ai/marketplace).
{% endhint %}

## Mieten auf CLORE.AI

1. Besuchen [CLORE.AI-Marktplatz](https://clore.ai/marketplace)
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:**

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

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

```bash

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

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

## Render-Befehle

### Einzelbild

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

### Animation (Frame-Bereich)

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

### Bestimmte Frames

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

## Render-Optionen

### Auflösung

```bash

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

### Python-Skript verwenden

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

**render\_setup.py:**

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

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

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

**Server 2:**

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

**Server 3:**

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

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

## OptiX-Unterstützung (RTX-GPUs)

Für RTX-Raytracing:

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

## Automatisiertes Render-Skript

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

Verwendung:

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

## Render-Fortschritt überwachen

### Ausgabeordner überwachen

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

```bash

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

```bash

# 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

```python

# 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

```python

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

```python

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

{% hint style="danger" %}
**Speicher voll**
{% endhint %}

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


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## 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, and the optional `goal` query parameter:

```
GET https://docs.clore.ai/guides/guides_v2-de/andere-workloads/blender-rendering.md?ask=<question>&goal=<endgoal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.