Sunshine + Moonlight Juegos remotos

Transmite y juega juegos de PC de forma remota con latencia casi nula usando Sunshine (host) y Moonlight (cliente) en los servidores con GPU de Clore.ai.

Sunshine es un servidor de transmisión de juegos de código abierto y autohospedado con más de 20.000 estrellas en GitHub. Moonlight es el cliente gratuito y de código abierto que se conecta a él. Juntos rivalizan con GeForce NOW, pero a una fracción del coste.

---

¿Qué son Sunshine y Moonlight?

Sunshine es un fork de la pila original Moonlight/GameStream, ahora totalmente independiente y mantenido activamente por LizardByte. Captura la salida de tu GPU, la codifica en tiempo real usando H.264/H.265/AV1 y la transmite por la red con latencia ultrabaja.

Moonlight es la aplicación cliente disponible para Windows, macOS, Linux, Android, iOS, Raspberry Pi e incluso algunas smart TVs.

¿Por qué usarlo en Clore.ai?

• Alquila una GPU de alto rendimiento (RTX 4090, A100, etc.) a precio spot

• Transmite juegos AAA desde la nube a cualquier dispositivo, incluso un portátil económico

• No se necesita suscripción a GeForce NOW — tú controlas el hardware

• Modificación de juegos, juego asistido por IA, o pruebas de desarrollo de juegos en hardware potente

---

Prerrequisitos

Requisito	Detalles
Cuenta de Clore.ai	Con saldo de CLORE suficiente
servidor GPU	GPU NVIDIA (preferible para codificación NVENC)
Cliente Moonlight	Instalado en tu dispositivo local
Acceso SSH	Para la configuración inicial

---

Paso 1: Alquila un servidor con GPU en Clore.ai

1. Ve a clore.ai → Marketplace

2. Filtrar por Tipo de GPU: Se recomienda RTX 3080 o mejor para streaming a 1080p/60fps

3. Busca servidores con puertos 22, 47990, y 48010 disponibles

4. Selecciona un servidor y procede a ordenar

Requisitos de puertos: Sunshine necesita los puertos 47990 (interfaz web HTTPS) y 48010 (streaming). Asegúrate de que estén listados en los puertos disponibles del servidor antes de ordenar.

GPU recomendada para streaming

Resolución	FPS objetivo	GPU mínima
1080p	60 fps	RTX 3060
1440p	60 fps	RTX 3080
4K	60 fps	RTX 3090 / 4080
1080p	120 fps	RTX 4070+

---

Paso 2: Desplegar Sunshine vía Docker

Docker Compose (recomendado)

Crea un archivo 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]

Inicia el contenedor

# Descargar e iniciar
docker compose up -d

# Comprobar logs
docker compose logs -f sunshine

# Verificar que esté en ejecución
docker ps | grep sunshine

Primer arranque: Sunshine tarda ~30 segundos en inicializarse. Observa los logs hasta ver "Sunshine started successfully" antes de continuar.

Comando Docker único (Inicio rápido)

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

---

Paso 3: Configurar la interfaz web de Sunshine

1. Abra su navegador y navegue a:

   https://<tu-ip-servidor-clore>:47990

2. Acepta la advertencia del certificado autofirmado

3. Inicia sesión con las credenciales que configuraste (admin / your_secure_password)

Solo HTTPS: La interfaz web de Sunshine se ejecuta en HTTPS. Tu navegador mostrará una advertencia de certificado — esto es esperado. Haz clic en "Avanzado" → "Continuar" para seguir.

Secciones de la interfaz web

Sección	Propósito
Pin	Emparejar con el cliente Moonlight
Aplicaciones	Define aplicaciones/juegos que se puedan transmitir
Configuración	Codificador, resolución, ajustes de bitrate
Registros	Depurar problemas de streaming

---

Paso 4: Configurar ajustes de codificación

Navegue a Configuración → Vídeo en la interfaz web:

Ajustes recomendados para Clore.ai

# Codificador
encoder: nvenc          # Usar codificación por hardware NVIDIA

# Resolución
resolution_width: 1920
resolution_height: 1080

# Tasa de frames
fps: 60

# Bitrate
bitrate: 50000          # 50 Mbps para 1080p60 — excelente calidad

# H.265 (mejor compresión, úsalo si el cliente lo soporta)
codec: hevc

NVENC vs VAAPI: En los servidores NVIDIA de Clore.ai, siempre usa nvenc encoder. Delegará la codificación al hardware GPU, liberando la CPU para el propio juego.

