Skip to main content
Este artículo contiene detalles sobre cómo crear compilaciones de Linux en PlayFab Multiplayer Servers, tanto mediante contenedores como mediante procesos.

​
Creación e implementación de imágenes de contenedor Linux

Esta sección describe los pasos específicos para ayudarle a crear e implementar imágenes de contenedor Linux. Como se describe en Creación de máquinas virtuales (VM), al usar nuestro servicio, usted configura las máquinas virtuales para que se pongan en marcha automáticamente como servidores de juegos a nivel mundial según su presupuesto y demanda. Para ello, no crea explícitamente las máquinas virtuales, sino que define parámetros que determinan cómo se crean en su nombre. Este proceso se denomina implementar o crear una compilación. PlayFab Multiplayer Servers puede implementar servidores de juegos basados tanto en Linux como en Windows. La forma en que se implementan las compilaciones para contenedores Linux es similar a la de los contenedores Windows, con algunas diferencias importantes. Para obtener más información, consulte Diferencias entre las imágenes de contenedor de Windows y Linux. Si quiere usar PowerShell/API para administrar contenedores Linux, consulte Administración de imágenes de contenedor Linux mediante las API. Al usar servidores de juegos basados en Linux, en lugar de usar una imagen de contenedor administrada, tiene que crear y cargar su imagen de contenedor en un registro de contenedores. Para facilitarle la carga de contenedores, su cuenta incluye un registro de contenedores de Azure.

​
Conocimientos necesarios

​
Configuración del dispositivo de desarrollo Windows

Este paso solo es necesario si quiere usar un dispositivo de desarrollo Windows para crear imágenes de contenedor Linux. Como alternativa, puede usar dispositivos con Linux OS, máquinas virtuales o sistemas de doble sistema operativo con Docker instalado. El Subsistema de Windows para Linux (WSL) le permite usar su dispositivo de desarrollo en el entorno familiar de Windows para crear y administrar imágenes de contenedor Linux. Usar WSL significa que no necesitaría la sobrecarga de una máquina virtual Linux tradicional ni de una configuración de arranque dual.
  1. Instale WSL 2. Asegúrese de reiniciar la máquina y de estar usando WSL 2. También debe instalar el paquete de actualización del kernel de Linux.
  2. Instale una distribución de Linux que use WSL. Aunque nuestras máquinas virtuales usan Ubuntu, puede seleccionar la distribución que quiera para su imagen de contenedor. Considere usar Ubuntu 20.04 Long-Term Support (LTS) o versiones posteriores.
  3. Instale Docker Desktop para Windows con WSL 2. Para el vínculo de descarga directa, vaya a Docker Desktop para Windows (externo).
Verificación de la configuración de WSL 2
  • Abra PowerShell
  • Ejecute wsl -l -v para comprobar que tanto la aplicación docker-desktop como ubuntu están ejecutando WSL 2 (versión 2)
Verificación de que Docker está configurado correctamente para WSL
  • Abra el terminal de WSL
  • Ejecute docker version para confirmar que Docker está instalado y que el sistema operativo usado es Linux
Para desarrollar y depurar aplicaciones C++ de Linux, use WSL en Visual Studio 2019.

​
Obtención de las credenciales de inicio de sesión del registro de contenedores de PlayFab

La cuenta del registro de contenedores de Azure está asociada a su cuenta de PlayFab. Solo usted tiene acceso a los contenedores cargados allí. Este registro de contenedores de Azure es gratuito.
  • En Game Manager, seleccione su título de juego y, después, Multiplayer > Servers. Seleccione New build para abrir la página de creación de compilaciones.
  • Seleccione Linux como sistema operativo de la máquina virtual.
  • Anote las credenciales de inicio de sesión (nombre, contraseña y customer5555555.azurecr.io), ya que esta información se necesitará más adelante
Si prefiere usar PowerShell/API, llame a la API GetContainerRegistryCredentials para recuperar la dirección del registro de contenedores, el nombre de usuario y la contraseña.

​
Creación e inserción de imágenes de contenedor Linux en Azure Container Registry

Estos pasos le ayudarán a crear e insertar su imagen de contenedor Linux personalizada.

​
Integración de la aplicación de servidor de juegos con el GSDK

Al igual que con los servidores Windows, tiene que integrar el código de su servidor de juegos con el SDK de PlayFab Multiplayer Server (GSDK). La integración del GSDK puede formar parte de su imagen de contenedor. Para obtener instrucciones, consulte Creación de una compilación de servidor de juegos e Integración del título con el SDK de servidor de juegos de PlayFab (GSDK).

