Sunshine + Moonlight Remote Gaming

PC-Spiele remote streamen und spielen mit nahezu null Latenz, indem Sie Sunshine (Host) und Moonlight (Client) auf den GPU-basierten Servern von Clore.ai verwenden.

Sunshine ist ein Open-Source-, selbstgehosteter Game-Streaming-Server mit über 20.000 GitHub-Sternen. Moonlight ist der kostenlose, quelloffene Client, der sich damit verbindet. Zusammen konkurrieren sie mit GeForce NOW — zu einem Bruchteil der Kosten.

---

Was ist Sunshine + Moonlight?

Sunshine ist ein Fork des ursprünglichen Moonlight/GameStream-Stacks, jetzt vollständig unabhängig und aktiv von LizardByte gepflegt. Es erfasst Ihre GPU-Ausgabe, kodiert sie in Echtzeit mit H.264/H.265/AV1 und streamt sie mit ultraniedriger Latenz über das Netzwerk.

Moonlight ist die Client-App, die für Windows, macOS, Linux, Android, iOS, Raspberry Pi und sogar einige Smart-TVs verfügbar ist.

Warum auf Clore.ai verwenden?

• Mieten Sie eine High-End-GPU (RTX 4090, A100 usw.) zu Spot-Preisen

• Streamen Sie AAA-Spiele aus der Cloud auf jedes Gerät — sogar auf ein günstiges Laptop

• Keine GeForce NOW-Abo erforderlich — Sie kontrollieren die Hardware

• Game-Modding, KI-unterstütztes Gameplay, oder Spieletests/Entwicklung auf leistungsstarker Hardware

---

Voraussetzungen

Anforderung	Details
Clore.ai-Konto	Mit ausreichendem CLORE-Guthaben
GPU-Server	NVIDIA-GPU (für NVENC-Encoding) bevorzugt
Moonlight-Client	Auf Ihrem lokalen Gerät installiert
SSH-Zugriff	Für die anfängliche Einrichtung

---

Schritt 1: Mieten Sie einen GPU-Server auf Clore.ai

1. Gehe zu clore.ai → Marktplatz

2. Filtern nach GPU-Typ: RTX 3080 oder besser empfohlen für 1080p/60fps-Streaming

3. Suchen Sie nach Servern mit Ports 22, 47990, und 48010 verfügbar

4. Wählen Sie einen Server und fahren Sie mit der Bestellung fort

Port-Anforderungen: Sunshine benötigt die Ports 47990 (HTTPS Web-UI) und 48010 (Streaming). Stellen Sie sicher, dass diese in den verfügbaren Ports des Servers aufgeführt sind, bevor Sie bestellen.

Empfohlene GPU zum Streaming

Auflösung	Ziel-FPS	Minimale GPU
1080p	60 fps	RTX 3060
1440p	60 fps	RTX 3080
4K	60 fps	RTX 3090 / 4080
1080p	120 fps	RTX 4070+

---

Schritt 2: Deployen Sie Sunshine via Docker

Docker Compose (empfohlen)

Erstellen Sie eine Datei docker-compose.yml:

version: "3.8"

services:
  sunshine:
    image: lizardbyte/sunshine:latest
    container_name: sunshine
    restart: unless-stopped
    privileged: true
    network_mode: host
    environment:
      - PUID=1000
      - PGID=1000
      - TZ=UTC
      - SUNSHINE_USERNAME=admin
      - SUNSHINE_PASSWORD=your_secure_password
    volumes:
      - ./sunshine-config:/config
      - /tmp/.X11-unix:/tmp/.X11-unix:rw
      - /dev/dri:/dev/dri
    devices:
      - /dev/dri:/dev/dri
    deploy:
      resources:
        reservations:
          devices:
            - driver: nvidia
              count: all
              capabilities: [gpu]

Starten Sie den Container

# Herunterziehen und starten
docker compose up -d

# Logs prüfen
docker compose logs -f sunshine

# Überprüfen, ob er läuft
docker ps | grep sunshine

Erster Start: Sunshine benötigt ~30 Sekunden zur Initialisierung. Überwachen Sie die Logs auf "Sunshine started successfully", bevor Sie fortfahren.

Einzelner Docker-Befehl (Quick Start)

