Jeu à distance Sunshine + Moonlight

Diffusez et jouez à des jeux PC à distance avec une latence quasi nulle grâce à Sunshine (hôte) et Moonlight (client) sur les serveurs Clore.ai équipés de GPU.

Sunshine est un serveur de diffusion 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 — pour 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 de votre GPU, l'encode en temps réel à l'aide de 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 certains téléviseurs connectés.

Pourquoi l'utiliser sur Clore.ai ?

• Louer un GPU haut de gamme (RTX 4090, A100, etc.) au tarif spot

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

• Pas besoin d'abonnement GeForce NOW nécessaire — vous contrôlez le matériel

• Modding de jeux, gameplay 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 (pour l'encodage NVENC) de préférence
client Moonlight	Installé sur votre appareil local
Accès SSH	Pour la configuration initiale

---

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

1. Accédez à clore.ai → Place de marché

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

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

4. Sélectionnez un serveur et passez la commande

Exigences en matière de ports: Sunshine a besoin des ports 47990 (interface Web HTTPS) et 48010 (streaming). Assurez-vous qu'ils figurent dans les ports disponibles du serveur avant de commander.

GPU recommandé pour le streaming

Résolution	FPS cible	GPU minimum
1080p	60 ips	RTX 3060
1440p	60 ips	RTX 3080
4K	60 ips	RTX 3090 / 4080
1080p	120 ips	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 journaux
docker compose logs -f sunshine

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

Premier démarrage: Sunshine met environ 30 secondes à s'initialiser. Surveillez les journaux pour « Sunshine démarré avec succès » 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://<your-clore-server-ip>:47990

2. Acceptez l'avertissement relatif au 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	Objectif
Code PIN	Associer avec le client Moonlight
Applications	Définir les applications/jeux diffusables
Configuration	Paramètres d'encodeur, de résolution et de débit
Journaux	Déboguer les problèmes de diffusion

---

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

Accédez à Configuration → Vidéo dans l'interface Web :

Paramètres recommandés pour Clore.ai

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

# Résolution
resolution_width: 1920
resolution_height: 1080

# Fréquence d'images
fps: 60

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

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

NVENC contre 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 du débit

Qualité	Résolution	Débit
Bon	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 de Sunshine → Applications → Ajouter:

Exemple : diffusion du bureau

Nom : Bureau
Commande : (laissez 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 écran)

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

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

# Créer l'affichage virtuel
Xvfb :1 -screen 0 1920x1080x24 &
export DISPLAY=:1

# Démarrer 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-le :

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

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

export __GL_SYNC_TO_VBLANK=0
export __GL_GSYNC_ALLOWED=0

---

Étape 7 : Connectez-vous avec le client Moonlight

Installer Moonlight

Plateforme	Téléchargement
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

Associez Moonlight avec Sunshine

1. Ouvrez Moonlight sur votre appareil local

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

3. Moonlight affichera un code PIN

4. Allez dans l'interface Web de Sunshine → Code PIN → saisissez le PIN

5. Connexion établie ! ✅

Paramètres Moonlight pour une expérience optimale

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

---

Étape 8 : Référence de redirection des ports

Port	Protocole	Objectif
22	TCP	Gestion SSH
47984	TCP	HTTPS (compatible GameStream)
47989	TCP	HTTP (compatible GameStream)
47990	TCP	Interface Web HTTPS
48010	TCP	RTSP (contrôle de diffusion)
47998-48000	UDP	Diffusion vidéo/audio
48010	UDP	Diffusion vidéo

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

---

Dépannage

Sunshine ne démarre pas

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

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

Écran noir lors de la diffusion

# Vérifier que l'affichage virtuel est en cours d'exécution
export DISPLAY=:1
xdpyinfo | grep dimensions

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

Latence élevée

• Passez de Wi-Fi à Ethernet côté client

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

• Utilisez H.265 au lieu de H.264 (meilleure compression à qualité égale)

• Activer Cadence des images dans la configuration de Sunshine

Erreur NVENC : « Aucun encodeur trouvé »

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

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

# Sinon, redémarrez avec l'option --gpus all
docker stop sunshine && docker rm sunshine
# Relancer avec --gpus all

Problèmes d'authentification/association

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

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

---

Configuration avancée

Prise en charge de plusieurs moniteurs

# Dans la configuration 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

Prise en charge des manettes de jeu

Sunshine prend en charge l'émulation de manette virtuelle. Activez-la dans la configuration :

[input]
gamepad = enabled
ds4_back_as_touchpad_click = disabled

Wake-on-LAN (pour les serveurs persistants)

# Garder le serveur actif même sans diffusion
docker update --restart=always sunshine

---

Optimisation des coûts

Calculez le coût de votre diffusion

Location du GPU : 0,05 $–0,19 $/h (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é)

Astuces pour économiser

1. Instances spot: Utilisez le GPU disponible le moins cher 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 tout 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 depuis 30 min, arrêt en cours"
    docker stop sunshine
    break
  fi
  sleep 60
done

---

Bonnes pratiques de sécurité

N'exposez jamais 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'adresse IP du serveur

Modifier les identifiants par défaut

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

Restreindre l'accès par IP

Dans la configuration 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 de 100 Mbps

---

Liens utiles

• GitHub de Sunshine — plus de 20 000 étoiles

• Site officiel de Moonlight

• Documentation Sunshine

• Discord de LizardByte

• Marketplace Clore.ai

---

Résumé

Étape	Action
1	Louez un serveur GPU avec les ports 22, 47990, 48010
2	Déployer lizardbyte/sunshine via Docker
3	Configurez via l'interface Web à https://IP:47990
4	Définir l'encodeur NVENC, débit de 50 Mb/s
5	Créer un affichage virtuel (Xvfb)
6	Installez le client Moonlight localement
7	Associez-vous à l’aide d’un code PIN
8	Diffusez et jouez ! 🎮

Avec Sunshine + Moonlight sur Clore.ai, vous obtenez une expérience de cloud gaming qui rivalise avec n’importe quel service commercial — avec un contrôle total sur votre matériel et 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
Diffusion en 1080p/60 ips	RTX 3090 (24 Go)	0,07–0,21 $/gpu/h
Diffusion en 4K/haut taux de rafraîchissement	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h
Jeux AAA + diffusion	RTX 4090 (24 Go)	0,14–0,42 $/gpu/h

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