Guía de bitrate

Calidad	Resolución	Bitrate
Bueno	1080p60	20 Mbps
Excelente	1080p60	35 Mbps
Excelente	1080p60	50 Mbps
Excelente	1440p60	50 Mbps
Excelente	4K60	100+ Mbps

---

Paso 5: Añadir aplicaciones para transmitir

En la interfaz web de Sunshine → Aplicaciones → Añadir nuevo:

Ejemplo: Transmisión del escritorio

Nombre: Desktop
Comando: (dejar vacío para escritorio completo)
Directorio de trabajo: /home/user

Ejemplo: Juego de Steam

Nombre: Steam Big Picture
Comando: steam -bigpicture
Directorio de trabajo: /home/user
Comando de desanexar: (vacío)

Ejemplo: Juego personalizado

Nombre: My Game
Comando: /opt/games/mygame/start.sh
Directorio de trabajo: /opt/games/mygame
Imagen: /opt/games/mygame/cover.png

---

Paso 6: Configurar pantalla virtual (servidor sin cabeza)

Los servidores de Clore.ai son headless (sin monitor físico). Necesitas una pantalla virtual:

# Instalar controlador de pantalla virtual
apt-get update && apt-get install -y xvfb x11vnc xfce4

# Crear pantalla virtual
Xvfb :1 -screen 0 1920x1080x24 &
export DISPLAY=:1

# Iniciar entorno de escritorio
startxfce4 &

O usa un script de framebuffer virtual

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

export DISPLAY=:1

# Iniciar pantalla virtual
Xvfb :1 -screen 0 1920x1080x24 -ac +extension GLX +render -noreset &
sleep 2

# Iniciar gestor de ventanas
openbox &
sleep 1

# Iniciar Sunshine
docker compose up -d sunshine

Hazlo ejecutable y ejecútalo:

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

GPU NVIDIA sin pantalla: Añade lo siguiente a tu configuración de Sunshine para usar la GPU sin un display físico:

export __GL_SYNC_TO_VBLANK=0
export __GL_GSYNC_ALLOWED=0

---

Paso 7: Conectar con el cliente Moonlight

Instala Moonlight

Plataforma	Descargar
Windows	moonlight-stream.org
macOS	Mac App Store o moonlight-stream.org
Linux	flatpak install flathub com.moonlight_stream.Moonlight
Android	Google Play Store
iOS	App Store
Raspberry Pi	apt install moonlight-embedded

Emparejar Moonlight con Sunshine

1. Abre Moonlight en tu dispositivo local

2. Haz clic Añadir PC e ingresa la IP de tu servidor Clore.ai

3. Moonlight mostrará un código PIN

4. Ve a la interfaz web de Sunshine → Pin → ingresa el PIN

5. ¡Conexión establecida! ✅

Ajustes de Moonlight para la mejor experiencia

Resolución: 1920x1080
FPS: 60
Bitrate: 50 Mbps
Códec de vídeo: HEVC (H.265)
Decodificación por hardware: Habilitada
Audio: Estéreo

---

Paso 8: Referencia de reenvío de puertos

Puerto	Protocolo	Propósito
22	TCP	Gestión SSH
47984	TCP	HTTPS (compatibilidad GameStream)
47989	TCP	HTTP (compatibilidad GameStream)
47990	TCP	Interfaz web HTTPS
48010	TCP	RTSP (control de streaming)
47998-48000	UDP	Transmisión de vídeo/audio
48010	UDP	Transmisión de vídeo

Asignación de puertos en Clore.ai: Al ordenar tu servidor, asegúrate de que los puertos 47990 y 48010 estén en tu mapa de puertos. Si es posible, los puertos UDP para streaming (47998-48000) también deberían estar disponibles.

---

Solución de problemas

Sunshine no arranca

# Verificar logs del contenedor
docker logs sunshine --tail 50

# Solución común: permisos
chmod 777 /tmp/.X11-unix
xhost +local:docker

Pantalla negra al transmitir

# Verificar que la pantalla virtual esté en ejecución
export DISPLAY=:1
xdpyinfo | grep dimensions

# Reiniciar pantalla
pkill Xvfb
Xvfb :1 -screen 0 1920x1080x24 &

Alta latencia

• Cambia de Wi-Fi a Ethernet en el lado del cliente

• Reduce el bitrate en los ajustes de Moonlight

• Usa H.265 en lugar de H.264 (mejor compresión con la misma calidad)