docker run -d \
  --name sunshine \
  --restart unless-stopped \
  --privileged \
  --network host \
  -e SUNSHINE_USERNAME=admin \
  -e SUNSHINE_PASSWORD=changeme \
  -v $(pwd)/sunshine-config:/config \
  -v /tmp/.X11-unix:/tmp/.X11-unix \
  --device /dev/dri:/dev/dri \
  --gpus all \
  lizardbyte/sunshine:latest

---

Schritt 3: Konfigurieren Sie die Sunshine Web-UI

1. Öffnen Sie Ihren Browser und navigieren Sie zu:

   https://<your-clore-server-ip>:47990

2. Akzeptieren Sie die Warnung zum selbstsignierten Zertifikat

3. Melden Sie sich mit den von Ihnen gesetzten Anmeldedaten an (admin / your_secure_password)

Nur HTTPS: Die Web-UI von Sunshine läuft über HTTPS. Ihr Browser wird eine Zertifikatswarnung anzeigen — das ist erwartet. Klicken Sie auf "Erweitert" → "Trotzdem fortfahren", um fortzufahren.

Web-UI-Bereiche

Abschnitt	Zweck
PIN	Mit Moonlight-Client koppeln
Anwendungen	Definieren Sie streambare Apps/Spiele
Konfiguration	Encoder-, Auflösungs- und Bitrate-Einstellungen
Logs	Streaming-Probleme debuggen

---

Schritt 4: Konfigurieren Sie die Encoding-Einstellungen

Navigieren Sie zu Konfiguration → Video in der Web-UI:

Empfohlene Einstellungen für Clore.ai

# Encoder
encoder: nvenc          # NVIDIA-Hardwareencoding verwenden

# Auflösung
resolution_width: 1920
resolution_height: 1080

# Bildrate
fps: 60

# Bitrate
bitrate: 50000          # 50 Mbps für 1080p60 — ausgezeichnete Qualität

# H.265 (bessere Kompression, verwenden, wenn der Client es unterstützt)
codec: hevc

NVENC vs VAAPI: Auf Clore.ai NVIDIA-Servern verwenden Sie immer nvenc Encoder. Er lagert das Encoding an die GPU-Hardware aus und entlastet die CPU für das Spiel selbst.

Bitrate-Leitfaden

Qualität	Auflösung	Bitrate
Gut	1080p60	20 Mbps
Sehr gut	1080p60	35 Mbps
Ausgezeichnet	1080p60	50 Mbps
Sehr gut	1440p60	50 Mbps
Ausgezeichnet	4K60	100+ Mbps

---

Schritt 5: Anwendungen zum Streamen hinzufügen

In der Sunshine Web-UI → Anwendungen → Neu hinzufügen:

Beispiel: Desktop-Streaming

Name: Desktop
Befehl: (leer lassen für kompletten Desktop)
Arbeitsverzeichnis: /home/user

Beispiel: Steam-Spiel

Name: Steam Big Picture
Befehl: steam -bigpicture
Arbeitsverzeichnis: /home/user
Detach-Befehl: (leer)

Beispiel: Eigenes Spiel

Name: Mein Spiel
Befehl: /opt/games/mygame/start.sh
Arbeitsverzeichnis: /opt/games/mygame
Bild: /opt/games/mygame/cover.png

---

Schritt 6: Einrichten einer virtuellen Anzeige (Headless-Server)

Clore.ai-Server sind headless (kein physischer Monitor). Sie benötigen eine virtuelle Anzeige:

# Virtuellen Anzeigetreiber installieren
apt-get update && apt-get install -y xvfb x11vnc xfce4

# Virtuelle Anzeige erstellen
Xvfb :1 -screen 0 1920x1080x24 &
export DISPLAY=:1

# Desktop-Umgebung starten
startxfce4 &

Oder verwenden Sie ein Virtual Framebuffer-Skript

#!/bin/bash
# start-display.sh

export DISPLAY=:1

# Virtuelle Anzeige starten
Xvfb :1 -screen 0 1920x1080x24 -ac +extension GLX +render -noreset &
sleep 2

# Window-Manager starten
openbox &
sleep 1

# Sunshine starten
docker compose up -d sunshine

Machen Sie es ausführbar und führen Sie es aus:

chmod +x start-display.sh
./start-display.sh

NVIDIA-GPU ohne Display: Fügen Sie Folgendes zu Ihrer Sunshine-Konfiguration hinzu, um die GPU ohne physischen Display zu verwenden:

export __GL_SYNC_TO_VBLANK=0
export __GL_GSYNC_ALLOWED=0

---