​
Creación de un Dockerfile

Un Dockerfile es un archivo de texto sin extensión que contiene todos los comandos necesarios para compilar una imagen de contenedor determinada.
  1. Abra el Bloc de notas o cualquier editor adecuado
  2. Agregue los comandos específicos necesarios para ejecutar y compilar un contenedor. Para ver un ejemplo de este archivo, consulte el DockerFile proporcionado en el ejemplo Wrapper. Para más información sobre cómo crear este archivo, consulte Formato de Dockerfile (externo) y Procedimientos recomendados al crear un Dockerfile (externo)
  3. Guarde el archivo como Dockerfile, idealmente en una carpeta o directorio vacío. Debe agregar a esta carpeta los demás archivos que se necesiten para compilar la imagen de contenedor.
Instrucciones para guardar al usar el Bloc de notas:
  • Seleccione File > Save as… para abrir las opciones de guardado
  • Vaya a la carpeta en la que quiera guardar el archivo
  • En File name:, use “Dockerfile”, incluidas las comillas.
  • Para Save as type:, seleccione All Files
  • Seleccione la codificación UTF-8
  • Seleccione Save

​
Compilación y carga de la imagen de contenedor Linux

  1. Abra su terminal de Linux con Docker instalado.
  2. Ejecute los siguientes comandos de Docker con las credenciales de inicio de sesión obtenidas en el paso anterior. Después, siga las instrucciones en pantalla para introducir su nombre de usuario y contraseña.
docker sign in le permite iniciar sesión en el registro de contenedores de Azure tal como se muestra en Game Manager.
  1. Compile la imagen de contenedor
Ejecute el siguiente comando para compilar la imagen de contenedor usando el Dockerfile de su directorio actual. Hay un ”.” al final del comando docker build. La marca -t especifica la información name:tag de su nueva imagen de contenedor. El nombre y la etiqueta se usan si la compilación se realiza correctamente. Si hay errores de compilación, debe corregirlos antes de pasar al paso siguiente. En el ejemplo siguiente, el nombre del repositorio es customer5555555.azurecr.io/pvp_gameserver y la etiqueta es v1. Para más información, consulte la referencia del comando docker build (vínculo externo) y Compilación de un Dockerfile (vínculo externo). Al usar WSL, la unidad C: de Windows está montada en /mnt/c.
  • Después, ejecute cd /mnt/c/path/to/your/Dockerfile para cambiar a la ruta donde se encuentra su Dockerfile. Para más información, consulte Acceso a la unidad C.
Al usar Linux, ejecute pwd para averiguar en qué directorio se encuentra actualmente.
  1. Cargue la imagen de contenedor
Ejecute los comandos para insertar la imagen en su registro de contenedores de PlayFab. Seleccione una combinación name:tag significativa y útil para la imagen de contenedor cargada. Para cargar el contenedor en el registro operado por PlayFab, use docker push u otro cliente de registro de contenedores.

​
Comprobación de que el contenedor se ha cargado

Una vez cargado el contenedor, vuelva a la página New Build de Game Manager y seleccione Refresh Images. Podrá ver la imagen en la lista y seleccionarla. Como alternativa, puede usar la llamada a la API ListContainerImages para enumerar las imágenes de contenedor cargadas. Ahora está listo para implementar servidores. Para obtener instrucciones, consulte Portal de PlayFab: Game Manager y Uso de PowerShell/API.

​
Diferencias entre las imágenes de contenedor de Windows y Linux

Para muchos desarrolladores, usar el contenedor administrado de Windows es la opción sencilla y predeterminada preferida. Sin embargo, las imágenes de contenedor Linux implementadas en máquinas virtuales disfrutan de una tarifa por hora más económica.
Puede personalizar completamente sus servidores de juegos tanto si usa imágenes de contenedor de Windows como de Linux. Al usar servidores Windows, se personaliza la imagen de contenedor administrada cargando recursos.
La tabla siguiente enumera algunas diferencias al crearlas y usarlas.

​
Administración de imágenes de contenedor Linux mediante las API

