> 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-fr/jeux-et-streaming/sunshine-moonlight.md).

# Sunshine + Moonlight jeu à distance

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.

{% hint style="info" %}
**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.
{% endhint %}

***

## 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](https://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

{% hint style="warning" %}
**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.
{% endhint %}

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

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

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

{% hint style="success" %}
**Premier démarrage**: Sunshine met \~30 secondes à s'initialiser. Surveillez les logs pour "Sunshine started successfully" avant de continuer.
{% endhint %}

### Commande Docker unique (démarrage rapide)

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

{% hint style="warning" %}
**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.
{% endhint %}

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

{% hint style="info" %}
**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.
{% endhint %}

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

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

```bash
#!/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 :

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

{% hint style="info" %}
**GPU NVIDIA sans écran** : Ajoutez ce qui suit à votre configuration Sunshine pour utiliser le GPU sans écran physique :

```bash
export __GL_SYNC_TO_VBLANK=0
export __GL_GSYNC_ALLOWED=0
```

{% endhint %}

***

## Étape 7 : Connectez-vous avec le client Moonlight

### Installez Moonlight

| Plateforme   | Télécharger                                              |
| ------------ | -------------------------------------------------------- |
| Windows      | [moonlight-stream.org](https://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                  |

{% hint style="warning" %}
**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.
{% endhint %}

***

## Dépannage

### Sunshine ne démarre pas

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

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

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

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

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

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

```yaml
[input]
gamepad = enabled
ds4_back_as_touchpad_click = disabled
```

### Wake-on-LAN (pour les serveurs persistants)

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

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

{% hint style="danger" %}
**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.
{% endhint %}

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

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

```bash
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](https://github.com/LizardByte/Sunshine) — 20K+ étoiles
* [Site officiel de Moonlight](https://moonlight-stream.org)
* [Documentation Sunshine](https://docs.lizardbyte.dev/projects/sunshine)
* [Discord LizardByte](https://discord.gg/lizardbyte)
* [Clore.ai Marketplace](https://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     | 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](https://clore.ai/marketplace) serveurs GPU. Parcourez les GPU disponibles et louez à l’heure — sans engagement, avec accès root complet.


---

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

```
GET https://docs.clore.ai/guides/guides_v2-fr/jeux-et-streaming/sunshine-moonlight.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.