Sunshine + Moonlight Remote-Gaming

Streamen und spielen Sie PC-Spiele aus der Ferne mit nahezu null Latenz mit Sunshine (Host) und Moonlight (Client) auf den GPU-betriebenen Servern von Clore.ai.

Sunshine ist ein Open-Source-, selbst gehosteter Game-Streaming-Server mit über 20.000 GitHub-Sternen. Moonlight ist der kostenlose Open-Source-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. Er erfasst Ihre GPU-Ausgabe, kodiert sie in Echtzeit mit H.264/H.265/AV1 und streamt sie mit extrem geringer 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.) zum Spotpreis

• AAA-Spiele streamen aus der Cloud auf jedes Gerät — sogar auf einen günstigen Laptop

• Kein GeForce-NOW-Abonnement erforderlich — Sie kontrollieren die Hardware

• Game-Modding, KI-gestütztes Gameplay, oder Tests der Spieleentwicklung auf leistungsstarker Hardware

---

Voraussetzungen

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

---

Schritt 1: GPU-Server auf Clore.ai mieten

1. Gehe zu clore.ai → Marktplatz

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

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

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

Portanforderungen: Sunshine benötigt die Ports 47990 (HTTPS-Weboberfläche) und 48010 (Streaming). Stellen Sie sicher, dass diese vor der Bestellung in den verfügbaren Ports des Servers aufgeführt sind.

Empfohlene GPU für 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: Sunshine per Docker bereitstellen

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

# Abrufen und starten
docker compose up -d

# Protokolle prüfen
docker compose logs -f sunshine

# Prüfen, ob es läuft
docker ps | grep sunshine

Erster Start: Sunshine benötigt etwa 30 Sekunden zum Initialisieren. Achten Sie in den Protokollen auf "Sunshine started successfully", bevor Sie fortfahren.

Einzelner Docker-Befehl (Schnellstart)

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: Sunshine-Weboberfläche konfigurieren

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

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

2. Die Warnung vor dem selbstsignierten Zertifikat akzeptieren

3. Melden Sie sich mit den von Ihnen festgelegten Zugangsdaten an (admin / your_secure_password)

Nur HTTPS: Die Weboberfläche von Sunshine läuft über HTTPS. Ihr Browser zeigt eine Zertifikatswarnung an — das ist normal. Klicken Sie auf "Erweitert" → "Fortfahren", um fortzufahren.

Abschnitte der Weboberfläche

Bereich	Zweck
PIN	Mit Moonlight-Client koppeln
Anwendungen	Streambare Apps/Spiele definieren
Konfiguration	Encoder-, Auflösungs- und Bitrate-Einstellungen
Protokolle	Streaming-Probleme debuggen

---

Schritt 4: Kodierungseinstellungen konfigurieren

Navigieren Sie zu Konfiguration → Video in der Weboberfläche:

Empfohlene Einstellungen für Clore.ai

# Encoder
encoder: nvenc          # NVIDIA-Hardwarekodierung verwenden

# Auflösung
resolution_width: 1920
resolution_height: 1080

# Bildrate
fps: 60

# Bitrate
bitrate: 50000          # 50 Mbit/s für 1080p60 — hervorragende Qualität

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

NVENC vs VAAPI: Auf NVIDIA-Servern von Clore.ai immer nvenc Encoder verwenden. Dadurch wird die Kodierung an die GPU-Hardware ausgelagert und die CPU für das Spiel selbst frei.

Bitraten-Leitfaden

Qualität	Auflösung	Bitrate
Gut	1080p60	20 Mbit/s
Großartig	1080p60	35 Mbit/s
Hervorragend	1080p60	50 Mbit/s
Großartig	1440p60	50 Mbit/s
Hervorragend	4K60	100+ Mbit/s

---

Schritt 5: Anwendungen zum Streamen hinzufügen

In der Sunshine-Weboberfläche → Anwendungen → Neu hinzufügen:

Beispiel: Desktop-Streaming

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

Beispiel: Steam-Spiel

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

Beispiel: Benutzerdefiniertes Spiel

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

---

Schritt 6: Virtuelles Display einrichten (Server ohne Monitor)

Clore.ai-Server sind headless (ohne physischen Monitor). Sie benötigen ein virtuelles Display:

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

# Virtuelles Display erstellen
Xvfb :1 -screen 0 1920x1080x24 &
export DISPLAY=:1

# Desktop-Umgebung starten
startxfce4 &

Oder ein Virtual-Framebuffer-Skript verwenden

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

export DISPLAY=:1

# Virtuelles Display 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 Anzeige: Fügen Sie Folgendes zu Ihrer Sunshine-Konfiguration hinzu, um die GPU ohne physische Anzeige zu verwenden:

export __GL_SYNC_TO_VBLANK=0
export __GL_GSYNC_ALLOWED=0

---

Schritt 7: Mit dem Moonlight-Client verbinden

