Amazon GameLift - Developer Guide · Configurar Amazon GameLift para que aloje un juego implica trabajar con los siguientes componentes: • Un servidor de juegos es un software del

Amazon GameLiftDeveloper Guide

Version

Amazon GameLift Developer Guide

Amazon GameLift: Developer GuideCopyright © 2018 Amazon Web Services, Inc. and/or its affiliates. All rights reserved.

Amazon's trademarks and trade dress may not be used in connection with any product or service that is not Amazon's, in any mannerthat is likely to cause confusion among customers, or in any manner that disparages or discredits Amazon. All other trademarks notowned by Amazon are the property of their respective owners, who may or may not be affiliated with, connected to, or sponsored byAmazon.


Table of Contents¿Qué es Amazon GameLift? ................................................................................................................ 1

¿Por qué Amazon GameLift? ....................................................................................................... 1Características clave ................................................................................................................... 1Cómo funciona GameLift ............................................................................................................. 2

Componentes principales ..................................................................................................... 2Alojamiento de servidores de juegos ..................................................................................... 2Ubicación de sesiones de juego ........................................................................................... 3Gestión de capacidad y escalado ......................................................................................... 3Monitorización de la actividad de la flota y resolución de problemas ........................................... 5Conectividad de red con los recursos de AWS ........................................................................ 6

Arquitectura de juego en GameLift ................................................................................................ 6Cómo se conectan los jugadores a los juegos ................................................................................ 8

Características de la sesión de juego y de jugador .................................................................. 9GameLift FlexMatch .................................................................................................................. 10

Funcionamiento de GameLift FlexMatch ............................................................................... 11Herramientas y recursos ............................................................................................................ 14

Principales herramientas .................................................................................................... 14Recursos adicionales ......................................................................................................... 14

SDK de GameLift ...................................................................................................................... 15Para servidores de juegos .................................................................................................. 15Para clientes y servicios de juego ....................................................................................... 16Compatibilidad con SDK .................................................................................................... 16

Capa gratuita y alertas de facturación .......................................................................................... 17Configuración ................................................................................................................................... 18

Configuración del proyecto ......................................................................................................... 18Configuración de una cuenta de AWS ......................................................................................... 18

Ejemplos de política de IAM ............................................................................................... 19Instalar la AWS CLI .................................................................................................................. 20

Integración de GameLift ..................................................................................................................... 21Plan de integración ................................................................................................................... 21Motores de videojuegos y GameLift ............................................................................................. 23

Amazon Lumberyard ......................................................................................................... 23Unreal Engine .................................................................................................................. 24Unity ............................................................................................................................... 24Otros motores .................................................................................................................. 24Lumberyard: preparación de un cliente de juego .................................................................... 24Unreal Engine: adición de GameLift a un proyecto del servidor de juegos .................................. 25Unity: adición de GameLift a un proyecto del servidor de juegos .............................................. 28

Integración de un servidor de juegos ........................................................................................... 31Adición de GameLift a un servidor de juegos ........................................................................ 31

Integración de un cliente de juego ............................................................................................... 35Adición de GameLift a un cliente de juego ............................................................................ 35Creación de sesiones de juego con colas ............................................................................. 39Generación de ID de jugador .............................................................................................. 39

Interacciones de GameLift .......................................................................................................... 40Configuración de un proceso del servidor nuevo .................................................................... 40Creación de una sesión de juego ........................................................................................ 40Adición de un jugador a una sesión de juego ........................................................................ 40Eliminación de un jugador de una sesión de juego ................................................................. 41Cierre de una sesión de juego ............................................................................................ 41Finalización de un proceso del servidor ................................................................................ 41Respuesta a una solicitud de cierre ..................................................................................... 42GameLift: interacciones del cliente/servidor de juegos ............................................................ 43

Prueba de la integración ............................................................................................................ 44

Versioniii


Configuración de Amazon GameLift Local ............................................................................ 44Prueba de un servidor de juegos ........................................................................................ 44Prueba de un servidor y un cliente de juego ......................................................................... 46Variaciones de Local ......................................................................................................... 48

Carga del juego en GameLift .............................................................................................................. 49Empaquetado de los archivos de compilación ............................................................................... 49

Creación de un script de instalación .................................................................................... 49Carga de archivos de compilación ............................................................................................... 50

Creación de una compilación con archivos en un directorio ..................................................... 51Creación de una compilación con archivos en Amazon S3 ...................................................... 52Actualización de los archivos de compilación ........................................................................ 54

Uso de flotas ................................................................................................................................... 55Configuración de flotas .............................................................................................................. 55

Elección de los recursos informáticos .................................................................................. 56Ejecución de varios procesos ............................................................................................. 57Creación de una flota ........................................................................................................ 60Problemas al crear una flota de depuración .......................................................................... 65Administración de los registros de la flota ............................................................................. 66

Administración de la capacidad de la flota .................................................................................... 67Establecimiento de los límites de capacidad de la flota ........................................................... 68Establecimiento manual de la capacidad de la flota ................................................................ 70Escalado automático de la capacidad de la flota .................................................................... 72

Guía de integración de flotas de spot .......................................................................................... 77Acceso remoto a instancias de una flota ...................................................................................... 79

Conexión a una instancia ................................................................................................... 79Visualización y actualización de instancias remotas ................................................................ 81

Configuración de la interconexión de VPC .................................................................................... 81Uso de alias .................................................................................................................................... 85

Creación de un alias ................................................................................................................. 85Edición de un alias ................................................................................................................... 85

Uso de colas .................................................................................................................................... 87Diseño de colas ........................................................................................................................ 87

¿Por qué conviene usar las colas? ...................................................................................... 87Consejos sobre la configuración de destinos de las colas ....................................................... 88Diseño de una cola de varias regiones ................................................................................ 89Diseño de las políticas de latencia de los jugadores ............................................................... 90Diseño de una cola para instancias de spot .......................................................................... 90Funcionamiento de FleetIQ ................................................................................................ 91Evaluación de métricas de cola .......................................................................................... 92

Creación de una cola ................................................................................................................ 92Creación de una cola (consola) .......................................................................................... 93Creación de una cola (AWS CLI) ........................................................................................ 94

Visualización de las colas .......................................................................................................... 95Visualización de los detalles de la cola ........................................................................................ 96

Resumen ......................................................................................................................... 96Destinos .......................................................................................................................... 96Políticas de latencia de los jugadores .................................................................................. 96Métricas de la cola ........................................................................................................... 97

Emparejamientos con FlexMatch ......................................................................................................... 98Guía de integración de FlexMatch ............................................................................................... 98Diseño de un creador de emparejamientos ................................................................................... 99

Configuraciones de creadores de emparejamientos ................................................................ 99Crear una configuración de emparejamiento ........................................................................ 101

Crear un conjunto de reglas ..................................................................................................... 102Componentes de un conjunto de reglas .............................................................................. 103Crear un conjunto de reglas de emparejamiento .................................................................. 104Ejemplos de conjuntos de reglas ....................................................................................... 105

Versioniv


Configurar la notificación de eventos .......................................................................................... 115Configuración de Eventos de CloudWatch ........................................................................... 116Configuración de un tema de SNS ..................................................................................... 116

Agregar FlexMatch a un cliente de juego .................................................................................... 117Solicitar el emparejamiento de jugadores ............................................................................ 118Hacer un seguimiento del estado de las solicitudes de emparejamiento ................................... 119Solicitar aceptación del jugador ......................................................................................... 120Conexión a un emparejamiento ......................................................................................... 120Ejemplo de solicitud de StartMatchmaking .......................................................................... 120

Agregar FlexMatch a un servidor de juegos ................................................................................ 121Configurar el servidor de juegos para el emparejamiento ....................................................... 122Trabajo con datos del creador de emparejamientos .............................................................. 122

Reposición de juegos existentes ................................................................................................ 123Envío de solicitudes de reposición (desde un servidor de juegos) ........................................... 124Envío de solicitudes de reposición (desde un servicio de cliente) ............................................ 125Actualización de datos de emparejamientos en el servidor de juegos ....................................... 127

Visualización de los datos de juego ................................................................................................... 129Visualización del estado actual de GameLift ................................................................................ 129Visualización de las compilaciones ............................................................................................ 130

Catálogo de compilaciones ............................................................................................... 130Detalles de la compilación ................................................................................................ 131

Visualización de flotas ............................................................................................................. 131Visualización de los detalles de la flota ...................................................................................... 132

Resumen ....................................................................................................................... 132Métricas ......................................................................................................................... 132Eventos ......................................................................................................................... 133Escalado ........................................................................................................................ 133Sesiones de juego .......................................................................................................... 134Desarrollo ...................................................................................................................... 135Asignación de capacidad .................................................................................................. 135Puertos .......................................................................................................................... 135ARN .............................................................................................................................. 135

Visualización de información sobre juego y jugador ...................................................................... 135Sesiones de juego .......................................................................................................... 136Sesiones de jugador ........................................................................................................ 136Información sobre el jugador ............................................................................................. 136

Visualización de alias .............................................................................................................. 137Catálogo de alias ............................................................................................................ 137Detalle de los alias .......................................................................................................... 137

Monitorización de GameLift .............................................................................................................. 138Monitorización con CloudWatch ................................................................................................. 138

Métricas de Amazon GameLift para flotas ........................................................................... 138Métricas de Amazon GameLift para colas ........................................................................... 143Métricas de Amazon GameLift para el emparejamiento ......................................................... 145Dimensiones de métricas de Amazon GameLift ................................................................... 148

Registro de llamadas a API ...................................................................................................... 148Información de Amazon GameLift en CloudTrail ................................................................... 149Descripción de las entradas de archivos de log de Amazon GameLift ...................................... 149

Guías de referencia de Amazon GameLift ........................................................................................... 152Referencia de la API de servidor (C++) ...................................................................................... 152

Actions .......................................................................................................................... 152Tipos de datos ................................................................................................................ 164

Referencia de la API de servidor (C#) ........................................................................................ 168Actions .......................................................................................................................... 168Tipos de datos ................................................................................................................ 178

Referencia de la API del servidor (Unreal Engine) ........................................................................ 182Actions .......................................................................................................................... 183

Versionv


Tipos de datos ................................................................................................................ 187Reglas de FlexMatch ............................................................................................................... 189

Tipos de regla ................................................................................................................ 189Expresiones de propiedades ............................................................................................. 191

Eventos de FlexMatch ............................................................................................................. 193Historial de revisión ......................................................................................................................... 205

Versionvi

Amazon GameLift Developer Guide¿Por qué Amazon GameLift?

¿Qué es Amazon GameLift?Amazon GameLift es un servicio totalmente administrado para implementar, utilizar y escalar servidoresde juegos multijugador basados en sesiones en la nube. Amazon GameLift sustituye el trabajo necesariopara alojar sus propios servidores de juego, incluyendo la compra y la configuración de hardware, yla administración de la actividad continuada, la seguridad, el almacenamiento y el seguimiento deldesempeño. Las funcionalidades de escalado automático de Amazon GameLift proporcionan protecciónadicional para no tener que pagar más recursos de los necesarios, al mismo tiempo que garantizan que losjugadores puedan encontrar juegos y conectarse a ellos con una espera mínima.

¿Por qué Amazon GameLift?A continuación presentamos algunas de las ventajas del uso de Amazon GameLift:

• Transmisión de experiencia de jugador de baja latencia para ser compatible con un juego rápido.• Lanzamiento de juegos multijugador rápidos basados en sesiones que requieren poca o ninguna

experiencia de back-end.• Mejora de los servicios de emparejamiento con colas inteligentes, ubicación de sesiones de juego y

reposición.• Reducción del esfuerzo operativo y de ingeniería para implementar y operar los servidores de juego.• Inicio rápido y pago según el uso, sin costos anticipados ni compromisos a largo plazo.• Reducción de costos hasta un 90% con las instancias de spot.• Uso de Amazon Web Services (AWS), incluido Amazon Elastic Compute Cloud (Amazon EC2), para

los recursos de informática en la nube a escala de la web y el escalado automático para administrar lacapacidad de alojamiento.

Características claveAmazon GameLift incluye estas características:

• Utilice FlexMatch y Queues para crear un servicio de emparejamiento personalizado para su juego.• Uso de colas de sesiones de juego para ubicar sesiones de juego nuevas de forma más efectiva entre

los recursos de Amazon GameLift.• Implementación de servidores de juego para ejecutarlos en sistemas operativos de Amazon Linux o

Windows Server.• Alojamiento de juegos de gran calidad para jugadores de todo el mundo mediante la implementación de

recursos informáticos en varias regiones.• Deje que FleetIQ optimice el uso de las instancias de spot para reducir los costos de alojamiento

utilizando instancias de spot con precios reducidos y frecuencias de interrupción bajas.

Uso de herramientas de escalado automático para ajustar la capacidad de alojamiento del juego parasatisfacer el uso de los jugadores reales y compensar la experiencia de los jugadores mediante lareducción de los costos.

Version1

https://aws.amazon.com/ec2/

Amazon GameLift Developer GuideCómo funciona GameLift

• Configuración de las características de la sesión de juego, como el número máximo de jugadorespermitido, las normas de participación y las propiedades específicas del juego.

• Ayuda a los jugadores en su búsqueda de sesiones a las que conectarse rápidamente concaracterísticas de búsqueda de sesión de juego.

• Análisis del desempeño de juego utilizando la consola de Amazon GameLift para realizar un seguimientode las métricas, ver los logs de sesión de juego y revisar los datos de sesiones de juego y de jugadorindividuales.

• Configuración del seguimiento de estado personalizado para procesos del servidor para detectarproblemas de forma rápida y resolver los problemas de desempeño bajo de los procesos.

Para obtener más información acerca de Amazon GameLift, incluidas las especificaciones y los precios,consulte las páginas de productos de Amazon GameLift.

Funcionamiento de Amazon GameLiftEn este tema se ofrece una descripción general de los componentes de Amazon GameLift y se explicacómo el servicio implementa los servidores de juegos multijugador y administra el tráfico de jugadores.

Componentes principalesConfigurar Amazon GameLift para que aloje un juego implica trabajar con los siguientes componentes:

• Un servidor de juegos es un software del servidor de juegos que se ejecuta en la nube. Carga unaversión de servidor de juegos en Amazon GameLift, que incluye los ejecutables del servidor, los activoscompatibles, las bibliotecas y las dependencias. Amazon GameLift implementa su servidor de juegos enrecursos informáticos virtuales para alojamiento.

• Una sesión de juego es una instancia de su servidor de juegos, que se ejecuta en Amazon GameLift, ala que los jugadores se conectan y con la que interactúan. Un juego define las características básicas deuna sesión de juego, como su vida útil o número de jugadores.

• El servicio de Amazon GameLift gestiona los recursos informáticos necesarios para alojar su servidorde juegos y permite a los jugadores conectarse a juegos. Regula el número de recursos para demandade los jugadores, inicia y detiene las sesiones de juego y gestiona las solicitudes de unión de jugadoresbuscando y reservando ranuras de jugadores en sesiones de juego activas. El servicio también recopiladatos de desempeño sobre el estado del proceso del servidor y sobre el uso de los jugadores.

• Un cliente de juego es el software del juego que se ejecuta en el dispositivo de un jugador. Con el clientede juego, un jugador puede conectarse a una sesión de juego que esté alojada en Amazon GameLift.

• Los servicios de juegos pueden comunicarse con el servicio Amazon GameLift para distintos fines. Porejemplo, puede crear un servicio de juegos para actuar como intermediario entre clientes y servidores dejuegos como, por ejemplo, para administrar el emparejamiento o la autenticación de jugadores.

Consulte Interacciones de Amazon GameLift y el cliente/servidor de juegos (p. 40) para obtener unadescripción detallada sobre cómo interactúan estos componentes.

Alojamiento de servidores de juegosPara alojar un servidor de juegos en Amazon GameLift, necesita una flota de recursos informáticosvirtuales, denominados instancias. El tipo de instancia que elija para una flota determina el hardwareinformático (incluida la potencia, la memoria, la capacidad de red, etc.) que se utilizará para alojarlos servidores de juegos. Obtenga más información acerca de cómo Elección de los recursosinformáticos (p. 56), incluido cómo trabajar con instancias de spot para reducir los costos dealojamiento.

Version2

https://aws.amazon.com/gamelift/faq

Amazon GameLift Developer GuideUbicación de sesiones de juego

Cada instancia de una flota puede ejecutar varios procesos de servidor simultáneamente, en función dela capacidad del hardware y cada proceso de servidor puede alojar una sesión de juego. Dado que unaversión de servidor de juegos puede tener uno o varios archivos ejecutables, puede configurar una flotapara ejecutar varios procesos de cada ejecutable en cada instancia. Tendrá que encontrar la configuraciónadecuada para equilibrar las necesidades informáticas del servidor del juego (y la cantidad de procesos delservidor que ejecutar) frente a las capacidades del tipo de instancia que elija. Más información acerca deejecución de varios procesos en una flota (p. 57).

Una flota implementa su versión de servidor de juegos en una única región de AWS. Para cada regiónen la que desea implementar su versión de servidor de juego, debe configurar una flota independiente.Para obtener una lista de las regiones disponibles para Amazon GameLift, consulte Regiones y puntos deconexión de AWS.

Le recomendamos asignar un alias a la flota. Un alias es una forma cómoda de establecer el modo enque los clientes de juego se conectan a los servidores de juegos. Puesto que puede cambiar un alias paraque apunte hacia la flota que desee, hacer referencia a un ID de alias en el cliente en lugar de a un ID deflota le ayuda a traspasar de forma sencilla los jugadores de una flota a otra, sin tener que implementaractualizaciones de cliente de juego.

Ubicación de sesiones de juegoUna vez que una versión del servidor de juegos se ha implementado correctamente en una flota, la flotaestá lista para alojar las sesiones de juego. Un cliente de juego o un servicio del cliente envía una solicitud,en nombre de uno o varios jugadores, para una sesión de juego nueva. Cuando se recibe una solicitudpara una nueva sesión de juego, la característica FleetIQ de Amazon GameLift busca los recursos dealojamiento disponibles y ubica la nueva sesión de juego en la mejor flota posible.

Puede definir qué significa "la mejor flota posible" para su juego mediante la creación de una cola desesiones de juego. Una cola identifica una lista de flotas en las que se pueden colocar nuevas sesionesde juego y define cómo elegir la mejor flota para cada sesión de juego nueva. Cuando su cliente de juegoo servicio de cliente solicita una nueva sesión de juego, especifica qué cola utilizar para su ubicación.La nueva sesión de juego puede ubicarse en cualquier flota de la cola que tenga un proceso de servidordisponible. Las colas pueden contener flotas que se encuentran en distintas regiones. Por ejemplo, podríaconfigurar una cola para ubicar sesiones de juego en cualquiera de las cinco regiones de Norteamérica.Con una cola de varias regiones, es más probable que Amazon GameLift encuentre recursos disponibles,incluso en momentos de tráfico intenso, e inicie una nueva sesión de juego de forma rápida.

Hay dos formas en las que FleetIQ localiza la mejor ubicación posible para una sesión de juego nueva. Laforma más eficaz es mediante la evaluación de la latencia del jugador. Las solicitudes de ubicación puedenincluir los datos de latencia de los jugadores para cada región cubierta en la cola. Si se proporcionan losdatos de latencia, FleetIQ busca disponibilidad de alojamiento en la región que ofrezca la latencia más bajapara los jugadores de la solicitud. Si opta por no facilitar datos de latencia, puede priorizar manualmenteuna lista de flotas en la cola. Al buscar disponibilidad de alojamiento, Amazon GameLift empieza por laparte superior de la lista y va bajando. En este caso, las sesiones de juego se suelen ubicar en la flota conmayor prioridad, y las flotas adicionales actúan como backup.

La cola es un concepto potente que puede utilizarse para resolver una serie de problemas. Las colaspueden equilibrar el uso de recursos en regiones y reducir la cantidad de tiempo de espera para jugadoresdurante picos de demanda inesperados. Se puede utilizar para mitigar reducciones de velocidad ointerrupciones en la región. También puede utilizarlas para crear grupos de jugadores que abarcanregiones. Las colas se necesitan cuando se utiliza el emparejamiento de FlexMatch o las flotas de spot deAmazon GameLift. Obtenga más información sobre cómo Diseño de colas de sesiones de juego (p. 87).

Gestión de capacidad y escaladoUna vez que una flota está activa y lista para alojar sesiones de juego, tendrá que ajustar la capacidadde la flota para satisfacer la demanda de los jugadores. Dado que el costo de alojamiento se basa en

Version3

https://docs.aws.amazon.com/general/latest/gr/rande.html#gamelift-region


Amazon GameLift Developer GuideGestión de capacidad y escalado

la cantidad utilizada de la capacidad, es importante encontrar el equilibrio entre el mantenimiento deuna capacidad de flota suficiente para los jugadores entrantes y la prevención de un gasto excesivo porrecursos que quedan sin utilizar durante los tiempos de inactividad.

La capacidad de la flota se mide en instancias. La configuración de una flota determina cuántas sesionesde juego y jugadores puede albergar cada instancia. Para ajustar la capacidad de la flota, puede aumentaro reducir el número de instancias en esta. Amazon GameLift ofrece varias opciones para administrarla capacidad de la flota. El método más eficaz, con diferencia, es utilizar la característica de escaladoautomático de Amazon GameLift, pero también puede establecer la capacidad de la flota manualmente.Obtenga más información sobre cómo Administración de la capacidad de la flota (p. 67).

Escalado automáticoEl escalado automático es una forma rápida, eficaz y precisa para hacer coincidir la capacidad de laflota con el uso por parte de los jugadores. Con el escalado automático, Amazon GameLift realiza unseguimiento de las métricas de alojamiento de la flota y determina cuándo añadir o eliminar instanciasen función de una serie de directrices, denominadas políticas, que puede definir. Con las políticas deescalado automático adecuadas, Amazon GameLift puede ajustar la capacidad directamente en respuestaa los cambios en la demanda de los jugadores, de modo que la flota siempre pueda dar cabida a nuevosjugadores sin mantener una cantidad excesiva de recursos inactivos. Obtenga más información sobre lamejora de la eficacia de costos con el escalado automático.

Existen dos tipos de escalado automático disponibles: el basado en destino y el basado en reglas. Laopción recomendada es utilizar escalado automático basado en destino como la opción más sencilla yeficaz. El escalado automático basado en reglas ofrece un control más detallado sobre las acciones deescalado, pero resulta difícil de configurar y administrar. Para la mayoría de juegos, el seguimiento dedestino es suficiente.

El escalado automático basado en destino le permite seleccionar el resultado deseado y hacer queAmazon GameLift aumente o disminuya la flota para llegar a ese resultado. La herramienta de Seguimientode destino se basa en una sola métrica clave: el porcentaje de recursos que están disponibles para alojarsesiones de juego que no se utilizan actualmente. Estos recursos compondrán su búfer: ya que estánpreparados para alojar partidas, representan el número de nuevas sesiones de juego y nuevos jugadoresque pueden unirse al juego con un periodo de espera mínimo. El Seguimiento de destino le permite elegirun tamaño del búfer, como porcentaje del total de la capacidad de la flota, que mejor se adapte a su juego.Por ejemplo, si la demanda para su juego es muy volátil, es posible que desee utilizar un búfer de mayortamaño. Con el seguimiento de destino activado, Amazon GameLift añade y elimina las instancias quesean necesarias para mantener el tamaño del búfer de destino. Para la mayoría de juegos, el seguimientode destino representa la mejor opción para administrar la capacidad de la flota. Aprenda cómo Escaladoautomático con Seguimiento de destino (p. 72).

El escalado automático basado en reglas ofrece un control más detallado sobre la actividad de escaladoautomático, pero resulta significativamente más difícil de administrar. Todas las políticas basadas en reglasespecifican cuándo y cómo disparar un evento de escalado. Por ejemplo, esta instrucción de la políticapuede utilizarse para disparar un evento de ampliación: "Si las instancias inactivas caen por debajo de 20durante 10 minutos consecutivos, aumentar la capacidad en un 10 %". Con el escalado automático basadoen reglas, la mayor parte de las flotas requieren múltiples políticas para mantener automáticamente lacapacidad de la flota. Dado que las políticas se evalúan de forma independiente y pueden tener efectoscompuestos inesperados, esta opción aumenta la complejidad del alojamiento de juegos. Aprenda cómoEscalado automático con políticas basadas en reglas (p. 73).

Escalado de flotas en acciónUn evento de escalado de flotas se puede disparar de varias maneras, ya sea mediante un cambio en lacapacidad deseada a través de escalado automático o escalado manual, o cuando se cierran instanciasdebido a su estado o por otros motivos. Básicamente, todos los eventos de escalado se activan cuando elrecuento de instancias "deseadas" no coincide con su recuento de instancias "activo". Esta circunstancia

Version4

https://aws.amazon.com/gamelift/pricing

https://aws.amazon.com/gamelift/pricing

Amazon GameLift Developer GuideMonitorización de la actividad dela flota y resolución de problemas

hace que Amazon GameLift agregue o elimine instancias, según resulte necesario, para que el recuento deinstancias activas coincida con el recuento de instancias deseadas.

• Cuando el recuento de instancias deseadas supera el recuento de instancias activas, Amazon GameLiftsolicita instancias adicionales y, una vez disponibles, comienza el proceso de instalación de la versióndel servidor del juego en las nuevas instancias y de inicio de los procesos del servidor del juego. Encuanto un proceso del servidor esté activo en una instancia, el número de instancias activas aumentade uno en uno. Amazon GameLift sigue añadiendo instancias hasta que los dos valores de recuento seigualen.

• Cuando el recuento de instancias activas supera al recuento de instancias deseadas, Amazon GameLiftempieza a buscar instancias que pueda terminar. Cualquier instancia disponible (es decir, que no alojeninguna sesión de juego) se puede terminar, así como cualquier instancia no protegida, incluso si alojasesiones de juego activas. Si no se puede terminar ninguna instancia, el evento de reducción de laescala producirá un error. En este caso, la disparidad entre el recuento de instancias deseadas y activasseguirá disparando eventos de reducción de escala hasta que una instancia quede libre y se puedaterminar. A continuación, Amazon GameLift inicia el proceso de terminación, que incluye la notificacióna todos los procesos del servidor en la instancia para iniciar un apagado sin problemas. Una vez que lainstancia se ha terminado, el número de instancias activas disminuye en uno. Amazon GameLift sigueañadiendo instancias hasta que los dos valores de recuento se igualen.

Características de escalado adicionalesEntre las características adicionales relacionadas con la capacidad de la flota y el escalado se incluyen:

• Protección de la sesión de juego: evita que las sesiones de juego que alojan a jugadores activos seterminen durante un evento de reducción de la escala. La protección de la sesión de juego se puedenactivar para toda la flota o se puede activar para sesiones de juego individuales. No se puede terminaruna instancia si alguno de sus procesos de servidor aloja sesiones de juego protegidas. Las sesiones dejuego no están protegidas ante la terminación debida a interrupciones relacionadas con su estado o coninstancias de subasta (consulte Instancias bajo demanda frente a instancias de spot (p. 56)).

• Límites de escalado: control del uso general de instancias mediante el establecimiento de límitesmínimos y máximos para el número de instancias en una flota. Estos límites se aplican al realizar unescalado automático o al establecer la capacidad manualmente.

• Habilitar/deshabilitar el escalado automático: activación/desactivación del escalado automático en elnivel de flota sin cambiar ni eliminar las políticas de escalado automático. Esta característica le permiteescalar temporalmente las flotas manualmente cuando sea necesario.

• Métricas de escalado: realiza un seguimiento del historial de capacidad de una flota y los eventos deescalado en forma de gráfico. Visión de la capacidad en conjunto con las métricas de uso de la flotapara evaluar la efectividad del enfoque de escalación. En el siguiente gráfico se muestra una flota conseguimiento de destino establecido en un búfer del 15 %; el porcentaje de ranuras de sesiones de juegodisponibles (en verde) se ajusta automáticamente a medida que cambia la capacidad de la flota (en azuly naranja).

Monitorización de la actividad de la flota y resoluciónde problemasEn cuanto las flotas ya estén operativas, Amazon GameLift recopilará distintos tipos de información que leayudarán a monitorizar el desempeño de los servidores de juegos implementados. Utilice esta información

Version5

Amazon GameLift Developer GuideConectividad de red con los recursos de AWS

para optimizar el uso de los recursos, resolver problemas y obtener información sobre la actividad de losjugadores en los juegos.

• Flota, sesión de juego y detalles sobre la sesión de jugador: estos datos incluyen el estado, que le ayudaa identificar los problemas de estado, así como información detallada como la duración de una sesión dejuego y el tiempo de conexión del jugador.

• Métricas de utilización: Amazon GameLift realiza el seguimiento de las métricas de flota a lo largo deltiempo:• Para las instancias: la actividad de red y el uso de la CPU• Para los procesos del servidor: el número de procesos activos, activaciones nuevas y terminaciones• Para juegos y jugadores: el número de sesiones de juego y de jugador activas

• Estado del proceso del servidor: Amazon GameLift realiza el seguimiento del estado de cada procesodel servidor que se ejecuta en una flota, incluyendo el número de procesos en buen estado, elporcentaje de procesos activos en buen estado y el número de terminaciones anormales.

• Logs de sesiones de juego: puede hacer que los servidores de juegos registren los datos de sesión yordenar a Amazon GameLift que recopile y almacene los logs al finalizar la sesión de juego. Los logspueden descargarse desde el servicio.

Todos estos datos están disponibles mediante la consola de Amazon GameLift. El panel de la consolapresenta un resumen de la actividad de todas las compilaciones y flotas, así como la opción de obtenerinformación más detallada.

Conectividad de red con los recursos de AWSSi el servidor de juegos se comunica con otros recursos alojados en AWS, puede utilizar la interconexiónde Amazon Virtual Private Cloud (VPC) para establecer conexiones rápidas y seguras. Una AmazonVPC es una red virtual definida por usted, que incluye un conjunto de recursos que se administran con sucuenta de AWS. Además, cada flota de Amazon GameLift, incluidos los procesos del servidor de juegosque se ejecutan en cada instancia de la flota, tiene su propia VPC. Gracias a la interconexión de VPC,puede establecer una conexión de red directa entre una VPC para los procesos del servidor de juegos yuna VPC para sus otros recursos de AWS.

Puede tener un conjunto de servicios web que se utilizan con el juego, por ejemplo, para la autenticaciónde jugadores o las redes sociales. Puede configurar una VPC para estos recursos y, a continuación, utilizarla característica de interconexión de VPC de Amazon GameLift para permitir que los servidores de juegosrealicen llamadas de red directas a los servicios web. Gracias a la interconexión de VPC, las llamadasdesde los procesos del servidor de juegos tienen una latencia mínima y, dado que no se redirigen a travésde la red pública de Internet, no están expuestas a amenazas externas.

Consulte más información sobre las nubes virtuales privadas y sobre la interconexión de VPC de Amazon.Puede interconectar sus flotas de Amazon GameLift con las VPC de cualquier cuenta de AWS a la quetenga acceso.

Amazon GameLift simplifica el proceso de configuración de la interconexión de VPC para los servidores dejuegos. Gestiona las solicitudes de interconexión, actualiza la tablas de ruteo y configura las conexionessegún sea necesario. Para obtener más información sobre cómo establecer la interconexión de VPC paralos servidores de juegos, consulte Configuración de la interconexión de VPC (p. 81).

Arquitectura de juego en Amazon GameLiftEl diagrama que aparece a continuación ilustra los componentes clave de un juego alojado en AmazonGameLift y el modo en que interactúan.

Version6

https://console.aws.amazon.com/gamelift/

https://docs.aws.amazon.com/vpc/latest/userguide/VPC_Introduction.html

https://docs.aws.amazon.com/vpc/latest/peering/Welcome.html

Amazon GameLift Developer GuideArquitectura de juego en GameLift

A continuación se describen los componentes clave.

Servicio Amazon GameLift

El servicio implementa los servidores de juegos en recursos de alojamiento en Amazon GameLift y controlala capacidad en función de la configuración. Además, administra la demanda de jugadores iniciandosesiones de juego nuevas y reservando ranuras de juego para jugadores nuevos. También realiza unseguimiento continuo del estado de los recursos de juego, las sesiones de juego y los jugadores paragarantizar la disponibilidad del juego y equilibrar el tráfico de jugadores.

Clientes de juego

Version7

Amazon GameLift Developer GuideCómo se conectan los jugadores a los juegos

El cliente de juego puede interactuar con Amazon GameLift de dos formas:

• Se comunica con el servicio Amazon GameLift para recuperar información sobre las sesiones de juegoactuales, solicitar sesiones de juego nuevas y solicitar ranuras en los juegos. Los clientes de juegopueden comunicar directamente con el servicio (tal y como muestra la línea de puntos), pero es normalque los servicios de juegos gestionen esta comunicación junto con otras tareas principales y que, acontinuación, transmitan la información según sea necesario al cliente de juego.

• Conecta directamente con una sesión de juego que se ejecuta en un servidor de juegos. Los detalles deconexión de una sesión de juego se proporcionan en respuesta a una solicitud de ranura de un jugador.Si utiliza un servicio de juegos para gestionar las solicitudes de los jugadores dirigidas al servicioAmazon GameLift, debe transmitir la información de la conexión al cliente de juego.

Servicios de juegos

Su juego puede decidir gestionar determinadas tareas a través de servicios de juegos en lugar de enel cliente de juego. Estos servicios los desarrolla y gestiona usted. A menudo, los servicios de juegosse utilizan para realizar tareas como la autenticación y autorización de los jugadores, la compilacióny el emparejamiento del equipo y el control de inventario o de divisas. Si su juego utiliza servicios, serecomienda llamar al servicio Amazon GameLift desde un servicio de juegos en lugar de desde el clientede juego. Por ejemplo, si un jugador quiere unirse a un juego, su cliente de juego podría llamar a suservicio de autenticación para verificar primero la identidad del jugador y, a continuación, enviar unasolicitud de ranura de un jugador al servicio Amazon GameLift.

Servidores de juegos

El software de servidor de juegos lo implementa Amazon GameLift en función de su configuración. Puedeordenar a Amazon GameLift que implemente uno o varios servidores de juegos en todas las regiones deAWS que necesite. Los servidores de juegos comunican con el servicio Amazon GameLift para iniciarsesiones de juego nuevas, validar los jugadores que se acaban de conectar e informar sobre el estado delas sesiones de juego, las conexiones de los jugadores y los recursos disponibles.

Servicios externos

Su juego puede confiar en un servicio externo para, por ejemplo, validar una suscripción. El diagrama dearquitectura muestra cómo la información de un servicio externo puede transferirse a los servidores dejuegos (a través de un servicio de juegos personalizado y el servicio Amazon GameLift) sin pasar por elcliente de juego.

Herramientas para desarrolladores

El conjunto de herramientas para desarrolladores de Amazon GameLift se utiliza para configurar losrecursos de alojamiento y la implementación de juegos, escalar la capacidad, monitorizar el estado actualde los recursos y realizar un seguimiento de las métricas de desempeño del servidor de juegos y laactividad de los jugadores y de los juegos.

Cómo se conectan los jugadores a los juegosUna sesión de juego es una instancia del juego que se ejecuta en Amazon GameLift. Para jugar al juego,los jugadores pueden buscar y conectarse a una sesión de juego existente o crear una nueva sesión dejuego y conectarse a ella. Los jugadores se conectan a la sesión mediante la creación de una sesión dejugador para la sesión de juego. Si la sesión de juego está abierta a jugadores (es decir, que se aceptanjugadores nuevos y tiene una ranura de jugador abierta), Amazon GameLift reserva una ranura para eljugador y proporciona la información de conexión al jugador. A continuación, el jugador podrá conectarse ala sesión de juego y aprovechar la ranura reservada.

Version8

Amazon GameLift Developer GuideCaracterísticas de la sesión de juego y de jugador

Para obtener información detallada sobre cómo crear y administrar sesiones de juego y de jugador,consulte Adición de Amazon GameLift al cliente de juego (p. 35).

Características de la sesión de juego y de jugadorAmazon GameLift ofrece varias características relacionadas con las sesiones de juego y de jugador:

Alojamiento de sesiones de juego en los mejores recursosdisponibles en varias regionesElija entre varias opciones al configurar la manera en que Amazon GameLift selecciona recursos paraalojar nuevas sesiones de juego. Si ejecuta varias flotas en más de una región, puede configurar las colasde sesión de juego que pueden colocar una nueva sesión de juego en cualquier flota independientementede la región. Esta función permite mejorar significativamente la capacidad del servicio Amazon GameLiftpara equilibrar de forma eficaz el uso de los recursos y responder a los cambios de la demanda de losjugadores, las disminuciones de capacidad, las interrupciones y otros problemas. Como resultado, el usode colas puede reducir la sobrecarga manual necesaria para supervisar y equilibrar los recursos. Puedeadministrar las colas y realizar un seguimiento de las métricas de desempeño de la cola en la consola deAmazon GameLift.

La característica de las colas le permite colocar sesiones de juego en función de la información de lalatencia de los jugadores. Esta función es especialmente útil para el servicio de emparejamiento. Lassolicitudes de una nueva sesión de juego también pueden solicitar nuevas sesiones de jugador a uno ovarios jugadores. Si se incluyen datos de latencia para cada jugador por región, Amazon GameLift puedeelegir una flota en una región que proporcione la mejor experiencia posible a todos los jugadores.

Control del acceso de jugadores a las sesiones de juegoDefina una sesión de juego para aceptar o rechazar las solicitudes de participaciones de jugadoresnuevos, independientemente del número de jugadores conectados en el momento. Puede utilizar estacaracterística para activar sesiones privadas, para limitar el acceso para la resolución de problemas u otrotipo de resolución de problema, etc.

Adición de datos de jugador y de juego personalizadosPuede agregar datos personalizados a objetos de sesiones de juego y de jugador, que contienen todaslas configuraciones y los metadatos de una sesión. Los datos personalizados se almacenan en AmazonGameLift y otros componentes los pueden recuperar cuando sea necesario. El servicio Amazon GameLiftpasa los datos de la sesión de juego a un servidor de juegos al iniciar una nueva sesión de juego y pasalos datos de la sesión de jugador al servidor de juego cuando un jugador se conecta a la sesión de juego.Amazon GameLift no utiliza los datos personalizados de juego y de jugador. Se pueden formatear segúnsea necesario para que los utilicen el cliente de juego, el servidor de juegos u otros servicios de juegos.

Los datos de juegos pueden ser útiles por diversas razones. Por ejemplo, al asociar posibles jugadores asesiones de juego, el juego podría utilizar las propiedades del juego para informar a un algoritmo de mejorcoincidencia o ayudar a los jugadores a elegir entre una lista de sesiones de juego. De forma alternativa,puede utilizar las propiedades del juego para pasar la información que necesita un servidor de juegos alconfigurar una sesión de juego nueva, como un modo o un mapa de juego.

Los datos del jugador también tienen diferentes usos. Por ejemplo, un servicio de emparejamiento puedeutilizar los datos de jugadores para seleccionar la mejor coincidencia o la clasificación de un equipo. Unservidor de juegos puede personalizar la experiencia de un jugador en función de las asociaciones a lasque pertenezca. Otro uso de los datos de jugadores es proporcionar información segura a un servidor dejuegos de una fuente distinta a un cliente de juego; por ejemplo, cuando la comunicación entre cliente y

Version9

Amazon GameLift Developer GuideGameLift FlexMatch

servidor de juegos está cifrada, como en determinados dispositivos, las claves de cifrado pueden pasarsedirectamente al servidor de juegos.

Filtrado y clasificación de las sesiones de juego disponiblesUtilice la función de búsqueda y clasificación de sesiones para encontrar el mejor emparejamiento paraun posible jugador o permita a los jugadores que examinen una lista de las sesiones de juego disponibles.Con esta característica, puede dirigir de forma efectiva a los jugadores a sesiones que es más probableque resulten en una experiencia de juego positiva. Por ejemplo, si el juego requiere un número mínimode jugadores, dirigir nuevas jugadores a juegos casi completos minimizará el tiempo de espera de todoslos jugadores. De forma alternativa, puede ocultar las sesiones que están casi terminadas. La funciónde búsqueda de sesión puede ser muy útil para la implementación de una función "conectarse ahora"respaldada por una expresión de búsqueda y clasificación bien formulada que consiga que los jugadorestengan experiencias de juego positivas muy rápidamente. Utilice la función de búsqueda y clasificaciónpara encontrar sesiones de juego en función de distintas características como la antigüedad de la sesión,las ranuras de jugadores disponibles, el número actual de jugadores, la cantidad máxima de jugadorespermitida y los datos de sesión de juego personalizados. También puede buscar y ordenar en función desus propios datos de juego personalizados.

Seguimiento de los datos de uso de juego y de los jugadoresConfigure Amazon GameLift para que almacene de forma automática logs de sesiones de juegofinalizadas. Configure el almacenamiento de logs al integrar Amazon GameLift en los servidores de juegos.Puede acceder a los logs almacenados descargándolos mediante la consola de Amazon GameLift omediante programación con el AWS SDK para Amazon GameLift.

Utilice la consola de Amazon GameLift para ver información detallada sobre las sesiones de juego,incluidos los metadatos y la configuración de la sesión, así como los datos de sesiones de jugadores.Para cada sesión de juego, puede ver una lista de las sesiones de jugador junto con los tiempos totalesde juego. También puede ver los datos de métricas y los gráficos que realizan el seguimiento del númerode sesiones de juego y de jugadores activas a lo largo del tiempo. Para obtener más información, consulteVisualización de datos de sesiones de juego y de jugador (p. 135) y Métricas (p. 132).

Amazon GameLift FlexMatchFlexMatch es un servicio de emparejamiento personalizable de Amazon GameLift. Ofrece herramientasflexibles que le permiten administrar el tipo de emparejamiento de la forma que mejor se adapte a sujuego. Puede utilizar FlexMatch para crear parejas de juego, seleccionar jugadores compatibles paracada emparejamiento y encontrar los mejores recursos de hospedaje disponibles para ofrecer una óptimaexperiencia de juego. También puede utilizar la función de reposición de FlexMatch para seleccionarnuevos jugadores compatibles con los juegos existentes, lo que garantiza que los juegos permaneceráncompletos y permite ofrecer una experiencia inmejorable a los jugadores.

Con FlexMatch, puede crear y ejecutar varios creadores de emparejamiento que se ajusten a los modosde juego y a los jugadores. Por ejemplo, puede utilizar un creador de emparejamientos diferente para cadamodo de juego, como, por ejemplo, batalla de equipo, batalla campal o jaula.

Características clave de FlexMatch

• Personalice el emparejamiento de jugadores. Diseñe y cree los tipos de experiencias multijugador másatractivas para sus jugadores. Para cada modo de juego, defina la estructura del equipo y otros atributosdel juego. Cree un conjunto de reglas personalizadas para evaluar los atributos de los jugadores (porejemplo, nivel de habilidad o rol) y utilícelas para crear los mejores emparejamientos posibles parauna sesión de juego. Utilice estas reglas para agrupar jugadores para nuevos emparejamientos oencontrar jugadores para completar ranuras abiertas en emparejamientos existentes ("reposición deemparejamiento").

Version10

Amazon GameLift Developer GuideFuncionamiento de GameLift FlexMatch

• Obtenga la aceptación del jugador. Requiera que todos los jugadores acepten un emparejamientopropuesto antes de comenzar. Si esta característica está habilitada, FlexMatch espera a que todos losjugadores asignados a un emparejamiento acepten antes de comenzar.

Soporte para grupos de jugadores.Genere emparejamientos para un grupo de jugadores que quieranjugar juntos en el mismo equipo. Encuentre jugadores adicionales para completar el emparejamientosegún sea necesario.

• Empareje jugadores en función de la latencia.Utilice la información de latencia de los jugadores paragarantizar que los jugadores emparejados tengan tiempos de respuesta similares. Esta característicaevita disparidades en el juego que podrían dar una ventaja indebida a algunos jugadores. Esespecialmente útil al crear emparejamientos que abarcan varias áreas geográficas.

• Relaje las reglas de emparejamiento de jugadores a lo largo del tiempo. Alcance el equilibrio adecuadoentre crear los mejores emparejamientos posibles de jugadores y colocar jugadores rápidamente enbuenos emparejamientos. Puede decidir dónde y cuándo relajar reglas estrictas de emparejamiento paracolocar a jugadores en juegos con un mínimo tiempo de espera.

• Encuentre los mejores recursos de hospedaje. Utilice la información de los jugadores y el juego paraseleccionar los mejores recursos disponibles para hospedar el emparejamiento y ofrecer una experienciade juego óptima.

• Mantenga juegos completos con jugadores emparejados. Utilice la función de reposición de FlexMatchpara completar ranuras de jugadores vacías con jugadores nuevos que encajen bien a lo largo de toda lavida útil de la sesión de juego.

Temas

• Funcionamiento deAmazon GameLift FlexMatch (p. 11)• Emparejamientos con FlexMatch (p. 98)

Funcionamiento deAmazon GameLift FlexMatchEn este tema, se describen los componentes esenciales de FlexMatch y se explica cómo FlexMatchprocesa las solicitudes de emparejamiento. Si necesita ayuda más detallada para agregar FlexMatch a sujuego (por ejemplo, para configurar un creador de emparejamiento y personalizar el emparejamiento dejugadores), consulte Emparejamientos con FlexMatch (p. 98).

Amazon GameLift FlexMatch necesita que estos tres componentes clave trabajen juntos:

• Mecanismos para disparar emparejamientos de jugadores. Un mecanismo determina cuándo iniciar elemparejamiento para los jugadores. Un segundo mecanismo (opcional) determina cuándo encontrarnuevos jugadores para completar ranuras vacías en un emparejamiento existente (reposición).Las solicitudes de emparejamiento y reposición de emparejamientos se entregan a un creador deemparejamientos para su procesamiento.

• Un creador de emparejamiento de FlexMatch que evalúe a los jugadores y cree emparejamientos. Uncreador de emparejamientos crea los mejores emparejamientos posibles a partir de las solicitudes querecibe. Tiene una regla que define la estructura del equipo del emparejamiento y establece los criteriosque se usarán a la hora de evaluar los jugadores para un emparejamiento. Un juego puede tener varioscreadores de emparejamientos y cada uno crea un tipo distinto de emparejamiento.

• Cola de sesión de juego para colocar nuevos emparejamientos. Una cola de sesión de juego encuentrarecursos informáticos disponibles para hospedar un emparejamiento. Determina dónde (en quéregiones) buscar recursos y cómo seleccionar el mejor recurso disponible para hospedar cadaemparejamiento.

En las secciones siguientes se detalla cómo funciona el emparejamiento para crear nuevosemparejamientos de juego o encontrar nuevos jugadores para emparejamientos de juego existentes.

Version11


Solicitudes de emparejamientoAsí es como FlexMatch administra las solicitudes de un nuevo emparejamiento de juego. Esta descripciónsupone que un servicio de juego del lado del cliente inicia las solicitudes de emparejamiento y realiza unseguimiento del estado del ticket de emparejamiento.

1. Solicite un emparejamiento. Los jugadores realizan alguna acción en el juego que dispara elemparejamiento, como que se haga clic en un botón tipo "conectarse ahora" o que una serie dejugadores forme un grupo. Su juego inicia una solicitud de emparejamiento, identificando qué creadorde emparejamiento utilizar e incluyendo uno o varios jugadores para emparejarlos. La solicitud incluyetoda la información de los jugadores, como nivel de habilidad o preferencias, que necesita el creador deemparejamientos para crear emparejamientos. Cada solicitud recibe un ID de ticket de emparejamiento,que el juego utiliza para realizar un seguimiento del estado de la solicitud y actuar según sea necesario.

2. Descubra posibles emparejamientos. Todos los tickets de emparejamiento se transfieren a loscreadores de emparejamiento especificados y se colocan en su grupo de tickets para el procesamiento.Un ticket permanece en el grupo de tickets hasta que se empareja o hasta que alcance el plazo máximoestablecido por el creador de emparejamientos.

Para encontrar emparejamientos de jugadores, el creador de emparejamientos realiza pases continuospor el grupo de tickets. En cada pase, el creador de emparejamientos comienza por el ticket másantiguo y lo evalúa frente a los demás tickets para encontrar los mejores emparejamientos posibles. Unconjunto de reglas del creador de emparejamientos determina (1) cuántos equipos se deben crear paraun emparejamiento, (2) el número de jugadores que se asignarán a cada equipo y (3) cómo evaluarcada posible jugador. Las reglas pueden establecer requisitos para jugadores individuales, equipos oemparejamientos Por ejemplo, una regla podría requerir que todos los jugadores emparejados tenganun determinado talento o que al menos un jugador de un equipo sea un determinado personaje. Unaregla usada a menudo requiere que todos los jugadores de un emparejamiento tengan puntuaciones dehabilidad similares.

Cuando el creador de emparejamientos evalúa un ticket, "aprueba" o "suspende" el ticket en funciónde las reglas. Para tickets con varios jugadores, el creador de emparejamientos supone que estosjugadores desean jugar juntos e intenta ubicarlos a todos en el mismo emparejamiento. Esto significaque, para cualquier posible emparejamiento, deben ser aceptables todos los jugadores del ticket. Siun jugador no cumple alguna regla, se considera que todo el ticket no es un emparejamiento. Lostickets que no se activan siguen en el grupo de tickets y se vuelven a evaluar en el siguiente pase.Una vez que se completa un posible emparejamiento, se actualiza el estado de todos los tickets en elemparejamiento.

3. Obtenga la aceptación del jugador. Si el creador de emparejamiento necesita que los jugadores aceptenun posible emparejamiento, FlexMatch no podrá continuar con el emparejamiento hasta que todos losjugadores lo acepten. El estado del ticket de emparejamiento cambia para indicar que la aceptaciónes necesaria, lo que hace que el juego solicite aceptaciones de todos los jugadores en cada ticketemparejado.

Los jugadores pueden elegir aceptar o rechazar un posible emparejamiento. El juego recopilalas respuestas de los jugadores y las comunica a FlexMatch. Todos los jugadores del posibleemparejamiento deben aceptarlo en un plazo determinado para continuar. Si cualquier jugador rechazael emparejamiento o no responde antes de un plazo especificado, el creador de emparejamientosabandona el posible emparejamiento. Los tickets de los jugadores que aceptaron el emparejamientose devuelven al grupo de tickets del creador de emparejamientos. Los tickets de los jugadores que noaceptaron el emparejamiento pasan a un estado de error y dejan de procesarse.

4. Encuentre recursos para hospedar el emparejamiento. Una vez que se realiza un posibleemparejamiento y los jugadores lo aceptan, FlexMatch intenta colocar el emparejamiento con losrecursos de alojamiento disponibles. El creador de emparejamientos se ha configurado para utilizar unacola de sesión de juego específica y pasa el posible emparejamiento a esa cola para su colocación.La cola utiliza un conjunto de reglas para buscar en regiones y flotas hasta encontrar el mejor procesodel servidor disponible para hospedar el emparejamiento. Si la solicitud de emparejamiento originalcontenía datos de latencia de los jugadores, la cola utiliza esta información para encontrar los

Version12


recursos que ofrecen la latencia más baja y la experiencia de juego más uniforme a los jugadores delemparejamiento.

Una vez que se encuentra un proceso del servidor disponible, Amazon GameLift crea un registro desesión de juego con los datos del creador de emparejamientos y propiedades del juego, incluida laestructura y el tamaño del equipo, las asignaciones de jugadores y las características relevantes de losjugadores.

5. Inicie una nueva sesión de juego. Al igual que al iniciar cualquier nueva sesión de juego, AmazonGameLift envía una solicitud de inicio al proceso del servidor junto con información sobre la sesión dejuego y el creador de emparejamientos. El proceso del servidor toma la información y la usa para iniciaruna nueva sesión de juego para un juego emparejado. Cuando la sesión de juego está lista para aceptarjugadores, el proceso del servidor notifica a Amazon GameLift.

6. Conecte jugadores a la nueva sesión de juego. Una vez que la sesión de juego está lista para losjugadores, Amazon GameLift crea nuevas sesiones de jugador para cada jugador en el emparejamiento.A continuación, actualiza todos los tickets de emparejamiento, cambia el estado del ticket para indicaréxito y añade información de conexión para todos los jugadores. Este cambio en el estado del ticket,señala al juego que transmita la información de conexión a los clientes de juego. Ahora los jugadorespueden unirse al juego y reclamar sus ranuras en el emparejamiento y sus asignaciones de equipo.

Solicitudes de reposiciónA continuación, se explica cómo se utiliza FlexMatch a fin de buscar nuevos jugadores para unemparejamiento existente. Como la reposición de emparejamientos requiere información actualizada sobrela disponibilidad de ranuras de jugadores en sesiones de juego, recomendamos iniciar las solicitudesde reposición de emparejamientos en el servidor de juegos. Otra opción es utilizar un servicio de juegodel lado del cliente, como un servicio de directorio de sesiones, que realiza un seguimiento de la sesiónde juego y la actividad del jugador. Consulte más información sobre cómo añadir la característica dereposición de emparejamientos a su juego en Reposición de juegos existentes con FlexMatch (p. 123).

1. Solicite un emparejamiento de reposición. Un juego emparejado tiene ranuras de jugadores vacíasque tienen que llenarse. Su juego inicia una solicitud de reposición, que identifica qué creador deemparejamientos utilizar y describe los jugadores actuales en la sesión de juego. Cada solicitud tieneun ID de ticket de emparejamiento, que el juego utiliza para realizar un seguimiento del estado de lasolicitud y actuar según sea necesario.

2. Descubra posibles emparejamientos. Los tickets de emparejamiento para reposiciones pasan alcreador de emparejamientos especificado y se colocan en el mismo grupo que los tickets para nuevosemparejamientos. La evaluación de jugadores del creador de emparejamientos es básicamente idénticatanto si los jugadores buscan un emparejamiento como si están en un emparejamiento que está enproceso de reposición. La única excepción es que un posible emparejamiento no puede tener más de unticket de reposición.

El ticket de reposición debe emparejarse con al menos otro ticket para que se complete correctamente,incluso si las reglas del creador de emparejamientos permiten que se complete un emparejamientocon ranuras de jugadores vacías. Una vez que se completa un posible emparejamiento, se actualiza elestado de todos los tickets en el emparejamiento.

3. Obtenga la aceptación del jugador. Si se necesita aceptación, solo los nuevos jugadores tienen queaceptar un emparejamiento de reposición. Este paso se gestiona como se describe en las solicitudes deemparejamiento. Los jugadores actuales no tienen que aceptar un emparejamiento del que ya formanparte. Como resultado, aunque el estado del ticket de solicitud de reposición indica que se requiereaceptación, el juego no tiene que realizar ninguna acción.

Si alguno de los nuevos jugadores propuestos no acepta el emparejamiento en el plazo establecido, seabandona el posible emparejamiento y no se añaden nuevos jugadores al emparejamiento existente.Cuando esto sucede, el ticket de la solicitud de reposición se devuelve al grupo de tickets para suprocesamiento.

Version13

Amazon GameLift Developer GuideHerramientas y recursos

4. Actualice una sesión de juego existente con nuevos datos de emparejamiento. Cuando unemparejamiento de reposición se completa correctamente, no hay necesidad de colocar una nuevasesión de juego. En cambio, Amazon GameLift actualiza los datos de emparejamiento para la sesión dejuego existente añadiendo los nuevos jugadores y asignaciones de equipo. Amazon GameLift envía lainformación de la sesión de juego actualizada al proceso del servidor que hospeda el juego actual.

5. Conecte nuevos jugadores a la sesión de juego existente. Amazon GameLift crea sesiones de jugadorespara los nuevos jugadores y actualiza los tickets de emparejamiento con información actual de estado,sesiones de los jugadores y conexión. El servicio de juego del cliente, que realiza el seguimiento delestado del ticket de los nuevos jugadores, transmite la información de conexión a los clientes de juego.Ahora, los jugadores pueden unirse al juego existente y reclamar su ranura de jugador.

Herramientas y recursosAmazon GameLift proporciona un conjunto de herramientas y recursos.

Principales herramientasUtilice estas herramientas para trabajar con Amazon GameLift.

Los SDK de Amazon GameLift

Los SDK de Amazon GameLift contienen las bibliotecas necesarias para comunicarse con el servicioAmazon GameLift desde los clientes, los servidores y los servicios de juegos. Las versiones de estosSDK están disponibles en Lumberyard o también puede descargar las últimas versiones por separado.Para obtener información detallada, consulte Los SDK de Amazon GameLift (p. 15).

Consola de AWS para Amazon GameLift

Utilice la Consola de administración de AWS para que Amazon GameLift administre lasimplementaciones de juegos, configure los recursos y realice un seguimiento del uso de los jugadoresy de las métricas de desempeño. La consola de Amazon GameLift ofrece una GUI alternativa paraadministrar los recursos de forma programática con el AWS SDK.

La CLI de AWS para Amazon GameLift

Utilice esta herramienta de línea de comando para realizar llamadas al AWS SDK, incluida la API deAmazon GameLift. Descargue la AWS Command Line Interface o consulte la AWS CLI CommandReference for Amazon GameLift.

Amazon GameLift Local

Esta herramienta de depuración del cliente emula un subconjunto de la API de Amazon GameLift ensu equipo de desarrollo local. Puede probar los cambios en el código iterativo sin necesidad de cargary ejecutar el servidor de juegos en instancias Amazon GameLift. Amazon GameLift Local se puedeutilizar en dispositivos Windows y Linux para probar los clientes y servidores de juegos que utilizanlos SDK de Amazon GameLift. Amazon GameLift Local está disponible en la descarga del SDK delservidor. Para obtener información detallada, consulte Prueba de la integración (p. 44).

Recursos adicionalesUtilice estos recursos para obtener información y experimentar con Amazon GameLift en sus juegosmultijugador.

Muestra de cinco clics

Ponga a punto y ejecute un juego multijugador de muestra en Amazon GameLift en menos de unahora. Con esta herramienta, puede comenzar a experimentar con las herramientas Amazon GameLiften tiempo real con una configuración mínima. Puede encontrar esta herramienta en la consola de

Version14

https://console.aws.amazon.com/gamelift

https://aws.amazon.com/cli/

https://docs.aws.amazon.com/cli/latest/reference/gamelift/



Amazon GameLift Developer GuideSDK de GameLift

Amazon GameLift: desde la página de introducción, haga clic en "Test Amazon GameLift" o desdecualquier otra página, seleccione "Sample game" en el menú de navegación de Amazon GameLift.

Tutoriales de introducción

Recurra a estos tutoriales para guiarse a través del proceso de puesta a punto y ejecución de un juegomultijugador de muestra en Amazon GameLift. En cuanto haya completado la serie, puede utilizarel juego para explorar otras características y herramientas de Amazon GameLift como, por ejemplo,el escalado automático y las métricas de desempeño (sin costo alguno si utiliza la capa gratuita deAmazon GameLift).

Foro de Amazon GameLift

Utilice el foro de Amazon GameLift para intercambiar ideas y conocimientos, descubrir sugerencias yobtener ayuda para solucionar problemas.

Motor de videojuegos de Amazon Lumberyard

Amazon Lumberyard tiene integrados los SDK de Amazon GameLift. Dicha integración se gestionaautomáticamente. Contiene también una muestra de juego multijugador que ejemplifica cómo usarLumberyard para integrar un juego con Amazon GameLift. Para obtener más información acerca deeste proyecto de muestra, consulte la Guía del usuario de Lumberyard.

Blog de GameDev

Siga este blog de desarrollo de juegos para estar al día de las nuevas características de AmazonGameLift y Amazon Lumberyard, obtener más información sobre el desarrollo de juegos con AWS yleer consejos de expertos de los equipos.

Información de producto de Amazon GameLift

Consulte estas páginas para ver descripciones detalladas de Amazon GameLift, además deinformación general, preguntas frecuentes e información sobre precios.

Los SDK de Amazon GameLiftUtilice los kits de desarrollo de software (SDK) de Amazon GameLift para desarrollar los servidoresde juegos multijugador, clientes y servicios de juegos compatibles con Amazon GameLift y que debenconectarse con el servicio Amazon GameLift.

Para obtener información detallada sobre cómo utilizar los SDK de Amazon GameLift con el motor devideojuegos, consulte Motores de videojuegos y Amazon GameLift (p. 23).

Para servidores de juegosCree e implemente servidores de juegos de 64 bits con el SDK de servidor de Amazon GameLift. EsteSDK permite al servicio Amazon GameLift implementar y administrar procesos del servidor de juegos enlos recursos virtuales de Amazon GameLift. Para utilizar el SDK de servidor de Amazon GameLift en elproyecto de juego, descargue el SDK de servidor y revise la documentación de la API (p. 31).

Compatibilidad con SDK

La descarga del SDK de servidor de Amazon GameLift contiene código fuente para las siguientesversiones:

• C++• C++ para Unreal Engine (complemento)• C# (.NET)

Entornos de desarrollo

Version15


https://gamedev.amazon.com/forums/tutorials#gamelift

https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-billing-alerts.html

https://gamedev.amazon.com/forums/spaces/123/gamelift-discussion.html

https://docs.aws.amazon.com/lumberyard/latest/userguide/sample-project-multiplayer-enhanced.html

https://aws.amazon.com/blogs/gamedev/

https://aws.amazon.com/gamelift/faq/

https://aws.amazon.com/gamelift/getting-started/

Amazon GameLift Developer GuidePara clientes y servicios de juego

Compile el SDK a partir del código adecuado para los sistemas operativos de desarrollo y motores devideojuegos compatibles:

• Sistemas operativos: Windows, Linux• Motores de videojuegos: Amazon Lumberyard, Unreal Engine, Unity, motor compatibles con bibliotecas

C++ o C#

Sistemas operativos de servidor de juegos

Utilice el SDK de servidor de Amazon GameLift para crear servidores de juegos que se ejecuten en lassiguientes plataformas:

• Windows Server 2012 R2• Amazon Linux

Para clientes y servicios de juegoCree clientes y servicios de juego de 64 bits utilizando el AWS SDK con la API de Amazon GameLift. EsteSDK permite a las aplicaciones y servicios de cliente buscar y administrar sesiones de juego y conectara los jugadores con los juegos alojados en Amazon GameLift. Descargue el AWS SDK o consulte lareferencia de la API de Amazon GameLift.

Compatibilidad con SDK

El AWS SDK con Amazon GameLift está disponible en los siguientes lenguajes. Consulte ladocumentación de cada lenguaje para obtener más información sobre la compatibilidad con entornos dedesarrollo y plataformas de cliente de juego.

• C++ (documentación del SDK) (Amazon GameLift)• Java (documentación del SDK) (Amazon GameLift)• .NET (documentación del SDK) (Amazon GameLift)• Go (documentación del SDK) (Amazon GameLift)• Python (documentación del SDK) (Amazon GameLift)• Ruby (documentación del SDK) (Amazon GameLift)• PHP (documentación del SDK) (Amazon GameLift)• JavaScript/Node.js ((documentación del SDK) (Amazon GameLift)

Compatibilidad con SDKSi utiliza los SDK de Amazon GameLift agrupados dentro de una versión de Amazon Lumberyard, losclientes y servidores de juego serán compatibles. Sin embargo, si actualiza el SDK de servidor de AmazonGameLift independientemente, tendrá que utilizar una versión compatible del AWS SDK a fin de garantizarque sus clientes y servicios de juego puedan conectarse correctamente con los servidores de juegos enAmazon GameLift.

Si el servidor de juegos utilizaesta versión del SDK de servidor:

Puede alojar clientes de juegointegrados con esta versión delAWS SDK for C++*:

Las versiones del SDK deservidor están disponibles en:

Versiones agrupadas en AmazonLumberyard.

Versiones agrupadas en AmazonLumberyard.

Lumberyard 1.0 a 1.3 (beta)

Version16

https://aws.amazon.com/windows/products/ec2/server2012r2/

https://aws.amazon.com/amazon-linux-ami/

https://aws.amazon.com/tools/#sdk

https://docs.aws.amazon.com/gamelift/latest/apireference/


https://aws.amazon.com//sdk-for-cpp/

http://sdk.amazonaws.com/cpp/api/LATEST/namespace_aws_1_1_game_lift.html

https://aws.amazon.com//sdk-for-java/

https://docs.aws.amazon.com/AWSJavaSDK/latest/javadoc/index.html?com/amazonaws/services/gamelift/AmazonGameLift.html

https://aws.amazon.com//sdk-for-net/

http://docs.aws.amazon.com/sdkfornet/v3/apidocs/items/GameLift/NGameLift.html

https://aws.amazon.com//sdk-for-go/

http://docs.aws.amazon.com/sdk-for-go/api/service/gamelift/

https://aws.amazon.com//sdk-for-python/

https://boto3.readthedocs.io/en/latest/reference/services/gamelift.html

https://aws.amazon.com//sdk-for-ruby/

http://docs.aws.amazon.com/sdkforruby/api/Aws/GameLift.html

https://aws.amazon.com//sdk-for-php/

http://docs.aws.amazon.com/aws-sdk-php/v3/api/class-Aws.GameLift.GameLiftClient.html

https://aws.amazon.com//sdk-for-node-js/

http://docs.aws.amazon.com/AWSJavaScriptSDK/latest/AWS/GameLift.html

Amazon GameLift Developer GuideCapa gratuita y alertas de facturación

Si el servidor de juegos utilizaesta versión del SDK de servidor:

Puede alojar clientes de juegointegrados con esta versión delAWS SDK for C++*:

Las versiones del SDK deservidor están disponibles en:

versión 3.0.7 versión 0.12.16 (commit) oposterior

Lumberyard 1.4 a 1.5 (beta)


• Lumberyard 1.6 a 1.7 (beta)• Descargadas desde Amazon

GameLift


• Lumberyard 1.8 (beta oposterior)

• Descarga desde AmazonGameLift

*Encontrará información de versión de AWS SDK for C++ en este archivo: aws-sdk-cpp/aws-cpp-sdk-core/include/aws/core/VersionConfig.h.

Capa gratuita y alertas de facturaciónAmazon GameLift incluye una capa gratuita con una instancia c4.large durante un año. Es posible que lacapa gratuita expire a mediados de mes; por lo tanto, le recomendamos que establezca y configure unaalerta de facturación para que le informe sobre los eventos de facturación como, por ejemplo, cuandoalcance el umbral de la capa gratuita. Para obtener más información, consulte Creación de una alarma defacturación.

Además de recibir alertas de facturación, puede ver la factura estimada actual de Amazon GameLift en laconsola de Gestión de facturación y costos en https://console.aws.amazon.com/billing/. Esto le permitirárevisar el consumo de recursos y determinar si desea seguir utilizando estos recursos más allá de la capagratuita e incurrir en gastos, o si desea reducir su flota y evitar incurrir en gastos.

Para evitar que se le cobre por encima de la capa gratuita, le recomendamos reducir su flota (p. 70)cuando no la utilice.

Version17

https://github.com/aws/aws-sdk-cpp/commit/6e0d1e23267b7e1b002ea37e520783761d2f1785

https://github.com/aws/aws-sdk-cpp/commit/d460f766d58ee6f8771b932ad4a4e243a9bcfe3a

https://github.com/aws/aws-sdk-cpp/commit/b9d5eb702e2ce02632890e00b3d8af55d2bc5202



https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/free-tier-alarms.html

https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/free-tier-alarms.html

https://console.aws.amazon.com/billing/

Amazon GameLift Developer GuideConfiguración del proyecto

ConfiguraciónLos temas de esta sección describen los pasos básicos necesarios para empezar a utilizar AmazonGameLift.

Temas• Configuración del proyecto de juego de Amazon Lumberyard (p. 18)• Configuración de una cuenta de AWS (p. 18)• Instalar la AWS CLI (p. 20)

Configuración del proyecto de juego de AmazonLumberyard

Siga los siguientes pasos para que el proyecto se pueda utilizar en Amazon GameLift. Si ha instaladoLumberyard, puede que ya haya completado algunas de estas tareas.

• Instale el tiempo de ejecución de Visual Studio 2013. Ejecute el instalador desde el directorio\3rdParty\Redistributables\Visual Studio 2013 o descargue y ejecute el instaladordirectamente desde Microsoft.

• Ejecute Setup Assistant para validar que ha instalado el software de terceros y los SDK adecuados,incluido el cliente Amazon GameLift. LumberyardLauncherBatch.exe se encuentra en \dev\Bin64.

• Configure el proyecto de juego de Lumberyard para comprobar que se compila correctamente. Sigaestas instrucciones:• Los ejecutables del servidor y el cliente deben enlazar aws-cpp-sdk-core y aws-cpp-sdk-gamelift.

• El ejecutable del servidor debe compilarse en una plataforma compatible con Amazon GameLift. Paraobtener una lista de las plataformas permitidas, consulte Los SDK de Amazon GameLift (p. 15).

• El proyecto debe definir la marca del pre-procesador AWS_CUSTOM_MEMORY_MANAGEMENT en 0 o 1,en función de su uso de un administrador de memoria personalizado.

Configuración de una cuenta de AWSAmazon GameLift es un servicio de AWS y debe disponer de una cuenta de AWS para utilizar AmazonGameLift. Crear una cuenta de AWS es gratuito.

Para obtener más información sobre lo que puede hacer con una cuenta de AWS, consulte Introducción aAWS.

Configuración de una cuenta para Amazon GameLift

1. Obtenga una cuenta. Abra Amazon Web Services y elija Sign In to the Console. Siga las instruccionespara crear una cuenta nueva o inicie sesión en una existente.

2. Configure los grupos de usuarios y permisos de acceso. Abra la consola de servicio de AWS Identityand Access Management (IAM) y siga estos pasos para definir un conjunto de usuarios o grupos de

Version18

http://www.microsoft.com/en-us/download/details.aspx?id=40784

https://aws.amazon.com/getting-started/

https://aws.amazon.com/getting-started/

https://aws.amazon.com/

Amazon GameLift Developer GuideEjemplos de política de IAM

usuarios y asígneles permisos de acceso. Los permisos se pueden extender a un usuario o grupode usuarios adjuntando una política de IAM, que especifica el conjunto de servicios y acciones deAWS al que debe tener acceso un usuario. Para obtener instrucciones detalladas sobre cómo utilizarla consola (o la CLI de AWS u otras herramientas) para configurar los grupos de usuarios, consulteCreación de usuarios de IAM.

a. Crear un usuario o grupo de usuarios administrativo. Los usuarios administrativos incluyen acualquiera que administre los recursos principales de Amazon GameLift, como las compilacionesy las flotas. Para otorgar permisos, debe crear su propia política de cero. Este ejemplo (p. 19)muestra una política de administrador para servicios Amazon GameLift.

b. Crear un usuario jugador. Un usuario jugador representa el cliente o clientes de juego. Otorgaacceso a la funcionalidad de cliente de Amazon GameLift, como obtener información de sesión dejuego y la participación de jugadores en juegos. El cliente de juego debe utilizar las credencialesde usuario de jugador al comunicarse con el servicio Amazon GameLift. Para otorgar permisos,debe crear su propia política de cero. Este ejemplo (p. 19) muestra una política de jugadorpara servicios Amazon GameLift.

Ejemplos de políticas de IAM para Amazon GameLiftPuede utilizar los siguientes ejemplos para crear políticas y añadir los permisos adecuados a los usuariosde IAM o a los grupos de usuarios.

Política simple para administradoresEsta política ofrece acceso administrativo total a un usuario. Adjúntelo a un usuario o grupo de usuariospara permitir todas las acciones de Amazon GameLift en todos los recursos de Amazon GameLift (flotas,alias, sesiones de juego, sesiones de jugador, etc.).

{"Version": "2012-10-17","Statement": { "Effect": "Allow", "Action": "gamelift:*", "Resource": "*" }}

Política simple para jugadoresEsta política permite acceso únicamente a la funcionalidad necesaria para los jugadores que utilizanun cliente de juego para conectarse a un servidor de juegos alojado en Amazon GameLift. Esta políticapermite a un usuario obtener información sobre la sesión de juego, crear sesiones de juego nuevas yconectarse a una sesión de juego.

{"Version": "2012-10-17","Statement": { "Effect": "Allow", "Action": [ "gamelift:CreateGameSession", "gamelift:DescribeGameSessions", "gamelift:SearchGameSessions", "gamelift:CreatePlayerSession" ], "Resource": "*" }}

Version19

https://docs.aws.amazon.com/IAM/latest/UserGuide/access_policies.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_users_create.html

Amazon GameLift Developer GuideInstalar la AWS CLI

Instalar la AWS CLIPuede utilizar la herramienta de interfaz de línea de comandos (AWS CLI) de AWS para realizar llamadasa cualquier acción en el SDK de AWS, incluida la API de Amazon GameLift. Como mínimo, deberá utilizaresta herramienta para cargar las compilaciones de juegos en el servicio Amazon GameLift.

Para instalar la AWS CLI para Amazon GameLift

1. Obtenga la herramienta. Descargue la última versión de la herramienta de línea de comandos de AWSy siga las instrucciones para instalarla. Esta herramienta se ejecuta en Windows, Linux, OS X y Unix.

2. Verifique la instalación. Abra una ventana de línea de comandos o terminal y escriba aws gamelifthelp. Si la interfaz de línea de comandos se ha instalado correctamente, verá el mensaje "Welcometo the Amazon GameLift API Reference", seguido de una lista de comandos de Amazon GameLift.

3. Configure la herramienta. Escriba aws configure e introduzca los siguientes valores cuando se losoliciten:

• AWS access key ID: es la mitad de las credenciales de usuario de la cuenta de AWS que segeneran al utilizar el servicio IAM. Para obtener ayuda, consulte Get your access key ID and secretaccess key.

• AWS secret access key: es la mitad de las credenciales de usuario de la cuenta de AWS más el IDde clave de acceso de AWS.

• Default region name: es el nombre de una región, como "us-west-2", que desea establecer comopredeterminada. Si no configura ninguna región predeterminada, cada comando deberá especificaruna región utilizando el parámetro --region. Para obtener una lista de las regiones disponiblespara Amazon GameLift, consulte Regiones y puntos de conexión de AWS.

• Default output format: formato para recibir respuestas de API. Opciones posibles: "json", "text" o"table". Si no introduce ningún formato predeterminado, la CLI procesará las solicitudes, pero nomostrará los resultados.

Version20

https://aws.amazon.com/cli/

https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html

https://docs.aws.amazon.com/cli/latest/userguide/cli-chap-getting-set-up.html


Amazon GameLift Developer GuidePlan de integración

Integración de los SDK de AmazonGameLift en juegos

Los SDK de Amazon GameLift proporcionan las bibliotecas necesarias que permiten que los clientesy servidores de juegos se comuniquen con el servicio Amazon GameLift. Los SDK se incluyen en ladescarga del motor de videojuegos de Amazon Lumberyard, pero también se pueden descargar porseparado. Para obtener más información sobre los SDK y dónde obtenerlos, consulte Los SDK de AmazonGameLift (p. 15).

Los temas de esta sección describen cómo los clientes y servidores de juegos interactúan con el servicioAmazon GameLift y proporcionan instrucciones sobre cómo añadir la funcionalidad de Amazon GameLift alos clientes y servidores de juegos.

Exploración de Amazon GameLift

Antes de preparar un juego para que utilice Amazon GameLift, puede experimentar con el servicio y lasherramientas de la consola:

• Asistente de cinco clics: utilice este asistente para crear una compilación del servidor de juegos a partirde un juego de ejemplo, implementarla en una flota de Amazon GameLift y conectarse al servidor desdeel cliente de juego de ejemplo. Desde aquí, puede ver o editar la flota utilizando las herramientas de laconsola de Amazon GameLift, así como ver las métricas y otras herramientas de Amazon GameLift enacción. Para tener acceso al asistente de muestra, inicie sesión en la consola de Amazon GameLift yseleccione Sample Game en el menú de Amazon GameLift.

• Ejemplo de multijugador de Amazon Lumberyard: si trabaja con Lumberyard, puede utilizarlo paraimplementar un servidor de juegos con GameLift o explorar el código fuente para conocer cómo seintegran el cliente de juego y el servidor de juegos con GameLift. Obtenga más información sobre eljuego ejemplo de multijugador y cómo configurarlo para GameLift.

Temas• Plan de integración (p. 21)• Motores de videojuegos y Amazon GameLift (p. 23)• Integración del servidor de juegos en Amazon GameLift (p. 31)• Integración del cliente de juego en Amazon GameLift (p. 35)• Interacciones de Amazon GameLift y el cliente/servidor de juegos (p. 40)• Prueba de la integración (p. 44)

Plan de integración¿Está listo para empezar a utilizar Amazon GameLift para ejecutar los juegos multijugador? Siga los pasosde este flujo de trabajo para integrar Amazon GameLift en los juegos e implementarlos. Si es la primeravez que utiliza Amazon GameLift, le recomendamos que lea ¿Qué es Amazon GameLift? (p. 1) Si noestá seguro de si Amazon GameLift es compatible con su sistema operativo y los entornos de desarrollo,consulte Para servidores de juegos (p. 15) y Motores de videojuegos y Amazon GameLift (p. 23).

Version21



https://docs.aws.amazon.com/lumberyard/latest/userguide/network-multiplayer-gs-gamelift.html

Amazon GameLift Developer GuidePlan de integración

Sugerencia

No necesita tener un juego preparado para empezar a experimentar con Amazon GameLift.Para obtener más información sobre las herramientas disponibles, explore rápidamentelas características de Amazon GameLift en este artículo informativo sobre AmazonGameLift (p. 21).

1. Prepárese para utilizar Amazon GameLift.

• Cree y configure su cuenta de AWS para Amazon GameLift. Consulte Configuración de una cuentade AWS (p. 18)

• Instale la herramienta AWS Command Line Interface (AWS CLI). Consulte Instalar la AWSCLI (p. 20).

2. Prepare el servidor de juegos para alojarlo en Amazon GameLift.

• Descargue el SDK del servidor de Amazon GameLift. Compile la versión del lenguaje deprogramación y motor de videojuegos preferidos y añádala al proyecto de servidor de juegos. Siutiliza el motor de videojuegos de Amazon Lumberyard, se integrará una versión del SDK. ConsulteMotores de videojuegos y Amazon GameLift (p. 23).

• Añada código al proyecto de servidor de juegos para permitir la comunicación con el servicioAmazon GameLift. Como mínimo, un servidor de juegos debe ser capaz de hacer lo siguiente: (1)Notificar a Amazon GameLift que está listo para alojar una sesión de juego; (2) iniciar las sesionesde juego cuando Amazon GameLift se lo solicite; (3) notificar a Amazon GameLift cuándo seconectan y se desconectan los jugadores de una sesión de juego; y (4) notificar cuándo una sesiónde juego está acabando o se está cerrando. Consulte Adición de Amazon GameLift al servidor dejuegos (p. 31).

3. Prepare el cliente de juego para conectarlo a sesiones de juego alojadas en Amazon GameLift.

• Configure los proyectos de cliente de juego o de servicio de juego con el SDK de AWS. Esto incluyelos proyectos que encuentran o crean sesiones de juego y agregan jugadores a juegos. El AWSSDK está disponible en varios idiomas. Consulte los SDK de Amazon GameLift Para clientes yservicios de juego (p. 16).

• Configure los proyectos de cliente de juego o de servicio de juego para conectarse con AmazonGameLift. Determine la región a la que conectarse, defina una flota y/o cola de destino, yalmacene las credenciales de AWS. Consulte Configuración de Amazon GameLift en un cliente oservicio (p. 36).

• Añada la funcionalidad para recuperar información sobre las sesiones de juego, crear sesiones dejuego nuevas y reservar espacio para los jugadores en una sesión de juego. Consulte Obtención desesiones de juego (p. 36).

4. Pruebe la integración con Amazon GameLift.

• Utilice Amazon GameLift Local para probar la integración del cliente y el servidor de juegos conuna versión del servicio Amazon GameLift ejecutado localmente. Puede utilizar esta herramientapara probar la integración sin necesidad de cargar versiones de juego ni configurar flotas. Puedecomprobar que los componentes del juego comunican con el servicio Amazon GameLift y probar lasfunciones principales. Consulte Prueba de la integración (p. 44)

5. Cargue el servidor de juegos en el servicio Amazon GameLift.

• Empaquete los archivos binarios del servidor de juegos, las dependencias, las instrucciones deinstalación y otros archivos necesarios para ejecutar el servidor de juegos. Consulte Empaquetadode los archivos de compilación (p. 49).

• Pruebe el proceso de instalación de la compilación del juego en el sistema operativo de destino paracomprobar si faltan dependencias.

• Cargue la compilación en el servicio Amazon GameLift. Asegúrese de cargar la compilación en cadaregión en la que tiene previsto implementar su juego. Consulte Carga de archivos de compilación enAmazon GameLift (p. 50).

Version22


Amazon GameLift Developer GuideMotores de videojuegos y GameLift

6. Compile una flota de recursos informáticos para alojar el juego.

• Diseñe una configuración de flota para el juego. Debe decidir, por ejemplo, el tipo de recursosinformáticos a utilizar, en qué regiones implementarlo, cómo asignar los recursos disponibles,si desea utilizar un alias de flota y la configuración preferida para una serie de características.Consulte Elección de los recursos informáticos (p. 56) y Ejecución de varios procesos en unaflota (p. 57).

• Cree una flota en función del diseño de la configuración. Puede crear una flota (y editar) desde laconsola de Amazon GameLift o la herramienta de AWS CLI. Al crear una flota, tarda unos minutosen activarse, es decir, hasta que esté lista para alojar sesiones de juego. Consulte Creación de unaflota (p. 60).

• Resuelva los problemas de creación de flotas que pueden indicar que existen problemas con laintegración del servidor de juegos. Consulte Problemas al crear una flota de depuración (p. 65).

• Experimente con los valores de la configuración de la flota de Amazon GameLift y corrija según seanecesario. Por ejemplo, puede cambiar la asignación de capacidad de una flota para optimizar eluso de recursos y configurar políticas de escalado automático para administrar la demanda previstade los jugadores. Consulte Acceso remoto a instancias de una flota (p. 79).

Una vez que haya integrado totalmente Amazon GameLift en los componentes del juego, bastará conadministrar las flotas del servidor de juegos para disfrutar de una disponibilidad y desempeño óptimasa largo plazo. Utilice las herramientas de Amazon GameLift para realizar un seguimiento de cosascomo, por ejemplo, con qué rapidez y eficacia pueden buscar y conectarse los jugadores a una sesiónde juego, el desempeño general de sus servidores de juego a lo largo del tiempo y los patrones de usode los jugadores. Consulte Visualización de los datos de juego en la consola (p. 129).

Motores de videojuegos y Amazon GameLiftPuede utilizar Amazon GameLift con la mayoría de motores de videojuegos compatibles con bibliotecas C++ o C#, incluidos Amazon Lumberyard, Unreal Engine y Unity. Para obtener más información sobre losSDK de Amazon GameLift disponibles, las plataformas de desarrollo y los sistemas operativos admitidos,consulte Los SDK de Amazon GameLift (p. 15) para ver los servidores de juegos.

Además de la información específica del motor proporcionada en este tema, encontrará más ayuda para laintegración de Amazon GameLift en los servidores, clientes y servicios de juegos en los siguientes temas:

• Plan de integración (p. 21): un flujo de trabajo de seis pasos para integrar correctamente AmazonGameLift en el juego y configurar los recursos de alojamiento.

• Adición de Amazon GameLift al servidor de juegos (p. 31): instrucciones detalladas sobre laintegración de Amazon GameLift en un servidor de juegos.

• Adición de Amazon GameLift al cliente de juego (p. 35): instrucciones detalladas sobre la integraciónen un cliente o servicio de juego, incluida la creación de sesiones de juego y la conexión de jugadores ajuegos.

Amazon LumberyardLos SDK y la funcionalidad de Amazon GameLift están totalmente integrados en el producto Lumberyard.

Servidores de juegos

Prepare los servidores de juegos para su alojamiento en Amazon GameLift mediante Amazon GameLiftServer SDK for C++ (p. 152). Consulte Adición de Amazon GameLift al servidor de juegos (p. 31) paraobtener ayuda con la integración de la funcionalidad necesaria en el servidor de juegos.

Clientes y servicios de juego

Version23

Amazon GameLift Developer GuideUnreal Engine

Active los clientes y/o servicios de juegos para interactuar con el servicio Amazon GameLift, por ejemplo,para buscar sesiones de juego disponibles o para crear sesiones nuevas y agregar jugadores a los juegos.Consulte la AWS SDK for C++ para obtener información sobre las funcionalidades principales de cliente.Para integrar Amazon GameLift en el proyecto de juego Lumberyard, consulte Preparación del cliente dejuego en Amazon Lumberyard (p. 24) y Adición de Amazon GameLift al cliente de juego (p. 35).

Unreal EngineServidores de juegos

Prepare los servidores de juegos para su alojamiento en Amazon GameLift añadiendo el AmazonGameLift Server SDK for Unreal Engine (p. 182) a su proyecto e implementando la funcionalidad deservidor necesaria. Para ayudar a configurar el complemento de Unreal Engine y añadir el código deAmazon GameLift, consulte Adición de Amazon GameLift a un proyecto del servidor de juegos UnrealEngine (p. 25).


Active los clientes y/o servicios de juegos para interactuar con el servicio Amazon GameLift, por ejemplo,para buscar sesiones de juego disponibles o para crear sesiones nuevas y agregar jugadores a los juegos.Consulte la AWS SDK for C++ para obtener información sobre las funcionalidades principales de cliente.Para integrar Amazon GameLift en su proyecto de juego de Unreal Engine, consulte Adición de AmazonGameLift al cliente de juego (p. 35).

UnityServidores de juegos

Prepare los servidores de juegos para su alojamiento en Amazon GameLift añadiendo el Amazon GameLiftServer SDK for C# (p. 168) a su proyecto e implementando la funcionalidad de servidor necesaria. Paraobtener ayuda sobre la configuración con Unity y la adición de código de Amazon GameLift, consulteAdición de Amazon GameLift a un proyecto del servidor de juegos Unity (p. 28).


Active los clientes y/o servicios de juegos para interactuar con el servicio Amazon GameLift, por ejemplo,para buscar sesiones de juego disponibles o para crear sesiones nuevas y agregar jugadores a los juegos.Consulte el AWS SDK para .NET para obtener información sobre las funcionalidades principales de cliente.Para integrar Amazon GameLift en el proyecto de juego Unity, consulte Adición de Amazon GameLift alcliente de juego (p. 35).

Otros motoresSi desea obtener una lista completa de los SDK de Amazon GameLift disponibles para servidores yclientes de juego, consulte the section called “SDK de GameLift” (p. 15).

Preparación del cliente de juego en AmazonLumberyardTodos los clientes de juego deben configurarse para permitir la comunicación con el servicio AmazonGameLift, incluidas las especificidades sobre la flota a utilizar, las credenciales de acceso, cómoconectarse, etc. El método más sencillo es crear un archivo por lotes que defina las variables de la consolaenumeradas como se indica a continuación.

Sugerencia

No necesita tener un juego preparado para empezar a experimentar con Amazon GameLift.Para obtener más información sobre las herramientas disponibles, explore rápidamente

Version24



https://docs.aws.amazon.com/sdkfornet/v3/apidocs/

Amazon GameLift Developer GuideUnreal Engine: adición de GameLifta un proyecto del servidor de juegos

las características de Amazon GameLift en este artículo informativo sobre AmazonGameLift (p. 21).

Para preparar el cliente de juego

1. En el archivo por lotes, defina las siguientes variables de la consola para lanzar el cliente de juego.Estas variables se han añadido a \dev\Code\CryEngine\CryNetwork\Lobby\LobbyCvars

• gamelift_aws_access_key = parte de IAM credenciales de seguridad (p. 18) para un usuariocon acceso de "jugador" en la cuenta de AWS

• gamelift_aws_secret_key = parte de IAM credenciales de seguridad (p. 18) para un usuariocon acceso de "jugador" en la cuenta de AWS

• gamelift_fleet_id = ID único de una flota activa a la que conectarse• gamelift_alias_id = ID único de un alias que apunta hacia la flota a la que conectarse• (Opcional) gamelift_endpoint = punto de enlace del servidor de Amazon GameLift; el valor

predeterminado es gamelift.us-west-2.amazonaws.com• (Opcional) gamelift_aws_region = nombre de la región de AWS; el valor predeterminado esus-west-2

• (Opcional) gamelift_player_id = ID que se genera para identificar de forma exclusiva a unjugador (p. 39)

2. Añada el siguiente comando para lanzar el navegador del servidor:

Siga este patrón al utilizar un ID de flota de Amazon GameLift (gamelift_fleet_id):

.\Bin64\[your game executable] +gamelift_fleet_id [your fleet ID] +gamelift_aws_region us-west-2 +gamelift_aws_access_key [your AWS access key] +gamelift_aws_secret_key [your AWS secret key] +sv_port 64091 +map [map name]

Siga este patrón al utilizar un ID de alias de Amazon GameLift (gamelift_alias_id):

.\Bin64\[your game executable] +gamelift_alias_id [your alias ID] +gamelift_aws_region us-west-2 +gamelift_aws_access_key [your AWS access key] +gamelift_aws_secret_key [your AWS secret key] +sv_port 64091 +map [map name]

Adición de Amazon GameLift a un proyecto delservidor de juegos Unreal EngineEste tema le ayudará a configurar y utilizar el complemento del SDK de servidor de Amazon GameLiftpara Unreal Engine en proyectos del servidor de juegos. Si no está seguro de si Amazon GameLift escompatible con los sistemas operativos que utiliza, consulte Para servidores de juegos (p. 15).

Configuración del complemento del SDK de servidor para UnrealEngineSiga estos pasos para que el complemento del SDK de servidor de Amazon GameLift para Unreal Engineesté listo para proyectos del servidor de juegos.

Para configurar el complemento del SDK de Amazon GameLift para Unreal Engine

1. Descargue el SDK del servidor de Amazon GameLift. Para comprobar que es compatible con losrequisitos del sistema del juego, consulte Los SDK de Amazon GameLift (p. 15).

Version25

https://aws.amazon.com/gamelift/getting-started


2. Compile las bibliotecas del SDK del servidor C++ para Unreal. La descarga del SDK contieneel código fuente para C++ (consulte GameLift_<release date>\GameLift-SDK-Release-<version>\GameLift-cpp-ServerSDK-<version>). Consulte el archivo README deeste directorio para conocer los requisitos mínimos antes de crear el SDK.

Para crear las bibliotecas del SDK, vaya al directorio GameLift-cpp-ServerSDK-<version> ycompílelo con el marcador -DBUILD_FOR_UNREAL establecido en true. Las siguientes instruccionesmuestran cómo compilar con cmake.

Para usuarios de Linux:

mkdir outcd outcmake -DBUILD_FOR_UNREAL=1 ..make

Se generan los siguientes archivos binarios:

• out/prefix/lib/libaws-cpp-sdk-gamelift-server.so

Para usuarios de Windows:

mkdir outcd outcmake -G "Visual Studio 14 2015 Win64" -DBUILD_FOR_UNREAL=1 ..msbuild ALL_BUILD.vcxproj /p:Configuration=Release

Se generan los siguientes archivos binarios:

• out\prefix\bin\aws-cpp-sdk-gamelift-server.dll

• out\prefix\lib\aws-cpp-sdk-gamelift-server.lib

Para obtener más información sobre la compilación del SDK de C++, incluidos los requisitos mínimosy las opciones de compilación, consulte el archivo README.md incluido en la descarga.

3. Agregue los archivos binarios a los archivos de complemento de Amazon GameLift. Copie los nuevosarchivos binarios en el directorio ThirdParty del complemento Unreal, con las siguientes rutas:

En Linux, utilice estas rutas:

• ThirdParty/GameLiftServerSDK/Linux/x86_64-unknown-linux-gnu/aws-cpp-sdk-gamelift-server.so

En Windows, utilice estas rutas:

• ThirdParty\GameLiftServerSDK\Win64\aws-cpp-sdk-gamelift-server.dll

• ThirdParty\GameLiftServerSDK\Win64\aws-cpp-sdk-gamelift-server.lib

4. Importe el complemento de Amazon GameLift a un proyecto. Aunque dispone de muchas formas paraimportar un complemento en Unreal Engine, el siguiente método no requiere el editor de Unreal.

a. Añada el complemento al proyecto de juego. Los archivos de complemento deben contenertodos los elementos del directorio GameLiftServerSDK del complemento, incluidos los archivosbinarios generados.

b. Añada el complemento al archivo .uproject del juego:

Version26


"Plugins": [ { "Name": "GameLiftServerSDK", "Enabled": true }]

c. Añada el complemento como dependencia de las ModuleRules del juego:

using UnrealBuildTool;

public class MyAwesomeGame : ModuleRules{ public MyAwesomeGame(TargetInfo Target) { PublicDependencyModuleNames.AddRange(new string[] { "Core", "CoreUObject", "Engine", "InputCore", "GameLiftServerSDK" }); }}

Adición de código de Amazon GameLiftPara obtener más información sobre cómo añadir funcionalidad de Amazon GameLift, consulte lossiguientes temas:

• Adición de Amazon GameLift al servidor de juegos (p. 31)• Referencia de la API del servidor de Amazon GameLift para Unreal Engine (p. 182)

Al añadir código específico de Amazon GameLift al proyecto de juego Unreal Engine, escriba el códigoutilizando la marca de preprocesador WITH_GAMELIFT=1. Esta marca garantiza que solo llamen a la APIbackplane de Amazon GameLift las compilaciones de servidor y le permite escribir código que se ejecutacorrectamente, independientemente del tipo de destino de compilación que pueda producir con el mismo.

El código envuelto con la marca WITH_GAMELIFT=1 solo se procesa si lo siguiente es verdadero:

• El complemento ha encontrado los archivos binarios del SDK de servidor de Amazon GameLift.• La compilación es un servidor de juegos: Target.Type == TargetRules.TargetType.Server

El siguiente fragmento de código ilustra cómo inicializar un servidor de juego Unreal Engine con AmazonGameLift.

// "GameLiftFPS" is a sample game name, replace with file names from your own game project#include "GameLiftFPS.h"#include "Engine.h"#include "EngineGlobals.h"#include "GameLiftFPSGameMode.h"#include "GameLiftFPSHUD.h"#include "GameLiftFPSCharacter.h"#include "GameLiftServerSDK.h"

AGameLiftFPSGameMode::AGameLiftFPSGameMode() : Super(){

//Let's run this code only if GAMELIFT is enabled. Only with Server targets!#if WITH_GAMELIFT

Version27

Amazon GameLift Developer GuideUnity: adición de GameLift a unproyecto del servidor de juegos

//Getting the module first. FGameLiftServerSDKModule* gameLiftSdkModule = &FModuleManager::LoadModuleChecked<FGameLiftServerSDKModule>(FName("GameLiftServerSDK"));

//InitSDK establishes a local connection with GameLift's agent to enable further communication. gameLiftSdkModule->InitSDK();

//When a game session is created, GameLift sends an activation request to the game server and passes along the game session object containing game properties and other settings. //Here is where a game server should take action based on the game session object. //Once the game server is ready to receive incoming player connections, it should invoke GameLiftServerAPI.ActivateGameSession() auto onGameSession = [=](Aws::GameLift::Server::Model::GameSession gameSession) { gameLiftSdkModule->ActivateGameSession(); }; FProcessParameters* params = new FProcessParameters(); params->OnStartGameSession.BindLambda(onGameSession);

//OnProcessTerminate callback. GameLift invokes this callback before shutting down an instance hosting this game server. //It gives this game server a chance to save its state, communicate with services, etc., before being shut down. //In this case, we simply tell GameLift we are indeed going to shut down. params->OnTerminate.BindLambda([=](){gameLiftSdkModule->ProcessEnding();});

//This is the HealthCheck callback. //GameLift invokes this callback every 60 seconds or so. //Here, a game server might want to check the health of dependencies and such. //Simply return true if healthy, false otherwise. //The game server has 60 seconds to respond with its health status. GameLift defaults to 'false' if the game server doesn't respond in time. //In this case, we're always healthy! params->OnHealthCheck.BindLambda([](){return true; });

//This game server tells GameLift that it listens on port 7777 for incoming player connections. params->port = 7777;

//Here, the game server tells GameLift what set of files to upload when the game session ends. //GameLift uploads everything specified here for the developers to fetch later. TArray<FString> logfiles; logfiles.Add(TEXT("aLogFile.txt")); params->logParameters = logfiles;

//Calling ProcessReady tells GameLift this game server is ready to receive incoming game sessions! gameLiftSdkModule->ProcessReady(*params);#endif}

Adición de Amazon GameLift a un proyecto delservidor de juegos UnityEste tema le ayudará a configurar el SDK del servidor C# de Amazon GameLift e integrar AmazonGameLift en el proyecto del servidor de juegos Unity. Si no está seguro de si Amazon GameLift escompatible con los sistemas operativos que utiliza, consulte Para servidores de juegos (p. 15).

Version28


Configuración del SDK del servidor C # para UnitySiga estos pasos para compilar el SDK de servidor para C# de Amazon GameLift y añadirlo a losproyectos del servidor de juegos Unity.

Para configurar el SDK del servidor de Amazon GameLift para Unity

1. Descargue el SDK del servidor de Amazon GameLift. Para comprobar que es compatible con losrequisitos del sistema del juego, consulte Los SDK de Amazon GameLift (p. 15). El SDK de servidorincluye las siguientes dos soluciones:

• GameLiftServerSDKNet35.sln for .Net framework 3.5• GameLiftServerSDKNet45.sln for .Net framework 4.5

Solo la solución .Net 3.5 es compatible con Unity.2. Compile las bibliotecas del SDK de C#. Consulte el archivo README.md para el SDK del servidor de

C# para conocer los requisitos mínimos y las opciones de compilación adicionales. En un IDE, cargueel archivo de la solución .Net 3.5. Para generar las bibliotecas del SDK, restaure los paquetes NuGet ycompile la solución.

3. Compruebe el valor de compatibilidad de la API. En el editor de Unity, vaya a File, Build Settings,Player Settings. En la sección Other Settings, bajo Optimization, asegúrese de que el nivel decompatibilidad de la API esté definido en .Net 2.0.

4. Agregue las bibliotecas de Amazon GameLift a Unity. En el editor de Unity, importe las siguientesbibliotecas al directorio Assets/Plugins:

• EngineIoClientDotNet.dll

• GameLiftServerSDKNet35.dll

• log4net.dll

• Newtonsoft.Json.dll

• protobuf-net.dll

• SocketIoClientDotNet.dll

• System.Threading.Tasks.NET35.dll

• WebSocket4Net.dll

Adición de código de servidor de Amazon GameLiftPara obtener más información sobre cómo añadir funcionalidad de Amazon GameLift, consulte lossiguientes temas:

• Adición de Amazon GameLift al servidor de juegos (p. 31)• Referencia de la API de servidor (C#) de Amazon GameLift (p. 168)

El siguiente código de ejemplo utiliza un MonoBehavior para ilustrar una inicialización sencilla delservidor de juegos con Amazon GameLift.

using UnityEngine;using Aws.GameLift.Server;using System.Collections.Generic;

public class GameLiftServerExampleBehavior : MonoBehaviour{ //This is an example of a simple integration with GameLift server SDK that makes game server processes go active on Amazon GameLift

Version29

https://aws.amazon.com/gamelift/getting-started


public void Start() { var listeningPort = 7777;

//InitSDK establishes a local connection with the Amazon GameLift agent to enable further communication. var initSDKOutcome = GameLiftServerAPI.InitSDK(); if (initSDKOutcome.Success) { ProcessParameters processParameters = new ProcessParameters( (gameSession) => { //When a game session is created, GameLift sends an activation request to the game server and passes along the game session object containing game properties and other settings. //Here is where a game server should take action based on the game session object. //Once the game server is ready to receive incoming player connections, it should invoke GameLiftServerAPI.ActivateGameSession() GameLiftServerAPI.ActivateGameSession(); }, () => { //OnProcessTerminate callback. GameLift invokes this callback before shutting down an instance hosting this game server. //It gives this game server a chance to save its state, communicate with services, etc., before being shut down. //In this case, we simply tell GameLift we are indeed going to shut down. GameLiftServerAPI.ProcessEnding(); }, () => { //This is the HealthCheck callback. //GameLift invokes this callback every 60 seconds or so. //Here, a game server might want to check the health of dependencies and such. //Simply return true if healthy, false otherwise. //The game server has 60 seconds to respond with its health status. GameLift will default to 'false' if the game server doesn't respond in time. //In this case, we're always healthy! return true; }, listeningPort, //This game server tells GameLift that it will listen on port 7777 for incoming player connections. new LogParameters(new List<string>() { //Here, the game server tells GameLift what set of files to upload when the game session ends. //GameLift uploads everything specified here for the developers to fetch later. "/local/game/logs/myserver.log" }));

//Calling ProcessReady tells GameLift this game server is ready to receive incoming game sessions! var processReadyOutcome = GameLiftServerAPI.ProcessReady(processParameters); if (processReadyOutcome.Success) { print("ProcessReady success."); } else { print("ProcessReady failure : " + processReadyOutcome.Error.ToString()); } } else { print("InitSDK failure : " + initSDKOutcome.Error.ToString());

Version30

Amazon GameLift Developer GuideIntegración de un servidor de juegos

} }

void OnApplicationQuit() { //Make sure to call GameLiftServerAPI.Destroy() when the application quits. This resets the local connection with GameLift's agent. GameLiftServerAPI.Destroy(); }}

Integración del servidor de juegos en AmazonGameLift

Los temas de esta sección describen cómo integrar Amazon GameLift en un servidor de juegosmultijugador.

Agregar Amazon GameLift al servidor de juegos es el paso 2 del plan de ruta Plan deintegración (p. 21). Los temas sobre integración de esta sección parten de la base de que ha creadouna cuenta de AWS y que dispone de un proyecto de servidor de juegos.

Temas

• Adición de Amazon GameLift al servidor de juegos (p. 31)• Referencia de la API de servidor (C++) de Amazon GameLift (p. 152)• Referencia de la API de servidor (C#) de Amazon GameLift (p. 168)• Referencia de la API del servidor de Amazon GameLift para Unreal Engine (p. 182)

Adición de Amazon GameLift al servidor de juegosUna vez implementado, el servidor de juegos debe interactuar con el servicio Amazon GameLift y debeejecutarse como varios procesos del servidor en una flota de Amazon GameLift. El código que añadapermite a cada proceso del servidor comunicarse con el servicio Amazon GameLift. Los procesos delservidor deben ser capaces de responder a determinados eventos disparados por el servicio AmazonGameLift y mantener a Amazon GameLift informado sobre la actividad de los jugadores y el estadodel proceso del servidor. Consulte la siguiente descripción completa de interacciones de AmazonGameLift (p. 40).

Utilice el SDK del servidor de Amazon GameLift para el lenguaje preferido para añadir funcionalidad deAmazon GameLift al servidor de juegos. Consulte las siguientes referencias de la API del servidor paraobtener más información:

• Referencia de la API de servidor C++ (p. 152)• Referencia de la API de servidor C# (p. 168)• Referencia de la API del complemento Unreal Engine (p. 182)

Para integrar Amazon GameLift en el servidor de juegos, añada el SDK del servidor de Amazon GameLiften el proyecto del servidor de juegos y compile la funcionalidad descrita en este tema.

Version31

Amazon GameLift Developer GuideAdición de GameLift a un servidor de juegos

Preparación de un proceso del servidorAñada código para inicializar un cliente de Amazon GameLift y notifique al servicio Amazon GameLift queel servidor está listo para alojar una sesión de juego. Este código debe ejecutarse automáticamente antesde cualquier código dependiente de Amazon GameLift como, por ejemplo, en el lanzamiento.

Note

Los nombres de acción de la API de servidor son los mismos en todos los lenguajes disponibles.

1. Inicializar el SDK del servidor. Llame a InitSdk().2. Notifique a Amazon GameLift que el proceso del servidor de juegos está listo para alojar una sesión

de juego. Cada proceso del servidor iniciado en una instancia Amazon GameLift debe llamar aProcessReady() con la siguiente información:

• El número de puerto que utiliza el proceso del servidor. Este número de puerto, junto con unadirección IP, se almacena en un objeto de sesión de juego, que los clientes de juego utilizan alconectarse a una sesión de juego activa.

• La ubicación de los archivos generados durante una sesión de juego activa que desea que AmazonGameLift conserve como, por ejemplo, los logs de sesiones de juego. Los archivos generados porun proceso del servidor al alojar una sesión de juego se guardan en la instancia Amazon GameLiftpero se pierden cuando se cierra una instancia. Amazon GameLift solo cargará aquellos archivosque solicite; una vez cargados, serán accesibles desde la consola de Amazon GameLift o llamandoa la API de Amazon GameLift GetGameSessionLogUrl(). Considere la posibilidad de utilizar unesquema de nomenclatura de archivos que identifique las sesiones de juego de forma unívoca si laflota se ha configurado para ejecutar varios procesos del servidor por instancia simultáneamente.

• Los nombres de las funciones de devolución de llamada utilizadas por Amazon GameLift paradisparar determinadas acciones en el proceso del servidor. En las siguientes secciones y enProcessParameters (p. 165) se ofrece más información acerca de la implementación de estasfunciones.• Se llama a onHealthCheck (requerido) con regularidad para solicitar un informe de estado del

proceso del servidor.• Se llama a onStartGameSession (requerido) cuando el servicio Amazon GameLift recibe una

solicitud para iniciar una nueva sesión de juego (CreateGameSession()).• Se llama a onProcessTerminate (requerido) cuando el servicio Amazon GameLift necesita

forzar la terminación del proceso del servidor, lo que permite que el proceso del servidor seapague correctamente.

• Se llama a onUpdateGameSession (opcional) cuando el servicio Amazon GameLift ofreceun objeto de sesión de juego actualizado al servidor de juegos o proporciona una actualizaciónde estado de una solicitud de reposición de emparejamiento. Esta devolución de llamadasolamente es necesaria si utiliza la característica de reposición de FlexMatch (p. 13). Obtengamás información sobre cómo implementar esta función de devolución de llamada en Actualizaciónde datos de emparejamientos en el servidor de juegos (p. 127).

Dependiendo de la configuración de las flotas, es posible que se ejecuten varios procesos del servidorde forma simultánea en una instancia de la flota. En cuanto un proceso del servidor en una instanciallama a ProcessReady() correctamente, el servicio Amazon GameLift define el estado de lainstancia en ACTIVE.

Notificación del estado del proceso del servidorAñada código para implementar la función de devolución de llamada onHealthCheck(). El servicioAmazon GameLift llama a esa función con regularidad para recopilar métricas de estado del proceso delservidor. La respuesta del proceso del servidor a una comprobación de estado es de tipo binario: en buenestado o en mal estado. Al implementar esta función de devolución de llamada, haga lo siguiente:

Version32


https://docs.aws.amazon.com/gamelift/latest/apireference/API_GetGameSessionLogUrl.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreateGameSession.html


• Evalúe el estado del proceso del servidor con las medidas adecuadas para el juego. Por ejemplo, si lasdependencias externas han fallado o si las métricas como, por ejemplo, la capacidad de memoria sesalen de un límite definido, tendría sentido decir que el proceso del servidor no funciona correctamente.

• Complete la evaluación del estado y responda a la devolución de llamada en un plazo de 60segundos. Si el servicio Amazon GameLift no recibe una respuesta durante ese período, consideraráautomáticamente que el proceso del servidor no está funcionando correctamente.

• Devuelva un valor booleano: true para buen estado, false para mal estado.

Si no implementa una devolución de llamada de la comprobación de estado, el servicio Amazon GameLiftconsiderará que el proceso del servidor está funcionando correctamente, a menos que el proceso noresponda, en cuyo caso considerará que no funciona correctamente.

Amazon GameLift utiliza el estado del proceso del servidor para terminar de forma eficaz procesos queno funcionan correctamente y para liberar recursos. Si un proceso del servidor sigue reportando un malestado o no responde a tres comprobaciones de estado consecutivas, el servicio Amazon GameLift puedecerrar el proceso e iniciar uno nuevo. Las métricas del estado del proceso del servidor de una flota serecopilan y se pueden consultar en la consola de Amazon GameLift.

Inicio de una sesión de juegoAñada código para implementar la función de devolución de llamada onStartGameSession. El servicioAmazon GameLift invoca esta función al crear una nueva sesión de juego, que puede producirse enrespuesta a una solicitud CreateGameSession() o como parte de la ubicación de la sesión de juego o delas actividades de emparejamiento.

La función onStartGameSession toma un objeto GameSession, proporcionado por el servicio AmazonGameLift, como parámetro de entrada. Este objeto contiene el ID de sesión de juego y otra informaciónque define a la sesión de juego solicitada. La función debe realizar las siguientes tareas:

• Realizar las acciones necesarias para crear una sesión de juego nueva. La sesión de juego nueva debereflejar el objeto GameSession, incluida la creación de ranuras para el número máximo de jugadoresespecificado y la referencia al nombre y el ID de la sesión de juego. El servicio Amazon GameLiftproporciona la misma información de sesión de juego al cliente de juego.

• Procese los valores de la propiedad de juego especificados por el cliente de juego en esta solicitud. Laspropiedades de juego se encuentran en el objeto GameSession.

• En algún momento después de que la sesión de juego nueva esté lista para aceptar jugadores, elproceso del servidor debe llamar a la acción de la API de servidor ActivateGameSession(). Enrespuesta a una llamada realizada correctamente, el servicio Amazon GameLift cambia el estado de lasesión de juego a ACTIVE.

Validación de un jugador nuevoAñada código para verificar una solicitud de conexión de jugador con el servicio Amazon GameLift. Estecódigo debe ejecutarse siempre que un nuevo jugador intente conectarse al proceso del servidor y antesde aceptar la conexión.

Las solicitudes de conexión de un cliente de juego deben hacer referencia a un ID de sesión de jugador.El servicio Amazon GameLift emite este ID y lo utiliza para reservar una ranura de jugador en la sesión dejuego (como respuesta a una llamada del SDK de AWS a CreatePlayerSession()). El servidor de juegosdebe llamar a AcceptPlayerSession() con el ID de sesión de jugador de referencia para verificar quela solicitud de conexión proviene del jugador autorizado.

Una vez que el ID de sesión del jugador esté validado por el servicio Amazon GameLift, el proceso delservidor puede aceptar la conexión y permitir que el jugador se conecte a la sesión de juego. Si el servicioAmazon GameLift no valida el ID de sesión de jugador, el proceso del servidor debe rechazar la conexión.

Version33



http://docs.aws.amazon.com/gamelift/latest/apireference/API_GameSession.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreatePlayerSession.html


Para recibir todos los datos de jugador asociados a la sesión de juego, llame aDescribePlayerSessions().

Notificación de la terminación de una sesión de jugadorAñada código para notificar al servicio Amazon GameLift que un jugador se ha desconectado de la sesiónde juego. Este código debe ejecutarse siempre que el proceso del servidor detecte la interrupción de unaconexión.

En el código que gestiona la conexión interrumpida, añada una llamada a la acción de la API de servidorRemovePlayerSession() con el ID de sesión de jugador asociado a la conexión interrumpida. Estanotificación permite al servicio Amazon GameLift realizar un seguimiento preciso del número de jugadoresactual y de las ranuras disponibles en la sesión de juego.

Parada de una sesión de juegoAñada código para notificar al servicio Amazon GameLift que un jugador ha finalizado una sesión de juego.Esta notificación permite al servicio Amazon GameLift realizar un seguimiento preciso de la disponibilidadde un proceso del servidor para sesiones de juego nuevas. Este código debe añadirse a la sesión de juegonormal que finaliza el proceso.

Al final del código para detener una sesión de juego, añada una llamada a la acción de la API de servidorTerminateGameSession(). Si la notificación se recibe correctamente, el servicio Amazon GameLiftcambia el estado de la sesión de juego por TERMINATED y puede iniciar una sesión de juego nuevainmediatamente.

Note

Si la parada de una sesión de juego va seguida del cierre inmediato del proceso del servidor,puede llamar a la acción de la API de servidor ProcessEnding(), que termina tanto la sesión dejuego como el proceso del servidor.

Parada de un proceso del servidorEl apagado puede iniciarse por un proceso de servidor o por el servicio Amazon GameLift. Realice lossiguientes cambios en el código del servidor de juegos para gestionar cualquier caso.

• Implemente la función de devolución de llamada onProcessTerminate(). Esta función debe llamaral código que apaga el servidor de juegos. El servicio Amazon GameLift llama a esta función parainiciar un apagado del proceso de servidor, normalmente antes de terminar la instancia que estáejecutando el proceso de servidor. Los motivos para invocar a esta llamada es cuando Amazon GameLiftestá apagando un proceso de servidor en mal estado, cuando se interrumpe una instancia de spot ocuando la capacidad de la instancia se está reduciendo. Después de recibir esta llamada, el proceso deservidor suele tener unos minutos (dos minutos en el caso de terminación de una instancia de spot) paradesconectar a los jugadores con fluidez, conservar los datos de estado del juego y realizar otras tareasde limpieza.

• Llame a la acción de la API del servidor GetTerminationTime() (p. 156) desde el código de apagado delservidor de juegos. Si Amazon GameLift ha emitido una llamada para terminar el proceso de servidor,GetTerminationTime() devuelve una tiempo de terminación estimado, si está disponible. Puedeutilizar esta información para determinar qué actividades de apagado se pueden realizar en el tiemporestante, como guardar los datos de estado del juego o la migración de jugadores a una nueva sesión dejuego.

• Al inicio del código de apagado del servidor de juegos, llame a la acción de la API del servidorProcessEnding() (p. 157). Esta llamada notifica al servicio Amazon GameLift que el proceso delservidor se va a apagar. Al recibir esta notificación, el servicio Amazon GameLift cambia el estado delproceso del servidor por TERMINATED y podría reciclar inmediatamente los recursos de la instancia

Version34

Amazon GameLift Developer GuideIntegración de un cliente de juego

según sea necesario. Esto garantiza también que ahora las sesiones de juego nuevas se envían alproceso. Una vez que se ha invocado ProcessEnding(), es seguro apagar el proceso.

Integración del cliente de juego en AmazonGameLift

Los temas de esta sección describen la funcionalidad de Amazon GameLift que puede añadir a un cliente oservicio de juegos que gestiona las siguientes tareas:

• Solicita información acerca de las sesiones de juego activas del servicio Amazon GameLift.• Conecta a un jugador a una sesión de juego existente.• Crea una sesión de juego nueva.• Cambia los metadatos de una sesión de juego existente.

Agregar Amazon GameLift al juego multijugador es el paso 5 del Plan de integración (p. 21). En lassiguientes instrucciones, se parte de la base de que ha creado una cuenta de AWS, generado un servidorde juegos compatible con Amazon GameLift, que lo ha subido a Amazon GameLift y que ha utilizado lasherramientas de Amazon GameLift (como la consola de Amazon GameLift) para crear y configurar unaflota virtual para alojar las sesiones de juego. Al añadir Amazon GameLift al cliente de juego, debe sercapaz de proporcionar las credenciales de la cuenta de AWS y especificar la flota que se va a utilizar conel cliente.

Para obtener más información acerca de cómo interactúan los clientes con el servicio de Amazon GameLifty sobre los servidores de juegos que se ejecutan en Amazon GameLift, consulte Interacciones de AmazonGameLift y el cliente/servidor de juegos (p. 40).

Temas• Adición de Amazon GameLift al cliente de juego (p. 35)• Creación de sesiones de juego con colas (p. 39)• Generación de ID de jugador (p. 39)

Adición de Amazon GameLift al cliente de juegoPuede integrar Amazon GameLift en componentes de juego que necesitan adquirir información desesión de juego, crear sesiones de juego nuevas y/o conectar a jugadores a juegos. Dependiendo de laarquitectura del juego, esta funcionalidad se coloca en el cliente de juego o en servicios de juego queadministran tareas como la autenticación de los jugadores, el emparejamiento o la ubicación de juegos.

Para hacerlo, utilice el AWS SDK con la API de Amazon GameLift. Este SDK está disponible en C++, C# y en otros lenguajes. Para obtener más información sobre la información de versión del AWS SDK, y lacompatibilidad de los lenguajes, consulte Los SDK de Amazon GameLift (p. 15). La mayoría de los enlacesde este tema lleva a la Referencia de la API del servicio Amazon GameLift, que describe la API del serviciode bajo nivel para acciones relacionadas con Amazon GameLift e incluye enlaces a guías de referenciaespecíficas de los lenguajes.

Note

¿Le interesa utilizar el emparejamiento para obtener jugadores en juegos? Una vez que hayaconfigurado Amazon GameLift en el cliente de juego o en un servicio, agregue FlexMatchpara emparejar jugadores y crear sesiones de juego personalizadas. Más información enEmparejamientos con FlexMatch (p. 98).

Version35


Amazon GameLift Developer GuideAdición de GameLift a un cliente de juego

Configuración de Amazon GameLift en un cliente o servicioPuede añadir código para inicializar un cliente o servicio de juego Amazon GameLift y almacenar algunosvalores clave para utilizarlos con Amazon GameLift. Este código debe ubicarse de tal forma que se ejecuteantes que cualquier código dependiente de Amazon GameLift, como durante el lanzamiento.

Note

Para configurar el cliente de juego para probar Amazon GameLift Local, consulte Prueba de laintegración (p. 44)

1. Decida si quiere utilizar la configuración del cliente predeterminada o crear ajustes personalizados.Para los ajustes personalizados, debe crear un objeto ClientConfiguration personalizado.Consulte AWS ClientConfiguration (C++) para ver la estructura de los objetos y la configuraciónpredeterminada.

Una configuración de cliente especifica una región de destino y un punto de enlace. La regióndetermina con qué recursos (flotas, colas, creador de emparejamientos, etc.) interactúa AmazonGameLift a la hora de responder a las solicitudes. La configuración de cliente predeterminadaespecifica la región US East (N. Virginia). Para utilizar cualquier otra región, cree una configuraciónpersonalizada. Consulte la lista de regiones de AWS admitida por Amazon GameLift para los nombresy los puntos de enlace. Si el cliente o servicio deben realizar solicitudes para varias regiones, cree unobjeto de configuración de cliente independiente para cada región de destino según sea necesario.Consulte Using Regions with the AWS SDKs para obtener ejemplos específicos de lenguaje.

2. Inicialice un cliente Amazon GameLift. Llame a Aws::GameLift::GameLiftClient() (C++) utilizando laconfiguración de cliente con los valores predeterminados o una configuración personalizada.

3. Añada un mecanismo para generar un identificador único para cada jugador. Amazon GameLiftnecesita un ID de jugador único para conectarse a una sesión de juego. Para obtener másinformación, consulte Generación de ID de jugador (p. 39).

4. Recopile y almacene la siguiente información para utilizar al conectarse a Amazon GameLift:

• Target fleet: la mayoría de solicitudes de API de Amazon GameLift deben especificar una flota,como, por ejemplo, a la hora de obtener información acerca de sesiones de juego disponibles oal administrar sesiones de juego y sesiones de jugador. La forma en que define la flota de destinoóptima (por ejemplo, configurar una flota estática o seleccionar flotas en función de la ubicaciónfísica de un dispositivo). Para especificar una flota de destino, utilice un ID de flota o un ID de aliasque apunte hacia la flota de destino. Los alias de la flota son muy útiles pues permiten intercambiarjugadores de una flota a otra sin emitir ninguna actualización de cliente de juego. La combinaciónde flota de destino y región (especificada en la configuración del cliente) identifica a la flota de formaexclusiva.

• Target queue: si el juego utiliza colas con varias flotas para ubicar sesiones de juego nuevas, puedeespecificar la cola que quiere utilizar. Para especificar una cola de destino, utilice el nombre de lacola. La cola debe configurarse en la región

• Credenciales de AWS: todas las llamadas al servicio Amazon GameLift deben proporcionarcredenciales para la cuenta de AWS que aloja el juego. Se trata de la cuenta que utilizópara configurar las flotas de Amazon GameLift y tiene que haber creado un usuario o grupode usuarios de IAM para jugadores con una política de permisos. Debe crear un objetoAws::Auth::AWSCredentials (C++) que contenga una clave de acceso de IAM y una clave secretapara el grupo de usuarios de los jugadores. Para obtener ayuda para encontrar las claves, consulteManaging Access Keys for IAM Users.

Obtención de sesiones de juegoAñada código para descubrir las sesiones de juego disponibles y administrar la configuración de lassesiones de juego y los metadatos. Consulte Características de la sesión de juego y de jugador (p. 9) paraobtener más información sobre las características de las sesiones de juego.

Version36

http://sdk.amazonaws.com/cpp/api/LATEST/struct_aws_1_1_client_1_1_client_configuration.html

https://docs.aws.amazon.com/general/latest/gr/rande.html#gamelift_region

https://aws.amazon.com/articles/3912

http://sdk.amazonaws.com/cpp/api/LATEST/class_aws_1_1_game_lift_1_1_game_lift_client.html

http://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-iam-policy-intro.html

http://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-iam-policy-intro.html

http://sdk.amazonaws.com/cpp/api/LATEST/class_aws_1_1_auth_1_1_a_w_s_credentials.html

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_credentials_access-keys.html


Búsqueda de sesiones de juego activas.

Utilice SearchGameSessions para obtener información sobre una sesión de juego específica, todas lassesiones activas o las sesiones que cumplan un conjunto de criterios de búsqueda. Esta llamada devuelveun objeto GameSession para cada sesión de juego activa que coincida con la solicitud de búsqueda.

Utilice los criterios de búsqueda para obtener una lista filtrada de las sesiones de juego activas a las quepuedan conectarse los jugadores. Por ejemplo, puede filtrar sesiones de la siguiente manera:

• Excluya las sesiones de juego que no aceptan jugadores nuevos: PlayerSessionCreationPolicy= DENY_ALL

• Excluya las sesiones de juego llenas: CurrentPlayerSessionCount =MaximumPlayerSessionCount

• Elija las sesiones de juego en función de la duración de la sesión: Evaluate CreationTime• Encuentre sesiones de juego en función de una propiedad de juego personalizada:gameSessionProperties.gameMode = "brawl"

Administración de sesiones de juego.

Utilice cualquiera de las operaciones siguientes para recuperar o actualizar la información de la sesión dejuego.

• DescribeGameSessionDetails(): obtener el estado de protección de la sesión de juego además de lainformación de la sesión de juego.

• UpdateGameSession(): cambiar los metadatos y la configuración de una sesión de juego según seanecesario.

• GetGameSessionLogUrl: acceder a logs de sesión de juego almacenados.

Creación de sesiones de juegoAñada código para iniciar sesiones de juego nuevas en las flotas implementadas y ponerlas a disposiciónde los jugadores. Existen dos opciones para crear sesiones de juego, en función de si el juego seimplementa en varias regiones o en una única región.

Creación de una sesión de juego utilizando una cola de varias regiones.

Utilice StartGameSessionPlacement para colocar una solicitud de una sesión de juego nueva en una cola.Para utilizar esta característica, tendrá que configurar una cola, que determina dónde (en qué flotas) sepuede ubicar la nueva sesión de juego. Una cola procesa una solicitud de ubicación de sesión de juegoprobando cada posible flota, una detrás de otra, hasta que encuentra una con los recursos disponiblespara alojar la sesión de juego nueva. Para obtener más información detallada acerca de las colas y cómoutilizarlas, consulte Diseño de colas de sesiones de juego (p. 87).

Al crear una ubicación de la sesión de juego, especifique el nombre de la cola a utilizar, un nombre desesión de juego, la cantidad máxima de jugadores simultáneos en el juego y un conjunto de propiedadesdel juego opcionales. Si lo desea, puede proporcionar una lista de los jugadores para que se unanautomáticamente a la sesión de juego. Si incluye los datos de latencia de los jugadores de las regionesrelevantes, Amazon GameLift utiliza esta información para colocar la sesión de juego nueva en una flotaque proporciona la mejor experiencia de juego posible a los jugadores.

La ubicación de sesiones de juego es un proceso asíncrono. Una vez realizada la solicitud, puedeesperar a que funcione o a que expire. También puede cancelar la solicitud en cualquier momentoutilizando StopGameSessionPlacement. Para comprobar el estado de la solicitud de ubicación, llame aDescribeGameSessionPlacement para recuperar un objeto GameSessionPlacement actualizado. Cuandose crea una sesión de juego nueva, GameSessionPlacement refleja los siguientes cambios: (1) el estado

Version37

https://docs.aws.amazon.com/gamelift/latest/apireference/API_SearchGameSessions.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_GameSession.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeGameSessionDetails.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_UpdateGameSession.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_GetGameSessionLogUrl.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_StartGameSessionPlacement.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_StopGameSessionPlacement.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeGameSessionPlacement.html


cambia de Pending a Fulfilled; (2) se añade información de sesión de juego nueva, incluido el ID de sesiónde juego y la región; y (3) se añade información de sesión de jugador nueva (si es necesario).

Creación de una sesión de juego en una flota específica.

Utilice CreateGameSession para crear una sesión nueva en una flota específica. Esta operación síncronafunciona o no dependiendo de si la flota dispone de los recursos necesarios para alojar una sesiónde juego nueva. Su juego debe gestionar los errores de la forma que mejor se adapte al juego y a losjugadores. Por ejemplo, puede repetir la solicitud hasta que se liberen o amplíen los recursos, o puedecambiar a otra flota. En cuanto Amazon GameLift haya creado la nueva sesión de juego y devuelva unobjeto GameSession, podrá comenzar a conectar jugadores a la sesión.

Si utiliza este método para crear una sesión de juego, especifique un ID de flota o de alias, un nombre deuna sesión y un número máximo de jugadores simultáneos para dicho juego. De forma opcional, puedeincluir un conjunto de propiedades del juego. Las propiedades del juego se definen en una matriz de paresde clave-valor en la que se definen las claves y un conjunto de valores significativos para el juego. Estainformación se transfiere al proceso del servidor que aloja la nueva sesión de juego, y que se va a utilizartal como se ha diseñado en el servidor de juegos. Por ejemplo, puede utilizar las propiedades del juegopara ordenar a la sesión de juego que utilice un determinado mapa de juego determinado o un conjunto denormas concreto.

Si utiliza la característica de protección de recursos de Amazon GameLift para limitar el número desesiones de juego que puede crear un jugador, tendrá que especificar el ID del jugador que va a crear lasesión de juego.

Conexión de un jugador a una sesión de juegoAñada código para reservar ranuras de jugador en las sesiones de juego activas y conectar a clientes dejuego a sesiones de juego.

1. Reserve una ranura de jugador en una sesión de juego.

Para reservar una ranura de jugador, cree una sesión de jugador nueva para la sesión de juego. Paraobtener más información sobre las sesiones de jugador, consulte Cómo se conectan los jugadores alos juegos (p. 8). Existen dos formas de crear sesiones de jugador nuevas:

• Si utiliza StartGameSessionPlacement para crear las sesiones de juego, tal y como se describeen la sección anterior, puede reservar ranuras para uno o más jugadores en la sesión de juegonueva.

• Reserve ranuras de jugador para uno o varios jugadores utilizando CreatePlayerSession oCreatePlayerSessions con un ID de sesión de juego.

Con ambos métodos, Amazon GameLift primero verifica que la sesión de juego esté aceptandojugadores nuevos y que tiene una ranura de jugador disponible. En caso afirmativo, AmazonGameLift reserva una ranura para el jugador, crea la sesión de jugador nueva y devuelve un objetoPlayerSession que contiene la dirección IP y el puerto a las que debe conectarse el cliente de juegopara participar en la sesión de juego.

Una solicitud de sesión de jugador debe incluir un ID exclusivo para cada jugador. Para obtener másinformación sobre los ID de jugador, consulte Generación de ID de jugador (p. 39).

Opcionalmente, una solicitud de sesión de jugador puede incluir un conjunto de datos de jugadorpersonalizados. Estos datos se almacenan en el objeto de jugador que se acaba de crear, quepuede recuperarse llamando a DescribePlayerSessions(). También se transfiere desde el servicioAmazon GameLift al servidor de juegos cuando el jugador se conecta directamente a la sesión dejuego. Amazon GameLift no utiliza los datos del jugador. Se trata de una cadena de caracteressencilla que está disponible para que la interpreten los componentes del juego. A la hora de solicitar

Version38




https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreatePlayerSessions.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_PlayerSession.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribePlayerSessions.html

Amazon GameLift Developer GuideCreación de sesiones de juego con colas

varias sesiones de jugador, puede proporcionar una cadena de datos de jugador para cada jugador,asignada al ID de jugador en la solicitud.

2. Conéctese a una sesión de juego.

Añada código al cliente de juego para recuperar el objeto PlayerSession, que contiene la direcciónIP y el puerto de la sesión de juego. Utilice esta información para conectarse directamente con elproceso del servidor. Para reclamar la ranura de jugadores reservada, la solicitud de conexión debehacer referencia al ID de sesión de jugador. Una vez conectado, el cliente de juego y el proceso delservidor se comunican directamente, sin involucrar a Amazon GameLift. Este marco permite minimizarla duración de la latencia en el juego.

El proceso del servidor mantiene la comunicación con el servicio Amazon GameLift acerca de laconexión del jugador con el fin de realizar el seguimiento de la disponibilidad de las ranuras dejugador. En la conexión inicial, se pone en contacto con el servicio para verificar que el ID de sesiónde jugador es válido y que tiene el estado de reservado. Si se valida, se reclama la reserva y seacepta la conexión de jugadores. Después, cuando el jugador se desconecte, el proceso del servidornotificará que se ha desconectado.

Creación de sesiones de juego con colasEste conjunto de características le permite colocar sesiones de juego nuevas de forma más eficiente en losrecursos de Amazon GameLift y es más compatible con los servicios de emparejamiento. Anteriormente,las solicitudes de sesiones de juego nuevas se limitaban a una única flota (CreateGameSession) y lasolicitud daba error si la flota estaba a pleno rendimiento o no disponible por otro motivo.

Utilice una cola para colocar sesiones de juego nuevas en un grupo de flotas que pueda abarcar variasregiones. Si es necesario, el incremento de la demanda de jugadores puede desplazarse hacia las flotasmenos utilizadas en otras regiones. Las colas también reducen la sobrecarga necesaria para monitorizarlas flotas y equilibrar los recursos entre varias flotas y regiones. Puede administrar las colas y realizar unseguimiento de las métricas de desempeño de la cola en la consola de Amazon GameLift.

Cree una solicitud de ubicación de la sesión de juego nueva y añádala a una cola. Una solicitud deubicación de la sesión de juego incluye propiedades de la sesión de juego estándares y también le permiteañadir uno o más jugadores a la sesión de juego nueva.

Al crear una solicitud de ubicación de la sesión de juego, incluya los datos de latencia de los jugadorespara ayudar a Amazon GameLift a elegir una flota en una región que proporcione la mejor experienciaposible para todos los jugadores.

Generación de ID de jugadorAmazon GameLift utiliza una sesión de jugador para representar un jugador conectado a una sesión dejuego. Cada vez que un jugador se conecta a una sesión de juego debe crearse una sesión de jugador.Cuando un jugador sale de un juego, la sesión de jugador finaliza y no se vuelve a utilizar.

Amazon GameLift proporciona un archivo llamado Lobby.cpp en el proyecto de muestra de AmazonLumberyard MultiplayerSample que muestra cómo generar un número de ID nuevo aleatorio para cadajugador en cada nueva sesión de juego. No es necesario utilizar el código de muestra, se proporciona amodo de ejemplo. También puede volver a escribir el código para conservar sus ID de jugador únicos y noidentificables.

El siguiente código de ejemplo en Lobby.cpp genera ID de jugador únicos de forma aleatoria:

bool includeBrackets = false;bool includeDashes = true;string playerId = AZ::Uuid::CreateRandom().ToString<string>(includeBrackets, includeDashes);

Version39



Amazon GameLift Developer GuideInteracciones de GameLift

Puede ver las sesiones de jugador por ID de jugador en la Consola de administración de AWS de AmazonGameLift. Para obtener más información sobre las sesiones de jugador, consulte Visualización de datos desesiones de juego y de jugador (p. 135).

Interacciones de Amazon GameLift y el cliente/servidor de juegos

En este tema se describen las interacciones entre una aplicación de cliente, un servidor de juegos y elservicio Amazon GameLift. Consulte también el diagrama siguiente: Amazon GameLift: interacciones delcliente/servidor de juegos (p. 43).

Configuración de un proceso del servidor nuevo1. El servicio Amazon GameLift lanza un proceso del servidor nuevo en una instancia Amazon Elastic

Compute Cloud (Amazon EC2).2. El proceso del servidor llama a estas acciones de la API de servidor como parte del proceso de

lanzamiento:• InitSDK() para inicializar el SDK del servidor.• ProcessReady() para comunicar que está lista para aceptar una sesión de juego y especificar el

puerto de conexión y la ubicación de los archivos de log de la sesión de juego.

A continuación, espera la devolución de la llamada del servicio Amazon GameLift.3. El servicio Amazon GameLift cambia el estado de la instancia EC2 a ACTIVE, con 0 sesiones de juego y

0 jugadores.4. El servicio Amazon GameLift empieza a llamar a la devolución de la llamada onHealthCheck de forma

regular mientras el proceso del servidor está activo. El proceso del servidor debe informar sobre elestado en el plazo de un minuto.

Creación de una sesión de juego1. La aplicación cliente llama a la acción de la API cliente CreateGameSession().2. El servicio Amazon GameLift busca un servidor activo con 0 sesiones de juego. Cuando lo encuentra,

hace lo siguiente:• Crea un nuevo objeto GameSession utilizando el valor del puerto notificado por el proceso del

servidor en ProcessReady()y establece su estado como ACTIVATING.• Responde a la solicitud de la aplicación cliente con el objeto GameSession.• Llama a la devolución de la llamada onStartGameSession en el proceso del servidor y pasa el

objeto GameSession.3. El proceso del servidor ejecuta la función de devolución de llamada onStartGameSession. Cuando

está listo para aceptar las conexiones de los jugadores, el proceso del servidor llama a la acción de laAPI de servidor ActivateGameSession() y espera las conexiones de los jugadores.

4. El servicio Amazon GameLift cambia el estado de GameSession a ACTIVE.

Adición de un jugador a una sesión de juego1. La aplicación cliente llama a la acción de la API cliente CreatePlayerSession() con un ID de sesión

de juego.

Version40


Amazon GameLift Developer GuideEliminación de un jugador de una sesión de juego

2. El servicio Amazon GameLift comprueba el estado de la sesión de juego (debe ser ACTIVE) y buscauna ranura de jugador abierta en la sesión de juego. Si hay una ranura disponible, hace lo siguiente:• Crea un objeto PlayerSession nuevo y define el estado en RESERVED.• Responde a la solicitud de la aplicación cliente con el objeto PlayerSession.

3. La aplicación cliente se conecta directamente con el proceso del servidor con el ID de sesión dejugador.

4. El proceso del servidor llama a la acción de la API de servidor AcceptPlayerSession() para validarel ID de sesión de jugador. Si se valida, el servicio Amazon GameLift pasa el objeto PlayerSession alproceso del servidor. A continuación, el proceso del servidor acepta o rechaza la conexión.

5. El servicio Amazon GameLift realiza una de las operaciones siguientes:• Si se acepta la conexión, establece el estado de PlayerSession en ACTIVE.• Si no se recibe respuesta en un plazo de 60 segundos a la llamada CreatePlayerSession()

original de la aplicación cliente, cambia el estado de PlayerSession a TIMEDOUT y vuelve a abrirla ranura de jugador en la sesión de juego.

Eliminación de un jugador de una sesión de juego1. La aplicación cliente se desconecta del proceso del servidor.2. El proceso del servidor detecta la pérdida de conexión y llama a la acción de la API de servidor

RemovePlayerSession().3. El servicio Amazon GameLift cambia el estado de PlayerSession a COMPLETED y vuelve a abrir la

ranura de jugador en la sesión de juego.

Cierre de una sesión de juegoCierre de una sesión de juego

1. El proceso del servidor llama a la acción de la API de servidor TerminateGameSession().2. El servicio Amazon GameLift realiza lo siguiente:

• Cambia el estado de GameSession a TERMINATED.• Carga los logs de sesión de juego en Amazon Simple Storage Service (Amazon S3).• Actualiza el uso de la flota para indicar que el servidor está inactivo (0 sesiones de juego, 0

jugadores).

Finalización de un proceso del servidor1. El proceso del servidor hace lo siguiente:

• Ejecuta código que cierra correctamente el proceso del servidor.• Llama a la acción de la API de servidor ProcessEnding() para informar al servicio Amazon

GameLift.2. El servicio Amazon GameLift realiza lo siguiente:

• Carga los logs de sesión de juego (si los hay) en Amazon S3.• Cambia el estado del proceso del servidor a TERMINATED.• Recicla los recursos de la instancia en función de la configuración de tiempo de ejecución de la flota.

Version41

Amazon GameLift Developer GuideRespuesta a una solicitud de cierre

Respuesta a una solicitud de cierre1. El servicio Amazon GameLift invoca la devolución de la llamada onProcessTerminate del proceso

del servidor. Esta llamada se utiliza para cerrar un proceso del servidor que ha notificado que está enmal estado o no ha respondido con ningún estado durante tres minutos consecutivos.

2. El proceso del servidor ejecuta la función de devolución de llamada onProcessTerminate, quedispara el proceso de terminación del servidor, que finaliza con una llamada a ProcessEnding().

3. El servicio Amazon GameLift realiza lo siguiente, ya sea en respuesta a la recepción de la llamadaProcessEnding() o después de cinco minutos:• Carga los logs de sesión de juego (si los hay) en Amazon S3.• Cambia el estado del proceso del servidor a TERMINATED.• Recicla los recursos de la instancia en función de la configuración de tiempo de ejecución de la flota.

Version42

Amazon GameLift Developer GuideGameLift: interacciones del cliente/servidor de juegos

Amazon GameLift: interacciones del cliente/servidorde juegos

Version43

Amazon GameLift Developer GuidePrueba de la integración

Prueba de la integraciónUtilice Amazon GameLift Local para ejecutar una versión limitada del servicio Amazon GameLift en undispositivo local y pruebe cómo se integra el juego. Esta herramienta es útil al realizar el desarrollo iterativoen la integración del juego. La alternativa, que es cargar cada nueva compilación en Amazon GameLift yconfigurar una flota para alojar el juego, puede tardar 30 minutos o más cada vez.

Con Amazon GameLift Local, puede verificar lo siguiente:

• Que el servidor de juegos se integra correctamente con el SDK del servidor y comunica de formaadecuada con el servicio Amazon GameLift para empezar nuevas sesiones de juego, aceptar jugadoresnuevos e informar sobre el estado.

• Que el cliente de juego está integrado correctamente con el SDK de AWS para Amazon GameLift yque puede recuperar información sobre sesiones de juego existentes, iniciar sesiones de juego nuevas,conectar jugadores a juegos y conectarse a la sesión de juego.

Amazon GameLift Local es una herramienta de línea de comando que inicia una versión autónoma delservicio Amazon GameLift. Amazon GameLift Local también proporciona un log de evento de ejecuciónde la inicialización del proceso del servidor, comprobaciones de estado y llamadas y respuestas de laAPI. Amazon GameLift Local reconoce un subconjunto de las acciones del SDK de AWS para AmazonGameLift. Puede realizar llamadas desde la AWS CLI o desde el cliente de juego. Todas las acciones de laAPI que se ejecutan localmente lo hacen de la misma forma que en el servicio web de Amazon GameLift.

Configuración de Amazon GameLift LocalAmazon GameLift Local se suministra como fichero .jar ejecutable que incluye el SDK del servidor. Sepuede ejecutar en Windows o Linux y utilizarse con cualquier lenguaje compatible con Amazon GameLift.

Antes de ejecutar Local, también debe tener instalado lo siguiente.

• Una compilación de la versión SDK de servidor de Amazon GameLift 3.1.5 o superior• Java 8

Prueba de un servidor de juegosSi solo desea probar el servidor de juegos, puede utilizar la AWS CLI para simular llamadas del cliente dejuego al servicio Amazon GameLift Local. De este modo se verifica que el servidor de juegos se comportasegún lo esperado:

• El servidor de juegos se inicia correctamente e inicializa el SDK del servidor de Amazon GameLift.• Como parte del proceso de lanzamiento, el servidor de juegos notifica a Amazon GameLift que el

servidor está listo para alojar sesiones de juego.• El servidor de juegos envía estados a Amazon GameLift cada minuto mientras se ejecuta.• El servidor de juegos responde a las solicitudes para iniciar una sesión de juego nueva.

1. Inicie Amazon GameLift Local.

Abra una ventana de símbolo del sistema, vaya al directorio que contiene el archivoGameLiftLocal.jar y ejecútelo. De forma predeterminada, Local atiende a las solicitudes declientes de juego en el puerto 8080. Para especificar un número de puerto diferente, utilice elparámetro -p, tal y como se muestra en el ejemplo siguiente:

Version44


Amazon GameLift Developer GuidePrueba de un servidor de juegos

java -jar GameLiftLocal-3.1.6.jar -p 9080

En cuanto Local arranque, verá los logs que indican que se iniciaron dos servidores locales, uno queatiende al servidor de juegos y otro al cliente de juego o a la AWS CLI. Los logs continúan informandosobre la actividad de los dos servidores locales, incluida la comunicación a y desde los componentesde juego.

2. Inicie el servidor de juegos.

Arranque el servidor de juegos integrado en Amazon GameLift localmente. No es necesario cambiar elpunto de enlace del servidor de juegos.

En la ventana de símbolo del sistema de Local, los mensajes de log indican que el servidor de juegosse ha conectado al servicio Amazon GameLift Local. Esto significa que el servidor de juegos hainicializado correctamente el SDK del servidor de Amazon GameLift (con InitSDK()). Ha llamado aProcessReady() con las rutas de log que se muestran y, en caso de éxito, está listo para alojar unasesión de juego. Mientras se ejecuta el servidor de juegos, Amazon GameLift registra cada informe deestado del servidor de juegos. El siguiente ejemplo de mensajes de log muestra un servidor de juegosintegrado correctamente:

16:50:53,217 INFO || - [SDKListenerImpl] nioEventLoopGroup-3-1 - SDK connected: /127.0.0.1:64247 16:50:53,217 INFO || - [SDKListenerImpl] nioEventLoopGroup-3-1 - SDK pid is 17040, sdkVersion is 3.1.5 and sdkLanguage is CSharp16:50:53,217 INFO || - [SDKListenerImpl] nioEventLoopGroup-3-1 - NOTE: Only SDK versions 3.1.5 and above are supported in GameLiftLocal!16:50:53,451 INFO || - [SDKListenerImpl] nioEventLoopGroup-3-1 - onProcessReady received from: /127.0.0.1:64247 and ackRequest requested? true16:50:53,543 INFO || - [SDKListenerImpl] nioEventLoopGroup-3-1 - onProcessReady data: logPathsToUpload: "C:\\game\\logs"logPathsToUpload: "C:\\game\\error"port: 1935 16:50:53,544 INFO || - [HostProcessManager] nioEventLoopGroup-3-1 - Registered new process true, true,16:50:53,558 INFO || - [SDKListenerImpl] nioEventLoopGroup-3-1 - onReportHealth received from /127.0.0.1:64247 with health status: healthy

A continuación se presentan posibles mensajes de error y advertencia:

• Error: "ProcessReady no encontró un proceso con pID: <ID de proceso>. ¿Se ha llamado aInitSDK()?"

• Advertencia: "El estado del proceso ya existe para el proceso con pID: <ID de proceso>. ¿Se hallamado a ProcessReady(...) más de una vez?"

3. Inicie la AWS CLI.

En cuanto el servidor de juegos llame a ProcessReady() correctamente, podrá comenzar a realizarllamadas de cliente. Abra una ventana de símbolo del sistema y empiece con la herramienta AWS CLI.Si no la ha configurado todavía, consulte Instalar la AWS CLI (p. 20). La AWS CLI predeterminadautiliza el punto de enlace de servicio web de Amazon GameLift. Debe anularlo con el punto de enlacede Local en cada solicitud que emplee el parámetro --endpoint-url, tal y como se muestra en elsiguiente ejemplo.

aws gamelift describe-game-sessions --endpoint-url http://localhost:9080 --fleet-id fleet-123

Version45

Amazon GameLift Developer GuidePrueba de un servidor y un cliente de juego

En la ventana de símbolo del sistema de AWS CLI, las llamadas a las API del SDK de AWS generanrespuestas similares a las documentadas aquí.

4. Cree una sesión de juego.

Con la AWS CLI, envíe una solicitud CreateGameSession(). La solicitud debería seguir la sintaxisesperada. Para Local, el parámetro FleetId puede adaptarse a cualquier cadena válida (^fleet-\S+).

aws gamelift create-game-session --endpoint-url http://localhost:9080 --maximum-player-session-count 2 --fleet-id fleet-1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d

En la ventana de símbolo del sistema de Local, los mensajes de log indican que Amazon GameLiftLocal ha enviado una devolución de la llamada onStartGameSession al servidor de juegos.Si se crea una sesión de juego correctamente, el servidor de juegos responderá llamado aActivateGameSession.

13:57:36,129 INFO || - [SDKInvokerImpl] Thread-2 - Finished sending event to game server to start a game session: arn:aws:gamelift:local::gamesession/fleet-1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d/gsess-ab423a4b-b827-4765-aea2-54b3fa0818b6. Waiting for ack response.13:57:36,143 INFO || - [SDKInvokerImpl] Thread-2 - Received ack response: true13:57:36,144 INFO || - [CreateGameSessionDispatcher] Thread-2 - GameSession with id: arn:aws:gamelift:local::gamesession/fleet-1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d/gsess-ab423a4b-b827-4765-aea2-54b3fa0818b6 created13:57:36,227 INFO || - [SDKListenerImpl] nioEventLoopGroup-3-1 - onGameSessionActivate received from: /127.0.0.1:60020 and ackRequest requested? true13:57:36,230 INFO || - [SDKListenerImpl] nioEventLoopGroup-3-1 - onGameSessionActivate data: gameSessionId: "arn:aws:gamelift:local::gamesession/fleet-1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d/gsess-abcdef12-3456-7890-abcd-ef1234567890"

En la ventana de la AWS CLI Amazon GameLift responde con un objeto de sesión de juego queincluye un ID de sesión de juego. Observe que el estado de la nueva sesión de juego es Activating. Elestado cambia a Active cuando el servidor de juegos invoca a ActivateGameSession. Si desea ver elestado modificado, utilice la AWS CLI para llamar a DescribeGameSessions().

{ "GameSession": { "Status": "ACTIVATING", "MaximumPlayerSessionCount": 2, "FleetId": "fleet-1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d", "GameSessionId": "arn:aws:gamelift:local::gamesession/fleet-1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d/gsess-abcdef12-3456-7890-abcd-ef1234567890", "IpAddress": "127.0.0.1", "Port": 1935 }}

Prueba de un servidor y un cliente de juegoPara comprobar la integración total del juego, incluidos los jugadores conectados a los juegos, puedeejecutar tanto el servidor como el cliente de juego localmente. De este modo podrá realizar llamadas

Version46


Amazon GameLift Developer GuidePrueba de un servidor y un cliente de juego

programáticas desde su cliente de juego a Amazon GameLift Local. Puede verificar las siguientesacciones:

• El cliente de juego está realizando correctamente solicitudes del SDK de AWS al servicio AmazonGameLift Local, incluida la creación de sesiones de juego, la recuperación de información sobresesiones de juego existentes y la creación de sesiones de jugador.

• El servidor de juegos está validando jugadores correctamente al intentar conectarse a una sesión dejuego. Para validar los jugadores, el servidor de juego puede recuperar datos de los jugadores (si estánimplementados).

• El servidor de juegos informa sobre la pérdida de la conexión cuando un jugador abandona el juego.• El servidor de juegos informa sobre la finalización de una sesión de juego.

1. Inicie Amazon GameLift Local.

Abra una ventana de símbolo del sistema, vaya al directorio que contiene el archivoGameLiftLocal.jar y ejecútelo. De forma predeterminada, Local atiende a las solicitudes declientes de juego en el puerto 8080. Para especificar un número de puerto diferente, utilice elparámetro -p, tal y como se muestra en el ejemplo siguiente.

./gamelift-local -p 9080

En cuanto Local arranque, verá los logs que indican que se iniciaron dos servidores locales, uno queatiende al servidor de juegos y otro al cliente de juego o a la AWS CLI.

2. Inicie el servidor de juegos.

Arranque el servidor de juegos integrado en Amazon GameLift localmente. Consulte Prueba de unservidor de juegos (p. 44) para obtener más información acerca de los logs de mensajes.

3. Configure su cliente de juego para Local e inícielo.

Para utilizar el cliente de juego con el servicio Amazon GameLift Local, debe realizar los siguientescambios en la configuración del cliente de juego, tal y como se describe en Configuración de AmazonGameLift en un cliente o servicio (p. 36):

• Modifique el objeto ClientConfiguration para que apunte hacia el punto de enlace de Local,por ejemplo http://localhost:9080.

• Defina un valor de ID de la flota de destino. Para Local, no se requiere un ID de flotareal; defina la flota de destino con cualquier cadena válida (^fleet-\S+), comofleet-1a2b3c4d-5e6f-7a8b-9c0d-1e2f3a4b5c6d.

• Defina las credenciales de AWS. Para Local, no requiere credenciales de AWS reales, de modo quepuede definir la clave de acceso y la clave secreta para cualquier cadena.

En la ventana de símbolo del sistema de Local, después de iniciar el cliente de juego, los mensajes delog deberían indicar que se ha inicializado GameLiftClient y que comunica correctamente con elservicio Amazon GameLift.

4. Pruebe las llamadas del cliente de juego al servicio Amazon GameLift.

Compruebe que el cliente de juego realiza correctamente alguna o todas las llamadas a la APIsiguientes:

• CreateGameSession()• DescribeGameSessions()• CreatePlayerSession()• CreatePlayerSessions()

Version47


https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeGameSessions.html


https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreatePlayerSessions.html

Amazon GameLift Developer GuideVariaciones de Local

• DescribePlayerSessions()

En la ventana de símbolo del sistema de Local, solo las llamadas a CreateGameSession()resultan en mensajes de log. Los mensajes de log muestran el momento en que Amazon GameLiftLocal solicita al servidor de juegos que inicie una sesión de juego (devolución de llamadaonStartGameSession) y obtiene un ActivateGameSession correcto cuando el servidor de juegoslo llama. En la ventana de la AWS CLI, todas las llamadas a la API generan respuestas o mensajes deerror tal y como se documenta.

5. Compruebe que el servidor de juegos valida las conexiones de jugadores nuevas.

Después de crear una sesión de juego y una sesión de jugador, establezca una conexión directa conla sesión de juego.

En la ventana de símbolo del sistema de Local, los mensajes de log deberían mostrar que el servidorde juegos ha enviado una solicitud AcceptPlayerSession() para validar la conexión de jugadoresnueva. Si utiliza la AWS CLI para llamar a DescribePlayerSessions(), el estado de la sesión dejugador debería cambiar de Reserved a Active.

6. Compruebe que el servidor de juegos informa sobre el estado del juego y del jugador al servicioAmazon GameLift.

Para que Amazon GameLift administre la demanda de los jugadores y notifique correctamente lasmétricas, el servidor de juegos debe informar sobre varios estados a Amazon GameLift. Compruebeque Local registra los eventos relacionados con las acciones siguientes. Es posible que tambiéndesee utilizar la AWS CLI para realizar un seguimiento de los cambios de estado.

• El jugador se desconecta de una sesión de juego: los mensajes de log de Amazon GameLift Localdeberían mostrar que el servidor de juegos llama a RemovePlayerSession(). Una llamada deAWS CLI a DescribePlayerSessions() debería mostrar un cambio de estado de Activea Completed. También puede llamar a DescribeGameSessions() para comprobar que elrecuento de jugadores actual de la sesión de juego resulta en un jugador menos.

• La sesión de juego finaliza: los mensajes de log de Amazon GameLift Local deberían mostrarque el servidor de juegos llama a TerminateGameSession(). Una llamada de AWS CLI aDescribeGameSessions() debería mostrar un cambio de estado de Active a Terminated (oTerminating).

• El proceso de servidor ha finalizado: los mensajes de log de Amazon GameLift Local deberíanmostrar que el servidor de juegos llama a ProcessEnding().

Variaciones de LocalAl utilizar Amazon GameLift Local, tenga en cuenta lo siguiente:

• A diferencia del servicio web de Amazon GameLift, Local no realiza el seguimiento del estado delservidor ni inicia la devolución de la llamada onProcessTerminate. Local simplemente deja deregistrar los informes de estado del servidor de juegos.

• Para realizar llamadas al SDK de AWS, los ID de la flota no están validados y puede tratarse decualquier valor de cadena que cumpla los requisitos de parámetro (^fleet-\S+).

• Los ID de sesión de juego creados con Local tienen una estructura diferente. Incluyen la cadena local,tal y como se muestra aquí:

arn:aws:gamelift:local::gamesession/fleet-123/gsess-56961f8e-db9c-4173-97e7-270b82f0daa6

Version48


Amazon GameLift Developer GuideEmpaquetado de los archivos de compilación

Carga del juego en Amazon GameLiftAntes de configurar los recursos informáticos para alojar el juego multijugador habilitado para AmazonGameLift, primero debe crear una compilación del juego y cargarla en el servicio Amazon GameLift. Unacompilación del juego incluye todos los ejecutables del servidor y los archivos dependientes necesariospara ejecutar procesos del servidor y alojar sesiones de juego. En cuanto haya cargado una compilaciónen Amazon GameLift, puede crear una flota de recursos informáticos para jugar.

Los temas de esta sección describen cómo empaquetar la compilación del juego y cómo utilizar laherramienta de la CLI de AWS para cargarla en Amazon GameLift.

Sugerencia

No necesita tener un juego preparado para empezar a experimentar con Amazon GameLift.Para obtener más información sobre las herramientas disponibles, explore rápidamente lascaracterísticas de Amazon GameLift en este artículo informativo sobre Amazon GameLift (p. 21).

Temas• Empaquetado de los archivos de compilación (p. 49)• Carga de archivos de compilación en Amazon GameLift (p. 50)

Empaquetado de los archivos de compilaciónAntes de cargar (p. 50)el servidor de juegos habilitado para Amazon GameLift en el servicio AmazonGameLift para alojarlo, es necesario empaquetar todos los archivos del servidor de juegos en un directoriode compilación. Este directorio debe incluir todos los componentes necesarios para ejecutar los servidoresde juegos, entre los que se incluyen los siguientes:

• Archivos binarios del servidor de juegos: son los archivos binarios necesarios para ejecutar elservidor de juegos. Una compilación puede incluir archivos binarios para varios servidores de juegos,siempre y cuando se compilen para ejecutarlos en la misma plataforma (consulte las plataformascompatibles (p. 15)).

• Dependencias: cualquier archivo dependiente necesario para que los ejecutables del servidor de juegosfuncione. Por ejemplo, activos, archivos de configuración y bibliotecas dependientes.

• Script de instalación: archivo de script para realizar las tareas necesarias para instalar por completola compilación del juego en los servidores de alojamiento de Amazon GameLift. Este archivo debecolocarse en la raíz del directorio de compilación. Un script de instalación se ejecuta una vez como partede la creación de la flota.

Después de empaquetar los archivos de compilación, asegúrese de que el servidor de juegos puedaejecutarse en una instalación limpia del sistema operativo de destino (distinta de la que se ha utilizado parael desarrollo). Este paso le ayuda a asegurarse de que se incluyen todas las dependencias necesarias enel paquete y de que el script de instalación es correcto.

Para observar el proceso de empaquetado de la compilación en acción, consulte los Amazon GameDevtutorials para Amazon GameLift.

Note

Si almacena los archivos de compilación de juegos en un bucket de Amazon S3 para cargarlos,coloque todos los archivos de compilación en un archivo .zip.

Creación de un script de instalaciónCree un script de instalación para el sistema operativo de la compilación del juego:

Version49

https://gamedev.amazon.com/forums/tutorials


Amazon GameLift Developer GuideCarga de archivos de compilación

• Windows: cree un archivo de procesamiento por lotes denominado "install.bat".• Linux: cree un archivo de script de shell denominado "install.sh".

Al crear un script de instalación, tenga en cuenta lo siguiente:

• El script no puede aceptar ninguna entrada por parte del usuario.• Una compilación se instala en un servidor de alojamiento en las siguientes ubicaciones. Los directorios

de los archivos del paquete de compilación se vuelven a crear.• Para las flotas de Windows: C:\game• Para las flotas de Linux: /local/game

• Durante el proceso de instalación, el usuario que realiza la ejecución tiene acceso limitado. Tiene accesocompleto al directorio en que se instalan los archivos de compilación. Si el script de instalación realizaacciones que requieren permisos de administrador, será necesario que especificar acceso administrativo(sudo para Linux o runas para Windows). Los errores de permisos relacionados con el script deinstalación generan un mensaje de evento que indica un problema con el script.

• En Linux, se admiten lenguajes comunes de intérprete de shell, como bash. Añada un shebang (como#!/bin/bash) al principio del script de instalación. Si necesita verificar la compatibilidad con loscomandos de shell que prefiera, puede iniciar una sesión remota en una instancia de Linux activa y abrirun símbolo del shell. Encontrará más información en Acceso remoto a instancias de una flota (p. 79).

Scripts de ejemplo

Estos ejemplos ilustran el uso común de los scripts para Windows y Linux.

Windows

En este ejemplo, el archivo install.bat instala los componentes del tiempo de ejecución de Visual C++ necesarios para el servidor de juegos y escribe los resultados en un archivo de log. El archivo decomponente se incluye en la raíz del paquete de compilación.

vcredist_x64.exe /install /quiet /norestart /log c:\game\vcredist_2013_x64.log

Linux

El archivo install.sh de este ejemplo muestra el uso de bash en el script de instalación y escribe losresultados en un archivo de log.

#!/bin/bashecho 'Hello World' > install.log

Carga de archivos de compilación en AmazonGameLift

En cuanto los archivos del servidor de juegos estén empaquetados (p. 49), deberá enviarlos a AmazonGameLift para su alojamiento. Esto se realiza mediante la creación de una compilación de AmazonGameLift. Dispone de dos opciones para crear una compilación:

• Crear una compilación con los archivos de compilación del juego que están almacenados en undirectorio. Este es el método más sencillo.

• Crear una compilación con los archivos de compilación del juego que están almacenados en una cuentade Amazon S3.

Version50

Amazon GameLift Developer GuideCreación de una compilación con archivos en un directorio

Al crear una compilación, se genera un registro de compilación de juego nuevo. Este registro contiene unID de compilación exclusivo (por ejemplo: build-75bf99cd-2dd8-2039-8074-ab24da1f80e4), lamarca temporal de creación, el tamaño del archivo cargado, el estado y otros metadatos. La compilaciónpasa inmediatamente al estado Initialized y permanece en él hasta que Amazon GameLift adquiere losarchivos de la compilación. En cuanto los archivos del servidor de juegos se adquieran correctamente, lacompilación pasará al estado Ready.

En cuanto la compilación tenga el estado Ready, podrá implementarla con una flota de Amazon GameLiftnueva. Al crear una flota para la compilación, Amazon GameLift configura instancias de flota nuevas einstala la compilación del servidor de juegos en cada instancia. Los archivos de compilación se instalan enlas ubicaciones siguientes:

• Para las flotas de Windows: C:\game• Para las flotas de Linux: /local/game

Para solucionar problemas de activación de flotas que podrían estar relacionados con la instalación de lacompilación, puede acceder de forma remota a una instancia de flota para la depuración. Consulte Accesoremoto a instancias de una flota (p. 79).

Creación de una compilación con archivos en undirectorioPara crear una compilación de juego con archivos de servidor de juegos empaquetados y almacenadosen cualquier ubicación, incluido un directorio local, utilice el comando upload-build de AWS Command LineInterface (AWS CLI). Este comando crea un registro de compilación nuevo en Amazon GameLift y cargaarchivos desde la ubicación que especifique.

1. Envíe una solicitud de carga. En una ventana de línea de comando, escriba el comando y losparámetros siguientes.

aws gamelift upload-build --operating-system [supported OS] --build-root [build path] --name [user-defined name of build] --build-version [user-defined build number] --region [region name]

--build-root

Es la ruta del directorio de los archivos de compilación.--operating-system

Es el sistema operativo en el que se ejecutan todos los ejecutables del servidor en la compilación.Todas las flotas creadas con esta compilación utilizan automáticamente este sistema operativo.Los valores válidos son WINDOWS_2012 y AMAZON_LINUX. Este parámetro es opcional. Sino se especifica ningún sistema operativo, Amazon GameLift utiliza el valor predeterminado(WINDOWS_2012). Este valor no se puede cambiar más adelante.

--region

Es el nombre de la región en la que desea crear la compilación. Debe crear la compilación en laregión donde desea implementar las flotas. Para implementar en varias regiones, debe crear unacompilación y archivos de carga para cada región. Si ha configurado la AWS CLI con una regiónpredeterminada, puede omitir este parámetro.

Note

Si trabaja en varias regiones, se recomienda comprobar la región predeterminadaactual. Utilice el comando de la CLI de AWS configure get (aws configure get

Version51

https://docs.aws.amazon.com/cli/latest/reference/gamelift/upload-build.html

https://docs.aws.amazon.com/cli/latest/reference/configure/get.html

Amazon GameLift Developer GuideCreación de una compilación con archivos en Amazon S3

region) para ver la región predeterminada actual. Utilice el comando configure set (awsconfigure set region [region name]) para definir una región predeterminada.

--name y --build-version

Utilice estos parámetros para describir la compilación. Estos valores de metadatos puedencambiarse más adelante con update-build (o la operación UpdateBuild de AWS SDK).

En respuesta a la solicitud de carga, el servicio Amazon GameLift informa sobre el progreso de lacarga y, si la carga se realiza correctamente, devuelve el nuevo ID de registro de la compilación. Eltiempo de carga depende del tamaño de los archivos del juego y de la velocidad de conexión.

Ejemplos:

aws gamelift upload-build --operating-system AMAZON_LINUX --build-root ~/mygame --name "My Game Nightly Build" --build-version "build 255" --region us-west-2

aws gamelift upload-build --operating-system WINDOWS_2012 --build-root "C:\mygame" --name "My Game Nightly Build" --build-version "build 255" --region us-west-2

2. Compruebe el estado de la compilación. Consulte el nuevo registro de compilación, incluido el estadoactual, utilizando describe-build (o DescribeBuild). También puede ver el estado en la consola deAmazon GameLift.

En una ventana de línea de comando, escriba el comando y los parámetros siguientes.

aws gamelift describe-build --build-id [build ID returned with the upload request] --region [region name]

Ejemplo:

aws gamelift describe-build --build-id "build-75bf99cd-2dd8-2039-8074-ab24da1f80e4" --region us-west-2

En respuesta a la solicitud, el servicio Amazon GameLift devuelve el registro de compilación solicitado.Este registro contiene un conjunto de metadatos de compilación entre los que se incluyen el estado, eltamaño de los archivos cargados y una marca temporal de creación.

Creación de una compilación con archivos en AmazonS3Para crear una compilación de juego con archivos del servidor de juegos empaquetados y almacenadosen un bucket de Amazon S3 en su cuenta de AWS, utilice el comando de la AWS CLI create-build. Estaoperación crea una compilación nueva en Amazon GameLift y adquiere los archivos de compilación delbucket de Amazon S3 que especifique.

1. Almacene los archivos de compilación en Amazon S3. Cree un archivo .zip que contenga losarchivos de compilación empaquetados y cárguelo en un bucket de Amazon S3 en su cuenta deAWS. Tome nota de la etiqueta del bucket y el nombre de archivo pues los necesitará para crear unacompilación de Amazon GameLift.

2. Otorgue acceso a Amazon GameLift a los archivos de compilación. Con el servicio AWS Identityand Access Management (IAM), configure un rol nuevo que permita a Amazon GameLift acceder alos archivos de compilación. Este paso requiere las siguientes tareas: (1) crear el rol y asignarle unnombre, (2) adjuntar una política de relación de confianza que permita a Amazon GameLift asumir el

Version52

https://docs.aws.amazon.com/cli/latest/reference/configure/set.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/update-build.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_UpdateBuild.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-build.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeBuild.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/create-build.html

Amazon GameLift Developer GuideCreación de una compilación con archivos en Amazon S3

rol y (3) adjuntar una política de acceso que limite el acceso del rol. Puede limitar el acceso cuantonecesite, incluso a un archivo específico en un bucket. En cuanto haya creado el rol, tome nota delnombre de recurso de Amazon (ARN) del nuevo rol, ya que lo necesitará para crear una compilación.

Note

Puede utilizar la consola de IAM o la herramienta de AWS CLI para configurar el rol. Siutiliza el asistente de la consola Create Role, el método más fácil consiste en crear un rolde servicio de AWS sencillo (seleccione cualquier servicio y no adjunte ninguna política).A continuación, añada la relación de confianza y la política de acceso (que se muestrana continuación) al rol que acaba de crear. Consulte el tema de la guía del usuario de IAMCreating a Role para obtener ayuda con la consola de IAM o la herramienta AWS CLI.

Adjunte las políticas siguientes al rol:

• Relación de confianza limitada a Amazon GameLift:

{ "Version": "2012-10-17", "Statement": [ { "Effect": "Allow", "Principal": { "Service": "gamelift.amazonaws.com" }, "Action": "sts:AssumeRole" } ]}

• Política en línea que restringe el acceso a los derechos de solo lectura de un bucket de S3específico:

{ "Version": "2012-10-17", "Statement": [ { "Action": [ "s3:GetObject", "s3:GetObjectVersion", "s3:GetObjectMetadata" ], "Resource": "arn:aws:s3:::[BucketName]/*", "Effect": "Allow" } ]}

3. Envíe una solicitud para crear una compilación nueva. Utilice el comando de la AWS CLI create-build (o la operación CreateBuild de AWS SDK) para crear un registro de compilación nuevo eindicarle a Amazon GameLift dónde se almacenan los archivos de compilación. En esta solicitud,debe especificar una ubicación de Amazon S3, incluida la siguiente información (que ha recopilado alconfigurar el bucket y el rol de acceso):

• Bucket: nombre del bucket que contiene la compilación. Por ejemplo, "my_build_files".

Version53

https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create_for-user.html



https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreateBuild.html

Amazon GameLift Developer GuideActualización de los archivos de compilación

• Clave: nombre del archivo .zip que contiene los archivos de compilación. Por ejemplo,"mygame_build_7.0.1, 7.0.2".

• ARN del rol: es el ARN asignado al rol de acceso que ha creado. Por ejemplo,

"arn:aws:iam::111122223333:role/GameLiftAccess".

En una ventana de línea de comando, escriba el comando y los parámetros siguientes.

aws gamelift create-build --operating-system [supported OS] --storage-location "Bucket=[S3 bucket label],Key=[Build zip file name],RoleArn=[Access role ARN]" --name [user-defined name of build] --build-version [user-defined build number] --region [region name]

Ejemplo:

aws gamelift create-build --operating-system WINDOWS_2012 --storage-location "Bucket=gamelift-builds,Key=MyGame.zip,RoleArn=arn:aws:iam::401680102694:role/gamelift" --name "My Game Nightly Build" --build-version "build 255" --region us-west-2

En respuesta a la solicitud, el servicio Amazon GameLift devuelve el registro de compilación queacaba de crear.

Actualización de los archivos de compilaciónUna vez creada una compilación de Amazon GameLift, los archivos de compilación asociados ya no sepueden modificar. En lugar de ello, debe crear una compilación de Amazon GameLift nueva para cadaconjunto de archivos nuevo. Si proporciona archivos de compilación utilizando el comando upload-build, no es necesario realizar ninguna acción especial porque Amazon GameLift crea automáticamenteun registro de compilación nuevo para cada solicitud. Si proporciona archivos de compilación utilizandoel comando create-build, cargue un nuevo archivo .zip de compilación con un nombre distinto enAmazon S3 y cree una compilación que haga referencia al nombre de archivo nuevo.

Tenga en cuenta estos consejos a la hora de implementar compilaciones actualizadas:

• Utilice alias para transferir jugadores de forma sencilla a una compilación del juego nueva. Al integrarel cliente de juego con Amazon GameLift, especifique un alias de flota en lugar de un ID de flota. Deesta forma, podrá trasladar los jugadores a una compilación nueva en tan solo tres pasos: (1) Crear lacompilación nueva. (2) Crear una flota para implementar la compilación nueva. (3) Cambiar el destino delalias de la flota antigua a la flota nueva. Para obtener más información, consulte Uso de alias (p. 85).

• Configure actualizaciones de compilación automatizadas. Siga las publicaciones del blog deGameDev Automating Deployments to Amazon GameLift, con scripts de ejemplo, para incorporar lasimplementaciones de Amazon GameLift en el sistema de compilación.

Version54

https://aws.amazon.com/blogs/gamedev/automating-deployments-to-amazon-gamelift/

Amazon GameLift Developer GuideConfiguración de flotas

Uso de flotasLos temas de esta sección proporcionan ayuda en detalle para la configuración y la administración de susflotas de servidor del juego.

Las flotas son, sencillamente, los recursos de alojamiento en forma de instancias EC2. Para alojar unservidor de juegos en Amazon GameLift, tendrá que implementar una flota con su versión del servidor deljuego. El tamaño de una flota depende del número de instancias que le asigne y puede ajustar el tamañode la flota para satisfacer la demanda de los jugadores, ya sea manualmente o por escalado automático.

La mayoría de juegos en producción requieren varias flotas. Cada flota implementa una versión de servidorde juegos en una única región de AWS. Por lo tanto, si desea alojar a jugadores en más de una región, o sitiene dos o más versiones del servidor de juegos (como, por ejemplo, versiones gratuita y prémium), tendráque tener varias flotas.

En esta sección, encontrará ayuda detallada para crear y administrar flotas de alojamiento. Comience conElección de los recursos informáticos (p. 56) para obtener información sobre los distintos tipos de flotasque puede crear.

Sugerencia

No necesita tener un juego preparado para empezar a experimentar con Amazon GameLift.Para obtener más información sobre las herramientas disponibles, explore rápidamente lascaracterísticas de Amazon GameLift en este artículo informativo sobre Amazon GameLift (p. 21).

Temas• Configuración de flotas (p. 55)• Administración de la capacidad de la flota (p. 67)• Guía de integración de flotas de spot (p. 77)• Acceso remoto a instancias de una flota (p. 79)• Configuración de la interconexión de VPC (p. 81)

Configuración de flotasLos temas de esta sección proporcionan ayuda para diseñar y crear una flota de recursos informáticosque se adapta bien al juego. Obtenga ayuda para seleccionar los recursos de alojamiento adecuados,planear el modo en que quiere usar estos recursos (creando una configuración para el entorno en tiempode ejecución), solicitando nuevas flotas y actualizaciones de flotas, y administrando los problemas con lacreación de flotas.

Una vez que una flota está en marcha y en ejecución, puede agregarla a una cola de sesiones dejuego (p. 87), crear un alias de flota (p. 85) y administrar la capacidad de la flota (p. 67).

Temas• Elección de los recursos informáticos (p. 56)• Ejecución de varios procesos en una flota (p. 57)• Creación de una flota (p. 60)• Problemas al crear una flota de depuración (p. 65)• Administración de los registros de la flota (p. 66)

Version55

Amazon GameLift Developer GuideElección de los recursos informáticos

Elección de los recursos informáticosAmazon GameLift utiliza recursos de Amazon Elastic Compute Cloud (Amazon EC2), denominadosinstancias, para implementar los servidores de juegos y alojar las sesiones de juego para los jugadores.Al configurar una nueva flota, decide qué tipo de instancias necesita el juego y cómo ejecutar los procesosdel servidor de juegos en las mismas (a través de la configuración de tiempo de ejecución). Una vez queuna flota está activa y lista para alojar sesiones de juego, puede añadir o eliminar instancias en cualquiermomento para dar cabida a más o menos jugadores. Todas las instancias de una flota utilizan el mismotipo de recursos y la misma configuración de tiempo de ejecución. Puede editar la configuración de tiempode ejecución de una flota, pero el tipo de recursos no puede modificarse.

Al elegir los recursos para una flota, tendrá que tener en cuenta varios factores, incluido el sistemaoperativo del juego, el tipo de instancia (el hardware informático) y si desea utilizar instancias bajodemanda o de spot. Cada una de estas cuestiones se trata más adelante en este tema. Tenga en cuentaque los costos de alojamiento con Amazon GameLift dependerán principalmente del tipo de recursos queutilice. Más información sobre los precios de Amazon GameLift.

Sistemas operativosAmazon GameLift admite las versiones de servidor de juegos que funcionan con Microsoft Windows oAmazon Linux (consulte sistemas operativos de servidor de juegos compatibles (p. 15)). Al cargar unaversión de juego en Amazon GameLift, debe especificar el sistema operativo para el juego. Al crear unaflota para implementar la versión del juego Amazon GameLift configura automáticamente instancias con elsistema operativo de la versión.

El costo de los recursos depende del sistema operativo en uso. Obtenga más información sobre losrecursos disponibles para los sistemas operativos admitidos:

• Microsoft Windows• Amazon Linux

Tipos de instanciaEl tipo de instancia de una flota determina la clase de hardware que se utilizará para cada instanciade la flota. Los tipos de instancia ofrecen distintas combinaciones de potencia informática, memoria,almacenamiento y funciones de red. Con Amazon GameLift dispone de una amplia gama de opcionesde tipos de instancia para elegir. Consulte una lista de tipos de instancia disponibles o abra la páginaService limits (Límites de servicio) en la consola de Amazon GameLift para ver tipos de instancia, usoactual y límites de uso. Para obtener más información acerca de las capacidades de cada tipo de instancia,consulte Tipos de instancia de Amazon EC2. Tenga en cuenta que los tipos de instancia ofrecidos podríanvariar en función de la región.

Cuando elija un tipo de instancia para el juego, tenga en cuenta lo siguiente: (1) las necesidades decomputación de la versión de su servidor de juegos y (2) el número de procesos del servidor que prevéejecutar en cada instancia. Es posible que pueda ejecutar varios procesos de servidor en cada instanciautilizando un tipo de instancia mayor, que puede reducir la cantidad de instancias necesarias parasatisfacer la demanda de los jugadores. Sin embargo, los tipos de instancias más grandes también cuestanmás. Más información acerca de ejecución de varios procesos en una flota (p. 57).

Instancias bajo demanda frente a instancias de spotAl crear una nueva flota, designa el tipo de flota bien como instancias on-demand (bajo demanda) o spot(de spot). Las instancias bajo demanda y de spot ofrecen exactamente el mismo hardware y desempeño,en función del tipo de instancia elegido y se configuran exactamente del mismo modo. Difieren en elsuministro disponible y en el costo.

Version56

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/instance-types.html

https://aws.amazon.com//gamelift/pricing

https://docs.aws.amazon.com/AWSEC2/latest/WindowsGuide/instance-types.html


https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-ec2-instance-limits.html


https://aws.amazon.com/ec2/instance-types/

Amazon GameLift Developer GuideEjecución de varios procesos

Instancias a petición

Las instancias bajo demanda son simplemente que: solicita una instancia y se le crea. Siempre puedeadquirir una instancia bajo demanda cuando la necesite y mantenerla todo el tiempo que desee. Lasinstancias bajo demanda tiene un costo fijo, se paga la cantidad de tiempo que las utiliza y no haycompromisos a largo plazo.

Instancias de spot

Las instancias de spot ofrecen una alternativa muy rentable a las instancias bajo demanda. Las instanciasde spot utilizan la capacidad de cálculo de AWS, de modo que las instancias de spot pueden costar muchomenos que las instancias bajo demanda. Hay un inconveniente a la hora de usar las instancias de spot: adiferencia de instancias bajo demanda, los precios de spot variarán en función de la oferta y la demandaactual para cada tipo de instancia en cada región. Por tanto, AWS podría interrumpir las instancias de spotcon una notificación de dos minutos cuando AWS necesita la capacidad de vuelta.

Con la característica FleetIQ de Amazon GameLift, sin embargo, puede ahorrar costos a la vez quemantiene una alta disponibilidad en el servidor de juegos. Cuando se ubican nuevas sesiones de juego,FleetIQ da prioridad al uso de instancias de spot para localizar el mejor servidor de juegos disponible enfunción de (1) las instancias que proporcionan el mayor ahorro de costos y (2) las instancias con tasas deinterrupción históricamente bajas.

Puede evaluar el desempeño de FleetIQ a través de un conjunto de métricas de la cola, así comode las métricas específicas de las instancias de spot. Más información sobre métricas de AmazonGameLift (p. 138). También puede ver el historial de precios de cualquier tipo de instancia mediante laconsola de Amazon GameLift. La página Spot history (Historial de spot) realiza un gráfico de precios bajodemanda y de spot y calcula el ahorro de costos relativo con spot. Utilice los controles para seleccionar untipo de instancia, sistema operativo y un intervalo de tiempo.

Para obtener más información sobre cómo utilizar las instancias de spot, consulte Guía de integración deflotas de spot (p. 77).

Límites de servicio de instanciasAWS establece límites sobre cuántas instancias Amazon EC2 (bajo demanda o spot) puede utilizar unacuenta de AWS. Cada tipo de instancia tiene un número máximo permitido por cuenta y este límite varíaen función de la región de AWS. Cada cuenta también se limita por número total de instancias utilizadasindependientemente del tipo de instancia. Puede acceder a información sobre límites de varias maneras:

• Encontrará información sobre límites generales para Amazon GameLift, así como del resto de serviciosde AWS en la página Límites de los servicios de AWS.

• Consulte los límites de una región específica en la consola de Amazon GameLift: seleccione una regióny elija Service limits en el menú de Amazon GameLift. También puede ver el número total de instanciasque se utiliza actualmente en la región.

• Recupere el número máximo de instancias por cuenta de AWS (por región) utilizando la acción de la APIde Amazon GameLift DescribeEC2InstanceLimits. Esta acción también devuelve el número de instanciasactivas actualmente en la región.

Si necesita más instancias de las permitidas por los límites del servicio de AWS, puede solicitar unaumento de los límites en la página Service limits de Amazon GameLift de la Consola de administración deAWS.

Ejecución de varios procesos en una flotaEste tema contiene información adicional acerca de cómo establecer la configuración el entorno en tiempode ejecución de una flota para ejecutar varios procesos en cada instancia. En función de cómo configurela flota, ejecutar varios procesos puede darle mayor control sobre el uso de los recursos de AmazonGameLift, lo que podría mejorar la eficacia y, posiblemente, reducir los costos de alojamiento totales.

Version57


https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_gamelift


https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeEC2InstanceLimits.html



Optimización para varios procesosComo mínimo, debe hacer lo siguiente para activar varios procesos:

• Crear una compilación (p. 49) que contenga todos los ejecutables del servidor de juego ejecutables quedesea implementar en una flota y cargarla en Amazon GameLift. Todos los servidores de juegos de unacompilación deben ejecutarse en la misma plataforma e integrarse con Amazon GameLift utilizando elSDK de servidor de Amazon GameLift para C++, versión 3.0.7 o posterior.

• Cree una configuración de tiempo de ejecución con una o varias configuraciones del proceso delservidor y múltiples procesos simultáneos.

• Los clientes de juego que se conectan a juegos alojados en esta flota deben integrarse utilizando elAWS SDK, versión 2016-08-04 o posterior.

Además, implemente lo siguiente en los servidores de juegos para optimizar el desempeño de la flota:

• Gestione los escenarios de cierre de procesos del servidor para garantizar que Amazon GameLift puedareciclar procesos de forma eficaz. Si no lo hace, los procesos del servidor no se podrán cerrar hasta quese produzca un error.• Añada un procedimiento de cierre al código del servidor de juegos que finalice con la llamada de la

API de servidor a ProcessEnding().• Implemente la función de devolución de llamada OnProcessTerminate() en su código de servidor

de juegos para gestionar correctamente las solicitudes de terminación de Amazon GameLift.• Asegúrese de que los procesos del servidor "en mal estado" se cierren y se vuelvan a lanzar de nuevo

rápidamente mediante la definición de los términos "en buen estado" y "en mal estado" e informandosobre dicho estado a Amazon GameLift. Para ello, implemente la función de devolución de llamadaOnHealthCheck() en el código del servidor de juegos. Amazon GameLift cierra automáticamentelos procesos del servidor en mal estado durante tres minutos consecutivos. Si no implementaOnHealthCheck(), Amazon GameLift supone que un proceso del servidor está en buen estado, amenos que no responda. Como resultado, los procesos del servidor que no funcionen muy bien puedenseguir existiendo utilizando los recursos hasta que finalmente fallen.

Modo en que una flota administra varios procesosAmazon GameLift utiliza una configuración de tiempo de ejecución de una flota para administrar losprocesos que quiere mantener en cada instancia de la flota. Una configuración de tiempo de ejecución secompone de una o varias configuraciones de procesos del servidor, cada una de las cuales identifica losiguiente:

• La ruta y el nombre de archivo de un ejecutable del servidor en la compilación del juego implementadaen la flota

• (Opcional) Los parámetros a pasar al proceso del servidor durante el lanzamiento• El número de este proceso del servidor a gestionar de forma simultánea en la instancia

Cuando se inicia una instancia en la flota, esta comienza inmediatamente a lanzar procesos del servidorllamados en la configuración de tiempo de ejecución. Los procesos del servidor en una instancia se lanzande forma escalonada con segundos de diferencia, de modo que en función del número total de procesosdel servidor configurados para una instancia, puede tardar unos minutos en alcanzar su capacidad total.

Con el paso del tiempo, los procesos de servidor finalizan, ya sea automáticamente (llamando al SDK delservidor ProcessEnding()) o los finaliza Amazon GameLift. Una instancia comprueba con regularidadque se está ejecutando el número y el tipo de procesos del servidor especificados en la configuración detiempo de ejecución. Si no es el caso, la instancia lanza procesos del servidor automáticamente segúnsea necesario para satisfacer los requisitos de configuración de tiempo de ejecución. Como resultado, a

Version58


medida que los procesos del servidor finalizan, sus recursos se reciclan continuamente para respaldarnuevos procesos del servidor, y, por lo general, las instancias gestionan el complemento esperado deprocesos del servidor activos.

Puede cambiar la configuración de tiempo de ejecución de una flota en cualquier momento mediante laadición, modificación o eliminación de las configuraciones de procesos del servidor. A continuación lemostramos cómo Amazon GameLift realiza cambios en la configuración de tiempo de ejecución.

1. Antes de que una instancia compruebe que se está ejecutando el tipo y el número de procesos delservidor correctos, primero solicita la última versión de la configuración de tiempo de ejecución de laflota al servicio Amazon GameLift. Si ha cambiado la configuración del tiempo de ejecución, la instanciaadquiere la nueva versión y la implementa.

2. La instancia comprueba sus procesos activos según la configuración de tiempo de ejecución actual ygestiona las discrepancias de la siguiente manera:• La configuración del tiempo de ejecución actualizada elimina un tipo de proceso del servidor. Los

procesos del servidor activos que ya no coinciden con la configuración del tiempo de ejecución siguenejecutándose hasta que finalizan.

• La configuración del tiempo de ejecución actualizada reduce el número de procesos simultáneos deun tipo de proceso del servidor. El exceso de ese tipo de procesos del servidor sigue ejecutándosehasta que finalice.

• La configuración del tiempo de ejecución actualizada añade un tipo de proceso del servidor nuevoo aumenta el valor de los procesos simultáneos de un tipo de proceso existente. Los procesos delservidor nuevos se lanzan inmediatamente para que coincida con la configuración del tiempo deejecución actualizada, a menos que la instancia ya esté ejecutando el número máximo de procesosdel servidor. En ese caso, los nuevos procesos de servidor se lanzan únicamente cuando losprocesos existentes finalizan.

Elección del número de procesos por instanciaHay que tener en cuenta tres límites a la hora de decidir el número de procesos simultáneos:

• Amazon GameLift limita cada instancia a un número máximo de procesos simultáneos.Independientemente de si la configuración de tiempo de ejecución tiene una o varias configuraciones deprocesos del servidor especificadas, la suma de todos los procesos simultáneos de las configuracionesde procesos del servidor no pueden exceder dicho límite.

• El tipo de instancia Amazon EC2 que elija puede limitar el número de procesos que puede ejecutarsede forma simultánea pero, al mismo tiempo, ofrecer los niveles de desempeño aceptables. Debe probardiferentes configuraciones del juego para encontrar el número óptimo de procesos del tipo de instanciapreferido. Los factores que pueden afectar a su elección son los requisitos de los recursos del servidorde juegos, el número de jugadores a alojar en cada sesión de juego y las expectativas de desempeño delos jugadores.

• Al cambiar la configuración de tiempo de ejecución de una flota, tenga en cuenta que Amazon GameLiftnunca ejecutará más procesos simultáneas del número total configurado. Esto significa que la transicióndesde la configuración de tiempo de ejecución anterior a la nueva puede realizarse de manera gradual,empezando los procesos nuevos cuando finalicen los existentes. A continuación se muestra un ejemplo:tiene una flota que se ha configurado para ejecutar 10 procesos simultáneos del ejecutable del servidor,myGame.exe, con los parámetros de lanzamiento establecidos en "-loglevel=1". Puede actualizar laconfiguración para continuar ejecutando 10 procesos simultáneos de myGame.exe pero cambiar losparámetros de lanzamiento por "-loglevel=4". Dado que las instancias de la flota ya están ejecutando10 procesos, Amazon GameLift espera a iniciar un proceso con los nuevos parámetros de lanzamientohasta que finalice un proceso con los parámetros de lanzamiento antiguos.

Version59

https://docs.aws.amazon.com/general/latest/gr/aws_service_limits.html#limits_gamelift

Amazon GameLift Developer GuideCreación de una flota

Creación de una flotaPuede crear una flota nueva para alojar servidores de juegos de cualquier compilación de juegos quese haya cargado en el servicio de Amazon GameLift y que tenga el estado Ready. Utilice la consola deAmazon GameLift o la AWS Command Line Interface (p. 20) (CLI) para crear una flota. Puede cambiar laconfiguración de una flota editándola (p. 66).

Creación de una flota (consola)Para crear una flota con la consola de Amazon GameLift:

1. Abra la consola de Amazon GameLift en https://console.aws.amazon.com/gamelift/.2. En la página Builds, busque la compilación para la que desea crear una flota y verifique que su

estado sea Ready. Seleccione la compilación (utilice el botón situado a la izquierda del estado de lacompilación) y haga clic en Create fleet from build (Crear flota a partir de compilación).

3. En la página Create fleet (Crear flota), complete la sección Fleet Details (Detalles de la flota):

• Name: cree un nombre significativo para la flota para poder identificarla fácilmente en una lista y enlas métricas.

• Description (Descripción): (opcional) añada una descripción breve de esta flota para identificarla aúnmás.

• Fleet type (Tipo de flota): elija si desea utilizar instancias de spot o bajo demanda paraesta flota. Obtenga más información sobre los tipos de flota en Elección de los recursosinformáticos (p. 56).

• Metric group: (opcional) introduzca el nombre de un grupo de métricas de flota nuevo o existente.Si utiliza Amazon CloudWatch para realizar un seguimiento de sus métricas de Amazon GameLift,puede agregar las métricas para varias flotas agregándolas al mismo grupo de métricas.

• Build (Compilación): si utilizó la característica Create fleet from build (Crear a partir de compilación),los datos de la compilación, incluido el nombre, el identificador y el sistema operativo, se rellenaránautomáticamente. De lo contrario, seleccione una compilación válida en la lista desplegable.

4. Instance type. Seleccione un tipo de instancia Amazon EC2 en la lista. Los tipos de instancia quese enumeran varían en función de varios factores, entre los que se incluyen la región actual, elsistema operativo de la versión del juego seleccionada y el tipo de flota (bajo demanda o de spot).Obtenga más información sobre cómo elegir un tipo de instancia en Elección de los recursosinformáticos (p. 56). Una vez creada esta flota, no puede cambiar el tipo de instancia.

Amazon GameLift ofrece una capa gratuita con una instancia c4.large durante un año. El tipo deinstancia de capa gratuita está disponible solo para las flotas bajo demanda. Cuando se utiliza un tipode instancia de capa gratuita, puede configurar alertas de configuración o activar el escalado seguropara la flota para evitar que se le cobre por encima de la capa gratuita. Para obtener más información,consulte Capa gratuita y alertas de facturación (p. 17).

5. Process management (Administración de procesos). Configure el modo en que desea que se ejecutenlos procesos del servidor para ejecutarlos en cada instancia.

a. Asignación de procesos del servidor:

Especifique el tipo y el número de procesos del servidor de juegos que desea ejecutar en cadainstancia. Cada flota debe tener al menos una configuración de procesos del servidor definida,pero también puede tener varias configuraciones. Por ejemplo, si la compilación del juego tienevarios ejecutables de servidor, debe haber una configuración para cada ejecutable.

• Launch path: escriba la ruta al ejecutable del juego en la compilación. Todas las rutas delanzamiento deben empezar con la ubicación del servidor de juegos, que varía en función delsistema operativo en uso. En instancias Windows, los servidores de juegos se compilan en laruta C:\game. En las instancias Linux, los servidores de juegos se compilan en /local/game,

Version60





por lo que todas las rutas de lanzamiento deben empezar con esta ubicación. Por ejemplo, C:\game\MyGame\server.exe o /local/game/MyGame/server.exe.

• Launch parameters: (opcional) puede transferir información al ejecutable del juego en elmomento del lanzamiento. Escriba aquí la información como un conjunto de parámetros delínea de comandos. Por ejemplo, +sv_port 33435 +start_lobby.

• Concurrent processes: indica cuántos procesos del servidor deben ejecutarse con estaconfiguración de forma simultánea en cada instancia de la flota. Compruebe los límites deAmazon GameLift en relación con el número de procesos del servidor simultáneos; dependerádel SDK que utilice el servidor del juego.

Después de introducir una configuración de proceso del servidor, haga clic en el botón de marcade verificación verde para guardarla. Para añadir más configuraciones de procesos del servidor,haga clic en Add configuration.

Las restricciones a los procesos del servidor simultáneos por instancia se aplican a todos losprocesos simultáneos de todas las configuraciones. Si está limitado a un proceso, solo puededisponer de una configuración y los procesos simultáneos deberán definirse en 1. Si configura laflota de manera que se supere el límite, la flota no podrá activarse.

La recopilación de configuraciones de proceso del servidor se denomina la configuración entiempo de ejecución de la flota. Describe todos los procesos del servidor que se van a ejecutar encada instancia de esta flota en un momento dado.

b. Activación de la sesión de juego:

Establezca las siguientes restricciones para determinar la forma en la que se activan las sesionesde juego nuevas en las instancias de esta flota:

• Max concurrent game session activation (Activación de sesiones de juego simultáneasmáximas): limita el número de sesiones de juego en una instancia que se pueden estaractivando al mismo tiempo. Este límite es útil cuando el lanzamiento de varias sesiones dejuego nuevas puede afectar al desempeño de otras sesiones de juegos que se ejecutan en lainstancia.

• New activation timeout: esta configuración limita la cantidad de tiempo que Amazon GameLiftconcede para que se active una nueva sesión de juego. Si la sesión de juego no completa laactivación y pasa al estado ACTIVE, se termina la activación de la sesión de juego.

6. Configuración de puertos de EC2. Haga clic en Add port settings (Añadir configuración de puertos)para definir los permisos de acceso del tráfico entrante que conecta con los procesos del servidorimplementados en esta flota. Puede crear varias configuraciones de puerto para una flota. Se debedefinir al menos una configuración de puerto para la flota antes de que se conceda acceso a la misma.Si no especifica ninguna configuración de puerto en este momento, puede editar la flota más adelante.

• Port range: especifique un rango de números de puerto que sus servidores de juegos puedanutilizar para permitir conexiones entrantes. Un rango de puertos debe utilizar el formato nnnnn[-nnnnn] con valores entre 1 025 y 60 000. Por ejemplo, 1 500 o 1 500-20 000.

• Protocol: seleccione el tipo de protocolo de comunicación que debe utilizar la flota.• IP address range: especifique un rango de direcciones IP válidas para las instancias de esta flota.

Utilice la notación CIDR. Por ejemplo, 0.0.0.0/0 (Este ejemplo otorga acceso a cualquiera queintente conectarse.)

7. En la sección Resource creation limit, haga clic en Add resource creation limits para configurar unapolítica que limite el número de sesiones de juego que puede crear cada jugador en un periodo detiempo específico. Este límite protege los recursos de la flota disponibles de un consumo excesivo.Para utilizar esta función, las solicitudes de sesiones de juego nuevas deben especificar un creador.

• Game sessions per policy period: especifique el número de sesiones de juego que puede crear unjugador (en función del ID de jugador) durante el periodo de políticas.

Version61

https://aws.amazon.com//ec2/faqs/#Is_Amazon_EC2_used_in_conjunction_with_Amazon_S3


• Policy period: especifique el período de tiempo, en minutos, durante el que limitar la creación de lasesión de juego por jugador. Amazon GameLift evalúa cada nueva solicitud de sesión de juego paradeterminar si el creador ha superado el límite de creación en el intervalo de tiempo más reciente.

8. En la sección Protection policy, elija si quiere aplicar la protección de sesiones de juego a lasinstancias de esta flota. Las instancias con protección no terminan durante un evento de reducción deescala si alojan una sesión de juego activa. También puede definir la protección de sesiones de juegoindividuales. Una vez creada la flota, puede editarla para cambiar la política de protección de toda laflota.

9. Cuando haya terminado de configurar la flota nueva, haga clic en Initialize fleet. Amazon GameLiftasigna un ID a la flota nueva y comienza el proceso de activación de la misma. Puede ver el estadode la flota nueva en la página Fleets. En cuanto la flota esté activa, puede cambiar la capacidad de laflota (p. 70), la configuración de tiempo de ejecución y otras opciones de configuración según seanecesario.

Creación de una flota (AWS CLI)Para crear una flota con la AWS CLI, abra una ventana de línea de comando y utilice el comandocreate-fleet para definir una flota nueva. Consulte la documentación completa de este comando en laReferencia de comandos de AWS CLI. Si todavía no ha instalado la AWS CLI, consulte el tema Instalar laAWS CLI (p. 20).

La solicitud create-fleet de ejemplo mostrada a continuación crea una nueva flota con lascaracterísticas siguientes:

• La flota utilizará instancias bajo demanda c4.large con el sistema operativo necesario para la versión deljuego seleccionada.

• Implementará la versión del servidor del juegos especificada, que debe estar en estado Listo.• Cada instancia de la flota ejecutará diez procesos idénticos del servidor de juegos de forma simultánea,

permitiendo que cada instancia aloje hasta diez sesiones de juego simultáneamente.• En cada instancia, Amazon GameLift solo permitirá la activación de dos nuevas sesiones de juego al

mismo tiempo. Asimismo, terminará cualquier sesión de juego de activación si no está lista para alojarjugadores en un plazo de 300 segundos.

• Todas las sesiones de juego alojadas en instancias en esta flota tienen la protección de sesión de juegoactivada. Se puede desactivar para sesiones de juego individuales.

• Los jugadores individuales pueden crear tres nuevas sesiones de juego en un período de 15 minutos.• Cada sesión de juego que se aloja en esta flota tendrá un punto de conexión dentro de los rangos

especificados de dirección IP y puerto.• Las métricas de esta flota se añadirán al grupo de métrica EMEAfleets, que (en este ejemplo) combina

las métricas de todas las flotas en las regiones EMEA.

$ aws gamelift create-fleet --name "SampleFleet123" --description "The sample test fleet" --ec2-instance-type "c4.large" --fleet-type "ON_DEMAND" --build-id "build-92f061ed-27c9-4a02-b1f4-6f85b2385620" --runtime-configuration "GameSessionActivationTimeoutSeconds=300, MaxConcurrentGameSessionActivations=2, ServerProcesses=[{LaunchPath=C:\game\Bin64.dedicated\MultiplayerSampleProjectLauncher_Server.exe, Parameters=+sv_port 33435 +start_lobby, ConcurrentExecutions=10}]" --new-game-session-protection-policy "FullProtection" --resource-creation-limit-policy "NewGameSessionsPerCreator=3,

Version62

https://docs.aws.amazon.com/cli/latest/reference/gamelift/create-fleet.html


PolicyPeriodInMinutes=15" --ec2-inbound-permissions "FromPort=33435,ToPort=33435,IpRange=0.0.0.0/0,Protocol=UDP" "FromPort=33235,ToPort=33235,IpRange=0.0.0.0/0,Protocol=UDP" --MetricGroups "EMEAfleets"

Versión copiable:

aws gamelift create-fleet --name "SampleFleet123" --description "The sample test fleet" --fleet-type "ON_DEMAND" --MetricGroups "EMEAfleets" --build-id "build-92f061ed-27c9-4a02-b1f4-6f85b2385620" --ec2-instance-type "c4.large" --runtime-configuration "GameSessionActivationTimeoutSeconds=300,MaxConcurrentGameSessionActivations=2,ServerProcesses=[{LaunchPath=C:\game\Bin64.dedicated\MultiplayerSampleProjectLauncher_Server.exe,Parameters=+sv_port 33435 +start_lobby,ConcurrentExecutions=10}]" --new-game-session-protection-policy "FullProtection" --resource-creation-limit-policy "NewGameSessionsPerCreator=3,PolicyPeriodInMinutes=15" --ec2-inbound-permissions "FromPort=33435,ToPort=33435,IpRange=0.0.0.0/0,Protocol=UDP" "FromPort=33235,ToPort=33235,IpRange=0.0.0.0/0,Protocol=UDP"

Si la solicitud de creación de la flota se realiza correctamente, Amazon GameLift devuelve un conjunto deatributos de la flota que incluye los valores de configuración solicitados y un ID de flota nuevo. AmazonGameLift inicia inmediatamente el proceso de activación de la flota y establece el estado de la flota enNew. Puede realizar un seguimiento del estado de la flota y ver más información sobre la flota con estoscomandos de la CLI:

• describe-fleet-events• describe-fleet-attributes• describe-fleet-capacity• describe-fleet-port-settings• describe-fleet-utilization• describe-runtime-configuration

En cuanto la flota esté activa, podrá cambiar la capacidad de la flota y otras opciones de configuraciónsegún sea necesario:

• update-fleet-attributes• update-fleet-capacity• update-fleet-port-settings• update-runtime-configuration

Creación de una conexión de flotas y una interconexión de VPCPuede crear una flota y solicitar una interconexión de VPC para la flota al mismo tiempo. Obtenga másinformación sobre Configuración de la interconexión de VPC (p. 81) con Amazon GameLift.

Antes de solicitar una interconexión para una flota nueva, primero debe seguir los pasos que se describena continuación. En los dos pasos, deben usarse las credenciales de la cuenta que administra los recursosque no son de GameLift.

• Cree una VPC para un conjunto de recursos. La VPC debe estar en la misma región que la flota queestá a punto de crear. Anote el ID de la VPC.

• Llame al comando create-vpc-peering-authorization de Amazon GameLift para preautorizar la solicitudde interconexión. Necesitará el ID de la cuenta que utilizó con Amazon GameLift. Esta autorización seráválida durante 24 horas, a menos que se revoque.

Version63

https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-fleet-events.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-fleet-attributes.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-fleet-capacity.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-fleet-port-settings.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-fleet-utilization.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-runtime-configuration.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/update-fleet-attributes.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/update-fleet-capacity.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/update-fleet-port-settings.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/update-runtime-configuration.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreateVpcPeeringAuthorization.html


Para crear una interconexión entre la VPC y la flota:

• Siga las instrucciones para crear una nueva flota a través de la CLI de AWS (p. 62). Incluya lossiguientes parámetros adicionales:

• peer-vpc-aws-account-id: ID de la cuenta de AWS que no es de GameLift para la que creó una VPC.• peer-vpc-id: ID de la VPC que se creó con la cuenta que no es de GameLift.

Una llamada correcta a create-fleet con los parámetros de la interconexión de VPC genera una flota nuevay una nueva solicitud de interconexión de VPC. El estado de la flota se establece en New y se inicia elproceso de activación de la flota. El estado de la solicitud de interconexión se establece en initiating-request. Puede comprobar si la solicitud de interconexión se realiza o no correctamente llamando adescribe-vpc-peering-connections.

Cuando se solicite una interconexión de VPC con una flota nueva, las dos acciones tendrán éxito ofallarán. Si se produce un error en una flota durante el proceso de creación, la interconexión de VPC nose completará correctamente. Del mismo modo, si falla una interconexión de VPC por cualquier motivo, laflota nueva no podrá a pasar del estado Activating al estado Active.

Note

La nueva interconexión de VPC no se completará hasta que la flota esté lista para activarse. Portanto, no estará disponible durante la instalación de la compilación del servidor de juegos en unanueva instancia de la flota.

En el ejemplo siguiente, se muestra una solicitud para crear una flota nueva y una interconexión entre unaVPC preestablecida y la VPC que se crea para la flota nueva. La VPC preestablecida se identifica de formainequívoca al combinar el ID de la cuenta de AWS que no es de GameLift y el ID de la VPC.

$ aws gamelift create-fleet --name "My_Fleet_1" --description "The sample test fleet" --ec2-instance-type "c4.large" --fleet-type "ON_DEMAND" --build-id "build-1111aaaa-22bb-33cc-44dd-5555eeee66ff" --runtime-configuration "GameSessionActivationTimeoutSeconds=300, MaxConcurrentGameSessionActivations=2, ServerProcesses=[{LaunchPath=C:\game\Bin64.dedicated\MultiplayerSampleProjectLauncher_Server.exe, Parameters=+sv_port 33435 +start_lobby, ConcurrentExecutions=10}]" --new-game-session-protection-policy "FullProtection" --resource-creation-limit-policy "NewGameSessionsPerCreator=3, PolicyPeriodInMinutes=15" --ec2-inbound-permissions "FromPort=33435,ToPort=33435,IpRange=0.0.0.0/0,Protocol=UDP" "FromPort=33235,ToPort=33235,IpRange=0.0.0.0/0,Protocol=UDP" --MetricGroups "EMEAfleets" --peer-vpc-aws-account-id "111122223333" --peer-vpc-id "vpc-a11a11a"

Versión copiable:

aws gamelift create-fleet --name "My_Fleet_1" --description "The sample test fleet" --fleet-type "ON_DEMAND" --MetricGroups "EMEAfleets" --build-id "build-1111aaaa-22bb-33cc-44dd-5555eeee66ff" --ec2-instance-type "c4.large" --runtime-configuration "GameSessionActivationTimeoutSeconds=300,MaxConcurrentGameSessionActivations=2,ServerProcesses=[{LaunchPath=C:\game\Bin64.dedicated\MultiplayerSampleProjectLauncher_Server.exe,Parameters=+sv_port 33435 +start_lobby,ConcurrentExecutions=10}]" --new-game-session-protection-policy "FullProtection" --resource-creation-limit-policy "NewGameSessionsPerCreator=3,PolicyPeriodInMinutes=15" --ec2-inbound-

Version64

https://docs.aws.amazon.com/cli/latest/reference/gamelift/create-fleet.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-vpc-peering-connections.html

Amazon GameLift Developer GuideProblemas al crear una flota de depuración

permissions "FromPort=33435,ToPort=33435,IpRange=0.0.0.0/0,Protocol=UDP" "FromPort=33235,ToPort=33235,IpRange=0.0.0.0/0,Protocol=UDP" --peer-vpc-aws-account-id "111122223333" --peer-vpc-id "vpc-a11a11a"

Problemas al crear una flota de depuraciónEste tema contiene directrices acerca del proceso de creación de la flota y de cómo diagnosticar y resolverproblemas comunes que pueden evitar que una flota se active.

Cómo funciona la creación de flotasCuando se crea una nueva flota, el servicio de Amazon GameLift realiza una serie de tareas para prepararuna instancia en función de la configuración de la flota. A medida que se completa cada fase de la creaciónde la flota, se emiten una serie de eventos para la flota junto con el estado actual de la flota. Puede hacerun seguimiento de todos los eventos, incluidos los de la creación de la flota, a través de la consola deAmazon GameLift (consulte la pestaña Events [Eventos] en la página de detalle de la flota).

Si surgen problemas durante la creación de la flota, el estado de la flota puede establecerse en Error ypueden aparecer mensajes de error significativos. La fase del proceso de creación de la flota en la que seproducen errores también puede ser un buen indicador. Las fases de creación de la flota son:

• New (Nueva): se crea el registro de la flota. Se asignan los recursos de la instancia inicial.• Downloading (Descarga): los archivos de compilación del juego se descargan en la instancia y se

extraen.• Validating (Validación): se validan los archivos de compilación del juego descargados.• Building (Compilación): la compilación del servidor de juegos se instala en la instancia mediante un script

de instalación, si está disponible.• Activating (Activación): los procesos se inician en función de la configuración del entorno en tiempo de

ejecución de la flota. Al menos un proceso debe comunicarse con Amazon GameLift para informar sudisposición para alojar una sesión de juego.

Tan pronto como uno de los procesos del servidor notifique a Amazon GameLift que está preparado, elestado de la flota cambia a Active (Activa).

Problemas comunes de la creación de flotasDescarga y validación

Durante esta fase, pueden producirse errores en la creación de la flota si hay problemas con los archivosde compilación extraídos, el script de instalación no se ejecuta o los ejecutables designados en laconfiguración del entorno en tiempo de ejecución no están incluidos en los archivos de compilación.Amazon GameLift proporciona registros relacionados con cada uno de estos problemas.

Si los registros no revelan incidencias, es posible que el problema se deba a un error de servicio interno.En este caso, intente crear de nuevo la flota. Si el problema persiste, considere la posibilidad de volver acargar la compilación del juego (en caso de que los archivos estén dañados). También puede ponerse encontacto con el equipo de soporte de Amazon GameLift o publicar una pregunta en el foro.

Building

En la mayoría de los casos, las incidencias que producen errores durante la fase de compilación se debena problemas con los archivos de compilación del juego o con el script de instalación. Compruebe que losarchivos de compilación del juego, tal y como se cargaron en Amazon GameLift, pueden instalarse en unequipo que ejecute el sistema operativo apropiado. Asegúrese de utilizar una instalación limpia del sistemaoperativo y no un entorno de desarrollo existente.

Activación

Version65

Amazon GameLift Developer GuideAdministración de los registros de la flota

Los problemas más habituales de la creación de flotas se producen durante la fase Activating (Activación).Durante esta fase, se comprueban una serie de elementos, como la viabilidad del servidor de juegos,la configuración del entorno en tiempo de ejecución y la capacidad del servidor para utilizar el SDK delservidor a la hora de interactuar con el servicio de Amazon GameLift.

Estos escenarios pueden ayudar a diagnosticar y resolver los problemas de activación:

• Los procesos del servidor no arrancan. En primer lugar, compruebe que ha definido correctamente laruta de lanzamiento y los parámetros de lanzamiento opcionales en la configuración del entorno entiempo de ejecución de la flota. Puede ver la configuración del entorno en tiempo de ejecución actualde la flota a través de la consola de Amazon GameLift (consulte en la página de detalles Fleet [Flota] lapestaña Capacity allocation [Asignación de capacidad] (p. 135)) o llamando al comando describe-runtime-configuration de la AWS CLI. Si la configuración del motor en tiempo de ejecución escorrecta, compruebe si hay problemas con los archivos de compilación del juego o con el script deinstalación.

• Los procesos del servidor arrancan pero la flota no se activa. Si los procesos del servidor arrancan yse ejecutan correctamente pero la flota no pasa del estado Active (Activo), es probable que la causasea que el proceso del servidor no esté notificando a Amazon GameLift que está listo para alojar lassesiones de juego. Compruebe que el servidor de juegos llame correctamente a la acción de la API deservidor ProcessReady() (consulte Preparación de un proceso del servidor (p. 32)).

Para obtener más información sobre la solución de problemas, puede obtener acceso a una instancia de laflota de forma remota. Consulte Acceso remoto a instancias de una flota (p. 79).

Los procesos del servidor arrancan pero dan error rápidamente o notifican que no están funcionandocorrectamente. Aparte de los problemas con la compilación del juego, esto puede ocurrir al intentarejecutar demasiados procesos del servidor simultáneamente en la instancia. La cantidad óptima deprocesos simultáneos depende del tipo de instancia y de los requisitos de los recursos del servidor dejuegos. Intente reducir el número de procesos simultáneos, que se define en la configuración del tiempode ejecución de la flota, para ver si mejora el desempeño. Puede cambiar la configuración de tiempo deejecución de una flota mediante la consola de Amazon GameLift (edite la configuración de asignación decapacidad de la flota) o llamando al comando update-runtime-configuration de AWS CLI.

Administración de los registros de la flotaUtilice la consola de Amazon GameLift o la CLI de AWS para administrar las flotas existentes, como laactualización de los atributos de la flota, los ajustes de los puertos y la configuración del entorno en tiempode ejecución. También puede eliminar una flota.

Actualización de una flotaUtilice la página Edit fleet de la consola de Amazon GameLift para modificar la configuración de unaflota. Todas las propiedades de la flota pueden cambiarse excepto el ID de compilación y el tipo deinstancia. Para cambiar la configuración de escalado, consulte Escalado automático de la capacidad de laflota (p. 72).

Note

Una flota activa puede implementarse con una compilación que se haya eliminado o se encuentreen un estado de error. Esto no afecta al estado de la flota ni a su capacidad para alojar sesionesde juego. En este caso, es posible que el estado de la compilación sea Deleted (Eliminado)o Error(si se produjo un error al intentar recuperar la información de la compilación).

También puede actualizar una flota utilizando los siguientes comandos de la CLI de AWS:

• update-fleet-attributes• update-fleet-port-settings• update-runtime-configuration

Version66




https://docs.aws.amazon.com/cli/latest/reference/gamelift/update-fleet-attributes.html



Amazon GameLift Developer GuideAdministración de la capacidad de la flota

Para actualizar una configuración de flota

1. Abra la consola de Amazon GameLift en https://console.aws.amazon.com/gamelift/.2. Seleccione Fleets (Flotas) en el menú para ver una lista de flotas y haga clic en el nombre de la flota

que desee actualizar. Una flota debe tener el estado ACTIVE (Activo) para poder editarla.3. En la página de los detalles de la flota, en Actions (Acciones), seleccione Edit fleet (Editar flota).4. En la página Edit fleet (Editar flota), puede realizar las siguientes actualizaciones (consulte Creación

de una flota (p. 60) para ver descripciones más detalladas de los campos):

• Modifique los atributos de la flota; por ejemplo, Name (Nombre) y Description (Descripción).• En Metric groups (Grupos de métricas), añada o quite los grupos de métricas que se utilizan en

Amazon CloudWatch para hacer un seguimiento de las métricas de Amazon GameLift agregadas devarias flotas.

• Cambie el modo en que desea que se ejecuten los procesos del servidor y se alojen las sesiones dejuego actualizando la asignación de procesos de servidor (configuración del entorno en tiempo deejecución) y los ajustes de activación de sesiones de juego.

• Actualice la configuración de los puertos de EC2 que se va a utilizar para establecer conexión conlos procesos de servidor de esta flota.

• Actualice la configuración de los límites de creación de recursos.• Active o desactive la protección de sesiones de juego.

5. Haga clic en Submit (Enviar) para guardar los cambios.

Eliminación de una flotaCuando ya no necesite una flota, puede eliminarla. Cuando se elimina una flota, se borran también deforma permanente todos los datos asociados con las sesiones de juego y las sesiones de jugador, asícomo los datos de las métricas recopilados. No obstante, también tiene la posibilidad de conservar la flota,deshabilitar el escalado automático y escalar manualmente la flota a 0 instancias.

Note

Para que una flota pueda eliminarse, debe escalarse a 0. Establezca el número de instanciasdeseadas en 0 y espere a que la flota reduzca el número de instancias activas a 0.

También puede eliminar una flota utilizando el siguiente comando de la CLI de AWS:

• delete-fleet

Para eliminar una flota

1. Abra la consola de Amazon GameLift en https://console.aws.amazon.com/gamelift/.2. Seleccione Fleets (Flotas) en la barra de menús para ver una lista de flotas y haga clic en el nombre

de la flota que desee eliminar. Una flota debe tener el estado ACTIVE (Activo) para poder eliminarla.3. En la página de detalles de la flota, en Actions (Acciones), seleccione Terminate fleet (Terminar flota).4. En el cuadro de diálogo Terminate fleet, confirme la eliminación escribiendo el nombre de la flota.5. Haga clic en Delete.

Administración de la capacidad de la flotaLa capacidad de la flota, medida en instancias, determina el número de sesiones de juego (y jugadores)que puede alojar la flota. Una de las tareas más exigentes del alojamiento de juegos consiste en encontrarun equilibrio entre el mantenimiento de una capacidad suficiente para dar cabida a los nuevos jugadores y

Version67


https://docs.aws.amazon.com/cli/latest/reference/gamelift/delete-fleet.html


Amazon GameLift Developer GuideEstablecimiento de los límites de capacidad de la flota

no perder dinero en recursos innecesarios. Obtenga más información sobre cómo funciona el escalado dela capacidad (p. 3) en Amazon GameLift.

Tiene el control absoluto sobre el escalado de las flotas. Puede establecer la capacidad según un númeroespecífico de instancias, o bien puede aprovechar el escalado automático para ajustar la capacidad enfunción de la demanda real de los jugadores. Recomendamos que comience por activar la opción deescalado automático Seguimiento de destino. El Seguimiento de destino es una herramienta eficaz y fácilde usar para ayudarle a mantener suficientes recursos de alojamiento como para adaptarse a la demandaactual de los jugadores y administrar picos repentinos. Para la gran mayoría de juegos, el seguimiento dedestino será la única solución que le hará falta.

Los temas de esta sección proporcionan ayuda en detalle en relación con las siguientes tareas:

• Establecimiento de límites máximos y mínimos para el escalado de la capacidad (p. 68)• Establecimiento manual de los niveles de capacidad (p. 70)• Activación del escalado automático con Seguimiento de destino (p. 72)• Administración del escalado automático basado en reglas (característica avanzada) (p. 73)• Desactivación temporal del escalado automático (p. 70)

La mayoría de las actividades de escalado de la flota se pueden realizar con la consola de AmazonGameLift. También puede utilizar la SDK o la AWS CLI de AWS con la API de servicio de AmazonGameLift para todas las actividades de escalado de la flota.

Para obtener acceso a la configuración de la capacidad de la flota en la consola:

1. Abra la consola de Amazon GameLift en https://console.aws.amazon.com/gamelift/.2. En la página Fleets (Flotas), haga clic en el nombre de una flota activa para abrir la página de detalles

de la flota. (También puede acceder a la página de detalles de una flota a través del panel.)3. Abra la pestaña Scaling (Escalado) para ver las métricas históricas de escalado y para ver o cambiar

la configuración actual. La configuración se encuentra bajo el gráfico de métricas. En esta sección,puede ver o actualizar los límites de escalado, configurar manualmente la capacidad de la flota,habilitar o deshabilitar el escalado automático, activar el escalado automático basado en destino y vertodas las políticas activas de escalado automático.

Temas• Establecimiento de los límites de capacidad de la flota (p. 68)• Establecimiento manual de la capacidad de la flota (p. 70)• Escalado automático de la capacidad de la flota (p. 72)

Establecimiento de los límites de capacidad de la flotaEl tamaño de la flota se determina mediante el número de instancias que contiene. Cada flota tiene unlímite mínimo y máximo definidos, que se pueden establecer según sea necesario para el juego. Todas lassolicitudes para cambiar la capacidad de la flota (ya sea mediante escalado automático o ajuste manual)deben estar dentro de los límites actuales. De forma predeterminada, los límites de las nuevas flotas seestablecen en un mínimo de 0 instancias y un máximo de 1 instancia. Antes de ampliar una flota, tendráque ajustar los límites de la flota.

Si está aplicando escalado automático a una flota, el límite máximo permite a Amazon GameLift ampliarla flota todo lo necesario para dar cabida a la demanda de los jugadores y, a la vez, evitar los costos dealojamiento excesivos, como los que podrían darse durante un ataque DDOS. Configure CloudWatchpara que cree una alarma cuando la capacidad se acerque al límite máximo, para que pueda evaluarla situación y realizar ajustes manuales según sea necesario. (También puede configurar una alerta de

Version68




https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/monitor-charges.html

Amazon GameLift Developer GuideEstablecimiento de los límites de capacidad de la flota

facturación para monitorear los costos de AWS). El límite mínimo es útil cuando desea asegurarse de quesiempre tenga cierta disponibilidad de alojamiento en todo momento.

Los límites también se aplican a las flotas con escalado manual. Para poder ajustar la capacidad de laflota a un valor fuera del rango límite, debe cambiar los límites. Dado que la capacidad de la flota tiene unefecto tan importante sobre la disponibilidad del juego y la experiencia de los jugadores, la característicade límites proporciona una capa de control adicional sobre la capacidad.

Puede establecer los límites de capacidad de una flota en la consola de Amazon GameLift o mediante laAWS CLI. El estado de la flota debe ser Active.

Establecimiento de los límites de capacidad (consola)1. Abra la consola de Amazon GameLift en https://console.aws.amazon.com/gamelift/.2. En la página Fleets (Flotas), haga clic en el nombre de una flota activa para abrir la página de detalles


la configuración actual. La configuración de escalado se encuentra bajo el gráfico de métricas.4. En Instance Limits (Límites de instancia), defina los recuentos mínimo y máximo. Para cada control,

confirme los cambios haciendo clic en el botón de marca de verificación .

Si el recuento de instancias deseadas actual de la flota está fuera del nuevo rango de límites, recibiráun error. En este caso, primero debe ajustar el recuento de instancias deseadas de la flota para quequede dentro del nuevo rango de límites. Esto se puede hacer en la pestaña Scaling (Escalado). Si laflota utiliza escalado automático, tendrá que deshabilitar el escalado automático, ajustar manualmenteel recuento de instancias deseadas, establecer el nuevo rango de límites y, a continuación, volver ahabilitar el escalado automático.

Los nuevos límites se reflejan inmediatamente en el gráfico, en la parte superior de la pestaña Scaling(Escalado).

Establecimiento de los límites de capacidad (CLI de AWS)1. Compruebe la configuración de la capacidad actual. En una ventana de línea de comandos, use

el comando describe-fleet-capacity con el ID de la flota para la que quiera cambiar la capacidad.Este comando devuelve un objeto FleetCapacity que incluye el recuento de instancias actual y loslímites de capacidad. Determine si los nuevos límites de instancia se ajustarán a la configuración deinstancias deseadas actual.

aws gamelift describe-fleet-capacity --fleet-id <unique fleet identifier>

2. Actualice la configuración de límites.En una ventana de línea de comandos, utilice el comando update-fleet-capacity con los siguientes parámetros. Puede ajustar tanto los límites de instancias como elrecuento de instancias deseadas con el mismo comando.

--fleet-id <unique fleet identifier>--max-size <maximum capacity for auto-scaling>--min-size <minimum capacity for auto-scaling>--desired-instances <fleet capacity as an integer> [Optional]

Ejemplo:

aws gamelift update-fleet-capacity--fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa--max-size 10--min-size 1

Version69

https://docs.aws.amazon.com/awsaccountbilling/latest/aboutv2/monitor-charges.html




https://docs.aws.amazon.com/gamelift/latest/apireference/API_FleetCapacity.html



Amazon GameLift Developer GuideEstablecimiento manual de la capacidad de la flota

--desired-instances 10

Versión copiable:

aws gamelift update-fleet-capacity --fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa --max-size 10 --min-size 1 --desired-instances 10

Si la solicitud se realiza correctamente, se devuelve el ID de la flota. Si el nuevo valor max-size o min-sizeentra en conflicto con la configuración desired-instances actual, se devuelve un error.

Establecimiento manual de la capacidad de la flotaAl crear una flota nueva, la capacidad de la flota se establece automáticamente en una instancia. Enrespuesta, Amazon GameLift inicia una nueva instancia con los procesos del servidor del juego tal y comose haya configurado. Para cambiar la capacidad de la flota, puede activar el escalado automático o puedeconfigurar manualmente el número de instancias que desee para la flota. Encontrará más información enGestión de capacidad y escalado (p. 3).

La configuración manual de la capacidad de una flota puede resultar útil cuando no se necesita el escaladoautomático cuando es necesario conservar la capacidad en un número arbitrario de instancias temporal opermanentemente. Cuando se configura manualmente la capacidad deseada, tenga en cuenta que estaacción afectará a la capacidad real de la flota solo si (1) no hay políticas de escalado automático para laflota, o (2) se ha deshabilitado el escalado automático. Si el escalado automático está habilitado, reiniciaráautomáticamente la capacidad deseada en función de sus reglas de escalado propias.

Puede establecer manualmente la capacidad de la flota en la consola de Amazon GameLift o mediante laAWS CLI. El estado de la flota debe ser Active.

Deshabilitación del escalado automáticoLa deshabilitación del escalado automático le permite desactivar el escalado automático para una flotay recuperar el escalado manual. Aunque siempre puede eliminar una política de escalado automáticode una flota, esta función le permite desactivar temporalmente el escalado automático pero conservarlas políticas para usarlas en el futuro. Por ejemplo, si desea ampliar la escala para prepararse para unevento importante en el futuro, puede deshabilitar el escalado automático, establecer manualmente lacapacidad de la flota deseada y, a continuación, una vez que el evento esté en curso, volver a habilitar elescalado automático. Cuando el escalado automático está deshabilitado, se detienen todas las actividadesde escalado automático para la flota, incluidas las políticas activas actualmente y las políticas que pudierancrearse en el futuro. Puede habilitar/deshabilitar el escalado automático en la consola de Amazon GameLift(consulte el paso 4 de "Configurar manualmente la capacidad").

Configurar manualmente la capacidad (consola)1. Abra la consola de Amazon GameLift en https://console.aws.amazon.com/gamelift/.2. En la página Fleets (Flotas), haga clic en el nombre de una flota activa para abrir la página de detalles


la configuración actual. La configuración de escalado se encuentra bajo el gráfico de métricas.4. En Auto-Scaling Policies (Políticas de escalado automático), marque la casilla "Disable all scaling

policies (Deshabilitar todas las políticas de escalado)" y confirme el cambio; para ello, haga clic enel botón de marca de verificación . Esta configuración detiene todas las acciones de escaladoautomático para la flota. Hacer esto es buena idea incluso si la flota no tiene políticas actualmente, ya

Version70


Amazon GameLift Developer GuideEstablecimiento manual de la capacidad de la flota

que evitará que las políticas de nueva creación tengan efecto. Tras confirmar este cambio, la tabla depolíticas de escalado activas indica que todas las políticas están "desactivadas".

5. En Auto-Scaling Policies (Políticas de escalado automático), para la opción "Manually adjustthe desired instance count to... (Ajustar manualmente el recuento de instancias deseadas a...)",especifique el número de instancias para la flota. Este valor indica a Amazon GameLift cuántasinstancias deben mantenerse en estado activo, disponibles para alojar sesiones de juego. Confirme elcambio haciendo clic en el botón de marca de verificación .

Si el nuevo valor de instancias deseado se encuentra fuera de los límites de capacidad de la flota,se producirá un error. En este caso, primero debe ajustar los límites de instancias de la flota paradar cabida al nuevo recuento de instancias deseadas. Los límites de instancias también se puedenestablecer en la pestaña Scaling (Escalado).

A partir del momento en que se confirmen los cambios en los límites de instancias y los niveles deescalado manual, los valores nuevos se verán reflejados en el gráfico de la parte superior de la pestañaScaling (Escalado). Amazon GameLift comienza inmediatamente a responder a los cambios mediantela implementación de instancias adicionales o el cierre de las que sean innecesarias. A medida que secomplete este proceso, el número de instancias en el campo Active (Activas) cambiará hasta alcanzar elvalor actualizado de instancias deseadas. Este proceso puede tardar cierto tiempo.

Configurar manualmente la capacidad (CLI de AWS)1. Compruebe la configuración de la capacidad actual. En una ventana de línea de comandos, use el

comando describe-fleet-capacity con el ID de la flota para la que quiera cambiar la capacidad. Estecomando devuelve un objeto FleetCapacity que incluye el recuento de instancias actual y los límitesde capacidad. Determine si el nuevo recuento de instancias se encuentra entre los límites mínimo ymáximo.

aws gamelift describe-fleet-capacity --fleet-id <unique fleet identifier>

2. Actualice la capacidad deseada.Utilice el comando update-fleet-capacity con el ID de la flota y unnuevo valor de desired-instances. Si este valor queda fuera del rango de límites actual, incluya valoresde ajuste de límites en el mismo comando.

--fleet-id <unique fleet identifier>--desired-instances <fleet capacity as an integer>--max-size <maximum capacity for auto-scaling> [Optional]--min-size <minimum capacity for auto-scaling> [Optional]

Ejemplo:

aws gamelift update-fleet-capacity--fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa--desired-instances 5--max-size 10--min-size 1

Versión copiable:

aws gamelift update-fleet-capacity --fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa --desired-instances 5 --max-size 10 --min-size 1

Si la solicitud se realiza correctamente, se devuelve el ID de la flota. Si el nuevo valor desired-instancesestá fuera de los límites máximos y mínimos, se devuelve un error.

Version71


https://docs.aws.amazon.com/gamelift/latest/apireference/API_FleetCapacity.html


Amazon GameLift Developer GuideEscalado automático de la capacidad de la flota

Escalado automático de la capacidad de la flotaUtilice el escalado automático para escalar de forma dinámica la capacidad de su flota en respuestaa la actividad del servidor de juego. A medida que los jugadores lleguen e inicien sesiones de juego,el escalado automático puede añadir nuevas instancias, y a medida que la demanda de los jugadoresdecrezca, el escalado automático irá cerrando las instancias innecesarias. El escalado automático esuna forma eficaz de minimizar sus recursos y costos de alojamiento y, a la vez, facilitar al jugador unaexperiencia rápida y sin interrupciones. Obtenga más información sobre cómo funciona el escaladoautomático (p. 4) en Amazon GameLift.

El escalado automático se realiza mediante la creación de políticas de escalado que proporcionaninstrucciones de aumento o reducción a Amazon GameLift. Existen dos tipos de políticas de escalado,las basadas en destino y las basadas en reglas. El enfoque basado en destinos (seguimiento dedestino) ofrece una solución completa: se recomienda como la opción más sencilla y eficaz. Las políticasde escalado basadas en reglas, que requieren que se defina cada aspecto del proceso de toma dedecisiones de escalado automático, son útiles para abordar cuestiones específicas. Funcionan mejor comocomplemento al escalado automático basado en destino.

El escalado automático basado en destino se puede administrar con la consola de Amazon GameLift, conla CLI de AWS o con el SDK de AWS. El escalado automático basado en reglas se administra únicamentemediante la CLI de AWS o el SDK de AWS, aunque puede ver las políticas de escalado basadas en reglasen la consola.

Temas• Escalado automático con Seguimiento de destino (p. 72)• Escalado automático con políticas basadas en reglas (p. 73)

Escalado automático con Seguimiento de destinoEl Seguimiento de destino ajusta los niveles de capacidad en función de una única métrica de flota clave:"porcentaje de sesiones de juego disponibles". Esta métrica mide el número de ranuras de sesionesde juego disponibles con la capacidad actual (sesiones de juego adicionales que se pueden iniciarinmediatamente). En efecto, esta métrica representa el búfer de la flota frente a aumentos repentinos de lademanda de los jugadores.

El principal motivo para mantener un búfer de capacidad es el tiempo de espera del jugador. Cuandolas ranuras de sesiones de juego están listas y en espera, el tiempo que se tarda en introducir nuevosjugadores en las sesiones de juego se puede medir en segundos. Si no hay recursos disponibles, losjugadores deben esperar a que las sesiones de juego existentes terminen o a que queden disponiblesnuevos recursos. El tiempo necesario para iniciar nuevas instancias y procesos del servidor puede ser devarios minutos.

Al configurar el seguimiento de destino, solo tiene que especificar el tamaño del búfer que quiera quemantenga la flota. Dado que la métrica "porcentaje de sesiones de juego disponibles" mide el porcentajede los recursos disponibles, el tamaño del búfer real es un porcentaje del total de la capacidad de la flota.Amazon GameLift añade o elimina las instancias que sean necesarias para mantener el tamaño del búferde destino. La selección del tamaño del búfer depende de cómo desee priorizar la reducción del tiempo deespera del jugador frente al control de los costos de alojamiento. Con un búfer grande, reducirá el tiempode espera, pero también pagará por recursos adicionales que podrían no utilizarse. Si los jugadores tienenmás tolerancia a los tiempos de espera, puede reducir los costos estableciendo un búfer pequeño.

Establecimiento del seguimiento de destino (consola)

1. Abra la consola de Amazon GameLift en https://console.aws.amazon.com/gamelift/.2. En la página Fleets (Flotas), haga clic en el nombre de una flota activa para abrir la página de detalles

de la flota. (También puede acceder a la página de detalles de una flota a través del panel.)

Version72



3. Abra la pestaña Scaling (Escalado). Esta pestaña muestra las métricas históricas de escalado dela flota y contiene controles para ajustar la configuración de escalado actual. La configuración deescalado se encuentra bajo el gráfico de métricas.

4. En Instance Limits (Límites de instancias), compruebe que los límites mínimo y máximo seanadecuados para la flota. Con el escalado automático habilitado, la capacidad se puede ajustar acualquier nivel entre estos dos límites.

5. En Auto-Scaling Policies (Políticas de escalado automático), active la opción Maintain a buffer of Xpercent game session availability (Mantener un búfer del X por ciento de disponibilidad de sesionesde juego). Establezca un tamaño del búfer y haga clic en el botón de marca de verificación paraguardar la configuración de escalado automático. Tras haber guardado la configuración, se añadiráuna nueva política basada en el destino a la tabla Scaling policies (Políticas de escalado).

6. Para activar el escalado automático para la flota. Compruebe que la opción Disable all scaling policiesin the fleet (Desactivar todas las políticas de escalado en la flota) esté desactivada. Si esta opción estáactivada, todas las políticas, incluida la nueva política de seguimiento de destino, están deshabilitadas.Este estado se refleja en la tabla Scaling policies (Políticas de escalado).

Establecimiento del seguimiento de destino (CLI de AWS)

1. Establecimiento de los límites de capacidad.Configure uno o ambos valores límites con el comandoupdate-fleet-capacity. Para obtener ayuda, consulte Establecimiento de los límites de capacidad (CLIde AWS) (p. 69).

2. Creación de una nueva política.Abra una ventana de línea de comandos y utilice el comando put-scaling-policy con la configuración de parámetros de su política. Para actualizar una política existente,especifique el nombre de la política y proporcione una versión completa de la política actualizada.

--fleet-id <unique fleet identifier>--name "<unique policy name>"--policy-type <target- or rule-based policy>--metric-name <name of metric>--target-configuration <buffer size>

Ejemplo:

$aws gamelift put-scaling-policy--fleet-id "fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa"--name "My_Target_Policy_1"--policy-type "TargetBased" --metric-name "PercentAvailableGameSessions"--target-configuration "TargetValue=5"

Versión copiable:

$aws gamelift put-scaling-policy --fleet-id "fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa" --name "My_Target_Policy_1" --policy-type "TargetBased" --metric-name "PercentAvailableGameSessions" --target-configuration "TargetValue=5"

Escalado automático con políticas basadas en reglasLas políticas de escalado basadas en reglas ofrecen un control detallado al escalar automáticamente lacapacidad de una flota en respuesta a la actividad de los jugadores. Para cada política, puede vincular elescalado de una flota a una métrica de la flota de entre varias disponibles, identificar un punto de disparoy personalizar el evento de ampliación o reducción de respuesta. Las políticas basadas en reglas son

Version73


https://docs.aws.amazon.com/cli/latest/reference/gamelift/put-scaling-policy.html



especialmente útiles para complementar el escalado basado en destino para afrontar circunstanciasespeciales.

Una política basada en reglas da la siguiente instrucción: "Si una métrica de una flota alcanza o superaun valor umbral durante un período de tiempo determinado, se debe cambiar la capacidad de la flota enuna cantidad determinada". En este tema se describe la sintaxis utilizada para construir una instrucción depolítica y proporciona ayuda para crear y administrar sus políticas basadas en reglas.

Administración de políticas basadas en reglas

Puede crear, actualizar o eliminar políticas basadas en reglas con el SDK o la CLI de AWS con la API deservicio de Amazon GameLift. Puede ver todas las políticas activas en la consola de Amazon GameLift.

Para desactivar temporalmente todas las políticas de escalado para una flota, utilice el comando de la CLIde AWS stop-fleet-actions.

Para crear o actualizar una política de escalado basada en reglas (CLI de AWS):

1. Establecimiento de los límites de capacidad.Configure uno o ambos valores límites con el comandoupdate-fleet-capacity. Para obtener ayuda, consulte Establecimiento de los límites de capacidad (CLIde AWS) (p. 69).

2. Creación de una nueva política.Abra una ventana de línea de comandos y utilice el comando put-scaling-policy con la configuración de parámetros de su política. Para actualizar una política existente,especifique el nombre de la política y proporcione una versión completa de la política actualizada.

--fleet-id <unique fleet identifier>--name "<unique policy name>"--policy-type <target- or rule-based policy>--metric-name <name of metric>--comparison-operator <comparison operator>--threshold <threshold integer value>--evaluation-periods <number of minutes>--scaling-adjustment-type <adjustment type>--scaling-adjustment <adjustment amount>

Ejemplo:

aws gamelift put-scaling-policy--fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa--name "Scale up when AGS<50"--policy-type RuleBased--metric-name AvailableGameSessions--comparison-operator LessThanThreshold--threshold 50--evaluation-periods 10--scaling-adjustment-type ChangeInCapacity--scaling-adjustment 1

Versión copiable:

aws gamelift put-scaling-policy --fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa --name "Scale up when AGS<50" --policy-type RuleBased --metric-name AvailableGameSessions --comparison-operator LessThanThreshold --threshold 50 --evaluation-periods 10 --scaling-adjustment-type ChangeInCapacity --scaling-adjustment 1

Version74



https://docs.aws.amazon.com/cli/latest/reference/gamelift/stop-fleet-actions.html





Para eliminar una política de escalado basada en reglas mediante la CLI de AWS:

• Abra una ventana de línea de comandos y utilice el comando delete-scaling-policy con el ID de la flotay el nombre de la política.

Ejemplo:

aws gamelift delete-scaling-policy--fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa--name "Scale up when AGS<50"

Versión copiable:

aws gamelift delete-scaling-policy --fleet-id fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa --name "Scale up when AGS<50"

Sintaxis para las reglas de escalado automático

Para construir una instrucción de política de escalado automático basado en reglas, debe especificar seisvariables:

Si <nombre de métrica> se mantiene en <operador de comparación> <valor umbral> durante<período de evaluación>, entonces se debe cambiar la capacidad de la flota utilizando <tipo deajuste> en/por <valor de ajuste>.

Por ejemplo, esta instrucción de la política activa un evento de ampliación cuando la capacidad adicionalde la flota (recursos de alojamiento disponibles que se estén utilizando actualmente) es inferior a lo que senecesita para administrar 50 nuevas sesiones de juego:

Si AvailableGameSessions se mantiene en less than 50 durante 15 minutes, entonces se debecambiar la capacidad de la flota utilizando ChangeInCapacity en 10 instances.

Nombre de métrica

Para disparar un evento de escalado, vincule una política de escalado automático a una delas siguientes métricas específicas de la flota. Consulte Métricas de Amazon GameLift paraflotas (p. 138) para obtener descripciones más completas de las métricas.• Activación de sesiones de juego• Sesiones de juego activas• Sesiones de juego disponibles• Porcentaje de sesiones de juego disponibles• Instancias activas• Sesiones de jugador disponibles• Sesiones de jugador actuales• Instancias inactivas• Porcentaje de instancias inactivas

Las siguientes métricas se pueden utilizar si la flota se incluye en una cola de sesión de juego:• Profundidad de la cola (específica a la flota): número de solicitudes de sesiones de juego pendientes

para las que esta flota es la mejor ubicación de alojamiento disponible.• Tiempo de espera (específico de la flota): el tiempo de espera específico de flota. Periodo de tiempo

que ha estado esperando la solicitud de sesión de juego más antigua hasta ser completada. De

Version75

https://docs.aws.amazon.com/cli/latest/reference/gamelift/delete-scaling-policy.html


igual modo que con la profundidad de cola, esta métrica solo refleja las solicitudes de sesiones dejuego para las que esta flota es la mejor ubicación de alojamiento disponible. El tiempo de espera deuna flota es igual al tiempo en cola de la solicitud actual más vieja.

Operador de comparación

Esta variable le indica a Amazon GameLift cómo debe comparar los datos de las métricas con el valorumbral. Los operadores de comparación válidos incluyen mayor que (>), menor que (<), mayor o igualque (>=) o menor o igual que (<=).

Valor umbral

Cuando el valor especificado de la métrica alcanza o supera el valor umbral, puede disparar un eventode escalado. En función de la métrica seleccionada, podría indicar una cantidad de sesiones dejugador, sesiones de juego, instancias o solicitudes de sesión de juego. Este valor siempre es unnúmero entero positivo.

Período de evaluación

La métrica debe alcanzar o superar el valor umbral durante la totalidad del periodo de evaluaciónantes de disparar un evento de escalado. La longitud del periodo de evaluación es consecutiva: si lamétrica cae por debajo del umbral, el periodo de evaluación se inicia de nuevo.

Tipo y valor de ajuste

Este conjunto de variables opera conjuntamente para especificar el modo en que Amazon GameLiftdebe ajustar la capacidad de la flota cuando se dispara un evento de escalado. Se puede elegir entretres tipos de ajustes posibles:• Change in capacity (Cambio de capacidad): permite aumentar o disminuir la capacidad actual

según el número de instancias especificado. Especifique el valor de ajuste según el número deinstancias que desea añadir o quitar de la flota. Los valores positivos añaden instancias, mientrasque los valores negativos eliminan instancias. Por ejemplo, un valor de "-10" reducirá la flota en 10instancias, independientemente del tamaño total de la flota.

• Percent change in capacity (Cambio porcentual de la capacidad): permite aumentar o disminuir lacapacidad actual según el porcentaje especificado. Especifique el valor de ajuste en función delporcentaje en que desea aumentar o reducir la capacidad de la flota. Los valores positivos añadeninstancias, mientras que los valores negativos eliminan instancias. Por ejemplo, en el caso de unaflota con 50 instancias, un cambio porcentual de "20" añadirá diez instancias a la flota.

• Exact capacity (Capacidad exacta): permite establecer el número de instancias deseado a un valorespecífico. Especifique el valor de ajuste en el número de instancias exacto que desea mantener enla flota.

Consejos para el escalado automático basado en reglas

Las siguientes sugerencias pueden ayudarle a sacar el máximo provecho del escalado automático conpolíticas basadas en reglas.

Utilice varias políticas

Puede emplear varias políticas de escalado automático para una flota al mismo tiempo. La situación máshabitual consiste en tener una política basada en destino que administre la mayoría de las necesidades deescalado y utilizar políticas basadas en reglas para administrar casos extremos. Sin embargo, no existenlímites en cuanto al uso de varias políticas.

Las distintas políticas se comportan de manera independiente. Tenga en cuenta que no se puede controlarla secuencia de eventos de escalado. Por ejemplo, si dispone de varias políticas de incremento de escala,es posible que la actividad de los jugadores dispare varios eventos de escalado de forma simultánea. Porejemplo, los efectos de las dos políticas de incremento de escala se pueden combinar fácilmente si laactividad de los jugadores puede disparar ambas métricas. También debe tener en cuenta las políticas

Version76

Amazon GameLift Developer GuideGuía de integración de flotas de spot

que disparan unas a otras. Por ejemplo, puede crear un bucle infinito si crea políticas de incremento ydescenso de escala que establecen una capacidad superior al umbral de cada una.

Defina una capacidad máxima y mínima

Cada flota tiene una límite de capacidad máxima y mínima. Esta característica es especialmenteimportante cuando se utiliza el escalado automático. El escalado automático nunca definirá un valor dela capacidad que no esté dentro de este rango. De forma predeterminada, las flotas que se acaban decrear tienen un mínimo de 0 y un máximo de 1. Para que la política de escalado automático afecte a lacapacidad según lo previsto, debe aumentar el valor máximo.

La capacidad de la flota también está acotada por los límites del tipo de instancia de la flota y de la cuentade AWS. No puede establecer un valor mínimo y uno máximo que se encuentren fuera de los límites delservicio y de la cuenta.

Realice el seguimiento de las métricas después de un cambio en la capacidad

Después de cambiar la capacidad en respuesta a una política de escalado automático, Amazon GameLiftespera diez minutos antes de responder a los disparadores de dicha política. Esta espera otorga a AmazonGameLift tiempo para añadir instancias nuevas, lanzar los servidores de juego, conectar a los jugadoresy empezar a recopilar datos de las instancias nuevas. Durante este tiempo, Amazon GameLift continúaevaluando la política en función de la métrica y realiza el seguimiento de su periodo de evaluación, quese reinicia en cuanto se dispara un evento de escalado. Esto significa que una política de escalado podríadisparar otro evento de escalado en cuanto acabe el tiempo de espera.

No hay tiempo de espera entre eventos de escalado disparados por diferentes políticas de escaladoautomático.

Guía de integración de flotas de spotAl configurar flotas de recursos de alojamiento, tiene la opción de utilizar tanto instancias de spot comoinstancias bajo demanda. Obtenga más información acerca de cómo Amazon GameLift utiliza lasinstancias de spot en Instancias bajo demanda frente a instancias de spot (p. 56). Si elige utilizar flotasde spot, necesitará realizar algunos ajustes en la integración del juego.

¿Está utilizando FlexMatch para realizar el emparejamiento? Puede utilizar flotas de spot con sus colasexistentes para emparejamiento.

Para configurar los recursos de juego y alojamiento para flotas de spot:

1. Diseñe una cola con una configuración "optimizada para instancias de spot". La administración deluso de la flota con una cola es siempre una práctica recomendada, pero es obligatoria al utilizarinstancias de spot. En este paso, tendrá que identificar las regiones que se van a cubrir en la cola,seleccionar los tipos de instancia adecuados (hardware) de su juego y decidir cómo desea que FleetIQpriorice la ubicación de la sesión de juego. Como práctica recomendada, cada región utilizada en lacola debe tener más de una flota de spot y una flota bajo demanda. Las flotas de spot deben utilizardistintos tipos de instancia, a ser posible, de la misma familia (C4.large, C4.xlarge, etc.). Este diseñoaumenta la resiliencia de los servidores de juegos. Consulte Diseño de una cola para instancias despot (p. 90) para obtener ayuda relacionada con el diseño de una cola optimizada para instanciasde spot.

Una vez que haya creado las flotas para su cola, puede crear la cola, añadir destinos de flota yestablecer las prioridades de flota. Consulte Creación de una cola (p. 92) para obtener ayuda sobrela creación y la configuración de la nueva cola.

2. Cree las flotas para la cola optimizada para instancias de spot. Antes de la creación de la cola,tiene que crear las flotas de la misma. Las flotas de spot y las flotas bajo demanda pueden tener

Version77

Amazon GameLift Developer GuideGuía de integración de flotas de spot

configuraciones idénticas, con la única diferencia de la designación del tipo de flota. Consulte Creaciónde una flota (p. 60) para obtener ayuda sobre la creación y la configuración de flotas.

Note

Le recomendamos que incluya el tipo de flota (spot o bajo demanda) en nombre de la flota.Esto facilitará la identificación de las flotas de spot a simple vista en una lista de nombres deflota como cuando se añaden flotas a una cola.

3. Habilite el cliente de juego o el servicio de cliente de juego para situar las sesiones de juego nuevasutilizando la cola optimizada para instancias de spot. Si todavía no lo está haciendo, actualice elcódigo del cliente de juego para que utilice la ubicación de sesiones de juego mediante una cola enlugar de crear sesiones de juego en una sola flota específica. Al utilizar la cola para situar las sesionesde juego, FleetIQ puede seleccionar la mejor flota disponible según el costo, la tasa de interrupcionesy la latencia de los jugadores. También está proporcionando recursos de alojamiento alternativos encaso de que una flota preferida no se encuentre disponible para su uso temporalmente. Para contribuira la implementación de ubicaciones de sesión de juego en su cliente de juego, consulte Creación desesiones de juego (p. 37).

4. Habilite el servidor de juegos para gestionar una interrupción de spot. Las instancias de spot sepueden interrumpir con una notificación previa de dos minutos cuando AWS necesita recuperar lacapacidad. Conviene que el servidor de juegos gestione una interrupción con fluidez si se produce yque se minimice el impacto sobre los jugadores. Cuando AWS está a punto de reclamar una instanciade spot, envía una notificación de terminación hasta dos minutos antes, que Amazon GameLift pasaa todos los procesos del servidor afectados. Esto se realiza invocando a la función de devoluciónde llamada SDK de servidor onProcessTerminate(). La implementación de esta función dedevolución de llamada es siempre una práctica recomendada, pero es particularmente importantecuando se utilizan instancias de spot. La implementación de esta devolución de llamada puede surtirefecto para finalizar las sesiones de juego con fluidez o buscar una forma de trasladar las sesiones dejuego y los jugadores a una nueva ubicación. Consulte Parada de un proceso del servidor (p. 34) paraobtener ayuda sobre la implementación onProcessTerminate().

Note

AWS hace todo lo posible por proporcionar la notificación en cuanto se haya elegido unainstancia para terminación, pero existe la posibilidad de que las instancias de spot seterminen antes de que llegue la advertencia. Su servidor de juegos debería estar preparadopara gestionar interrupciones imprevistas.

5. Evaluar el rendimiento de las colas y las flotas de spot. Una vez que la nueva cola está ubicandoactivamente nuevas sesiones de juego, utilice las métricas de Amazon GameLift para evaluar elrendimiento. Entre las métricas principales se incluyen:

• Tasa de interrupción: realiza un seguimiento del número y frecuencia de las interrupcionesrelacionadas con spot para instancias y sesiones de juego en una flota de spot. Estas métricasde flota (InstanceInterruptions y GameSessionInterruptions) pueden visualizarseen la consola de Amazon GameLift o mediante Amazon CloudWatch (consulte Métricas deAmazon GameLift para flotas (p. 138)). Si agrega las métricas de flota en un grupo de métricas,también puede ver las interrupciones por tipo de instancia y sistema operativo en CloudWatch.Las sesiones de juego que se terminaron por motivos relacionados con spot tienen un estado de"TERMINATED" (terminado) y una razón para el estado de "INTERRUPTED" (interrumpida).

• Eficacia de la cola: realiza un seguimiento de las métricas de sus colas, incluida la ubicación detasas de éxito, tiempo de espera promedio y profundidad de cola para verificar que el uso de lasflotas de spot no tiene ningún impacto en el rendimiento de la cola. Las métricas de cola puedenvisualizarse en la consola de Amazon GameLift o mediante Amazon CloudWatch.

• Utilización de flota: monitorice las tasas de uso de sus flotas, incluidos los datos sobre instancias,sesiones de juego y sesiones de jugadores. El uso de las flotas bajo demanda puede ser unindicador de que FleetIQ está optando por evitar ubicaciones arriesgadas en flotas de spot y estárecurriendo a las flotas bajo demanda. Las métricas de utilización de flota pueden visualizarse en laconsola de Amazon GameLift o mediante Amazon CloudWatch.

Version78

Amazon GameLift Developer GuideAcceso remoto a instancias de una flota

Acceso remoto a instancias de una flotaPuede acceder de forma remota a cualquier instancia de la flota que se ejecute actualmente en una flotade Amazon GameLift. Esta acción resulta útil para la resolución de los problemas de activación de laflota. También puede utilizar esta característica para obtener la actividad del servidor de juegos en tiemporeal, como, por ejemplo, realizar un seguimiento de las actualizaciones de log o ejecutar herramientas deanálisis comparativos utilizando el tráfico de jugadores real.

Al acceder de forma remota a instancias de Amazon GameLift, tenga en cuenta lo siguiente:

• El servicio Amazon GameLift continúa administrando la actividad y la capacidad de la flota. Estableceruna conexión remota a una instancia no afecta a la forma en que Amazon GameLift la administra. Comoresultado, la instancia sigue ejecutando la configuración de tiempo de ejecución de la flota, detiene yarranca procesos del servidor, crea y termina sesiones de juego y permite conexiones de jugadores.Además, el servicio Amazon GameLift puede terminar la instancia en cualquier momento como parte deun evento de reducción de escala.

• Realizar cambios locales en una instancia que aloja sesiones de juego activas y tiene jugadoresconectados en directo puede afectar de forma significativa a la experiencia de los jugadores. Porejemplo, los cambios locales podrían desconectar a jugadores individuales, bloquear sesiones de juegoo incluso cerrar toda la instancia afectando a múltiples sesiones de juego y a jugadores.

Para obtener más información acerca de cómo se implementan y gestionan juegos en instancias AmazonGameLift, consulte los siguientes temas:

• Funcionamiento de Amazon GameLift (p. 2)• Problemas al crear una flota de depuración (p. 65)• Modo en que una flota administra varios procesos (p. 58)

Conexión a una instanciaPuede acceder a las instancias remotas que se ejecuten en Windows o Linux. Para conectarse a unainstancia Windows, utilice un cliente de protocolo de escritorio remoto (RDP). Para conectarse a unainstancia Linux, utilice un cliente SSH.

Utilice la AWS CLI para obtener la información que necesita para acceder a una instancia remota. Paraobtener ayuda, consulte la referencia de comandos de AWS CLI. Si todavía no ha instalado la AWSCLI, consulte el tema Instalar la AWS CLI (p. 20). También puede utilizar el SDK de AWS, junto con ladocumentación disponible en la Referencia de la API del servicio Amazon GameLift.

1. Busque el ID de la instancia a la que desea conectarse. Al solicitar acceso, deberá especificar unID de instancia. Utilice el comando describe-instances de la CLI de AWS (o la llamada a la APIDescribeInstances) con un ID de flota para obtener información sobre todas las instancias de esa flota.Para obtener ayuda, como solicitudes y respuestas de ejemplo, consulte las guías de referencia de laCLI o la API.

2. Solicite credenciales de acceso para la instancia. Una vez que tenga un ID de instancia, utilice elcomando get-instance-access (o la llamada a la API GetInstanceAccess) para solicitar credencialesde acceso y otra información. Para obtener ayuda, como solicitudes y respuestas de ejemplo, consultelas guías de referencia de la CLI o la API. Si funciona correctamente, Amazon GameLift devuelve elsistema operativo, la dirección IP y un conjunto de credenciales (nombre de usuario y clave secreta)de la instancia. El formato de las credenciales depende del sistema operativo de la instancia. Siga lassiguientes instrucciones para recuperar las credenciales para RDP o SSH.

Version79



https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-instances.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeInstances.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/get-instance-access.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_GetInstanceAccess.html

Amazon GameLift Developer GuideConexión a una instancia

• Para instancias Windows: para conectarse a una instancia Windows, RDP requiere un nombre deusuario y una contraseña. La solicitud get-instance-access devuelve estos valores en forma decadenas simples, por lo que puede utilizar los valores devueltos tal cual. Credenciales de ejemplo:

"Credentials": { "Secret": "aA1bBB2cCCd3EEE", "UserName": "gl-user-remote"}

• Para instancias Linux: para conectarse a una instancia Linux, SSH requiere un nombre de usuarioy una clave privada. Amazon GameLift emite claves privadas RSA y las devuelve en forma de unaúnica cadena, con el carácter de nueva línea (\n) marcando saltos de línea. Para que se puedautiliza la clave privada, (1) debe convertir la cadena en un archivo .pem y (2) establecer permisospara el archivo nuevo. Credenciales de ejemplo devueltas:

"Credentials": { "Secret": "-----BEGIN RSA PRIVATE KEY-----nEXAMPLEKEYKCAQEAy7WZhaDsrA1W3mRlQtvhwyORRX8gnxgDAfRt/gx42kWXsT4rXE/b5CpSgie/\nvBoU7jLxx92pNHoFnByP+Dc21eyyz6CvjTmWA0JwfWiW5/akH7iO5dSrvC7dQkW2duV5QuUdE0QW\nZ/aNxMniGQE6XAgfwlnXVBwrerrQo+ZWQeqiUwwMkuEbLeJFLhMCvYURpUMSC1oehm449ilx9X1F\nG50TCFeOzfl8dqqCP6GzbPaIjiU19xX/azOR9V+tpUOzEL+wmXnZt3/nHPQ5xvD2OJH67km6SuPW\noPzev/D8V+x4+bHthfSjR9Y7DvQFjfBVwHXigBdtZcU2/wei8D/HYwIDAQABAoIBAGZ1kaEvnrqu\n/uler7vgIn5m7lN5LKw4hJLAIW6tUT/fzvtcHK0SkbQCQXuriHmQ2MQyJX/0kn2NfjLV/ufGxbL1\nmb5qwMGUnEpJaZD6QSSs3kICLwWUYUiGfc0uiSbmJoap/GTLU0W5Mfcv36PaBUNy5p53V6G7hXb2\nbahyWyJNfjLe4M86yd2YK3V2CmK+X/BOsShnJ36+hjrXPPWmV3N9zEmCdJjA+K15DYmhm/tJWSD9\n81oGk9TopEp7CkIfatEATyyZiVqoRq6k64iuM9JkA3OzdXzMQexXVJ1TLZVEH0E7bhlY9d8O1ozR\noQs/FiZNAx2iijCWyv0lpjE73+kCgYEA9mZtyhkHkFDpwrSM1APaL8oNAbbjwEy7Z5Mqfql+lIp1\nYkriL0DbLXlvRAH+yHPRit2hHOjtUNZh4Axv+cpg09qbUI3+43eEy24B7G/Uh+GTfbjsXsOxQx/x\np9otyVwc7hsQ5TA5PZb+mvkJ5OBEKzet9XcKwONBYELGhnEPe7cCgYEA06Vgov6YHleHui9kHuws\nayav0elc5zkxjF9nfHFJRry21R1trw2Vdpn+9g481URrpzWVOEihvm+xTtmaZlSp//lkq75XDwnU\nWA8gkn6O3QE3fq2yN98BURsAKdJfJ5RL1HvGQvTe10HLYYXpJnEkHv+Unl2ajLivWUt5pbBrKbUC\ngYBjbO+OZk0sCcpZ29sbzjYjpIddErySIyRX5gV2uNQwAjLdp9PfN295yQ+BxMBXiIycWVQiw0bH\noMo7yykABY7Ozd5wQewBQ4AdSlWSX4nGDtsiFxWiI5sKuAAeOCbTosy1s8w8fxoJ5Tz1sdoxNeGs\nArq6Wv/G16zQuAE9zK9vvwKBgF+09VI/1wJBirsDGz9whVWfFPrTkJNvJZzYt69qezxlsjgFKshy\nWBhd4xHZtmCqpBPlAymEjr/TOlbxyARmXMnIOWIAnNXMGB4KGSyl1mzSVAoQ+fqR+cJ3d0dyPl1j\njjb0Ed/NY8frlNDxAVHE8BSkdsx2f6ELEyBKJSRr9snRAoGAMrTwYneXzvTskF/S5Fyu0iOegLDa\nNWUH38v/nDCgEpIXD5Hn3qAEcju1IjmbwlvtW+nY2jVhv7UGd8MjwUTNGItdb6nsYqM2asrnF3qS\nVRkAKKKYeGjkpUfVTrW0YFjXkfcrR/V+QFL5OndHAKJXjW7a4ejJLncTzmZSpYzwApc=\n-----END RSA PRIVATE KEY-----", "UserName": "gl-user-remote"}

Si utiliza la CLI de AWS, puede generar automáticamente un archivo .pem con el formato correctoincluyendo los parámetros --query y --output en la solicitud get-instance-access.

Para establecer permisos en el nuevo archivo .pem, ejecute el siguiente comando:

$ chmod 400 MyPrivateKey.pem

3. Abra un puerto para la conexión remota. Solo se puede acceder a las instancias en flotas de AmazonGameLift a través de los puertos autorizados en la configuración de la flota. Puede ver la configuraciónde los puertos de la flota mediante el comando describe-fleet-port-settings.

Recomendamos abrir los puertos para el acceso remoto solo cuando se necesiten y cerrarlos cuandohaya terminado. Utilice el comando update-fleet-port-settings para añadir una configuraciónde puerto para la conexión remota (como 22 para SSH o 3389 para RDP). Para el valor del rango deIP, especifique las direcciones IP de los dispositivos que desea utilizar para conectarse (convertidos alformato CIDR). Ejemplo:

Version80

https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-fleet-port-settings.html


Amazon GameLift Developer GuideVisualización y actualización de instancias remotas

$ aws gamelift update-fleet-port-settings --fleet-id "fleet-2222bbbb-33cc-44dd-55ee-6666ffff77aa" --inbound-permission-authorizations "FromPort=22,ToPort=22,IpRange=54.186.139.221/32,Protocol=TCP"

4. Abra un cliente de conexión remoto. Utilice el escritorio remoto para Windows o SSH para instanciasLinux. Conéctese a la instancia a través de la dirección IP, la configuración del puerto y lascredenciales de acceso.

Ejemplo de SSH:

ssh -i MyPrivateKey.pem [email protected]

Visualización y actualización de instancias remotasAl conectarse a una instancia de forma remota, dispone de acceso administrativo y de usuario pleno. Estosignifica que también tendrá la capacidad de provocar errores y fallos al alojar juegos. Si la instancia alojajuegos con jugadores activos, existe el riesgo de que bloquee sesiones de juego y desconecte a jugadores,así como de interrumpir los procesos de cierre de juegos y provocar errores en los datos y los logs dejuego guardados.

Los recursos de alojamiento en una instancia se encuentra en las siguientes ubicaciones:

• Archivos de compilación de juegos. Estos son los archivos incluidos en la compilación del juego queha cargado en Amazon GameLift. Incluyen uno o más ejecutables del servidor de juegos, activos ydependencias. Estos archivos se encuentran en un directorio raíz llamado game:• En Windows: c:\game• En Linux: /local/game

• Archivos de log de juegos. Los archivos de log que genera el servidor de juegos se almacenan en eldirectorio raíz game en la ruta de directorio que haya especificado.

• Recursos de alojamiento de Amazon GameLift. Los archivos que utiliza el servicio Amazon GameLiftpara administrar el alojamiento de juegos se encuentran en un directorio raíz llamado Whitewater.Estos archivos no deben modificarse por ningún motivo.

• Configuración de tiempos de ejecución. La configuración de tiempos de ejecución de la flota no esaccesible para instancias individuales. Para probar los cambios realizados en una configuración detiempo de ejecución (ruta de lanzamiento, parámetros de lanzamiento, número máximo de procesossimultáneos), debe actualizar la configuración de tiempo de ejecución de toda la flota (consulte la accióndel SDK de AWS UpdateRuntimeConfiguration o la AWS CLI update-runtime-configuration).

Configuración de la interconexión de VPCUtilice las interconexiones de Amazon Virtual Private Cloud (VPC) para permitir que sus servidoresde juegos se comuniquen directamente y de forma privada con otros de sus recursos de AWS, comoun servicio web o un repositorio. En este tema se ofrecen directrices sobre cómo configurar unainterconexión entre la VPC de sus servidores de juegos de Amazon GameLift y una VPC de recursosque no pertenezcan a Amazon GameLift. Para obtener más información acerca del funcionamientode la interconexión de VPC con Amazon GameLift, consulte Conectividad de red con los recursos deAWS (p. 6).

Si ya está familiarizado con Amazon VPC y la interconexión de VPC, tenga en cuenta que la configuraciónde la interconexión con los servidores de juegos de Amazon GameLift es algo distinta. Dado que no tiene

Version81

https://docs.aws.amazon.com/gamelift/latest/apireference/API_UpdateRuntimeConfiguration.html


Amazon GameLift Developer GuideConfiguración de la interconexión de VPC

acceso a la VPC de los procesos del servidor de juegos (que se controla mediante el servicio AmazonGameLift), no puede crear una solicitud de interconexión de VPC para ella. En lugar de ello, primero debepreautorizar a una VPC de recursos que no pertenezcan a Amazon GameLift para que acepte una solicitudde interconexión procedente de Amazon GameLift. A continuación, debe hacer que Amazon GameLiftsolicite la interconexión de VPC que acaba de autorizar. Amazon GameLift automáticamente crea lainterconexión, configura las tablas de ruteo y configura la conexión según sea necesario.

Para configurar una interconexión de VPC:

1. Obtenga los identificadores de cada VPC.

Obtenga la siguiente información para las dos VPC que se van a interconectar:

• VPC de los servidores de juegos de Amazon GameLift: los procesos del servidor de juegosse implementan en Amazon GameLift como una flota de instancias EC2. Cada flota se sitúaautomáticamente en su propia VPC, que se administra mediante el servicio Amazon GameLift.Dado que no tiene acceso a la VPC de los procesos del servidor de juegos, debe identificar la VPCmediante su flota asociada. Para identificar el conjunto de procesos del servidor de juegos para elque desea establecer una interconexión de VPC, necesita el ID de flota de Amazon GameLift.

• VPC para los recursos de AWS que no pertenecen a Amazon GameLift: puede establecer unainterconexión de VPC con cualquier recurso que se ejecute en AWS y se administre mediante unacuenta de AWS a la que tenga acceso. Si todavía no ha creado una VPC para estos recursos,consulte Introducción a Amazon VPC para saber cómo crear una VPC y añadir recursos en ella.Una vez que haya creado una VPC, puede encontrar el ID de la VPC iniciando sesión en la Consolade administración de AWS para Amazon VPC y consultando las VPC.

Note

Cuando se solicita una interconexión, las dos VPC deben existir en la misma región. La VPCde los procesos del servidor de juegos de la flota de Amazon GameLift está en la mismaregión que la flota.

2. Obtenga los ID de cuenta de AWS y las credenciales.

Necesita un ID y credenciales de inicio de sesión para las dos cuentas siguientes de AWS. Puedeencontrar los ID de cuenta de AWS iniciando sesión en la Consola de administración de AWS y viendola configuración de su cuenta. Para obtener las credenciales, vaya a la consola de IAM.

• Cuenta de AWS que se utiliza para administrar sus servidores de juegos de Amazon GameLift.• Cuenta de AWS que se utiliza para administrar sus recursos que no pertenecen a Amazon

GameLift.

Si utiliza la misma cuenta para recursos que pertenecen a Amazon GameLift y recursos que nopertenecen a Amazon GameLift, solo necesitará el ID y las credenciales de esa cuenta.

3. Autorice una interconexión de VPC con los recursos que no pertenecen a Amazon GameLift.

En este paso, va a aceptar una futura solicitud de interconexión desde Amazon GameLift con la VPCde los recursos que no pertenecen a Amazon GameLift. Para esta acción, utilice las credenciales de lacuenta que administra los recursos que no pertenecen a Amazon GameLift.

Para autorizar la interconexión de VPC, llame a la API CreateVpcPeeringAuthorization() del servicioAmazon GameLift o utilice el comando create-vpc-peering-authorization de la CLI de AWS.Proporcione la siguiente información:

• ID de la VPC de interconexión: es la VPC de los recursos que no pertenecen a Amazon GameLift.• ID de la cuenta de AWS de Amazon GameLift: es la cuenta que se utiliza para gestionar la flota de

Amazon GameLift.

Version82

https://docs.aws.amazon.com/vpc/latest/userguide/getting-started-ipv4.html

https://console.aws.amazon.com/





Una vez que haya autorizado la interconexión de VPC, la autorización sigue siendo válida durante 24horas, a menos que revoque. Puede administrar las autorizaciones de interconexión de VPC mediantelas siguientes operaciones:

• DescribeVpcPeeringAuthorizations() (describe-vpc-peering-authorizations en la CLI deAWS).

• DeleteVpcPeeringAuthorization() (delete-vpc-peering-authorization en la CLI de AWS).4. Solicite una interconexión entre la VPC de una flota de Amazon GameLift y la de los recursos que no

pertenecen a Amazon GameLift.

Una vez que tenga una autorización válida para una interconexión de VPC, puede indicar a AmazonGameLift que solicite la interconexión. Para esta acción, utilice las credenciales de la cuenta queadministra los servidores de juegos de Amazon GameLift.

Para solicitar la interconexión de VPC, llame a la API CreateVpcPeeringConnection() del servicioAmazon GameLift o utilice el comando create-vpc-peering-connection de la CLI de AWS.Proporcione la siguiente información, que identifica las dos VPC que se van a interconectar:

• ID de la VPC de interconexión e ID de la cuenta de AWS: es la VPC de los recursos que nopertenecen a Amazon GameLift y la cuenta que utiliza para la administrarlos. El ID de la VPC debecoincidir con uno de una autorización válida.

• ID de la flota: identifica la VPC de los procesos del servidor de juegos de Amazon GameLift.

Puede administrar las interconexiones de VPC mediante las siguientes operaciones:

• DescribeVpcPeeringConnections() (describe-vpc-peering-connections en la CLI de AWS).• DeleteVpcPeeringConnection() (delete-vpc-peering-connection en la CLI de AWS).

Puede solicitar una interconexión de VPC al crear una flota. Para obtener más información, consulteCreación de una conexión de flotas y una interconexión de VPC (p. 63).

5. Haga un seguimiento de sus interconexiones de VPC.

La solicitud de una interconexión de VPC es una operación asíncrona. Para realizar el seguimientodel estado de una solicitud de interconexión y gestionar los casos de éxito o error, utilice una de lassiguientes opciones:

• Sondee continuamente con DescribeVpcPeeringConnections(). Esta operación recuperael registro de la interconexión de VPC, incluido el estado de la solicitud. Si se crea correctamenteuna interconexión, el registro de conexión también contiene un bloque de CIDR de direcciones IPprivadas que se asigna a la VPC.

• Gestione los eventos de flota asociados a las inconexiones de VPC con DescribeFleetEvents(),incluidos los eventos de éxito y de error.

Motivos habituales por los que falla una solicitud de conexión:

• No se ha encontrado una autorización para la conexión solicitada. Esto puede significar queuna autorización existente ya no es válida o que nunca ha existido. Una causa común para esteproblema es una mezcla de regiones. Compruebe que la autorización y la solicitud están utilizandola misma región.

• Bloques de CIDR solapados (consulte Configuraciones de interconexión de VPC noválidas). Los bloques de CIDR IPv4 asignados a las VPC interconectadas no puedensolaparse. El bloque de CIDR de la VPC de la flota de Amazon GameLift se asignaautomáticamente y no puede modificarse. Puede consultar este bloque de CIDR llamando a

Version83

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeVpcPeeringAuthorizations.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DeleteVpcPeeringAuthorization.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreateVpcPeeringConnection.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeVpcPeeringConnections.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DeleteVpcPeeringConnection.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeFleetEvents.html

https://docs.aws.amazon.com/vpc/latest/peering/invalid-peering-configurations.html#overlapping-cidr

https://docs.aws.amazon.com/vpc/latest/peering/invalid-peering-configurations.html#overlapping-cidr


DescribeVpcPeeringConnections(). Para resolver este problema, deberá cambiar el bloquede CIDR de la VPC de los recursos que no pertenecen a Amazon GameLift a un rango que no sesolape.

• La flota no se ha activado. Si solicitó una interconexión de VPC como parte de una solicitudCreateFleet(), es posible que la flota nueva no haya llegado al estado Active. En este caso, lainterconexión no puede realizarse.

Version84

Amazon GameLift Developer GuideCreación de un alias

Uso de aliasAmazon GameLift emplea el término alias para referirse al redireccionamiento de sesiones de jugadorhacia una flota específica. Puede utilizar alias para dirigir las sesiones de jugador hacia flotas con las querealiza pruebas de lanzamiento o para respaldar diferentes sesiones de juego de cliente.

Amazon GameLift utiliza el término alias para referirse al redireccionamiento de la conexión entre una flotay los jugadores. Puede decidir qué flota debe resolverse con un alias y también puede incrustar el ID delalias en el cliente de juego para controlar el flujo de jugadores hacia la flota designada.

Existen dos tipos de estrategias de enrutamiento para alias:

• Simple: un alias simple redirige el tráfico de jugadores hacia la flota asociada. Puede actualizar la flotaresuelta por el alias en cualquier momento.

• Terminal: un alias terminal no puede resolver una flota. En su lugar, transmite un mensaje al cliente.Por ejemplo, puede indicar a los jugadores que actualicen sus versiones de cliente de juego si intentanconectarse a una flota que ya no es compatible.

Creación de un aliasPuede crear un alias nuevo para resolverlo en una flota.

Para crear un alias nuevo

1. Abra la consola de Amazon GameLift en https://console.aws.amazon.com/gamelift/.2. En la barra de menús, elija Aliases.3. En la página Aliases, haga clic en Create alias.4. En la página Create alias, en la sección Alias details, haga lo siguiente:

• Alias name: escriba un nombre sencillo que le permita identificar fácilmente el alias en el catálogo.• Description: (opcional) escriba una descripción breve del alias para identificarlo aún más.

5. En la sección Routing options, para Type, elija Simple o Terminal:

• Si elige Simple, seleccione una flota disponible para asociarla con el alias. Un alias simple redirige eltráfico de jugadores hacia la flota asociada.

• Si selecciona Terminal, escriba un mensaje que luego se mostrará a los jugadores. Un alias terminalno se resuelve en una flota, sino que solo pasa el mensaje al cliente.

6. Haga clic en Configure alias.

Edición de un aliasUtilice la página Edit alias en la consola de Amazon GameLift para actualizar la información de su alias.

Para editar un alias

1. Abra la consola de Amazon GameLift en https://console.aws.amazon.com/gamelift/.2. En la barra de menús, elija Aliases.3. En la página Aliases, haga clic en el nombre del alias que desea editar.

Version85



Amazon GameLift Developer GuideEdición de un alias

4. En la página del alias seleccionado, bajo Actions, seleccione Edit alias.5. En la página Edit alias, puede editar los siguientes campos:

• Alias name: es el nombre sencillo del alias.• Description: es una descripción breve del alias.• Type: es la estrategia de enrutamiento del tráfico de jugadores. Seleccione Simple para cambiar la

flota asociada o seleccione Terminal para editar el mensaje de terminación.6. Haga clic en Submit.

Version86

Amazon GameLift Developer GuideDiseño de colas

Uso de colasAmazon GameLift utiliza las colas para colocar sesiones de juego nuevas de forma eficaz en cualquierflota de un grupo de flotas que puede abarcar varias regiones. Cuando un cliente de juego o un servicio dejuego solicita una sesión de juego nueva, especifica una cola para procesar la solicitud. Una cuenta puedetener varias colas. Utilice la AWS Command Line Interface (CLI) o la consola de Amazon GameLift paracrear, editar o realizar el seguimiento de las métricas de una cola.

Temas• Diseño de colas de sesiones de juego (p. 87)• Creación de una cola (p. 92)• Visualización de las colas (p. 95)• Visualización de los detalles de la cola (p. 96)

Diseño de colas de sesiones de juegoAmazon GameLift utiliza colas para procesar las solicitudes de las ubicaciones de sesiones de juego ypara encontrar recursos de alojamiento disponibles para las nuevas sesiones de juego. El diseño de lacola determina (1) dónde busca Amazon GameLift los recursos disponibles y (2) cómo evalúa AmazonGameLift los recursos disponibles para encontrar la opción más idónea para cada nueva sesión de juego.Utilice colas para ofrecer la mejor experiencia posible a los jugadores y para asegurarse de que losrecursos de alojamiento por los que paga se utilizan de forma eficaz.

Las colas son necesarias para estas características de Amazon GameLift:

• Emparejamiento con FlexMatch (consulte Diseño de un creador de emparejamientos deFlexMatch (p. 98))

• Flotas de spot (consulte Guía de integración de flotas de spot (p. 77))

Para obtener más información sobre las colas, consulte the section called “Ubicación de sesionesde juego” (p. 3). Para obtener información sobre cómo crear una cola, consulte Creación de unacola (p. 92). Para obtener información sobre cómo crear sesiones de juego nuevas mediante colas,consulte Creación de sesiones de juego (p. 37).

¿Por qué conviene usar las colas?Recomendamos encarecidamente utilizar colas para la ubicación de sesiones de juego, incluso si no seutiliza una característica de Amazon GameLift que las necesite. Aunque siempre existe la posibilidad decrear manualmente una sesión de juego en una flota específica (mediante CreateGameSession), las colas,especialmente las que abarcan varias regiones, pueden ofrecer beneficios importantes para usted y paralos jugadores.

• Minimización de la latencia para una mejor experiencia de los jugadores. Cuando una solicitud deubicación de sesiones de juego incluye los datos de latencia de los jugadores, la característica FleetIQse asegura de que los jugadores tengan la menor latencia posible en el servidor de juegos. Establezcareglas adicionales para minimizar las diferencias de latencia entre los jugadores y para encontrarun equilibrio entre incorporar a los jugadores a los juegos con rapidez y proporcionarles la mejorexperiencia de juego posible.

Version87



Amazon GameLift Developer GuideConsejos sobre la configuración de destinos de las colas

• Aprovechamiento de flotas de spot más económicas. Puede añadir flotas de spot, que ofrecen costos dealojamiento significativamente menores, a una cola en cualquier momento. Cuando hay flotas de spotdisponibles, FleetIQ sitúa las sesiones de juego nuevas en las flotas que tienen la menor latencia posibley el menor precio de spot.

• Colocación más rápida de los juegos nuevos con alta capacidad. Una sola flota tiene una capacidadlimitada y, una vez que se alcanza el límite de jugadores, estos deben esperar hasta que se aumenteel número de instancias para poder iniciar sesiones de juego nuevas. Sin embargo, una cola puederealizar inmediatamente ubicaciones en otras flotas si la flota preferida está llena. Además, con elescalado automático, cada flota de la cola aumenta su tamaño a medida que se acerca a su capacidadmáxima, por lo que es improbable que todas las flotas de una cola se llenen al mismo tiempo. Comoconsecuencia, el tiempo de espera de los jugadores se ve menos afectado cuando se producenaumentos de la demanda de jugadores.

• Aumento de la resiliencia de la disponibilidad de los juegos. Pueden producirse interrupciones en elnivel de flota y en el de región. Cuando se utiliza una cola de varias regiones, una ralentización o unainterrupción no tiene por qué afectar al acceso de los jugadores al juego. En su lugar, si una o variasflotas preferidas no están disponibles, Amazon GameLift puede colocar las sesiones de juego nuevas enla siguiente mejor flota. El escalado automático se ajusta a este cambio temporal en la actividad de lasflotas hasta que las flotas preferidas vuelvan a estar disponibles.

• Uso más eficaz de la capacidad adicional de las flotas. Para hacer frente a aumentos inesperados en lademanda de jugadores, tiene sentido tener acceso rápido a capacidad de alojamiento adicional. Cuandose depende de una sola flota para proporcionar acceso a un juego a los jugadores, se debe mantenercapacidad no utilizada por si fuera necesaria. Por el contrario, las flotas de una cola pueden utilizarsesucesivamente, desplazando el aumento de la demanda de jugadores a las flotas menos utilizadasde otras regiones cuando sea necesario. Por ejemplo, cuando la demanda es alta en Asia, suele serbaja en Europa; las flotas europeas pueden proporcionar capacidad adicional para atender los picos dedemanda en Asia, incluso cuando se han reducido durante periodos de baja demanda.

• Obtención de métricas de las ubicaciones de sesiones de juego y del desempeño de las colas. AmazonGameLift emite métricas específicas de las colas, que incluyen estadísticas sobre éxitos y errores deubicación, el número de solicitudes en la cola y el tiempo medio que las solicitudes pasan en la cola.Puede ver estas métricas en la consola de Amazon GameLift o en CloudWatch.

Consejos sobre la configuración de destinos de lascolasUna cola contiene una lista de destinos donde se pueden atender solicitudes de ubicación de sesionesde juego. En la mayoría de los casos un destino es una flota, que se puede especificar mediante un ID deflota o ID de alias. Cuando elija destinos para la cola, tenga en cuenta las siguientes directrices y prácticasrecomendadas:

• Puede añadir cualquier flota o alias existente de cualquier región. Añada una flota en cada una delas regiones en las que desee admitir jugadores, especialmente si está utilizando la latencia de losjugadores para ubicarlos.

• Si asigna alias a las flotas (tal y como se recomienda), conviene que utilice los nombres de alias cuandoconfigure los destinos en la cola.

• Todos los destinos de una cola tienen que ejecutar compilaciones de juegos compatibles con los clientesde juego que utilizan la cola. Tenga en cuenta que se pueden colocar solicitudes de sesiones de juegonuevas procesadas por la cola en cualquier destino de la cola.

• Una cola debe tener al menos dos flotas y abarcar dos regiones como mínimo. Este diseño mejora laresiliencia del alojamiento al reducir el impacto de las ralentizaciones de flota o regionales y administrarde manera más eficiente los cambios inesperados en la demanda de los jugadores.

• El orden de la lista de destinos en una cola es importante. Si se incluyen los datos de latencia enuna solicitud de ubicación de sesión de juego, Amazon GameLift vuelve a priorizar los destinos paraencontrar recursos disponibles con (1) la latencia mínima para el jugador y (2) el precio de spot más bajo

Version88

Amazon GameLift Developer GuideDiseño de una cola de varias regiones

(si procede). Si no se proporcionan los datos de latencia, Amazon GameLift sigue el orden de lista dedestinos. En este caso, las sesiones de juego normalmente se alojarán en la primera flota de la lista, ysolo se situarán en las flotas de respaldo cuando sea necesario.

• Debe decidir donde se debe crear la cola (en qué región). Lo ideal es que las solicitudes de ubicación desesiones de juego se realicen a través de un servicio de cliente de juego, como por ejemplo, un serviciode directorio de sesiones. Si es así, recomendamos que se cree la cola en una región geográficamentecercana al lugar en el que se haya implementado el servicio de cliente. Esta disposición minimiza lalatencia al enviar solicitudes de ubicación de sesiones de juego.

Diseño de una cola de varias regionesSe recomienda utilizar un diseño de varias regiones para todas las colas, independientemente de que seutilicen o no características especiales, como las flotas de spot o el emparejamiento de FlexMatch. Estediseño puede mejorar la velocidad de ubicación y la resiliencia de alojamiento, y es fundamental cuando setrabaja con los datos de latencia de los jugadores.

En este tema se detallan los pasos del proceso de diseño de una cola básica de varias regiones. En esteejemplo, utilizaremos una compilación del servidor de juegos que queremos distribuir a los jugadores de lacosta este de Norteamérica. Hemos decidido alojar nuestro juego en las siguientes regiones: us-east-1 yca-central-1. Hemos cargado la compilación del juego y hemos creado una flota en cada región.

1. Elegir una región en la que crear la cola. La ubicación de nuestra cola puede que no tenga importancia,pero si estamos realizando solicitudes de ubicación a través de un servicio de cliente, podemosminimizar latencia de las solicitudes colocando la cola en una región cercana al lugar en el que se haimplementado el servicio de cliente.

2. Crear una cola nueva y añadir nuestras flotas como destinos de la cola.3. Decidir el orden predeterminado de la lista de destinos. GameLift puede evaluar las flotas en este orden

al buscar los recursos de alojamiento disponibles. Si una solicitud de ubicación contiene los datos delatencia de los jugadores, Amazon GameLift reordena nuestros destinos para dar prioridad a los quetienen la latencia más baja. Si no se proporcionan los datos de latencia, Amazon GameLift utiliza elorden predeterminado.• Si esperamos recibir muchas solicitudes sin datos de latencia, deberemos prestar más atención al

orden de lista predeterminado y a las flotas que situamos primero. Cuando no disponga de datos delatencia, Amazon GameLift siempre colocará las sesiones de juego nuevas en la primera flota queaparezca en la lista cuando esté disponible, y solo utilizará las flotas restantes como respaldo. Porello, debemos situar en el primer puesto una flota (1) que sea lo suficientemente potente como paragestionar la mayor parte de nuestra base de jugadores y (2) que ofrezca la mayor disponibilidad y lamenor latencia posibles a la mayoría de nuestros jugadores.

En este caso, esperamos que la flota us-east-1 servirá mejor a la mayoría de nuestros jugadores,por lo que elegimos un tipo de instancia de alto desempeño, lo configuramos para múltiples sesionesde juego simultáneas, lo escalamos para un alto volumen de jugadores y lo colocamos en primeraposición en nuestra cola. Nuestra flota ca-central-1 de reserva utiliza un tipo de instancia máspequeño y menos costoso, y mantiene una capacidad mínima. Las flotas de reserva adicionales (si seañaden) no es necesario que estén ordenadas, pero podríamos dar menos prioridad a las regionesque probablemente tengan tasas de latencia más altas.

• Si esperamos que la mayoría de las solicitudes tengan datos de latencia, el orden de la lista es menosimportante porque FleetIQ volverá a establecer las prioridades. Nos conviene tener flotas en todas lasregiones cercanas a nuestros jugadores objetivo para minimizar la tasa de latencia. Por lo general,queremos flotas que estén configuradas para gestionar la demanda esperada de jugadores. Nosconviene asegurarnos de que la flota situada en el primer lugar es una buena opción para atender lassolicitudes que no tienen datos de latencia.

En esta situación, esperamos que las flotas us-east-1 y ca-central-1 proporcionen tasas delatencias bajas y se utilicen mucho. Ambas flotas utilizan tipos de instancia de alto desempeño y están

Version89

Amazon GameLift Developer GuideDiseño de las políticas de latencia de los jugadores

configuradas para múltiples sesiones de juego simultáneas. La demanda de la flota ca-central-1será algo menor, por lo que mantendrá una capacidad inferior.

A medida que nuestra cola se ponga en marcha, podemos utilizar los datos de las métricas paradeterminar cómo se comporta el diseño. Las colas nos permiten realizar cambios en las flotas según seanecesario, ya sea reconfigurando las flotas existentes o eliminando y añadiendo flotas nuevas que seadapten mejor a nuestras necesidades de alojamiento.

Diseño de las políticas de latencia de los jugadoresSi las solicitudes de ubicación de sesiones de juego incluyen datos de latencia de los jugadores, AmazonGameLift utiliza FleetIQ para asegurarse de que los jugadores se sitúan en las sesiones de juego con lamenor latencia posible. FleetIQ prioriza los destinos de una cola basándose en la latencia regional mediade todos los jugadores de la solicitud.

Puede configurar políticas de latencia de los jugadores para determinar cómo utiliza Amazon GameLift losdatos de latencia de los jugadores. Puede configurar políticas de latencia de los jugadores para:

• Establecer la latencia máxima para cada jugador. De forma predeterminada, Amazon GameLift sitúa lassesiones de juego en función de la latencia media de todos los jugadores de la solicitud. Esta políticagarantiza que una sesión de juego no se sitúe en una ubicación en la que cualquier jugador supere lalatencia máxima.

• Utilizar varias políticas para relajar la latencia máxima con el paso del tiempo. Establecer una latenciamáxima protege a los jugadores de los juegos de alta latencia, pero también aumenta el riesgo de queuna solicitud de sesión de juego con valores de latencia altos nunca se atienda. Puede utilizar una seriede políticas para aumentar gradualmente la latencia máxima con el paso del tiempo. Utilice este enfoquepara equilibrar la forma en que proporciona experiencias de juego increíbles con la reducción al mínimodel tiempo de espera de los jugadores para iniciar los juegos.

Por ejemplo, puede definir las siguientes políticas para una cola con un tiempo de espera de 5 minutos.Varias políticas se ejecutan de forma consecutiva, empezando por la política con la latencia máxima másbaja. Este conjunto de políticas comienza con una latencia máxima de 50 milisegundos y la aumenta conel paso del tiempo a 200 milisegundos. La última política establece la latencia máxima absoluta permitidapara cualquier jugador. Si desea asegurarse de que todas las sesiones de juego se atiendan, sea cual seala latencia, puede establecer el valor máximo de la última política en un valor muy alto.

1. Si se pasa 120 segundos buscando un destino donde todas las latencias de los jugadores son demenos de 50 milisegundos, entonces...

2. Si se pasa 120 segundos buscando un destino donde todas las latencias de los jugadores son demenos de 100 milisegundos, entonces...

3. Invertir el tiempo de espera de la cola restante en buscar un destino donde todas las latencias de losjugadores son de menos de 200 milisegundos.

En este ejemplo, la primera política se aplica durante los primeros dos minutos, la segunda política seaplica para los minutos tres y cuatro, y la tercera política se aplica durante el quinto minuto hasta que seagota el tiempo de espera de la solicitud de ubicación.

Diseño de una cola para instancias de spotSi tiene previsto utilizar instancias de subasta para las flotas, tendrá que configurar una cola. Lo ideal esestablecer una cola dotada de resiliencia que aproveche el ahorro de costos que ofrecen las flotas de spoty que al mismo tiempo minimice la posibilidad de que se produzcan interrupciones en las sesiones dejuego. Utilice las siguientes prácticas recomendadas:

Version90

Amazon GameLift Developer GuideFuncionamiento de FleetIQ

• Incluya flotas de más de una región. Una cola de varias regiones aumenta la resiliencia asegurándosede que siempre haya flotas disponibles para alojar sesiones de juego nuevas.

• En cada región, incluya al menos una flota de spot y una flota bajo demanda. Este diseño garantizaque las sesiones de juego se puedan ubicar en cualquier región, incluso si no hay flotas de spot viablesactualmente en esa región.

• Si incluye varias las flotas de spot en cada región, utilice distintos tipos de instancias para cada flota,preferiblemente de la misma familia de instancias (C4.large, C4.xlarge, etc.). Este diseño disminuyela probabilidad de que varias de las flotas de subasta no estén disponibles o se interrumpan al mismotiempo. Compruebe los datos de precios históricos en la consola de Amazon GameLift para verificar quelos tipos de instancias que prefiere suelen ofrecer ahorros de costos considerables con la modalidadspot. Estos datos muestra los precios para las instancias de spot y bajo demanda, y proporcionan elahorro estimado de la modalidad spot por cada instancia.

• Para optimizar la capacidad de FleetIQ para seleccionar el precio más bajo de instancia de spot, pienseen incluir los datos de latencia de los jugadores en todas las regiones. Tal y como se describe enFuncionamiento de FleetIQ (p. 91), FleetIQ funciona de forma más eficaz cuando los destinos sevuelven a priorizar por región, lo que sucede cuando se proporcionan los datos de latencia.

• Si no proporciona los datos de latencia de los jugadores en las solicitudes de ubicación de sesiones dejuego, ordene los destinos por preferencia. Por ejemplo, puede ordenar los destinos por preferencia deregión (flota de spot seguida de flota bajo demanda). También puede situar todas sus flotas de spot enprimer lugar.

Funcionamiento de FleetIQFleetIQ utiliza el siguiente proceso de toma de decisiones a la hora de buscar la mejor ubicación posiblepara una nueva sesión de juego.

1. FleetIQ filtra los destinos de la cola para quitar cualquiera de las siguientes flotas:• Si la solicitud incluye datos de latencia de los jugadores, FleetIQ evalúa las políticas de latencia de

los jugadores en cola y quita todas las flotas de las regiones en las que la latencia de algún jugadorsupere el límite máximo de la política.

• FleetIQ quita las flotas de spot que actualmente no son viables porque las tasas de interrupciónresultan inaceptables.

2. FleetIQ prioriza el resto de destinos de la cola en función de lo siguiente:• Si se proporcionan los datos de latencia de los jugadores, FleetIQ vuelve a ordenar los destinos de la

cola por región y clasifica en primer lugar los que tienen una menor latencia media.• Si no se proporcionan los datos de latencia de los jugadores, FleetIQ utiliza la lista original de destinos

de la cola.3. FleetIQ selecciona un destino en la lista priorizada.

• Si la lista de destinos se ha priorizado por región, FleetIQ selecciona la flota de la región con lalatencia más baja y el menor precio. Si no hay flotas de subasta viables, se puede seleccionarcualquier flota en esa región.

• Si la lista de destinos no se ha priorizado, FleetIQ selecciona la primera flota viable de la lista originalaunque haya flotas de spot con menor precio en la lista.

4. FleetIQ evalúa si la flota seleccionada tiene un proceso de servidor disponible para alojar una sesión dejuego nueva. Se considera una ubicación "óptima" cuando la nueva sesión de juego se coloca en unaflota con la menor latencia y/o el menor precio posibles.

5. Si la flota seleccionada no tiene recursos disponibles, FleetIQ pasa al siguiente destino de la lista yrepite el proceso hasta que encuentra una flota en la que alojar la nueva sesión de juego.

Version91


Amazon GameLift Developer GuideEvaluación de métricas de cola

Evaluación de métricas de colaUtilice métricas para evaluar el desempeño de las colas. Puede ver las métricas específicas de la colaen la consola de Amazon GameLift (Visualización de los detalles de la cola (p. 96)) o en AmazonCloudWatch. Las métricas de la cola se describen en Métricas de Amazon GameLift para colas (p. 143).

Las métricas de la cola pueden proporcionar información sobre tres aspectos principales:

• Desempeño general de la cola: las métricas indican qué tal está respondiendo una cola a las solicitudesde ubicación y ayudan a identificar cuándo y por qué se producen errores. En el caso de las flotasescaladas manualmente, los tiempos de espera medios de las métricas y la profundidad de la colapueden indicar cuándo es necesario ajustar la capacidad de una cola.

• Desempeño de FleetIQ: en las solicitudes de ubicación que utilizan los filtros y prioridades de FleetIQ (esdecir, las solicitudes que contienen datos de latencia de los jugadores), las métricas indican la frecuenciacon la que FleetIQ es capaz de encontrar una ubicación óptima para nuevas sesiones de juego. Laubicación óptima puede incluir la búsqueda de recursos con la menor latencia de jugadores posible o, sihay flotas de spot disponibles, con el precio más bajo. También hay métricas de error que identifican losmotivos habituales por los que se producen errores en la colocación óptima.

• Ubicaciones específicas de regiones: en las colas de varias regiones, las métricas muestran lasubicaciones que se han realizado correctamente desglosadas por región. En el caso de las colas queutilizan FleetIQ, estos datos proporcionan información útil acerca de dónde se produce la actividad de losjugadores.

Cuando valúe las métricas de desempeño de FleetIQ, tenga en cuenta las siguientes recomendaciones:

• Utilice la métrica "placements succeeded" (ubicaciones correctas) junto con las métricas de FleetIQ quemiden la latencia y/o el precio más bajos para hacer un seguimiento del índice de ubicaciones óptimasde la cola.

• Si desea aumentar el índice de ubicaciones óptimas de una cola, consulte las métricas de errores paraobtener la siguiente información:• Si la métrica de error "first choice not available" (la primera opción no está disponible) es alta, es

un buen indicativo de que es necesario ajustar el escalado de capacidad en las flotas de la cola.Es posible que el escalado de todas las flotas de la cola sea menor de lo necesario o que unadeterminada flota o región resulte la más adecuada para la mayoría de las ubicaciones.

• Si la métrica de error "first choice not viable" (la primera opción no es viable) es alta, puede indicarque debe analizarse el uso de las flotas de spot. Las flotas de spot no se consideran viables cuando latasa de interrupción es muy alta en un determinado tipo de instancia. Para solucionar este problema,cambie la cola para que utilice flotas de spot con otros tipos de instancias. Tal y como se indicó en lasprácticas recomendadas sobre el uso de colas con flotas de spot, siempre es conveniente incluir flotasde spot con diferentes tipos de instancias en cada región.

Creación de una colaLas colas se utilizan para ubicar nuevas sesiones de juego con los mejores recursos de alojamientodisponibles en varias flotas y regiones. Para obtener más información sobre la creación de colas para unjuego, consulte Diseño de colas de sesiones de juego (p. 87).

En un cliente de juego, las sesiones de juego nuevas se inician en las colas mediante las solicitudes deubicación. Para obtener más información sobre la ubicación de sesiones de juego, consulte Creación desesiones de juego (p. 37).

Puede utilizar la consola de Amazon GameLift o la AWS Command Line Interface (p. 20) (CLI) para crearuna flota.

Version92


Amazon GameLift Developer GuideCreación de una cola (consola)

Creación de una cola (consola)Creación de una cola desde la Consola de administración de AWS.

Para crear una cola

1. Abra la consola de Amazon GameLift en https://console.aws.amazon.com/gamelift/ y elija la región enla que desea crear la cola.

2. En el menú de Amazon GameLift, seleccione Create a queue.3. En la página Create queue, complete la sección Queue Details:

• Queue Name: cree un nombre significativo para la cola para poder identificarla fácilmenteen una lista y en las métricas. Para solicitar una sesión de juego nueva (medianteStartGameSessionPlacement) deberá especificar el nombre de la cola. No se admiten espacios nicaracteres especiales en el nombre.

• Queue Timeout: especifique el tiempo que quiere que Amazon GameLift intente colocar una sesiónde juego nueva antes de parar. Amazon GameLift continuará buscando recursos disponibles encualquier flota hasta que se agote el tiempo de la solicitud.

4. En Player latency policies, defina cero o más políticas para la cola. Para cada solicitud de ubicación,Amazon GameLift minimiza de forma automática la latencia media en todos los jugadores. Tambiénpuede crear políticas de latencia para establecer un límite máximo para cada jugador individual.Las políticas de latencia de los jugadores solo se evalúan cuando los datos de latencia del jugadorse facilitan en la solicitud de ubicación. Puede optar por aplicar un límite a lo largo del procesode ubicación, o bien puede relajar gradualmente el límite con el paso del tiempo. Encontrará másinformación en Diseño de las políticas de latencia de los jugadores (p. 90).

a. Para añadir una primera política, elija Add player latency policy. Introduzca un valor de latenciamáxima de los jugadores para esta política (el valor predeterminado es 150 milisegundos). Tal ycomo se indica en el lenguaje de la política, esta primera política se aplicará o bien para todo elproceso de ubicación o, si crea políticas adicionales, para el tiempo restante después de que lasdemás políticas hayan caducado.

b. Para añadir otra política de latencia de los jugadores, elija Add player latency policy de nuevo.Para políticas adicionales, defina el valor máximo de latencia de los jugadores y el tiempo (ensegundos) para aplicarlo. Los valores máximos de latencia de estas políticas deben ser inferioresa los de la primera política.

Al añadir las políticas, la consola reordena automáticamente las políticas en función del valormáximo de latencia de los jugadores, el valor más bajo aparece en primer lugar. Este es el ordenen que se aplican las políticas durante el proceso de ubicación de sesiones de juego.

5. En Destinations, añada uno o varios destinos a la cola. Una cola puede contener flotas de variasregiones y con flotas bajo demanda y de spot. El único requisito es que todas las flotas deben estarejecutando versiones del juego que sean compatibles con los clientes del juego que utilizarán la cola,como flotas en varias regiones que ejecutan la misma versión del juego. Las flotas y los alias debenexistir antes de poder añadirlas como destino.

a. Elija Add destination.b. Utilice las columnas para especificar la región y el tipo (flota o alias) de su destino. En la lista de

nombres de flota o alias resultante, seleccione el que desea añadir.c. Elija el icono de marca de verificación verde para guardar el destino. Debe guardar cada destino

antes de añadir uno nuevo, de cambiar el orden predeterminado o de guardar la cola.d. Si tiene varios destinos, defina el orden predeterminado con los iconos de flechas en la columna

Priority (default). Amazon GameLift utiliza este orden al buscar destinos para que los recursosdisponibles coloquen una sesión de juego nueva. (El orden predeterminado se anula si unasolicitud de ubicación de sesiones de juego incluye datos de latencia de los jugadores).

Version93


https://docs.aws.amazon.com/gamelift/latest/apireference/API_StartGameSessionPlacement.html

Amazon GameLift Developer GuideCreación de una cola (AWS CLI)

6. En cuanto haya terminado la configuración de la cola nueva, seleccione Create queue. La cola nuevase guarda y la página Queues mostrará la cola nueva y cualquier otra cola existente. Puede elegir unacola de esta página para ver información detallada, incluidas las métricas de la cola. Puede editar laconfiguración de una cola en cualquier momento.

Creación de una cola (AWS CLI)Puede utilizar la AWS Command Line Interface (AWS CLI) para crear una cola. Si todavía no ha instaladola AWS CLI, consulte el tema Instalar la AWS CLI (p. 20).

Para crear una cola

• Abra una ventana de línea de comando y utilice el comando create-game-session-queue paradefinir una cola nueva. Para obtener más información, consulte la Referencia de comandos de AWSCLI.

En el siguiente ejemplo se crea una cola para colocar sesiones de juego nuevas en varias flotas antes deque expiren en cinco minutos. Las flotas se enumeran como destinos y se identifican con un ARN de flotao de alias. Todos los alias y las flotas ya tienen que existir. Amazon GameLift intenta colocar sesiones dejuego nuevas en las flotas en el orden en el que se enumeran aquí a menos que dicho orden lo anulen lassolicitudes de ubicación de sesiones de juego individuales.

Note

Puede obtener los valores del ARN de la flota y el alias llamando a describe-fleet-attributes oa describe-alias con el ID de la flota o del alias. Para obtener más información sobre el ARN(nombre de recurso de Amazon), consulte Nombres de recursos de Amazon (ARN) y espacios denombres de servicios de AWS.

$ aws gamelift create-game-session-queue --name "Sample test queue"--timeout-in-seconds 300--destinations DestinationArn=arn:aws:gamelift:us-east-1::alias/alias-a1234567-b8c9-0d1e-2fa3-b45c6d7e8910 DestinationArn=arn:aws:gamelift:us-west-2::alias/alias-b0234567-c8d9-0e1f-2ab3-c45d6e7f8901 DestinationArn=arn:aws:gamelift:us-west-2::fleet/fleet-f1234567-b8c9-0d1e-2fa3-b45c6d7e8912

Versión copiable:

aws gamelift create-game-session-queue --name "Sample test queue" --timeout-in-seconds 300 --destinations DestinationArn=arn:aws:gamelift:us-east-1::alias/alias-a1234567-b8c9-0d1e-2fa3-b45c6d7e8910 DestinationArn=arn:aws:gamelift:us-west-2::alias/alias-b0234567-c8d9-0e1f-2ab3-c45d6e7f8901 DestinationArn=arn:aws:gamelift:us-west-2::fleet/fleet-f1234567-b8c9-0d1e-2fa3-b45c6d7e8912

Si la solicitud create-game-session-queue se realiza correctamente, Amazon GameLift devuelve unobjeto GameSessionQueue con la nueva configuración de la cola. Ahora puede enviar solicitudes a la colautilizando StartGameSessionPlacement.

Para crear una cola con las políticas de latencia de los jugadores

• Abra una ventana de línea de comando y utilice el comando create-game-session-queue paradefinir una cola nueva. Para obtener más información, consulte la Referencia de comandos de AWSCLI.

Version94

https://docs.aws.amazon.com/cli/latest/reference/gamelift/create-game-session-queue.html


https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-fleet-attributes.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/describe-alias.html

https://docs.aws.amazon.com/general/latest/gr/aws-arns-and-namespaces.html


https://docs.aws.amazon.com/gamelift/latest/apireference/API_GameSessionQueue.html

https://docs.aws.amazon.com/gamelift/latest/apireference//API_StartGameSessionPlacement.html



Amazon GameLift Developer GuideVisualización de las colas

En el siguiente ejemplo se crea una cola con un tiempo de espera de 10 minutos, tres destinos y unconjunto de políticas de latencia de los jugadores. En este ejemplo, la primera política de latencia de losjugadores se aplica durante los primeros dos minutos, la segunda política se aplica para el minuto tres ycuatro, y la tercera política se aplica durante seis minutos hasta que se agota el tiempo de espera de lasolicitud de ubicación.

$ aws gamelift create-game-session-queue--name "matchmaker-queue"--timeout-in-seconds 600--destinations DestinationArn=arn:aws:gamelift:us-east-1::alias/alias-a1234567-b8c9-0d1e-2fa3-b45c6d7e8910 DestinationArn=arn:aws:gamelift:us-west-2::alias/alias-b0234567-c8d9-0e1f-2ab3-c45d6e7f8901 DestinationArn=arn:aws:gamelift:us-west-2::fleet/fleet-f1234567-b8c9-0d1e-2fa3-b45c6d7e8912--player-latency-policies "MaximumIndividualPlayerLatencyMilliseconds=50,PolicyDurationSeconds=120" "MaximumIndividualPlayerLatencyMilliseconds=100,PolicyDurationSeconds=120" "MaximumIndividualPlayerLatencyMilliseconds=150"

Versión copiable:

aws gamelift create-game-session-queue --name "matchmaker-queue" --timeout-in-seconds 600 --destinations DestinationArn=arn:aws:gamelift:us-east-1::alias/alias-a1234567-b8c9-0d1e-2fa3-b45c6d7e8910 DestinationArn=arn:aws:gamelift:us-west-2::alias/alias-b0234567-c8d9-0e1f-2ab3-c45d6e7f8901 DestinationArn=arn:aws:gamelift:us-west-2::fleet/fleet-f1234567-b8c9-0d1e-2fa3-b45c6d7e8912 --player-latency-policies "MaximumIndividualPlayerLatencyMilliseconds=50,PolicyDurationSeconds=120" "MaximumIndividualPlayerLatencyMilliseconds=100,PolicyDurationSeconds=120" "MaximumIndividualPlayerLatencyMilliseconds=150"

Si la solicitud create-game-session-queue se realiza correctamente, Amazon GameLift devuelve unobjeto GameSessionQueue con la nueva configuración de la cola.

Visualización de las colasPuede consultar información sobre todas las colas (p. 87) de ubicación de sesiones de juego existentes.Las colas que se muestran solo incluyen las creadas en la región seleccionada. En la página Queues,puede crear una cola nueva, eliminar las colas existentes o abrir una página de detalles de una colaseleccionada. Una página de detalles de la cola contiene la configuración y los datos de métricas de lacola. También puede editar o eliminar la cola.

Para ver la página Queues

1. Elija Queues en el menú de la consola de Amazon GameLift.

La página Queues muestra la siguiente información resumida de cada cola:

• Queue name: es el nombre asignado a la cola. Las solicitudes de sesiones de juego nuevas utilizaneste nombre para identificar una cola.

• Queue timeout: duración máxima, en segundos, que una solicitud de ubicación de sesión de juegose mantiene en la cola antes de expirar.

• Destinations in queue: número de flotas que aparece en la lista de flotas de la configuración de lacola. Las sesiones de juego nuevas se pueden colocar en cualquier flota de la cola.

Version95


Amazon GameLift Developer GuideVisualización de los detalles de la cola

2. Para ver los detalles de una cola, incluidas las métricas, elija el nombre de la misma. Para obtenermás información acerca de la página de detalles de la cola, consulte Visualización de los detalles de lacola (p. 96).

Visualización de los detalles de la colaPuede acceder a información detallada sobre cualquier cola, incluida la configuración y las métricas de lacola. Para abrir una página de detalles de la cola, vaya a la página Queues y elija el nombre de la misma.

La página de detalles de la cola muestra una tabla de resumen y pestañas que contienen informaciónadicional. En esta página puede hacer lo siguiente:

• Actualizar la configuración de la cola, la lista de destinos y las políticas de latencia de los jugadores. ElijaActions, Edit queue.

• Eliminar una cola. Después de eliminar una cola, todas las solicitudes de sesiones de juego nuevas quehacen referencia al nombre de la cola darán error. (Tenga en cuenta que las colas eliminadas puedenrestaurarse creando simplemente una cola con el nombre de la cola eliminada.) Elija Actions, Deletequeue.

ResumenLa tabla de resumen incluye la siguiente información:

• Queue name: es el nombre asignado a la cola. Las solicitudes de sesiones de juego nuevas utilizan estenombre para identificar una cola.

• Queue timeout: duración máxima, en segundos, que una solicitud de ubicación de sesión de juego semantiene en la cola antes de expirar.

• Destinations in queue: número de flotas que aparece en la lista de flotas de la configuración de la cola.Las sesiones de juego nuevas se pueden colocar en cualquier flota de la cola.

DestinosLa pestaña Destinations muestra todas las flotas o alias correspondientes a la cola. Las flotas se identificanpor un ARN de la flota o un ARN del alias, que especifica el ID de la flota o del alias y la región.

Cuando Amazon GameLift busca los destinos para los recursos disponibles para alojar una nueva sesiónde juego, la búsqueda la realiza según el orden indicado aquí. Mientras exista capacidad en el primerdestino de la lista, las sesiones de juego nuevas se colocarán ahí. Esta es la clasificación predeterminadapara los destinos. Puede hacer que determinadas solicitudes de ubicación de sesiones de juego anulen elorden predeterminado si proporciona los datos de latencia de los jugadores. Estos datos indican a AmazonGameLift que busque un destino disponible que tenga la latencia media de jugadores más baja.

Para añadir, editar o eliminar destinos, elija Actions, Edit queue.

Políticas de latencia de los jugadoresLa pestaña Player latency policies muestra todas las políticas que se han definido para la cola. Laspolíticas se enumeran en el orden en el que se ejecutan durante el proceso de ubicación de sesiones dejuego.

Para añadir, editar o eliminar políticas de latencia de los jugadores, elija Actions, Edit queue.

Version96

Amazon GameLift Developer GuideMétricas de la cola

Métricas de la colaLa pestaña Metrics muestra una representación gráfica de las métricas de la cola a lo largo del tiempo.

Las métricas de la cola abarcan una amplio abanico de información que describe la actividad de ubicaciónde toda la cola, así como las ubicaciones correctas desglosadas por región. Los datos específicos de laregión resultan útiles para hacer un seguimiento de la ubicación en la que se han alojado los juegos. En lascolas que usan FleetIQ y priorizan las ubicaciones para minimizar la latencia de los jugadores y los costosde alojamiento, las métricas de ubicación regionales pueden ayudar a detectar problemas con el diseñoglobal de la cola.

Las métricas de la cola también están disponibles en Amazon CloudWatch. Puede ver las descripciones detodas las métricas en Métricas de Amazon GameLift para colas (p. 143).

Para visualizar información de métricas en el gráfico

1. Haga clic en uno o varios de los nombres de las métricas que se encuentren a la izquierda de la zonade gráficos. Los nombres de las métricas en negro se muestran en el gráfico, mientras que los queaparecen en gris están desactivados. Utilice la clave de color para identificar las líneas del gráfico quecoinciden con una métrica seleccionada.

2. Utilice los filtros siguientes, que se muestran por encima del gráfico, para modificar la forma en que semuestran los datos de las métricas:

• Data y Period: ofrece dos opciones para seleccionar un rango de fechas:• Use Relative para seleccionar un período de tiempo relacionado con la hora actual, como Last

hour, Last day, Last week.• Use Absolute para especificar un período con una fecha/hora de inicio y de fin arbitraria.

• Granularity: seleccione una duración para agregar puntos de datos.• Refresh rate: seleccione la frecuencia con la que quiere que se actualice la visualización gráfica.

Puede actualizar el gráfico en cualquier momento haciendo clic en el botón Actualizar situado en laesquina superior derecha del gráfico.

• Time zone (Zona horaria): seleccione el formato de hora que quiere utilizar en la representacióngráfica: UTC (hora universal coordinada) o Browser time (hora del explorador u hora local).

• Show points: active esta opción para visualizar solo los puntos de datos discretos (en forma decírculos) o las líneas de visualización.

Version97

Amazon GameLift Developer GuideGuía de integración de FlexMatch

Emparejamientos con FlexMatchUtilice la característica FlexMatch de Amazon GameLift para incorporar a los juegos el emparejamientode jugadores. FlexMatch combina el servicio de emparejamiento con un motor de reglas personalizable.Permite diseñar el emparejamiento de jugadores en función de los atributos de los jugadores y los modosde juego relevantes para el juego, así como confiar en FlexMatch para que administre las cuestionesprácticas de formación de grupos de jugadores y su ubicación en los juegos.

Además, FlexMatch se basa en la característica Queues (Colas). Una vez que se crea un emparejamiento,FlexMatch transfiere los datos del emparejamiento a una cola de su elección. La cola busca, acontinuación, recursos de hospedaje disponibles en sus flotas de Amazon GameLift y comienza una nuevasesión de juego para el emparejamiento.

Para obtener más información sobre las principales características de FlexMatch y su funcionamiento,consulte Amazon GameLift FlexMatch (p. 10).

Temas• Guía de integración de FlexMatch (p. 98)• Diseño de un creador de emparejamientos de FlexMatch (p. 99)• Creación de un conjunto de reglas de FlexMatch (p. 102)• Configuración de la notificación de eventos en FlexMatch (p. 115)• Agregar FlexMatch a un cliente de juego (p. 117)• Agregar FlexMatch a un servidor de juegos (p. 121)• Reposición de juegos existentes con FlexMatch (p. 123)

Guía de integración de FlexMatchPara agregar el emparejamiento de FlexMatch a un juego, debe completar las siguientes tareas.

• Configurar un creador de emparejamientos. Un creador de emparejamientos recibe solicitudes deemparejamiento de jugadores y las procesa. Agrupa a los jugadores en función de un conjunto de reglasdefinidas y crea nuevas sesiones de juego y de jugadores por cada emparejamiento correcto. Siga estospasos para configurar un creador de emparejamientos:• Crear un conjunto de reglas. Un conjunto de reglas indica al creador de emparejamientos cómo

conformar un emparejamiento válido. Especifica la estructura del equipo y cómo evaluar a losjugadores para su inclusión en un emparejamiento. Consulte estos temas:• Creación de un conjunto de reglas de FlexMatch (p. 102)• Ejemplos de conjuntos de reglas de FlexMatch (p. 105)

• Crear una cola de sesión de juego. Una cola localiza la mejor región para cada emparejamiento y creauna sesión de juego nueva en esa región. Puede utilizar una cola existente o crear una nueva para elemparejamiento. Consulte este tema:• Creación de una cola (p. 92)

• Configurar notificaciones (opcional). Dado que las solicitudes de emparejamiento son asíncronas,necesitará una forma de controlar el estado de las solicitudes. Las notificaciones son la opciónpreferida. Consulte este tema:• Configuración de la notificación de eventos en FlexMatch (p. 115)

• Configurar un creador de emparejamientos. Tras contar con un conjunto de reglas, una cola y undestino de notificaciones, puede crear la configuración para su creador de emparejamiento. Consulteestos temas:

Version98

Amazon GameLift Developer GuideDiseño de un creador de emparejamientos

• Diseño de un creador de emparejamientos de FlexMatch (p. 99)• Crear una configuración de emparejamiento (p. 101)

• Integrar FlexMatch en el servicio del cliente de juego. Inicie nuevas sesiones de juego conemparejamientos. Añada funcionalidad a su servicio de cliente de juego para realizar solicitudes deemparejamiento y proporcionar los atributos necesarios del jugador para el emparejamiento. Lassolicitudes de emparejamiento identifican qué creador de emparejamientos utilizar, lo que determina elconjunto de reglas y la cola que se utilizan para atender las solicitudes. Consulte este tema:• Agregar FlexMatch a un cliente de juego (p. 117)

• Integrar FlexMatch en el servidor de juegos. Habilite el servidor de juegos para que inicie nuevassesiones de juego para emparejamientos en respuesta a solicitudes del servicio Amazon GameLift. Lassolicitudes incluyen información del juego, jugador y emparejamiento, que el servidor de juego utilizapara construir una sesión de juego para el emparejamiento. Consulte este tema:• Agregar FlexMatch a un servidor de juegos (p. 121)

• Configurar la reposición de FlexMatch (opcional). Busque jugadores para completar ranuras dejugadores abiertas en juegos existentes. Puede iniciar solicitudes de reposición de emparejamientodirectamente desde los procesos del servidor de juegos, o desde el servicio del lado del cliente, como unservicio de directorio de sesiones. Consulte este tema:• Reposición de juegos existentes con FlexMatch (p. 123)

Diseño de un creador de emparejamientos deFlexMatch

La tarea de crear los emparejamientos del juego la realiza un proceso del creador de emparejamientosde FlexMatch. Administra el grupo de solicitudes de emparejamiento recibidas, forma equipos para unemparejamiento, procesa y selecciona jugadores para encontrar los mejores grupos de jugadores posiblese inicia el proceso de colocar y comenzar una sesión de juego para el emparejamiento. En este tema sedescriben los aspectos clave de un creador de emparejamientos y cómo configurar uno personalizado parasu juego.

Para crear un creador de emparejamientos, defina una configuración de emparejamientoutilizando la consola de Amazon GameLift o la CLI de AWS (consulte Crear una configuración deemparejamiento (p. 101)). Puede configurar tantos creadores de emparejamientos como necesite para eljuego.

Para obtener una descripción detallada de cómo los creadores de emparejamiento de FlexMatchprocesan las solicitudes de emparejamiento que reciben, consulte Funcionamiento deAmazon GameLiftFlexMatch (p. 11).

Configuraciones de creadores de emparejamientosComo mínimo, un creador de emparejamientos necesita tres elementos:

• El conjunto de reglas determina el tamaño y el alcance de los equipos para un emparejamiento, y defineun conjunto de reglas para utilizar a la hora de evaluar los jugadores para un emparejamiento. Cadacreador de emparejamientos está configurado para utilizar un conjunto de reglas. Para obtener másinformación sobre la creación de conjuntos de reglas, consulte Creación de un conjunto de reglas deFlexMatch (p. 102).

• La cola de la sesión de juego determina donde se hospedarán los emparejamientos creados por estecreador de emparejamientos. El creador de emparejamientos utiliza la cola para encontrar recursosdisponibles y colocar una sesión de juego para el emparejamiento. Una cola especifica qué regionesutilizar a la hora de colocar una sesión de juego. Para obtener más información sobre la creación decolas, consulte Creación de una cola (p. 92).

Version99

Amazon GameLift Developer GuideConfiguraciones de creadores de emparejamientos

• El tiempo de espera de la solicitud determina el periodo durante el cual las solicitudes deemparejamiento pueden permanecer en el grupo de solicitudes y ser evaluadas para comprobar losemparejamientos potenciales. Cuando una solicitud agota el tiempo de espera, significa que no se hapodido realizar un emparejamiento y se retira del grupo.

Además de estos requisitos mínimos, puede configurar su creador de emparejamientos con las siguientesopciones adicionales.

Aceptación del jugador

Puede configurar un creador de emparejamientos para que exija que todos los jugadores seleccionadospara un emparejamiento acepten la participación. Si la aceptación es obligatoria, se debe dar a todoslos jugadores la opción de aceptar o rechazar un emparejamiento propuesto. Un emparejamiento deberecibir aceptaciones de todos los jugadores en el emparejamiento propuesto para que pueda completarse.Si un jugador rechaza o no acepta un emparejamiento, se descarta el emparejamiento propuesto. Lassolicitudes de emparejamiento se administran de la siguiente manera: las solicitudes en las que todos losjugadores aceptan el emparejamiento se devuelven al grupo de emparejamientos para continuar con elprocesamiento; las solicitudes en las que al menos un jugador rechaza el emparejamiento o no responde,fracasan y dejan de procesarse. La aceptación del jugador requiere un plazo, que se puede definir. Todoslos jugadores deben aceptar un emparejamiento propuesto dentro del plazo establecido para que elemparejamiento continúe.

Notificación de emparejamiento

Esta característica emite todos los eventos relacionados con el emparejamiento a un tema de AmazonSimple Notification Service (SNS) designado. Dado que las solicitudes de emparejamiento son asíncronas,todos los juegos deben contar con un método para hacer un seguimiento del estado de las solicitudes deemparejamiento. El establecimiento de notificaciones es sencillo y eficaz. Consulte más opciones pararealizar un seguimiento de las solicitudes en Agregar FlexMatch a un cliente de juego (p. 117). Parautilizar las notificaciones, primero debe configurar un tema de SNS y, a continuación, proporcionar elARN del tema como el objetivo de notificación en la configuración de emparejamientos. Consulte másinformación sobre la configuración de notificaciones en Configuración de la notificación de eventos enFlexMatch (p. 115).

Propiedades del juego

A la hora de solicitar una nueva sesión de juego, puede transferir información adicional al servidorde juegos sobre el tipo de sesión que desea crear. Las propiedades del juego se pueden entregarcon cualquier tipo de solicitud de sesión de juego (con una solicitud de ubicación o una solicitud deemparejamiento). Con el emparejamiento, las propiedades del juego se incluyen en la configuración delcreador de emparejamientos. Todas las sesiones de juego creadas con un creador de emparejamientosutilizan las mismas propiedades de juego. Si tiene que cambiar las propiedades del juego, generecreadores de emparejamientos independientes. Envíe solicitudes de emparejamiento al creador deemparejamientos con las propiedades del juego correspondientes.

Ranuras de jugadores reservadas

Puede designar que determinadas ranuras de jugadores de cada emparejamiento se reserven y serellenen en otro momento. Esto se hace configurando la propiedad "additional player count" de unaconfiguración de emparejamiento.

Datos de eventos personalizados

Utilice esta propiedad para incluir un conjunto de información personalizada en todos los eventosrelacionados con el emparejamiento para el creador de emparejamientos. Esta característica puederesultar útil para realizar un seguimiento de determinada actividad exclusiva de su juego, incluido elseguimiento del desempeño de sus creadores de emparejamientos.

Version100

Amazon GameLift Developer GuideCrear una configuración de emparejamiento

Crear una configuración de emparejamientoPara configurar un creador de emparejamiento de FlexMatch, debe crear una nueva configuración deemparejamiento. Utilice la consola Amazon GameLift o la AWS Command Line Interface (AWS CLI). Paraobtener información más detallada sobre cómo configurar un creador de emparejamientos, consulte thesection called “Diseño de un creador de emparejamientos” (p. 99).

Note

Antes de poder crear una configuración de emparejamiento, debe haber creado el conjunto dereglas y la cola que desea utilizar con el creador de emparejamientos.

Elegir una región para el creador de emparejamientosUn creador de emparejamientos se hospeda en la región en la que se crea su configuración. Merece lapena considerar cómo puede afectar la ubicación de un creador de emparejamientos a su desempeño ycómo ajustar la experiencia de emparejamiento para los jugadores previstos. Recomendamos que coloqueun creador de emparejamientos en una región cercana a los clientes o al servicio de cliente que realizarálas solicitudes de emparejamiento. Como práctica recomendada, también recomendamos colocar alcreador de emparejamientos y la cola que utiliza en la misma región. Esto ayuda a minimizar la latencia dela comunicación entre el creador de emparejamientos y la cola.

Crear una configuración de emparejamiento (consola)Siga estos pasos para crear una configuración de emparejamiento a partir de la Consola de administraciónde AWS.

Para crear una configuración de emparejamiento con la consola de Amazon GameLift:

1. Abra la consola de Amazon GameLift en https://console.aws.amazon.com/gamelift/home.2. Cambie a la región donde desee colocar su creador de emparejamientos.3. Desde el menú principal, elija Create matchmaking configuration. Complete los detalles de

configuración del emparejamiento.

• Name: cree un nombre significativo para el creador de emparejamientos para poder identificarlofácilmente en una lista y en las métricas. El nombre de creador de emparejamientos debe ser únicodentro de una región. Las solicitudes de emparejamiento identifican el creador de emparejamientosque se debe utilizar por su nombre y región.

• Description: añada una descripción para el creador de emparejamientos (opcional). La descripciónse utiliza solo para la identificación. No se utiliza en el proceso de emparejamiento.

• Queue: elija la cola de la sesión de juego que utilizará con este creador de emparejamientos. Paraencontrar la cola, elija en primer lugar la región donde se ha configurado la cola. A continuación,elija la cola que desea de la lista de colas disponibles en esa región.

• Request timeout: escriba el tiempo máximo, en segundos, para que el creador de emparejamientoscomplete un emparejamiento para cada solicitud. Las solicitudes de emparejamiento que superaneste tiempo se terminan.

• Acceptance required: indica si se debe exigir a cada jugador en un emparejamiento propuestoque acepte activamente la participación en el emparejamiento (opcional). Si eligió sí, indique eltiempo de espera deseado para que el creador de emparejamientos reciba las aceptaciones de losjugadores antes de cancelar el emparejamiento.

• Rule set name: elija el conjunto de reglas que utilizará con este creador de emparejamientos. Lalista contiene todos los conjuntos de reglas que se han creado en la región actual.

• Notification target: escriba el ARN de un tema de SNS para recibir notificaciones de eventos deemparejamiento (opcional). Si aún no ha configurado uno, puede agregar esta información mástarde editando la configuración de emparejamiento. Consulte Configuración de la notificación deeventos en FlexMatch (p. 115)

Version101

https://docs.aws.amazon.com/gamelift/latest/developerguide/match-create-ruleset.html

https://docs.aws.amazon.com/gamelift/latest/developerguide/match-create-ruleset.html

https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-creating.html


Amazon GameLift Developer GuideCrear un conjunto de reglas

• Additional players: especifique el número de ranuras de jugadores que permanecen vacantes encada emparejamiento nuevo (opcional). Estas ranuras pueden ocuparse con jugadores en el futuro.

• Custom event data: especifique cualquier dato que desee asociar con este creador deemparejamientos en mensajería de eventos (opcional). Estos datos se incluyen en cualquier eventoasociado con el creador de emparejamientos.

4. Una vez que haya terminado de configurar un creador de emparejamientos, haga clic en Create. Si lacreación se realiza correctamente, el creador de emparejamientos está listo de inmediato para aceptarsolicitudes de emparejamiento.

Crear una configuración de emparejamiento (CLI de AWS)Para crear una configuración de emparejamiento con la AWS CLI, abra una ventana de línea decomando y utilice el comando create-matchmaking-configuration para definir un creador deemparejamientos nuevo. Consulte la documentación completa de este comando en la Referencia decomandos de AWS CLI. Si todavía no ha instalado la AWS CLI, consulte Instalar la AWS CLI (p. 20).

Este ejemplo crea una nueva configuración de emparejamiento que requiere la aceptación delos jugadores y utiliza notificaciones para realizar un seguimiento del estado de las solicitudes deemparejamiento. También reserva dos ranuras de jugadores para agregar jugadores adicionales másadelante.

$ aws gamelift create-matchmaking-configuration--name "SampleMatchamker123"--description "The sample test matchmaker with acceptance"--game-session-queue-arns "arn:aws:gamelift:us-west-2:111122223333:gamesessionqueue/My_Game_Session_Queue_One"--rule-set-name "My_Rule_Set_One"--request-timeout-seconds "120"--acceptance-required "true"--acceptance-timeout-seconds "30"--notification-target "arn:aws:sns:us-west-2:111122223333:My_Matchmaking_SNS_Topic"--additional-player-count "2"--game-session-data "key=map,value=winter444"

Versión copiable:

aws gamelift create-matchmaking-configuration --name "SampleMatchamker123" --description "The sample test matchmaker with acceptance" --game-session-queue-arns "arn:aws:gamelift:us-west-2:111122223333:gamesessionqueue/My_Game_Session_Queue_One" --rule-set-name "My_Rule_Set_One" --request-timeout-seconds "120" --acceptance-required "true" --acceptance-timeout-seconds "30" --notification-target "arn:aws:sns:us-west-2:111122223333:My_Matchmaking_SNS_Topic" --additional-player-count "2" --game-session-data "key=map,value=winter444"

Si la solicitud de creación de configuración de emparejamiento se realiza correctamente, AmazonGameLift devuelve un objeto MatchmakingConfiguration con los ajustes que solicitó para el creador deemparejamientos. El nuevo creador de emparejamientos está listo de inmediato para aceptar solicitudes deemparejamiento.

Creación de un conjunto de reglas de FlexMatchCada creador de emparejamiento de FlexMatch debe tener un conjunto de reglas. El conjunto de reglasdetermina los dos elementos clave de un emparejamiento: (1) la estructura y el tamaño del equipo, y (2)cómo agrupar los jugadores para lograr el mejor emparejamiento y la mejor experiencia de juego posibles.

Version102

https://docs.aws.amazon.com/cli/latest/reference/gamelift/create-matchmaking-configuration.html

https://docs.aws.amazon.com/cli/latest/reference/gamelift/create-matchmaking-configuration.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_MatchmakingConfiguration.html

Amazon GameLift Developer GuideComponentes de un conjunto de reglas

Por ejemplo, un conjunto de reglas podría describir un emparejamiento de este tipo: Crear unemparejamiento con dos equipos de cinco jugadores cada uno (un equipo de defensores y un equipode invasores). Todos los jugadores de ambos equipos deben tener las mismas (o casi las mismas)habilidades. Todos los jugadores deben ser capaces de jugar con una latencia de 20 milisegundos omenos. Si después de 30 segundos no se ha encontrado ningún emparejamiento, relaje gradualmente losrequisitos de habilidad y de latencia.

Puede utilizar la consola de Amazon GameLift o la CLI de AWS para crear un conjunto de reglasde emparejamiento. Puede crear varios conjuntos de reglas y utilizarlos en diferentes creadores deemparejamientos, o bien emplear el mismo conjunto en más de un creador de emparejamientos.

Temas

• Crear un conjunto de reglas de emparejamiento (p. 104)• Ejemplos de conjuntos de reglas de FlexMatch (p. 105)• Referencia de reglas de FlexMatch (p. 189)

Componentes de un conjunto de reglasCada conjunto de reglas contiene los siguientes componentes:

• Name (opcional): se trata de una etiqueta descriptiva dentro de la sintaxis del conjunto de reglas queAmazon GameLift no utiliza de forma significativa. No debe confundirse este valor con el nombre delconjunto de reglas, que se establece, junto con la sintaxis del conjunto de reglas, al crear un conjunto.

• Rule language version (Versión de lenguaje de reglas) (obligatorio): versión del lenguaje de lasexpresiones de propiedad que se utilizan para crear reglas de FlexMatch. El valor debe ser igual a "1.0".

• Player attributes (opcional): las reglas pueden elegir jugadores para emparejamientos en función delas características de los jugadores individuales. Si crea reglas que confían en los atributos de losjugadores, deben declararse en esta sección. Los valores de estos atributos de los jugadores se debenincluir en cada solicitud de emparejamiento que se envía al creador de emparejamientos con esteconjunto de reglas. Al declarar el atributo del jugador, incluya la siguiente información:• Name (obligatorio): este valor debe ser único en el conjunto de reglas.• Type (obligatorio): este es el tipo de datos del valor de atributo. Los tipos de datos válidos son number,

string o string map.• Default (opcional): escriba un valor predeterminado para utilizarlo si no se proporciona ninguno para

un jugador. Si no se declara ninguno predeterminado y un jugador no proporciona un valor, no esposible emparejar al jugador.

• Teams (obligatorio): esta sección define la estructura y el tamaño de los equipos para elemparejamiento.• Puede definir tantos equipos como desee.• Cada equipo debe tener un nombre único

Rule language version (obligatorio): el valor debe ser igual a 1.0.• Cada equipo debe tener un tamaño mínimo y máximo. Utilice el mismo valor para cada uno si desea

exigir un tamaño específico. O bien establezca un rango si desea ser flexible. FlexMatch siempreintentará completar los equipos con el tamaño máximo de jugadores. Si utiliza un rango, pero deseaque todos los equipos del emparejamiento tengan equipos del mismo tamaño, puede crear una reglaespecífica. Consulte el tema Ejemplos de conjuntos de reglas de FlexMatch (p. 105) para ver unejemplo de regla "EqualTeamSizes".

• Los equipos pueden ser asimétricos. Puede crear equipos de diferentes tamaños para cualquierpropósito que se adapte a su juego.

• Rules (opcional): esta sección contiene una o más declaraciones de reglas que definen cómo evaluarjugadores para un emparejamiento aceptable. Las reglas pueden describir requisitos para cada jugador

Version103

Amazon GameLift Developer GuideCrear un conjunto de reglas de emparejamiento

individual o requisitos para un equipo completo o emparejamiento. Cada regla contiene los siguienteselementos:• Name (obligatorio): se trata de un nombre fácil de recordar, que identifica de forma exclusiva la regla

dentro de un conjunto de reglas. También se hace referencia a los nombres de la reglas en registrosde eventos y métricas que realizan un seguimiento de la actividad relacionada con esta regla.

• Description (opcional): utilice este elemento para adjuntar una descripción de texto de formato libre. Elcreador de emparejamientos no utiliza esta información.

• Type (obligatorio): el elemento Type identifica la operación que se debe utilizar al procesar la regla.Cada tipo de regla requiere un conjunto de elementos adicionales. Por ejemplo, varios tipos de reglarequieren un valor de referencia con el que comparar o medir los atributos de un jugador. Consulte lalista de requisitos y tipos de reglas válidos en Referencia de reglas de FlexMatch (p. 189).

• Measurements (obligatorio): este es el valor de jugador que se evalúa para determinar si este es unemparejamiento aceptable. La medida debe estar en consonancia con el tipo de regla. Una medidapuede ser un atributo del jugador para un jugador individual o un conjunto de atributos para un equipoo el emparejamiento en su totalidad. Las mediciones se expresan mediante el lenguaje de expresiónde propiedad. Consulte más información sobre las expresiones de propiedades en Referencia dereglas de FlexMatch (p. 189).

• Expansions (opcional): este elemento le permite relajar los criterios de las reglas a lo largo del tiempo.Esta característica se utiliza para ayudar a garantizar que los emparejamientos se realizan dentro de unperiodo de tiempo razonable. Al relajar las reglas, puede ampliar gradualmente el grupo de jugadoresque puede emparejarse.

Crear un conjunto de reglas de emparejamientoCree conjuntos de reglas de emparejamiento para los creadores de emparejamiento de FlexMatch.Utilice la consola de Amazon GameLift o la interfaz de línea de comandos (CLI) de AWS. Para obtenerinformación más detallada sobre cómo configurar un creador de emparejamientos, consulte the sectioncalled “Crear un conjunto de reglas” (p. 102).

Una vez que se han creado, los conjuntos de reglas de emparejamiento no pueden modificarse nieliminarse, por lo que le recomendamos comprobar la sintaxis del conjunto de reglas antes de su creación.Tanto la consola como la CLI de AWS proporcionan una opción de validación.

Crear un conjunto de reglas de emparejamiento (consola)Para crear un conjunto de reglas con la consola de Amazon GameLift:

1. Abra la consola de Amazon GameLift en https://console.aws.amazon.com/gamelift/.2. Cambie a la región donde desea colocar su conjunto de reglas. Los conjuntos de reglas deben

definirse en la misma región que la configuración de emparejamiento con la que se utilizarán.3. En el menú principal de Amazon GameLift, elija Create matchmaking rule set y rellene los detalles del

conjunto de reglas.

• Rule set name: cree un nombre significativo para poder identificarlo fácilmente en una lista, eneventos y en las métricas. El nombre del conjunto de reglas debe ser exclusivo dentro de unaregión. Las configuraciones de emparejamiento identifican el conjunto de reglas que se debe utilizarpor su nombre. Nota: No debe confundirse con el campo "name" en el cuerpo del conjunto dereglas, que en la actualidad no se utiliza.

• Rule set: escriba el texto JSON del cuerpo de un conjunto de reglas. Cree su propio cuerpo deconjunto de reglas o cópielo de la página Ejemplos de conjuntos de reglas de FlexMatch (p. 105).

4. Como los conjuntos de reglas no se pueden editar una vez que se han creado, es recomendablevalidar primero el conjunto de reglas. Haga clic en Validate rule set para comprobar que la sintaxis delcuerpo del conjunto de reglas sea correcta.

Version104


Amazon GameLift Developer GuideEjemplos de conjuntos de reglas

5. Una vez que haya terminado de configurar un creador de emparejamientos, haga clic en Create ruleset. Si la creación se realiza correctamente, un creador de emparejamientos podrá usar el conjunto dereglas.

Crear un conjunto de reglas de emparejamiento (CLI de AWS)Para crear un conjunto de reglas de emparejamiento con la AWS CLI, abra una ventana de línea decomando y utilice el comando create-matchmaking-rule-set para definir un conjunto de reglasnuevo. Consulte la documentación completa de este comando en la Referencia de comandos de AWS CLI.Si todavía no ha instalado la AWS CLI, consulte Instalar la AWS CLI (p. 20).

Este ejemplo crea un sencillo conjunto de reglas de emparejamiento para configurar un equipo. Asegúresede crear el conjunto de reglas en la misma región que las configuraciones de emparejamiento que haránreferencia a dicho conjunto.

$ aws gamelift create-matchmaking-rule-set--name "SampleRuleSet123"--rule-set-body '{"name": "aliens_vs_cowboys", "ruleLanguageVersion": "1.0", "teams": [{ "name": "cowboys", "maxPlayers": 8, "minPlayers": 4}]}'

Versión copiable:

aws gamelift create-matchmaking-rule-set --name "SampleRuleSet123" --rule-set-body '{"name": "aliens_vs_cowboys", "ruleLanguageVersion": "1.0", "teams": [{"name": "cowboys", "maxPlayers": 8, "minPlayers": 4}]}'

Si la solicitud de creación es correcta, Amazon GameLift devuelve un objeto MatchmakingRuleSet queincluye la configuración especificada. Un creador de emparejamientos puede usar ahora el conjunto dereglas nuevo.

Ejemplos de conjuntos de reglas de FlexMatchLos conjuntos de reglas de FlexMatch pueden cubrir una amplia variedad de situaciones deemparejamiento. Los siguientes ejemplos se ajustan a la estructura de configuración y el lenguaje deexpresiones de propiedad de FlexMatch. Copie estos conjuntos de reglas en su totalidad o elija loscomponentes según sea necesario.

Para obtener más información sobre cómo utilizar las reglas y los conjuntos de reglas de FlexMatch,consulte los siguientes temas:

• Creación de un conjunto de reglas de FlexMatch (p. 102)• Referencia de reglas de FlexMatch (p. 189)

Note

Cuando evalúe un ticket de emparejamiento que incluya varios jugadores, todos los jugadores dela solicitud deben cumplir los requisitos del emparejamiento.

Version105

https://docs.aws.amazon.com/cli/latest/reference/gamelift/create-matchmaking-rule-set.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_MatchmakingRuleSet.html


Ejemplo 1: Crear dos equipos con jugadores emparejados demanera uniformeEste ejemplo ilustra cómo configurar dos equipos de jugadores emparejados de manera uniforme con lassiguientes instrucciones.

• Cree dos equipos de jugadores.• Incluya entre cuatro y ocho jugadores en cada equipo.• Los equipos definitivos deben tener el mismo número de jugadores.

• Incluya el nivel de habilidad de un jugador (si no se proporciona, de manera predeterminada es 10).• Elija jugadores en función de si su nivel de habilidad es similar al de otros jugadores. Asegúrese de que

la habilidad promedio de los jugadores de ambos equipos esté dentro de 10 puntos entre sí.• Si el emparejamiento no se completa rápidamente, relaje el requisito de habilidades de los jugadores

para completar un emparejamiento dentro de un tiempo razonable.• Transcurridos 5 segundos, expanda la búsqueda para permitir equipos con habilidades promedio de

los jugadores dentro de los 50 puntos.• Transcurridos 15 segundos, expanda la búsqueda para permitir equipos con habilidades promedio de

los jugadores dentro de los 100 puntos.

Notas sobre el uso de este conjunto de reglas:

• Este ejemplo permite que los equipos tengan cualquier tamaño entre cuatro y ocho jugadores (aunquedeben ser del mismo tamaño). En el caso de los equipos con un rango de tamaños válido, el creador deemparejamientos hace todo lo posible para emparejar el número máximo de jugadores permitidos.

• La regla FairTeamSkill garantiza que los equipos estén emparejados de manera uniforme según lashabilidades de los jugadores. Para evaluar esta regla con cada posible jugador nuevo, FlexMatch pruebaa añadir el jugador a un equipo y calcula las medias. Si la regla genera un error, no se agrega el posiblejugador al emparejamiento.

{ "name": "aliens_vs_cowboys", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "skill", "type": "number", "default": 10 }], "teams": [{ "name": "cowboys", "maxPlayers": 8, "minPlayers": 4 }, { "name": "aliens", "maxPlayers": 8, "minPlayers": 4 }], "rules": [{ "name": "FairTeamSkill", "description": "The average skill of players in each team is within 10 points from the average skill of all players in the match", "type": "distance", // get skill values for players in each team and average separately to produce list of two numbers "measurements": [ "avg(teams[*].players.attributes[skill])" ], // get skill values for players in each team, flatten into a single list, and average to produce an overall average

Version106


"referenceValue": "avg(flatten(teams[*].players.attributes[skill]))", "maxDistance": 10 // minDistance would achieve the opposite result }, { "name": "EqualTeamSizes", "description": "Only launch a game when the number of players in each team matches, e.g. 4v4, 5v5, 6v6, 7v7, 8v8", "type": "comparison", "measurements": [ "count(teams[cowboys].players)" ], "referenceValue": "count(teams[aliens].players)", "operation": "=" // other operations: !=, <, <=, >, >= }], "expansions": [{ "target": "rules[FairTeamSkill].maxDistance", "steps": [{ "waitTimeSeconds": 5, "value": 50 }, { "waitTimeSeconds": 15, "value": 100 }] }]}

Ejemplo 2: Crear equipos desiguales (cazadores frente amonstruo)Este ejemplo describe un modo de juego en el que un grupo de jugadores da caza a un único monstruo.Las personas eligen el rol de cazador o de monstruo. Los cazadores especifican el nivel de habilidadmínimo del monstruo al que quieren enfrentarse. El tamaño mínimo del equipo de cazadores puederelajarse a lo largo del tiempo para completar el emparejamiento. Esta situación establece las siguientesinstrucciones:

• Cree un equipo con cinco cazadores.• Cree otro equipo con un monstruo.• Incluya los siguientes atributos de los jugadores:

• El nivel de habilidad de un jugador (si no se proporciona, de manera predeterminada es 10).• El nivel de habilidad de un monstruo preferido del jugador (si no se proporciona, de manera

predeterminada es 10).• Si el jugador quiere ser el monstruo (si no se proporciona, de manera predeterminada es 0 o false).

• Elija un jugador para que sea el monstruo en función de los siguientes criterios:• El jugador debe solicitar el rol del monstruo.• El jugador debe cumplir o superar el nivel de habilidad más alto preferido por los jugadores que ya se

han agregado al equipo de cazadores.• Elija jugadores para el equipo de cazadores en función de los siguientes criterios:

• Los jugadores que soliciten el rol del monstruo no pueden unirse al equipo de cazadores.• Si el rol del monstruo ya se ha asignado, el jugador debe desear un nivel de habilidad de monstruo

inferior a la habilidad del monstruo propuesto.• Si un emparejamiento no se completa rápidamente, relaje el tamaño mínimo del equipo de cazadores de

la siguiente manera:• Después de 30 segundos, permita que el juego comience con tan solo cuatro jugadores en el equipo

de cazadores.• Después de 60 segundos, permita que el juego comience con tan solo tres personas en el equipo de

cazadores.


Version107


• Al utilizar dos equipos independientes para cazadores y monstruo, puede evaluar la pertenencia segúndiferentes conjuntos de criterios.

{ "name": "players_vs_monster_5_vs_1", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "skill", "type": "number", "default": 10 },{ "name": "desiredSkillOfMonster", "type": "number", "default": 10 },{ "name": "wantsToBeMonster", "type": "number", "default": 0 }], "teams": [{ "name": "players", "maxPlayers": 5, "minPlayers": 5 }, { "name": "monster", "maxPlayers": 1, "minPlayers": 1 }], "rules": [{ "name": "MonsterSelection", "description": "Only users that request playing as monster are assigned to the monster team", "type": "comparison", "measurements": ["teams[monster].players.attributes[wantsToBeMonster]"], "referenceValue": 1, "operation": "=" },{ "name": "PlayerSelection", "description": "Do not place people who want to be monsters in the players team", "type": "comparison", "measurements": ["teams[players].players.attributes[wantsToBeMonster]"], "referenceValue": 0, "operation": "=" },{ "name": "MonsterSkill", "description": "Monsters must meet the skill requested by all players", "type": "comparison", "measurements": ["avg(teams[monster].players.attributes[skill])"], "referenceValue": "max(teams[players].players.attributes[desiredSkillOfMonster])", "operation": ">=" }], "expansions": [{ "target": "teams[players].minPlayers", "steps": [{ "waitTimeSeconds": 30, "value": 4 },{ "waitTimeSeconds": 60, "value": 3 }] }]}

Version108


Ejemplo 3: Establecer requisitos de equipo y límites de latenciaEste ejemplo ilustra cómo configurar tres equipos de jugadores emparejados equitativamente y aplicarun conjunto de reglas a un equipo, en lugar de a cada jugador. También establece una latencia máximapara todos los jugadores. Los máximos de latencia pueden relajarse con el tiempo para completar elemparejamiento. Esta situación establece las siguientes instrucciones:

• Cree tres equipos de jugadores.• Incluya entre tres y cinco jugadores en cada equipo.• Los equipos definitivos deben contener el mismo o casi el mismo número de jugadores (dentro de

uno).• Incluya los siguientes atributos de los jugadores:

• El nivel de habilidad de un jugador (si no se proporciona, de manera predeterminada es 10).• Un rol de personaje de jugador (si no se proporciona, de manera predeterminada es "ignorante").

• Elija jugadores en función de si su nivel de habilidad es similar al de otros jugadores del emparejamiento.• Asegúrese de que la habilidad promedio de los jugadores de cada equipo esté dentro de 10 puntos

entre sí.• Limite los equipos al siguiente número de personajes de "médicos":

• Un emparejamiento completo puede tener un máximo de cinco médicos.• Empareje solamente jugadores con un máximo de 50 ms de latencia.• Si un emparejamiento no se completa rápidamente, relaje el requisito de latencia de los jugadores de la

siguiente manera:• Transcurridos 10 segundos, permita valores de latencia de los jugadores de hasta 100 ms.• Transcurridos 20 segundos, permita valores de latencia de los jugadores de hasta 150 ms.


• El conjunto de reglas garantiza que los equipos estén emparejados de manera uniforme según lashabilidades de los jugadores. Para evaluar la regla FairTeamSkill, FlexMatch prueba a agregar elposible jugador a un equipo, calcula la habilidad media de los jugadores del equipo y la compara con lahabilidad media de los jugadores de ambos equipos. Si la regla genera un error, no se agrega el posiblejugador al emparejamiento.

• Los requisitos del equipo y del nivel de emparejamiento (número total de médicos) se logran medianteuna regla de colección. Este tipo de regla toma una lista de atributos de personajes para todos losjugadores y la compara con los recuentos máximos. Utilice flatten para crear una lista de todos losjugadores en todos los equipos.

• Cuando realice la evaluación en función de la latencia, tenga en cuenta lo siguiente:• Se proporcionan datos de latencia en la solicitud de emparejamiento como parte del objeto Player. No

se trata de un atributo del jugador, por lo que no necesita enumerarse como tal.• El creador de emparejamientos evalúa la latencia por región. Cualquier región con una latencia

superior al máximo se ignora. Para ser aceptado para un emparejamiento, un jugador debe tener almenos una región con una latencia por debajo del máximo.

• Si en una solicitud de emparejamiento no se proporcionan los datos de latencia de uno o variosjugadores, la solicitud se rechaza para todos los emparejamientos.

{ "name": "three_team_game", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "skill", "type": "number",

Version109


"default": 10 },{ "name": "character", "type": "string_list", "default": [ "peasant" ] }], "teams": [{ "name": "red", "minPlayers": 3, "maxPlayers": 5 }, { "name": "blue", "minPlayers": 3, "maxPlayers": 5 }, { "name": "green", "minPlayers": 3, "maxPlayers": 5 }], "rules": [{ "name": "FairTeamSkill", "description": "The average skill of players in each team is within 10 points from the average skill of players in the match", "type": "distance", // get players for each team, and average separately to produce list of 3 "measurements": [ "avg(teams[*].players.attributes[skill])" ], // get players for each team, flatten into a single list, and average to produce overall average "referenceValue": "avg(flatten(teams[*].players.attributes[skill]))", "maxDistance": 10 // minDistance would achieve the opposite result }, { "name": "CloseTeamSizes", "description": "Only launch a game when the team sizes are within 1 of each other. e.g. 3 v 3 v 4 is okay, but not 3 v 5 v 5", "type": "distance", "measurements": [ "max(count(teams[*].players))"], "referenceValue": "min(count(teams[*].players))", "maxDistance": 1 }, { "name": "OverallMedicLimit", "description": "Don't allow more than 5 medics in the game", "type": "collection", // This is similar to above, but the flatten flattens everything into a single // list of characters in the game. "measurements": [ "flatten(teams[*].players.attributes[character])"], "operation": "contains", "referenceValue": "medic", "maxCount": 5 }, { "name": "FastConnection", "description": "Prefer matches with fast player connections first", "type": "latency", "maxLatency": 50 }], "expansions": [{ "target": "rules[FastConnection].maxLatency", "steps": [{ "waitTimeSeconds": 10, "value": 100 }, { "waitTimeSeconds": 20, "value": 150 }] }]}

Version110


Ejemplo 4: Utilizar la ordenación explícita para encontrar losmejores emparejamientosEste ejemplo configura un emparejamiento sencillo con dos equipos de tres jugadores. Muestra cómoutilizar reglas de ordenación explícitas para encontrar los mejores emparejamientos posibles lo más rápidoposible. Estas reglas ordenan previamente todos los tickets de emparejamiento activos para crear losmejores emparejamientos según determinados requisitos clave. Esta situación se implementa con lassiguientes instrucciones:

• Cree dos equipos de jugadores.• Incluya exactamente tres jugadores en cada equipo.• Incluya los siguientes atributos de los jugadores:

• Nivel de experiencia (si no se proporciona, de manera predeterminada es 50).• Modos de juego preferidos (puede enumerar varios valores) (si no se proporcionan, de manera

predeterminada son "coop" y "deathmatch").• Mapas de juego preferidos, se incluyen el nombre del mapa y la ponderación de preferencias (si no se

proporciona, de manera predeterminada es "defaultMap" con un peso de 100).• Configure la ordenación previa:

• Ordene los jugadores en función de su preferencia por el mismo mapa de juego que el jugador dereferencia. Los jugadores pueden tener varios mapas de juego favoritos, por lo que este ejemplo utilizaun valor de preferencia.

• Ordene los jugadores según el grado de coincidencia de su nivel de experiencia con el del jugadorde referencia. Con esta ordenación, todos los jugadores de todos los equipos tendrían niveles deexperiencia lo más similares posible.

• Todos los jugadores de todos los equipos deben haber seleccionado al menos un modo de juego encomún.

• Todos los jugadores de todos los equipos deben haber seleccionado al menos un mapa de juego encomún.


• La ordenación de mapa de juego utiliza una ordenación absoluta que compara el valor del atributomapPreference. En primer lugar se coloca en el conjunto de reglas para priorizarlo.

• La ordenación por experiencia utiliza una ordenación por distancia que compara la distancia de unposible jugador respecto de un jugador de referencia.

• El orden de las reglas de ordenación determina el orden en el que se realiza cada ordenación. En estasituación, se ordena a los jugadores por preferencia de mapa de juego y, a continuación, por el nivel deexperiencia.

{ "name": "multi_map_game", "ruleLanguageVersion": "1.0", "playerAttributes": [{ "name": "experience", "type": "number", "default": 50 }, { "name": "gameMode", "type": "string_list", "default": [ "deathmatch", "coop" ] }, { "name": "mapPreference", "type": "string_number_map",

Version111


"default": { "defaultMap": 100 } }, { "name": "acceptableMaps", "type": "string_list", "default": [ "defaultMap" ] }], "teams": [{ "name": "red", "maxPlayers": 3, "minPlayers": 3 }, { "name": "blue", "maxPlayers": 3, "minPlayers": 3 }], "rules": [{ // We placed this rule first since we want to prioritize players preferring the same map "name": "MapPreference", "description": "Favor grouping players that have the highest map preference aligned with the anchor's favorite", // This rule is just for sorting potential matches. We sort by the absolute value of a field. "type": "absoluteSort", // Highest values go first "sortDirection": "descending", // Sort is based on the mapPreference attribute. "sortAttribute": "mapPreference", // We find the key in the anchor's mapPreference attribute that has the highest value. // That's the key that we use for all players when sorting. "mapKey": "maxValue" }, { // This rule is second because any tie-breakers should be ordered by similar experience values "name": "ExperienceAffinity", "description": "Favor players with similar experience", // This rule is just for sorting potential matches. We sort by the distance from the anchor. "type": "distanceSort", // Lowest distance goes first "sortDirection": "ascending", "sortAttribute": "experience" }, { "name": "SharedMode", "description": "The players must have at least one game mode in common", "type": "collection", "operation": "intersection", "measurements": [ "flatten(teams[*].players.attributes[gameMode])"], "minCount": 1 }, { "name": "MapOverlap", "description": "The players must have at least one map in common", "type": "collection", "operation": "intersection", "measurements": [ "flatten(teams[*].players.attributes[acceptableMaps])"], "minCount": 1 }]}

Version112


Ejemplo 5: Buscar las intersecciones entre varios atributos de losjugadoresEste ejemplo ilustra cómo utilizar una regla de colección para encontrar intersecciones en dos o másatributos de los jugadores. Cuando trabaje con colecciones, puede utilizar la operación intersectionpara un único atributo y la operación reference_intersection_count para varios atributos.

Para ilustrar este enfoque, este ejemplo evalúa los jugadores de un emparejamiento en función de suspersonajes preferidos. El juego del ejemplo es de tipo "todos contra todos" en el que todos los jugadoresde un emparejamiento son oponentes entre sí. A cada jugador se le pide que (1) elija un personaje parasí mismo, y (2) elija los personajes contra los que desea jugar. Necesitamos una regla que garantice quecada jugador de un emparejamiento utiliza un personaje que está la lista de oponentes preferidos de todoslos demás jugadores.

El conjunto de reglas del ejemplo describe un emparejamiento con las siguientes características:

• Estructura del equipo: un equipo de cinco jugadores• Atributos de los jugadores:

• myCharacter: el personaje elegido por el jugador.• preferredOpponents: lista de personajes contra los que desea jugar el jugador.

• Reglas de emparejamiento: un posible emparejamiento es aceptable si cada uno de los personajes enuso se encuentra en la lista de oponentes preferidos de cada jugador.

Para implementar la regla de emparejamiento, en este ejemplo se utiliza una regla de colección con lossiguientes valores de propiedades:

• Operación: utiliza la operación reference_intersection_count para evaluar el grado decoincidencia de cada lista de cadenas del valor de medición con la lista de cadenas del valor dereferencia.

• Medición: utiliza la expresión de propiedad flatten para crear una lista de listas de cadenas, cada unade las cuales contiene el valor del atributo myCharacter de un jugador.

• Valor de referencia: utiliza la expresión de propiedad set_intersection para crear una lista decadenas de todos los valores del atributo preferredOpponents que son comunes a cada jugador delemparejamiento.

• Restricciones: minCount se establece en 1 para garantizar que el personaje elegido por cada jugador(una lista de cadenas en la medición) coincide al menos con uno de los oponentes preferidos comunes atodos los jugadores (una cadena en el valor de referencia).

• Expansion: si no se consigue realizar un emparejamiento en 15 segundos, relajar el requisito mínimo deintersección.

El flujo de proceso para esta regla es el siguiente:

1. Se añade un jugador al posible emparejamiento. El valor de referencia (una lista de cadenas) se vuelvea calcular para incluir las intersecciones con la lista de oponentes preferidos del nuevo jugador. El valorde la medición (una lista de listas de cadenas) se vuelve a calcular para añadir el personaje elegido deljugador nuevo como una lista de cadenas nueva.

2. Amazon GameLift verifica que cada lista de cadenas del valor de medición (los personajes elegidos porlos jugadores) coincide al menos con una cadena del valor de referencia (los oponentes preferidos delos jugadores). Dado que en este ejemplo cada lista de cadenas de la medición contiene solo un valor,la intersección es 0 o 1.

3. Si cualquier lista de cadenas de la medición no tiene un valor que coincide con la lista de cadenas devalores de referencia, la regla no se cumple y el jugador nuevo se elimina del posible emparejamiento.

Version113


4. Si no se consigue un emparejamiento en un plazo de 15 segundos, se elimina el requisitode emparejamiento con el contrincante para rellenar el resto de ranuras de jugadores en elemparejamiento.

{ "name": "preferred_characters", "ruleLanguageVersion": "1.0",

"playerAttributes": [{ "name": "myCharacter", "type": "string_list" }, { "name": "preferredOpponents", "type": "string_list" }],

"teams": [{ "name": "red", "minPlayers": 5, "maxPlayers": 5 }],

"rules": [{ "description": "Make sure that all players in the match are using a character that is on all other players' preferred opponents list.", "name": "OpponentMatch", "type": "collection", "operation": "reference_intersection_count", "measurements": ["flatten(teams[*].players.attributes[myCharacter])"], "referenceValue": "set_intersection(flatten(teams[*].players.attributes[preferredOpponents]))", "minCount":1 }], "expansions": [{ "target": "rules[OpponentMatch].minCount", "steps": [{ "waitTimeSeconds": 15, "value": 0 }] }]}

Ejemplo 6: Comparar los atributos entre todos los jugadoresEste ejemplo ilustra cómo comparar los atributos de los jugadores entre un grupo de jugadores.

El conjunto de reglas del ejemplo describe un emparejamiento con las siguientes características:

• Estructura de equipos: dos equipos de un jugador cada uno• Atributos de los jugadores:

• gameMode: tipo de juego elegido por el jugador (si no se proporciona, el valor predeterminado es"turn-based" (por turnos)).

• gameMap: mundo del juego elegido por el jugador (si no se proporciona, el valor predeterminado es1).

• character: personaje elegido por el jugador (si no hay ningún valor predeterminado, significa que losjugadores deben especificar un personaje).

• Reglas de emparejamiento: los jugadores deben emparejarse de acuerdo con los requisitos siguientes:• Los jugadores deben elegir el mismo modo de juego.• Los jugadores deben elegir el mismo mapa de juego.

Version114

Amazon GameLift Developer GuideConfigurar la notificación de eventos

• Los jugadores deben elegir personajes distintos.

Para implementar la regla de emparejamiento, en este ejemplo se utilizan reglas de comparación paracomprobar todos los valores de los atributos de los jugadores. Para el modo y el mapa de juego, la reglaverifica que los valores sean los mismos. Para el personaje, la regla verifica que los valores sean distintos.

{ "name": "", "ruleLanguageVersion": "1.0",

"playerAttributes": [{ "name": "gameMode", "type": "string", "default": "turn-based" }, { "name": "gameMap", "type": "number", "default": 1 }, { "name": "character", "type": "number" }],

"teams": [{ "name": "red", "minPlayers": 1, "maxPlayers": 1 }, { "name": "blue", "minPlayers": 1, "maxPlayers": 1 }],

"rules": [{ "name": "SameGameMode", "description": "Only match players when they choose the same game type", "type": "comparison", "operation": "=", "measurements": ["flatten(teams[*].players.attributes[gameMode])"] }, { "name": "SameGameMap", "description": "Only match players when they're in the same map", "type": "comparison", "operation": "=", "measurements": ["flatten(teams[*].players.attributes[gameMap])"] }, { "name": "DifferentCharacter", "description": "Only match players when they're using different characters", "type": "comparison", "operation": "!=", "measurements": ["flatten(teams[*].players.attributes[character])"] }]}

Configuración de la notificación de eventos enFlexMatch

Si utiliza el emparejamiento de FlexMatch en un juego, necesita un método que le permita realizar elseguimiento del estado de cada solicitud de emparejamiento y tomar la medida apropiada. A veces, como

Version115

Amazon GameLift Developer GuideConfiguración de Eventos de CloudWatch

cuando los jugadores tienen que aceptar un emparejamiento propuesto, estas acciones son prioritarias.El método más sencillo para hacer un seguimiento del estado de cada solicitud consiste en realizar unsondeo continuamente utilizando DescribeMatchmaking. Sin embargo, para una solución más rápida,recomendamos el uso de notificaciones para realizar un seguimiento de los eventos de emparejamiento.Las notificaciones de eventos son muy fáciles de configurar y son mucho más rápidas y eficaces.

Existen dos opciones para configurar las notificaciones de eventos. Puede utilizar Amazon CloudWatchEvents, que dispone de un conjunto de herramientas disponibles para administrar eventos y tomar lasmedidas necesarias. De forma alternativa, puede configurar sus propios temas de SNS y adjuntarlos a sucreador de emparejamientos para recibir notificaciones de eventos de emparejamiento directamente.

Consulte la lista de eventos de FlexMatch emitida por Amazon GameLift en Referencia de eventos deFlexMatch (p. 193).

Configuración de Eventos de CloudWatchAmazon GameLift publica automáticamente todos los eventos de emparejamiento en Eventosde CloudWatch. Con Eventos de CloudWatch puede configurar reglas para que los eventos deemparejamiento se dirijan a un rango de objetivos, incluidos temas de SNS y otros servicios de AWS parasu procesamiento. Por ejemplo, puede establecer una regla para dirigir el evento "PotentialMatchCreated"a una función de AWS Lambda que administre aceptaciones de jugadores. Obtenga más informaciónsobre cómo utilizar Eventos de CloudWatch en la Guía de introducción, que incluye una colección detutoriales.

Si tiene previsto utilizar Eventos de CloudWatch, cuando configure sus creadores de emparejamiento,puede dejar el campo de destino de notificaciones vacío o hacer referencia a un tema de SNS si deseautilizar ambas opciones.

Para obtener acceso a eventos de emparejamiento de Amazon GameLift en Eventos de CloudWatch,vaya a la consola de Amazon CloudWatch y abra Events. Asegúrese de que está en la región dondeha establecido la configuración del emparejamiento. Para obtener más información sobre cómo obtenercredenciales de cuenta para acceder a Eventos de CloudWatch consulte Inicio de sesión en la consolade Amazon CloudWatch. Cada evento de emparejamiento se identifica mediante el servicio (GameLift), elnombre del emparejamiento y el ticket del emparejamiento.

Configuración de un tema de SNSPuede pedir a Amazon GameLift que publique todos los eventos generados por un creador deemparejamiento de FlexMatch en un tema de Amazon Simple Notification Service (SNS). Al configurar elcreador de emparejamientos, defina el campo de destino de notificación en un ARN de tema de SNS.

Para configurar un tema de SNS para la notificación de eventos de Amazon GameLift

1. Vaya a la consola de Amazon Simple Notification Service.2. Creación de un tema. Desde el panel de SNS, elija Create topic y siga las instrucciones para crear el

tema. Cuando se crea el tema, la consola abre automáticamente la página Topic details para el temanuevo.

3. Permitir que Amazon GameLift publique en el tema. Si todavía no está en la página Topic details parasu tema, elija Topics en la barra de navegación y haga clic en el ARN de los temas para abrirlo. Elija laacción del tema Edit topic policy y vaya a la pestaña Advanced view.

Agregue la sintaxis en negrita, al final de la política existente. Se muestra la política completa paramayor claridad.

{ "Version": "2008-10-17",

Version116

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeMatchmaking.html

https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/CWE_GettingStarted.html

https://aws.amazon.com/cloudwatch

https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/GettingSetup_cwe.html

https://docs.aws.amazon.com/AmazonCloudWatch/latest/events/GettingSetup_cwe.html

https://aws.amazon.com/sns

Amazon GameLift Developer GuideAgregar FlexMatch a un cliente de juego

"Id": "__default_policy_ID", "Statement": [ { "Sid": "__default_statement_ID", "Effect": "Allow", "Principal": { "AWS": "*" }, "Action": [ "SNS:GetTopicAttributes", "SNS:SetTopicAttributes", "SNS:AddPermission", "SNS:RemovePermission", "SNS:DeleteTopic", "SNS:Subscribe", "SNS:ListSubscriptionsByTopic", "SNS:Publish", "SNS:Receive" ], "Resource": "arn:aws:sns:your_region:your_account:your_topic_name", "Condition": { "StringEquals": { "AWS:SourceOwner": "your_account" } } }, { "Sid": "__console_pub_0", "Effect": "Allow", "Principal": { "Service": "gamelift.amazonaws.com" }, "Action": "SNS:Publish", "Resource": "arn:aws:sns:your_region:your_account:your_topic_name" } ]}

Agregar FlexMatch a un cliente de juegoEn este tema, se describe cómo se inicia el proceso de emparejamiento de FlexMatch con sus jugadores.Para obtener más información acerca de FlexMatch y de cómo configurarlo para los juegos, consulte estostemas:

• Amazon GameLift FlexMatch (p. 10)• Guía de integración de FlexMatch (p. 98)

Note

A la hora de solicitar emparejamientos para sus jugadores, recomendamos encarecidamenterealizar estas solicitudes a través de un servicio de juego del lado del cliente y no directamentedesde su cliente de juego. Al utilizar una fuente de confianza, es más sencillo protegerse frentea intentos de piratería y evitar el uso de datos de jugadores falsos que podrían arruinar laexperiencia de juego de sus jugadores. Si su juego utiliza un servicio de directorio de sesiones,esta es una buena opción para controlar las solicitudes de emparejamiento.

Al igual que con otras funcionalidades de cliente, su servicio de juego habilita el emparejamiento a travésdel uso del SDK de AWS con la API de Amazon GameLift. Este SDK está disponible en C++, C # y enotros lenguajes. Para obtener una descripción general de las API de cliente, consulte Referencia de la API

Version117


Amazon GameLift Developer GuideSolicitar el emparejamiento de jugadores

del servicio Amazon GameLift, que describe la API del servicio de bajo nivel para acciones relacionadascon Amazon GameLift e incluye enlaces a guías de referencia específicas de lenguaje.

La información de este tema supone que (1) ha creado una configuración de emparejamiento (consulteDiseño de un creador de emparejamientos de FlexMatch (p. 99)); y (2) ha integrado correctamenteAmazon GameLift en el servicio de juego (consulte Adición de Amazon GameLift al cliente dejuego (p. 35)). Para probar FlexMatch en el juego, también deberá configurar el servidor de juegos paraque las sesiones de juego se inicien de forma adecuada para los emparejamientos (consulte AgregarFlexMatch a un servidor de juegos (p. 121)).

Si desea habilitar FlexMatch para los clientes de juego, tendrá que agregar la siguiente funcionalidad:

• Solicite el emparejamiento para uno o varios jugadores.• Haga un seguimiento del estado de las solicitudes de emparejamiento.• Solicite la aceptación de un jugador para un propuesta de emparejamiento.• Una vez que se ha creado una sesión de juego para el nuevo emparejamiento, obtenga la información

de la conexión del jugador y únase al juego.

Si utiliza FlexMatch, puede configurar el proceso de reposición de los juegos. La reposición deemparejamientos ayuda a mantener las sesiones de juegos llenas a medida que los jugadores abandonanel juego y es particularmente útil en juegos con una vida útil más larga. Garantiza que los nuevosjugadores que entran en el juego satisfacen los mismos criterios de emparejamiento que los jugadoresexistentes. Encontrará más información sobre la reposición de emparejamientos en FuncionamientodeAmazon GameLift FlexMatch (p. 11). Para obtener ayuda sobre la configuración, consulte Reposición dejuegos existentes con FlexMatch (p. 123).

Solicitar el emparejamiento de jugadoresAgregue código para crear y enviar una solicitud de emparejamiento a un creador de emparejamientos deFlexMatch. Para administrar la solicitudes de emparejamiento, utilice estas API:

• StartMatchmaking• StopMatchmaking

Para crear una solicitud de emparejamiento, llame a StartMatchmaking con la siguiente información.

Creador de emparejamientos

Especifique el nombre de la configuración de emparejamiento que desea utilizar para la solicitud.FlexMatch ubica cada solicitud en el grupo de solicitudes del creador de emparejamiento especificado.La solicitud se procesará en función del conjunto de normas y la configuración del creador deemparejamiento.

ID del ticket

Especifique un ID de ticket. Se debe asignar un ID de ticket único a todas las solicitudes deemparejamiento. Usted es responsable de generar, asignar y administrar los ID de ticket. Puede utilizarcualquier formato de cadena, hasta un máximo de 128 caracteres. Los ID de ticket se adjuntan a todas lassolicitudes, eventos y notificaciones relacionados con el emparejamiento.

Datos del jugador

Especifique uno o más jugadores para los que desea crear un emparejamiento. Si incluye a variosjugadores en una única solicitud, FlexMatch intentará crear un emparejamiento para todos los jugadoresy colocarlos en el mismo equipo. Todos los jugadores de una solicitud deben pasar las reglas deemparejamiento para que la solicitud produzca un emparejamiento.

Version118


https://docs.aws.amazon.com/gamelift/latest/apireference/API_StartMatchmaking.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_StopMatchmaking.html

Amazon GameLift Developer GuideHacer un seguimiento del estado delas solicitudes de emparejamiento

Note

Un jugador (identificado por su ID de jugador) solo puede incluirse en una solicitudde emparejamiento activa en cada momento. Si se crea una solicitud nueva para unjugador, cualquier ticket de emparejamiento activo con el mismo ID de jugador se cancelaautomáticamente.

• ID del jugador: cada jugador debe tener un ID de jugador único generado por usted. Para obtener másinformación, consulte Generación de ID de jugador (p. 39).

• Atributos del jugador: para cada jugador en una solicitud, debe haber un conjunto de valores de atributosdel jugador según lo requiera el creador de emparejamientos. Se definen en el conjunto de reglas delcreador de emparejamientos y admiten reglas que evalúan posibles emparejamientos en función delos atributos del jugador como nivel de habilidades individuales. El nombre del atributo y el tipo dedatos en la solicitud de emparejamiento deben coincidir con lo definido en el conjunto de reglas delcreador de emparejamientos. Los atributos en un conjunto de reglas se pueden configurar con unvalor predeterminado que se utilizará cuando una solicitud de emparejamiento no proporciona uno.Sin embargo, si un atributo no tiene ningún valor predeterminado y la solicitud de emparejamiento noproporciona uno, el jugador no podrá emparejarse (y la solicitud de emparejamiento fracasará). Paraobtener más información sobre los conjuntos de reglas del creador de emparejamiento y los atributos delos jugadores, consulte the section called “Crear un conjunto de reglas” (p. 102).

• Latencias de los jugadores: los datos de latencia de los jugadores contienen valores de latenciainformados para una o más regiones. Los datos de latencia de los jugadores pueden utilizarse paraencontrar emparejamientos entre jugadores que informan latencias similares. Si se proporcionan,también se utilizan para colocar una sesión de juego de un emparejamiento en una región que ofrezca lalatencia más baja posible para todos los jugadores del emparejamiento.

Si un creador de emparejamientos tiene una regla que evalúa la latencia de los jugadores, estos debeninformar de la latencia para ser emparejados. En este caso, los jugadores solo pueden emparejarse enregiones para las que se proporciona un valor de latencia.

Otros factores que afectan a una solicitud de emparejamiento se establecen en la configuración deemparejamiento, incluido un plazo para solicitudes y aceptación opcional de emparejamientos deljugador. Todas las solicitudes de emparejamiento enviadas a un creador de emparejamientos seprocesan tal y como se han configurado. Para obtener más información sobre cómo configurar uncreador de emparejamientos y establecer reglas de emparejamiento, consulte Diseño de un creador deemparejamientos de FlexMatch (p. 99).

Una solicitud de emparejamiento se puede cancelar en cualquier momento utilizando StopMatchmaking.

Hacer un seguimiento del estado de las solicitudes deemparejamientoAgregue código a un servicio de juego para realizar un seguimiento del estado de todas las solicitudes deemparejamiento y responda según sea necesario. Hay un par de opciones disponibles para realizar unseguimiento del estado.

Notificaciones de eventos

Configure notificaciones para realizar un seguimiento de eventos que Amazon GameLift emite paraprocesos de emparejamiento. Este es el método recomendado: es fácil de configurar y permite un usoeficiente de los recursos. Puede configurar notificaciones directamente, mediante la creación de un temade SNS o a través de eventos de CloudWatch. Para obtener más información sobre la configuración denotificaciones, consulte Configuración de la notificación de eventos en FlexMatch (p. 115). Una vezconfiguradas las notificaciones, debe agregar un agente de escucha en su servicio de juego para detectarlos eventos y responder según sea necesario. También es buena idea sondear actualizaciones de estadosi no ha recibido una notificación después de 30 segundos.

Version119

Amazon GameLift Developer GuideSolicitar aceptación del jugador

Sondeo continuo

Recupere un ticket de solicitud de emparejamiento, incluido el estado actual, llamando aDescribeMatchmaking. Esta llamada devuelve información completa sobre la solicitud de emparejamiento.Una vez que se ha completado correctamente la solicitud, el ticket también contiene la informaciónnecesaria para conectar un jugador al emparejamiento. Recomendamos sondear no más de una vez cada10 segundos.

Solicitar aceptación del jugadorPara las solicitudes que utilizan un creador de emparejamientos con la aceptación de jugador activada, elservicio de juego debe ser capaz de hacer lo siguiente:

1. Detectar cuándo se requiere la aceptación de los jugadores. El servicio de juego debe ser capazde detectar cuándo el estado del ticket de emparejamiento es REQUIRES_ACCEPTANCE. Si estámonitorizando las notificaciones, los cambios que se produzcan en este estado activarán el eventoMatchmakingRequiresAcceptance de FlexMatch.

2. Obtener aceptaciones de todos los jugadores. Su servicio de juego debe tener un mecanismo parapresentar los detalles del emparejamiento a cada jugador en el ticket de emparejamiento y solicitar unaaceptación o rechazo. Puede recuperar detalles del emparejamiento llamando a DescribeMatchmaking.

3. Informar de las respuestas de los jugadores a FlexMatch. Informe de la aceptación de cadajugador llamando a AcceptMatch para aceptar o rechazar. Todos los jugadores en una solicitud deemparejamiento deben aceptar el emparejamiento para que avance.

4. Administrar tickets con aceptaciones erróneas. Su servicio de juego debe tener una manera deadministrar las solicitudes de emparejamiento que no logran la aceptación de jugadores. Esto incluye lassolicitudes en las que cualquier jugador de la solicitud rechaza el emparejamiento o no responde antesde que transcurra el plazo de aceptación.

Conexión a un emparejamientoAgregue código a su servicio de juego para administrar los emparejamientos completados correctamente(estado COMPLETED o evento MatchmakingSucceeded), según corresponda. Esto incluye entregar lainformación de la conexión del emparejamiento a los clientes del juego. Cuando se completa una solicitudde emparejamiento, la información de la conexión se añade al ticket de emparejamiento. La informaciónde conexión (consulte GameSessionConnectionInfo) incluye el puerto y la dirección IP de la sesión dejuego, así como un conjunto de ID de jugador e ID de sesión de jugador para todos los jugadores en elemparejamiento. Para recuperar un ticket de emparejamiento completado, llame a DescribeMatchmaking.

Su cliente de juego utiliza esta información para conectarse directamente al proceso del servidor quehospeda el emparejamiento. Una solicitud de conexión para una sesión de juego emparejada debe incluirun ID de jugador y un ID de sesión de jugador. Al igual que ocurre con todas las conexiones de sesiónde juego, el ID de sesión de jugador se utiliza para validar la solicitud de conexión del jugador y reclamaruna ranura reservada en la sesión de juego. Para sesiones de juego emparejadas, el ID de jugador asociael jugador conectado a un conjunto de datos de emparejamiento, incluidas asignaciones de equipo, quedescriben la sesión de juego (consulte GameSession).

Ejemplo de solicitud de StartMatchmakingEl siguiente código de ejemplo se basa en solicitudes de emparejamiento de una variedad de creadoresde emparejamiento. Como hemos visto, cada creador de emparejamientos tiene sus propios requisitos deatributos del jugador; las solicitudes de emparejamiento deben satisfacer esos requisitos.

# Uses matchmaker for two-team game mode based on player skill leveldef start_matchmaking_for_cowboys_vs_aliens(config_name, ticket_id, player_id, skill, team):

Version120



https://docs.aws.amazon.com/gamelift/latest/apireference/API_AcceptMatch.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_GameSessionConnectionInfo.html



Amazon GameLift Developer GuideAgregar FlexMatch a un servidor de juegos

response = gamelift.start_matchmaking( ConfigurationName=config_name, Players=[{ "PlayerAttributes": { "skill": {"N": skill} }, "PlayerId": player_id, "Team": team }], TicketId=ticket_id)

# Uses matchmaker for monster hunter game mode based on player skill leveldef start_matchmaking_for_players_vs_monster(config_name, ticket_id, player_id, skill, is_monster): response = gamelift.start_matchmaking( ConfigurationName=config_name, Players=[{ "PlayerAttributes": { "skill": {"N": skill}, "desiredSkillOfMonster": {"N": skill}, "wantsToBeMonster": {"N": int(is_monster)} }, "PlayerId": player_id }], TicketId=ticket_id)

# Uses matchmaker for brawler game mode with latencydef start_matchmaking_for_three_team_brawler(config_name, ticket_id, player_id, skill, role): response = gamelift.start_matchmaking( ConfigurationName=config_name, Players=[{ "PlayerAttributes": { "skill": {"N": skill}, "character": {"S": [role]}, }, "PlayerId": player_id, "LatencyInMs": { "us-west-2": 20} }], TicketId=ticket_id)

# Uses matchmaker for multiple game modes and maps based on player experiencedef start_matchmaking_for_multi_map(config_name, ticket_id, player_id, skill, maps, modes): response = gamelift.start_matchmaking( ConfigurationName=config_name, Players=[{ "PlayerAttributes": { "experience": {"N": skill}, "gameMode": {"SL": modes}, "mapPreference": {"SL": maps} }, "PlayerId": player_id }], TicketId=ticket_id)

Agregar FlexMatch a un servidor de juegosEn este tema, se describe cómo Amazon GameLift FlexMatch se integra en el servidor de juegos. Estaes una de las tareas necesarias para añadir características de FlexMatch al juego; consulte Guía deintegración de FlexMatch (p. 98) para ver todo el proceso. Para obtener una descripción detallada delemparejamiento personalizado de FlexMatch, consulte Amazon GameLift FlexMatch (p. 10).

Version121

Amazon GameLift Developer GuideConfigurar el servidor de juegos para el emparejamiento

La información de este tema supone que ha integrado correctamente el SDK del servidor de AmazonGameLift en el proyecto del servidor de juegos, tal y como se describe en Adición de Amazon GameLiftal servidor de juegos (p. 31). Con esta tarea completada, dispone de la mayoría de los mecanismosque necesita. En las secciones de este tema, se explican las demás tareas que son necesarias paraadministrar juegos configurados con FlexMatch.

Configurar el servidor de juegos para elemparejamientoPara configurar el servidor de juegos para gestionar juegos emparejados, complete las siguientes tareas.

1. Inicie sesiones de juego creadas con el emparejamiento. Para solicitar una nueva sesión de juego,Amazon GameLift envía una solicitud onStartGameSession() a su servidor de juegos con unobjeto de sesión de juego (consulte GameSession). Su servidor de juegos utiliza la información de lasesión de juego, incluidos los datos de juego personalizados, para iniciar la sesión de juego solicitada.Para obtener más información, consulte Inicio de una sesión de juego (p. 33).

Para juegos emparejados, el objeto de sesión de juego contiene un conjunto de datos del creador deemparejamientos, descritos más adelante en este tema. Los datos del creador de emparejamientosincluyen información que el servidor de juegos necesita para configurar una nueva sesión de juegopara el emparejamiento. Esto incluye la estructura del equipo del emparejamiento, asignaciones deequipo y ciertos atributos de los jugadores. Por ejemplo, puede utilizar la media de nivel de habilidadesde los jugadores para desbloquear determinadas características o niveles. Otro ejemplo sería permitira los jugadores elegir varias preferencias de mapa y, a continuación, crear emparejamientos con solouna opción de mapa común. En este caso, debería utilizar los datos de los atributos de los jugadorespara determinar el mapa adecuado para la sesión de juego. Consulte Trabajo con datos del creadorde emparejamientos (p. 122) para obtener más detalles.

2. Administre las conexiones de los jugadores. Al conectarse a un juego emparejado, el cliente de juegoreferencia un ID de jugador así como el ID de sesión de jugador usado para la validación (consulteValidación de un jugador nuevo (p. 33)) Su código debe utilizar el ID de jugador para asociar unjugador entrante a información del jugador en los datos del creador de emparejamientos. Los datos delcreador de emparejamientos identifican las asignaciones de equipo del jugador y pueden proporcionarotra información necesaria para representar correctamente al jugador en el juego. Por ejemplo, losatributos del jugador podrían determinar el personaje del juego del jugador, la ubicación o el estado enel juego, etc.

3. Informe cuando los jugadores abandonan un juego. Asegúrese de que el servidor de juegos llama ala API del servidor RemovePlayerSession() para comunicar el abandono de jugadores (consulteNotificación de la terminación de una sesión de jugador (p. 34)). Este paso es especialmenteimportante si utiliza la reposición de FlexMatch para completar ranuras vacías en juegos existentes yes crucial cuando se inician las solicitudes de reposición en el servicio de juego del lado del cliente.Para obtener más información sobre la implementación de la reposición de FlexMatch, consulteReposición de juegos existentes con FlexMatch (p. 123).

4. Solicite nuevos jugadores para sesiones de juego emparejadas existentes (opcional). Si va a intentarutilizar la característica de reposición de emparejamientos para añadir nuevos jugadores a juegosexistentes, puede enviar solicitudes de reposición directamente al servidor de juegos. Para obtenermás información, incluidas las opciones de solicitud, consulte Reposición de juegos existentescon FlexMatch (p. 123). Encontrará más información sobre la característica de reposición deemparejamientos en Funcionamiento deAmazon GameLift FlexMatch (p. 11).

Trabajo con datos del creador de emparejamientosSu servidor de juegos debe poder reconocer y utilizar la información del juego en un objeto GameSession.El servicio Amazon GameLift pasa estos objetos a su servidor de juegos siempre que se inicia o actualizauna sesión de juego. La información básica de la sesión de juego incluye nombre e ID de sesión del

Version122



Amazon GameLift Developer GuideReposición de juegos existentes

juego, número máximo de jugadores, información de conexión y datos de juego personalizados (si seproporcionan).

En el caso de las sesiones de juego creadas mediante FlexMatch, el objeto GameSession tambiéncontiene un conjunto de datos del creador de emparejamiento que se generó como parte del proceso deemparejamiento. Además de un ID de emparejamiento único, identifica al creador de emparejamientosque se utilizó para crear el emparejamiento y describe los equipos, asignaciones de equipos y jugadores.Incluye los atributos de los jugadores de la solicitud de emparejamiento original (consulte el objeto Player).No incluye la latencia de los jugadores; si necesita datos de latencia de los jugadores actuales, como parala reposición de emparejamientos, recomendamos obtener datos nuevos.

Note

Los datos del creador de emparejamientos especifican el ARN de configuración deemparejamientos completo, que identifica el nombre de la configuración y la cuenta y la región deAWS. A la hora de solicitar la reposición de emparejamiento, necesita el ARN de configuracióncompleto (cuando la solicitud se realiza desde un servidor de juegos) o solo el nombre de laconfiguración (cuando la solicitud se realiza desde un cliente de juego o un servicio de cliente).Puede extraer el nombre de la configuración de un valor de ARN analizando la cadena queva a continuación de ":matchmakingconfiguration/". En el ejemplo mostrado, el nombre de laconfiguración de emparejamiento es "MyMatchmakerConfig".

El siguiente JSON muestra un conjunto típico de datos del creador de emparejamiento. Este ejemplodescribe un juego de dos jugadores, con jugadores emparejados en función de sus puntuaciones dehabilidad y el nivel más alto alcanzado. El creador de emparejamientos también realiza emparejamientosen función del personaje y garantiza que los jugadores emparejados tengan al menos una preferencia demapa en común. En esta situación de ejemplo, el servidor de juegos debe poder detectar el mapa común,o seleccionarlo de varias preferencias comunes, para determinar qué mapa asignar a la sesión de juego.

{ "matchId":"1111aaaa-22bb-33cc-44dd-5555eeee66ff", "matchmakingConfigurationArn":"arn:aws:gamelift:us-west-2:111122223333:matchmakingconfiguration/MyMatchmakerConfig", "teams":[ {"name":"attacker", "players":[ {"playerId":"4444dddd-55ee-66ff-77aa-8888bbbb99cc", "attributes":{ "skills":{ "attributeType":"STRING_DOUBLE_MAP", "valueAttribute":{"Body":10.0,"Mind":12.0,"Heart":15.0,"Soul":33.0}} } }] },{ "name":"defender", "players":[{ "playerId":"3333cccc-44dd-55ee-66ff-7777aaaa88bb", "attributes":{ "skills":{ "attributeType":"STRING_DOUBLE_MAP", "valueAttribute":{"Body":11.0,"Mind":12.0,"Heart":11.0,"Soul":40.0}} } }] }]}

Reposición de juegos existentes con FlexMatchLa reposición de emparejamiento utiliza los mecanismos de FlexMatch para emparejar nuevos jugadoresa sesiones de juego existentes que ya están emparejadas. Aunque siempre puede añadir jugadores

Version123

https://docs.aws.amazon.com/gamelift/latest/apireference/API_Player.html

Amazon GameLift Developer GuideEnvío de solicitudes de reposición

(desde un servidor de juegos)

a cualquier juego (consulte Conexión de un jugador a una sesión de juego (p. 38)), la reposición deemparejamientos garantiza que los nuevos jugadores cumplirán los mismos criterios de emparejamientoque los jugadores actuales. Además, la reposición de emparejamientos asigna los nuevos jugadores aequipos, administra la aceptación de los jugadores y envía información de emparejamiento actualizada alproceso del servidor de juegos que se ejecuta en la sesión de juego. Encontrará más información sobre lareposición de emparejamientos en Funcionamiento deAmazon GameLift FlexMatch (p. 11).

En este tema describe cómo configurar la reposición de emparejamientos para su juego. Se suponeque ya ha creado los componentes de FlexMatch necesarios y que ha añadido correctamente procesosde emparejamiento al servidor de juegos y un servicio de juego del lado del cliente. Para obtener másinformación sobre la configuración de FlexMatch, consulte Guía de integración de FlexMatch (p. 98).

Para habilitar la reposición de emparejamientos para su juego, deberá añadir la siguiente funcionalidad:

• Envíe las solicitudes de reposición de emparejamiento a un creador de emparejamientos y realice unseguimiento del estado de las solicitudes.

• Actualice la información de emparejamiento de la sesión de juego.

Envío de solicitudes de reposición (desde un servidorde juegos)Puede iniciar solicitudes de reposición de emparejamiento directamente desde el proceso del servidor dejuego que hospeda la sesión de juego. El proceso del servidor tiene la información más actualizada sobrelos jugadores conectados al juego en un momento dado y el estado de ranuras de jugadores vacías.

Al igual que con otras funcionalidades del servidor, un servidor de juegos utiliza el SDK del servidor deAmazon GameLift. Este SDK está disponible en C++ y C#. Para obtener una descripción general de lasAPI del servidor, consulte las referencias de la API del servidor (p. 152).

Para realizar solicitudes de reposición de emparejamiento desde su servidor de juegos, complete lassiguientes tareas.

1. Dispare una solicitud de reposición de emparejamiento. Por lo general, es buena idea iniciar unasolicitud de reposición siempre que un juego emparejado tiene una o varias ranuras de jugadoresvacías. Es posible que desee vincular solicitudes de reposición a circunstancias específicas, porejemplo, para suplir funciones de personaje cruciales o equilibrar equipos. También es probable quedesee limitar la actividad de reposición en función de la antigüedad de una sesión de juego.

2. Cree una solicitud de reposición. Añada código para crear y enviar solicitudes de reposición deemparejamiento a un creador de emparejamiento de FlexMatch. Las solicitudes de reposición segestionan con estas API del servidor:

• StartMatchBackfill() (p. 160)• StopMatchBackfill() (p. 161)

Para crear una solicitud de reposición, llame a StartMatchBackfill con la siguiente información.Para cancelar una solicitud de reposición, llame a StopMatchBackfill con el ID del ticket desolicitud de reposición.

• Ticket ID (ID del ticket): proporcione un ID del ticket del creador de emparejamientos (o puedeoptar por que se generen automáticamente). Puede utilizar el mismo mecanismo para asignar IDde tickets tanto para el creador de emparejamientos como para las solicitudes de reposición. Lostickets para el emparejamiento y la reposición se procesan de la misma forma.

• Matchmaker (Creador de emparejamientos): identifique qué creador de emparejamientos utilizarpara la solicitud de reposición. Por lo general, deberá utilizar el mismo creador de emparejamientosque se usó para crear el emparejamiento original. Esta solicitud toma un ARN de configuración

Version124


(desde un servicio de cliente)

de creador de emparejamientos. Esta información se almacena en el objeto de sesión de juego(GameSession), que Amazon GameLift proporcionó al proceso del servidor cuando se activóla sesión de juego. La configuración del ARN de emparejamiento se incluye en la propiedadMatchmakerData.

• Game session ARN (ARN de sesión de juego): identifique la sesión de juego que seva a reponer. Para obtener el ARN de la sesión de juego, llame a la API del servidorGetGameSessionId() (p. 155). Durante el proceso de emparejamiento, los tickets de las nuevassolicitudes no tienen un ID de sesión de juego, mientras que los tickets de las solicitudes dereposición si lo tienen. La presencia del ID de sesión de juego es una forma de saber la diferenciaentre los tickets de los nuevos emparejamientos y los tickets de las reposiciones.

• Player data (Datos del jugador): incluya información del jugador (Player) de todos los jugadoresactuales en la sesión de juego que está en fase de reposición. Esta información permite a loscreadores de emparejamientos localizar los mejores emparejamientos de jugador para los jugadoresque se encuentren en la sesión de juego. Si el servidor de juegos ha comunicado de forma precisael estado de conexión del jugador, tendría que poder adquirir estos datos como sigue:1. El proceso del servidor que hospeda la sesión de juego debe tener la información más

actualizada sobre que jugadores están actualmente conectados a la sesión de juego.2. Para obtener los ID, atributos y asignaciones de equipo del jugador, extraiga datos del jugador de

la propiedad MatchmakerData del objeto de sesión de juego (GameSession) (consulte Trabajocon datos del creador de emparejamientos (p. 122)). Los datos del creador de emparejamientosincluyen a todos los jugadores emparejados en la sesión de juego, por lo que tendrá que extraerlos datos solo de los jugadores actualmente conectados.

3. Para la latencia de los jugadores, si el creador de emparejamientos solicita datos de latencia,recopile nuevos valores de latencia de todos los jugadores actuales e inclúyalos en cada objetoPlayer. Si se omiten los datos de latencia y el creador de emparejamientos tiene una regla delatencia, la solicitud no se emparejará correctamente. Las solicitudes de reposición exigen datosde latencia solo para la región en la que se encuentra el juego en esos momentos. Puede obteneruna región de sesión de juego de la propiedad GameSessionId del objeto GameSession; estevalor es un ARN, que incluye la región.

3. Haga un seguimiento del estado de una solicitud de reposición. Amazon GameLift actualiza en suservidor de juegos el estado de las solicitudes de reposición por medio de la función de devoluciónde llamada del SDK del servidor onUpdateGameSession (consulte Preparación de un proceso delservidor (p. 32)). Añada código para gestionar los mensajes estado —así como los objetos de sesiónde juego actualizados como resultado de solicitudes de reposición correctas— en Actualización dedatos de emparejamientos en el servidor de juegos (p. 127).

Un creador de emparejamientos solo puede procesar una solicitud de reposición deemparejamiento de una sesión de juego a la vez. Si necesita cancelar una solicitud, llame aStopMatchBackfill() (p. 161). Si necesita cambiar una solicitud, llame a StopMatchBackfill yenvíe una solicitud actualizada.

Envío de solicitudes de reposición (desde un serviciode cliente)Como alternativa a enviar solicitudes de reposición desde un servidor de juegos, puede enviarlas desdeun servicio de juego del lado del cliente. Para utilizar esta opción, el servicio del lado del cliente debe teneracceso a datos actualizados de la actividad de la sesión de juego y las conexiones del jugador; si el juegoutiliza un servicio de directorio de sesiones, esto podría ser una buena opción.

Al igual que con otras funcionalidades de cliente, un servicio de juego del lado del cliente utiliza el SDKde AWS con una API de Amazon GameLift. Este SDK está disponible en C++, C # y en otros lenguajes.Para obtener una descripción general de las API de cliente, consulte la Referencia de la API del servicioAmazon GameLift, que describe las API de servicio de bajo nivel para acciones relacionadas con AmazonGameLift e incluye enlaces a guías de referencia específicas de un lenguaje.

Version125





(desde un servicio de cliente)

Para configurar un servicio de juego del lado del cliente para reponer juegos emparejados, complete lassiguientes tareas.

1. Dispare una solicitud de reposición. Por lo general, un juego inicia una solicitud de reposición siempreque un juego emparejado tiene una o varias ranuras de jugadores vacías. Es posible que deseevincular solicitudes de reposición a circunstancias específicas, por ejemplo, para suplir funciones depersonaje cruciales o equilibrar equipos. También es probable que desee limitar las reposicionesen función de la antigüedad de una sesión de juego. Independientemente de lo que utilice comodisparador, necesitará la siguiente información como mínimo. Puede obtener esta información de lasesión de juego del objeto (GameSession) llamando a DescribeGameSessions con un ID de sesión dejuego.

• Número de ranuras de jugadores vacías en la actualidad. Este valor se puede calcular a partir dellímite de jugadores máximos de una sesión de juego y el recuento actual de jugadores. El recuentoactual de jugadores se actualiza siempre que el servidor de juegos contacta con el servicio AmazonGameLift para validar la conexión de un nuevo jugador o para informar del abandono de un jugador.

• Política de creación. Esta configuración indica si la sesión de juego acepta nuevos jugadores.

El objeto de sesión de juego contiene otra información potencialmente útil, incluida la hora de inicio dela sesión de juego, propiedades personalizadas del juego y datos del creador de emparejamientos.

2. Cree una solicitud de reposición. Añada código para crear y enviar solicitudes de reposición deemparejamiento a un creador de emparejamiento de FlexMatch. Las solicitudes de reposición segestionan con estas API del cliente:

• StartMatchBackfill• StopMatchmaking

Para crear una solicitud de reposición, llame a StartMatchBackfill con la siguiente información.Una solicitud de reposición es parecida a una solicitud de creador de emparejamientos (consulteSolicitar el emparejamiento de jugadores (p. 118)), pero además identifica la sesión de juegoexistente. Para cancelar una solicitud de reposición, llame a StopMatchmaking con el ID del ticketde solicitud de reposición.

• Ticket ID (ID del ticket): proporcione un ID del ticket del creador de emparejamientos (o puedeoptar por que se generen automáticamente). Puede utilizar el mismo mecanismo para asignar IDde tickets tanto para el creador de emparejamientos como para las solicitudes de reposición. Lostickets para el emparejamiento y la reposición se procesan de la misma forma.

• Matchmaker (Creador de emparejamientos): identifique el nombre de la configuración del creadorde emparejamientos que se va a usar. Por lo general, deberá utilizar el mismo creador deemparejamientos para la reposición que el que se usó para crear el emparejamiento original.Esta información se encuentra en la propiedad MatchmakerData de un objeto de sesión dejuego (GameSession), bajo el ARN de configuración del creador de emparejamientos. El valor delnombre es la cadena después de ""matchmakingconfiguration/". (Por ejemplo, en el valor de ARN"arn:aws:gamelift:us-west-2:111122223333:matchmakingconfiguration/MM-4v4", el nombre de laconfiguración del creador de emparejamientos es "MM-4v4".)

• Game session ARN (ARN de sesión de juego): especifique la sesión de juego que se va a reponer.Utilice la propiedad GameSessionId del objeto de sesión de juego; este ID utiliza el valor deARN que usted necesita. Los tickets del creador de emparejamientos (MatchmakingTicket) parasolicitudes de reposición tienen el ID de sesión de juego mientras están siendo procesados; lostickets de nuevas solicitudes de emparejamiento no reciben un ID de sesión de juego hasta que elemparejamiento está implementado; la presencia del ID de sesión de juego es una forma de saberla diferencia entre tickets para nuevos emparejamientos y tickets para reposiciones.

Version126



https://docs.aws.amazon.com/gamelift/latest/apireference/API_StartMatchBackfill.html



https://docs.aws.amazon.com/gamelift/latest/apireference/API_MatchmakingTicket.html

Amazon GameLift Developer GuideActualización de datos de

emparejamientos en el servidor de juegos

• Player data (Datos del jugador): incluya información del jugador (Player) de todos los jugadoresactuales en la sesión de juego que está en fase de reposición. Esta información permite al creadorde emparejamientos localizar los mejores emparejamientos de jugador para los jugadores quese encuentren en la sesión de juego. Si el servidor de juegos ha comunicado de forma precisa elestado de conexión del jugador, tendría que poder adquirir estos datos como sigue:1. Llame a DescribePlayerSessions() con el ID de sesión de juego para descubrir qué jugadores

están conectados actualmente a la sesión de juego. Cada sesión de jugador incluye un ID dejugador. Puede añadir un filtro de estado para recuperar solo las sesiones de jugador activas.

2. Extraiga datos del jugador de la propiedad MatchmakerData del objeto de sesión de juego(GameSession) (consulte Trabajo con datos del creador de emparejamientos (p. 122)). Utilicelos ID de jugadores adquiridos en el paso anterior para obtener datos solo de los jugadoresconectados actualmente. Como los datos del creador de emparejamientos no se actualizancuando los jugadores abandonan el juego, tendrá que extraer los datos solo para los jugadoresactuales.

3. Para la latencia de los jugadores, si el creador de emparejamientos solicita datos de latencia,recopile nuevos valores de latencia de todos los jugadores actuales e inclúyalos en el objetoPlayer. Si se omiten los datos de latencia y el creador de emparejamientos tiene una regla delatencia, la solicitud no se emparejará correctamente. Las solicitudes de reposición exigen datosde latencia solo para la región en la que se encuentra el juego en esos momentos. Puede obteneruna región de sesión de juego de la propiedad GameSessionId del objeto GameSession; estevalor es un ARN, que incluye la región.

3. Haga un seguimiento del estado de una solicitud de reposición. Añada código para permanecera la escucha de actualizaciones del estado del ticket de emparejamiento. Puede utilizarla configuración del mecanismo para realizar un seguimiento de los tickets de las nuevassolicitudes de emparejamiento (consulte Hacer un seguimiento del estado de las solicitudes deemparejamiento (p. 119)) utilizando notificación (preferido) o sondeo de eventos. Aunque nonecesita disparar la actividad de aceptación del jugador con solicitudes de reposición y la informacióndel jugador se actualiza en el servidor de juegos, aún tiene que vigilar el estado del ticket paragestionar errores y repeticiones de envío de solicitudes.

Un creador de emparejamientos solo puede procesar una solicitud de reposición de emparejamientode una sesión de juego a la vez. Si necesita cancelar una solicitud, llame a StopMatchmaking. Sinecesita cambiar una solicitud, llame a StopMatchmaking y envíe una solicitud actualizada.

Una vez que una solicitud de reposición de emparejamiento tiene éxito, su servidor de juegos recibeun objeto GameSession actualizado y gestiona las tareas necesarias para incorporar nuevosjugadores a la sesión de juego. Más información en Actualización de datos de emparejamientos en elservidor de juegos (p. 127).

Actualización de datos de emparejamientos en elservidor de juegosIndependientemente de cómo inicie las solicitudes de reposición de emparejamiento en su juego, elservidor de juegos tiene que poder gestionar las actualizaciones de sesión de juego que Amazon GameLiftproporciona como resultado de solicitudes de reposición de emparejamiento.

Cuando Amazon GameLift completa una solicitud de reposición de emparejamiento —correctamente ono—, llama a su servidor de juegos con la función de devolución de llamada onUpdateGameSession.Esta llamada tiene tres parámetros de entrada: un ID de ticket de reposición de emparejamiento, unmensaje de estado y un objeto GameSession que contiene los datos del creador de emparejamientos másactualizados, incluida la información del jugador. Tiene que añadir el siguiente código a su servidor dejuegos como parte de la integración del servidor de juegos:

Version127





Amazon GameLift Developer GuideActualización de datos de

emparejamientos en el servidor de juegos

1. Implemente la función onUpdateGameSession. Esta función tiene que poder gestionar los siguientesmensajes de estado (updateReason):• MATCHMAKING_DATA_UPDATED: se han emparejado correctamente nuevos jugadores a la sesión

de juego. El objeto GameSession contiene datos actualizados del creador de emparejamientos,incluidos datos de jugador de los jugadores existentes y los jugadores recién emparejados.

• BACKFILL_FAILED: el intento de reponer el emparejamiento falló debido a un error interno. El objetoGameSession no ha cambiado.

• BACKFILL_TIMED_OUT: el creador de emparejamientos no pudo encontrar una emparejamiento dereposición dentro del límite de tiempo. El objeto GameSession no ha cambiado.

• BACKFILL_CANCELLED: la solicitud de reposición de emparejamiento fue cancelada por unallamada StopMatchmaking (cliente) o StopMatchBackfill (servidor). El objeto GameSession no hacambiado.

2. Para emparejamientos de reposición correctos, utilice los datos actualizados del creador deemparejamientos para gestionar los nuevos jugadores cuando se conecten a la sesión de juego. Comomínimo, deberá utilizar las asignaciones de equipo para el o los nuevos jugadores, así como otrosatributos del jugador necesarios para que el jugador inicie el juego.

3. En la llamada del servidor de juegos a la acción del SDK del servidor ProcessReady() (p. 157), añadael método de devolución de llamada onUpdateGameSession como un parámetro del proceso.

Version128

Amazon GameLift Developer GuideVisualización del estado actual de GameLift

Visualización de los datos de juegoen la consola

Amazon GameLift recopila datos continuamente para que los juegos activos le ayuden a comprender elcomportamiento y el desempeño de los jugadores. Puede utilizar la consola de Amazon GameLift para ver,administrar y analizar dicha información para las compilaciones, flotas y sesiones de juego y de jugador.

Temas• Visualización del estado actual de Amazon GameLift (p. 129)• Visualización de las compilaciones (p. 130)• Visualización de flotas (p. 131)• Visualización de los detalles de la flota (p. 132)• Visualización de datos de sesiones de juego y de jugador (p. 135)• Visualización de alias (p. 137)

Visualización del estado actual de AmazonGameLift

El panel proporciona una vista de cuadrícula que muestra lo siguiente:

• Las compilaciones actualizadas• Las flotas creadas en todos los estados• Los alias creados y las flotas hacia las que apunta (si hay)

Para abrir el panel de Amazon GameLift

• En la consola de Amazon GameLift, elija Dashboard en la barra de menús.

Desde el panel puede realizar las siguientes acciones:

• Crear una flota o alias nueva.• Ver las relaciones entre dichos elementos. Haga clic en cualquier cuadro de un elemento para ver las

relaciones entre dicho elemento y los demás elementos en el panel. Por ejemplo, haga clic en unacompilación para ver todas las flotas que se han creado con dicha compilación. Haga clic en una flotapara ver la compilación con la que se ha creado y el alias hacia el que apunta. Para restablecer el panel,haga clic en el botón Reset overview.

• Ver detalles sobre una compilación, flota o alias. Haga clic en el número de ID para que el elemento abrala página de detalles.

Version129


Amazon GameLift Developer GuideVisualización de las compilaciones

Visualización de las compilacionesPuede ver información acerca de todas las compilaciones del servidor de juegos subidas a AmazonGameLift y realizar acciones en ellas. Las compilaciones que se muestran solo incluyen las cargadas en laregión seleccionada.

Catálogo de compilacionesLas compilaciones cargadas se muestran en la página Builds. Para ver esta página, elija Builds en la barrade menús de la consola de Amazon GameLift.

La página Builds contiene la siguiente información resumida para todas las compilaciones:

• Status: muestra uno de los tres posibles mensajes de estado:• Initialized: la compilación se ha creado, pero aún no ha empezado la carga o la carga todavía está en

curso.• Ready: la compilación se ha recibido correctamente y está lista para crear flotas.• Failed: la compilación ha expirado antes de haber recibido los archivos binarios.

• Build name: nombre asociado a la compilación cargada. El nombre de la compilación se proporciona alcargar la compilación en Amazon GameLift, y se puede modificar utilizando la acción UpdateBuild deAWS SDK.

• Build ID: identificador único asignado al cargar la compilación.• Version: etiqueta de versión asociada a la compilación cargada. El nombre de la compilación se

proporciona al cargar la compilación en Amazon GameLift, y se puede modificar utilizando la acciónUpdateBuild de AWS SDK.

• OS: sistema operativo en el que se ejecuta la compilación. El sistema operativo de la compilacióndetermina el sistema operativo que se instala en las instancias de una flota.

• Size: tamaño en megabytes (MB) del archivo de compilación cargado en Amazon GameLift.

Version130



Amazon GameLift Developer GuideDetalles de la compilación

• Date created: fecha y hora en que se cargó la compilación en Amazon GameLift.• Fleets: número de flotas implementado actualmente con la compilación.

En esta página puede hacer lo siguiente:

• Crear una flota nueva a partir de una compilación. Seleccionar una compilación y hacer clic en Createfleet from build.

• Eliminar una flota. Seleccione una compilación y haga clic en Delete build.• Filtrar y ordenar la lista de compilación. Utilice los controles en la parte superior de la tabla.• Ver los detalles de las compilaciones. Haga clic en el nombre de la compilación para abrir la página de

detalles de la compilación.

Detalles de la compilaciónAcceda a la página de detalles de la compilación desde el panel de la consola o desde la página Buildshaciendo clic en el nombre de la compilación. La página de detalles de la compilación muestra la mismainformación resumida de la compilación que aparece en la página Builds. También muestra una listade flotas creada con la compilación. Esta lista es básicamente el catálogo de flotas pero filtrado porcompilación. Incluye la misma información resumida que aparece en la página Fleets (p. 131).

Visualización de flotasPuede visualizar información sobre todas las flotas creadas para alojar los juegos en Amazon GameLift ensu cuenta de AWS. Las flotas que se muestran solo incluyen las creadas en la región seleccionada. En lapágina Fleets, puede crear una flota nueva o ver información detallada adicional de una flota seleccionada.Una página de detalles de una flota contiene información de uso y las métricas. Además, permite ver yeditar la configuración de la flota, crear o eliminar la flota y acceder a datos de sesiones de juego y dejugador de la flota.

Para ver la página Fleets, seleccione Fleets en la barra de menús de la consola de Amazon GameLift.

La página Fleets muestra la siguiente información resumida:

• Status: estado actual de la flota, que puede tener uno de los siguientes estados New, Downloading,Building y Active. Una flota debe tener el estado Active para poder alojar sesiones de juego y permitir lasconexiones de los jugadores.

• Fleet name: nombre fácil de recordar de la flota.• EC2 type: es el tipo de instancia Amazon EC2 que determina la capacidad de procesamiento de las

instancias de la flota.• OS: es el sistema operativo en cada instancia de la flota. El sistema operativo de la flota viene

determinado por la compilación implementada.• Active: es el número de instancias EC2 en uso para la flota.• Desired: es el número de instancias EC2 que Amazon GameLift debe conservar en la flota. Este valor es

configurable (dentro de los límites del servicio). Amazon GameLift comienza o termina instancias segúnsea necesario para mantener el número deseado de instancias.

• Active game sessions: es el número de sesiones de juego que se ejecuta actualmente en la flota. Losdatos tienen un decalaje de cinco minutos.

• Player sessions: es el número de ranuras de jugador conectado a sesiones de juego en la flota. Losdatos tienen un decalaje de cinco minutos.

• Uptime: es el tiempo total que se ha ejecutado la flota.• Date created: es la fecha y la hora en que se creó la flota.

Version131

Amazon GameLift Developer GuideVisualización de los detalles de la flota

Visualización de los detalles de la flotaPuede acceder a información detallada sobre cualquier flota, incluidos los ajustes de configuración, deescalado, las métricas y los datos de los jugadores y los juegos. Acceda a la página de detalles la flotadesde el panel de la consola o desde la página Fleets haciendo clic en el nombre de la flota.

La página de detalles de la flota muestra una tabla de resumen y pestañas que contienen informaciónadicional. En esta página puede hacer lo siguiente:

• Actualizar los metadatos y la configuración del tiempo de ejecución de la flota. Elija Actions: Edit fleet.• Cambiar la configuración de la capacidad de la flota. En la página Scaling, edite los valores de las

instancias Minimum, Maximum y Desired.• Definición o modificación de las políticas de escalado automático. En la página Scaling, añada o edite

una política.• Cerrar una flota. Elija Actions: Terminate fleet.

ResumenLa tabla de resumen incluye la siguiente información:

• Status: estado actual de la flota, que puede ser New, Downloading, Building y Active. Una flota debeestar activa para poder alojar sesiones de juego o aceptar conexiones de jugadores.

• Fleet ID: es el identificador único asignado a la flota.• EC2 type: tipo de instancia Amazon EC2 seleccionado para la flota al crearla. Un tipo de instancia

de la flota especifica el hardware informático y la capacidad utilizada para cada instancia de la flota ydetermina los límites de la instancia para la flota.

• OS: es el sistema operativo en cada instancia de la flota. El sistema operativo de la flota vienedeterminado por la compilación implementada.

• Active instances: es el número de instancias con estado Active, lo que significa que son sesiones dejuego que se ejecutan actualmente o que están listas para ejecutar sesiones de juego.

• Active servers: es el número de procesos del servidor que actualmente tiene el estado Active en la flota.Los datos tiene un decalaje de cinco minutos.

• Active game sessions: es el número de sesiones de juego que se ejecuta actualmente en las instanciasde la flota. Los datos tiene un decalaje de cinco minutos.

• Current player sessions: es el número de jugadores conectado actualmente junto con el número total deranuras de jugador en sesiones de juego activas en toda la flota. Por ejemplo, 25 (jugadores conectados)de 100 (jugadores posibles) significa que la flota admite 75 jugadores adicionales. Los datos tiene undecalaje de cinco minutos.

• Protection: es el valor actual de la protección de sesiones de juego (p. 3) de la flota.

Uptime: es el tiempo total que la flota ha estado activa.• Date created: es la fecha y la hora en que se creó la flota.

MétricasLa pestaña Metrics muestra una representación gráfica de las métricas de la flota a lo largo del tiempo.

Para visualizar información de métricas en el gráfico

1. Haga clic en uno o más nombres de métrica a la izquierda del área de gráficos para añadirlo a lavisualización de gráficos. Los nombres de métricas aparecen en gris cuando están desactivados.Utilice la clave de color para identificar las líneas del gráfico de una métrica seleccionada. Encontrará

Version132


Amazon GameLift Developer GuideEventos

descripciones de las métricas individuales en Métricas de Amazon GameLift para flotas (p. 138).Están disponibles las siguientes categorías de métricas:

• Instance Counts (Recuentos de instancia): estas métricas realizan un seguimiento de los cambiosen la capacidad y la utilización en el nivel de instancia a lo largo del tiempo (también se muestran enla pestaña Scaling [Escalado]).

• Game (Juego): estas métricas muestran la actividad de la flota y la utilización en el nivel de sesiónde juego a lo largo del tiempo.

• Server processes: estas métricas realizan un seguimiento del estado de los procesos del servidor entoda la flota. El servicio Amazon GameLift pregunta regularmente a cada proceso del servidor activopor su estado.

• Instance performance (Desempeño de la instancia): estas métricas reflejan el desempeño de losrecursos informáticos de la flota. Consulte las descripciones detalladas de cada métrica en lainformación sobre Métricas de instancia de EC2.

2. Utilice los filtros siguientes, que se muestran por encima del gráfico, para modificar la forma en que semuestran los datos de las métricas:

• Data & Period: ofrece dos opciones para seleccionar un rango de fechas:• Use Relative para seleccionar un período de tiempo relacionado con la hora actual, como Last


• Granularity: seleccione una duración para agregar puntos de datos.• Refresh rate: seleccione la frecuencia con la que quiere que se actualice la visualización gráfica.• Time zone (Zona horaria): seleccione el formato de hora que quiere utilizar en la representación

gráfica: UTC (hora universal coordinada) o Browser time (hora del explorador u hora local).• Show Points (Mostrar puntos): active o desactive esta opción para ver puntos de datos concretos

(en forma de círculos) o líneas de visualización, exclusivamente.

EventosLa pestaña Events proporciona un registro de todos los eventos que se han producido en la flota,incluido el código del evento, el mensaje y la marca temporal. Consulte las descripciones de Evento en laReferencia de la API de Amazon GameLift.

EscaladoLa pestaña Scaling contiene información acerca de la capacidad de la flota, incluido el estado actualy una representación gráfica de los cambios de capacidad a lo largo del tiempo. También proporcionaherramientas para actualizar los límites de capacidad y gestionar el escalado automático.

Para ver la información de escalado actual e histórica

1. Vaya a la parte superior de la pestaña Scaling. El estado de la capacidad actual de esta flota semuestra en la columna izquierda. Estos valores se definen de la siguiente manera:

• Scaling Limits: estas métricas realizan el seguimiento del historial de cambios en los límites de lacapacidad.• Minimum: límite inferior máximo del número de instancias a mantener en la flota. La capacidad

de la flota no caerá por debajo del mínimo actual durante el escalado automático ni tampoco si lacapacidad deseada se fija por debajo del mínimo.

• Desired: es el número de instancias activas deseado actualmente en la flota. El objetivo es queel número de instancias Active (Activas) (se explica más adelante) coincida con el número de

Version133

https://docs.aws.amazon.com/AWSEC2/latest/UserGuide/viewing_metrics_with_cloudwatch.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_Event.html

Amazon GameLift Developer GuideSesiones de juego

instancias deseadas, lo que se consigue mediante la creación o terminación de instancias, segúnsea necesario.

• Maximum: límite superior máximo del número de instancias a mantener en la flota. La capacidadde la flota no superará el máximo actual durante el escalado automático ni tampoco si lacapacidad deseada se fija por encima del máximo.

• Instance Counts (Recuentos de instancias): estas métricas realizan un seguimiento de los cambiosen la capacidad y la utilización a lo largo del tiempo. Consulte las descripciones de las métricasindividuales en Métricas de Amazon GameLift para flotas (p. 138).

2. Para ver cómo ha cambiado la flota a lo largo del tiempo, muestre en el gráfico algunas o todas lasmétricas de escalado de la lista de la izquierda. Haga clic en el nombre de la métrica para añadirlaal gráfico. (Los nombres de métricas aparecen en gris cuando no se utilizan). Utilice la clave de colorpara identificar las líneas del gráfico que coinciden con una métrica seleccionada.

3. (Opcional) Utilice los siguientes filtros, que se muestran por encima del gráfico, para especificar laforma en que se muestran los datos de las métricas en el gráfico:

• Data & Period: ofrece dos opciones para seleccionar un rango de fechas:• Use Relative para seleccionar un período de tiempo relacionado con la hora actual, como Last


• Granularity: seleccione una duración para agregar puntos de datos.• Refresh rate: seleccione la frecuencia con la que quiere que se actualice la visualización gráfica.• Format: seleccione el formato de hora que quiere utilizar en la visualización gráfica: UTC (hora

universal coordinada) o Browser time (hora local).• Show Points: active o desactive para visualizar solo los puntos de datos discretos (en forma de

círculos) o las líneas de visualización.

Para cambiar la capacidad de la flota

• Debajo del gráfico de historial hay herramientas para configurar los límites de capacidad y lacapacidad de escalado. Consulte Establecimiento manual de la capacidad de la flota (p. 70) paraobtener más información sobre cómo usar estas herramientas. Consulte Escalado automático dela capacidad de la flota (p. 72) para obtener más información sobre la administración del escaladoautomático.

Sesiones de juegoLa pestaña Game sessions (Sesiones de juego) enumera las sesiones de juego pasadas y presenteshospedadas en la flota, incluida información detallada. Haga clic en un ID de sesión de juego para accedera la información adicional de la sesión de juego, incluidas las sesiones de jugador.

• Status: es el estado de la sesión de juego. Los estados válidos son:• Activating: se ha iniciado una sesión de juego y está a punto de ejecutarse.• Active: se está ejecutando una sesión de juego y está disponible para recibir jugadores (en función de

la política de creación de jugadores de la sesión).• Terminated: ha finalizado la sesión de juego.

• Name: se ha generado el juego para la sesión de juego.• ID: es el identificador único asignado por Amazon GameLift a la sesión de juego.• IP address: es la dirección IP específica de la sesión de juego.• Port : es el número de puerto que se utiliza para conectar con la sesión de juego.

Version134


Amazon GameLift Developer GuideDesarrollo

• Player sessions: es el número de jugadores conectado a las sesiones de juego junto con el númerototal de jugadores posible que admite la sesión de juego. Por ejemplo, 2 (jugadores conectados) de 10(jugadores posibles) significa que la flota admite 8 jugadores adicionales.

• Uptime: tiempo total que la sesión de juego ha estado ejecutándose.• Date created: es la fecha y la marca temporal en que se creó la flota.

DesarrolloLa pestaña Build muestra la configuración relacionada con la compilación de la flota, que se fijó al crear laflota. Seleccione el ID de compilación para ver la página de detalles de la compilación completa.

Si la compilación se ha eliminado o se ha producido un error al intentar recuperar la compilación, puede veralguno de los siguientes mensajes de estado:

• Deleted: se ha eliminado la compilación de esta flota. La flota seguirá ejecutándose correctamente apesar de haber eliminado la compilación.

• Error: se ha producido un error al intentar recuperar información de compilación para la flota.

Asignación de capacidadLa pestaña Capacity allocation muestra la configuración de tiempo de ejecución de la flota, que especificalos procesos del servidor a lanzar en cada instancia y el modo de hacerlo. Incluye la ruta del ejecutable delservidor de juegos y los parámetros de lanzamiento opcionales. Puede cambiar la asignación de capacidadde la flota ya sea editando la flota en la consola o utilizando la AWS CLI para actualizar la configuración detiempo de ejecución.

PuertosLa pestaña Ports muestra los permisos de conexión de la flota, incluida la dirección IP y los rangos deconfiguración del puerto. Puede cambiar los permisos de conexión ya sea editando la flota en la consola outilizando la AWS CLI para actualizar la configuración del puerto de la flota.

ARNLa pestaña ARN enumera los Nombres de recursos de Amazon (ARN) asignados a esta flota.

Visualización de datos de sesiones de juego y dejugador

Puede visualizar información acerca de los juegos que se ejecutan en una flota y sobre cada jugador. Paraobtener más información acerca de las sesiones de juego y de jugador, consulte Cómo se conectan losjugadores a los juegos (p. 8).

Para ver los datos de sesiones de juego

1. En la consola de Amazon GameLift, abra la página de detalles de la flota que desea estudiar.(Seleccione Fleets en la barra de menús y haga clic en el nombre de una flota.)

2. Abra la pestaña Game sessions . Esta pestaña enumera todas las sesiones de juego alojadas en laflota junto con información resumida.

Version135



Amazon GameLift Developer GuideSesiones de juego

3. Haga clic en una sesión de juego para ver información adicional acerca de la sesión de juego, asícomo una lista de los jugadores conectados al juego.

Sesiones de juegoEn la parte superior de la página se muestra un resumen de la información de la sesión de juego, queincluye:

• Status: es el estado de la sesión de juego. Los estados válidos son:• Activating: Amazon GameLift ha creado una sesión de juego y ha remitido las propiedades del juego

al proceso del servidor de juegos. El servidor de juegos interpreta las propiedades del juego y vuelve allamar a Amazon GameLift cuando esté listo para la conexión de posibles sesiones de jugador.

• Active: la sesión de juego admite un juego con ninguna o varias sesiones de jugador conectadas.• Terminated: la sesión de juego ha finalizado y las sesiones de jugador ya no pueden conectarse a la

sesión de juego terminada.• Name: es el nombre que se genera automáticamente para la sesión de juego.• IP address: para las sesiones de juego con un estado Activating o Active, se trata de la dirección IP que

se utiliza para conectarse al juego.• Port: es el número de puerto que se utiliza para conectar con la sesión de juego.• Player sessions: es el número de jugadores conectado actualmente a la sesión de juego junto con el

número total de ranuras de jugador en la sesión de juego. Por ejemplo, el valor 10 de 15 indica que delas 15 ranuras disponibles en el juego, 10 están llenas y 5 abiertas.

• Player session creation policy: es la política que determina si los jugadores nuevos pueden conectarseal juego. Los valores son Accept all o Deny all. Para obtener más información, consulte el objetoGameSession.

• Uptime: es el tiempo total que la sesión de juego ha estado ejecutándose.• Date created: es la fecha y la hora en que se creó la sesión de juego.

Sesiones de jugadorPara cada sesión de juego se recopilan los siguientes datos de sesiones de jugador:

• Status: es el estado de la sesión de jugador. Las opciones son:• Reserved: la sesión de jugador está reservada, pero el jugador no se ha conectado todavía.• Active: la sesión de jugador está conectada actualmente en el servidor de juegos.• Completed: la sesión de jugador ha finalizado y el jugador ya no está conectado.• Timed Out: la sesión de jugador estaba reservada, pero el jugador no se ha conectado.

• ID: es el identificador asignado a la sesión de jugador.• Player ID: es un identificador exclusivo para el jugador. Haga clic en este ID para obtener información

adicional del jugador.• Start time: es la hora en que el jugador se conectó a la sesión de juego.• End time: es la hora en que el jugador se desconectó de la sesión de juego.• Total time: es el período de tiempo total que el jugador ha estado activo en la sesión de jugador.

Información sobre el jugadorPuede ver información adicional de un jugador seleccionado, incluida una lista de todos los juegos a losque se ha conectado el jugador en todas las flotas de la región actual. Esta información incluye el estado,

Version136



Amazon GameLift Developer GuideVisualización de alias

la hora de inicio y de fin, y el tiempo total de conexión de cada sesión de jugador. Puede hacer clic para verlos datos de las sesiones de juego y de las flotas relevantes.

Visualización de aliasPuede consultar la información de todos los alias de la flota que ha creado y realizar acciones sobre losmismos desde la página Aliases. Los alias que se muestran solo incluyen los alias creados para la regiónseleccionada.

Catálogo de aliasTodos los alias creados se muestran en la página de catálogo de los alias. Para ver la página Aliases,seleccione Aliases en la barra de menús de la consola de Amazon GameLift.

La página Aliases proporciona información resumida sobre todas las compilaciones, incluido el tipo. Enesta página puede hacer lo siguiente:

• Crear un alias nuevo. Para ello, haga clic en Create alias.• Filtrar y ordenar la lista de alias. Utilice los controles en la parte superior de la tabla.• Ver los detalles de los alias. Haga clic en el nombre del alias para abrir la página de detalles del alias.

Detalle de los aliasAcceda a la página de detalles del alias desde el panel de la consola o desde la página de catálogoAliases haciendo clic en el nombre del alias. La página de detalles del alias muestra información resumidasobre el alias.

En esta página puede hacer lo siguiente:

• Editar un alias, incluso cambiar el nombre, la descripción y el ID de la flota con el que está asociado elalias. Haga clic en Actions: Edit alias.

• Ver información sobre la flota con la que está asociada actualmente el alias. La información incluye elestado y el uso actual de la flota (sesiones de juego y jugadores activos).

• Eliminar un alias. Haga clic en Actions: Delete alias.

La información detallada del alias incluye:

• Type: es la opción de enrutamiento para el alias, que puede ser una de las siguientes:• Simple: un alias simple redirige al jugador hacia los juegos de una flota asociada. Puede actualizar el

alias para que apunte hacia otra flota en cualquier momento.• Terminal: un alias terminal no apunta hacia una flota. En su lugar, transmite un mensaje al cliente.

Este tipo de alias es útil para notificar de forma sencilla a los jugadores que un conjunto de servidoresde juegos ya no está disponible. Por ejemplo, un alias terminal podría informar a los jugadores que losclientes de juego están desactualizados y proporcionar opciones de actualización.

• Alias ID: es el número exclusivo que se utiliza para identificar al alias.• Description: es la descripción del alias.• Date created: es la fecha y la hora en que se creó el alias.

Version137

Amazon GameLift Developer GuideMonitorización con CloudWatch

Monitorización de Amazon GameLiftLa monitorización es una acción importante a la hora de mantener la fiabilidad, la disponibilidad y eldesempeño de Amazon GameLift y sus otras soluciones de AWS. Amazon GameLift emplea las métricasde tres maneras: para supervisar el estado del sistema y configurar alertas, para realizar el seguimientodel uso y del desempeño del servidor de juegos y para administrar la capacidad mediante el escaladoautomático o manual.

AWS ofrece las siguientes herramientas de monitorización para controlar a Amazon GameLift, informarcuando algo no funciona y realizar acciones automáticas cuando proceda:

• Consola de Amazon GameLift• Amazon CloudWatch: puede monitorizar las métricas de Amazon GameLift en tiempo real, así como

otras métricas de otros recursos de AWS y las aplicaciones que se ejecuten en los servicios de AWS.CloudWatch ofrece un conjunto de funciones de monitorización, incluidas las herramientas para crear lospaneles personalizados y la capacidad de definir alarmas de notificación o realizar acciones cuando unamétrica alcance un umbral específico.

• AWS CloudTrail: captura todas las llamadas a la API y los eventos relacionados realizados por o ennombre de su cuenta de AWS para los servicios de Amazon GameLift y otros servicios de AWS. Losdatos se entregan como archivos de registro en el bucket de Amazon S3 que especifique. Tambiénpueden identificar qué usuarios y cuentas llamaron a AWS, la dirección IP de origen desde la que serealizaron las llamadas y el momento en que se efectuaron las llamadas.

Temas• Monitorización de Amazon GameLift con Amazon CloudWatch (p. 138)• Registro de llamadas a la API de Amazon GameLift con AWS CloudTrail (p. 148)

Monitorización de Amazon GameLift con AmazonCloudWatch

Puede monitorizar Amazon GameLift mediante Amazon CloudWatch, un servicio de AWS que recopila yprocesa los datos sin formato y los convierte en métricas legibles y casi en tiempo real. Estas estadísticasse guardan durante un periodo de 15 meses, de forma que puede acceder a información de historial yobtener una mejor perspectiva sobre el desempeño del alojamiento del servidor de juegos en AmazonGameLift. También puede establecer alarmas que observen determinados umbrales y enviar notificacioneso realizar acciones cuando se cumplan dichos umbrales. Para obtener más información, consulte la Guíadel usuario de Amazon CloudWatch.

Para acceder a las métricas de CloudWatch para los juegos, puede utilizar la Consola de administración deAWS, la AWS CLI o la API de CloudWatch. Las tablas siguientes incluyen las métricas y dimensiones paraAmazon GameLift. Todas las métricas que están disponibles en CloudWatch también están disponibles enla consola de Amazon GameLift, que proporciona los datos como un conjunto de gráficos personalizados.

Métricas de Amazon GameLift para flotasEl espacio de nombres AWS/GameLift incluye las siguientes métricas relativas a la actividad de una flotao grupo de flotas. El servicio Amazon GameLift envía las métricas a CloudWatch cada minuto.

Version138

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/

https://docs.aws.amazon.com/AmazonCloudWatch/latest/monitoring/

Amazon GameLift Developer GuideMétricas de Amazon GameLift para flotas

Instancias

Métrica Descripción

ActiveInstances Instancias con el estado ACTIVE, lo que indica quese trata de procesos del servidor activos. El recuentoincluye las instancias inactivas y las que alojan una ovarias sesiones de juego. Esta métrica mide la capacidadtotal actual de las instancias. Se puede usar con elescalado automático.

Unidades: recuento

Estadísticas de CloudWatch pertinentes: Average,Minimum, Maximum

DesiredInstances Número de destino de instancias activas que utilizaAmazon GameLift para mantener la flota. Con elescalado automático, este valor se determina en funciónde las políticas de escalado aplicadas actualmente.Sin el escalado automático, este valor se establecemanualmente. Esta métrica no está disponible cuando seconsultan datos de grupos de métricas de flotas.

Unidades: recuento


IdleInstances Instancias activas que alojan actualmente cero (0)sesiones de juego. Esta métrica mide la capacidaddisponible pero sin usar. Se puede usar con el escaladoautomático.

Unidades: recuento


MaxInstances Número máximo de instancias permitidas para la flota.El número máximo de instancias de una flota determinael límite máximo de capacidad durante el escaladoascendente manual o automático. Esta métrica no estádisponible cuando se consultan datos de grupos demétricas de flotas.

Unidades: recuento


MinInstances Número mínimo de instancias permitidas para la flota.El número mínimo de instancias de una flota determinael límite inferior de capacidad durante el escaladodescendente manual o automático. Esta métrica no estádisponible cuando se consultan datos de grupos demétricas de flotas.

Version139


Métrica DescripciónUnidades: recuento


PercentIdleInstances Porcentaje de todas las instancias activasque se encuentran inactivas (calculado comoIdleInstances / ActiveInstances). Esta métricase puede usar para el escalado automático.

Unidades: porcentaje


InstanceInterruptions Número de las instancias de spot que se haninterrumpido.

Unidades: recuento

Estadísticas de CloudWatch pertinentes: Sum, Average,Minimum, Maximum

Procesos del servidor


ActiveServerProcesses Procesos del servidor con el estado ACTIVE, lo queindica que se están ejecutando y pueden alojar sesionesde juego. El recuento incluye los procesos de servidorinactivos y los que alojan sesiones de juego. Estamétrica mide la capacidad total actual de los procesosdel servidor.

Unidades: recuento


HealthyServerProcesses Procesos del servidor activos registrados como en buenestado. Esta métrica es útil para realizar un seguimientodel estado general de los servidores de juego de la flota.

Unidades: recuento


PercentHealthyServerProcesses Porcentaje de todos los procesos del servidoractivos registrados como en buen estado(calculado como HealthyServerProcesses /ActiveServerProcesses).


Version140


Métrica DescripciónEstadísticas de CloudWatch pertinentes: Average,Minimum, Maximum

ServerProcessAbnormalTerminations Procesos del servidor que se cerraron debido acircunstancias anormales desde el último informe. Estamétrica incluye las terminaciones iniciadas por el servicioAmazon GameLift. Esto se produce cuando un procesodel servidor deja de responder, registra una y otra vezcomprobaciones de estado no superadas o no se terminalimpiamente (al llamar a ProcessEnding()).

Unidades: recuento


ServerProcessActivations Procesos del servidor que pasaron correctamente delestado ACTIVATING a ACTIVE desde el último informe.Los procesos del servidor no pueden alojar sesiones dejuego hasta que están activos.

Unidades: recuento


ServerProcessTerminations Procesos del servidor que se cerraron desde el últimoinforme. Esto incluye todos los procesos del servidorque por algún motivo pasaron a tener el estadoTERMINATED, incluidas las terminaciones del procesonormales y anormales.

Unidades: recuento


Sesiones de juego


ActivatingGameSessions Sesiones de juego con el estado ACTIVATING, lo queindica que se están iniciando. Las sesiones de juegono pueden alojar jugadores hasta que están activas.Un número elevado durante un periodo de tiempoprolongado puede indicar que las sesiones de juegono están pasando del estado ACTIVATING al estadoACTIVE. Se puede usar con el escalado automático.

Unidades: recuento


Version141

https://docs.aws.amazon.com/gamelift/latest/developerguide/integration-server-sdk-cpp-ref-actions.html#integration-server-sdk-cpp-ref-processending



ActiveGameSessions Sesiones de juego con el estado ACTIVE, lo que indicaque pueden alojar jugadores y que están alojando ceroo más jugadores. Esta métrica mide el número total desesiones de juego alojadas actualmente. Se puede usarcon el escalado automático.

Unidades: recuento


AvailableGameSessions Slots de sesiones de juego en procesos del servidoractivos y en buen estado que no se están usandoactualmente. Esta métrica mide el número total desesiones de juego nuevas que se pueden iniciarinmediatamente. Se puede usar con el escaladoautomático.

Unidades: recuento


PercentAvailableGameSessions Porcentaje de slots de sesiones de juego en todoslos procesos del servidor activos (en buen estado oen mal estado) que no se están usando actualmente(calculado como AvailableGameSessions /[ActiveGameSessions +AvailableGameSessions + unhealthy serverprocesses]). Se puede usar con el escaladoautomático.


Estadísticas de CloudWatch relevantes: Average

GameSessionInterruptions Número de sesiones de juego en instancias de spot quese han interrumpido.

Unidades: recuento


Sesiones de jugador


CurrentPlayerSessions Sesiones de jugador con el estado ACTIVE (el jugadorestá conectado a una sesión de juego activa) o con elestado RESERVED (al jugador se le ha asignado un sloten una sesión de juego pero aún no se ha conectado).Se puede usar con el escalado automático.

Unidades: recuento

Version142

Amazon GameLift Developer GuideMétricas de Amazon GameLift para colas

Métrica DescripciónEstadísticas de CloudWatch pertinentes: Average,Minimum, Maximum

PlayerSessionActivations Sesiones de jugador que pasaron correctamente delestado RESERVED a ACTIVE desde el último informe.Esto ocurre cuando un jugador se conecta correctamentea una sesión de juego activa.

Unidades: recuento


Métricas de Amazon GameLift para colasEl espacio de nombres GameLift incluye las siguientes métricas relativas a la actividad en una cola deubicación de sesión de juego. El servicio Amazon GameLift envía las métricas a CloudWatch cada minuto.


AverageWaitTime Promedio de tiempo que las solicitudes de ubicación desesión de juego en la cola con el estado PENDING hanesperado a ser atendidas.

Unidades: segundos

Estadísticas pertinentes de CloudWatch: Average,Minimum, Maximum, Sum

FirstChoiceNotViable Sesiones de juego que se transfirieron correctamentepero NO a la primera flota elegida, ya que dicha flota nose consideraba viable (por ejemplo, una flota de spotcon un gran número de interrupciones). La primera flotaelegida es la primera flota que aparece en la cola o,si una solicitud de ubicación contiene datos sobre lalatencia de los jugadores, la primera flota elegida por lapriorización de FleetIQ.

Unidades: recuento


FirstChoiceOutOfCapacity Sesiones de juego que se transfieren correctamentepero NO a la primera flota elegida, ya que dicha flota notiene recursos disponibles. La primera flota elegida esla primera flota que aparece en la cola o, si una solicitudde ubicación contiene datos sobre la latencia de losjugadores, la primera flota elegida por la priorización deFleetIQ.

Unidades: recuento


Version143

https://docs.aws.amazon.com/gamelift/latest/developerguide/queues-design.html#queues-design-fleetiq



Amazon GameLift Developer GuideMétricas de Amazon GameLift para colas


LowestLatencyPlacement Sesiones de juego que se transfirieron correctamentea una región que ofrece la menor latencia posible enla cola para los jugadores. Esta métrica solamente seemite cuando los datos de latencia de los jugadoresse incluyen en la solicitud de ubicación, que activa lapriorización de FleetIQ.

Unidades: recuento


LowestPricePlacement Sesiones de juego que se transfirieron correctamentea una flota que tiene el menor precio posible de la colapara la región elegida. (La priorización de FleetIQ eligeen primer lugar la región que tiene la latencia más bajapara los jugadores y luego busca la flota que tiene elcosto más bajo en esa región). Esta flota puede ser unaflota de spot o, si la cola no tiene instancias de spot,una instancia bajo demanda. Esta métrica solamente seemite solo cuando los datos de latencia de los jugadoresse incluyen en la solicitud de ubicación.

Unidades: recuento


Placement <region name> Sesiones de juego que se transfirieron correctamente alas flotas situadas en la región especificada. Esta métricadesglosa el valor PlacementsSucceeded por regiones.

Unidades: recuento

Estadísticas de CloudWatch relevantes: Sum

PlacementsCanceled Solicitudes de ubicación de sesión de juego que secancelaron porque se agotó el tiempo de espera desde elúltimo informe.

Unidades: recuento


PlacementsFailed Solicitudes de ubicación de sesión de juego que no serealizaron correctamente por alguna razón desde elúltimo informe.

Unidades: recuento


Version144



Amazon GameLift Developer GuideMétricas de Amazon GameLift para el emparejamiento


PlacementsStarted Solicitudes de ubicación de sesión de juego nuevas quese añadieron a la cola desde el último informe.

Unidades: recuento


PlacementsSucceeded Solicitudes de ubicación de sesión de juego que dieronlugar a una nueva sesión de juego desde el últimoinforme.

Unidades: recuento


PlacementsTimedOut Solicitudes de ubicación de sesión de juego quealcanzaron el límite de tiempo de espera de la cola sinser atendidas desde el último informe.

Unidades: recuento


QueueDepth Número de solicitudes de ubicación de sesión de juegode la cola con el estado PENDING.

Unidades: recuento


Métricas de Amazon GameLift para el emparejamientoEl espacio de nombres GameLift contiene las métricas de la actividad de emparejamiento sobrelas configuraciones y las reglas de esta actividad. El servicio Amazon GameLift envía las métricas aCloudWatch cada minuto.

Para obtener más información sobre la secuencia de la actividad de emparejamiento, consulteFuncionamiento de Amazon GameLift FlexMatch.

Configuraciones de emparejamiento


CurrentTickets En la actualidad, se están procesando solicitudes deemparejamiento o están a la espera de ser procesadas.

Unidades: recuento


Version145

https://docs.aws.amazon.com/gamelift/latest/developerguide/gamelift-match-howitworks.html



MatchAcceptancesTimedOut Para las configuraciones de emparejamiento querequieren aceptación, los posibles emparejamientos queagotaron su tiempo durante la aceptación desde el últimoinforme.

Unidades: recuento


MatchesAccepted Para las configuraciones de emparejamiento querequieren aceptación, los posibles emparejamientos quese aceptaron desde el último informe.

Unidades: recuento


MatchesCreated Emparejamientos potenciales creados desde el últimoinforme.

Unidades: recuento


MatchesPlaced Emparejamientos que se ubicaron en una sesión dejuego desde el último informe.

Unidades: recuento


MatchesRejected Para las configuraciones de emparejamiento querequieren aceptación, los posibles emparejamientos querechazó al menos un jugador desde el último informe.

Unidades: recuento


PlayersStarted Jugadores en incidencias de emparejamiento que seañadieron desde el último informe.

Unidades: recuento


TicketsFailed Solicitudes de emparejamiento con error desde el últimoinforme.

Unidades: recuento


TicketsStarted Nuevas solicitudes de emparejamiento creadas desde elúltimo informe.

Unidades: recuento


Version146



TicketsTimedOut Solicitudes de emparejamiento que alcanzaron el límitede tiempo de espera desde el último informe.

Unidades: recuento


TimeToMatch Para las solicitudes de emparejamiento que se pusieronen un emparejamiento potencial antes del último informe,la cantidad de tiempo entre la creación de la incidencia yla creación de emparejamientos potenciales.

Unidades: segundos

Estadísticas de CloudWatch relevantes: Data Samples,Average, Minimum, Maximum, p99

TimeToTicketCancel Para las solicitudes de emparejamiento que secancelaron antes del último informe, la cantidad detiempo entre la creación de la incidencia y la cancelación.

Unidades: segundos


TimeToTicketSuccess Para las solicitudes de emparejamiento con éxitoantes del último informe, la cantidad de tiempoentre la creación de la incidencia y la ubicación deemparejamiento con éxito.

Unidades: segundos


Reglas de emparejamiento


RuleEvaluationsPassed Evaluaciones de reglas durante el proceso deemparejamiento superadas desde el último informe. Estamétrica se limita a las 50 primeras reglas.

Unidades: recuento


RuleEvaluationsFailed Evaluaciones de reglas durante el emparejamiento queno se superaron desde el último informe. Esta métrica selimita a las 50 primeras reglas.

Unidades: recuento


Version147

Amazon GameLift Developer GuideDimensiones de métricas de Amazon GameLift

Dimensiones de métricas de Amazon GameLiftAmazon GameLift permite filtrar métricas por las siguientes dimensiones.

Dimensión Descripción

FleetId Identificador único de una sola flota. Esta dimensión seusa con todas las métricas de instancias, procesos deservidor, sesiones de juego y sesiones de jugador. No seusa con las métricas de cola y emparejamiento.

MetricGroup Identificador único de una colección de flotas. Una flotase incluye en un grupo de métricas de flota añadiendoel nombre del grupo de flotas a los atributos de la flota(véase UpdateFleetAttributes()). Esta dimensión seusa con todas las métricas de instancias, procesos deservidor, sesiones de juego y sesiones de jugador. No seusa con las métricas de cola y emparejamiento.

QueueName Identificador único de una sola cola. Esta dimensión seusa únicamente con las métricas de colas de ubicaciónde sesión de juego.

MatchmakingConfigurationName Identificador único de una sola configuración deemparejamiento Esta dimensión solo se usa con lasmétricas de emparejamiento.

MatchmakingConfigurationName-RuleName

Identificador único del intersect de una configuraciónde emparejamiento y una regla de emparejamiento.Esta dimensión solo se usa con las métricas deemparejamiento.

InstanceType Identificador único de una designación de tipo instanciaEC2, como "C4.large". Esta dimensión solo se usa conlas métricas de instancias de spot.

OperatingSystem Identificador único para el sistema operativo de unainstancia. Esta dimensión solo se usa con las métricasde instancias de spot.

Registro de llamadas a la API de Amazon GameLiftcon AWS CloudTrail

Amazon GameLift está integrado con AWS CloudTrail, un servicio que registra todas las llamadas a laAPI realizadas por o en nombre de Amazon GameLift desde la cuenta de AWS. CloudTrail entrega losarchivos de log al bucket de Amazon S3 que especifique. CloudTrail captura todas las llamadas a las APIdesde la consola de Amazon GameLift desde la API de Amazon GameLift. Utilice la información recopiladapor CloudTrail para determinar qué solicitudes ha realizado a Amazon GameLift, la dirección IP de origendesde la que se realizó la solicitud, quién realizó la solicitud, cuándo la realizó, etcétera. Para obtener másinformación sobre CloudTrail, incluido cómo configurarlo y habilitarlo, consulte la AWS CloudTrail UserGuide.

Version148

https://docs.aws.amazon.com/gamelift/latest/apireference/API_UpdateFleetAttributes.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/

Amazon GameLift Developer GuideInformación de Amazon GameLift en CloudTrail

Información de Amazon GameLift en CloudTrailSi el log de CloudTrail está habilitado en la cuenta de AWS, las llamadas a la API realizadas en accionesde Amazon GameLift quedan registradas en archivos de log. Los registros de Amazon GameLift seescriben junto con los de otros servicios de AWS en un archivo de log. CloudTrail determina cuándo creary escribir en un nuevo archivo en función del período de tiempo y del tamaño del archivo.

CloudTrail registra todas las acciones de Amazon GameLift. Por ejemplo, las llamadas aCreateGameSession, CreatePlayerSession y UpdateGameSession generan entradas en losarchivos de log de CloudTrail. Para ver la lista completa de las acciones, consulte la Referencia de la APIde Amazon GameLift.

Cada entrada de log contiene información sobre quién generó la solicitud. La información de identidaddel usuario que figura en el log le ayudará a determinar si la solicitud se hizo con credenciales de usuariode IAM o de la raíz de la cuenta de AWS, con credenciales de seguridad temporales para un rol o unusuario federado o bien mediante otro servicio de AWS. Para obtener más información, consulte el campouserIdentity en Referencia de eventos de CloudTrail.

Puede almacenar los archivos de log en el bucket de S3 durante todo el tiempo que desee, perotambién puede definir reglas de ciclo de vida de Amazon S3 para archivar o eliminar archivos de logautomáticamente. De forma predeterminada, los archivos log se cifran con cifrado de servidor de AmazonS3 (SSE).

Si desea actuar rápidamente al recibir un archivo de log, puede hacer que CloudTrail publiquenotificaciones de Amazon Simple Notification Service (Amazon SNS) cuando se envíen archivos de lognuevos. Para obtener más información, consulte Configuring Amazon SNS Notifications.

También puede agregar archivos de log de Amazon GameLift de varias regiones de AWS y de variascuentas de AWS en un solo bucket de S3. Para obtener más información, consulte Aggregating CloudTrailLog Files to a Single Amazon S3 Bucket.

Descripción de las entradas de archivos de log deAmazon GameLiftLos archivos de log de CloudTrail contienen una o varias entradas de log, cada una de las cuales estácompuesta por varios eventos con formato JSON. Una entrada de log representa una única solicitud decualquier origen e incluye información sobre la acción solicitada, los parámetros, la fecha y la hora de laacción, etcétera. No se garantiza que las entradas de log sigan un orden específico; es decir, no son unrastro de stack ordenado de las llamadas públicas a la API.

En el ejemplo siguiente se muestra una entrada de log de CloudTrail que ilustra las accionesCreateFleet y DescribeFleetAttributes.

{ "Records": [ { "eventVersion": "1.04", "userIdentity": { "type": "IAMUser", "principalId": "AIDACKCEVSQ6C2EXAMPLE", "arn": "arn:aws:iam::111122223333:user/myUserName", "accountId": "111122223333", "accessKeyId": AKIAIOSFODNN7EXAMPLE", "userName": "myUserName" }, "eventTime": "2015-12-29T23:40:15Z", "eventSource": "gamelift.amazonaws.com", "eventName": "CreateFleet",

Version149



https://docs.aws.amazon.com/awscloudtrail/latest/userguide/event_reference_top_level.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/getting_notifications_top_level.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/aggregating_logs_top_level.html

https://docs.aws.amazon.com/awscloudtrail/latest/userguide/aggregating_logs_top_level.html

Amazon GameLift Developer GuideDescripción de las entradas de

archivos de log de Amazon GameLift

"awsRegion": "us-west-2", "sourceIPAddress": "192.0.2.0", "userAgent": "[]", "requestParameters": { "buildId": "build-92b6e8af-37a2-4c10-93bd-4698ea23de8d", "eC2InboundPermissions": [ { "ipRange": "10.24.34.0/23", "fromPort": 1935, "protocol": "TCP", "toPort": 1935 } ], "logPaths": [ "C:\\game\\serverErr.log", "C:\\game\\serverOut.log" ], "eC2InstanceType": "c4.large", "serverLaunchPath": "C:\\game\\MyServer.exe", "description": "Test fleet", "serverLaunchParameters": "-paramX=baz", "name": "My_Test_Server_Fleet" }, "responseElements": { "fleetAttributes": { "fleetId": "fleet-0bb84136-4f69-4bb2-bfec-a9b9a7c3d52e", "serverLaunchPath": "C:\\game\\MyServer.exe", "status": "NEW", "logPaths": [ "C:\\game\\serverErr.log", "C:\\game\\serverOut.log" ], "description": "Test fleet", "serverLaunchParameters": "-paramX=baz", "creationTime": "Dec 29, 2015 11:40:14 PM", "name": "My_Test_Server_Fleet", "buildId": "build-92b6e8af-37a2-4c10-93bd-4698ea23de8d" } }, "requestID": "824a2a4b-ae85-11e5-a8d6-61d5cafb25f2", "eventID": "c8fbea01-fbf9-4c4e-a0fe-ad7dc205ce11", "eventType": "AwsApiCall", "recipientAccountId": "111122223333" }, { "eventVersion": "1.04", "userIdentity": { "type": "IAMUser", "principalId": "AIDACKCEVSQ6C2EXAMPLE", "arn": "arn:aws:iam::111122223333:user/myUserName", "accountId": "111122223333", "accessKeyId": "AKIAIOSFODNN7EXAMPLE", "userName": "myUserName" }, "eventTime": "2015-12-29T23:40:15Z", "eventSource": "gamelift.amazonaws.com", "eventName": "DescribeFleetAttributes", "awsRegion": "us-west-2", "sourceIPAddress": "192.0.2.0", "userAgent": "[]", "requestParameters": { "fleetIds": [ "fleet-0bb84136-4f69-4bb2-bfec-a9b9a7c3d52e" ] }, "responseElements": null,

Version150

Amazon GameLift Developer GuideDescripción de las entradas de

archivos de log de Amazon GameLift

"requestID": "82e7f0ec-ae85-11e5-a8d6-61d5cafb25f2", "eventID": "11daabcb-0094-49f2-8b3d-3a63c8bad86f", "eventType": "AwsApiCall", "recipientAccountId": "111122223333" }, ]}

Version151

Amazon GameLift Developer GuideReferencia de la API de servidor (C++)

Guías de referencia de AmazonGameLift

Esta sección contiene un conjunto de guías de referencia disponibles para utilizar Amazon GameLift.

Temas• Referencia de la API de servidor (C++) de Amazon GameLift (p. 152)• Referencia de la API de servidor (C#) de Amazon GameLift (p. 168)• Referencia de la API del servidor de Amazon GameLift para Unreal Engine (p. 182)• Referencia de reglas de FlexMatch (p. 189)• Referencia de eventos de FlexMatch (p. 193)

Referencia de la API de servidor (C++) de AmazonGameLift

Esta referencia de la API de servidor de C++ de Amazon GameLift puede ayudarle a preparar el juegomultijugador para utilizarlo con Amazon GameLift. Para obtener más información sobre el proceso deintegración, consulte Adición de Amazon GameLift al servidor de juegos (p. 31).

Esta API se define en GameLiftServerAPI.h, LogParameters.h y ProcessParameters.h.

• Actions (p. 152)• Tipos de datos (p. 164)

Referencia de la API de servidor (C++) de AmazonGameLift: accionesEsta referencia de la API de servidor de C++ de Amazon GameLift puede ayudarle a preparar el juegomultijugador para utilizarlo con Amazon GameLift. Para obtener más información sobre el proceso deintegración, consulte Adición de Amazon GameLift al servidor de juegos (p. 31).


• Actions• Tipos de datos (p. 164)

AcceptPlayerSession()Notifica al servicio Amazon GameLift que un jugador con el ID de sesión de jugador especificado se haconectado al proceso del servidor y requiere validación. Amazon GameLift verifica que el ID de sesióndel jugador es válido, es decir, que el ID de jugador ha reservado una ranura de jugador en la sesión dejuego. Una vez completada la validación, Amazon GameLift cambia el estado de la ranura de jugador deRESERVED a ACTIVE.

Version152

Amazon GameLift Developer GuideActions

Sintaxis

GenericOutcome AcceptPlayerSession(const std::string& playerSessionId);

Parámetros

playerSessionId

ID único emitido por el servicio Amazon GameLift en respuesta a una llamada a la acción de APICreatePlayerSession de Amazon GameLift en AWS SDK. El cliente del juego hace referencia a esteID cuando se conecta al proceso del servidor.

Tipo: std::string

Requerido: sí

Valor devuelto

Devuelve un resultado genérico que se compone de una notificación que indica que la operación se harealizado correctamente o de un mensaje de error.

Ejemplo

Este ejemplo muestra una función para gestionar una solicitud de conexión, incluida la validación y elrechazo de ID de sesión de jugador no válidos.

void ReceiveConnectingPlayerSessionID (Connection& connection, const std::string& playerSessionId){ Aws::GameLift::GenericOutcome connectOutcome = Aws::GameLift::Server::AcceptPlayerSession(playerSessionId); if(connectOutcome.IsSuccess()) { connectionToSessionMap.emplace(connection, playerSessionId); connection.Accept(); } else { connection.Reject(connectOutcome.GetError().GetMessage(); } }

ActivateGameSession()Notifica al servicio Amazon GameLift que el proceso del servidor ha iniciado una sesión de juego y queestá listo para recibir las conexiones de los jugadores. Esta acción debe llamarse como parte de la funciónde devolución de llamada onStartGameSession(), después de completar la inicialización de todas lassesiones de juego.

Sintaxis

GenericOutcome ActivateGameSession();

Parámetros

Esta acción no tiene parámetros.

Version153



Valor devuelto


Ejemplo

Este ejemplo muestra cómo se llama a ActivateGameSession() como parte de la función dedevolución de llamada onStartGameSession().

void onStartGameSession(Aws::GameLift::Model::GameSession myGameSession){ // game-specific tasks when starting a new game session, such as loading map GenericOutcome outcome = Aws::GameLift::Server::ActivateGameSession();}

DescribePlayerSessions()Recupera datos de sesión de jugador, incluida la configuración, los metadatos de la sesión y los datosde jugador. Utilice esta acción para obtener información para una única sesión de jugador, para todas lassesiones de jugador de una sesión de juego o para todas las sesiones de jugador asociadas a un solo IDde jugador.

Sintaxis

DescribePlayerSessionsOutcome DescribePlayerSessions ( const Aws::GameLift::Server::Model::DescribePlayerSessionsRequest &describePlayerSessionsRequest);

Parámetros

describePlayerSessionsRequest

Es un objeto DescribePlayerSessionsRequest (p. 164) que describe las sesiones de jugador arecuperar.

Requerido: sí

Valor devuelto

Si funciona correctamente, devuelve un objeto DescribePlayerSessionsOutcome que contiene unconjunto de objetos de sesión de jugador que se ajusta a los parámetros de la solicitud. Los objetos de lassesiones de jugador tienen una estructura idéntica al tipo de datos PlayerSession de la API del AWS SDKde Amazon GameLift.

Ejemplo

Este ejemplo muestra una solicitud de todas las sesiones de jugador conectadas activamente a una sesiónde juego específica. Al omitir NextToken y definir el valor de Limit en 10, Amazon GameLift devuelve losprimeros 10 registros de sesiones de jugador que coincidan con la solicitud.

// Set request parametersAws::GameLift::Server::Model::DescribePlayerSessionsRequest request;request.SetPlayerSessionStatusFilter(Aws::GameLift::Server::Model::PlayerSessionStatusMapper::GetNameForPlayerSessionStatus(Aws::GameLift::Server::Model::PlayerSessionStatus::Active));request.SetLimit(10);

Version154



request.SetGameSessionId("the game session ID"); // can use GetGameSessionId()

// Call DescribePlayerSessionsAws::GameLift::DescribePlayerSessionsOutcome playerSessionsOutcome = Aws::GameLift::Server::DescribePlayerSessions(request);

GetGameSessionId()Recupera un identificador único de la sesión de juego hospedada actualmente por el procesodel servidor, siempre que esté activo. El identificador se devuelve en el formato de ARN:arn:aws:gamelift:<region>::gamesession/fleet-<fleet ID>/<ID string>.

Sintaxis

AwsStringOutcome GetGameSessionId();

Parámetros


Valor devuelto

Si funciona correctamente, devuelve el ID de sesión del juego como objeto AwsStringOutcome. Si nofunciona, devuelve un mensaje de error.

Ejemplo

Aws::GameLift::AwsStringOutcome sessionIdOutcome = Aws::GameLift::Server::GetGameSessionId();

GetSdkVersion()Devuelve el número de versión actual del SDK en uso.

Sintaxis

AwsStringOutcome GetSdkVersion();

Parámetros


Valor devuelto

Si funciona correctamente, devuelve la versión del SDK actual como objeto AwsStringOutcome. Lacadena devuelta solo incluye el número de versión (por ejemplo, "3.1.5"). Si no funciona, devuelve unmensaje de error.

Ejemplo

Aws::GameLift::AwsStringOutcome SdkVersionOutcome = Aws::GameLift::Server::GetSdkVersion();

Version155


GetTerminationTime()Devuelve la hora a la que está programada el cierre de un proceso de servidor, si hay una hora determinación disponible. Un proceso de servidor realiza esta acción después de recibir una devolución dellamada onProcessTerminate() desde el servicio Amazon GameLift. Un proceso de servidor puedecerrarse por varias razones: (1) mal estado del proceso, (2) cuando se termina una instancia durante unevento de reducción de escala o (3) cuando una instancia se termina por una interrupción de instancia despot (p. 77).

Si el proceso ha recibido una devolución de llamada onProcessTerminate(), el devuelto es la horade terminación estimada en segundos en formato de tiempo Unix. Si no hay una hora de terminacióndisponible, el valor devuelto es -1, lo que indica que el proceso de servidor podría terminarse en cualquiermomento. Si el proceso no ha recibido una devolución de llamada onProcessTerminate(), el valordevuelto siempre será -1. Más información acerca del apagado de un proceso de servidor (p. 34).

Sintaxis

AwsLongOutcome GetTerminationTime();

ParámetrosEsta acción no tiene parámetros.

Valor devueltoSi funciona correctamente, devuelve la versión del SDK actual como objeto AwsLongOutcome. El valor esla hora de terminación en segundos en formato de tiempo Unix o el valor -1. Si no funciona, devuelve unmensaje de error.

Ejemplo

Aws::GameLift::AwsLongOutcome TermTimeOutcome = Aws::GameLift::Server::GetTerminationTime();

InitSDK()Inicializa el SDK de Amazon GameLift. Este método debe llamarse en el momento del lanzamiento, antesde cualquier otra inicialización relacionada con Amazon GameLift.

Sintaxis

InitSDKOutcome InitSDK();


Valor devueltoSi funciona correctamente, devuelve un objeto InitSdkOutcome e indica que el proceso del servidor estálisto para llamar a ProcessReady() (p. 157).

Ejemplo

Aws::GameLift::Server::InitSDKOutcome initOutcome =

Version156


Aws::GameLift::Server::InitSDK();

ProcessEnding()Notifica al servicio Amazon GameLift que el proceso del servidor se va a apagar. Se debe salir de estemétodo con un código de salida de 0; un código de salida que no sea 0 provoca un mensaje de evento queafirma que no se ha salido del proceso correctamente.

Sintaxis

GenericOutcome ProcessEnding();

Parámetros


Valor devuelto


Ejemplo

Aws::GameLift::GenericOutcome outcome = Aws::GameLift::Server::ProcessEnding();

ProcessReady()Notifica al servicio Amazon GameLift que el proceso del servidor está listo para alojar sesiones de juego.Este método debe llamarse después de llamar correctamente a InitSDK() (p. 156) y completar las tareasde configuración necesarias antes de que el proceso del servidor pueda alojar una sesión de juego.

La llamada es síncrona. Para realizar una llamada asíncrona, utilice ProcessReadyAsync() (p. 158).Consulte Preparación de un proceso del servidor (p. 32) para obtener más detalles.

Sintaxis

GenericOutcome ProcessReady( const Aws::GameLift::Server::ProcessParameters &processParameters);

Parámetros

processParameters

Es un objeto ProcessParameters (p. 165) que comunica la siguiente información acerca del procesodel servidor:• Nombres de métodos de devolución de llamada, implementados en el código de servidor de juegos,

que el servicio Amazon GameLift invoca para comunicarse con el proceso del servidor.• Número de puerto de escucha del servidor de proceso.• Ruta a cualquier archivo específico de la sesión de juego que desea que Amazon GameLift capture

y almacene.

Requerido: sí

Version157


Valor devueltoDevuelve un resultado genérico que se compone de una notificación que indica que la operación se harealizado correctamente o de un mensaje de error.

EjemploEste ejemplo ilustra las implementaciones tanto de la función de llamada como de la función de devoluciónde llamada ProcessReady() (p. 157).

// Set parameters and call ProcessReadystd::string serverLog("serverOut.log"); // Example of a log file written by the game serverstd::vector<std::string> logPaths;logPaths.push_back(serverLog);

int listenPort = 9339;

Aws::GameLift::Server::ProcessParameters processReadyParameter = Aws::GameLift::Server::ProcessParameters( std::bind(&Server::onStartGameSession, this, std::placeholders::_1), std::bind(&Server::onProcessTerminate, this), std::bind(&Server::OnHealthCheck, this), std::bind(&Server::OnUpdateGameSession, this), listenPort, Aws::GameLift::Server::LogParameters(logPaths));

Aws::GameLift::GenericOutcome outcome = Aws::GameLift::Server::ProcessReady(processReadyParameter);

// Implement callback functionsvoid Server::onStartGameSession(Aws::GameLift::Model::GameSession myGameSession){ // game-specific tasks when starting a new game session, such as loading map GenericOutcome outcome = Aws::GameLift::Server::ActivateGameSession (maxPlayers);}

void Server::onProcessTerminate(){ // game-specific tasks required to gracefully shut down a game session, // such as notifying players, preserving game state data, and other cleanup GenericOutcome outcome = Aws::GameLift::Server::ProcessEnding();}

bool Server::onHealthCheck(){ bool health; // complete health evaluation within 60 seconds and set health return health;}

ProcessReadyAsync()Notifica al servicio Amazon GameLift que el proceso del servidor está listo para alojar sesiones de juego.Este método debe llamarse cuando el proceso del servidor esté listo para alojar una sesión de juego.Los parámetros especifican los nombres de las funciones de devolución de llamada para que AmazonGameLift llame en determinadas circunstancias. El código de servidor de juegos debe implementar estasfunciones.

La llamada es asíncrona. Para realizar una llamada síncrona, utilice ProcessReady() (p. 157). ConsultePreparación de un proceso del servidor (p. 32) para obtener más detalles.

Version158


Sintaxis

GenericOutcomeCallable ProcessReadyAsync( const Aws::GameLift::Server::ProcessParameters &processParameters);

Parámetros

processParameters



y almacene.

Requerido: sí

Valor devuelto


Ejemplo

// Set parameters and call ProcessReadystd::string serverLog("serverOut.log"); // This is an example of a log file written by the game serverstd::vector<std::string> logPaths;logPaths.push_back(serverLog);

int listenPort = 9339;

Aws::GameLift::Server::ProcessParameters processReadyParameter = Aws::GameLift::Server::ProcessParameters( std::bind(&Server::onStartGameSession, this, std::placeholders::_1), std::bind(&Server::onProcessTerminate, this), std::bind(&Server::OnHealthCheck, this), std::bind(&Server::OnUpdateGameSession, this), listenPort, Aws::GameLift::Server::LogParameters(logPaths));

Aws::GameLift::GenericOutcomeCallable outcome = Aws::GameLift::Server::ProcessReadyAsync(processReadyParameter);

// Implement callback functionsvoid onStartGameSession(Aws::GameLift::Model::GameSession myGameSession){ // game-specific tasks when starting a new game session, such as loading map GenericOutcome outcome = Aws::GameLift::Server::ActivateGameSession (maxPlayers);}

void onProcessTerminate(){ // game-specific tasks required to gracefully shut down a game session, // such as notifying players, preserving game state data, and other cleanup GenericOutcome outcome = Aws::GameLift::Server::ProcessEnding();}

Version159


bool onHealthCheck(){ // perform health evaluation and complete within 60 seconds return health;}

RemovePlayerSession()Notifica al servicio Amazon GameLift que un jugador con el ID de sesión de jugador especificado se hadesconectado del proceso del servidor. En respuesta, Amazon GameLift cambia el estado de la ranura dejugador a disponible, por lo que se le puede asignar un jugador nuevo.

Sintaxis

GenericOutcome RemovePlayerSession( const std::string& playerSessionId);

Parámetros

playerSessionId


Tipo: std::string

Requerido: sí

Valor devuelto


Ejemplo

Aws::GameLift::GenericOutcome disconnectOutcome = Aws::GameLift::Server::RemovePlayerSession(playerSessionId);

StartMatchBackfill()Envía una solicitud para encontrar nuevos jugadores para ranuras abiertas en una sesión de juego creadacon FlexMatch. Véase también la acción del SDK de AWS StartMatchBackfill(). Con esta acción, unproceso del servidor de juegos que hospeda la sesión de juego puede iniciar solicitudes de reposiciónde emparejamiento. Encontrará más información acerca de la función de reposición de FlexMatch enReposición de juegos existentes con FlexMatch (p. 123).

Esta acción es asíncrona. Si se emparejan correctamente nuevos jugadores, el servicio Amazon GameLiftofrece datos actualizados del creador de emparejamientos por medio de la función de devolución dellamada OnUpdateGameSession().

Un proceso del servidor solo puede tener una solicitud de reposición de emparejamiento activa a la vez.Para enviar una nueva solicitud, en primer lugar llame a StopMatchBackfill() (p. 161) para cancelar lasolicitud original.

Version160


http://docs.aws.amazon.com/gamelift/latest/apireference/API_StartMatchBackfill.html


Sintaxis

StartMatchBackfillOutcome StartMatchBackfill ( const Aws::GameLift::Server::Model::StartMatchBackfillRequest &startBackfillRequest);

Parámetros

StartMatchBackfillRequest

Un objeto StartMatchBackfillRequest (p. 167) que comunica la siguiente información:• Un ID de ticket que se asignará a la solicitud de reposición. Esta información es opcional; si no se

proporciona ningún ID, Amazon GameLift lo generará automáticamente.• El creador de emparejamientos al que se enviará la solicitud. El ARN de configuración completo es

obligatorio. Este valor se puede obtener de los datos del creador de emparejamientos de la sesiónde juego.

• El ID de la sesión de juego que está en fase de reposición.• Datos de emparejamiento disponibles para los jugadores actuales de la sesión de juego.

Requerido: sí

Valor devuelto

Devuelve un objeto StartMatchBackfillOutcome con el ticket de reposición de emparejamiento o un errorcon un mensaje de error. Podrá realizar el seguimiento del estado del ticket con la acción del SDK de AWSDescribeMatchmaking().

Ejemplo

// Build a backfill requeststd::vector<Player> players;Aws::GameLift::Server::Model::StartMatchBackfillRequest startBackfillRequest;startBackfillRequest.SetTicketId("a ticket ID"); //optional, autogenerated if not providedstartBackfillRequest.SetMatchmakingConfigurationArn("the matchmaker configuration ARN"); //from the game session matchmaker datastartBackfillRequest.SetGameSessionArn("the game session ARN"); // can use GetGameSessionId()startBackfillRequest.SetPlayers(players); //from the game session matchmaker data

// Send backfill requestAws::GameLift::StartMatchBackfillOutcome backfillOutcome = Aws::GameLift::Server::StartMatchBackfill(startBackfillRequest);

// Implement callback function for backfillvoid Server::OnUpdateGameSession(Aws::GameLift::Server::Model::GameSession gameSession, Aws::GameLift::Server::Model::UpdateReason updateReason, std::string backfillTicketId){ // handle status messages // perform game-specific tasks to prep for newly matched players}

StopMatchBackfill()Cancela una solicitud de reposición de emparejamiento activa que se creó conStartMatchBackfill() (p. 160). Véase también la acción del SDK de AWS StopMatchmaking(). Encontrará

Version161

http://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeMatchmaking.html

http://docs.aws.amazon.com/gamelift/latest/apireference/API_StopMatchmaking.html


más información acerca de la función de reposición de FlexMatch en Reposición de juegos existentes conFlexMatch (p. 123).

Sintaxis

GenericOutcome StopMatchBackfill ( const Aws::GameLift::Server::Model::StopMatchBackfillRequest &stopBackfillRequest);

Parámetros

StopMatchBackfillRequest

Un objeto StopMatchBackfillRequest (p. 167) que identifica el ticket de emparejamiento que se va acancelar:• ID del ticket asignado a la solicitud de reposición que se va a cancelar• el creador de emparejamientos al que se envió la solicitud de reposición• sesión de juego asociada a la solicitud de reposición

Requerido: sí


Ejemplo

// Set backfill stop request parameters

Aws::GameLift::Server::Model::StopMatchBackfillRequest stopBackfillRequest;stopBackfillRequest.SetTicketId("the ticket ID");stopBackfillRequest.SetGameSessionArn("the game session ARN"); // can use GetGameSessionId()stopBackfillRequest.SetMatchmakingConfigurationArn("the matchmaker configuration ARN"); // from the game session matchmaker data

Aws::GameLift::GenericOutcome stopBackfillOutcome = Aws::GameLift::Server::StopMatchBackfillRequest(stopBackfillRequest);

TerminateGameSession()Notifica al servicio Amazon GameLift que el proceso del servidor ha cerrado la sesión de juego. Comocada proceso del servidor hospeda únicamente una sesión de juego a la vez, no hay necesidad deespecificar qué sesión. Esta acción debe llamarse al final del proceso de cierre de la sesión de juego.Después de llamar a esta acción, el proceso del servidor puede llamar a ProcessReady() (p. 157)para indicar su disponibilidad para alojar una sesión nueva de juego. También puede llamar aProcessEnding() (p. 157) para cerrar el proceso del servidor y terminar la instancia.

Sintaxis

GenericOutcome TerminateGameSession();


Version162


Valor devuelto


Ejemplo

Este ejemplo ilustra un proceso del servidor al final de una sesión de juego.

// game-specific tasks required to gracefully shut down a game session, // such as notifying players, preserving game state data, and other cleanup

Aws::GameLift::GenericOutcome outcome = Aws::GameLift::Server::TerminateGameSession();Aws::GameLift::GenericOutcome outcome = Aws::GameLift::Server::ProcessReady(onStartGameSession, onProcessTerminate);

UpdatePlayerSessionCreationPolicy()Actualiza la capacidad de la sesión de juego actual para aceptar sesiones de jugador nuevas. Una sesiónde juego se puede configurar para que acepte o deniegue todas las sesiones nuevas de los jugadores.Véase también la acción del SDK de AWS UpdateGameSession().

Sintaxis

GenericOutcome UpdatePlayerSessionCreationPolicy( Aws::GameLift::Model::PlayerSessionCreationPolicy newPlayerSessionPolicy);

Parámetros

newPlayerSessionPolicy

Valor de cadena que indica si la sesión de juego acepta jugadores nuevos.

Tipo: Aws::GameLift::Model::PlayerSessionCreationPolicy enum. Los valores válidos son:• ACCEPT_ALL: se aceptan todas las sesiones de jugador nuevas.• DENY_ALL: se rechazan todas las sesiones de jugador nuevas.

Requerido: sí

Valor devuelto


Ejemplo

Este ejemplo establece la política de participación en la sesión de juego actual para aceptar todos losjugadores.

Aws::GameLift::GenericOutcome outcome = Aws::GameLift::Server::UpdatePlayerSessionCreationPolicy(Aws::GameLift::Model::PlayerSessionCreationPolicy::ACCEPT_ALL);

Version163

http://docs.aws.amazon.com/gamelift/latest/apireference/API_UpdateGameSession.html

http://sdk.amazonaws.com/cpp/api/LATEST/namespace_aws_1_1_game_lift_1_1_model.html#afa8a7527defe9e7ca0caebc239182c53

Amazon GameLift Developer GuideTipos de datos

Referencia de la API de servidor (C++) de AmazonGameLift: tipos de datosEsta referencia de la API de servidor de C++ de Amazon GameLift puede ayudarle a preparar el juegomultijugador para utilizarlo con Amazon GameLift. Para obtener más información sobre el proceso deintegración, consulte Adición de Amazon GameLift al servidor de juegos (p. 31).


• Actions (p. 152)• Tipos de datos

DescribePlayerSessionsRequestEste tipo de datos se utiliza para especificar qué sesión o sesiones de jugador recuperar. Puede utilizarlopara las siguientes tareas:

• Proporcionar un PlayerSessionId para solicitar una sesión de jugador específica.• Proporcionar un GameSessionId para solicitar todas las sesiones de jugador de la sesión de juego

especificada.• Proporcionar un PlayerId para solicitar todas las sesiones de jugador del jugador especificado.

Para grandes conjuntos de sesiones de jugador, utilice los parámetros de paginación para recuperar losresultados en bloques consecutivos.

Contenido

GameSessionId

Identificador único de la sesión de juego. Use este parámetro para solicitar todas las sesiones dejugador de la sesión de juego especificada. El formato de ID de la sesión de juego es el siguiente:arn:aws:gamelift:<region>::gamesession/fleet-<fleet ID>/<ID string>. El valorde la <cadena de ID> es una cadena de ID personalizada o (si se especificó una cuando se creó lasesión de juego) una cadena generada.

Tipo: String

Requerido: NoLímite

Número máximo de resultados a devolver. Use este parámetro con NextToken para obtenerresultados en un conjunto de páginas secuenciales. Si se especifica un ID de sesión de jugador, esteparámetro se ignora.

Tipo: Número entero

Requerido: NoNextToken

Token que indica el inicio de la siguiente página de resultados secuencial. Utilice el token devuelto conuna llamada anterior a esta acción. Para especificar el inicio del conjunto de resultados, no indiqueningún valor. Si se especifica un ID de sesión de jugador, este parámetro se ignora.

Tipo: String

Version164


Requerido: NoPlayerId

Identificador único de un jugador. Los ID de jugador los define el desarrollador. Consulte Generaciónde ID de jugador (p. 39).

Tipo: String

Requerido: NoPlayerSessionId

Identificador único de una sesión de jugador.

Tipo: String

Requerido: NoPlayerSessionStatusFilter

Estado de la sesión de juego para filtrar los resultados. Los posibles estados de sesión de jugadorson:• RESERVED: se ha recibido la solicitud de sesión de jugador, pero el jugador aún no se ha

conectado al proceso del servidor o aún no se ha validado.• ACTIVE: el proceso del servidor ha validado el jugador y actualmente está conectado.• COMPLETED: ha caído la conexión del jugador.• TIMEDOUT: se ha recibido una solicitud de sesión de jugador, pero el jugador no se ha conectado

y/o no se ha validado en el plazo de tiempo de espera (60 segundos).

Tipo: String

Requerido: No

LogParametersEste tipo de datos se utiliza para identificar los archivos generados durante una sesión de juego quedesea que Amazon GameLift cargue y almacene cuando finalice la sesión de juego. Esta información secomunicará al servicio Amazon GameLift en una llamada ProcessReady() (p. 157).

Contenido

logPaths

Rutas de directorio a archivos de log del servidor de juegos que desea que Amazon GameLiftalmacene para futuros accesos. Estos archivos se generan durante cada sesión de juego. Losnombres y las rutas de los archivos se definen en el servidor de juegos y se almacenan en el directorioraíz de compilación del juego. Por ejemplo, si la compilación del juego almacena los logs de sesiónde juego en una ruta del tipo MyGame\sessionlogs\, entonces la ruta de los logs sería c:\game\MyGame\sessionLogs (en una instancia Windows) o /local/game/MyGame/sessionLogs (enuna instancia Linux).

Tipo: std:vector<std::string>

Requerido: No

ProcessParametersEste tipo de datos contiene un conjunto de parámetros enviado al servicio Amazon GameLift en unallamada ProcessReady() (p. 157).

Version165


Contenido

port

Es el número de puerto en el que escucha el proceso del servidor para recibir conexiones de jugadornuevas. El valor debe estar en el rango de puertos configurado para cualquier flota que implementeesa compilación de servidor de juegos. Este número de puerto se incluye en los objetos de sesiónde juego y de jugador, que las sesiones de juego utilizan a la hora de conectarse a un proceso delservidor.


Requerido: sílogParameters

Objeto con una lista de rutas de directorio a archivos de log de la sesión de juego.

Tipo: Aws::GameLift::Server::LogParameters (p. 165)

Requerido: NoonStartGameSession

Nombre de la función de devolución de llamada que el servicio Amazon GameLift llama para activaruna sesión de juego nueva. Amazon GameLift llama a esta función en respuesta a la solicitud decliente CreateGameSession. La función de devolución de llamada pasa un objeto GameSession(definido en la Referencia de la API del servicio Amazon GameLift).

Escriba: const std::function<void(Aws::GameLift::Model::GameSession)>onStartGameSession

Requerido: síonProcessTerminate

Nombre de la función de devolución de llamada que el servicio Amazon GameLift llama paraforzar el cierre del proceso del servidor. Después de llamar a esta función, Amazon GameLiftespera cinco minutos hasta que el proceso del servidor se cierre y responda con una llamadaProcessEnding() (p. 157). Si no recibe respuesta, cierra el proceso del servidor.

Escriba: std::function<void()> onProcessTerminate

Requerido: NoonHealthCheck

Nombre de la función de devolución de llamada que el servicio Amazon GameLift llama para solicitarun informe de estado del proceso del servidor. Amazon GameLift llama a esta función cada 60segundos. Después de llamar a esta función, Amazon GameLift espera una respuesta durante 60segundos y si no recibe respuesta, registra que el proceso del servidor no funciona correctamente.

Escriba: std::function<bool()> onHealthCheck

Requerido: NoonUpdateGameSession

Nombre de la función de devolución de llamada a la que el servicio Amazon GameLift llama paraproporcionar un objeto de sesión de juego actualizado. Amazon GameLift llama a esta función unavez que se ha procesado una solicitud de reposición de emparejamiento (p. 123). Pasa un objetoGameSession, una actualización de estado (updateReason) y el ID del ticket de reposición deemparejamiento.

Escriba: std::function<void(Aws::GameLift::Server::Model::UpdateGameSession)>onUpdateGameSession

Version166





Requerido: No

StartMatchBackfillRequestEste tipo de datos se utiliza para enviar una solicitud de reposición de emparejamiento. La información secomunica al servicio Amazon GameLift en una llamada StartMatchBackfill() (p. 160).

Contenido

GameSessionArn

Identificador único de la sesión de juego. La acción de la API GetGameSessionId() (p. 155) devuelveel identificador en formato de ARN.

Tipo: String

Requerido: síMatchmakingConfigurationArn

Identificador único, en forma de un ARN, que el creador de emparejamientos utiliza para esta solicitud.Para encontrar el creador de emparejamientos que se usó para crear la sesión de juego original,busque en el objeto de sesión de juego, en la propiedad de datos del creador de emparejamientos.Para obtener más información sobre los datos del creador de emparejamientos consulte Trabajo condatos del creador de emparejamientos (p. 122).

Tipo: String

Requerido: síPlayers

Un conjunto de datos que representa a todos los jugadores que están actualmente en la sesiónde juego. El creador de emparejamientos utiliza esta información para buscar nuevos jugadoresque son idóneos para los jugadores actuales. Para obtener una descripción del formato del objetoPlayer, consulte Guía de referencia de la API de Amazon GameLift. Para encontrar los atributos, ID yasignaciones de equipo del jugador, busque en el objeto de sesión de juego, en la propiedad de datosdel creador de emparejamientos. Si el creador de emparejamientos utiliza latencia, recopile la latenciaactualizada para la región actual e inclúyala en los datos de cada jugador.

Tipo: std:vector<Player>

Requerido: síTicketId

Identificador único para un ticket de solicitud de emparejamiento o reposición de emparejamiento. Sino se proporciona ningún valor aquí, Amazon GameLift generará uno en forma de UUID. Use esteidentificador para realizar un seguimiento del estado del ticket de reposición de emparejamiento ocancelar la solicitud si es necesario.

Tipo: String

Requerido: No

StopMatchBackfillRequestEste tipo de datos se utiliza para cancelar una solicitud de reposición de emparejamiento. La informaciónse comunica al servicio Amazon GameLift en una llamada StopMatchBackfill() (p. 161).

Version167


Amazon GameLift Developer GuideReferencia de la API de servidor (C#)

Contenido

GameSessionArn

Identificador único de sesión de juego asociado a la solicitud que se va a cancelar.

Tipo: String


Identificador único del creador de emparejamientos al que se envió esta solicitud.

Tipo: String


Identificador único del ticket de solicitud de reposición que se va a cancelar.

Tipo: String

Requerido: sí

Referencia de la API de servidor (C#) de AmazonGameLift

Esta referencia de la API de servidor C# de Amazon GameLift puede ayudarle a preparar el juegomultijugador para utilizarlo con Amazon GameLift. Para obtener más información sobre el proceso deintegración, consulte Adición de Amazon GameLift al servidor de juegos (p. 31).

Esta API se define en GameLiftServerAPI.cs, LogParameters.cs y ProcessParameters.cs.


Referencia de la API de servidor (C#) de AmazonGameLift: accionesEsta referencia de la API de servidor C# de Amazon GameLift puede ayudarle a preparar el juegomultijugador para utilizarlo con Amazon GameLift. Para obtener más información sobre el proceso deintegración, consulte Adición de Amazon GameLift al servidor de juegos (p. 31).

Esta API se define en GameLiftServerAPI.cs, LogParameters.cs y ProcessParameters.cs.


AcceptPlayerSession()Notifica al servicio Amazon GameLift que un jugador con el ID de sesión de jugador especificado se haconectado al proceso del servidor y requiere validación. Amazon GameLift verifica que el ID de sesión

Version168


del jugador es válido, es decir, que el ID de jugador ha reservado una ranura de jugador en la sesión dejuego. Una vez completada la validación, Amazon GameLift cambia el estado de la ranura de jugador deRESERVED a ACTIVE.

Sintaxis

GenericOutcome AcceptPlayerSession(String playerSessionId)

Parámetros

playerSessionId


Tipo: String

Requerido: sí


EjemploEste ejemplo muestra una función para gestionar una solicitud de conexión, incluida la validación y elrechazo de ID de sesión de jugador no válidos.

void ReceiveConnectingPlayerSessionID (Connection connection, String playerSessionId){ var acceptPlayerSessionOutcome = GameLiftServerAPI.AcceptPlayerSession(playerSessionId); if(acceptPlayerSessionOutcome.Success) { connectionToSessionMap.emplace(connection, playerSessionId); connection.Accept(); } else { connection.Reject(acceptPlayerSessionOutcome.Error.ErrorMessage); } }

ActivateGameSession()Notifica al servicio Amazon GameLift que el proceso del servidor ha activado una sesión de juego y queestá listo para recibir las conexiones de los jugadores. Esta acción debe llamarse como parte de la funciónde devolución de llamada onStartGameSession(), después de completar la inicialización de todas lassesiones de juego.

Sintaxis

GenericOutcome ActivateGameSession()


Version169




EjemploEste ejemplo muestra cómo se llama a ActivateGameSession() como parte de la función dedelegación onStartGameSession().

void OnStartGameSession(GameSession gameSession){ // game-specific tasks when starting a new game session, such as loading map

// When ready to receive players var activateGameSessionOutcome = GameLiftServerAPI.ActivateGameSession();}

DescribePlayerSessions()Recupera datos de sesión de jugador, incluida la configuración, los metadatos de la sesión y los datosde jugador. Utilice esta acción para obtener información para una única sesión de jugador, para todas lassesiones de jugador de una sesión de juego o para todas las sesiones de jugador asociadas a un solo IDde jugador.

Sintaxis

DescribePlayerSessionsOutcome DescribePlayerSessions(DescribePlayerSessionsRequest describePlayerSessionsRequest)

Parámetros

describePlayerSessionsRequest

Es un objeto DescribePlayerSessionsRequest (p. 179) que describe las sesiones de jugador arecuperar.

Requerido: sí

Valor devueltoSi funciona correctamente, devuelve un objeto DescribePlayerSessionsOutcome que contiene unconjunto de objetos de sesión de jugador que se ajusta a los parámetros de la solicitud. Los objetos de lassesiones de jugador tienen una estructura idéntica al tipo de datos PlayerSession de la API del AWS SDKde Amazon GameLift.

EjemploEste ejemplo muestra una solicitud de todas las sesiones de jugador conectadas activamente a una sesiónde juego específica. Al omitir NextToken y definir el valor de Limit en 10, Amazon GameLift devolverá losprimeros 10 registros de sesiones de jugador que coincidan con la solicitud.

// Set request parameters var describePlayerSessionsRequest = new Aws.GameLift.Server.Model.DescribePlayerSessionsRequest(){ GameSessionId = GameLiftServerAPI.GetGameSessionId().Result, //gets the ID for the current game session

Version170



Limit = 10, PlayerSessionStatusFilter = PlayerSessionStatusMapper.GetNameForPlayerSessionStatus(PlayerSessionStatus.ACTIVE)}; // Call DescribePlayerSessionsAws::GameLift::DescribePlayerSessionsOutcome playerSessionsOutcome = Aws::GameLift::Server::Model::DescribePlayerSessions(describePlayerSessionRequest);

GetGameSessionId()Recupera el ID de la sesión de juego alojada actualmente por el proceso del servidor, siempre que estéactivo.

Sintaxis

AwsStringOutcome GetGameSessionId()


Valor devueltoSi funciona correctamente, devuelve el ID de sesión del juego como objeto AwsStringOutcome. Si nofunciona, devuelve un mensaje de error.

Ejemplo

var getGameSessionIdOutcome = GameLiftServerAPI.GetGameSessionId();

GetSdkVersion()Devuelve el número de versión actual del SDK integrado en el proceso del servidor.

Sintaxis

AwsStringOutcome GetSdkVersion()


Valor devueltoSi funciona correctamente, devuelve la versión del SDK actual como objeto AwsStringOutcome. Lacadena devuelta solo incluye el número de versión (por ejemplo, "3.1.5"). Si no funciona, devuelve unmensaje de error.

Ejemplo

var getSdkVersionOutcome = GameLiftServerAPI.GetSdkVersion();

GetTerminationTime()Devuelve la hora a la que está programada el cierre de un proceso de servidor, si hay una hora determinación disponible. Un proceso de servidor realiza esta acción después de recibir una devolución de

Version171


llamada onProcessTerminate() desde el servicio Amazon GameLift. Un proceso de servidor puedecerrarse por varias razones: (1) mal estado del proceso, (2) cuando se termina una instancia durante unevento de reducción de escala o (3) cuando una instancia se termina por una interrupción de instancia despot (p. 77).

Si el proceso ha recibido una devolución de llamada onProcessTerminate(), el devuelto es la horade terminación estimada en segundos en formato de tiempo Unix. Si no hay una hora de terminacióndisponible, el valor devuelto es -1, lo que indica que el proceso de servidor podría terminarse en cualquiermomento. Si el proceso no ha recibido una devolución de llamada onProcessTerminate(), el valordevuelto siempre será -1. Más información acerca del apagado de un proceso de servidor (p. 34).

Sintaxis

AwsLongOutcome GetTerminationTime()


Valor devueltoSi funciona correctamente, devuelve la versión del SDK actual como objeto AwsLongOutcome. El valor esla hora de terminación en segundos en formato de tiempo Unix o el valor -1. Si no funciona, devuelve unmensaje de error.

Ejemplo

var getTerminationTimeOutcome = GameLiftServerAPI.GetTerminationTime();


Sintaxis

InitSDKOutcome InitSDK()


Valor devueltoSi funciona correctamente, devuelve un objeto InitSdkOutcome e indica que el proceso del servidor estálisto para llamar a ProcessReady() (p. 173).

Ejemplo

var initSDKOutcome = GameLiftServerAPI.InitSDK();

ProcessEnding()Notifica al servicio Amazon GameLift que el proceso del servidor se va a apagar. Se debe salir de estemétodo con un código de salida de 0; un código de salida que no sea 0 provoca un mensaje de evento queafirma que no se ha salido del proceso correctamente.

Version172


Sintaxis

GenericOutcome ProcessEnding()

Parámetros


Valor devuelto


Ejemplo

var processEndingOutcome = GameLiftServerAPI.ProcessEnding();


Sintaxis

GenericOutcome ProcessReady(ProcessParameters processParameters)

Parámetros

processParameters



y almacene.

Requerido: sí

Valor devuelto


Ejemplo

Este ejemplo ilustra las implementaciones tanto de la función de llamada ProcessReady() (p. 173) comode la función de delegación.

// Set parameters and call ProcessReady

Version173


var processParams = new ProcessParameters( this.OnGameSession, this.OnProcessTerminate, this.OnHealthCheck, this.OnGameSessionUpdate, port, new LogParameters(new List<string>() // Examples of log and error files written by the game server { "C:\\game\\logs", "C:\\game\\error" }));

var processReadyOutcome = GameLiftServerAPI.ProcessReady(processParams);

// Implement callback functionsvoid OnGameSession(GameSession gameSession){ // game-specific tasks when starting a new game session, such as loading map // When ready to receive players var activateGameSessionOutcome = GameLiftServerAPI.ActivateGameSession();}

void OnProcessTerminate(){ // game-specific tasks required to gracefully shut down a game session, // such as notifying players, preserving game state data, and other cleanup var ProcessEndingOutcome = GameLiftServerAPI.ProcessEnding(); GameLiftServerAPI.Destroy();}

bool OnHealthCheck(){ bool isHealthy; // complete health evaluation within 60 seconds and set health return isHealthy;}


Sintaxis

GenericOutcome RemovePlayerSession(String playerSessionId)

Parámetros

playerSessionId


Tipo: String

Requerido: sí

Version174



Valor devuelto


Ejemplo

Aws::GameLift::GenericOutcome disconnectOutcome = Aws::GameLift::Server::RemovePlayerSession(playerSessionId);

StartMatchBackfill()Envía una solicitud para encontrar nuevos jugadores para ranuras abiertas en una sesión de juego creadacon FlexMatch. Véase también la acción del SDK de AWS StartMatchBackfill(). Con esta acción, unproceso del servidor de juegos que hospeda la sesión de juego puede iniciar solicitudes de reposiciónde emparejamiento. Encontrará más información acerca de la función de reposición de FlexMatch enReposición de juegos existentes con FlexMatch (p. 123).

Esta acción es asíncrona. Si se emparejan correctamente nuevos jugadores, el servicio Amazon GameLiftofrece datos actualizados del creador de emparejamientos por medio de la función de devolución dellamada OnUpdateGameSession().

Un proceso del servidor solo puede tener una solicitud de reposición de emparejamiento activa a la vez.Para enviar una nueva solicitud, en primer lugar llame a StopMatchBackfill() (p. 176) para cancelar lasolicitud original.

Sintaxis

StartMatchBackfillOutcome StartMatchBackfill (StartMatchBackfillRequest startBackfillRequest);

Parámetros

StartMatchBackfillRequest

Un objeto StartMatchBackfillRequest (p. 181) que comunica la siguiente información:• Un ID de ticket que se asignará a la solicitud de reposición. Esta información es opcional; si no se

proporciona ningún ID, Amazon GameLift lo generará automáticamente.• El creador de emparejamientos al que se enviará la solicitud. El ARN de configuración completo es

obligatorio. Este valor se puede obtener de los datos del creador de emparejamientos de la sesiónde juego.

• El ID de la sesión de juego que está en fase de reposición.• Datos de emparejamiento disponibles para los jugadores actuales de la sesión de juego.

Requerido: sí

Valor devuelto

Devuelve un objeto StartMatchBackfillOutcome con el ID del ticket de reposición de emparejamiento o unerror con un mensaje de error.

Ejemplo

// Build a backfill request

Version175

http://docs.aws.amazon.com/gamelift/latest/apireference/API_StartMatchBackfill.html


var startBackfillRequest = new AWS.GameLift.Server.Model.StartMatchBackfillRequest(){ TicketId = "a ticket ID", //optional MatchmakingConfigurationArn = "the matchmaker configuration ARN", GameSessionId = GameLiftServerAPI.GetGameSessionId().Result, // gets ID for current game session //get player data for all currently connected players MatchmakerData matchmakerData = MatchmakerData.FromJson(gameSession.MatchmakerData); // gets matchmaker data for current players // get matchmakerData.Players // remove data for players who are no longer connected Players = ListOfPlayersRemainingInTheGame};

// Send backfill requestvar startBackfillOutcome = GameLiftServerAPI.StartMatchBackfill(startBackfillRequest);

// Implement callback function for backfillvoid OnUpdateGameSession(GameSession myGameSession){ // game-specific tasks to prepare for the newly matched players and update matchmaker data as needed }

StopMatchBackfill()Cancela una solicitud de reposición de emparejamiento activa que se creó conStartMatchBackfill() (p. 175). Véase también la acción del SDK de AWS StopMatchmaking(). Encontrarámás información acerca de la función de reposición de FlexMatch en Reposición de juegos existentes conFlexMatch (p. 123).

Sintaxis

GenericOutcome StopMatchBackfill (StopMatchBackfillRequest stopBackfillRequest);

Parámetros

StopMatchBackfillRequest

Un objeto StopMatchBackfillRequest (p. 182) que identifica el ticket de emparejamiento que se va acancelar:• ID del ticket asignado a la solicitud de reposición que se va a cancelar• el creador de emparejamientos al que se envió la solicitud de reposición• sesión de juego asociada a la solicitud de reposición

Requerido: sí

Valor devuelto


Ejemplo

// Set backfill stop request parameters

Version176

http://docs.aws.amazon.com/gamelift/latest/apireference/API_StopMatchmaking.html


var stopBackfillRequest = new AWS.GameLift.Server.Model.StopMatchBackfillRequest(){ TicketId = "a ticket ID", //optional, if not provided one is autogenerated MatchmakingConfigurationArn = "the matchmaker configuration ARN", //from the game session matchmaker data GameSessionId = GameLiftServerAPI.GetGameSessionId().Result //gets the ID for the current game session};

var stopBackfillOutcome = GameLiftServerAPI.StopMatchBackfillRequest(stopBackfillRequest);

TerminateGameSession()Notifica al servicio Amazon GameLift que el proceso del servidor ha cerrado la sesión de juego.(Actualmente, cada proceso del servidor aloja únicamente una sesión de juego a la vez, por lo queno es necesario especificar qué sesión.) Esta acción debe llamarse al final del proceso de cierrede la sesión de juego. Después de llamar a esta acción, el proceso del servidor puede llamar aProcessReady() (p. 173) para indicar su disponibilidad para alojar una sesión nueva de juego. Tambiénpuede llamar a ProcessEnding() (p. 172) para cerrar el proceso del servidor y terminar la instancia.

Sintaxis

GenericOutcome TerminateGameSession()

Parámetros


Valor devuelto


Ejemplo

Este ejemplo ilustra un proceso del servidor al final de una sesión de juego.

// game-specific tasks required to gracefully shut down a game session, // such as notifying players, preserving game state data, and other cleanup

var terminateGameSessionOutcome = GameLiftServerAPI.TerminateGameSession();var processReadyOutcome = GameLiftServerAPI.ProcessReady(processParams);

UpdatePlayerSessionCreationPolicy()Actualiza la capacidad de la sesión de juego actual para aceptar sesiones de jugador nuevas. Unasesión de juego se puede configurar para que acepte o deniegue todas las sesiones nuevas de losjugadores. (Véase también la acción UpdateGameSession() en la Referencia de la API del servicioAmazon GameLift).

Sintaxis

GenericOutcome UpdatePlayerSessionCreationPolicy(PlayerSessionCreationPolicy playerSessionPolicy)

Version177



Parámetros

newPlayerSessionPolicy

Valor de cadena que indica si la sesión de juego acepta jugadores nuevos.

Tipo: PlayerSessionCreationPolicy enum. Los valores válidos son:• ACCEPT_ALL: se aceptan todas las sesiones de jugador nuevas.• DENY_ALL: se rechazan todas las sesiones de jugador nuevas.

Requerido: sí


EjemploEste ejemplo establece la política de participación en la sesión de juego actual para aceptar todos losjugadores.

var updatePlayerSessionCreationPolicyOutcomex = GameLiftServerAPI.UpdatePlayerSessionCreationPolicy(PlayerSessionCreationPolicy.ACCEPT_ALL);

Referencia de la API de servidor (C#) de AmazonGameLift: tipos de datosEsta referencia de la API de servidor C# de Amazon GameLift puede ayudarle a preparar el juegomultijugador para utilizarlo con Amazon GameLift. Para obtener más información sobre el proceso deintegración, consulte Adición de Amazon GameLift al servidor de juegos (p. 31).



LogParametersEste tipo de datos se utiliza para identificar los archivos generados durante una sesión de juego quedesea que Amazon GameLift cargue y almacene cuando finalice la sesión de juego. Esta información secomunicará al servicio Amazon GameLift en una llamada ProcessReady() (p. 173).

Contenido

logPaths

Lista de las rutas de directorio a archivos de log del servidor de juegos que desea que AmazonGameLift almacene para futuros accesos. Estos archivos los genera un proceso del servidor durantecada sesión de juego; las rutas de archivo y los nombres se definen en el servidor de juegos y sealmacenan en el directorio raíz de compilación de juegos. Por ejemplo, si la compilación del juegoalmacena los logs de sesión de juego en una ruta del tipo MyGame\sessionlogs\, entonces la rutade los logs sería c:\game\MyGame\sessionLogs (en una instancia Windows) o /local/game/MyGame/sessionLogs (en una instancia Linux).

Version178

http://sdk.amazonaws.com/cpp/api/LATEST/namespace_aws_1_1_game_lift_1_1_model.html#afa8a7527defe9e7ca0caebc239182c53


Tipo: Lista de <cadenas>

Requerido: No

DescribePlayerSessionsRequestEste tipo de datos se utiliza para especificar qué sesión o sesiones de jugador recuperar. Se puede utilizarde varias maneras: (1) proporcione un PlayerSessionId para solicitar una sesión de jugador específica;(2) proporcione un GameSessionId para solicitar todas las sesiones de jugador de la sesión de juegoespecificada; o (3) proporcione un PlayerId para solicitar todas las sesiones de jugador del jugadorespecificado. Para grandes recopilaciones de sesiones de jugador, utilice los parámetros de paginaciónpara recuperar resultados como páginas secuenciales.

Contenido

GameSessionId

Identificador único de la sesión de juego. Use este parámetro para solicitar todas las sesiones dejugador de la sesión de juego especificada. El formato de ID de la sesión de juego es el siguiente:arn:aws:gamelift:<region>::gamesession/fleet-<fleet ID>/<ID string>. El valor dela <cadena de ID> es una cadena de ID personalizada (si se especificó una cuando se creó la sesiónde juego) o una cadena generada.

Tipo: String

Requerido: NoLímite

Número máximo de resultados a devolver. Use este parámetro con NextToken para obtenerresultados en un conjunto de páginas secuenciales. Si se especifica un ID de sesión de jugador, esteparámetro se ignora.


Requerido: NoNextToken

Token que indica el inicio de la siguiente página de resultados secuencial. Utilice el token devuelto conuna llamada anterior a esta acción. Para especificar el inicio del conjunto de resultados, no indiqueningún valor. Si se especifica un ID de sesión de jugador, este parámetro se ignora.

Tipo: String

Requerido: NoPlayerId

Identificador único de un jugador. Los ID de jugador los define el desarrollador. Consulte Generaciónde ID de jugador (p. 39).

Tipo: String

Requerido: NoPlayerSessionId

Identificador único de una sesión de jugador.

Tipo: String

Requerido: No

Version179


PlayerSessionStatusFilter

Estado de la sesión de juego para filtrar los resultados. Los posibles estados de sesión de jugadorson:• RESERVED: se ha recibido la solicitud de sesión de jugador, pero el jugador aún no se ha

conectado al proceso del servidor o aún no se ha validado.• ACTIVE: el proceso del servidor ha validado el jugador y actualmente está conectado.• COMPLETED: ha caído la conexión del jugador.• TIMEDOUT: se ha recibido una solicitud de sesión de jugador, pero el jugador no se ha conectado

y/o no se ha validado en el plazo de tiempo de espera (60 segundos).

Tipo: String

Requerido: No

ProcessParametersEste tipo de datos contiene un conjunto de parámetros enviado al servicio Amazon GameLift en unallamada ProcessReady() (p. 173).

Contenido

puerto

Es el número de puerto al que escucha el proceso del servidor para conexiones de jugador nuevas.El valor debe estar en el rango de puertos configurado para cualquier flota que implemente esacompilación de servidor de juegos. Este número de puerto se incluye en los objetos de sesión dejuego y de jugador, que las sesiones de juego utilizan a la hora de conectarse a un proceso delservidor.




Escriba: Aws::GameLift::Server::LogParameters (p. 178)

Requerido: síonStartGameSession

Nombre de la función de devolución de llamada que el servicio Amazon GameLift llama para activaruna sesión de juego nueva. Amazon GameLift llama a esta función en respuesta a la solicitud decliente CreateGameSession. La función de devolución de llamada toma un objeto GameSession(definido en la Referencia de la API del servicio Amazon GameLift).

Escriba: void OnStartGameSessionDelegate(GameSession gameSession)


Nombre de la función de devolución de llamada que el servicio Amazon GameLift llama paraforzar el cierre del proceso del servidor. Después de llamar a esta función, Amazon GameLiftespera cinco minutos hasta que el proceso del servidor se cierre y responde con una llamadaProcessEnding() (p. 172) antes de apagar el proceso del servidor.

Escriba: void OnProcessTerminateDelegate()

Version180




Requerido: síonHealthCheck


Escriba: bool OnHealthCheckDelegate()

Requerido: síonHealthCheck


Escriba: void OnUpdateGameSessionDelegate ( UpdateGameSessionupdateGameSession )

Requerido: No

StartMatchBackfillRequestEste tipo de datos se utiliza para enviar una solicitud de reposición de emparejamiento. La información secomunica al servicio Amazon GameLift en una llamada StartMatchBackfill() (p. 175).

Contenido

GameSessionArn

Identificador único de la sesión de juego. La acción de la API GetGameSessionId() (p. 171) devuelveel identificador en formato de ARN.

Tipo: String


Identificador único, en forma de un ARN, que el creador de emparejamientos utiliza para esta solicitud.Para encontrar el creador de emparejamientos que se usó para crear la sesión de juego original,busque en el objeto de sesión de juego, en la propiedad de datos del creador de emparejamientos.Para obtener más información sobre los datos del creador de emparejamientos consulte Trabajo condatos del creador de emparejamientos (p. 122).

Tipo: String

Requerido: síPlayers

Un conjunto de datos que representa a todos los jugadores que están actualmente en la sesiónde juego. El creador de emparejamientos utiliza esta información para buscar nuevos jugadoresque son idóneos para los jugadores actuales. Para obtener una descripción del formato del objetoPlayer, consulte Guía de referencia de la API de Amazon GameLift. Para encontrar los atributos, ID yasignaciones de equipo del jugador, busque en el objeto de sesión de juego, en la propiedad de datosdel creador de emparejamientos. Si el creador de emparejamientos utiliza latencia, recopile la latenciaactualizada para la región actual e inclúyala en los datos de cada jugador.

Version181

Amazon GameLift Developer GuideReferencia de la API del servidor (Unreal Engine)

Tipo: Jugador[ ]


Identificador único para un ticket de solicitud de emparejamiento o reposición de emparejamiento. Sino se proporciona ningún valor aquí, Amazon GameLift generará uno en forma de UUID. Use esteidentificador para realizar un seguimiento del estado del ticket de reposición de emparejamiento ocancelar la solicitud si es necesario.

Tipo: String

Requerido: No

StopMatchBackfillRequestEste tipo de datos se utiliza para cancelar una solicitud de reposición de emparejamiento. La informaciónse comunica al servicio Amazon GameLift en una llamada StopMatchBackfill() (p. 176).

Contenido

GameSessionArn

Identificador único de sesión de juego asociado a la solicitud que se va a cancelar.

Tipo: String


Identificador único del creador de emparejamientos al que se envió esta solicitud.

Tipo: String


Identificador único del ticket de solicitud de reposición que se va a cancelar.

Tipo: String

Requerido: sí

Referencia de la API del servidor de AmazonGameLift para Unreal Engine

Esta referencia de la API del servidor de Amazon GameLift puede ayudarle a preparar los proyectos dejuego de Unreal Engine para utilizarlos con Amazon GameLift. Para obtener más información sobre elproceso de integración, consulte Adición de Amazon GameLift al servidor de juegos (p. 31).

Esta API se define en GameLiftServerSDK.h y GameLiftServerSDKModels.h.

Para configurar el complemento Unreal Engine y ver ejemplos de código, consulte Adición de AmazonGameLift a un proyecto del servidor de juegos Unreal Engine (p. 25).

Version182




Referencia de la API del servidor de Amazon GameLiftpara Unreal Engine: accionesEsta referencia de la API del servidor de Amazon GameLift puede ayudarle a preparar los proyectos dejuego de Unreal Engine para utilizarlos con Amazon GameLift. Para obtener más información sobre elproceso de integración, consulte Adición de Amazon GameLift al servidor de juegos (p. 31).




AcceptPlayerSession()Notifica al servicio Amazon GameLift que un jugador con el ID de sesión de jugador especificado se haconectado al proceso del servidor y requiere validación. Amazon GameLift verifica que el ID de sesióndel jugador es válido, es decir, que el ID de jugador ha reservado una ranura de jugador en la sesión dejuego. Una vez completada la validación, Amazon GameLift cambia el estado de la ranura de jugador deRESERVED a ACTIVE.

Sintaxis

FGameLiftGenericOutcome AcceptPlayerSession(const FString& playerSessionId)

Parámetros

playerSessionId


Tipo: FString

Requerido: sí


ActivateGameSession()Notifica al servicio Amazon GameLift que el proceso del servidor ha activado una sesión de juego y queestá listo para recibir las conexiones de los jugadores. Esta acción debe llamarse como parte de la funciónde devolución de llamada onStartGameSession(), después de completar la inicialización de todas lassesiones de juego.

Version183



Sintaxis

FGameLiftGenericOutcome ActivateGameSession()

Parámetros


Valor devuelto


GetGameSessionId()Recupera el ID de la sesión de juego alojada actualmente por el proceso del servidor, siempre que estéactivo.

Sintaxis

FGameLiftStringOutcome GetGameSessionId()

Parámetros


Valor devuelto

Si funciona correctamente, devuelve el ID de sesión del juego como objeto FGameLiftStringOutcome.Si no funciona, devuelve un mensaje de error.

GetSdkVersion()Devuelve el número de versión actual del SDK integrado en el proceso del servidor.

Sintaxis

FGameLiftStringOutcome GetSdkVersion();

Parámetros


Valor devuelto

Si funciona correctamente, devuelve la versión del SDK actual como objeto FGameLiftStringOutcome.La cadena devuelta solo incluye el número de versión (por ejemplo, "3.1.5"). Si no funciona, devuelve unmensaje de error.

Ejemplo

Aws::GameLift::AwsStringOutcome SdkVersionOutcome = Aws::GameLift::Server::GetSdkVersion();

Version184



Sintaxis

FGameLiftGenericOutcome InitSDK()

Parámetros


Valor devuelto


ProcessEnding()Notifica al servicio Amazon GameLift que el proceso del servidor se va a apagar. Este método debellamarse después de realizar las demás tareas de limpieza, incluido el cierre de todas las sesiones dejuego activas. Se debe salir de este método con un código de salida de 0; un código de salida que no sea 0provoca un mensaje de evento que afirma que no se ha salido del proceso correctamente.

Sintaxis

FGameLiftGenericOutcome ProcessEnding()

Parámetros


Valor devuelto



Sintaxis

FGameLiftGenericOutcome ProcessReady(FProcessParameters &processParameters)

Parámetros

FProcessParameters

Es un objeto FProcessParameters (p. 188) que comunica la siguiente información acerca delproceso del servidor:

Version185


• Nombres de métodos de devolución de llamada, implementados en el código de servidor de juegos,que el servicio Amazon GameLift invoca para comunicarse con el proceso del servidor.

• Número de puerto de escucha del servidor de proceso.• Ruta a cualquier archivo específico de la sesión de juego que desea que Amazon GameLift capture

y almacene.

Requerido: sí

Valor devuelto


Ejemplo

Consulte el código de ejemplo en Using the Unreal Engine Plugin (p. 27).


Sintaxis

FGameLiftGenericOutcome RemovePlayerSession(const FString& playerSessionId)

Parámetros

playerSessionId


Tipo: FString

Requerido: sí

Valor devuelto


TerminateGameSession()Notifica al servicio Amazon GameLift que el proceso del servidor ha cerrado la sesión de juego.(Actualmente, cada proceso del servidor aloja únicamente una sesión de juego a la vez, por lo queno es necesario especificar qué sesión.) Esta acción debe llamarse al final del proceso de cierrede la sesión de juego. Después de llamar a esta acción, el proceso del servidor puede llamar aProcessReady() (p. 185) para indicar su disponibilidad para alojar una sesión nueva de juego. Tambiénpuede llamar a ProcessEnding() (p. 185) para cerrar el proceso del servidor y terminar la instancia.

Version186



Sintaxis

FGameLiftGenericOutcome TerminateGameSession()

Parámetros


Valor devuelto


UpdatePlayerSessionCreationPolicy()Actualiza la capacidad de la sesión de juego actual para aceptar sesiones de jugador nuevas. Una sesiónde juego se puede configurar para que acepte o deniegue todas las sesiones nuevas de los jugadores.(Consulte también la acción UpdateGameSession() en la Referencia de la API del servicio AmazonGameLift).

Sintaxis

FGameLiftGenericOutcome UpdatePlayerSessionCreationPolicy(EPlayerSessionCreationPolicy policy)

Parámetros

Auto Scaling

Valor que indica si la sesión de juego acepta jugadores nuevos.

Tipo: EPlayerSessionCreationPolicy enum. Los valores válidos son:• ACCEPT_ALL: se aceptan todas las sesiones de jugador nuevas.• DENY_ALL: se rechazan todas las sesiones de jugador nuevas.

Requerido: sí

Valor devuelto


Referencia de la API del servidor de Amazon GameLiftpara Unreal Engine: tipos de datosEsta referencia de la API del servidor de Amazon GameLift puede ayudarle a preparar los proyectos dejuego de Unreal Engine para utilizarlos con Amazon GameLift. Para obtener más información sobre elproceso de integración, consulte Adición de Amazon GameLift al servidor de juegos (p. 31).



Version187




FProcessParametersEste tipo de datos contiene un conjunto de parámetros enviado al servicio Amazon GameLift en unallamada ProcessReady() (p. 185).

Contenido

puerto

Es el número de puerto al que escucha el proceso del servidor para conexiones de jugador nuevas.El valor debe estar en el rango de puertos configurado para cualquier flota que implemente esacompilación de servidor de juegos. Este número de puerto se incluye en los objetos de sesión dejuego y de jugador, que las sesiones de juego utilizan a la hora de conectarse a un proceso delservidor.




Tipo: TArray<FString>

Requerido: NoonStartGameSession

Nombre de la función de devolución de llamada que el servicio Amazon GameLift llama para activaruna sesión de juego nueva. Amazon GameLift llama a esta función en respuesta a la solicitud decliente CreateGameSession. La función de devolución de llamada toma un objeto GameSession(definido en la Referencia de la API del servicio Amazon GameLift).

Tipo: FOnStartGameSession


Nombre de la función de devolución de llamada que el servicio Amazon GameLift llama paraforzar el cierre del proceso del servidor. Después de llamar a esta función, Amazon GameLiftespera cinco minutos hasta que el proceso del servidor se cierre y responde con una llamadaProcessEnding() (p. 185) antes de apagar el proceso del servidor.

Tipo: FSimpleDelegate

Requerido: NoonHealthCheck


Tipo: FOnHealthCheck

Requerido: No

Version188



Amazon GameLift Developer GuideReglas de FlexMatch

Referencia de reglas de FlexMatchUtilice las siguientes expresiones de propiedad cuando escriba las reglas de los conjuntos de reglas deFlexMatch.

Más información sobre la creación de reglas de FlexMatch:

• Creación de un conjunto de reglas de FlexMatch (p. 102)• Crear un conjunto de reglas de emparejamiento (p. 104)• Ejemplos de conjuntos de reglas de FlexMatch (p. 105)

Tipos de reglaSe permiten los siguientes tipos de regla. Cada tipo de regla requiere un conjunto de propiedades, tal ycomo se define aquí.

Regla de distancia (distance)

Las reglas de distancia miden la diferencia entre dos valores numéricos, como, por ejemplo, la distanciaentre dos niveles de habilidad. Por ejemplo, una regla de distancia podría requerir que todos los jugadoresestén situados a dos niveles de distancia entre sí como máximo.

• measurement: valor de atributo del jugador para medir la distancia; debe ser un valor numérico.• referenceValue: valor numérico con el que se mide la distancia para un posible emparejamiento.• minDistance/maxDistance: valor máximo o mínimo de distancia permitido para un emparejamiento

correcto.• partyAggregation: cómo atender solicitudes de varios jugadores (grupo). Las opciones válidas deben

utilizar los valores mínimo (min), máximo (max) o promedio (avg) para los jugadores de una solicitud. Elvalor predeterminado es avg.

Regla de comparación (comparison)

Las reglas de comparación comparan el de valor de un atributo de un jugador con otro valor. Existendos tipos de reglas de comparación. El primer tipo compara el valor de un atributo con un valor dereferencia. Se debe especificar el valor de referencia y cualquier operación de comparación válida. Porejemplo, la regla podría exigir que los jugadores emparejados tengan un nivel de habilidad mayor oigual a 24. El segundo tipo compara el valor de un atributo para todos los jugadores de un equipo o unemparejamiento. Este tipo omite el valor de referencia y especifica si debe ser igual o no (la totalidad oninguno de los jugadores tienen el mismo valor para el atributo). Por ejemplo, la regla podría exigir quetodos los jugadores elijan el mismo mapa de juego.

• measurement: valor del atributo del jugador que se va a comparar.• referenceValue: valor para evaluar la medición frente a un posible emparejamiento.• operation: cómo evaluar la medición. Entre las operaciones válidas se incluyen: <, <=, =, !=, >,>=.

• partyAggregation: cómo ordenar solicitudes de múltiples jugadores (grupo). Las opciones válidasdeben utilizar los valores mínimo (min), máximo (max) o promedio (avg) para los jugadores de unasolicitud. El valor predeterminado es avg.

Regla de colección (collection)

Las reglas de colección evalúan colecciones de valores de atributos de los jugadores. Una colecciónpuede contener valores de atributos de varios jugadores, un atributo de un jugador que es una colección

Version189

Amazon GameLift Developer GuideTipos de regla

(una lista de cadenas), o ambos. Por ejemplo, una regla de colección podría examinar la colecciónde personajes elegidos por los jugadores de un equipo y exigir que contenga al menos un personajedeterminado.

• measurement: la colección de valores de atributos de los jugadores que se va a evaluar. Los valores delos atributos deben se listas de cadenas.

• referenceValue: valor o colección de valores con los que se va a evaluar la medición para realizar unposible emparejamiento.

• operation: cómo evaluar una colección de mediciones. Entre las operaciones válidas se incluyen:• intersection mide el número de valores comunes en las colecciones de todos los jugadores.

Consulte la regla MapOverlap en el Ejemplo 4: Utilizar la ordenación explícita para encontrar losmejores emparejamientos (p. 111).

• contains mide el número de colecciones de atributos de los jugadores que contienen undeterminado valor de referencia. Consulte la regla OverallMedicLimit en el Ejemplo 3: Establecerrequisitos de equipo y límites de latencia (p. 109).

• reference_intersection_count mide la intersección entre la colección de atributos de unjugador y una colección de valores de referencia. Cada colección de atributos del jugador (listade cadenas) de la medición se evalúa con respecto a la colección de referencia por separado.Esta operación se puede utilizar para evaluar distintos atributos de los jugadores. Consulte laregla OpponentMatch en el Ejemplo 5: Buscar las intersecciones entre varios atributos de losjugadores (p. 113).

• minCount/maxCount: valor máximo o mínimo de cantidad permitido para un emparejamiento correcto.• partyAggregation: cómo ordenar solicitudes de múltiples jugadores (grupo). Las opciones válidas

deben utilizar union o intersection de valores para los jugadores de una solicitud. El valorpredeterminado es union.

Regla de latencia (latency)

Las reglas de latencia evalúan los ajustes de latencia de los jugadores para conseguir emparejamientosaceptables. Por ejemplo, una regla podría requerir que todos los jugadores emparejados deben tener unalatencia regional por debajo de un límite máximo.

• maxLatency: el valor máximo de latencia aceptable para una región. Para cada jugador, ignore todaslas regiones que superan esta latencia.

• maxDistance: diferencia máxima entre la latencia de cada jugador y el valor de referencia de distancia.• distanceReference: valor numérico con el que se mide la distancia para un emparejamiento correcto.

Para la latencia, este valor es la suma de los valores de latencia de varios jugadores. Las opcionesválidas son los valores mínimo (min) o medio (avg) de latencia de los jugadores. (Consulte la secciónExpresiones de propiedades).


Regla de ordenación por distancia (distanceSort)

La ordenación por distancia es una opción de ordenación explícita que indica al creador deemparejamientos que ordene previamente las solicitudes de emparejamiento en función de un atributo delos jugadores. Una regla de ordenación por distancia evalúa las solicitudes de emparejamiento según ladistancia de la solicitud de referencia.

• sortDirection: dirección para ordenar solicitudes de emparejamiento. Las opciones válidas sonascending o descending.

• sortAttribute: atributo del jugador para la ordenación de los jugadores.

Version190

Amazon GameLift Developer GuideExpresiones de propiedades

• mapKey: cómo evaluar el atributo del jugador si se trata de una asignación. Entre las opciones válidas seincluyen:• minValue: para el jugador de referencia, encuentre la clave con el valor más bajo.• maxValue: para el jugador de referencia, encuentre la clave con el valor más alto.


Regla de ordenación absoluta (absoluteSort)

La ordenación absoluta es una opción de ordenación explícita que indica al creador de emparejamientosque ordene previamente las solicitudes de emparejamiento en función de un atributo de los jugadores.Una ordenación absoluta evalúa las solicitudes de emparejamiento en función de si el atributo del jugadorcoincide con la solicitud de referencia.

• sortDirection: dirección para ordenar solicitudes de emparejamiento. Las opciones válidas sonascending o descending.

• sortAttribute: atributo del jugador para la ordenación de los jugadores.• mapKey: cómo evaluar el atributo del jugador si se trata de una asignación. Entre las opciones válidas se

incluyen:• minValue: para el jugador de referencia, encuentre la clave con el valor más bajo.• maxValue: para el jugador de referencia, encuentre la clave con el valor más alto.


Expresiones de propiedadesLas expresiones de propiedades se utilizan en un conjunto de reglas para referirse a determinadaspropiedades relacionadas con el emparejamiento. Las propiedades pueden incluir los valores de losatributos del jugador de las solicitudes de emparejamiento. Por ejemplo, una regla podría utilizar unaexpresión de propiedad para identificar el atributo del jugador que se debe evaluar.

Suelen adoptar una de las dos formas siguientes:

• Datos de los jugadores individuales• Datos calculados del equipo, que adoptan la forma de colecciones de datos de jugadores individuales.

Una expresión de propiedad válida identifica un valor específico para un solo jugador, equipo oemparejamiento. Las siguientes expresiones parciales ilustran cómo identificar equipos y jugadores:

Para identificar unequipo específico en unemparejamiento:

teams[red] El equipo rojo Equipo

Para identificar todoslos equipos en unemparejamiento:

teams[*] Todos los equipos List<Team>

Para identificarjugadores en un equipoespecífico:

team[red].players Jugadores en el equiporojo

List<Player>

Version191

Amazon GameLift Developer GuideExpresiones de propiedades

Para identificarjugadores en unemparejamiento:

team[*].players Jugadores en elemparejamiento,agrupados por equipo

List<List<Player>>

La tabla siguiente ilustra algunas expresiones de propiedades válidas que se basan en los ejemplosanteriores:

Expresión Significado Tipo resultante

teams[red].players[playerid] ID de todos los jugadores delequipo rojo

List<string>

teams[red].players.attributes[skill] Los atributos de "habilidad" detodos los jugadores del equiporojo

List<number>

teams[*].players.attributes[skill] Los atributos de "habilidad"de todos los jugadores delemparejamiento, agrupados porequipo

List<List<number>>

Pueden utilizarse expresiones de propiedades para agregar datos del equipo utilizando las siguientesfunciones o combinaciones de funciones:

Agregación Entrada Significado Salida

min List<number> Obtenga el mínimo detodos los números en lalista.

número

max List<number> Obtenga el máximo detodos los números en lalista.

número

avg List<number> Obtenga el promedio detodos los números en lalista.

número

median List<number> Obtenga la mediana detodos los números en lalista.

número

sum List<number> Obtenga la suma detodos los números en lalista.

número

count List<?> Obtenga el número deelementos en la lista.

número

stddev List<number> Obtenga la desviaciónestándar de todos losnúmeros en la lista.

número

flatten List<List<?>> Convierta una colecciónde listas anidadasen una sola lista que

List<?>

Version192

Amazon GameLift Developer GuideEventos de FlexMatch

Agregación Entrada Significado Salidacontenga todos loselementos.

set_intersection List<List<string>> Obtenga una listade cadenas que seencuentran en todaslas listas de cadenas deuna colección.

List<string>

All above List<List<?>> Todas las operacionesde una lista anidadaactúan en cada listasecundaria de maneraindividual para generaruna lista de resultados.

List<?>

La tabla siguiente ilustra algunas expresiones de propiedades válidas que utilizan funciones de agregación:

Expresión Significado Tipo resultante

flatten(teams[*].players.attributes[skill])Los atributos de "habilidad"de todos los jugadores delemparejamiento (no agrupados)

List<number>

avg(teams[red].players.attributes[skill])Las habilidades promedio detodos los jugadores del equiporojo

número

avg(teams[*].players.attributes[skill] La habilidad promedio de cadaequipo en el emparejamiento

List<number>

avg(flatten(teams[*].players.attributes[skill]))El nivel de habilidad promediode todos los jugadores en elemparejamiento. Esta expresiónobtiene una lista aplanada delas habilidades del jugador y, acontinuación, hace un promedio.

número

count(teams[red].players) El número de jugadores delequipo rojo

número

count (teams[*].players) El número de jugadores de cadaequipo en el emparejamiento

List<number>

max(avg(teams[*].players.attributes[skill]))El nivel de habilidad más alto delequipo en el emparejamiento

número

Referencia de eventos de FlexMatchAmazon GameLift emite eventos relacionados con el procesamiento de tickets de emparejamiento. Todoslos eventos que se indican aquí se pueden publicar en un tema de Amazon SNS. Estos eventos tambiénse emiten a Amazon CloudWatch Events. Para obtener más detalles sobre cómo trabajar con eventosde emparejamiento, consulte Configuración de la notificación de eventos en FlexMatch (p. 115). Para

Version193


obtener más información sobre estados de tickets de emparejamiento, consulte MatchmakingTicket en laReferencia de la API del servicio Amazon GameLift.

Nombre delevento

Descripción Recurso Detalle Ejemplo

MatchmakingSearchingSe hainsertado elticket en elemparejamiento.Esto incluyenuevassolicitudesy solicitudesqueformaronparte de unemparejamientopropuestoque generóerror.

ConfigurationArntype, tickets,estimatedWaitMillis,gameSessionInfo

{ "version": "0", "id": "cc3d3ebe-1d90-48f8-b268-c96655b8f013", "detail-type": "GameLift Matchmaking Event", "source": "aws.gamelift", "account": "123456789012", "time": "2017-08-08T21:15:36.421Z", "region": "us-west-2", "resources": [ "arn:aws:gamelift:us-west-2:123456789012:matchmakingconfiguration/SampleConfiguration" ], "detail": { "tickets": [ { "ticketId": "ticket-1", "startTime": "2017-08-08T21:15:35.676Z", "players": [ { "playerId": "player-1" } ] } ], "estimatedWaitMillis": "NOT_AVAILABLE", "type": "MatchmakingSearching", "gameSessionInfo": { "players": [ { "playerId": "player-1" } ] } }}

PotentialMatchCreatedSe hacreado unposibleemparejamiento.Esteevento seemite paratodos losemparejamientosnuevosposibles,independientementede que sea

ConfigurationArntype, tickets,acceptanceTimeout,acceptanceRequired,ruleEvaluationMetrics,gameSessionInfo,matchId

{ "version": "0", "id": "fce8633f-aea3-45bc-aeba-99d639cad2d4", "detail-type": "GameLift Matchmaking Event", "source": "aws.gamelift", "account": "123456789012", "time": "2017-08-08T21:17:41.178Z", "region": "us-west-2", "resources": [ "arn:aws:gamelift:us-west-2:123456789012:matchmakingconfiguration/SampleConfiguration" ],

Version194



Nombre delevento


necesaria laaceptación.

"detail": { "tickets": [ { "ticketId": "ticket-1", "startTime": "2017-08-08T21:15:35.676Z", "players": [ { "playerId": "player-1", "team": "red" } ] }, { "ticketId": "ticket-2", "startTime": "2017-08-08T21:17:40.657Z", "players": [ { "playerId": "player-2", "team": "blue" } ] } ], "acceptanceTimeout": 600, "ruleEvaluationMetrics": [ { "ruleName": "EvenSkill", "passedCount": 3, "failedCount": 0 }, { "ruleName": "EvenTeams", "passedCount": 3, "failedCount": 0 }, { "ruleName": "FastConnection", "passedCount": 3, "failedCount": 0 }, { "ruleName": "NoobSegregation", "passedCount": 3, "failedCount": 0 } ], "acceptanceRequired": true, "type": "PotentialMatchCreated", "gameSessionInfo": { "players": [ { "playerId": "player-1", "team": "red" }, { "playerId": "player-2", "team": "blue" } ]

Version195


Nombre delevento


}, "matchId": "3faf26ac-f06e-43e5-8d86-08feff26f692" }}

Version196


Nombre delevento


AcceptMatch Losjugadoreshanaceptadoun posibleemparejamiento.Este eventocontiene elestado deaceptaciónactualde cadajugador en elemparejamiento.La faltade datossignifica queno se hallamado aAcceptMatchpara esejugador.

ConfigurationArntype, tickets,matchId,gameSessionInfo

{ "version": "0", "id": "b3f76d66-c8e5-416a-aa4c-aa1278153edc", "detail-type": "GameLift Matchmaking Event", "source": "aws.gamelift", "account": "123456789012", "time": "2017-08-09T20:04:42.660Z", "region": "us-west-2", "resources": [ "arn:aws:gamelift:us-west-2:123456789012:matchmakingconfiguration/SampleConfiguration" ], "detail": { "tickets": [ { "ticketId": "ticket-1", "startTime": "2017-08-09T20:01:35.305Z", "players": [ { "playerId": "player-1", "team": "red" } ] }, { "ticketId": "ticket-2", "startTime": "2017-08-09T20:04:16.637Z", "players": [ { "playerId": "player-2", "team": "blue", "accepted": false } ] } ], "type": "AcceptMatch", "gameSessionInfo": { "players": [ { "playerId": "player-1", "team": "red" }, { "playerId": "player-2", "team": "blue", "accepted": false } ] }, "matchId": "848b5f1f-0460-488e-8631-2960934d13e5" }}

Version197


Nombre delevento


AcceptMatchCompletedLaaceptacióndelemparejamientoestácompletadebido a laaceptaciónde losjugadores,el rechazode losjugadoreso elagotamientodeltiempo deaceptación.

ConfigurationArntype, tickets,acceptance,matchId,gameSessionInfo

{ "version": "0", "id": "b1990d3d-f737-4d6c-b150-af5ace8c35d3", "detail-type": "GameLift Matchmaking Event", "source": "aws.gamelift", "account": "123456789012", "time": "2017-08-08T20:43:14.621Z", "region": "us-west-2", "resources": [ "arn:aws:gamelift:us-west-2:123456789012:matchmakingconfiguration/SampleConfiguration" ], "detail": { "tickets": [ { "ticketId": "ticket-1", "startTime": "2017-08-08T20:30:40.972Z", "players": [ { "playerId": "player-1", "team": "red" } ] }, { "ticketId": "ticket-2", "startTime": "2017-08-08T20:33:14.111Z", "players": [ { "playerId": "player-2", "team": "blue" } ] } ], "acceptance": "TimedOut", "type": "AcceptMatchCompleted", "gameSessionInfo": { "players": [ { "playerId": "player-1", "team": "red" }, { "playerId": "player-2", "team": "blue" } ] }, "matchId": "a0d9bd24-4695-4f12-876f-ea6386dd6dce" }}

Version198


Nombre delevento


MatchmakingSucceededSe hacompletadocorrectamenteelemparejamientoy se hacreado unasesión dejuego.

ConfigurationArntype, tickets,matchId,gameSessionInfo

{ "version": "0", "id": "5ccb6523-0566-412d-b63c-1569e00d023d", "detail-type": "GameLift Matchmaking Event", "source": "aws.gamelift", "account": "123456789012", "time": "2017-08-09T19:59:09.159Z", "region": "us-west-2", "resources": [ "arn:aws:gamelift:us-west-2:123456789012:matchmakingconfiguration/SampleConfiguration" ], "detail": { "tickets": [ { "ticketId": "ticket-1", "startTime": "2017-08-09T19:58:59.277Z", "players": [ { "playerId": "player-1", "playerSessionId": "psess-6e7c13cf-10d6-4756-a53f-db7de782ed67", "team": "red" } ] }, { "ticketId": "ticket-2", "startTime": "2017-08-09T19:59:08.663Z", "players": [ { "playerId": "player-2", "playerSessionId": "psess-786b342f-9c94-44eb-bb9e-c1de46c472ce", "team": "blue" } ] } ], "type": "MatchmakingSucceeded", "gameSessionInfo": { "gameSessionArn": "arn:aws:gamelift:us-west-2:123456789012:gamesession/836cf48d-bcb0-4a2c-bec1-9c456541352a", "ipAddress": "192.168.1.1", "port": 10777, "players": [ { "playerId": "player-1", "playerSessionId": "psess-6e7c13cf-10d6-4756-a53f-db7de782ed67", "team": "red"

Version199


Nombre delevento


}, { "playerId": "player-2", "playerSessionId": "psess-786b342f-9c94-44eb-bb9e-c1de46c472ce", "team": "blue" } ] }, "matchId": "c0ec1a54-7fec-4b55-8583-76d67adb7754" }}

Version200


Nombre delevento


MatchmakingTimedOutError delticket deemparejamientodebido aque se haagotado eltiempo deespera.

ConfigurationArntype, tickets,ruleEvaluationMetrics,message,matchId,gameSessionInfo

{ "version": "0", "id": "fe528a7d-46ad-4bdc-96cb-b094b5f6bf56", "detail-type": "GameLift Matchmaking Event", "source": "aws.gamelift", "account": "123456789012", "time": "2017-08-09T20:11:35.598Z", "region": "us-west-2", "resources": [ "arn:aws:gamelift:us-west-2:123456789012:matchmakingconfiguration/SampleConfiguration" ], "detail": { "reason": "TimedOut", "tickets": [ { "ticketId": "ticket-1", "startTime": "2017-08-09T20:01:35.305Z", "players": [ { "playerId": "player-1", "team": "red" } ] } ], "ruleEvaluationMetrics": [ { "ruleName": "EvenSkill", "passedCount": 3, "failedCount": 0 }, { "ruleName": "EvenTeams", "passedCount": 3, "failedCount": 0 }, { "ruleName": "FastConnection", "passedCount": 3, "failedCount": 0 }, { "ruleName": "NoobSegregation", "passedCount": 3, "failedCount": 0 } ], "type": "MatchmakingTimedOut", "message": "Removed from matchmaking due to timing out.", "gameSessionInfo": { "players": [ { "playerId": "player-1", "team": "red"

Version201


Nombre delevento


} ] } }}

Version202


Nombre delevento


MatchmakingCancelledSe hacanceladoel ticket deemparejamiento.


{ "version": "0", "id": "8d6f84da-5e15-4741-8d5c-5ac99091c27f", "detail-type": "GameLift Matchmaking Event", "source": "aws.gamelift", "account": "123456789012", "time": "2017-08-09T20:00:07.843Z", "region": "us-west-2", "resources": [ "arn:aws:gamelift:us-west-2:123456789012:matchmakingconfiguration/SampleConfiguration" ], "detail": { "reason": "Cancelled", "tickets": [ { "ticketId": "ticket-1", "startTime": "2017-08-09T19:59:26.118Z", "players": [ { "playerId": "player-1" } ] } ], "ruleEvaluationMetrics": [ { "ruleName": "EvenSkill", "passedCount": 0, "failedCount": 0 }, { "ruleName": "EvenTeams", "passedCount": 0, "failedCount": 0 }, { "ruleName": "FastConnection", "passedCount": 0, "failedCount": 0 }, { "ruleName": "NoobSegregation", "passedCount": 0, "failedCount": 0 } ], "type": "MatchmakingCancelled", "message": "Cancelled by request.", "gameSessionInfo": { "players": [ { "playerId": "player-1" } ]

Version203


Nombre delevento


} }}

MatchmakingFailedEl ticket deemparejamientohaencontradoun error.Esto puededebersea que noes posibleacceder ala cola de lasesión dejuego o a unerror interno.


{ "version": "0", "id": "025b55a4-41ac-4cf4-89d1-f2b3c6fd8f9d", "detail-type": "GameLift Matchmaking Event", "source": "aws.gamelift", "account": "123456789012", "time": "2017-08-16T18:41:09.970Z", "region": "us-west-2", "resources": [ "arn:aws:gamelift:us-west-2:123456789012:matchmakingconfiguration/SampleConfiguration" ], "detail": { "tickets": [ { "ticketId": "ticket-1", "startTime": "2017-08-16T18:41:02.631Z", "players": [ { "playerId": "player-1", "team": "red" } ] } ], "customEventData": "foo", "type": "MatchmakingFailed", "reason": "UNEXPECTED_ERROR", "message": "An unexpected error was encountered during match placing.", "gameSessionInfo": { "players": [ { "playerId": "player-1", "team": "red" } ] }, "matchId": "3ea83c13-218b-43a3-936e-135cc570cba7" }}

Version204


Historial de la documentación deAmazon GameLift

En la siguiente tabla se describen cambios importantes en la documentación de Amazon GameLift. Paraobtener más información sobre los lanzamientos de nuevas características y actualizaciones, consulte lasNotas de la versión de Amazon GameLift.

Fecha Cambio Actualizaciones de la documentación Versiones deAPI

14 de juniode 2018

Nuevas características:

• Métricas de colas deFleetIQ: utilice lasmétricas de FleetIQ parahacer un seguimiento deldesempeño de las colas.

Developer Guide:

• Se han añadido cinco nuevas métricasde cola a Métricas de Amazon GameLiftpara colas (p. 143).

• Nuevo tema Evaluación de métricas decola (p. 92) para optimizar el desempeñode la cola.

AWS SDK:2018-05-10

Server SDK3.2.1

GameLiftLocal1.0.0

10 de mayode 2018


• Escalado automático conseguimiento de destino:utilice este nuevo métodode escalado para ajustarla capacidad de la flotaa la demanda de losjugadores.

• Habilitación/deshabilitación delescalado automático:cambie entre el escaladoautomático y el escaladomanual sin necesidad deeliminar las políticas deescalado.

Developer Guide:

• La nueva sección Administración dela capacidad de la flota (p. 67) abarcatodos los temas relacionados con elescalado, entre los que se incluye elescalado automático.

• Sección actualizada sobre Gestión decapacidad y escalado (p. 3) en el tema"Funcionamiento de Amazon GameLift".

Referencia de la API de servicio para elAWS SDK:

• El tema PutScalingPolicy se haactualizado

• Nuevos ejemplos de código para todaslas acciones de la API de políticas deescalado

• Nuevas acciones de la APIStopFleetActions y StartFleetActions

AWS SDK:2018-05-10

Server SDK3.2.1

GameLiftLocal1.0.0

15 defebrero de2018


• Instancias de spot yFleetIQ: utilice la nuevacaracterística FleetIQ conflotas de spot para reducirde forma significativa loscostos de alojamiento.

Developer Guide:

• Guía de integración de flotas despot (p. 77): nueva guía paso a pasopara el uso de las flotas de spot

• Diseño de colas de sesiones dejuego (p. 87): nuevos consejos de diseñopara la creación y el uso de colas,incluidas las flotas de spot

• Temas actualizados:

AWS SDK:2018-02-15

Server SDK3.2.1

GameLiftLocal1.0.0

Version205

https://aws.amazon.com/releasenotes/Amazon-GameLift/

https://docs.aws.amazon.com/gamelift/latest/apireference/API_PutScalingPolicy.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_StopFleetActions.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_StartFleetActions.html



Elección de los recursosinformáticos (p. 56)

Creación de una flota (p. 60)

Parada de un proceso del servidor (p. 34)


Temas actualizados:

• CreateFleet• FleetAttributes• Evento

Server SDK:

• GetTerminationTime (C++) (p. 156)

GetTerminationTime (C#) (p. 171)

Version206

https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreateFleet.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_FleetAttributes.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_Event.html



8 de febrerode 2018


• Reposición de FlexMatch:utilice FlexMatch parainyectar nuevos jugadoresen sesiones de juegoemparejadas que esténen curso.

• Búsqueda de sesiones dejuego: utilice propiedadesdel juego personalizadas

Developer Guide:

• Funcionamiento deAmazon GameLiftFlexMatch (p. 11): se ha actualizadola información general sobre lacaracterística FlexMatch

• Reposición de juegos existentes conFlexMatch (p. 123): nueva guía deprocedimientos

• Obtención de sesiones de juego (p. 36):se ha actualizado para las propiedadesdel juego personalizadas


• StartMatchBackfill• SearchGameSessions• GameSession

Server SDK:

• StartMatchBackfill (C++) (p. 160)

StartMatchBackfill (C#) (p. 175)

StopMatchBackfill (C++) (p. 161)

StopMatchBackfill (C#) (p. 176)

AWS SDK:2018-02-08

Server SDK3.2.0

GameLiftLocal1.0.0

Version207

https://docs.aws.amazon.com/gamelift/latest/apireference/API_StartMatchBackfill.html





1 deseptiembrede 2017


Interconexión de VPCpara las flotas de AmazonGameLift: ahora puede usarla interconexión de VPCpara configurar conexionesprivadas directas entre susservidores de juego deAmazon GameLift y otrosrecursos de AWS.

Developer Guide:

• Conectividad de red con los recursos deAWS (p. 6): obtenga más informaciónsobre la interconexión de VPC y cómofunciona con Amazon GameLift.

• Configuración de la interconexión deVPC (p. 81): obtenga más informaciónsobre cómo configurar la interconexiónde VPC.

Referencia de la API del servicio:

• Nuevas API para la interconexión deVPC:• CreateVpcPeeringAuthorization• DescribeVpcPeeringAuthorizations• DeleteVpcPeeringAuthorization• CreateVpcPeeringConnection• DescribeVpcPeeringConnections• DeleteVpcPeeringConnection

• Otras actualizaciones de API:• MatchmakingTicket tiene dos

nuevas propiedades: EndTime yEstimatedWaitTime.

• La documentación deDescribeMatchmaking se ha corregido.Esta operación puede utilizarse pararecuperar un máximo de 10 tickets deemparejamiento.

AWSSDK: 1 deseptiembrede 2017

Server SDK3.1.7

GameLiftLocal1.0.0

16 de agostode 2017


Amazon GameLiftFlexMatch: agregue elemparejamiento a losjuegos con este serviciode emparejamientopersonalizable. ConFlexMatch, puede diseñarun conjunto de reglasbasado en los formatosde los equipos y lascaracterísticas de losjugadores que mejor seadapten al juego.

Developer Guide:

• Amazon GameLift FlexMatch (p. 10):obtenga más información sobre lascaracterísticas clave de FlexMatch y sufuncionamiento.

• Emparejamientos con FlexMatch (p. 98):aprenda a configurar FlexMatch y apersonalizarlo en función del juego.


• API de servidor de Amazon GameLift:nuevas API para administrar los recursosde FlexMatch e iniciar nuevos juegos conemparejamiento.

AWS SDK:2017-08-16

Server SDK3.1.7

GameLiftLocal1.0.0

Version208


https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeVpcPeeringAuthorizations.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DeleteVpcPeeringAuthorization.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreateVpcPeeringConnection.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeVpcPeeringConnections.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DeleteVpcPeeringConnection.html






16 de mayode 2017


• Ahora, AmazonCloudWatch admite lasmétricas de AmazonGameLift, que incluyen laposibilidad de trabajar conmétricas agregadas paraun grupo de flotas.

• Limitar las activacionesde sesiones de juego eninstancias de una flota.

Actualizaciones:

• Benefíciese de lasmétricas adicionales parael escalado automático.

• Uso de una nueva interfazde usuario de la consolapara definir el escaladode la flota.

Developer Guide:

• Monitorización de AmazonGameLift (p. 138): nueva sección demonitorización incluida la lista de lasmétricas disponible en la consola deAmazon GameLift y en Cloudwatch.

• Creación de una flota (consola) (p. 60)y Administración de los registros de laflota (p. 66): instrucciones actualizadassobre cómo crear y actualizar lasconfiguraciones de la flota.

• Escalado automático de la capacidad dela flota (p. 72): instrucciones actualizadassobre la configuración del escaladomanual y automático para una flota.


• Parámetro MetricGroups nuevoañadido para habilitar las métricasagregadas:• CreateFleet• UpdateFleetAttributes• FleetAttributes

• Se han añadido parámetros nuevos paralos límites de activación de sesiones dejuego a RuntimeConfiguration.

AWS SDK:16 de mayode 2017

Server SDK3.1.5

GameLiftLocal1.0.0

Version209




https://docs.aws.amazon.com/gamelift/latest/apireference/API_RuntimeConfiguration.html



11 de abrilde 2017


• Amazon GameLift Local:pruebe la integración deljuego localmente.

• Defina una política decola que limite la latenciapermitida para cadajugador.

Actualizaciones:

• Cambios en la API delservicio Amazon GameLift(parte del SDK de AWS)para mejorar el uso.

Developer Guide:

• Prueba de la integración (p. 44): nuevotema sobre cómo configurar y utilizarAmazon GameLift Local.

• Creación de una cola (p. 92): temaactualizado sobre la creación de colas,con información nueva sobre las políticasde latencia de los jugadores.


• Se utiliza un tipo de datosPlayerLatencyPolicy nuevo conCreateGameSessionQueue yUpdateGameSessionQueue.

• El tipo de datos nuevoPlacedPlayerSession describe unasesión de jugador creada atendiendouna solicitud de ubicación de la sesiónde juego.

• Ahora el tipo de datos revisadoGameSessionPlacement incluye estaspropiedades después de atender unasolicitud de ubicación de sesión dejuego: GameSessionId, IpAddress,Port y PlacedPlayerSessions.

• CreateGameSession dispone de unparámetro nuevo, IdempotencyToken,para sustituir a GameSessionId.

• GameSessionQueue tieneun identificador único nuevo,GameSessionQueueArn, con región eID de sesión de juego.

AWS SDK:11 de abrilde 2017

Server SDK3.1.5

GameLiftLocal1.0.0

Version210

https://docs.aws.amazon.com/gamelift/latest/apireference/API_PlayerLatencyPolicy.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_PlacedPlayerSession.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_GameSessionPlacement.html





21 defebrero de2017


• Compatibilidad conmúltiples motores devideojuegos, incluidosUnreal Engine, Unity y C++ y C # personalizados

• Compatibilidad delenguaje para el SDK deservidor ampliada paraincluir C#

• Creación de sesiones dejuego nuevas mediantelas ubicaciones desesiones de juego y colasentre regiones

• Compatibilidad delos datos de jugadorpersonalizados conentrega directa a servidorde juegos

Developer Guide:

• Arquitectura de juego en AmazonGameLift (p. 6): diagrama dearquitectura.

• Motores de videojuegos y AmazonGameLift (p. 23): ayuda para utilizarAmazon GameLift con varios motoresde videojuegos e instrucciones deconfiguración de complementos paraUnreal Engine y Unity.

• Uso de colas (p. 87): ayuda para lacreación, la gestión y el seguimiento delas métricas de las colas.

AWS SDK:21 de febrerode 2017

Server SDK3.1.5

18 denoviembrede 2016


• Acceso remoto a lasinstancias de flotas deAmazon GameLift

Developer Guide:

• Temas nuevos:• Acceso remoto a instancias de una

flota (p. 79): cómo obtener accesoy conectarse de forma remota ainstancias Amazon GameLift.

• Problemas al crear una flota dedepuración (p. 65): consejos para laresolución de problemas de flotasnuevas que no se activan.


• Para el acceso remoto:• GetInstanceAccess (nueva)• InstanceAccess (nueva)• InstanceCredentials (nueva)

AWS SDK:18 denoviembrede 2016

Server SDKfor C++:3.1.0

Version211

https://docs.aws.amazon.com/gamelift/latest/apireference/API_GetInstanceAccess.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_InstanceAccess.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_InstanceCredentials.html



13 deoctubre de2016


• Protección de la creaciónde recursos

• Acceso a los datos de lainstancia

Actualizaciones ycorrecciones:

• Ayuda adicional paraLinux.

Developer Guide:

• Temas revisados:• Funcionamiento de Amazon

GameLift (p. 2): se ha añadido unadescripción sobre la protección delos recursos y se ha mejorado ladescripción sobre la gestión de lacapacidad.

• Se ha añadido ayuda específica deLinux:

Empaquetado de los archivos decompilación (p. 49): instalar scriptspara Linux.

Carga de archivos de compilación enAmazon GameLift (p. 50): ejemplosnuevos de Linux.

Creación de una flota (consola) (p. 60):ejemplo nuevo de ruta de lanzamientopara Linux.


• CreateFleet y UpdateFleetAttributes:parámetro ResourceCreationLimitPolicynuevo.

• ResourceCreationLimitPolicy (nueva)• CreateGameSession: parámetro

CreatorId nuevo.• DescribeInstances (nueva)

AWS SDK:13 deoctubre de2016


1 deseptiembrede 2016


• Ahora los servidores dejuegos pueden ejecutarseen Linux

Developer Guide:

• Temas nuevos:• Los SDK de Amazon GameLift (p. 15):

tema de referencia que describetodos los SDK de Amazon GameLift,incluidos los lenguajes y sistemasoperativos admitidos.


• Se han añadido parámetros del sistemaoperativo nuevos a:• upload-build (p. 50) (solo CLI)• CreateBuild()• Desarrollo• FleetAttributes

AWSSDK: 1 deseptiembrede 2016


Version212



https://docs.aws.amazon.com/gamelift/latest/apireference/API_ResourceCreationLimitPolicy.html


https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeInstances.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_CreateBuild.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_Build.html




4 de agostode 2016


• Búsqueda de sesiones dejuego

• Comprobaciones deestado personalizadas

Actualizaciones:

• Ampliación del soportepara la asignaciónde capacidad (variosprocesos por instancia deflota)

• Amazon GameLift ServerSDK for C++ ya estádisponible para sudescarga

• Todas las API deintegración del cliente dejuego ya están incluidasen la AWS SDK.

Developer Guide:

• Temas nuevos:• Referencia de la API de servidor (C

++) de Amazon GameLift (p. 152):documentación de referenciacompleta.

• Ejecución de varios procesos enuna flota (p. 57): información técnicageneral acerca de la asignación decapacidad y cómo configurar una flotapara que ejecute varios procesos.

• Herramientas y recursos (p. 14): listacompleta de herramientas y recursos,incluida la compatibilidad de la versióndel SDK.

• Temas revisados:• Cómo se conectan los jugadores a

los juegos (p. 8): tema ampliado conla descripción de las característicasrelacionadas con las sesiones dejuego, incluida la nueva función debúsqueda.

• Adición de Amazon GameLift alservidor de juegos (p. 31): se hanrevisado los pasos de integración parasu uso con la versión 3.0.7 ServerSDK for C++.

• Adición de Amazon GameLift al clientede juego (p. 35): se han revisado lospasos de integración para su uso conla AWS SDK for C++.


• SearchGameSessions() (nueva)

AWS SDK: 4de agosto de2016


Version213




28 de juniode 2016

Actualizaciones:

• Nuevas métricas deestado del proceso delservidor

• Se han revisado losprocesos de asignaciónde la capacidad de laflota y la configuración delanzamiento del servidorde juegos

• Se han revisado lasinstrucciones delempaquetado de lacompilación

Developer Guide:

• Temas revisados:• Empaquetado de los archivos

de compilación (p. 49): ahora ladescripción refleja cómo AmazonGameLift gestiona un archivoinstall.bat en una compilación dejuego.

• Creación de una flota (consola) (p. 60)y Creación de una flota (AWSCLI) (p. 62): ahora las instruccionespara la creación de una flota cubrenla asignación de la capacidad decobertura mediante una configuraciónde tiempo de ejecución.

• Visualización de los detalles dela flota (p. 132) y Visualizaciónde datos de sesiones de juegoy de jugador (p. 135): ahora lasdescripciones de la página de laconsola incluyen las métricas ypestañas de escalado actuales.

• Interacciones de Amazon GameLift yel cliente/servidor de juegos (p. 40):se han corregido las descripcionesy el diagrama (p. 43) para utilizarnombres de funciones de devoluciónde llamada de los ejemplos y paraaclarar que la devolución de la llamadaonProcessTerminate() hacereferencia al cierre de un servidor dejuegos, no de una sesión de juegos.


• Para una nueva asignación decapacidad:• CreateFleet(): se ha añadido la

configuración del tiempo de ejecución.• DescribeRuntimeConfiguration

(nuevo)• UpdateRuntimeConfiguration

(nuevo)• Para el proceso de lanzamiento del

servidor de juegos:• GameSession: se ha añadido el

número de puerto. PlayerSession:se ha añadido el número de puerto.

• Para las métricas de estado:

AWS SDK:28 de juniode 2016

Version214



• FleetUtilization: se ha añadidoun recuento nuevo a los procesos delservidor activos.

10 de marzode 2016


• Escalado automático• Protección de la sesión

de juego• Límites de la capacidad

de la flota

Developer Guide:

• Temas nuevos:• Escalado automático de la capacidad

de la flota (p. 72): cómo configurar yadministrar las políticas de escaladoautomático.

• Establecimiento manual de lacapacidad de la flota (p. 70): cómocambiar el número de instancias deuna flota y definir límites.

• Funcionamiento de AmazonGameLift (p. 2): un resumen técnicosobre cómo Amazon GameLiftadministra la implementación del juegoen recursos virtuales.

• Temas revisados:• Creación de una flota (consola) (p. 60):

se ha revisado para incluir laconfiguración de la protección de lasesión de juego y para el escaladoseguro.

• Otros cambios:• El tutorial de Lumberyard-Amazon

GameLift se ha trasladado alrepositorio GameDev Tutorials.


• Para el escalado automático:• PutScalingPolicy• DescribeScalingPolicies• DeleteScalingPolicy

• Para la protección de la sesión de juego:• DescribeGameSessionDetails• CreateFleet (revisada)• UpdateFleetAttributes (revisada)• DescribeFleetAttributes (revisada)• UpdateGameSession (revisada)

• Para los límites de la capacidad de laflota:• UpdateFleetCapacity (revisada)• DescribeFleetCapacity (revisada)

AWS SDK:10 de marzode 2016

Version215


https://docs.aws.amazon.com/gamelift/latest/apireference/API_PutScalingPolicy.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeScalingPolicies.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DeleteScalingPolicy.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeGameSessionDetails.html



https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeFleetAttributes.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_UpdateGameSession.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_UpdateFleetCapacity.html

https://docs.aws.amazon.com/gamelift/latest/apireference/API_DescribeFleetCapacity.html



9 de febrerode 2016

Lanzamiento del servicio Guía para desarrolladores y referencia dela API para el servicio Amazon GameLiftlanzado en AWS.

AWS SDK: 9de febrero de2016

Version216

Documents

Amazon GameLift - Developer Guide · Configurar Amazon GameLift para que aloje un juego implica trabajar con los siguientes componentes: • Un servidor de juegos es un software del