• Activa Sincronización de frames en la configuración de Sunshine

Error NVENC: "No encoder found"

# Verificar que la GPU NVIDIA sea accesible
nvidia-smi

# Comprobar que el contenedor tiene acceso a la GPU
docker exec sunshine nvidia-smi

# Si no, reinicia con la bandera --gpus all
docker stop sunshine && docker rm sunshine
# Volver a ejecutar con --gpus all

Problemas de autenticación/emparejamiento

# Restablecer credenciales de Sunshine
docker exec sunshine sunshine --creds admin newpassword

# Borrar clientes emparejados
rm -f ./sunshine-config/sunshine_state.json
docker restart sunshine

---

Configuración avanzada

Soporte multi-monitor

# En la configuración de Sunshine (sunshine.conf)
[video]
adapter_name = /dev/dri/card0
output_name = HDMI-A-1

Audio por red

Instala un sink virtual de 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

Soporte de controladores de juego

Sunshine admite emulación de gamepad virtual. Habilítalo en la configuración:

[input]
gamepad = enabled
ds4_back_as_touchpad_click = disabled

Wake-on-LAN (para servidores persistentes)

# Mantener el servidor activo incluso cuando no se está transmitiendo
docker update --restart=always sunshine

---

Optimización de costos

Calcula tu costo de streaming

Alquiler de GPU: ~$0.30-0.80/hora (RTX 3080)
Almacenamiento: ~$0.01/hora (SSD 50GB)
Total: ~$0.31-0.81/hora

vs GeForce NOW: $9.99-$19.99/mes (horas limitadas)
vs Xbox Cloud Gaming: $14.99/mes (catálogo limitado)

Consejos para ahorrar dinero

1. Instancias spot: Usa la GPU más barata disponible durante horas valle

2. Pausar cuando no juegas: Detén el contenedor pero conserva el volumen

3. Preinstalar juegos: Usa un volumen persistente para no volver a descargar cada vez

4. Apagado automático: Añade un script para detener el servidor tras inactividad

# Apagado automático tras 30 min sin conexión 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 "No connections for 30 min, shutting down"
    docker stop sunshine
    break
  fi
  sleep 60
done

---

Buenas prácticas de seguridad

¡Nunca expongas Sunshine sin autenticación! Siempre establece una contraseña fuerte y considera usar una VPN o túnel SSH para mayor seguridad.

Método de túnel SSH (más seguro)

# En tu máquina local, crea un túnel SSH
ssh -L 47990:localhost:47990 \
    -L 48010:localhost:48010 \
    root@<clore-server-ip>

# Luego conecta Moonlight a localhost en lugar de la IP del servidor

Cambiar credenciales por defecto

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

Restringir acceso por IP

En la configuración de Sunshine:

allowed_ips = 192.168.1.0/24,203.0.113.5

---

Benchmarks de rendimiento

GPU	Resolución	FPS	Latencia	Codificador
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

Latencia medida en una conexión de red local de 100 Mbps

---

Enlaces útiles

• Sunshine en GitHub — 20K+ estrellas

• Sitio oficial de Moonlight

• Documentación de Sunshine

• Discord de LizardByte

• Mercado de Clore.ai

---

Resumen

Paso	Acción
1	Alquila servidor GPU con puertos 22, 47990, 48010
2	Desplegar lizardbyte/sunshine vía Docker
3	Configurar vía interfaz web en https://IP:47990
4	Configura el codificador NVENC, bitrate 50 Mbps
5	Crear pantalla virtual (Xvfb)
6	Instala el cliente Moonlight localmente
7	Empareja usando el código PIN
8	¡Transmite y juega! 🎮

Con Sunshine + Moonlight en Clore.ai, obtienes una experiencia de juego en la nube que rivaliza con cualquier servicio comercial — con control total sobre tu hardware y tus juegos. Sin suscripciones, sin restricciones, sin límites.

---

Recomendaciones de GPU en Clore.ai

Caso de uso	GPU recomendada	Coste estimado en Clore.ai
Streaming 1080p/60fps	RTX 3090 (24GB)	~$0.12/gpu/hr
Streaming 4K/Alta frecuencia	RTX 4090 (24GB)	~$0.70/gpu/hr
Juegos AAA + Streaming	RTX 4090 (24GB)	~$0.70/gpu/hr

💡 Todos los ejemplos en esta guía pueden desplegarse en Clore.ai servidores GPU. Navega las GPUs disponibles y alquila por hora — sin compromisos, acceso root completo.