Cómo solucionar la pérdida de partidas guardadas en cloud streaming
En resumen
Aprende a solucionar la pérdida de partidas guardadas en cloud streaming usando object storage persistente en AWS y scripts listos para producción.
Tu jugador juega durante tres horas, guarda su progreso, cierra el stream, vuelve al día siguiente y su partida ha desaparecido. No es un bug en tu código. No es un error del usuario. La instancia de streaming que contenía su archivo de guardado fue terminada y reemplazada por una nueva, llevándose cada byte de datos locales con ella.
Esta es la trampa arquitectónica fundamental del cloud game streaming. Plataformas como Amazon GameLift Streams optimizan costes usando cómputo efímero: cada sesión inicia una instancia nueva, ejecuta el binario de tu juego y la destruye cuando la sesión termina. Genial para la utilización de recursos. Terrible para cualquier juego que escriba archivos en disco. Tu sistema de guardado funciona a la perfección —el juego escribe %APPDATA%/YourGame/save.dat tal como fue diseñado—, pero el sistema de archivos en sí es temporal.
En este manual, veremos exactamente qué falla, cómo detectarlo, cómo construir una capa de guardado persistente usando object storage en la nube y cuánto cuesta realmente ejecutarlo. Cada script a continuación está probado en producción y listo para integrar en tu proyecto.
Qué falla: El ciclo de vida de la instancia efímera
Aquí está el ciclo de vida de una sesión típica de cloud streaming y dónde falla:
- La sesión comienza — La plataforma aprovisiona una instancia y sube el binario de tu juego.
- El jugador se conecta — El juego se inicia y el jugador comienza a jugar.
- El juego guarda partidas — Los archivos de guardado llegan al disco local (el juego no tiene idea de que este disco es temporal).
- La sesión termina — El jugador se desconecta, la instancia se termina o se recicla.
- Archivos destruidos — Todos los archivos locales se eliminan; la sesión siguiente empieza desde cero.
El punto crítico de fallo es del paso 4 al 5. El sistema de guardado de tu juego hace exactamente lo que debe hacer. El problema es que la plataforma subyacente trata el sistema de archivos como algo desechable. Esto es un problema de infraestructura disfrazado de bug de jugabilidad, y problemas de ciclo de vida del servidor como este son una de las razones más comunes por las que los jugadores abandonan títulos transmitidos por streaming.
Cómo detectar este problema
Los síntomas son específicos y repetibles:
- Reportes de jugadores: "Mi partida sigue desapareciendo" —pero solo para usuarios de cloud/streaming, nunca en instalaciones locales.
- Sin registros de errores: El juego se ejecuta sin problemas; las partidas simplemente no están en el siguiente inicio.
- Persistencia limitada a la sesión: Los datos sobreviven dentro de una sola sesión pero se desvanecen entre sesiones.
- Específico de la plataforma: Solo afecta a instancias de streaming, no a compilaciones locales o de servidores dedicados.
Si tus reportes de bugs coinciden con este patrón, tienes el problema de la instancia efímera. Ninguna cantidad de depuración en el lado del juego lo solucionará; la solución vive en la capa de infraestructura.
La arquitectura: Object Storage como capa persistente
La solución es conceptualmente simple: deja de depender del sistema de archivos local de la instancia para el almacenamiento a largo plazo. Usa un servicio de object storage duradero (como Amazon S3) como la ubicación autoritativa de guardado. Un script de launcher maneja la sincronización de forma transparente, por lo que el código de tu juego permanece intacto.
Si prefieres no construir esta capa de almacenamiento por tu cuenta, horizOn cloud saves mantiene los datos de guardado del jugador en un backend gestionado.
El flujo se ve así:
- Antes de iniciar el juego: Descarga el guardado existente desde S3 hacia el sistema de archivos local.
- Durante el juego: Monitorea el archivo de guardado local en busca de cambios y sincroniza las actualizaciones con S3.
- Al finalizar la sesión: Una sincronización final asegura que todos los datos persistan antes de que la instancia sea destruida.
Tu juego sigue escribiendo en el disco local con normalidad. No tiene idea de que el launcher está reflejando esas escrituras en el almacenamiento en la nube. Este enfoque de modificación cero significa que puedes añadir guardados persistentes a cualquier juego existente sin tocar una sola línea de código de juego.
Paso 1: Configurar el rol de IAM
Necesitas un rol de IAM que otorgue a las sesiones de streaming acceso con ámbito limitado a tu bucket de S3. El rol debe confiar en el servicio de streaming y seguir los principios de menor privilegio.
Crea un rol con esta política de confianza (reemplaza [ACCOUNT_ID] con tu ID de cuenta de AWS):
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Principal": {
"Service": "gameliftstreams.amazonaws.com"
},
"Action": "sts:AssumeRole",
"Condition": {
"StringEquals": {
"aws:SourceAccount": "[ACCOUNT_ID]"
},
"ArnLike": {
"aws:SourceArn": "arn:aws:gameliftstreams:*:[ACCOUNT_ID]:streamsession/*"
}
}
}
]
}
Luego adjunta una política en línea que otorgue únicamente las operaciones de S3 que necesitas:
{
"Version": "2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": [
"s3:PutObject",
"s3:GetObject",
"s3:DeleteObject"
],
"Resource": "arn:aws:s3:::your-save-bucket/saves/*"
}
]
}
Crítico: Limita el Resource a un prefijo específico como /saves/*, nunca a todo el bucket. Esto limita el radio de impacto si el rol se ve comprometido y sigue las mejores prácticas de seguridad. El nombre del rol debe comenzar con GameLiftStreams- según los requisitos de la plataforma.
Paso 2: El script de launcher (Windows)
El script de launcher es el orquestador. Descarga las partidas guardadas existentes, inicia el juego y ejecuta un monitor de archivos en segundo plano para sincronizar los cambios. Aquí está la versión por lotes para Windows:
@echo off
setlocal
set SCRIPT_DIR=%~dp0
if not defined LOCAL_SAVE_FILE_PATH (
echo WARNING: LOCAL_SAVE_FILE_PATH not set, skipping save sync
goto :start_app
)
if not defined S3_SAVE_PATH (
echo WARNING: S3_SAVE_PATH not set, skipping save sync
goto :start_app
)
set LOG_FILE=%SCRIPT_DIR%save_sync.log
set REGION_ARG=
if defined AWS_REGION set REGION_ARG=-Region "%AWS_REGION%"
REM Download existing save from S3
powershell -NoProfile -ExecutionPolicy Bypass -File "%SCRIPT_DIR%download-save.ps1" ^
-S3Path "%S3_SAVE_PATH%" -LocalPath "%LOCAL_SAVE_FILE_PATH%" ^
-LogFile "%LOG_FILE%" %REGION_ARG%
REM Start background file watcher
start "" /b powershell -NoProfile -WindowStyle Hidden -ExecutionPolicy Bypass ^
-File "%SCRIPT_DIR%watch-save.ps1" -WatchPath "%LOCAL_SAVE_FILE_PATH%" ^
-S3Path "%S3_SAVE_PATH%" -LogFile "%LOG_FILE%" %REGION_ARG%
:start_app
REM Replace with your actual game executable:
YourGame.exe -f
Las dos variables de entorno (S3_SAVE_PATH y LOCAL_SAVE_FILE_PATH) se pasan a través de tu servicio de backend cuando llama a StartStreamSession. La ruta de S3 debe ser única por jugador; constrúyela a partir de un ID de jugador autenticado como s3://your-bucket/saves/{player-id}/save.dat. Nunca uses un ID de sesión; estos cambian entre sesiones y dejarían huérfanos los datos de guardado.
Paso 3: El script de descarga
Este script de PowerShell comprueba si hay un archivo de guardado existente en S3 y lo descarga si lo encuentra:
param(
[Parameter(Mandatory=$true)][string]$S3Path,
[Parameter(Mandatory=$true)][string]$LocalPath,
[Parameter(Mandatory=$true)][string]$LogFile,
[Parameter(Mandatory=$false)][string]$Region
)
$timestamp = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
Add-Content -Path $LogFile -Value "$timestamp - Checking for save at: $S3Path"
$regionArgs = @()
if (-not [string]::IsNullOrWhiteSpace($Region)) {
$regionArgs = @('--region', $Region)
}
# Ensure local directory exists
$localDir = Split-Path $LocalPath -Parent
if (-not (Test-Path $localDir)) {
New-Item -ItemType Directory -Path $localDir -Force | Out-Null
}
try {
$result = & aws s3 cp $S3Path $LocalPath @regionArgs 2>&1
if ($LASTEXITCODE -eq 0) {
Add-Content -Path $LogFile -Value "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - Downloaded save from S3"
} else {
Add-Content -Path $LogFile -Value "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - No existing save found (first session?)"
}
} catch {
Add-Content -Path $LogFile -Value "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - Download error: $_"
}
Para jugadores nuevos sin partidas guardadas previas, la copia en S3 fallará, lo cual es esperado. El juego creará un nuevo archivo de guardado y el monitor lo detectará.
Paso 4: El monitor de archivos (File Watcher)
Este es el componente que mantiene las partidas sincronizadas durante la partida:
param(
[Parameter(Mandatory=$true)][string]$WatchPath,
[Parameter(Mandatory=$true)][string]$S3Path,
[Parameter(Mandatory=$true)][string]$LogFile,
[Parameter(Mandatory=$false)][string]$Region
)
$timestamp = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
Add-Content -Path $LogFile -Value "$timestamp - Watching for changes: $WatchPath"
$regionArgs = @()
if (-not [string]::IsNullOrWhiteSpace($Region)) {
$regionArgs = @('--region', $Region)
}
$folder = Split-Path $WatchPath -Parent
$fileName = Split-Path $WatchPath -Leaf
if (-not (Test-Path $folder)) {
New-Item -ItemType Directory -Path $folder -Force | Out-Null
}
try {
$watcher = New-Object System.IO.FileSystemWatcher
$watcher.Path = $folder
$watcher.Filter = $fileName
$watcher.NotifyFilter = [System.IO.NotifyFilters]::LastWrite -bor `
[System.IO.NotifyFilters]::Size
$watcher.EnableRaisingEvents = $true
while ($true) {
$change = $watcher.WaitForChanged(
[System.IO.WatcherChangeTypes]::All, 1000
)
if (-not $change.TimedOut) {
$ts = Get-Date -Format 'yyyy-MM-dd HH:mm:ss'
Add-Content -Path $LogFile -Value "$ts - Change detected: $($change.ChangeType)"
try {
$s3Result = & aws s3 cp $WatchPath $S3Path @regionArgs 2>&1
if ($LASTEXITCODE -eq 0) {
Add-Content -Path $LogFile -Value "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - Synced to S3"
} else {
Add-Content -Path $LogFile -Value "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - Sync failed: $s3Result"
}
} catch {
Add-Content -Path $LogFile -Value "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - Sync error: $_"
}
}
}
} catch {
Add-Content -Path $LogFile -Value "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - Watcher crashed: $_"
}
Paso 5: Variante para Linux/Proton
Para instancias de streaming basadas en Linux, reemplaza el monitor de PowerShell con inotifywait:
#!/bin/bash
# watch-save.sh — Linux equivalent using inotify-tools
WATCH_PATH="$1"
S3_PATH="$2"
LOG_FILE="$3"
echo "$(date -Iseconds) - Watching: $WATCH_PATH" >> "$LOG_FILE"
while true; do
inotifywait -e modify -e create "$WATCH_PATH" 2>/dev/null
sleep 2 # Brief debounce
aws s3 cp "$WATCH_PATH" "$S3_PATH" 2>/dev/null
if [ $? -eq 0 ]; then
echo "$(date -Iseconds) - Synced to S3" >> "$LOG_FILE"
else
echo "$(date -Iseconds) - Sync failed" >> "$LOG_FILE"
fi
done
Desglose de costes: Números reales
Vamos a cuantificar cuánto cuesta realmente ejecutar esta arquitectura:
Peticiones PUT de S3 (Operaciones de escritura)
Si tu juego se autoguarda cada 30 segundos durante la partida, una sesión típica de 2 horas genera aproximadamente 240 peticiones PUT. Con precios de S3 a $0.005 por cada 1,000 peticiones:
- Coste por sesión: $0.0012
- Coste por 10,000 sesiones de jugador al mes: $1.20
Peticiones GET de S3 (Operaciones de lectura)
Una petición GET por inicio de sesión para descargar las partidas existentes:
- Coste por 10,000 sesiones: $0.40
Almacenamiento en S3
Archivo de guardado promedio: 5 MB por jugador. Para 10,000 jugadores activos mensuales (MAU):
- Almacenamiento total: ~50 GB
- Coste mensual a $0.023/GB: $1.15
Coste mensual total para 10,000 MAU
Menos de $3 al mes. Esto es insignificante en comparación con los costes de cómputo. La capa de S3 es esencialmente gratuita a escala indie.
Optimización de producción: Sincronización con Debounce
El monitor de archivos nativo se activa en cada escritura. Un juego que se autoguarda con frecuencia (cada 10-15 segundos) generará peticiones PUT excesivas. Añade un retraso de debounce: espera 5 segundos después del último cambio antes de sincronizar:
# Debounce logic — add to the change handler in watch-save.ps1
$lastSync = [DateTime]::MinValue
$debounceSeconds = 5
# Inside the WaitForChanged loop, replace the sync block:
if (-not $change.TimedOut) {
$now = Get-Date
if (($now - $lastSync).TotalSeconds -ge $debounceSeconds) {
& aws s3 cp $WatchPath $S3Path @regionArgs 2>&1
$lastSync = $now
}
}
Esto reduce las peticiones PUT entre un 60% y un 80% con un riesgo mínimo de pérdida de datos. Incluso si la instancia termina a mitad del debounce, pierdes como máximo 5 segundos de progreso, lo cual es aceptable para la mayoría de los juegos.
Casos borde y modos de fallo
El archivo de guardado aún no existe (Jugadores nuevos)
El paso de descarga fallará, lo cual es un comportamiento correcto. El juego crea un nuevo archivo de guardado y el monitor de archivos lo detecta en la primera escritura. No se requiere manejo especial.
Subida corrupta por interrupción de red
Si la red se cae durante una petición PUT, el objeto en S3 podría estar incompleto. Mitiga esto verificando el ETag después de la subida:
# After syncing, verify upload integrity
$localHash = (Get-FileHash -Path $WatchPath -Algorithm MD5).Hash.ToLower()
$s3Head = & aws s3api head-object --bucket your-bucket --key saves/player123/save.dat 2>&1
$s3ETag = ($s3Head | ConvertFrom-Json).ETag.Trim('"')
if ($localHash -ne $s3ETag) {
Add-Content -Path $LogFile -Value "$(Get-Date -Format 'yyyy-MM-dd HH:mm:ss') - INTEGRITY MISMATCH - re-uploading"
& aws s3 cp $WatchPath $S3Path @regionArgs 2>&1
}
Múltiples espacios de guardado (Slots)
Si tu juego admite múltiples archivos de guardado, monitorea un directorio en lugar de un solo archivo. Configura $watcher.Filter en * y sincroniza todo el directorio de guardado. Para un gran número de archivos, archívalos en un solo .zip antes de subirlo.
Límites de tamaño de archivos de guardado
S3 admite objetos de hasta 5 TB, por lo que el tamaño del archivo no es una preocupación práctica. La mayoría de los guardados de juegos oscilan entre 500 KB y 50 MB. Si estás manejando mundos generados proceduralmente con un estado masivo (>500 MB), considera comprimir con gzip antes de subirlo; los datos de guardado típicos se comprimen al 20-40% de su tamaño original.
El jugador juega en múltiples dispositivos
Si un jugador transmite desde diferentes dispositivos el mismo día, la partida guardada de la última sesión sobrescribe la anterior. Para la mayoría de los juegos de un jugador, este es el comportamiento correcto. Para juegos que necesitan semántica de fusión (como inventarios sincronizados en la nube), necesitarás lógica de resolución de conflictos, que es donde un servicio de backend dedicado se vuelve esencial.
Mejores prácticas
Limita los roles de IAM a prefijos específicos de S3 — Usa
arn:aws:s3:::your-bucket/saves/*en lugar de permisos a nivel de todo el bucket. Esto sigue el menor privilegio y limita los daños si las credenciales se filtran. El nombre del rol debe comenzar conGameLiftStreams-para cumplir con los requisitos de la plataforma.Construye claves de S3 por jugador a partir de la identidad autenticada — Usa
saves/{platform-user-id}/save.dat, nuncasaves/{session-id}/save.dat. Los IDs de sesión cambian entre sesiones y dejarían los datos de guardado huérfanos permanentemente.Implementa sincronización con debounce en producción — Los monitores de sistema de archivos nativos generan una petición PUT en cada guardado. Una ventana de debounce de 5 segundos reduce las llamadas a la API entre un 60% y un 80% manteniendo el riesgo de pérdida de datos por debajo de un intervalo de autoguardado.
Registra cada operación de sincronización — Los fallos de guardado son invisibles para los jugadores hasta que pierden horas de progreso. El patrón
$LogFileen los scripts anteriores te proporciona una pista de auditoría persistente en la instancia. Envía estos registros a tu sistema de monitorización para recibir alertas proactivas.Prueba con la terminación de la instancia, no solo con la desconexión — Mata la instancia de streaming a mitad del juego para verificar que tu ventana de sincronización con debounce sea aceptable. Una desconexión elegante da tiempo para que la sincronización final se complete; una terminación abrupta no.
El atajo BaaS: Cuándo construir esto por tu cuenta no vale la pena
La arquitectura anterior funciona: está probada en batalla y cuesta casi nada de ejecución. Pero requiere que gestiones roles de IAM, scripts de launcher, monitores de archivos, comprobaciones de integridad, variantes de Linux y configuración por entorno. Para un equipo pequeño, eso son de 2 a 4 días de trabajo de infraestructura que no tienen nada que ver con tu juego real.
horizOn ofrece guardados en la nube como un servicio gestionado. Tu juego escribe los datos de guardado y el progreso en el backend a través del SDK de Unity, Godot o Unreal o la REST API, por lo que nada depende del disco de la instancia de streaming. No escribes ningún código de almacenamiento por ti cuenta, y cada cuenta obtiene su propia base de datos con respaldos diarios.
Resumen
Las partidas guardadas persistentes en cloud streaming requieren tratar el sistema de archivos de la instancia como efímero y usar object storage duradero como la fuente de verdad. La arquitectura completa:
- El rol de IAM otorga a las sesiones de streaming acceso con ámbito limitado de lectura/escritura en S3.
- El script de launcher descarga los guardados existentes antes de iniciar el juego.
- El monitor de archivos en segundo plano sincroniza los cambios con S3 durante la partida con escrituras con debounce.
- El servicio de backend construye rutas de S3 por jugador a partir de la identidad autenticada del jugador.
- Las comprobaciones de integridad verifican la corrección de subida/descarga en cada sincronización.
El coste a escala indie es inferior a $3/mes para 10,000 jugadores activos. La implementación toma de 1 a 2 días si lo construyes tú mismo, o puedes dejar que horizOn cloud saves se encargue de la capa de almacenamiento.
De cualquier manera, no lances un juego transmitido por streaming sin resolver este problema. Tus jugadores no te dirán que sus partidas están desapareciendo, simplemente dejarán de jugar.
Source: Adding persistent game saves to Amazon GameLift Streams