Juego remoto con Sunshine + Moonlight

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

Sunshine es un servidor de streaming de juegos autohospedado y de código abierto 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, por una fracción del costo.

---

¿Qué es Sunshine + Moonlight?

Sunshine es una bifurcación de la pila original Moonlight/GameStream, ahora completamente independiente y mantenida 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 TV.

¿Por qué usarlo en Clore.ai?

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

• Transmitir juegos AAA desde la nube a cualquier dispositivo, incluso una laptop barata

• 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

---

Requisitos previos

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

---

Paso 1: Alquila un servidor GPU en Clore.ai

1. Ve a clore.ai → Marketplace

2. Filtrar por Tipo de GPU: Se recomienda una RTX 3080 o superior para transmisión 1080p/60fps

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

4. Selecciona un servidor y continúa con el pedido

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

GPU recomendada para transmisión

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: Implementa Sunshine mediante 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

# Ver registros
docker compose logs -f sunshine

# Verifica que se esté ejecutando
docker ps | grep sunshine

Primer arranque: Sunshine tarda ~30 segundos en inicializarse. Revisa los registros para "Sunshine started successfully" antes de continuar.

Comando único de Docker (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: Configura la interfaz web de Sunshine

1. Abre tu navegador y navega a:

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

2. Acepta la advertencia del certificado autofirmado

3. Inicia sesión con las credenciales que estableciste (admin / tu_contraseña_segura)

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
Fijar	Emparejar con el cliente Moonlight
Aplicaciones	Definir aplicaciones/juegos compatibles con streaming
Configuración	Ajustes de codificador, resolución y bitrate
Registros	Depurar problemas de streaming

---

Paso 4: Configura los ajustes de codificación

Navega a Configuración → Video en la interfaz web:

Ajustes recomendados para Clore.ai

# Codificador
codificador: nvenc          # Usa codificación por hardware de NVIDIA

# Resolución
resolution_width: 1920
resolution_height: 1080

# Frecuencia de cuadros
fps: 60

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

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

NVENC frente a VAAPI: En los servidores NVIDIA de Clore.ai, usa siempre nvenc codificador. Descarga la codificación al hardware de la GPU, liberando la CPU para el juego en sí.

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ñade aplicaciones para transmitir

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

Ejemplo: transmisión de escritorio

Nombre: Escritorio
Comando: (déjalo vacío para el 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 desconexión: (vacío)

Ejemplo: juego personalizado

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

---

Paso 6: Configura una pantalla virtual (servidor sin interfaz)

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

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

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

# Inicia el entorno de escritorio
startxfce4 &

O usa un script de framebuffer virtual

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

export DISPLAY=:1

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

# Inicia el gestor de ventanas
openbox &
sleep 1

# Inicia 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 una pantalla física:

export __GL_SYNC_TO_VBLANK=0
export __GL_GSYNC_ALLOWED=0

---

Paso 7: Conéctate con el cliente Moonlight

Instala Moonlight

Plataforma	Descarga
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

Empareja Moonlight con Sunshine

1. Abre Moonlight en tu dispositivo local

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

3. Moonlight mostrará un código PIN

4. Ve a la interfaz web de Sunshine → Fijar → introduce el PIN

5. ¡Conexión establecida! ✅

Ajustes de Moonlight para la mejor experiencia

Resolución: 1920x1080
FPS: 60
Bitrate: 50 Mbps
Códec de video: 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	Administración SSH
47984	TCP	HTTPS (compatibilidad con GameStream)
47989	TCP	HTTP (compatibilidad con GameStream)
47990	TCP	Interfaz web HTTPS
48010	TCP	RTSP (control de streaming)
47998-48000	UDP	Transmisión de video/audio
48010	UDP	Transmisión de video

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

---

Solución de problemas

Sunshine no se inicia

# Compruebe los registros del contenedor
docker logs sunshine --tail 50

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

Pantalla negra al transmitir

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

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

Alta latencia

• Cambiar 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)

• Habilita Sincronización de fotogramas en la configuración de Sunshine

Error de NVENC: "No se encontró ningún codificador"

# Verifica que la GPU NVIDIA sea accesible
nvidia-smi

# Comprueba que el contenedor tenga 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

# Restablece las credenciales de Sunshine
docker exec sunshine sunshine --creds admin newpassword

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

---

Configuración avanzada

Compatibilidad con varios monitores

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

Audio por red

Instala el sumidero 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

Compatibilidad con mandos de juego

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

[input]
gamepad = enabled
ds4_back_as_touchpad_click = disabled

Wake-on-LAN (para servidores persistentes)

# Mantén el servidor activo incluso cuando no esté transmitiendo
docker update --restart=always sunshine

---

Optimización de costos

Calcula tu costo de streaming

Alquiler de GPU: $0.05–0.19/h (RTX 3080)
Almacenamiento: ~$0.01/hora (SSD de 50 GB)
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 las horas de menor demanda

2. Pausar cuando no estés jugando: Detén el contenedor pero conserva el volumen

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

4. Apagado automático: Añade un script para detener el servidor después de la inactividad

# Apagado automático después de 30 min sin conexión de 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 "Sin conexiones durante 30 min, apagando"
    docker stop sunshine
    break
  fi
  sleep 60
done

---

Mejores prácticas de seguridad

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

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

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

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

Cambiar las credenciales predeterminadas

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

Restringir el acceso por IP

En la configuración de Sunshine:

allowed_ips = 192.168.1.0/24,203.0.113.5

---

Puntos de referencia 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

• GitHub de Sunshine — más de 20 mil estrellas

• Sitio oficial de Moonlight

• Documentación de Sunshine

• Discord de LizardByte

• Marketplace de Clore.ai

---

Resumen

Paso	Acción
1	Alquila un servidor GPU con puertos 22, 47990 y 48010
2	Implementar lizardbyte/sunshine vía Docker
3	Configurar mediante la interfaz web en https://IP:47990
4	Configurar el codificador NVENC, bitrate de 50 Mbps
5	Crear pantalla virtual (Xvfb)
6	Instalar el cliente Moonlight localmente
7	Emparejar usando un código PIN
8	¡Transmitir y jugar! 🎮

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 para Clore.ai

Caso de uso	GPU recomendada	Costo estimado en Clore.ai
Streaming 1080p/60fps	RTX 3090 (24GB)	$0.07–0.21/gpu/hr
Streaming 4K/de alta frecuencia de actualización	RTX 4090 (24GB)	$0.14–0.42/gpu/hr
Juegos AAA + Streaming	RTX 4090 (24GB)	$0.14–0.42/gpu/hr

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