Schritt 7: Verbinden Sie sich mit dem Moonlight-Client

Moonlight installieren

Plattform	Herunterladen
Windows	moonlight-stream.org
macOS	Mac App Store oder moonlight-stream.org
Linux	flatpak install flathub com.moonlight_stream.Moonlight
Android	Google Play Store
iOS	App Store
Raspberry Pi	apt install moonlight-embedded

Moonlight mit Sunshine koppeln

1. Öffnen Sie Moonlight auf Ihrem lokalen Gerät

2. Klicken Sie PC hinzufügen und geben Sie die IP Ihres Clore.ai-Servers ein

3. Moonlight zeigt einen PIN-Code

4. Gehen Sie zur Sunshine Web-UI → PIN → geben Sie den PIN ein

5. Verbindung hergestellt! ✅

Moonlight-Einstellungen für das beste Erlebnis

Auflösung: 1920x1080
FPS: 60
Bitrate: 50 Mbps
Videocodec: HEVC (H.265)
Hardware-Decoding: Aktiviert
Audio: Stereo

---

Schritt 8: Port-Forwarding-Referenz

Port	Protokoll	Zweck
22	TCP	SSH-Verwaltung
47984	TCP	HTTPS (GameStream-Kompatibilität)
47989	TCP	HTTP (GameStream-Kompatibilität)
47990	TCP	HTTPS Web-UI
48010	TCP	RTSP (Streaming-Steuerung)
47998-48000	UDP	Video/Audio-Streaming
48010	UDP	Video-Streaming

Clore.ai Portzuordnung: Beim Bestellen Ihres Servers stellen Sie sicher, dass die Ports 47990 und 48010 in Ihrer Portkarte enthalten sind. UDP-Ports für Streaming (47998-48000) sollten nach Möglichkeit ebenfalls verfügbar sein.

---

Fehlerbehebung

Sunshine startet nicht

# Überprüfen Sie die Container-Logs
docker logs sunshine --tail 50

# Häufige Lösung: Berechtigungen
chmod 777 /tmp/.X11-unix
xhost +local:docker

Schwarzer Bildschirm beim Streaming

# Überprüfen Sie, ob die virtuelle Anzeige läuft
export DISPLAY=:1
xdpyinfo | grep dimensions

# Anzeige neu starten
pkill Xvfb
Xvfb :1 -screen 0 1920x1080x24 &

Hohe Latenz

• Wechseln Sie von WLAN zu Ethernet auf der Client-Seite

• Reduzieren Sie die Bitrate in den Moonlight-Einstellungen

• Verwende H.265 anstelle von H.264 (bessere Kompression bei gleicher Qualität)

• Aktivieren Sie Frame Pacing in der Sunshine-Konfiguration

NVENC-Fehler: "Kein Encoder gefunden"

# Überprüfen Sie, ob die NVIDIA-GPU zugänglich ist
nvidia-smi

# Prüfen Sie, ob der Container GPU-Zugriff hat
docker exec sunshine nvidia-smi

# Falls nicht, starten Sie mit dem --gpus all Flag neu
docker stop sunshine && docker rm sunshine
# Erneut mit --gpus all ausführen

Authentifizierungs-/Koppelungsprobleme

# Sunshine-Anmeldeinformationen zurücksetzen
docker exec sunshine sunshine --creds admin newpassword

# Gekoppelte Clients löschen
rm -f ./sunshine-config/sunshine_state.json
docker restart sunshine

---

Erweiterte Konfiguration

Unterstützung für mehrere Monitore

# In der Sunshine-Konfiguration (sunshine.conf)
[video]
adapter_name = /dev/dri/card0
output_name = HDMI-A-1

Audio über Netzwerk

Installieren Sie PulseAudio Virtual Sink:

apt-get install -y pulseaudio
pulseaudio --daemon
pactl load-module module-null-sink sink_name=virtual_sink
export PULSE_SERVER=unix:/run/user/1000/pulse/native

Unterstützung für Gamecontroller

Sunshine unterstützt virtuelle Gamepad-Emulation. Aktivieren Sie es in der Konfiguration:

[input]
gamepad = enabled
ds4_back_as_touchpad_click = disabled

Wake-on-LAN (für persistente Server)

# Server am Leben halten, auch wenn nicht gestreamt wird
docker update --restart=always sunshine

---

Kostenoptimierung

Berechnen Sie Ihre Streaming-Kosten

