Jeu à distance Sunshine + Moonlight

Diffusez et jouez à des jeux PC à distance avec une latence quasi nulle en utilisant Sunshine (hôte) et Moonlight (client) sur les serveurs GPU de Clore.ai.

Sunshine est un serveur de streaming de jeux open-source et auto-hébergé avec plus de 20 000 étoiles sur GitHub. Moonlight est le client gratuit et open-source qui s'y connecte. Ensemble, ils rivalisent avec GeForce NOW — à une fraction du coût.

---

Qu'est-ce que Sunshine + Moonlight ?

Sunshine est un fork de la pile originale Moonlight/GameStream, désormais entièrement indépendant et activement maintenu par LizardByte. Il capture la sortie GPU, l'encode en temps réel en H.264/H.265/AV1 et la diffuse sur le réseau avec une latence ultra-faible.

Moonlight est l'application cliente disponible pour Windows, macOS, Linux, Android, iOS, Raspberry Pi et même certaines smart TV.

Pourquoi l'utiliser sur Clore.ai ?

• Louez un GPU haut de gamme (RTX 4090, A100, etc.) à prix spot

• Diffusez des jeux AAA depuis le cloud vers n'importe quel appareil — même un ordinateur portable bon marché

• Aucun abonnement GeForce NOW n'est nécessaire — vous contrôlez le matériel

• Modding de jeux, jeu assisté par IA, ou tests de développement de jeux sur du matériel puissant

---

Prérequis

Exigence	Détails
Compte Clore.ai	Avec un solde CLORE suffisant
serveur GPU	GPU NVIDIA (préféré pour l'encodage NVENC)
Client Moonlight	Installé sur votre appareil local
Accès SSH	Pour la configuration initiale

---

Étape 1 : Louez un serveur GPU sur Clore.ai

1. Aller à clore.ai → Place de marché

2. Filtrer par Type de GPU: RTX 3080 ou meilleur recommandé pour le streaming 1080p/60fps

3. Recherchez des serveurs avec des ports 22, 47990, et 48010 disponibles

4. Sélectionnez un serveur et passez la commande

Exigences de ports: Sunshine nécessite les ports 47990 (interface web HTTPS) et 48010 (streaming). Assurez-vous qu'ils sont listés dans les ports disponibles du serveur avant la commande.

GPU recommandé pour le streaming

Résolution	FPS ciblés	GPU minimum
1080p	60 fps	RTX 3060
1440p	60 fps	RTX 3080
4K	60 fps	RTX 3090 / 4080
1080p	120 fps	RTX 4070+

---

Étape 2 : Déployez Sunshine via Docker

Docker Compose (recommandé)

Créez un fichier 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]

Démarrez le conteneur

# Récupérer et démarrer
docker compose up -d

# Vérifier les logs
docker compose logs -f sunshine

# Vérifiez qu'il fonctionne
docker ps | grep sunshine

Premier démarrage: Sunshine met ~30 secondes à s'initialiser. Surveillez les logs pour "Sunshine started successfully" avant de continuer.

Commande Docker unique (démarrage rapide)

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

---

Étape 3 : Configurez l'interface web de Sunshine

1. Ouvrez votre navigateur et rendez-vous sur :

   https://<votre-ip-serveur-clore> :47990

2. Acceptez l'avertissement de certificat auto-signé

3. Connectez-vous avec les identifiants que vous avez définis (admin / your_secure_password)

HTTPS uniquement : L'interface web de Sunshine fonctionne en HTTPS. Votre navigateur affichera un avertissement de certificat — c'est normal. Cliquez sur "Avancé" → "Continuer" pour poursuivre.

Sections de l'interface web

Section	Usage
Pin	Appairer avec le client Moonlight
Applications	Définir les applications/jeux diffusables
Configuration	Paramètres d'encodeur, résolution, débit binaire
Logs	Déboguez les problèmes de streaming

---

Étape 4 : Configurez les paramètres d'encodage

Naviguez vers Configuration → Vidéo dans l'interface web :

Paramètres recommandés pour Clore.ai

# Encodeur
encoder : nvenc          # Utilisez l'encodage matériel NVIDIA

# Résolution
resolution_width : 1920
resolution_height : 1080

# Fréquence d'images
fps : 60

# Débit binaire
bitrate : 50000          # 50 Mbps pour 1080p60 — excellente qualité

# H.265 (meilleure compression, à utiliser si le client le prend en charge)
codec : hevc

NVENC vs VAAPI : Sur les serveurs NVIDIA de Clore.ai, utilisez toujours nvenc encodeur. Il délègue l'encodage au matériel GPU, libérant le CPU pour le jeu lui-même.

