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

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

{% hint style="info" %}
**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.
{% 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 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](https://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

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

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

```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 journaux
docker compose logs -f sunshine

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

{% hint style="success" %}
**Premier démarrage**: Sunshine met environ 30 secondes à s'initialiser. Surveillez les journaux pour « Sunshine démarré avec succès » 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://<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`)

{% 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           | 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
```

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

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

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

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

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

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

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

{% endhint %}

***

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

### Installer Moonlight

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

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

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

***

## Dépannage

### Sunshine ne démarre pas

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

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

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

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

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

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

### Prise en charge des manettes de jeu

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

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

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

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

```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 depuis 30 min, arrêt en cours"
    docker stop sunshine
    break
  fi
  sleep 60
done
```

***

## Bonnes pratiques de sécurité

{% hint style="danger" %}
**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.
{% 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'adresse IP du serveur
```

### Modifier les identifiants par défaut

```bash
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](https://github.com/LizardByte/Sunshine) — plus de 20 000 étoiles
* [Site officiel de Moonlight](https://moonlight-stream.org)
* [Documentation Sunshine](https://docs.lizardbyte.dev/projects/sunshine)
* [Discord de LizardByte](https://discord.gg/lizardbyte)
* [Marketplace Clore.ai](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     | 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](https://clore.ai/marketplace) des serveurs GPU. Parcourez les GPU disponibles et louez à l'heure — sans engagement, 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, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.