Puede usar las API para administrar imágenes de contenedor Linux. Para el resto del ciclo de vida de la compilación (ver el uso, actualizar las regiones y las configuraciones de standingBy, eliminación), adminístrelas mediante Game Manager.
  • GetContainerRegistryCredentials: recupere la dirección del registro de contenedores, el nombre de usuario y la contraseña
  • ListContainerImages y ListContainerImageTags: asegúrese de que su nueva imagen y etiqueta aparecen en la lista (a veces puede tardar un par de minutos en registrarse completamente la imagen en el sistema)
  • CreateBuildWithCustomContainer: cree una compilación con un contenedor personalizado. Especifique la imagen etiquetada que cargó anteriormente. Asegúrese de que las siguientes propiedades estén establecidas en la solicitud:
    • ContainerImageReference: el nombre de imagen y la etiqueta que se cargaron anteriormente. Estos valores son visibles en ListContainerImages y ListContainerImageTags.
    • ContainerFlavor: “CustomLinux”
    • ContainerRunCommand (opcional): si su contenedor no tiene un comando predeterminado, use esta propiedad para proporcionar el comando que se va a ejecutar, junto con los argumentos.

​
Empaquetado de recursos para servidores Linux basados en procesos

Al usar Linux en modo de proceso (en lugar de modo de contenedor), se carga el servidor de juegos como un archivo de recursos en lugar de una imagen de contenedor. Esta sección cubre requisitos importantes de empaquetado.

​
Formatos de archivo compatibles

Los recursos deben cargarse como archivos .tar.gz o .tar, para que los permisos de archivos de Unix (como el bit de ejecución) puedan conservarse durante la extracción.
Los archivos .zip no conservan los permisos de archivos de Unix en Linux. Si carga el ejecutable de su servidor de juegos Linux en un archivo .zip, pierde su permiso de ejecución y no se inicia, con un error “Permission denied”. Para solucionar este problema, use .tar.gz en su lugar, o establezca como comando de inicio un script de shell que ejecute chmod +x en el ejecutable antes de iniciarlo.

​
Requisitos de estructura de archivos tar.gz y tar

Al extraer archivos .tar o .tar.gz, PlayFab Multiplayer Servers quita el primer nivel de directorio del archivo (equivalente a tar --strip-components=1). El archivo debe contener un único directorio contenedor de nivel superior con todos los archivos del juego dentro. Estructura correcta: los archivos dentro de un directorio de nivel superior:
Cree el archivo con:
Si los archivos están en la raíz del archivo comprimido sin un directorio contenedor, se omiten silenciosamente durante la extracción. Su servidor de juegos falla con errores “No such file or directory” porque el ejecutable nunca se escribe en el disco.

​
Establecimiento del comando de inicio

Para los servidores basados en procesos, el comando de inicio debe ser relativo a la carpeta raíz de recursos después de la extracción (es decir, relativo a donde terminan los archivos después de quitarse el directorio de nivel superior). Por ejemplo, si el archivo contiene MyGameServer/MyGame.x86_64, después de la extracción el archivo está en la raíz de la carpeta de recursos. Establezca el comando de inicio en:
Si el ejecutable está dentro de una subcarpeta (por ejemplo, MyGameServer/bin/MyGame.x86_64), establezca el comando de inicio en:

​
Administración de compilaciones Linux basadas en procesos mediante las API

Puede usar las API para administrar compilaciones Linux basadas en procesos. Para el resto del ciclo de vida de la compilación (ver el uso, actualizar las regiones y las configuraciones de standingBy, eliminación), adminístrelas mediante Game Manager.
  • CreateBuildWithProcessBasedServer: cree una compilación con el servidor de juegos ejecutándose como proceso. Asegúrese de que las siguientes propiedades estén establecidas en la solicitud:
    • OsPlatform: “Linux”
    • GameAssetReferences: la lista de recursos del juego (cargados como archivos .tar.gz o .tar). Cada recurso requiere un FileName que coincida con el nombre del recurso cargado.
    • StartMultiplayerServerCommand: el comando que se ejecuta cuando se inicia el servidor de juegos. La ruta debe ser relativa a la carpeta raíz de recursos después de la extracción (por ejemplo, MyGame.x86_64 -server).
    • Ports: los puertos que se asignarán para la compilación.
    • MultiplayerServerCountPerVm: el número de instancias de servidor de juegos que se hospedarán en una única máquina virtual.
    • RegionConfigurations: las regiones en las que se va a implementar, con los recuentos de servidores en espera y máximos.

​
Consulte también

Última modificación el 28 de agosto de 2026

Temas relacionados

Implementación de compilaciones mediante PowerShell/APIImplementación de compilaciones de servidores multijugador de PlayFabTutorial: Implementación de compilaciones mediante PowerShell/APIImplementación de un servidor Linux de Unreal en la nube de MPSEjemplo de Wrapper