Guide de débit binaire

Qualité	Résolution	Débit binaire
Bonne	1080p60	20 Mbps
Excellent	1080p60	35 Mbps
Excellente	1080p60	50 Mbps
Excellent	1440p60	50 Mbps
Excellente	4K60	100+ Mbps

---

Étape 5 : Ajoutez des applications à diffuser

Dans l'interface web Sunshine → Applications → Ajouter nouveau:

Exemple : Diffusion du bureau

Nom : Desktop
Commande : (laisser vide pour le bureau complet)
Répertoire de travail : /home/user

Exemple : Jeu Steam

Nom : Steam Big Picture
Commande : steam -bigpicture
Répertoire de travail : /home/user
Commande de détachement : (vide)

Exemple : Jeu personnalisé

Nom : My Game
Commande : /opt/games/mygame/start.sh
Répertoire de travail : /opt/games/mygame
Image : /opt/games/mygame/cover.png

---

Étape 6 : Configurez un affichage virtuel (serveur sans tête)

Les serveurs Clore.ai sont headless (pas d'écran physique). Vous avez besoin d'un affichage virtuel :

# Installez le pilote d'affichage virtuel
apt-get update && apt-get install -y xvfb x11vnc xfce4

# Créez un affichage virtuel
Xvfb :1 -screen 0 1920x1080x24 &
export DISPLAY=:1

# Démarrez l'environnement de bureau
startxfce4 &

Ou utilisez un script de framebuffer virtuel

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

export DISPLAY=:1

# Démarrer l'affichage virtuel
Xvfb :1 -screen 0 1920x1080x24 -ac +extension GLX +render -noreset &
sleep 2

# Démarrer le gestionnaire de fenêtres
openbox &
sleep 1

# Démarrer Sunshine
docker compose up -d sunshine

Rendez-le exécutable et lancez :

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

GPU NVIDIA sans écran : Ajoutez ce qui suit à votre configuration Sunshine pour utiliser le GPU sans écran physique :

export __GL_SYNC_TO_VBLANK=0
export __GL_GSYNC_ALLOWED=0

---

Étape 7 : Connectez-vous avec le client Moonlight

Installez Moonlight

Plateforme	Télécharger
Windows	moonlight-stream.org
macOS	Mac App Store ou moonlight-stream.org
Linux	flatpak install flathub com.moonlight_stream.Moonlight
Android	Google Play Store
iOS	App Store
Raspberry Pi	apt install moonlight-embedded

Appairez Moonlight avec Sunshine

1. Ouvrez Moonlight sur votre appareil local

2. Cliquez Ajouter un PC et saisissez l'IP de votre serveur Clore.ai

3. Moonlight affichera un code PIN

4. Allez dans l'interface web Sunshine → Pin → saisissez le PIN

5. Connexion établie ! ✅

Paramètres Moonlight pour la meilleure expérience

Résolution : 1920x1080
FPS : 60
Débit binaire : 50 Mbps
Codec vidéo : HEVC (H.265)
Décodage matériel : Activé
Audio : Stéréo

---

Étape 8 : Référence du transfert de ports

Port	Protocole	Usage
22	TCP	Gestion SSH
47984	TCP	HTTPS (compatibilité GameStream)
47989	TCP	HTTP (compatibilité GameStream)
47990	TCP	Interface Web HTTPS
48010	TCP	RTSP (contrôle du streaming)
47998-48000	UDP	Streaming vidéo/audio
48010	UDP	Streaming vidéo

Mappage de ports Clore.ai : Lors de la commande de votre serveur, assurez-vous que les ports 47990 et 48010 figurent dans votre carte de ports. Les ports UDP pour le streaming (47998-48000) devraient également être disponibles si possible.

---

Dépannage

Sunshine ne démarre pas

# Vérifiez les logs du conteneur
docker logs sunshine --tail 50

# Correctif courant : permissions
chmod 777 /tmp/.X11-unix
xhost +local:docker

Écran noir lors du streaming

# Vérifiez que l'affichage virtuel fonctionne
export DISPLAY=:1
xdpyinfo | grep dimensions

# Redémarrez l'affichage
pkill Xvfb
Xvfb :1 -screen 0 1920x1080x24 &

Latence élevée

• Passez de Wi‑Fi à Ethernet sur le côté client

• Réduisez le débit binaire dans les paramètres Moonlight

• Utilisez H.265 au lieu de H.264 (meilleure compression pour la même qualité)

• Activer Pacing des images dans la config Sunshine

Erreur NVENC : "No encoder found"

# Vérifiez que le GPU NVIDIA est accessible
nvidia-smi

# Vérifiez que le conteneur a accès au GPU
docker exec sunshine nvidia-smi

# Si non, redémarrez avec le flag --gpus all
docker stop sunshine && docker rm sunshine
# Relancer avec --gpus all

Problèmes d'authentification/appairage

# Réinitialisez les identifiants Sunshine
docker exec sunshine sunshine --creds admin newpassword

# Supprimez les clients appariés
rm -f ./sunshine-config/sunshine_state.json
docker restart sunshine

---

Configuration avancée

Support multi-écran

# Dans la config Sunshine (sunshine.conf)
[video]
adapter_name = /dev/dri/card0
output_name = HDMI-A-1

Audio sur le réseau

Installez un sink virtuel PulseAudio :

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

Support des manettes de jeu

Sunshine prend en charge l'émulation de gamepad virtuel. Activez dans la config :

[input]
gamepad = enabled
ds4_back_as_touchpad_click = disabled

Wake-on-LAN (pour les serveurs persistants)

# Gardez le serveur actif même lorsqu'il ne diffuse pas
docker update --restart=always sunshine

---

Optimisation des coûts

Calculez le coût de votre streaming

Location GPU : ~0,30$-0,80$/heure (RTX 3080)
Stockage : ~0,01$/heure (SSD 50 Go)
Total : ~0,31$-0,81$/heure

vs GeForce NOW : 9,99$-19,99$/mois (heures limitées)
vs Xbox Cloud Gaming : 14,99$/mois (catalogue limité)

Conseils pour économiser de l'argent

1. Instances spot : Utilisez le GPU le moins cher disponible pendant les heures creuses

2. Mettez en pause lorsque vous ne jouez pas : Arrêtez le conteneur mais conservez le volume

3. Pré-installez les jeux : Utilisez un volume persistant pour ne pas retélécharger à chaque fois

4. Arrêt automatique : Ajoutez un script pour arrêter le serveur après inactivité

# Arrêt automatique après 30 min sans connexion Moonlight
#!/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 "Aucune connexion pendant 30 min, extinction"
    docker stop sunshine
    break
  fi
  sleep 60
done

---

Bonnes pratiques de sécurité

Ne jamais exposer Sunshine sans authentification ! Définissez toujours un mot de passe fort et envisagez d'utiliser un VPN ou un tunnel SSH pour une sécurité supplémentaire.

Méthode du tunnel SSH (la plus sûre)

# Sur votre machine locale, créez un tunnel SSH
ssh -L 47990:localhost:47990 \
    -L 48010:localhost:48010 \
    root@<clore-server-ip>

# Puis connectez Moonlight à localhost au lieu de l'IP du serveur

Changez les identifiants par défaut

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

Restreindre l'accès par IP

Dans la config Sunshine :

allowed_ips = 192.168.1.0/24,203.0.113.5

---

Benchmarks de performance

GPU	Résolution	FPS	Latence	Encodeur
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

Latence mesurée sur une connexion réseau locale 100 Mbps

---

Liens utiles

• Sunshine sur GitHub — 20K+ étoiles

• Site officiel de Moonlight

• Documentation Sunshine

• Discord LizardByte

• Clore.ai Marketplace

---

Résumé

Étape	Action
1	Louez un serveur GPU avec les ports 22, 47990, 48010
2	Déployer lizardbyte/sunshine via Docker
3	Configurer via l'interface web à https://IP:47990
4	Définir l'encodeur NVENC, débit binaire 50 Mbps
5	Créer un affichage virtuel (Xvfb)
6	Installez le client Moonlight localement
7	Appairez en utilisant le code PIN
8	Diffusez et jouez ! 🎮

Avec Sunshine + Moonlight sur Clore.ai, vous bénéficiez d'une expérience de cloud gaming qui rivalise avec n'importe quel service commercial — avec le contrôle total de votre matériel et de vos jeux. Pas d'abonnements, pas de restrictions, pas de limites.

---

Recommandations GPU Clore.ai

Cas d’utilisation	GPU recommandé	Coût estimé sur Clore.ai
Streaming 1080p/60fps	RTX 3090 (24GB)	~$0.12/gpu/hr
Streaming 4K/haut rafraîchissement	RTX 4090 (24GB)	~$0.70/gpu/hr
Jeux AAA + Streaming	RTX 4090 (24GB)	~$0.70/gpu/hr

💡 Tous les exemples de ce guide peuvent être déployés sur Clore.ai serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.