Moonlight installieren

Plattform	Download
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 auf PC hinzufügen und geben Sie die IP Ihres Clore.ai-Servers ein

3. Moonlight zeigt einen PIN-Code

4. Gehen Sie zur Sunshine-Weboberfläche → PIN → PIN eingeben

5. Verbindung hergestellt! ✅

Moonlight-Einstellungen für das beste Erlebnis

Auflösung: 1920x1080
FPS: 60
Bitrate: 50 Mbit/s
Videocodec: HEVC (H.265)
Hardware-Dekodierung: aktiviert
Audio: Stereo

---

Schritt 8: Referenz für Portweiterleitung

Port	Protokoll	Zweck
22	TCP	SSH-Verwaltung
47984	TCP	HTTPS (GameStream-kompatibel)
47989	TCP	HTTP (GameStream-kompatibel)
47990	TCP	HTTPS-Weboberfläche
48010	TCP	RTSP (Streaming-Steuerung)
47998-48000	UDP	Video-/Audio-Streaming
48010	UDP	Video-Streaming

Clore.ai-Port-Mapping: Wenn Sie Ihren Server bestellen, stellen Sie sicher, dass die Ports 47990 und 48010 in Ihrem Port-Mapping enthalten sind. UDP-Ports für Streaming (47998-48000) sollten nach Möglichkeit ebenfalls verfügbar sein.

---

Fehlerbehebung

Sunshine startet nicht

# Container-Logs prüfen
docker logs sunshine --tail 50

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

Schwarzer Bildschirm beim Streaming

# Prüfen, ob das virtuelle Display läuft
export DISPLAY=:1
xdpyinfo | grep dimensions

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

Hohe Latenz

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

• Bitrate in den Moonlight-Einstellungen reduzieren

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

• Aktiviere Frame-Pacing in der Sunshine-Konfiguration

NVENC-Fehler: "No encoder found"

# Prüfen, ob die NVIDIA-GPU zugänglich ist
nvidia-smi

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

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

Authentifizierungs-/Kopplungsprobleme

# Sunshine-Zugangsdaten 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 das Netzwerk

PulseAudio-Virtual-Sink installieren:

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

Gamecontroller-Unterstützung

Sunshine unterstützt virtuelle Gamepad-Emulation. In der Konfiguration aktivieren:

[input]
gamepad = enabled
ds4_back_as_touchpad_click = disabled

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

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

---

Kostenoptimierung

Berechnen Sie Ihre Streaming-Kosten

GPU-Miete: 0,05–0,19 $/Std. (RTX 3080)
Speicher: ca. 0,01 $/Stunde (50 GB SSD)
Gesamt: ca. 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 Geldsparen

1. Spot-Instanzen: Verwenden Sie außerhalb der Stoßzeiten die günstigste verfügbare GPU

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

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

4. Automatisches Herunterfahren: Fügen Sie ein Skript hinzu, das den Server nach Inaktivität stoppt

# Automatisches Herunterfahren nach 30 Minuten 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 "30 Minuten lang keine Verbindungen, fahre herunter"
    docker stop sunshine
    break
  fi
  sleep 60
done

---

Bewährte Sicherheitspraktiken

Stellen Sie Sunshine niemals ohne Authentifizierung offen ins Netz! Verwenden Sie immer ein starkes Passwort und erwägen Sie für zusätzliche Sicherheit die Nutzung eines VPN oder SSH-Tunnels.

SSH-Tunnel-Methode (am sichersten)

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

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

Standard-Zugangsdaten ä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

---

Leistungsbenchmarks

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 Mbit/s

---

Nützliche Links

• Sunshine auf GitHub — über 20.000 Sterne

• Offizielle Moonlight-Website

• Sunshine-Dokumentation

• LizardByte Discord

• Clore.ai-Marktplatz

---

Zusammenfassung

Schritt	Aktion
1	GPU-Server mit den Ports 22, 47990 und 48010 mieten
2	Bereitstellen lizardbyte/sunshine über Docker
3	Konfigurieren Sie über die Weboberfläche unter https://IP:47990
4	NVENC-Encoder, 50 Mbit/s Bitrate einstellen
5	Virtuelles Display erstellen (Xvfb)
6	Moonlight-Client lokal installieren
7	Per PIN-Code koppeln
8	Streamen und spielen! 🎮

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

---

GPU-Empfehlungen für Clore.ai

Anwendungsfall	Empfohlene GPU	Geschätzte Kosten bei Clore.ai
1080p/60 FPS-Streaming	RTX 3090 (24 GB)	0,07–0,21 $/GPU/Stunde
4K/Streaming mit hoher Bildwiederholrate	RTX 4090 (24 GB)	0,14–0,42 $/GPU/Stunde
AAA-Gaming + Streaming	RTX 4090 (24 GB)	0,14–0,42 $/GPU/Stunde

💡 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.