> ## Documentation Index
> Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt
> Use this file to discover all available pages before exploring further.
# Depuración local de servidores de juego e integración con PlayFab
> Describe cómo integrar los servidores de juego multijugador de PlayFab con el SDK de servidor de juegos de PlayFab (GSDK) y cómo comprobar y depurar la integración.
## Información general
Los servidores de juego multijugador de PlayFab requieren la integración con el [SDK de servidor de juegos de PlayFab (GSDK)](/services/playfab/multiplayer/servers/integrating-game-servers-with-gsdk). Además, los servidores de juego se ejecutan como aplicaciones en contenedores en la plataforma multijugador de PlayFab.
Ejecutarlos como aplicaciones en contenedores permite ejecutar y depurar el servidor localmente, en un entorno que coincide con el de la plataforma de PlayFab en Azure. Esto facilita iteraciones de desarrollo más rápidas. Este artículo le ayuda a comprobar que el servidor de juegos de PlayFab cumple los requisitos de la plataforma.
El conjunto de herramientas de depuración local de PlayFab incluye [LocalMultiplayerAgent](https://github.com/PlayFab/MpsAgent), que proporciona respuestas simuladas al GSDK y comprueba si el servidor de juegos está integrado correctamente con el GSDK. Con las respuestas simuladas, VmAgent hace pasar al servidor de juegos por los distintos estados de su ciclo de vida en la plataforma multijugador de PlayFab.
Puede configurar el agente para ejecutar el servidor de juegos como una aplicación en contenedores. Compruebe que el servidor de juegos está empaquetado con todas las dependencias necesarias y que se ejecuta sin problemas en la plataforma multijugador de PlayFab. LocalMultiplayerAgent puede funcionar con servidores de juego de Windows o de Linux.
## Configuración básica: Windows
* Integre el servidor de juegos con el GSDK y compílelo. Para obtener más información, consulte [Integración de servidores de juego con el SDK de servidor de juegos de PlayFab (GSDK)](/services/playfab/multiplayer/servers/integrating-game-servers-with-gsdk).
* Comprima el servidor de juegos y sus dependencias en un archivo zip. Para ejecutarse correctamente en modo contenedor, el archivo zip debe contener las DLL del sistema que no estén incluidas en la imagen del contenedor. Para obtener más información, consulte [determinación de las DLL del sistema necesarias](/services/playfab/multiplayer/servers/determining-required-dlls).
Evite este error común: no comprima accidentalmente una carpeta *dentro* de otra carpeta en el zip. Después de comprimir, examine la carpeta zip y compruebe que el software de compresión no agregó un nivel adicional de jerarquía de archivos.
* Descargue el [conjunto de herramientas de depuración local](https://github.com/PlayFab/MpsAgent/releases) y extráigalo en la carpeta que prefiera (por ejemplo, *C:\PlayFabVmAgent*).
* Mientras examina el archivo json [LocalMultiplayerAgent MultiplayerSettings.json Generator](https://github.com/PlayFab/MpsAgent/tree/main/LocalMultiplayerAgent/SettingsJsonGenerator), lea más información sobre las siguientes opciones a continuación.
* Vaya a la ubicación de la carpeta extraída y abra el archivo *MultiplayerSettings.json* en un editor de texto (como [Visual Studio Code](https://code.visualstudio.com/download)). Actualice las siguientes propiedades:
* `LocalFilePath`: ruta de acceso local completa (en la estación de trabajo) al archivo zip de recursos del servidor de juegos creado anteriormente, por ejemplo: *D:\\\MyAmazingGame\\\asset.zip* (tenga en cuenta que las barras diagonales inversas deben escaparse para el formato JSON).
* `StartGameCommand`: ruta de acceso completa al ejecutable del servidor de juegos dentro del contenedor. Por ejemplo, si el nombre del ejecutable es *mygame.exe*, una ruta de ejemplo sería *C:\\\Assets\\\mygame.exe*. Las rutas de acceso de StartGameCommand son diferentes para un proceso y un contenedor. La ruta de StartGameCommand para un contenedor es una ruta absoluta a un recurso en el contenedor o en la carpeta de recursos. La ruta de StartGameCommand para un proceso es una ruta relativa donde el directorio de trabajo será el primer recurso especificado.
* `PortMappingsList`: son los puertos que están disponibles para el juego durante la ejecución. `NodePort` es el puerto que se abre en la estación de trabajo; `GamePort.Number` es el puerto al que el servidor de juegos debe enlazarse cuando se ejecuta en un contenedor. Actualice la sección GamePort para que coincida con el protocolo y el puerto en los que el servidor de juegos escucha a los clientes. Si el servidor de juegos necesita varios puertos, copie y pegue la configuración de puertos existente e incremente `NodePort`; después actualice `GamePort.Number` y `GamePort.Name` con el puerto necesario. Cuando se ejecuta como proceso, `GamePort.Number` se omite; el proceso debe enlazarse a NodePort. Para gestionar ambos casos, realice una de las siguientes acciones:
* Establezca los puertos en el mismo valor
* Compruebe en tiempo de ejecución la configuración del GSDK para obtener el valor con la clave `GamePort.Name`, que siempre devuelve el puerto correcto al que enlazarse.
* Hay campos adicionales en el archivo *MultiplayerSettings.json* que puede que quiera editar:
* `ResourceLimits` (opcional): si se especifica, Docker limita el uso de CPU/memoria. Advertencia: si el servidor supera la memoria permitida, se termina. ResourceLimits solo puede especificarse en modo contenedor.
* `SessionCookie` (opcional): cualquier cookie de sesión que se pase al servidor de juegos como parte de la llamada a la [API RequestMultiplayerServer](xref:titleid.playfabapi.com.multiplayer.multiplayerserver.requestmultiplayerserver).
* `OutputFolder` (opcional): ruta absoluta a una unidad o carpeta donde se generan las salidas y los archivos de configuración. Asegúrese de que haya suficiente espacio disponible, ya que el servidor de juegos se extraerá en esta ruta. Si no se especifica, se usa la carpeta del agente.
* `MountPath`: ruta dentro del contenedor en la que se monta el recurso. Este campo no es necesario cuando se ejecuta en modo proceso. Se recomienda usar el valor de ejemplo: *C:\\\Assets* (tenga en cuenta que las barras diagonales inversas deben escaparse para el formato JSON).
* `AgentListeningPort`: especifica el puerto al que se enlaza el agente para comunicarse con el servidor de juegos. Cualquier puerto abierto funcionará; si tiene otro proceso enlazado al puerto 56001, debe cambiar este valor (o terminar el otro proceso).
## Comprobación de la integración con el GSDK
* En el archivo *MultiplayerSettings.json*, establezca `RunContainer` en `false`.
* En una ventana de PowerShell (como administrador):
* Cambie el directorio de trabajo a la carpeta donde se extrajo el conjunto de herramientas.
* Ejecute *LocalMultiplayerAgent.exe*. En este punto, **LocalMultiplayerAgent** configura el agente de escucha http, descomprime el recurso del juego e inicia el servidor de juegos en un proceso independiente. Después, **LocalMultiplayerAgent** espera los latidos del GSDK integrado con el servidor de juegos.
* Si el GSDK está integrado correctamente, **LocalMultiplayerAgent** imprime las siguientes salidas:
* `CurrentGameState - Initializing` (esto es opcional y puede no aparecer si el servidor de juegos llama directamente a `GSDK::ReadyForPlayers` y no llama a `GSDK::Start`)
* `CurrentGameState - StandingBy`
* `CurrentGameState - Active`
* `CurrentGameState - Terminating`
* Si las devoluciones de llamada de apagado están configuradas correctamente, el servidor de juegos se cierra poco después de que el estado se establezca en terminating. Es importante comprobar que el servidor de juegos se cierra para evitar apagados incorrectos en la plataforma de PlayFab.
* **LocalMultiplayerAgent** también debería terminar junto con el juego.
### Prueba de conexión al juego
Cuando el ejecutable del servidor de juegos está en ejecución y **LocalMultiplayerAgent** imprime `CurrentGameState - Active`, puede conectarse al servidor de juegos mediante la dirección IP **127.0.0.1** y el puerto `NodePort` en el que escucha el servidor de juegos.
Después de `NumHeartBeatsForActivateResponse` latidos, **LocalMultiplayerAgent** solicita al servidor de juegos que pase de en espera a activo. Después de `NumHeartBeatsForTerminateResponse` latidos, **LocalMultiplayerAgent** solicita al servidor de juegos que pase de activo a terminado. Este comportamiento puede ajustarse actualizando los valores del archivo *MultiplayerSettings.json*.
## Comprobación de la contenedorización
Si es nuevo en el mundo de los contenedores, puede consultar una introducción [aquí](https://learn.microsoft.com/en-us/dotnet/architecture/microservices/container-docker-introduction/).
### Requisitos previos
* Windows 10 Pro (o superior) con la actualización de abril de 2018 (1803).
* Descargue [Docker](https://download.docker.com/win/stable/Docker%20for%20Windows%20Installer.exe). Como alternativa, puede descargarlo desde la página principal del [sitio web de Docker](https://www.docker.com/products/docker-desktop).
### Configuración
* Asegúrese de que Docker esté configurado para [usar contenedores de Windows](https://docs.docker.com/docker-for-windows/#switch-between-windows-and-linux-containers)
* En una ventana de PowerShell (como administrador):
* Vaya a la carpeta donde se extrajo el conjunto de herramientas.
* Ejecute *Setup.ps1*, que configura las redes de Docker, agrega reglas de firewall para comunicarse con **LocalMultiplayerAgent** y descarga la imagen de Docker de PlayFab desde [Microsoft/PlayFab-Multiplayer](https://hub.docker.com/r/microsoft/playfab-multiplayer/). Tenga en cuenta que la primera vez que se ejecuta el script, la descarga de la imagen del contenedor puede tardar unos minutos.
Para ejecutar esta configuración correctamente, puede que tenga que configurar el firewall de cualquier programa antivirus de terceros (como McAfee, Norton o Avira) que tenga instalado.
### Ejecución del servidor de juegos dentro de un contenedor
* En el archivo *MultiplayerSettings.json*, establezca `RunContainer` en `true`.
* Abra una ventana de **PowerShell** (como administrador) en la carpeta donde se extrajo el conjunto de herramientas (*C:\PlayFabVmAgent*) y ejecute `LocalMultiplayerAgent.exe`. Esto inicia el servidor de juegos dentro de un contenedor. Con el tiempo, debería ver en la ventana de PowerShell la salida de los cambios de estado del juego (igual que en la sección anterior Comprobación de la integración con el GSDK).
### Prueba de conexión al servidor de juegos en ejecución dentro de un contenedor
Cuando la salida de **LocalMultiplayerAgent** imprima `CurrentGameState - Active`, conéctese al servidor de juegos mediante la dirección IP **127.0.0.1** y el puerto igual a `NodePort` (de forma predeterminada, **56100**) especificado en el archivo *MultiplayerSettings.json*.
Después de `NumHeartBeatsForActivateResponse` latidos, **LocalMultiplayerAgent** solicita al servidor de juegos que pase de en espera a activo. Después de `NumHeartBeatsForTerminateResponse` latidos, **LocalMultiplayerAgent** solicita al servidor de juegos que pase de activo a terminado. Este comportamiento puede ajustarse actualizando los valores del archivo *MultiplayerSettings.json*.
### Uso de LocalMultiplayerAgent con contenedores de Linux
Puede usar LocalMultiplayerAgent para depurar el servidor de juegos de Linux ejecutándolo en un contenedor en Windows mediante [Docker para Windows](https://docs.docker.com/docker-for-windows/). Puede ver más información sobre la ejecución de contenedores de Linux en Windows [aquí](https://learn.microsoft.com/en-us/virtualization/windowscontainers/deploy-containers/linux-containers). En esencia, lo único que tiene que hacer es ejecutar el agente con el parámetro *-lcow* y configurar correctamente el archivo *LocalMultiplayerSettings.json*.
Para ejecutar los servidores de juego de Linux en contenedores en Windows, debe realizar los siguientes pasos:
* Descargue la versión más reciente de LocalMultiplayerAgent desde la página de [versiones](https://github.com/PlayFab/MpsAgent/releases) en GitHub
* [Instale Docker Desktop en Windows](https://docs.docker.com/docker-for-windows/install/)
* Asegúrese de que se ejecuta con [contenedores de Linux](https://docs.docker.com/docker-for-windows/#switch-between-windows-and-linux-containers)
* Debe montar una de las unidades de disco duro; puede encontrar instrucciones [aquí](https://docs.docker.com/docker-for-windows/#file-sharing)
* La imagen del servidor de juegos puede publicarse en un registro de contenedor o compilarse localmente.
* Ejecute el archivo de PowerShell `SetupLinuxContainersOnWindows.ps1`, que crea una red de Docker llamada "PlayFab"
* Configure correctamente el archivo *LocalMultiplayerSettings.json*. A continuación puede ver un ejemplo, incluido en `MultiplayerSettingsLinuxContainersOnWindowsSample.json`:
```json theme={null}
{
"RunContainer": true,
"OutputFolder": "C:\\output\\UnityServerLinux",
"NumHeartBeatsForActivateResponse": 10,
"NumHeartBeatsForTerminateResponse": 60,
"TitleId": "",
"BuildId": "00000000-0000-0000-0000-000000000000",
"Region": "WestUs",
"AgentListeningPort": 56001,
"ContainerStartParameters": {
"ImageDetails": {
"Registry": "mydockerregistry.io",
"ImageName": "mygame",
"ImageTag": "0.1",
"Username": "",
"Password": ""
}
},
"PortMappingsList": [
[
{
"NodePort": 56100,
"GamePort": {
"Name": "game_port",
"Number": 7777,
"Protocol": "TCP"
}
}
]
],
"SessionConfig": {
"SessionId": "ba67d671-512a-4e7d-a38c-2329ce181946",
"SessionCookie": null,
"InitialPlayers": [ "Player1", "Player2" ]
}
}
```
Algunas notas: 1. Debe establecer
`RunContainer` en true. Esto es obligatorio para los servidores de juego de Linux.
2. Modifique
`imageDetails` con los detalles de la imagen de Docker del servidor de juegos. La imagen puede compilarse localmente (mediante el comando [docker build](https://docs.docker.com/engine/reference/commandline/build/)) o hospedarse en un registro de contenedor remoto.
3.
`StartGameCommand` y `AssetDetails` son opcionales. Normalmente no se usan cuando se utiliza un contenedor de Docker, ya que todos los recursos del juego y el comando de inicio del servidor de juegos pueden empaquetarse en el [Dockerfile](https://docs.docker.com/engine/reference/builder/) correspondiente
4. Por último, pero no menos importante, preste atención al uso de mayúsculas y minúsculas en la variable
`OutputFolder`, ya que los contenedores de Linux distinguen entre mayúsculas y minúsculas. Si el uso de mayúsculas es incorrecto, puede ver una excepción de Docker similar a *error while creating mount source path '/host\_mnt/c/output/UnityServerLinux/PlayFabVmAgentOutput/2020-01-30T12-47-09/GameLogs/a94cfbb5-95a4-480f-a4af-749c2d9cf04b': mkdir /host\_mnt/c/output: file exists*
* Después de realizar todos los pasos anteriores, puede ejecutar LocalMultiPlayerAgent con el comando `LocalMultiplayerAgent.exe -lcow` (lcow significa *Linux Containers On Windows*)
### Solución de problemas
* En modo contenedor, si el servidor de juegos se cierra inmediatamente con un error similar a "Container ... exited with exit code 1", pero funciona bien en modo proceso, asegúrese de haber incluido todas las [DLL del sistema](/services/playfab/multiplayer/servers/determining-required-dlls) necesarias en el paquete de recursos.
* Todos los registros se encuentran en la carpeta `OutputFolder` especificada en el archivo *MultiplayerSettings.json*. **LocalMultiplayerAgent** crea una carpeta nueva cada vez que se inicia, con la marca de tiempo como nombre de carpeta. Todos los registros del servidor de juegos emitidos a través del GSDK se encuentran dentro de la carpeta GameLogs.\
Si el servidor de juegos se ejecuta en un contenedor, puede haber un nivel adicional de jerarquía de directorios que examinar.
* El GSDK escribe registros de depuración en la carpeta GameLogs. Estos registros se encuentran dentro de la carpeta GameLogs junto con los registros generados por el servidor de juegos.
* Asegúrese de que los firewalls (de Windows y otros antivirus) estén configurados para permitir el tráfico por los puertos.
* Si recibe un error similar a: `Docker API responded with status code=InternalServerError, response={"message":"failed to create endpoint on network playfab: hnsCall failed in Win32: The specified port already exists". It's likely there is already a container running on the specified port.` Esto puede ocurrir si **LocalMultiplayerAgent** se cierra prematuramente. Use el comando `docker ps` para encontrar el contenedor que está en ejecución y, después, termínelo mediante `docker kill `.
* Si recibe un error que contiene `Failed to find network 'playfab'`, pruebe a volver a ejecutar *Setup.ps1*
* Si recibe un error `Unhandled Exception`, puede que esté ejecutando PowerShell como administrador.
* `OutputFolder` puede usarse a su vez en otras variables del sistema, así que asegúrese de haber usado una ruta absoluta. Por ejemplo, GSDK\_CONFIG\_FILE tiene esta dependencia, por lo que una ruta relativa (o un valor incorrecto) aquí puede provocar errores al cargar la configuración del servidor de juegos.
### Limitaciones conocidas
1. Es posible que los contenedores no terminen al final de la depuración. Si esto ocurre, ejecute los siguientes comandos de PowerShell como administrador. Estos comandos detienen y quitan todos los contenedores, incluidos los que no inició **LocalMultiplayerAgent**.
```powershell theme={null}
docker stop $(docker ps -aq)
docker rm $(docker ps -aq)
```
## Related topics
- [Ejemplo de Wrapper](/es/services/playfab/multiplayer/servers/wrapper-sample.md)
- [Creación de una compilación de servidor de juegos](/es/services/playfab/multiplayer/servers/author-a-game-server-build.md)
- [Conceptos básicos de un servidor de juegos de PlayFab](/es/services/playfab/multiplayer/servers/basics-of-a-playfab-game-server.md)
- [Depurar servidores de juegos en contenedores con LocalMultiplayerAgent](/es/services/playfab/multiplayer/servers/LocalMultiplayerAgent/run-container-gameserver.md)
- [Depurar servidores de juegos basados en procesos con LocalMultiplayerAgent](/es/services/playfab/multiplayer/servers/LocalMultiplayerAgent/run-process-based-gameserver.md)