GPU-Miete: ~$0.30-0.80/Stunde (RTX 3080)
Speicher: ~$0.01/Stunde (50GB SSD)
Gesamt: ~$0.31-0.81/Stunde

vs GeForce NOW: $9.99-$19.99/Monat (begrenzte Stunden)
vs Xbox Cloud Gaming: $14.99/Monat (begrenzter Katalog)

Tipps zum Sparen

1. Spot-Instanzen: Verwenden Sie die günstigste verfügbare GPU in Nebenzeiten

2. Pausieren, wenn nicht gespielt wird: Stoppen Sie den Container, aber behalten Sie das Volume

3. Spiele vorinstallieren: Verwenden Sie ein persistentes Volume, damit Sie nicht jedes Mal neu herunterladen müssen

4. Automatisches Herunterfahren: Fügen Sie ein Skript hinzu, um den Server nach Inaktivität zu stoppen

# Automatisches Herunterfahren nach 30 Min. ohne Moonlight-Verbindung
#!/bin/bash
while true; do
  connections=$(ss -tn | grep 47990 | wc -l)
  if [ "$connections" -eq 0 ]; then
    idle_count=$((idle_count + 1))
  else
    idle_count=0
  fi
  if [ "$idle_count" -ge 30 ]; then
    echo "Keine Verbindungen für 30 Min., fahre herunter"
    docker stop sunshine
    break
  fi
  sleep 60
done

---

Sicherheits-Best-Practices

Öffnen Sie Sunshine niemals ohne Authentifizierung! Setzen Sie stets ein starkes Passwort und ziehen Sie die Verwendung eines VPNs oder SSH-Tunnels für zusätzliche Sicherheit in Betracht.

SSH-Tunnel-Methode (am sichersten)

# Erstellen Sie auf Ihrer lokalen Maschine einen SSH-Tunnel
ssh -L 47990:localhost:47990 \
    -L 48010:localhost:48010 \
    root@<clore-server-ip>

# Verbinden Sie Moonlight dann mit localhost statt der Server-IP

Standard-Anmeldedaten ändern

docker exec sunshine sunshine --creds admin 'Y0urStr0ngP@ssw0rd!'

Zugriff nach IP einschränken

In der Sunshine-Konfiguration:

allowed_ips = 192.168.1.0/24,203.0.113.5

---

Leistungs-Benchmarks

GPU	Auflösung	FPS	Latenz	Encoder
RTX 3060	1080p	60	~15ms	NVENC
RTX 3080	1440p	60	~12ms	NVENC
RTX 4080	4K	60	~10ms	NVENC AV1
RTX 4090	4K	120	~8ms	NVENC AV1

Latenz gemessen bei einer lokalen Netzwerkverbindung mit 100 Mbps

---

Nützliche Links

• Sunshine GitHub — 20K+ Sterne

• Moonlight Offizielle Seite

• Sunshine Dokumentation

• LizardByte Discord

• Clore.ai Marketplace

---

Zusammenfassung

Schritt	Aktion
1	Mieten Sie einen GPU-Server mit den Ports 22, 47990, 48010
2	Deployen lizardbyte/sunshine via Docker
3	Konfigurieren über die Web-UI unter https://IP:47990
4	NVENC-Encoder einstellen, 50 Mbps Bitrate
5	Virtuelle Anzeige erstellen (Xvfb)
6	Installieren Sie den Moonlight-Client lokal
7	Mit PIN koppeln
8	Streamen und spielen! 🎮

Mit Sunshine + Moonlight auf Clore.ai erhalten Sie ein Cloud-Gaming-Erlebnis, das jedem kommerziellen Dienst Konkurrenz macht — mit voller Kontrolle über Ihre Hardware und Spiele. Keine Abos, keine Einschränkungen, keine Limits.

---

Clore.ai GPU-Empfehlungen

Anwendungsfall	Empfohlene GPU	Geschätzte Kosten auf Clore.ai
1080p/60fps-Streaming	RTX 3090 (24GB)	~$0.12/gpu/hr
4K/High-Refresh-Streaming	RTX 4090 (24GB)	~$0.70/gpu/hr
AAA-Gaming + Streaming	RTX 4090 (24GB)	~$0.70/gpu/hr

💡 Alle Beispiele in diesem Leitfaden können bereitgestellt werden auf Clore.ai GPU-Servern. Durchsuchen Sie verfügbare GPUs und mieten Sie stundenweise — keine Verpflichtungen, voller Root-Zugriff.